diff --git a/.gitignore b/.gitignore index c7e3f84..aece050 100644 --- a/.gitignore +++ b/.gitignore @@ -13,9 +13,9 @@ /Debug64 /Release64 /ipch -/bin /obj /.vs -/Machinings -/Materials - +/bin/*.lua +/bin/*.ini +/bin/LuaLibs/*.lua +/bin/Images/*.png diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index d93515f..2024050 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -7,60 +7,25 @@ variables: NET_USERQ: 'steamw\egalware' #Note compilazione LUA: -# lua53 -o 32\$FileName -s $FileName: -o = output, -s = NON include i debug symbols +# lua54 -o bin\$FileName -s $FileName: -o = output, -s = NON include i debug symbols -# helper compilazione LUA a 32 bit -.LuaCompile32: &LuaCompile32 +# helper compilazione LUA a 32 e 64 bit +.LuaCompile: &LuaCompile - | - Set-Alias lua53 C:\Tools\Lua32\luac53 - echo "Copia file *.ini" - $FileList = Get-ChildItem("*.ini") - ForEach ($File in $FileList) { - $FileName = Split-Path $File -leaf - Copy-Item -Path $FileName -Destination 32\$FileName - echo "Copy-Item -Path $FileName -Destination 32\$FileName" - } - echo "Copia file *.lua" + Set-Alias lua54 C:\Tools\Lua32\luac54 $FileList = Get-ChildItem("*.lua") ForEach ($File in $FileList) { $FileName = Split-Path $File -leaf - Copy-Item -Path $FileName -Destination 32\$FileName - echo "Copy-Item -Path $FileName -Destination 32\$FileName" + lua54 -o bin\$FileName $FileName + echo "lua54 -o bin\$FileName $FileName" } $FileList = Get-ChildItem("LuaLibs\*.lua") ForEach ($File in $FileList) { $FileName = Split-Path $File -leaf - lua53 -o 32\LuaLibs\$FileName LuaLibs\$FileName - echo "lua53 -o 32\LuaLibs\$FileName LuaLibs\$FileName" + lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName + echo "lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName" } -# helper compilazione LUA a 64 bit -.LuaCompile64: &LuaCompile64 - - | - Set-Alias lua53 C:\Tools\Lua64\luac53 - echo "Copia file *.ini" - $FileList = Get-ChildItem("*.ini") - ForEach ($File in $FileList) { - $FileName = Split-Path $File -leaf - Copy-Item -Path $FileName -Destination 64\$FileName - echo "Copy-Item -Path $FileName -Destination 64\$FileName" - } - echo "Copia file *.lua" - $FileList = Get-ChildItem("*.lua") - ForEach ($File in $FileList) { - $FileName = Split-Path $File -leaf - Copy-Item -Path $FileName -Destination 64\$FileName - echo "Copy-Item -Path $FileName -Destination 64\$FileName" - } - $FileList = Get-ChildItem("LuaLibs\*.lua") - ForEach ($File in $FileList) { - $FileName = Split-Path $File -leaf - lua53 -o 64\LuaLibs\$FileName LuaLibs\$FileName - echo "lua53 -o 64\LuaLibs\$FileName LuaLibs\$FileName" - } - -# Copy-Item -Path $FileName -Destination 64\$FileName -# echo "Copy-Item -Path $FileName -Destination 64\$FileName" # helper copia SORGENTI verso cartella di rete R:\ dei SORGENTI .CodeReplicaR: &CodeReplicaR - | @@ -71,27 +36,21 @@ variables: net use R: /delete -# helper copia script verso cartella di rete R:\ delle cartelle 32 e 64 +# helper copia script verso cartella di rete R:\ delle cartelle bin .ReplicaR: &ReplicaR - | net use R: /delete net use R: $env:NET_SHARE_R /u:$env:NET_USERQ $ZDRIVE_PASSWD - ROBOCOPY /MIR 32 R:\EgtData\$env:APP_NAME\32 - ROBOCOPY /MIR 64 R:\EgtData\$env:APP_NAME\64 - ROBOCOPY /MIR Images R:\EgtData\$env:APP_NAME\32\Images - ROBOCOPY /MIR Images R:\EgtData\$env:APP_NAME\64\Images + ROBOCOPY /MIR bin R:\EgtData\$env:APP_NAME\bin SLEEP 2 net use R: /delete -# helper copia script verso cartella di rete R:\ delle cartelle 32 e 64 +# helper copia script verso cartella di rete R:\ delle cartelle bin .ReplicaZ: &ReplicaZ - | net use Z: /delete net use Z: $env:NET_SHARE_Z /u:$env:NET_USERQ $ZDRIVE_PASSWD - ROBOCOPY /MIR 32 Z:\EgtData\$env:APP_NAME\32 - ROBOCOPY /MIR 64 Z:\EgtData\$env:APP_NAME\64 - ROBOCOPY /MIR Images Z:\EgtData\$env:APP_NAME\32\Images - ROBOCOPY /MIR Images Z:\EgtData\$env:APP_NAME\64\Images + ROBOCOPY /MIR bin Z:\EgtData\$env:APP_NAME\bin SLEEP 2 net use Z: /delete @@ -106,9 +65,7 @@ LuaCompile:build: tags: - win script: - - *LuaCompile32 - - *LuaCompile64 + - *LuaCompile - *CodeReplicaR - *ReplicaR - *ReplicaZ - diff --git a/32/LuaLibs/.placeholder b/32/LuaLibs/.placeholder deleted file mode 100644 index e69de29..0000000 diff --git a/3dPrinting.ini b/3dPrinting.ini deleted file mode 100644 index 25e9d21..0000000 --- a/3dPrinting.ini +++ /dev/null @@ -1,16 +0,0 @@ -[3dPrinting] -Enable=1 -BaseDir=C:\EgtData\3dPrinting -Button1=PartPositioning.lua,Images\PartPositioning.png,Disponi pezzo sulla tavola macchina -Button2=Slicing.lua,Images\Slicing.png,Calcola lo slicing, i solidi e i percorsi utensile -Button3=MachiningParamCalc.lua,Images\MachiningParamCalc.png,Calcola parametri di lavorazione (Tempo layer, F, S) -Button4=GcodeGenerate.lua,Images\GcodeGenerate.png,Genera codice CN -Button5=ShowManager.lua,Images\ShowManager.png,Gestore visualizzazione -Button6=ViewManager.lua,Images\ViewManager.png,Nascondi Visualizza strato -Button7=SliceAdvancement.lua,Images\SliceAdvancement.png,Mostra avanzamento strato -Button8=SlicePalette.lua,Images\SlicePalette.png,Gestore colori strato -Button9=MachiningParamEdit.lua,Images\MachiningParamEdit.png,Edita i parametri di stampa -Button10=MaterialParamEdit.lua,Images\MaterialParamEdit.png,Edita i parametri del materiale -ParamFile=C:\EgtData\3dPrinting\Machinings\Params.ini -ResultReadProg="C:\Program Files\Microsoft Office\root\Office16\EXCEL.EXE" -MachiningEditProg="C:\Windows\System32\notepad.exe" \ No newline at end of file diff --git a/64/Images/.placeholder b/64/Images/.placeholder deleted file mode 100644 index e69de29..0000000 diff --git a/64/LuaLibs/.placeholder b/64/LuaLibs/.placeholder deleted file mode 100644 index e69de29..0000000 diff --git a/CalcMachParamFromSW.lua b/CalcMachParamFromSW.lua index 400bca9..5d13947 100644 --- a/CalcMachParamFromSW.lua +++ b/CalcMachParamFromSW.lua @@ -1,4 +1,4 @@ --- CalcMachParamFromSW.lua by Egaltech s.r.l. 2022/09/15 +-- CalcMachParamFromSW.lua by Egaltech s.r.l. 2023/01/11 -- Calcolo dei parametri di stampa -- Intestazioni @@ -7,8 +7,7 @@ _ENV = EgtProtectGlobal() EgtEnableDebug( false) -- Imposto direttorio libreria specializzata per Stampa 3d -local sBaseDir = EgtGetSourceDir() -EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') +EgtAddToPackagePath( PRINT.BASEDIR .. '\\LuaLibs\\?.lua') -- Librerie _G.package.loaded.RunMachParamFromSWCalc = nil diff --git a/CalcSolids.lua b/CalcSolids.lua new file mode 100644 index 0000000..5f3fe91 --- /dev/null +++ b/CalcSolids.lua @@ -0,0 +1,17 @@ +-- CalcSolids.lua by Egaltech s.r.l. 2023/01/11 +-- Calcola i solidi a partire dallo slicing + +-- Intestazioni +require( 'EgtBase') +_ENV = EgtProtectGlobal() +EgtEnableDebug( false) + +-- Imposto direttorio libreria specializzata per Stampa 3d +EgtAddToPackagePath( PRINT.BASEDIR .. '\\LuaLibs\\?.lua') + +-- Librerie +_G.package.loaded.RunCalcSolids = nil +local RCS = require( 'RunCalcSolids') + +-- Calcolo +RCS.Exec() \ No newline at end of file diff --git a/Compile.bat b/Compile.bat new file mode 100644 index 0000000..62cf277 --- /dev/null +++ b/Compile.bat @@ -0,0 +1,18 @@ + +REM Compilazione degli script 3dPrinting Egaltech 2023.01.11 +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\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\Slicing.lua Slicing.lua diff --git a/GcodeGenerate.lua b/GcodeGenerate.lua index 1047d2b..703149d 100644 --- a/GcodeGenerate.lua +++ b/GcodeGenerate.lua @@ -1,4 +1,4 @@ --- GcodeGenerate.lua by Egaltech s.r.l. 2022/04/11 +-- GcodeGenerate.lua by Egaltech s.r.l. 2023/01/11 -- Calcoli prima fase per Stampa 3d -- Intestazioni @@ -7,8 +7,7 @@ _ENV = EgtProtectGlobal() EgtEnableDebug( false) -- Imposto direttorio libreria specializzata per Stampa 3d -local sBaseDir = EgtGetSourceDir() -EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') +EgtAddToPackagePath( PRINT.BASEDIR .. '\\LuaLibs\\?.lua') -- Librerie _G.package.loaded.RunGcodeGenerate = nil diff --git a/Images/GcodeGenerate.png b/Images/GcodeGenerate.png deleted file mode 100644 index 67d9056..0000000 Binary files a/Images/GcodeGenerate.png and /dev/null differ diff --git a/Images/MachiningParamCalc.png b/Images/MachiningParamCalc.png deleted file mode 100644 index ffe23a7..0000000 Binary files a/Images/MachiningParamCalc.png and /dev/null differ diff --git a/Images/MachiningParamEdit.png b/Images/MachiningParamEdit.png deleted file mode 100644 index f65d28c..0000000 Binary files a/Images/MachiningParamEdit.png and /dev/null differ diff --git a/Images/MaterialParamEdit.png b/Images/MaterialParamEdit.png deleted file mode 100644 index eef5977..0000000 Binary files a/Images/MaterialParamEdit.png and /dev/null differ diff --git a/Images/PartPositioning.png b/Images/PartPositioning.png deleted file mode 100644 index 860306a..0000000 Binary files a/Images/PartPositioning.png and /dev/null differ diff --git a/Images/ShowManager.png b/Images/ShowManager.png deleted file mode 100644 index ad9d17b..0000000 Binary files a/Images/ShowManager.png and /dev/null differ diff --git a/Images/SliceAdvancement.png b/Images/SliceAdvancement.png deleted file mode 100644 index 4ced7f5..0000000 Binary files a/Images/SliceAdvancement.png and /dev/null differ diff --git a/Images/SlicePalette.png b/Images/SlicePalette.png deleted file mode 100644 index 0918ad5..0000000 Binary files a/Images/SlicePalette.png and /dev/null differ diff --git a/Images/Slicing.png b/Images/Slicing.png deleted file mode 100644 index 58e76e2..0000000 Binary files a/Images/Slicing.png and /dev/null differ diff --git a/Images/ViewManager.png b/Images/ViewManager.png deleted file mode 100644 index 7457827..0000000 Binary files a/Images/ViewManager.png and /dev/null differ diff --git a/LuaLibs/AddManData.lua b/LuaLibs/AddManData.lua index 1d1454c..934eff9 100644 --- a/LuaLibs/AddManData.lua +++ b/LuaLibs/AddManData.lua @@ -24,9 +24,12 @@ COASTING_CRV = "Coasting" WIPE_CRV = "Wipe" LEAD_IN_CRV = "LeadIn" LEAD_OUT_CRV = "LeadOut" +LINK_CRV = "Link" FRAME_PART = "FramePart" START_GEOM = "Start" TOT_SHELL_TRIM_SURF = "TotalShellSurfForTrim" +TRIM_SURF_LOOP = "TrimSurfLoop" +SURF_LOOP = "SurfLoop" MIN_LEN = 0.1 MIN_AREA = 0.01 @@ -35,14 +38,18 @@ MIN_RIBS_LEN = 2 -- Parametri di lavorazione SEC_DEFAULT = "Default" KEY_PARAMS = "Params" -KEY_SLICING_45 = "Slicing45" -KEY_SLICING_DIR="SlicingDir" +KEY_CALC_SOLIDS = "CalcSolids" +KEY_SPIRAL_VASE = "SpiralVase" +KEY_SLICING_TYPE = "SlicingType" +KEY_SLICING_DIR = "SlicingDir" KEY_SLICE_STEP = "StrandH" KEY_SHELLS_NBR = "StrandCount" KEY_STRAND = "StrandW" -KEY_OFFSET_SLICE ="Offset" +KEY_STRAND_OVERLAP = "StrandOverlap" +KEY_OFFSET_SLICE = "Offset" KEY_SP_OFFSET_ON_SLICE = "StartPointOffsetOnSlice" -KEY_PRINT_ORDER = "StrandOrder" +KEY_STRAND_ORDER = "StrandOrder" +KEY_PRINT_ORDER = "PrintOrder" KEY_PRINT_DIRECTION = "Direction" KEY_TYPE = "Type" KEY_LINK_TYPE = "LinkType" @@ -72,10 +79,13 @@ KEY_OFFSET_LEAD_POINT = "OffsetLeadPoint" KEY_COASTING_LEN = "CoastingLen" KEY_COASTING_FEED = "CoastingFeed" KEY_WIPE_LEN = "WipeLen" +KEY_WIPE_DIR = "WipeDir" KEY_WIPE_FEEDPU = "WipeFeedPu" KEY_TOOL_DIAM = "ToolDiam" -- Ribs +KEY_RIBS_TYPE = "RibsType" +KEY_LIMIT_UNBDD_RIBS = "LimitUnboundedRibsWithSolid" KEY_RIBS_OVERLAP = "RibsOverlap" KEY_RIBS_SHELLS_NBR = "RibsStrandCount" KEY_RIBS_LINK = "RibsLink" @@ -89,14 +99,29 @@ KEY_RIBS_LEAD_OUT_COASTING = "RibsLeadOutCoasting" KEY_RIBS_LEAD_OUT_WIPE = "RibsLeadOutWipe" KEY_RIBS_LEAD_OUT_WIPE_DIR = "RibsLeadOutWipeDir" KEY_RIBS_INTERS = "RibsHaveIntersections" -KEY_SPLIT_RIB = "SplitRib" -KEY_RIBS_TWO_STRANDS = "RibsHaveAll2Strands" +KEY_RIBS_SPECIAL_CASE = "RibsSpecialCase" +KEY_SPLIT_ORDER = "SplitOrder" +KEY_SPLIT_AFTER_TRIM = "RibsSplitAfterTrim" +KEY_SPLIT_AFTER_TRIM_ORDER = "RibsSplitAfterTrimOrder" +KEY_SPLIT_AFTER_TRIM_TOT = "RibsSplitAfterTrimTot" +KEY_SPLIT_ID = "SplitId" +KEY_START_RIB = "StartRib" +KEY_ORIGINAL_RIB = "OriginalRib" +KEY_LOOP_RIB = "LoopRib" +KEY_RIBS_USER_LINK = "RibWithUserLink" +KEY_RIBS_USER_LINK_CCW = "RibUserLinkCCW" +KEY_RIBS_USER_LINK_ORDER = "RibUserLinkOrder" +KEY_RIBS_USER_LINK_TOT = "RibsUserLinkParts" +KEY_RIBS_INVERT_STRAND_ORDER = "RibsInvertStrandOrder" -- Regioni con diverso numero di passate KEY_SHELL_NBR_DIFF = "ShellNbrDifference" KEY_SHELL_NBR_COASTING = "ShellNbrCoasting" KEY_SHELL_NBR_WIPE = "ShellNbrWipe" KEY_SHELL_NBR_WIPE_DIR = "ShellNbrWipeDir" +KEY_EXTRA_SHELL_COASTING = "ExtraShellCoasting" +KEY_EXTRA_SHELL_WIPE = "ExtraShellWipe" +KEY_EXTRA_SHELL_WIPE_DIR = "ExtraShellWipeDir" -- Solidi ausiliari KEY_AUX_SOLIDS_INFILL = "AuxSolidsInfill" @@ -126,6 +151,17 @@ KEY_ZIG_ZAG_DIR = "ZigZagDir" KEY_INVERTED_CRV = "InvertedCrv" KEY_CLOSED_CRV = "ClosedCrv" KEY_ASSOCIATED_SURF = "AssociatedSurf" +KEY_ASSOCIATED_CRVS = "AssociatedCrvs" +KEY_HAS_SOLIDS = "Solids" +KEY_BOX_MIN_Z = "PartBoxMinZ" +KEY_START_POINT = "StartPoint" + +SLICING_TYPE = { + VERTICAL = 1, + DEG45_X = 2, + DEG45_Y = 3, + HORIZONTAL = 4, +} TYPE = { OUTER_SHELL = 1, @@ -140,9 +176,20 @@ TYPE = { AUX_SOLID = 10, } +PRINT_ELEMENT = { + SHELL = 1, + EXTRA_SHELL = 2, + INFILL = 3, + AUX_SOLID = 4, + RIB_UNBOUNDED = 5, + RIB_EXTERNAL = 6, + RIB_INTERNAL = 7, + RIB_SUPPORT = 8, +} + PRINT_ORDER = { - EXT_INT_INF = 1, - INF_INT_EXT = 2, + EXT_INT = 1, + INT_EXT = 2, } PRINT_DIRECTION = { @@ -168,6 +215,13 @@ INFILL_TYPE = { ZIGZAG = 3, } +RIB_TYPE = { + INTERNAL = 1, + EXTERNAL = 2, + UNBOUNDED = 3, + SUPPORT = 4, +} + --------------------------------------------------------------------- TABLE = "Table" PART = "Part" @@ -195,6 +249,7 @@ KEY_SLICE_ADV_MODE = 'SliceAdvMode' KEY_SLICE_ADV_PERC = 'SliceAdvPerc' KEY_MOVED_PART ='MovedPart' +KEY_MOVED_PART2 ='MovedPart2' RESULT = { OK = 1, @@ -252,6 +307,8 @@ KEY_FCUR = "FCur" KEY_LENGTH = "Length" KEY_SLICEID = "SliceId" KEY_MASS = "PrintMass" +KEY_MF = "MF" +KEY_TOTAREA = "TotArea" --------------------------------------------------------------------- return AddManData diff --git a/LuaLibs/CSVManager.lua b/LuaLibs/CSVManager.lua deleted file mode 100644 index 3dc77ac..0000000 --- a/LuaLibs/CSVManager.lua +++ /dev/null @@ -1,75 +0,0 @@ --- CalcPaths.lua by Egaltech s.r.l. 2022/03/30 --- Calcolo percorsi di lavoro per Stampa 3d - --- Tabella per definizione modulo -local CSVManager = {} - --- Intestazioni -require( 'EgtBase') - -EgtOutLog( ' CSVManager started', 1) - --- Dati -local AMD = require( 'AddManData') - ---------------------------------------------------------------------- -function toCSV (t) - local s = "" - for _,p in pairs(t) do - s = s .. "," .. escapeCSV(p) - end - return string.sub(s, 2) -- remove first comma -end - ---------------------------------------------------------------------- -function escapeCSV (s) - if string.find(s, '[,"]') then - ns = '"' .. string.gsub(s, '"', '""') .. '"' - end - return s -end - ---------------------------------------------------------------------- -local function fromCSV(s) - s = s .. ';' -- ending comma - local t = {} -- table to collect fields - local fieldstart = 1 - repeat - -- next field is quoted? (start with `"'?) - if string.find(s, '^"', fieldstart) then - local a, c - local i = fieldstart - repeat - -- find closing quote - a, i, c = string.find(s, '"("?)', i+1) - until c ~= '"' -- quote not followed by quote? - if not i then error('unmatched "') end - local f = string.sub(s, fieldstart+1, i-1) - table.insert(t, (string.gsub(f, '""', '"'))) - fieldstart = string.find(s, ';', i) + 1 - else -- unquoted; find next comma - local nexti = string.find(s, ';', fieldstart) - table.insert(t, string.sub(s, fieldstart, nexti-1)) - fieldstart = nexti + 1 - end - until fieldstart > string.len(s) - return t -end - ---------------------------------------------------------------------- -function read_file( path) - local file = io.open( path, "r") -- r read mode and b binary mode - if not file then return nil end - local CSVTable = {} - - for line in io.lines( path) do - CSVTable[#CSVTable + 1] = fromCSV( line) - end - - file:close() - - return CSVTable -end - ---------------------------------------------------------------------- -return CSVManager diff --git a/LuaLibs/CalcPaths.lua b/LuaLibs/CalcPaths.lua index 8a2394e..5347226 100644 --- a/LuaLibs/CalcPaths.lua +++ b/LuaLibs/CalcPaths.lua @@ -18,9 +18,12 @@ local s_dOffsCorr = 10 * GEO.EPS_SMALL --------------------------------------------------------------------- local function GetLayerParamsForPathCalc() - local LayerParams = {} - LayerParams.nShellsNbr = EgtGetInfo( s_nPartId, KEY_SHELLS_NBR, 'i') + local LayerParams = {} + LayerParams.bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false + LayerParams.nShellsNbr = EgtGetInfo( s_nPartId, KEY_SHELLS_NBR, 'i') LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd') + LayerParams.dLayHeight = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') + LayerParams.nStrandOverlap = EgtGetInfo( s_nPartId, KEY_STRAND_OVERLAP, 'i') or 0 LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd') LayerParams.nFloorNbr = EgtGetInfo( s_nPartId, KEY_FLOOR_NBR, 'i') or 0 LayerParams.nFloorType = EgtGetInfo( s_nPartId, KEY_FLOOR_TYPE, 'i') or INFILL_TYPE.ZIGZAG @@ -28,23 +31,51 @@ local function GetLayerParamsForPathCalc() LayerParams.nCeilType = EgtGetInfo( s_nPartId, KEY_CEIL_TYPE, 'i') or INFILL_TYPE.ZIGZAG LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v') LayerParams.bPrintInvert = ( EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW) + LayerParams.vPrintOrder = EgtGetInfo( s_nPartId, KEY_PRINT_ORDER, 'vi') or { 1, 2, 3, 4, 5, 6, 7, 8} -- parametri costolature LayerParams.bRibsInvertOrder = EgtGetInfo( s_nPartId, KEY_RIBS_INVERT_ORDER, 'b') - return LayerParams + -- parametri regioni con diverse passate + LayerParams.dShellNbrCoasting = EgtGetInfo( s_nPartId, KEY_SHELL_NBR_COASTING, 'd') + LayerParams.dShellNbrWipe = EgtGetInfo( s_nPartId, KEY_SHELL_NBR_WIPE, 'd') + LayerParams.dShellNbrWipeDir = EgtGetInfo( s_nPartId, KEY_SHELL_NBR_WIPE_DIR, 'd') + + -- eventuale modifica dei parametri per gestire correttamente il caso spiral vase + if LayerParams.bSpiralVase then + LayerParams.nShellsNbr = 1 + LayerParams.nFloorNbr = 0 + LayerParams.nCeilNbr = 0 + end + + return LayerParams +end + +-------------------------------------------------------------------------------------------- +local function CopyInfo( nSouId, nDestId, sInfo, sType) + local info = EgtGetInfo( nSouId, sInfo, sType) + EgtSetInfo( nDestId, sInfo, info) +end + +-------------------------------------------------------------------------------------------- +local function UpdateInvertInfo( nId) + local bInvert = EgtGetInfo( nId, KEY_INVERTED_CRV, 'b') or false + EgtSetInfo( nId, KEY_INVERTED_CRV, not bInvert) end ---------------------------------------------------------------------- -local function ComputeSurfOffset( nSrf, nGrpId, dOffs) - - local nCopySrf = EgtCopy( nSrf, nGrpId) +local function ComputeSurfOffset( nSrf, nGrpId, dOffs, vtSlicing) + -- gruppo temporaneo locale + local nGrpTmp = EgtGroup( nGrpId, Frame3d( ORIG(), vtSlicing), GDB_RT.GLOB) + local nCopySrf = EgtCopyGlob( nSrf, nGrpTmp) or GDB_ID.NULL local bOk = EgtSurfFrOffset( nCopySrf, dOffs) local bExists = EgtSurfFrChunkCount( nCopySrf) > 0 if not bOk or not bExists then EgtErase( nCopySrf) - nCopySrf = EgtCopyGlob( nSrf, nGrpId) + nCopySrf = EgtCopyGlob( nSrf, nGrpTmp) or GDB_ID.NULL bOk = EgtSurfFrOffset( nCopySrf, dOffs + 0.05) bExists = EgtSurfFrChunkCount( nCopySrf) > 0 end + EgtRelocateGlob( nCopySrf, nGrpId) + EgtErase( nGrpTmp) return bOk, bExists, nCopySrf end @@ -91,12 +122,16 @@ local function ModifyStartPoint( nCrvId, vPtStart) -- cerco lo start point più vicino tra quelli possibili if vPtStart and #vPtStart > 0 then local nMinIdx = -1 - local dMinDist = GEO.INFINITO - for i = 1, #vPtStart do - local dDist = EgtPointCurveDist( vPtStart[i], nCrvId) - if dDist < dMinDist - 10 * GEO.EPS_SMALL then - dMinDist = dDist - nMinIdx = i + if #vPtStart == 1 then + nMinIdx = 1 + else + local dMinDist = GEO.INFINITO + for i = 1, #vPtStart do + local dDist = EgtPointCurveDist( vPtStart[i], nCrvId) + if dDist < dMinDist - 10 * GEO.EPS_SMALL then + dMinDist = dDist + nMinIdx = i + end end end EgtChangeClosedCurveStartPoint( nCrvId, vPtStart[nMinIdx]) @@ -157,8 +192,8 @@ local function VerifyPath( nCrvId, dStrand, vtSlicing, nGrp) -- verifico se fattibile con una sola passata -- TODO da sistemare con medial axis per curva generica local bSingleStrand = false - if EgtCurveIsClosed( nCrvId) then - local nGrpTmp = EgtGroup( nGrp, Frame3d( ORIG(), vtSlicing)) + if EgtCurveIsClosed( nCrvId) then + local nGrpTmp = EgtGroup( nGrp, Frame3d( ORIG(), vtSlicing), GDB_RT.GLOB) EgtRelocateGlob( nCrvId, nGrpTmp) local frLoc, dDimX, dDimY = EgtCurveMinAreaRectangleXY( nCrvId) if dDimY < 0.5 then @@ -181,7 +216,7 @@ local function VerifyPath( nCrvId, dStrand, vtSlicing, nGrp) EgtRelocateGlob( nCrvId, nGrp, GDB_IN.LAST_SON) EgtErase( nGrpTmp) end - -- se non è fattibile con unica passata lo cancello + -- se non è fattibile con unica passata lo cancello if not bSingleStrand then EgtErase( nCrvId) return false @@ -192,7 +227,7 @@ local function VerifyPath( nCrvId, dStrand, vtSlicing, nGrp) end ------------------------------------------------------------------- -local function ComputeTrimSurfWithOverlaps( vIds, nSrfBase, sKeyOverlap, dStrand, nGrp) +local function ComputeTrimSurfWithOverlaps( vIds, nSrfBase, sKeyOverlap, dStrand, nGrp, vtSlicing) -- per ogni overlap creo le superfici con cui fare i trim local vSurfOffs = {} @@ -200,7 +235,7 @@ local function ComputeTrimSurfWithOverlaps( vIds, nSrfBase, sKeyOverlap, dStrand local nOverlap = EgtGetInfo( vIds[i], sKeyOverlap, 'i') if not vSurfOffs[nOverlap] then local dNewOffs = nOverlap / 100 * dStrand - local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfBase, nGrp, dNewOffs) + local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfBase, nGrp, dNewOffs, vtSlicing) if bOk then vSurfOffs[nOverlap] = nSrfOffs end @@ -306,13 +341,13 @@ local function ComputeOffsetInfill( nSrf, dStrand, vtSlicing, sName, nType, vPtS -- estraggo i contorni della superficie local vOldIds = GetPathsFromSurf( nSrf, sName, nType, nGrp, vPtStart) local dOffs = - dStrand - local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrf, nGrp, dOffs) + local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrf, nGrp, dOffs, vtSlicing) while bOk and bExists do -- estraggo i contorni local vNewIds = GetPathsFromSurf( nSrfOffs, sName, nType, nGrp, vPtStart) if vNewIds then -- riordino - ReorderPath( vOldIds, vNewIds) + ReorderPath( vOldIds, vNewIds) -- verifico fattibilità local k = 1 while k <= #vNewIds do @@ -329,7 +364,7 @@ local function ComputeOffsetInfill( nSrf, dStrand, vtSlicing, sName, nType, vPtS EgtErase( nSrfOffs) -- offset successivo dOffs = dOffs - dStrand - bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrf, nGrp, dOffs) + bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrf, nGrp, dOffs, vtSlicing) end end @@ -347,7 +382,7 @@ local function ComputeZigZagInfill( nSrf, dStrand, vtSlicing, sName, nType, vPtS local frLoc = Frame3d( ORIG(), vtSlicing) local vIds = {} for nId = nFirst, nFirst + nCnt - 1 do - local nGrpTmp = EgtGroup( nGrp, frLoc) + local nGrpTmp = EgtGroup( nGrp, frLoc, GDB_RT.GLOB) -- recupero outer curve local nCrvGrpId = EgtGetParent( nGrp) @@ -394,7 +429,7 @@ local function ComputeZigZagInfill( nSrf, dStrand, vtSlicing, sName, nType, vPtS EgtSetInfo( j, KEY_TYPE, nType) EgtSetInfo( j, KEY_ZIG_ZAG_DIR, vtDir) EgtSetInfo( j, KEY_ZIG_ZAG_INFILL, 1) - EgtModifyCurveExtrusion( j, vtSlicing) + EgtModifyCurveExtrusion( j, vtSlicing, GDB_RT.GLOB) table.insert( vIds, j) end local vtS = EgtSV( nInd) @@ -403,57 +438,436 @@ local function ComputeZigZagInfill( nSrf, dStrand, vtSlicing, sName, nType, vPtS end -------------------------------------------------------------------- +-------------------------------------------------------------------- --------------------------- RIBS ----------------------------------- -------------------------------------------------------------------- --- Funzione che sistema le intersezioni fra costolature nel caso generico -local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffsGrp) - - -- calcolo gli offset della curva principale ( nCrv1) da usare per trim - local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i') - local nOverlap1 = EgtGetInfo( nCrv1, KEY_RIBS_OVERLAP, 'i') - local nOverlap2 = EgtGetInfo( nCrv2, KEY_RIBS_OVERLAP, 'i') - local nOverlap = min( nOverlap1, nOverlap2) - local dOffs = ( nShells - 1) * LayerParams.dStrand / 2 - local nSrf = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dOffs + ( 1 - nOverlap / 100) * LayerParams.dStrand, false) +local function VerifyRibsHoles( vIds, dStrand) - -- recupero gli offset della curva secondaria ( nCrv2) - local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) - -- trim degli offset della curva secondaria - for i = 1, #vOffs2 do - local nId, nCnt = EgtTrimCurveWithRegion( vOffs2[i], nSrf, false, true) - EgtChangeId( nId, vOffs2[i]) - if nCnt > 1 then - EgtSetInfo( nId + 1, KEY_SPLIT_RIB, vOffs2[i]) - EgtRelocateGlob( nId + 1, nOffsGrp, GDB_IN.LAST_SON) + local sPrevName = EgtGetName( vIds[1]) + local i = 2 + while i <= #vIds do + + local bAdd = false + local sCurrName = EgtGetName( vIds[i]) + -- se derivano dallo stesso setto verifico se possono essere uniti + if sCurrName == sPrevName then + if dist( EgtEP( vIds[i-1]), EgtSP( vIds[i])) < dStrand + 10 * GEO.EPS_SMALL then + bAdd = true + -- unisco il secondo tratto al primo + EgtAddCurveCompoLine( vIds[i-1], EgtSP( vIds[i])) + EgtAddCurveCompoCurve( vIds[i-1], vIds[i]) + table.remove( vIds, i) -- rimuovo il setto dalla tabella + elseif dist( EgtSP( vIds[i-1]), EgtEP( vIds[i])) < dStrand + 10 * GEO.EPS_SMALL then + bAdd = true + -- unisco il primo tratto al secondo + EgtAddCurveCompoLine( vIds[i], EgtSP( vIds[i-1])) + EgtAddCurveCompoCurve( vIds[i], vIds[i-1]) + table.remove( vIds, i-1) -- rimuovo il setto dalla tabella + end end - end - EgtErase( nSrf) - + -- aggiorno per iterazione successiva + sPrevName = sCurrName + if not bAdd then + i = i + 1 + end + end end -------------------------------------------------------------------- --- Funzione che sistema le intersezioni fra costolature nel caso di 2 passate -local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nOffsGrp, nOrigGrp) +local function CheckRibUserLink( nCrv, nCnt, vtSlicing) + + -- se dal trim non ho ottenuto almeno due tratti, non si tratta di UserLink + if nCnt < 2 then return end + + -- stabilisco l'orientamento del link + local bCCW = false + -- costruisco la superficie "definita" dal setto + local nGrpTmp = EgtGroup( EgtGetParent( nCrv)) + local nSrfLoop = EgtCurveCompoFromPoints( nGrpTmp, {EgtEP( nCrv), EgtSP( nCrv + 1)}) + EgtAddCurveCompoLine( nSrfLoop, EgtSP( nCrv + 1) + 100 * EgtSV( nCrv + 1)) + EgtAddCurveCompoLine( nSrfLoop, EgtEP( nCrv) - 100 * EgtEV( nCrv)) + EgtCloseCurveCompo( nSrfLoop) + + local nSurf = EgtSurfFlatRegion( nGrpTmp, {nSrfLoop}) + if not nSurf then + EgtErase( nGrpTmp) + return + end + -- verifico direzione della normale + local vtN = EgtSurfFrNormVersor( nSurf, GDB_ID.ROOT) + if AreSameVectorApprox( vtN, vtSlicing) then + bCCW = true + end - -- recupero gli offset originali delle due curve - local vOffsOrig1 = EgtGetNameInGroup( nOrigGrp, EgtGetName( nCrv1)) - local vOffsOrig2 = EgtGetNameInGroup( nOrigGrp, EgtGetName( nCrv2)) + -- setto le info + for i = 0, nCnt - 1 do + EgtSetInfo( nCrv + i, KEY_RIBS_USER_LINK, 1) + EgtSetInfo( nCrv + i, KEY_RIBS_USER_LINK_CCW, bCCW) + EgtSetInfo( nCrv + i, KEY_RIBS_USER_LINK_ORDER, i) + EgtSetInfo( nCrv + i, KEY_RIBS_USER_LINK_TOT, nCnt) + end + + EgtErase( nGrpTmp) + +end + +------------------------------------------------------------------- +local function TrimRibs( vRibs, nRibsGrp, nSrf, dSrfOffs, vtSlicing) + -- costruisco le superfici con cui fare il trim grossolano dei setti + local nSrfInt = EgtCopyGlob( nSrf, nRibsGrp) or GDB_ID.NULL + local nSrfExt = EgtCopyGlob( nSrf, nRibsGrp) or GDB_ID.NULL + EgtSurfFrOffset( nSrfInt, dSrfOffs) + EgtSurfFrOffset( nSrfExt, - dSrfOffs) + + -- trim dei setti + local nTrimmedRibsGrp = EgtGroup( nRibsGrp) + for i = 1, #vRibs do + local nCopyRib = EgtCopyGlob( vRibs[i], nTrimmedRibsGrp) + local nType = EgtGetInfo( vRibs[i], KEY_RIBS_TYPE, 'i') + + local nCrv, nCnt + if nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT then + if EgtSurfFrChunkCount( nSrfInt) == 0 then + -- se la superficie non esiste, il setto deve essere cancellato + EgtErase( nCopyRib) + nCrv = GDB_ID.NULL + nCnt = 0 + else + nCrv, nCnt = EgtTrimCurveWithRegion( nCopyRib, nSrfInt, true, true) + end + elseif nType == RIB_TYPE.EXTERNAL then + if EgtSurfFrChunkCount( nSrfExt) == 0 then + -- se la superficie non esiste il setto è valido + nCrv = nCopyRib + nCnt = 1 + else + nCrv, nCnt = EgtTrimCurveWithRegion( nCopyRib, nSrfExt, false, true) + end + else + -- setto unbounded non va tagliato + nCrv = nCopyRib + nCnt = 1 + end + + -- se errore nel calcolare trim ( nCrv = nil) riprendo il setto originario + if not nCrv then + nCrv = nCopyRib + nCnt = 1 + end + + for nId = nCrv, nCrv + nCnt - 1 do + EgtSetInfo( nId, KEY_START_RIB, vRibs[i]) + -- se originale era chiusa ma è stata spezzata dopo il trim è il caso di LoopRib + if EgtCurveIsClosed( vRibs[i]) and nCnt > 1 then + EgtSetInfo( nId, KEY_LOOP_RIB, 1) + end + end + -- verifico se link definito dall'utente e ne analizzo le proprietà + CheckRibUserLink( nCrv, nCnt, vtSlicing) + + end + + return nTrimmedRibsGrp +end + +-------------------------------------------------------------------- +local function ComputeRibsOrientedOffset( nRibsGrp, dStrand) + + local nOffsGrp = EgtGroup( EgtGetParent( nRibsGrp)) + + local nCurrRib = EgtGetFirstNameInGroup( nRibsGrp, RIBS_CRV .. '*') + while nCurrRib do + + -- recupero tutti i tratti appartenenti a quel setto (hanno lo stesso nome) + local sName = EgtGetName( nCurrRib) + local vIds = EgtGetNameInGroup( nRibsGrp, sName) + + -- recupero i parametri del setto + local bInvert = EgtGetInfo( nCurrRib, KEY_RIBS_INVERT_DIR, 'b') or false + local bInvertOrder = EgtGetInfo( nCurrRib, KEY_RIBS_INVERT_STRAND_ORDER, 'b') or false + + local nShellsNbr = EgtGetInfo( nCurrRib, KEY_RIBS_SHELLS_NBR, 'i') + local dOffs = ( nShellsNbr - 1) * dStrand / 2 + + -- offset di ogni tratto del setto + local vOffs = {} + local bPlusToMinus = false + for i = 1, #vIds do + + local bUserLinked = EgtGetInfo( vIds[i], KEY_RIBS_USER_LINK, 'b') or false + local bCCW = EgtGetInfo( vIds[i], KEY_RIBS_USER_LINK_CCW, 'b') or false + local nLinkOrder = EgtGetInfo( vIds[i], KEY_RIBS_USER_LINK_ORDER, 'i') or 0 + + -- ordine di realizzazione degli offset + if not bUserLinked then + bPlusToMinus = false + else + if nLinkOrder == 0 then + -- determinato dal verso del collegamento + bPlusToMinus = EgtIf( bCCW, true, false) + else + bPlusToMinus = not bPlusToMinus + end + end + + for k = 0, nShellsNbr - 1 do + local dOffsCurr = dOffs - k * dStrand + local nNewId + if abs( dOffsCurr) < GEO.EPS_SMALL then + nNewId = EgtCopyGlob( vIds[i], nOffsGrp) + else + nNewId = EgtOffsetCurveAdv( vIds[i], EgtIf( bPlusToMinus, dOffsCurr, - dOffsCurr)) + end + + if nNewId then + EgtSetName( nNewId, sName) + EgtSetInfo( nNewId, KEY_TYPE, TYPE.RIB) + EgtSetInfo( nNewId, KEY_ORIGINAL_RIB, vIds[i]) + EgtRelocateGlob( nNewId, nOffsGrp) + table.insert( vOffs, nNewId) + end + end + end + + -- ordinamento + if bInvertOrder then + for i = 1, #vOffs - 1 do + EgtRelocateGlob( vOffs[i], vOffs[#vOffs], GDB_IN.AFTER) + end + -- aggiorno il vettore con gli indici per rispettare nuovo ordinamento + vOffs = EgtGetNameInGroup( nOffsGrp, sName) + end + + -- orientamento + local bInvertCrv = bInvert + for j = 1, #vOffs, nShellsNbr do + + -- stabilisco orientamento del primo tratto del gruppo + local bUserLinked = EgtGetInfo( vOffs[j], KEY_RIBS_USER_LINK, 'b') or false + local nLinkOrder = EgtGetInfo( vOffs[j], KEY_RIBS_USER_LINK_ORDER, 'i') or 0 + local nLinkTot = EgtGetInfo( vOffs[j], KEY_RIBS_USER_LINK_TOT, 'i') or 0 + if not bUserLinked then + bInvertCrv = bInvert + else + if ( not bInvertOrder and nLinkOrder == 0) or ( bInvertOrder and nLinkOrder == nLinkTot - 1) then + bInvertCrv = bInvert + if ( nShellsNbr % 2 == 0 and not bInvertOrder) or ( nShellsNbr % 2 ~= 0 and bInvertOrder) then + bInvertCrv = not bInvert + end + else + if nShellsNbr % 2 == 0 then + bInvertCrv = not bInvertCrv + end + end + end + + -- inversione + for k = 0, nShellsNbr - 1 do + if ( bInvertCrv and k % 2 == 0) or ( not bInvertCrv and k % 2 ~= 0) then + EgtInvertCurve( vOffs[j + k]) + UpdateInvertInfo( vOffs[j + k]) + end + end + end + + -- passo al setto successivo + nCurrRib = EgtGetNextName( vIds[#vIds], RIBS_CRV .. '*') + end + + return nOffsGrp +end + +-------------------------------------------------------------------- +local function ComputeTrimSurfWithOverlapsForRibs( vIds, nSrfBase, nSrfExt, dOffs, dStrand, nGrp, vtSlicing) + + -- per ogni tipologia e overlap creo le superfici con cui fare i trim + local tSurfOffs = {{}, {}, {}, {}} + for i = 1, #vIds do + local nOverlap = EgtGetInfo( vIds[i], KEY_RIBS_OVERLAP, 'i') + local nType = EgtGetInfo( vIds[i], KEY_RIBS_TYPE, 'i') + if not tSurfOffs[nType][nOverlap] then + if nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT then + if nSrfBase ~= GDB_ID.NULL then + local dNewOffs = nOverlap / 100 * dStrand + local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfBase, nGrp, dNewOffs, vtSlicing) + if bOk then + tSurfOffs[RIB_TYPE.INTERNAL][nOverlap] = nSrfOffs + tSurfOffs[RIB_TYPE.SUPPORT][nOverlap] = nSrfOffs + end + end + elseif nType == RIB_TYPE.EXTERNAL then + if nSrfExt ~= GDB_ID.NULL then + local dNewOffs = dOffs + ( 0.5 - nOverlap / 100) * dStrand + local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfExt, nGrp, dNewOffs, vtSlicing) + if bOk then + tSurfOffs[nType][nOverlap] = nSrfOffs + EgtSetName( nSrfOffs, TOT_SHELL_TRIM_SURF) + end + else + -- se la superficie non esiste, il setto è sicuramente esterno (è analogo ad unbounded) + tSurfOffs[nType][nOverlap] = GDB_ID.NULL + end + else + tSurfOffs[nType][nOverlap] = GDB_ID.NULL + end + end + end + return tSurfOffs +end + +-------------------------------------------------------------------- +local function VerifyRibsIntersection( nRib1, nRib2, nType1, nType2, nSrf1, nSrf2, dStrand, nGrp, nOffsGrp) + + -- setti interni/supporto ed esterni non si possono intersecare per definizione + if ( ( nType1 == RIB_TYPE.INTERNAL or nType1 == RIB_TYPE.SUPPORT) and nType2 == RIB_TYPE.EXTERNAL) or + ( nType1 == RIB_TYPE.EXTERNAL and ( nType2 == RIB_TYPE.INTERNAL or nType2 == RIB_TYPE.SUPPORT)) then + return false + end + -- se hanno lo stesso nome derivano dalla stessa costolatura quindi non ha senso controllare intersezione + if EgtGetName( nRib1) == EgtGetName( nRib2) then + return false + end + + local bInters = false + local bForceCrv1Cut = false + + -- porto le curve nel gruppo locale + local nCrv1 = EgtCopyGlob( nRib1, nGrp) + local nCrv2 = EgtCopyGlob( nRib2, nGrp) + -- verifico se si intersecano nel piano XY definito dal gruppo locale + local nId, nPntCnt, nCrvCnt = EgtCurveCurveInters( nCrv1, nCrv2, nGrp) + + -- se si intersecano verifico se ho intersezioni valide + if nId then + -- scorro tutti i punti di intersezione trovati + for i = 0, nPntCnt - 1 do + local nPtId = nId + i + -- verifico se valida + if nType1 == RIB_TYPE.UNBOUNDED and nType2 == RIB_TYPE.UNBOUNDED then + -- nel caso unbounded l'intersezione può essere ovunque + bInters = true + elseif nType1 == RIB_TYPE.EXTERNAL or nType2 == RIB_TYPE.EXTERNAL then + if nSrf2 then + -- l'intersezione deve essere esterna + if EgtSurfFrTestExternal( nSrf2, nPtId) then bInters = true end + else + -- se la surf non esiste l'intersezione è sicuramente esterna + bInters = true + end + else + -- se uno dei due è interno o supporto l'intersezione deve essere interna + if nSrf1 and not EgtSurfFrTestExternal( nSrf1, nPtId) then bInters = true end + end + + -- se valida verifico se forza il taglio sulla curva 1 + if bInters then + local ptInt = EgtSP( nPtId, GDB_ID.ROOT) + local dPar1 = EgtCurveParamAtPoint( nCrv1, ptInt, GEO.EPS_SMALL, GDB_RT.GLOB) + local dPar2 = EgtCurveParamAtPoint( nCrv2, ptInt, GEO.EPS_SMALL, GDB_RT.GLOB) + local _, dParE1 = EgtCurveDomain( nCrv1) + local _, dParE2 = EgtCurveDomain( nCrv2) + + local bCrv1OnExtr = ( dPar1 < 10 * GEO.EPS_SMALL or abs( dPar1 - dParE1) < 10 * GEO.EPS_SMALL) + local bCrv2OnExtr = ( dPar2 < 10 * GEO.EPS_SMALL or abs( dPar2 - dParE2) < 10 * GEO.EPS_SMALL) + bForceCrv1Cut = ( bCrv1OnExtr and not bCrv2OnExtr) + + if bForceCrv1Cut then + return bInters, bForceCrv1Cut -- true, true + end + end + end + + return bInters, bForceCrv1Cut -- true/false, false + + else + -- se non si intersecano, verifico se si intersecano i loro offset + local vOffs1 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv1)) or {} + local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) or {} + for i = 1, #vOffs1 do + local nSrfOffs1 = EgtSurfFrFatCurve( nGrp, vOffs1[i], 0.5 * dStrand, false) + if nSrfOffs1 then + for j = 1, #vOffs2 do + -- verifico se intersezione + local nRes = EgtCurveWithRegionClassify( vOffs2[j], nSrfOffs1) + if nRes == GDB_CRC.IN or nRes == GDB_CRC.INTERS then + bInters = true + break + end + end + if bInters then break end + end + end + + return bInters, bForceCrv1Cut -- true, false + end + +end + +--------------------------------------------------------------------------------- +-- Funzione che sistema le intersezioni fra costolature nel caso generico +local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffsGrp, bSaveSurf, nLoopGrp) + + -- calcolo la superficie della curva principale ( nCrv1) da usare per trim + local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i') + local nOverlap = EgtGetInfo( nCrv2, KEY_RIBS_OVERLAP, 'i') + local dOffs = ( nShells - 1) * LayerParams.dStrand / 2 + local nSrf = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dOffs + ( 1 - nOverlap / 100) * LayerParams.dStrand, false) + if not nSrf then return end + + -- trim degli offset della curva secondaria ( nCrv2) + local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) or {} + for i = 1, #vOffs2 do + local nId, nCnt = EgtTrimCurveWithRegion( vOffs2[i], nSrf, false, true) + + -- se setto chiuso verifico se primo e ultimo tratto possono essere uniti + if EgtCurveIsClosed( nCrv2) then + if nCnt > 1 and AreSamePointApprox( EgtEP( nId + nCnt - 1), EgtSP( nId)) then + EgtRelocateGlob( nId + nCnt - 1, nId, GDB_IN.AFTER) + EgtAddCurveCompoCurve( nId + nCnt - 1, nId) + EgtChangeId( nId + nCnt - 1, nId) + nCnt = nCnt - 1 + end + end + + -- aggiorno ordine di split copiandolo da nCrv2 + for j = nId, nId + nCnt - 1 do + CopyInfo( nCrv2, j, KEY_SPLIT_ORDER, 'i') + end + end + + -- se necessario salvo i loop da usare per ingressi e uscite + if bSaveSurf then + -- verifico orientamento della superficie per compatibilità ingressi ribs splittati + local vtN = EgtSurfFrNormVersor( nSrf) + if AreSameVectorApprox( vtN, LayerParams.vtSlicing) then + EgtInvertSurf( nSrf) + end + local nChunks = EgtSurfFrChunkCount( nSrf) + for i = 0, nChunks - 1 do + local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrf, i, nLoopGrp) + for j = nRes, nRes + nCnt - 1 do + EgtSetName( j, SURF_LOOP) + end + end + end + + EgtErase( nSrf) +end + +-------------------------------------------------------------------- +-- Funzione che sistema le intersezioni fra costolature nel caso di 2 passate +local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nOffsGrp) + -- costruisco le superfici da usare per trim - local nOverlap = EgtGetInfo( nCrv1, KEY_RIBS_OVERLAP, 'i') - local dOffs = LayerParams.dStrand / 2 + ( 1 - nOverlap / 100) * LayerParams.dStrand - - local nRect1 = EgtRectangle3P( nOffsGrp, EgtSP( vOffsOrig1[1]), EgtEP( vOffsOrig1[2]), EgtEP( vOffsOrig1[1])) - local nSrf1 = EgtSurfFlatRegion( nOffsGrp, {nRect1}) - local vtN1 = EgtSurfFrNormVersor( nSrf1, GDB_ID.ROOT) + local nSrf1 = EgtSurfFrFatCurve( nOffsGrp, nCrv1, LayerParams.dStrand / 2, false) + local vtN1 = EgtSurfFrNormVersor( nSrf1, GDB_ID.ROOT) if LayerParams.vtSlicing * vtN1 < 0 then EgtInvertSurf( nSrf1) end - - local nRect2 = EgtRectangle3P( nOffsGrp, EgtSP( vOffsOrig2[1]), EgtEP( vOffsOrig2[2]), EgtEP( vOffsOrig2[1])) - local nSrf2 = EgtSurfFlatRegion( nOffsGrp, {nRect2}) - local vtN2 = EgtSurfFrNormVersor( nSrf2, GDB_ID.ROOT) + + local nSrf2 = EgtSurfFrFatCurve( nOffsGrp, nCrv2, LayerParams.dStrand / 2, false) + local vtN2 = EgtSurfFrNormVersor( nSrf2, GDB_ID.ROOT) if LayerParams.vtSlicing * vtN2 < 0 then EgtInvertSurf( nSrf2) end @@ -465,159 +879,381 @@ local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams end -- trim degli offset di nCrv2 - local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) + local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) for i = 1, #vOffs2 do local nId, nCnt = EgtTrimCurveWithRegion( vOffs2[i], nSrf1, false, true) end EgtErase( nSrf1) - EgtErase( nRect1) EgtErase( nSrf2) - EgtErase( nRect2) end --------------------------------------------------------------------- -local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, bAllTwoStrands) +------------------------------------------------------------------ +local function UpdateSplitOrder( nCrv, tInters, nOffsGrp) + local nOrder = EgtGetInfo( nCrv, KEY_SPLIT_ORDER, 'i') or 0 + local nNewOrder = nOrder + 1 + + -- aggiorno tutte le curve che dipendono da nCrv + if tInters[nCrv] then + for i = 1, #tInters[nCrv] do + local nOldOrder = EgtGetInfo( tInters[nCrv][i], KEY_SPLIT_ORDER, 'i') + if nOldOrder < nNewOrder then + EgtSetInfo( tInters[nCrv][i], KEY_SPLIT_ORDER, nNewOrder) + -- aggiorno i suoi offset + local vOffs = EgtGetNameInGroup( nOffsGrp, EgtGetName( tInters[nCrv][i])) + for j = 1, #vOffs do + EgtSetInfo( vOffs[j], KEY_SPLIT_ORDER, nNewOrder) + end + -- aggiorno eventuali dipendenze + UpdateSplitOrder( tInters[nCrv][i], tInters, nOffsGrp) + end + end + end +end + +--------------------------------------------------------------------------------- +local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, nLoopGrp, bAllTwoStrands, vTypeSequence) - local nCrvGrp = EgtGetParent( nRibsPathGrp) + local bSpecialCase = false + local vRibsIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') -- copio gli offset delle costolature nel RibsPathGrp + local nCrvGrp = EgtGetParent( nRibsPathGrp) local vOffsRib = EgtGetAllInGroup( nOffsGrp) for i = 1, #vOffsRib do EgtCopyGlob( vOffsRib[i], nRibsPathGrp) end - -- calcolo la regione nella quale ha senso considerare l'intersezione - local nSrf = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF) - local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrf, nCrvGrp, 2 * LayerParams.dStrand) - if not bOk or not bExists then - nSrfOffs = EgtCopyGlob( nSrf, nCrvGrp) + -- creo un gruppo con frame locale per calcolare le intersezioni ( è il piano XY locale dove calcolare intersezioni) + local frLoc = Frame3d( ORIG(), LayerParams.vtSlicing) + local nGrpTmp = EgtGroup( nRibsGrp, frLoc, GDB_RT.GLOB) + + -- calcolo le regioni nella quali ha senso considerare l'intersezione + local nSrfOffs1, nSrfOffs2 + local bOk, bExists + local nSrf1 = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF) or GDB_ID.NULL + if nSrf1 ~= GDB_ID.NULL then + bOk, bExists, nSrfOffs1 = ComputeSurfOffset( nSrf1, nCrvGrp, 2 * LayerParams.dStrand, LayerParams.vtSlicing) + if not bOk or not bExists then + nSrfOffs1 = EgtCopyGlob( nSrf1, nCrvGrp) + end end - - local vRibsIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') + local nSrf2 = EgtGetFirstNameInGroup( nCrvGrp, LAYER_SRF) or GDB_ID.NULL + if nSrf2 ~= GDB_ID.NULL then + bOk, bExists, nSrfOffs2 = ComputeSurfOffset( nSrf2, nCrvGrp, - 2 * LayerParams.dStrand, LayerParams.vtSlicing) + if not bOk or not bExists then + nSrfOffs2 = EgtCopyGlob( nSrf2, nCrvGrp) + end + end + local bInters = false local vSplit = {} + local tInters = {} -- tabella che tiene traccia delle intersezioni trovate for i = 1, #vRibsIds do + local nType1 = EgtGetInfo( vRibsIds[i], KEY_RIBS_TYPE, 'i') + -- verifico se interseca uno dei setti successivi for j = i + 1, #vRibsIds do - local ptInt = EgtIP( vRibsIds[i], vRibsIds[j], ORIG()) - if ptInt then + local nType2 = EgtGetInfo( vRibsIds[j], KEY_RIBS_TYPE, 'i') + + local bRibInters, bForceCrv1Cut = VerifyRibsIntersection( vRibsIds[i], vRibsIds[j], nType1, nType2, nSrfOffs1, nSrfOffs2, LayerParams.dStrand, nGrpTmp, nOffsGrp) + if bRibInters then + bInters = true - -- verifico se l'interserzione si trova nella regione dello slice - local nPtId = EgtPoint( nRibsPathGrp, ptInt) - if not EgtSurfFrTestExternal( nSrfOffs, nPtId) then - bInters = true - - local dPar1 = EgtCurveParamAtPoint( vRibsIds[i], ptInt) - local dPar2 = EgtCurveParamAtPoint( vRibsIds[j], ptInt) - local _, dParE1 = EgtCurveDomain( vRibsIds[i]) - local _, dParE2 = EgtCurveDomain( vRibsIds[j]) - - local nCrv1 = vRibsIds[i] -- curva principale che non viene tagliata - local nCrv2 = vRibsIds[j] -- curve secondaria da modificare - if dPar1 < 10 * GEO.EPS_SMALL or abs( dPar1 - dParE1) < 10 * GEO.EPS_SMALL then - nCrv1, nCrv2 = nCrv2, nCrv1 - end - - if bAllTwoStrands then - -- nel caso di 2 passate gestione speciale - AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nRibsPathGrp, nOffsGrp) - else - AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nRibsPathGrp) + local nCrv1 = vRibsIds[i] -- curva principale che non viene tagliata + local nCrv2 = vRibsIds[j] -- curve secondaria da modificare + local nSplitOrder1 = EgtGetInfo( nCrv1, KEY_SPLIT_ORDER, 'i') or 0 + local nSplitOrder2 = EgtGetInfo( nCrv2, KEY_SPLIT_ORDER, 'i') or 0 + + if bForceCrv1Cut then + nCrv1, nCrv2 = nCrv2, nCrv1 + nSplitOrder1, nSplitOrder2 = nSplitOrder2, nSplitOrder1 + else + -- se stessa tipologia taglio il setto già splittato più volte, altrimenti taglio il setto che viene realizzato successivamente + if ( nType1 == nType2 and nSplitOrder1 > nSplitOrder2) or + ( nType1 ~= nType2 and vTypeSequence[nType1] > vTypeSequence[nType2]) then + nCrv1, nCrv2 = nCrv2, nCrv1 + nSplitOrder1, nSplitOrder2 = nSplitOrder2, nSplitOrder1 end end - EgtErase( nPtId) + + -- aggiorno tabella delle intersezioni + local bSaveSurf = false + if tInters[nCrv1] then + table.insert( tInters[nCrv1], nCrv2) + else + tInters[nCrv1] = {nCrv2} + -- è la prima volta che nCrv1 viene usata per un trim quindi devo salvare la superficie utilizzata + bSaveSurf = true + end + + -- aggiorno ordine di split + if nSplitOrder2 < nSplitOrder1 + 1 then + EgtSetInfo( nCrv2, KEY_SPLIT_ORDER, nSplitOrder1 + 1) + UpdateSplitOrder( nCrv2, tInters, nRibsPathGrp) + end + + if bAllTwoStrands and ( nType1 == nType2) then + -- nel caso di 2 passate e stessa tipologia gestione speciale per creare unico percorso + AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nRibsPathGrp) + bSpecialCase = true + else + AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nRibsPathGrp, bSaveSurf, nLoopGrp) + end end end end - EgtErase( nSrfOffs) + EgtErase( nSrfOffs1) + EgtErase( nSrfOffs2) + EgtErase( nGrpTmp) - return bInters + return bInters, bSpecialCase +end + +--------------------------------------------------------------------- +local function ReorderSplitRibs( vIds, dStrand, bParamInvertOrder) + + -- individuo i setti che derivano da uno stesso pezzo di costolatura + local tabRibs = {} + for i = 1, #vIds do + local nOrigId = EgtGetInfo( vIds[i], KEY_ORIGINAL_RIB, 'i') + if tabRibs[nOrigId] then + table.insert( tabRibs[nOrigId], vIds[i]) + else + tabRibs[nOrigId] = { vIds[i]} + end + end + + for k, tabVal in pairs( tabRibs) do + + -- verifico se split dopo intersezione con altro setto + local nSplitOrder = EgtGetInfo( tabVal[1], KEY_SPLIT_ORDER, 'i') or 0 + + -- verifico se split dopo aver fatto il trim con la superficie + local nStartRib = EgtGetInfo( tabVal[1], KEY_START_RIB, 'i') + local bSplitAfterTrim = EgtGetInfo( nStartRib, KEY_SPLIT_AFTER_TRIM, 'b') or false + + if nSplitOrder > 0 or bSplitAfterTrim then + -- caso di setti splittati + local nShells = EgtGetInfo( tabVal[1], KEY_RIBS_SHELLS_NBR, 'i') + if nShells == 1 then + -- non è necessario il riordino, associo splitId diversi ad ogni tratto per gestire correttamente il link nel CalcToolPath + for i = 1, #tabVal do + EgtSetInfo( tabVal[i], KEY_SPLIT_ID, i) + end + + else + -- associo le curve dello split + local tAssociatedRibs = {} + while #tabVal > 0 do + local nCurrId = tabVal[1] + table.remove( tabVal, 1) + table.insert( tAssociatedRibs, { nCurrId}) + local bCurrSplitAfterTrim = EgtGetInfo( nCurrId, KEY_SPLIT_AFTER_TRIM, 'b') or false + while nCurrId do + local ptCurr = EgtMP( nCurrId) + bFound = false + for j = 1, #tabVal do + local dDist1 = EgtPointCurveDist( ptCurr, tabVal[j]) + local dDist2 = EgtPointCurveDist( EgtMP( tabVal[j]), nCurrId) + if dDist1 < dStrand + 10 * GEO.EPS_SMALL or dDist2 < dStrand + 10 * GEO.EPS_SMALL then + + -- verifico nel caso di setti splittati dopo il trim che siano compatibili + local bUserLink = EgtGetInfo( tabVal[j], KEY_RIBS_USER_LINK, 'b') or false + local bSplitAfterTrim = EgtGetInfo( tabVal[j], KEY_SPLIT_AFTER_TRIM, 'b') or false + if bSplitAfterTrim ~= bCurrSplitAfterTrim then + if not bCurrSplitAfterTrim and bSplitAfterTrim then + local nOrd = EgtGetInfo( tabVal[j], KEY_SPLIT_AFTER_TRIM_ORDER, 'i') + if nOrd == 0 then + bFound = true + end + end + if bCurrSplitAfterTrim then + local nOrd = EgtGetInfo( nCurrId, KEY_SPLIT_AFTER_TRIM_ORDER, 'i') + local nTot = EgtGetInfo( nCurrId, KEY_SPLIT_AFTER_TRIM_TOT, 'i') + if nOrd == nTot - 1 then + bFound = true + end + end + else + bFound = true + end + + if bFound then + EgtRelocateGlob( tabVal[j], nCurrId, GDB_IN.AFTER) + nCurrId = tabVal[j] + bCurrSplitAfterTrim = bSplitAfterTrim + table.remove( tabVal, j) + table.insert( tAssociatedRibs[#tAssociatedRibs], nCurrId) + break + end + end + end + + if not bFound then + nCurrId = nil + end + end + end + + -- assegno splitid per gestire correttamente il link nel CalcToolPath + for i = 1, #tAssociatedRibs do + for j = 1, #tAssociatedRibs[i] do + EgtSetInfo( tAssociatedRibs[i][j], KEY_SPLIT_ID, i) + end + end + + -- modifiche per preservare i link definiti dall'utente + local bUserLink = EgtGetInfo( tAssociatedRibs[1][1], KEY_RIBS_USER_LINK, 'b') or false + if bUserLink and nShells % 2 == 0 then + + local nLinkOrder = EgtGetInfo( tAssociatedRibs[1][1], KEY_RIBS_USER_LINK_ORDER, 'i') or 0 + local nTotParts = EgtGetInfo( tAssociatedRibs[1][1], KEY_RIBS_USER_LINK_TOT, 'i') or 1 + local bInvertOrder = EgtGetInfo( tAssociatedRibs[1][1], KEY_RIBS_INVERT_STRAND_ORDER, 'b') or false + + -- ordinamento + if ( nTotParts % 2 == 0 and bInvertOrder and nLinkOrder % 2 ~= 0 ) or + ( nTotParts % 2 == 0 and not bInvertOrder and nLinkOrder % 2 == 0) or + ( nTotParts % 2 ~= 0 and nLinkOrder % 2 == 0) then + local vLastGrp = tAssociatedRibs[#tAssociatedRibs] + local nPrevId = vLastGrp[#vLastGrp] + for i = #tAssociatedRibs - 1, 1, -1 do + for j = 1, #tAssociatedRibs[i] do + local nCurrId = tAssociatedRibs[i][j] + EgtRelocateGlob( nCurrId, nPrevId, GDB_IN.AFTER) + nPrevId = nCurrId + end + end + end + + -- direzione + if ( nTotParts % 2 == 0 and nLinkOrder > 0 and nLinkOrder < nTotParts - 1) or + ( nTotParts % 2 ~= 0 and not bInvertOrder and nLinkOrder > 0) or + ( nTotParts % 2 ~= 0 and bInvertOrder and nLinkOrder < nTotParts - 1) then + local vLastGrp = tAssociatedRibs[#tAssociatedRibs] + for j = 1, #vLastGrp do + EgtInvertCurve( vLastGrp[j]) + UpdateInvertInfo( vLastGrp[j]) + end + end + end + end + end + end + end -------------------------------------------------------------------- --- Funzione che riordina le costolature nel caso generico -local function ReorderRibs( nGrp, bInvertOrder, dStrand, nMaxNbr) +local function ShortestPathForRibs( vRibs, nGrp, bInvertOrder) - EgtSpInit() - local vIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*') - if not vIds or #vIds == 0 then return end + if not vRibs or #vRibs == 0 then return end - local vSplitRibs = {} - local vSPRibs = {} - for i = 1, #vIds do - local nInfo = EgtGetInfo( vIds[i], KEY_SPLIT_RIB, 'i') - local nShells = EgtGetInfo( vIds[i], KEY_RIBS_SHELLS_NBR, 'i') - -- se è ottenuto dalla divisione di una costolatura non va considerato per il TSP ( viene aggiunto in seguito) - if nInfo and nShells == 1 then - table.insert( vSplitRibs, vIds[i]) + -- divido per gruppi di setti ( i gruppi sono identificati dallo stesso nome) + local tabRibs = {} + local sPrevName = "" + for i = 1, #vRibs do + local sName = EgtGetName( vRibs[i]) + if sName == sPrevName then + table.insert( tabRibs[#tabRibs], vRibs[i]) else - local pt = EgtMP( vIds[i], GDB_RT.GLOB) - EgtSpAddPoint( pt:getX(), pt:getY(), pt:getZ(), 0, 0, pt:getX(), pt:getY(), pt:getZ(), 0, 0) - table.insert( vSPRibs, vIds[i]) + table.insert( tabRibs, {vRibs[i]}) end + sPrevName = sName end - local vOrd, dLen = EgtSpCalculate( SHP_TY.OPEN) - EgtSpTerminate() - - EgtRelocateGlob( vSPRibs[vOrd[1]], nGrp, EgtIf( bInvertOrder, GDB_IN.LAST, GDB_IN.FIRST)) - for i = 2, #vOrd do - EgtRelocateGlob( vSPRibs[vOrd[i]], vSPRibs[vOrd[i-1]], EgtIf( bInvertOrder, GDB_IN.BEFORE, GDB_IN.AFTER)) + + -- stabilisco l'ordine di realizzazione dei gruppi di setti + local vOrd + if #tabRibs == 1 then + -- se un solo gruppo ordinamento banale + vOrd = {1} + else + -- se più gruppi ordinamento con shortest path + EgtSpInit() + for i = 1, #tabRibs do + local ptS = EgtSP( tabRibs[i][1], GDB_ID.ROOT) + local ptE = EgtEP( tabRibs[i][#tabRibs[i]], GDB_ID.ROOT) + EgtSpAddPoint( ptS:getX(), ptS:getY(), ptS:getZ(), 0, 0, ptE:getX(), ptE:getY(), ptE:getZ(), 0, 0) + end + vOrd = EgtSpCalculate( SHP_TY.OPEN) + EgtSpTerminate() end - -- sistemo nomi - local kMax = nMaxNbr + 1 - local dTol = 500 * GEO.EPS_SMALL - for i = 1, nMaxNbr do - local vIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. tostring(i)) or {} - for j = 2, #vIds do - local dDistS = EgtPointCurveDist( EgtSP( vIds[j]), vIds[j-1]) - local dDistM = EgtPointCurveDist( EgtMP( vIds[j]), vIds[j-1]) - local dDistE = EgtPointCurveDist( EgtEP( vIds[j]), vIds[j-1]) - if abs( dDistS - dStrand) < dTol or abs( dDistM - dStrand) < dTol or abs( dDistE - dStrand) < dTol then - -- se le costolatura è vicina alla precedente avrà lo stesso nome - EgtSetName( vIds[j], EgtGetName( vIds[j-1])) - EgtRelocateGlob( vIds[j], vIds[j-1], GDB_IN.AFTER) - else - -- se la costolatura dista troppo dalla precedente le cambio il nome - EgtSetName( vIds[j], RIBS_CRV .. tostring( kMax)) - kMax = kMax + 1 - end - end - end - - -- aggiusto tutte le costolature divise - for i = 1, #vSplitRibs do - local nPrevId = EgtGetInfo( vSplitRibs[i], KEY_SPLIT_RIB, 'i') - local bInverted = EgtGetInfo( vSplitRibs[i], KEY_INVERTED_CRV, 'b') or false - -- aggiungo come successiva alla costolatura da cui si è generata - EgtRelocateGlob( vSplitRibs[i], nPrevId, EgtIf( bInverted, GDB_IN.BEFORE, GDB_IN.AFTER)) - -- correggo le info per gestire correttamente nel calcolo toolpath - if bInverted then - EgtRemoveInfo( vSplitRibs[i], KEY_SPLIT_RIB) - EgtSetInfo( nPrevId, KEY_SPLIT_RIB, vSplitRibs[i]) + -- creo il vettore con i setti ordinati + local vIds = {} + local nStart = EgtIf( bInvertOrder, #vOrd, 1) + local nEnd = EgtIf( bInvertOrder, 1, #vOrd) + local nStep = EgtIf( bInvertOrder, -1, 1) + for i = nStart, nEnd, nStep do + local vCurrRibs = tabRibs[vOrd[i]] + for j = 1, #vCurrRibs do + table.insert( vIds, vCurrRibs[j]) end end + EgtRelocateGlob( vIds[1], nGrp, GDB_IN.LAST_SON) + for i = 2, #vIds do + EgtRelocateGlob( vIds[i], vIds[i-1], GDB_IN.AFTER) + end + end --------------------------------------------------------------------------------------------- -local function CopyInfo( nSouId, nDestId, sInfo, sType) - local info = EgtGetInfo( nSouId, sInfo, sType) - EgtSetInfo( nDestId, sInfo, info) +-------------------------------------------------------------------- +local function ReorderRibs( nGrp, bInvertOrder, dStrand) + + local vIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*') + if not vIds or #vIds == 0 then return end + + -- riordino setti splittati + ReorderSplitRibs( vIds, dStrand, bInvertOrder) + + -- aggiorno gli id con il nuovo ordinamento + vIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*') + + -- raggruppo per tipologia + local tRibs = {{}, {}, {}, {}} + for i = 1, #vIds do + local nType = EgtGetInfo( vIds[i], KEY_RIBS_TYPE, 'i') + table.insert( tRibs[nType], vIds[i]) + end + + -- riordino ogni tipologia + for j = 1, 4 do + local vIds = tRibs[j] + + -- raggruppo in base allo split order + local tSplitOrder = {} + local nMaxSplitOrder = 0 + for i = 1, #vIds do + local nSplitOrder = EgtGetInfo( vIds[i], KEY_SPLIT_ORDER, 'i') or 0 + -- eventuale aggiornamento del max split order + if nSplitOrder > nMaxSplitOrder then nMaxSplitOrder = nSplitOrder end + -- inserisco nella tabella + if not tSplitOrder[nSplitOrder] then + tSplitOrder[nSplitOrder]= {vIds[i]} + else + table.insert( tSplitOrder[nSplitOrder], vIds[i]) + end + end + + -- riordino ogni ordine di split con shortest path + for k = 0, nMaxSplitOrder do + ShortestPathForRibs( tSplitOrder[k], nGrp, bInvertOrder) + end + end end -------------------------------------------------------------------------------------------- local function ReassignInfo( nCrv, nCnt, vOrig) - for nId = nCrv, nCrv + nCnt - 1 do + for nId = nCrv, nCrv + nCnt - 1 do local ptS = EgtSP( nId) local ptE = EgtEP( nId) - -- info overlap - local nOverlap = EgtGetInfo( s_nPartId, KEY_RIBS_OVERLAP, 'i') - EgtSetInfo( nId, KEY_RIBS_OVERLAP, nOverlap) + EgtSetInfo( nId, KEY_TYPE, TYPE.RIB) + if EgtCurveIsClosed( nId) then + EgtSetInfo( nId, KEY_CLOSED_CRV, 1) + end local bStart = false local bEnd = false @@ -632,6 +1268,8 @@ local function ReassignInfo( nCrv, nCnt, vOrig) CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_IN_INVERT, 'b') CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_IN_LEN, 'd') CopyInfo( vOrig[i], nId, KEY_ASSOCIATED_SURF, 'i') + CopyInfo( vOrig[i], nId, KEY_RIBS_OVERLAP, 'i') + CopyInfo( vOrig[i], nId, KEY_RIBS_TYPE, 'i') bStart = true end -- verifico se corrisponde al suo end @@ -655,9 +1293,39 @@ end --------------------------------------------------------------------------------------------- -- Funzione che riordina le costolature nel caso di intersezioni e 2 passate -local function ReorderRibsInters2Shells( nOffsGrp, dStrand) +local function ReorderRibsInters2Shells( nOffsGrp, dStrand, bInvertOrder) - local vOffs = EgtGetNameInGroup( nOffsGrp, RIBS_CRV .. '*') + local vOffs = {} + local vClosed = {} + local nId = EgtGetFirstNameInGroup( nOffsGrp, RIBS_CRV .. '*') + while nId do + if EgtCurveIsClosed( nId) then + table.insert( vClosed, nId) + else + table.insert( vOffs, nId) + end + nId = EgtGetNextName( nId, RIBS_CRV .. '*') + end + + local k = 0 -- indice da utilizzare per i nomi + + -- gestione delle curve chiuse + if #vClosed > 0 then + k = k + 1 + local sPrevName = EgtGetName( vClosed[1]) + EgtSetName( vClosed[1], RIBS_CRV .. tostring( k)) + for i = 2, #vClosed do + local sCurrName = EgtGetName( vClosed[i]) + -- se setto diverso aggiorno il nome + if sCurrName ~= sPrevName then + k = k + 1 + end + EgtSetName( vClosed[i], RIBS_CRV .. tostring( k)) + sPrevName = sCurrName + end + end + + -- gestione delle curve aperte -- copio le curve originali ( per recuperarne le info) local vCopy = {} for i = 1, #vOffs do @@ -667,14 +1335,13 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand) -- concateno le curve local nCrv, nCnt = EgtCurveCompoByChain( nOffsGrp, vOffs, ORIG()) - local vIds = {} for i = nCrv, nCrv + nCnt - 1 do - EgtSetInfo( i, KEY_TYPE, TYPE.RIB) table.insert( vIds, i) end - - local k = 0 -- indice da utilizzare per i nomi + -- recupero le info dalle curve originali + ReassignInfo( nCrv, nCnt, vCopy) + while #vIds > 0 do k = k + 1 -- prendo la prima tra le curve a disposizione @@ -686,9 +1353,12 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand) local nCnt = 0 -- scorro alla ricerca di una curva che posso collegare alla corrente while nCurrCrv do + local nCurrType = EgtGetInfo( nCurrCrv, KEY_RIBS_TYPE, 'i') local bFound = false for j = 1, #vIds do - if vIds[j] ~= nCrv and not EgtCurveIsClosed(vIds[j]) then + local nType = EgtGetInfo( vIds[j], KEY_RIBS_TYPE, 'i') + + if vIds[j] ~= nCrv and not EgtCurveIsClosed(vIds[j]) and nCurrType == nType then -- verifico se il collegamento è possibile local bAdd = false @@ -715,7 +1385,7 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand) if dParE - dParMinDist < 500 * GEO.EPS_SMALL then bAdd = true -- altrimenti può essere vicino allo start - elseif dParMinDist < 500 * GEO.EPS_SMALL and nCnt == 0 then + elseif dParMinDist < 500 * GEO.EPS_SMALL and nCnt == 0 then bAdd = true EgtInvertCurve( nCurrCrv) end @@ -735,7 +1405,7 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand) end end - if bAdd then + if bAdd then bFound = true nCnt = nCnt + 1 EgtRelocateGlob( vIds[j], nCurrCrv, GDB_IN.AFTER) @@ -764,44 +1434,51 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand) end end end + + -- eventuale inversione ordinamento + if bInvertOrder then + local vRibs = EgtGetNameInGroup( nOffsGrp, RIBS_CRV .. '*') + for j = #vRibs, 1, -1 do + -- inverto direzione curve per mantenere concatenamento + EgtInvertCurve( vRibs[j]) + EgtRelocateGlob( vRibs[j], nOffsGrp, GDB_IN.LAST_SON) + end + end - -- Recupero le info dalle curve originali - ReassignInfo( nCrv, nCnt, vCopy) end --------------------------------------------------------------------- -local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nIdx, nMaxStrandDiff) +------------------------------------------------------------------- +local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nIdx, vPtStart) - local vRibs = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') + -- stabilisco ordine di realizzazione delle varie tipologie + local vTypeSequence = {} + for i = 1, #LayerParams.vPrintOrder do + if LayerParams.vPrintOrder[i] == PRINT_ELEMENT.RIB_UNBOUNDED then + vTypeSequence[RIB_TYPE.UNBOUNDED] = i + elseif LayerParams.vPrintOrder[i] == PRINT_ELEMENT.RIB_INTERNAL then + vTypeSequence[RIB_TYPE.INTERNAL] = i + elseif LayerParams.vPrintOrder[i] == PRINT_ELEMENT.RIB_EXTERNAL then + vTypeSequence[RIB_TYPE.EXTERNAL] = i + elseif LayerParams.vPrintOrder[i] == PRINT_ELEMENT.RIB_SUPPORT then + vTypeSequence[RIB_TYPE.SUPPORT] = i + end + end + + local vOrigRibs = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') -- verifico se tutte le costolature vengono fatte con 2 passate local bAllTwoStrands = true - for i = 1, #vRibs do - local nStrand = EgtGetInfo( vRibs[i], KEY_RIBS_SHELLS_NBR, 'i') + for i = 1, #vOrigRibs do + local nStrand = EgtGetInfo( vOrigRibs[i], KEY_RIBS_SHELLS_NBR, 'i') if nStrand ~= 2 then bAllTwoStrands = false break end end - local nLast = EgtGetLastNameInGroup( nRibsGrp, RIBS_CRV .. '*') - local sLastName = EgtGetName( nLast) - local nMaxNbr = tonumber( string.sub( sLastName, 4)) + -- verifico se posso ignorare eventuali buchi nei setti + VerifyRibsHoles( vOrigRibs, LayerParams.dStrand) - -- calcolo gli offset - local nOffsGrp = EgtGroup( nRibsGrp) - for i = 1, #vRibs do - local nShellsNbr = EgtGetInfo( vRibs[i], KEY_RIBS_SHELLS_NBR, 'i') - local dOffs = ( nShellsNbr - 1) * LayerParams.dStrand / 2 - for k = 0, nShellsNbr - 1 do - local nNewId = EgtOffsetCurveAdv( vRibs[i], - dOffs + k * LayerParams.dStrand) - EgtSetName( nNewId, EgtGetName( vRibs[i])) - EgtSetInfo( nNewId, KEY_TYPE, TYPE.RIB) - EgtRelocateGlob( nNewId, nOffsGrp) - end - end - -- scorro i gruppi di curve - local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs + ( LayerParams.nShellsNbr - 1) * LayerParams.dStrand local nCrvGrp = EgtGetFirstNameInGroup( nSliceGrp, CONTOUR_GRP .. '*') while nCrvGrp do @@ -815,84 +1492,120 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nIdx, nMaxStrand EgtEmptyGroup( nRibsPathGrp) end - -- creo le superfici con cui fare i trim - local nSrfBase = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF) - if not nSrfBase then - EgtOutLog( 'Warning : Ribs not possible (layer '..tostring( nIdx)..') - CalcPaths') - else - local vSurfOffs = ComputeTrimSurfWithOverlaps( vRibs, nSrfBase, KEY_RIBS_OVERLAP, LayerParams.dStrand, nRibsPathGrp) - - -- gestisco eventuali intersezioni fra costolature - local bInters = HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, bAllTwoStrands) - EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_INTERS, bInters) - EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_TWO_STRANDS, bAllTwoStrands) - - -- eseguo il trim delle costole con la regione offsettata - local tOldNewIds = {} - local vOrderedRibs = EgtGetNameInGroup( nRibsPathGrp, RIBS_CRV ..'*') - for i = 1, #vOrderedRibs do - -- trim con superficie opportuna - local nOverlap = EgtGetInfo( vOrderedRibs[i], KEY_RIBS_OVERLAP, 'i') - if not vSurfOffs[ nOverlap] then - -- la costolatura non è fattibile - EgtOutLog( 'Warning: Ribs not possibile (layer '..tostring( nIdx)..') - CalcPaths') - EgtErase( vOrderedRibs[i]) - else - local nCrv, nCnt = EgtTrimCurveWithRegion( vOrderedRibs[i], vSurfOffs[nOverlap], true, false) - tOldNewIds[ vOrderedRibs[i]] = {} - - -- elimino tratti troppo corti - for nInd = 0, nCnt - 1 do - local dLen = EgtCurveLength( nCrv + nInd) - if dLen < MIN_RIBS_LEN then - EgtErase( nCrv + nInd) - else - table.insert( tOldNewIds[ vOrderedRibs[i]], nCrv + nInd) - - -- controllo la direzione (consideriamo inclinazione solo lungo X) - local vtDir = EgtMV( nCrv + nInd) - local dXl = sqrt( sqr( vtDir:getX()) + sqr( vtDir:getZ())) - local dYl = abs( vtDir:getY()) - local dVal = EgtIf( dXl > dYl - GEO.EPS_SMALL, vtDir:getX(), vtDir:getY()) - if dVal < - GEO.EPS_SMALL then - EgtInvertCurve( nCrv + nInd) - EgtSetInfo( nCrv + nInd, KEY_INVERTED_CRV, 1) - end - - -- salvo info della superficie di trim associata - EgtSetInfo( nCrv + nInd, KEY_ASSOCIATED_SURF, vSurfOffs[nOverlap]) - - if nInd == 0 then - -- aggiorno la info - local nInfo = EgtGetInfo( nCrv + nInd, KEY_SPLIT_RIB, 'i') - if nInfo then - -- aggiorno info - if #tOldNewIds[nInfo] > 0 then - local nLast = #tOldNewIds[nInfo] - EgtSetInfo( nCrv + nInd, KEY_SPLIT_RIB, tOldNewIds[nInfo][nLast]) - else - -- se la costolatura da cui deriva è stata eliminata, tolgo l'info che le associava - EgtRemoveInfo( nCrv + nInd, KEY_SPLIT_RIB) - end - end - end - end - end + -- recupero le superfici + local nSrfBase = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF) or GDB_ID.NULL + local nSrfExt = EgtGetFirstNameInGroup( nCrvGrp, LAYER_SRF) or GDB_ID.NULL + + -- trim grossolano dei setti + local nTrimGrp = TrimRibs( vOrigRibs, nRibsGrp, nSrfExt, LayerParams.dOffs - LayerParams.dStrand / 2, LayerParams.vtSlicing) + + -- calcolo offset orientati + local nOffsGrp = ComputeRibsOrientedOffset( nTrimGrp, LayerParams.dStrand) + + -- creo le superfici con cui fare i trim corretti + local tSurfOffs = ComputeTrimSurfWithOverlapsForRibs( vOrigRibs, nSrfBase, nSrfExt, LayerParams.dOffs, LayerParams.dStrand, nRibsPathGrp, LayerParams.vtSlicing) + + -- preparo il gruppo con i contorni delle superfici di offset ( necessario per CalcToolPath) + local nLoopGrp = EgtGroup( nRibsPathGrp) + local nSrfId = EgtGetFirstNameInGroup( nRibsPathGrp, TOT_SHELL_TRIM_SURF) + while nSrfId do + local nChunksNbr = EgtSurfFrChunkCount( nSrfId) + for i = 0, nChunksNbr - 1 do + local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfId, i, nLoopGrp) + for j = nRes, nRes + nCnt - 1 do + EgtSetName( j, TRIM_SURF_LOOP) end end + nSrfId = EgtGetNextName( nSrfId, TOT_SHELL_TRIM_SURF) + end + + -- gestisco eventuali intersezioni fra costolature + local bInters, bSpecialCase = HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, nLoopGrp, bAllTwoStrands, vTypeSequence) + EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_INTERS, bInters) + EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_SPECIAL_CASE, bSpecialCase) - -- riordino le costolature - if bAllTwoStrands and bInters then - -- gestione caso speciale di intersezione e 2 passate - ReorderRibsInters2Shells( nRibsPathGrp, LayerParams.dStrand) + -- trim dei setti con le regioni offsettate secondo opportuno overlap + local vRibs = EgtGetNameInGroup( nRibsPathGrp, RIBS_CRV ..'*') or {} + for i = 1, #vRibs do + local nCrvId = vRibs[i] + -- trim con superficie opportuna + local nOverlap = EgtGetInfo( nCrvId, KEY_RIBS_OVERLAP, 'i') + local nType = EgtGetInfo( nCrvId, KEY_RIBS_TYPE, 'i') + if not tSurfOffs[nType][nOverlap] then + -- la costolatura non è fattibile + EgtOutLog( 'Warning: Ribs not possibile (layer '..tostring( nIdx)..') - CalcPaths') + EgtErase( vRibs[i]) else - ReorderRibs( nRibsPathGrp, LayerParams.bRibsInvertOrder, LayerParams.dStrand, nMaxNbr) + local nCrv, nCnt + if tSurfOffs[nType][nOverlap] == GDB_ID.NULL then + -- caso unbounded o esterno in assenza di solido + nCrv = nCrvId + nCnt = 1 + else + nCrv, nCnt = EgtTrimCurveWithRegion( nCrvId, tSurfOffs[nType][nOverlap], EgtIf( nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT, true, false), false) + end + + for nInd = 0, nCnt - 1 do + -- verifico vicolo sulla lunghezza + local dLen = EgtCurveLength( nCrv + nInd) + if dLen < MIN_RIBS_LEN then + EgtErase( nCrv + nInd) + else + + -- salvo info della superficie di trim associata + EgtSetInfo( nCrv + nInd, KEY_ASSOCIATED_SURF, tSurfOffs[nType][nOverlap]) + + -- setti chiusi + if EgtCurveIsClosed( nCrv + nInd) then + EgtSetInfo( nCrv + nInd, KEY_CLOSED_CRV, 1) + + -- ripristino orientamento originale + local bInvertInfo = EgtGetInfo( nCrv + nInd, KEY_RIBS_INVERT_DIR, 'b') or false + local bInverted = EgtGetInfo( nCrv + nInd, KEY_INVERTED_CRV, 'b') or false + if bInvertInfo ~= bInverted then + EgtInvertCurve( nCrv + nInd) + UpdateInvertInfo( nCrv + nInd) + end + + ModifyStartPoint( nCrv + nInd, vPtStart) + EgtSetInfo( nCrv + nInd, KEY_RIBS_LINK, 0) + end + + -- se dopo trim ho avuto split in più tratti, salvo alcune info + if nCnt > 1 then + local nStartRib = EgtGetInfo( nCrv + nInd, KEY_START_RIB, 'i') + EgtSetInfo( nStartRib, KEY_SPLIT_AFTER_TRIM, 1) + EgtSetInfo( nCrv + nInd, KEY_SPLIT_AFTER_TRIM, 1) + EgtSetInfo( nCrv + nInd, KEY_SPLIT_AFTER_TRIM_ORDER, nInd) + EgtSetInfo( nCrv + nInd, KEY_SPLIT_AFTER_TRIM_TOT, nCnt) + end + end + end end end - if not EgtGetFirstNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') then - EgtErase( nRibsPathGrp) + -- riordino le costolature + if bSpecialCase then + -- gestione caso speciale di intersezione e 2 passate + ReorderRibsInters2Shells( nRibsPathGrp, LayerParams.dStrand, LayerParams.bRibsInvertOrder) + else + ReorderRibs( nRibsPathGrp, LayerParams.bRibsInvertOrder, LayerParams.dStrand) end + + if not EgtGetFirstNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') then + EgtErase( nRibsPathGrp) + end + + -- sistemo le quote delle superfici e dei loop per CalcToolPath + local vLoopIds = EgtGetAllInGroup( nLoopGrp) or {} + for i = 1, #vLoopIds do + EgtMove( vLoopIds[i], LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) + end + local vSrfIds = EgtGetNameInGroup( nRibsPathGrp, TOT_SHELL_TRIM_SURF) or {} + for i = 1, #vSrfIds do + EgtMove( vSrfIds[i], LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) + end + nCrvGrp = EgtGetNextName( nCrvGrp, CONTOUR_GRP .. '*') end end @@ -940,12 +1653,15 @@ local function CreateShellNbrSurfaces( nGrp, nShellsNbr) end end -- costruisco la surf - local nSrfId, nCnt = EgtSurfFlatRegion( nSrfGrp, vCrvIds) - for nIdSrf = nSrfId + 1, nSrfId + nCnt - 1 do - EgtSurfFrAdd( nSrfId, nIdSrf) - EgtErase( nIdSrf) + local nSrfId = EgtSurfFlatRegion( nSrfGrp, vCrvIds[1]) + for i = 2, #vCrvIds do + local nSrfTmp = EgtSurfFlatRegion( nSrfGrp, vCrvIds[i]) + EgtSurfFrAdd( nSrfId, nSrfTmp) + EgtErase( nSrfTmp) end EgtSetName( nSrfId, SHELL_NBR_SURF .. tostring( nDiff)) + -- salvo come info gli id delle curve che la definiscono + EgtSetInfo( nSrfId, KEY_ASSOCIATED_CRVS, vCrvIds) end end @@ -958,7 +1674,7 @@ local function ComputeMaxShellNbrDiff( nSrf, nShellNbrSurfGrp) local nShellNbrSrf = EgtGetFirstNameInGroup( nShellNbrSurfGrp, SHELL_NBR_SURF .. tostring( nId)) while nShellNbrSrf do -- se interessa la regione considerata aggiorno il nMaxShellNbrDiff - if not EgtSurfFrTestExternal( nSrf, nShellNbrSrf) then + if not EgtSurfFrTestExternal( nSrf, nShellNbrSrf) then nMaxShellNbrDiff = nId end @@ -971,10 +1687,69 @@ local function ComputeMaxShellNbrDiff( nSrf, nShellNbrSurfGrp) return nMaxShellNbrDiff end +---------------------------------------------------------------- +local function FindExtraShellRetractionParams( ptP, vIds, LayerParams) + + local dCoasting, dWipe, dWipeDir + -- cerco la curva sulla quale si ferma + for i = 1, #vIds do + local dPar = EgtCurveParamAtPoint( vIds[i], ptP, 10 * GEO.EPS_SMALL) + if dPar then + dCoasting = EgtGetInfo( vIds[i], KEY_SHELL_NBR_COASTING, 'd') + dWipe = EgtGetInfo( vIds[i], KEY_SHELL_NBR_WIPE, 'd') + dWipeDir = EgtGetInfo( vIds[i], KEY_SHELL_NBR_WIPE_DIR, 'd') + break + end + end + + if not dCoasting then + -- se non ho trovato una curva considero i parametri generali + return LayerParams.dShellNbrCoasting, LayerParams.dShellNbrWipe, LayerParams.dShellNbrWipeDir + else + return dCoasting, dWipe, dWipeDir + end +end + +----------------------------------------------------------------- +local function TrimOuterCurveForExtraShellCalc( nOuterCrv, nSrfDiff, nGrpId, vPtStart, LayerParams) + + local nCopy = EgtCopyGlob( nOuterCrv, nGrpId) + ModifyStartPoint( nCopy, vPtStart) + -- recupero tutte le curve delle ShellNumber coinvolte + local vShellNbrCrvs = EgtGetInfo( nSrfDiff, KEY_ASSOCIATED_CRVS, 'vi') + + -- trim della curva + local nCrv, nCnt = EgtTrimCurveWithRegion( nCopy, nSrfDiff, false, false) + if nCrv and nCnt ~= 0 then + + -- verifico se prima e ultima curva possono essere unite + if nCnt > 1 and AreSamePointApprox( EgtEP( nCrv + nCnt - 1), EgtSP( nCrv)) then + EgtRelocateGlob( nCrv + nCnt - 1, nCrv, GDB_IN.AFTER) + EgtAddCurveCompoCurve( nCrv + nCnt - 1, nCrv) + EgtChangeId( nCrv + nCnt - 1, nCrv) + nCnt = nCnt - 1 + end + + -- assegno le info in base alla curva che li delimita + for nId = nCrv, nCrv + nCnt - 1 do + local ptS = EgtSP( nId) + local dCoastingS, dWipeS, dWipeDirS = FindExtraShellRetractionParams( ptS, vShellNbrCrvs, LayerParams) + local ptE = EgtEP( nId) + local dCoastingE, dWipeE, dWipeDirE = FindExtraShellRetractionParams( ptE, vShellNbrCrvs, LayerParams) + EgtSetInfo( nId, KEY_EXTRA_SHELL_COASTING, {dCoastingS, dCoastingE}) + EgtSetInfo( nId, KEY_EXTRA_SHELL_WIPE, {dWipeS, dWipeE}) + EgtSetInfo( nId, KEY_EXTRA_SHELL_WIPE_DIR, {dWipeDirS, dWipeDirE}) + end + return nCrv, nCnt + else + return nOuterCrv, 0 + end +end + -------------------------------------------------------------------- local function UpdateTotalShellSurf( nSrf, nCrv, dStrand, nGrpId) - local nSrfExtraShell = EgtSurfFrFatCurve( nGrpId, nCrv, dStrand - s_dOffsCorr, false) + local nSrfExtraShell = EgtSurfFrFatCurve( nGrpId, nCrv, dStrand - s_dOffsCorr, false) if nSrfExtraShell then local vtSrfN = EgtSurfFrNormVersor( nSrf, GDB_ID.ROOT) local vtSrfExShN = EgtSurfFrNormVersor( nSrfExtraShell, GDB_ID.ROOT) @@ -1022,7 +1797,7 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert) if bPrintInvert then for i = 1, #vIds do EgtInvertCurve( vIds[i]) - EgtSetInfo( vIds[i], KEY_INVERTED_CRV, 1) + UpdateInvertInfo( vIds[i]) end end @@ -1050,7 +1825,7 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert) local bFound = false for j = 1, #vIds do - if not EgtCurveIsClosed( vIds[j]) then + if not EgtCurveIsClosed( vIds[j]) then local ptS = EgtSP( vIds[j]) local ptE = EgtEP( vIds[j]) @@ -1104,74 +1879,70 @@ local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, d end for nInd = nMaxShellNbrDiff, 1, -1 do - dOffs = dOffs + LayerParams.dStrand + dOffs = dOffs + LayerParams.dStrand * ( 1 - EgtIf( nInd == LayerParams.nShellsNbr, 0, LayerParams.nStrandOverlap / 100)) local nSrfDiff = EgtGetFirstNameInGroup( nShellNbrGrp, SHELL_NBR_SURF .. tostring( nInd)) local nOuterCrv = EgtGetFirstNameInGroup( nCrvGrpId, OUTER_CRV) while nOuterCrv do - local nCopy = EgtCopyGlob( nOuterCrv, nGrpId) - ModifyStartPoint( nCopy, vPtStart) + -- trim della curva con la superficie + local nTrimCrv, nTrimCnt = TrimOuterCurveForExtraShellCalc( nOuterCrv, nSrfDiff, nGrpId, vPtStart, LayerParams) - -- trim della curva con la regione con diverso numero di passate - local nTrimCrv, nTrimCnt = EgtTrimCurveWithRegion( nCopy, nSrfDiff, false, false) - if nTrimCnt ~= 0 then - -- verifico se prima e ultima curva possono essere unite - if nTrimCnt > 1 and AreSamePointApprox( EgtEP( nTrimCrv + nTrimCnt - 1), EgtSP( nTrimCrv)) then - local nNewId = EgtCurveCompo( nGrpId, { nTrimCrv + nTrimCnt - 1, nTrimCrv}) - EgtChangeId( nNewId, nTrimCrv) - nTrimCnt = nTrimCnt - 1 - end - - for nCrvT = nTrimCrv, nTrimCrv + nTrimCnt - 1 do - -- calcolo offset della curva ( è il percorso della shell) - EgtModifyCurveExtrusion( nCrvT, LayerParams.vtSlicing) - local nOffs, nOffsCnt = EgtOffsetCurveAdv( nCrvT, - dOffs) - EgtErase( nCrvT) - for nCrvOffs = nOffs, nOffs + nOffsCnt - 1 do - -- trim con la regione già occupata dal altre shell - local nCrv, nCnt = EgtTrimCurveWithRegion( nCrvOffs, nSrfTrim, true, true) - if nCrv and nCnt ~= 0 then - for nId = nCrv, nCrv + nCnt - 1 do - local dLen = EgtCurveLength( nId) - local bValid = true - if EgtCurveIsClosed( nId) then - bValid = VerifyPath( nId, LayerParams.dStrand, LayerParams.vtSlicing, nGrpId) - end - -- verifico se soddisfa vincolo sulla lunghezza - if dLen > MIN_LEN and bValid then - EgtModifyCurveExtrusion( nId, LayerParams.vtSlicing) - EgtSetName( nId, EXTRA_SHELL_CRV .. tostring( nMaxShellNbrDiff - nInd + 1)) - if nInd == LayerParams.nShellsNbr then - EgtSetInfo( nId, KEY_TYPE, TYPE.EXTRA_OUTER_SHELL) - else - EgtSetInfo( nId, KEY_TYPE, TYPE.EXTRA_SHELL) - end - - -- aggiorno la superficie occupata dalle shell con quella appena calcolata - UpdateTotalShellSurf( nSrfTrim, nId, LayerParams.dStrand, nGrpId) - -- se la superficie si annulla non è possibile realizzare altro, quindi cancello tutte le curve rimaste - if EgtSurfFrChunkCount( nSrfTrim) == 0 then - for j = nId + 1, nCrv + nCnt - 1 do - EgtErase( j) - end - for j = nCrvT + 1, nTrimCrv + nTrimCnt - 1 do - EgtErase( j) - end - ReorderExtraShells( nGrpId, LayerParams.dStrand, vPtStart, LayerParams.bPrintInvert) - return - end + for nCrvT = nTrimCrv, nTrimCrv + nTrimCnt - 1 do + -- calcolo offset della curva ( è il percorso della shell) + EgtModifyCurveExtrusion( nCrvT, LayerParams.vtSlicing, GDB_RT.GLOB) + local nOffs, nOffsCnt = EgtOffsetCurveAdv( nCrvT, - dOffs) + EgtErase( nCrvT) + for nCrvOffs = nOffs, nOffs + nOffsCnt - 1 do + -- trim con la regione già occupata dal altre shell + local nCrv, nCnt = EgtTrimCurveWithRegion( nCrvOffs, nSrfTrim, true, true) + if nCrv and nCnt ~= 0 then + for nId = nCrv, nCrv + nCnt - 1 do + local dLen = EgtCurveLength( nId) + local bValid = true + if EgtCurveIsClosed( nId) then + bValid = VerifyPath( nId, LayerParams.dStrand, LayerParams.vtSlicing, nGrpId) + end + -- verifico se soddisfa vincolo sulla lunghezza + if dLen > MIN_LEN and bValid then + EgtSetStatus( nId, GDB_ST.ON) + EgtModifyCurveExtrusion( nId, LayerParams.vtSlicing, GDB_RT.GLOB) + EgtSetName( nId, EXTRA_SHELL_CRV .. tostring( nMaxShellNbrDiff - nInd + 1)) + if nInd == LayerParams.nShellsNbr then + EgtSetInfo( nId, KEY_TYPE, TYPE.EXTRA_OUTER_SHELL) else - EgtErase( nId) + EgtSetInfo( nId, KEY_TYPE, TYPE.EXTRA_SHELL) end + + -- aggiorno la superficie occupata dalle shell con quella appena calcolata (tenendo conto dell'overlap) + UpdateTotalShellSurf( nSrfTrim, nId, ( 1 - LayerParams.nStrandOverlap / 100) * LayerParams.dStrand, nGrpId) + -- se la superficie si annulla non è possibile realizzare altro, quindi cancello tutte le curve rimaste + if EgtSurfFrChunkCount( nSrfTrim) == 0 then + for j = nId + 1, nCrv + nCnt - 1 do + EgtErase( j) + end + for j = nCrvT + 1, nTrimCrv + nTrimCnt - 1 do + EgtErase( j) + end + -- aggiorno superficie + EgtSurfFrOffset( nSrfTrim, - LayerParams.nStrandOverlap / 100 * LayerParams.dStrand) + -- riordino le curve appena create e se possibile creo percorsi chiusi + ReorderExtraShells( nGrpId, LayerParams.dStrand, vPtStart, LayerParams.bPrintInvert) + return + end + else + EgtErase( nId) end end end end end + nOuterCrv = EgtGetNextName( nOuterCrv, OUTER_CRV) end end + -- aggiorno superificie + EgtSurfFrOffset( nSrfTrim, - LayerParams.nStrandOverlap / 100 * LayerParams.dStrand) -- riordino le curve appena create e se possibile creo percorsi chiusi ReorderExtraShells( nGrpId, LayerParams.dStrand, vPtStart, LayerParams.bPrintInvert) @@ -1180,10 +1951,10 @@ end -------------------------------------------------------------------- ------------------ AUX SOLIDS ------------------------------------- -------------------------------------------------------------------- -local function UpdateTrimSurfWithAuxSolidsOffset( nSrfSolid, nSrfBase, dStrand, nCrvGrp) +local function UpdateTrimSurfWithAuxSolidsOffset( nSrfSolid, nSrfBase, dStrand, nCrvGrp, vtSlicing) -- offset della superifice del solido - local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfSolid, nCrvGrp, dStrand) + local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfSolid, nCrvGrp, dStrand, vtSlicing) if nSrfOffs then EgtSurfFrSubtract( nSrfBase, nSrfOffs) EgtErase( nSrfOffs) @@ -1262,23 +2033,23 @@ end local function AddExtraZigZag( nSrf, sName, dStrand, vtSlicing, nGrp, nSrfTrim) local vIds = EgtGetNameInGroup( nGrp, sName) - local vtDir = EgtSV( vIds[1]) + local vtDir = EgtSV( vIds[1], GDB_ID.ROOT) local vtYLoc = vtSlicing ^ vtDir local nOuterLoop = EgtExtractSurfFrChunkLoops( nSrf, 0, nGrp) for i = 1, #vIds do local _, dParE = EgtCurveDomain( vIds[i]) - local ptS = EgtUP( vIds[i], dParE - 1) + dStrand * vtYLoc - local ptE = EgtEP( vIds[i]) + dStrand * vtYLoc - local nExtraCrv = EgtLine( nGrp, ptS, ptE) + local ptS = EgtUP( vIds[i], dParE - 1, GDB_ID.ROOT) + dStrand * vtYLoc + local ptE = EgtEP( vIds[i], GDB_ID.ROOT) + dStrand * vtYLoc + local nExtraCrv = EgtLine( nGrp, ptS, ptE, GDB_RT.GLOB) -- verifico se la linea aggiuntiva serve local dDist = EgtPointCurveDist( EgtMP( nExtraCrv), nOuterLoop) if dDist < dStrand - 1 then -- verifico se si trova nella regione ammissibile if EgtCurveWithRegionClassify( nExtraCrv, nSrfTrim) == GDB_CRC.IN then EgtInvertCurve( nExtraCrv) - EgtAddCurveCompoLine( vIds[i], ptE) + EgtAddCurveCompoLine( vIds[i], ptE, GDB_RT.GLOB) EgtAddCurveCompoCurve( vIds[i], nExtraCrv) end end @@ -1313,7 +2084,7 @@ local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart) if not nSrfBase then EgtOutLog( 'Warning : AuxSolids not possible (layer '..tostring( nIdx)..') - CalcPaths') else - local vSurfOffs = ComputeTrimSurfWithOverlaps( vSolidIds, nSrfBase, KEY_AUX_SOLIDS_OVERLAP, LayerParams.dStrand, nSolidPathGrp) + local vSurfOffs = ComputeTrimSurfWithOverlaps( vSolidIds, nSrfBase, KEY_AUX_SOLIDS_OVERLAP, LayerParams.dStrand, nSolidPathGrp, LayerParams.vtSlicing) for i = 1, #vSolidIds do -- creo la flat region corrispondente al solido ausiliario @@ -1331,7 +2102,7 @@ local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart) if nInfillType == INFILL_TYPE.OFFSET then ComputeOffsetInfill( nFirst + j, LayerParams.dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, vPtStart, nSolidPathGrp) -- aggiorno la trim surf - UpdateTrimSurfWithAuxSolidsOffset( nFirst + j, nSrfBase, LayerParams.dStrand, nSolidPathGrp) + UpdateTrimSurfWithAuxSolidsOffset( nFirst + j, nSrfBase, LayerParams.dStrand, nSolidPathGrp, LayerParams.vtSlicing) else ComputeZigZagInfill( nFirst + j, LayerParams.dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, vPtStart, nSolidPathGrp) -- aggiungo eventuale passata extra @@ -1350,7 +2121,7 @@ local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart) -- verifico se il gruppo contine qualcosa if not EgtGetFirstNameInGroup( nSolidPathGrp, AUX_SOLIDS_CRV .. '*') then - EgtErase( nSolidPathGrp) + EgtErase( nSolidPathGrp) end -- passo al gruppo di contorni successivo @@ -1363,10 +2134,10 @@ function CalcPaths.Exec( nPartId) s_nPartId = nPartId - local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*") + local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*") if not vLayIds then EgtOutBox( 'Error no slice', 'PathCalc') - return + return true end -- recupero i parametri per calcolo dei path @@ -1390,7 +2161,7 @@ function CalcPaths.Exec( nPartId) local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[nIdx], CONTOUR_GRP.."*") or GDB_ID.NULL while nCrvGrpId ~= GDB_ID.NULL do - -- verifico se il path e il solido sono già stati calcolati + -- verifico se il path è già stato calcolato local nGrpId = EgtGetFirstNameInGroup( nCrvGrpId, PATH_GRP) or GDB_ID.NULL if nGrpId == GDB_ID.NULL then nGrpId = EgtGroup( nCrvGrpId) @@ -1399,10 +2170,6 @@ function CalcPaths.Exec( nPartId) EgtEmptyGroup( nGrpId) EgtSetStatus( nGrpId, GDB_ST.ON) end - local nSolidGrpId = EgtGetFirstNameInGroup( nCrvGrpId, SOLID_GRP) or GDB_ID.NULL - if nSolidGrpId ~= GDB_ID.NULL then - EgtErase( nSolidGrpId) - end -- recupero la superficie ottenuta dallo slicing local nSrf = EgtGetFirstNameInGroup( nCrvGrpId, LAYER_SRF) @@ -1415,7 +2182,7 @@ function CalcPaths.Exec( nPartId) local dOffs = - LayerParams.dOffs - 0.5 * LayerParams.dStrand if nMaxShellNbrDiff < LayerParams.nShellsNbr then dOffs = dOffs + LayerParams.dStrand - local bOk, bExists, nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs) + local bOk, bExists, nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs, LayerParams.vtSlicing) if not bOk then EgtOutLog( 'Error on ExtOffset (layer '..tostring( nIdx)..') - CalcPaths') elseif not bExists then @@ -1432,13 +2199,14 @@ function CalcPaths.Exec( nPartId) for i = 1, #vOuterShell do table.insert( vPtInnerStart, EgtSP( vOuterShell[i])) end - if #vPtInnerStart == 0 then vPtInnerStart = vPtStart end + if #vPtInnerStart == 0 then vPtInnerStart = vPtStart end + EgtSetInfo( nCrvGrpId, KEY_START_POINT, vPtInnerStart[1]) -- pareti interne complete for nInd = 1, LayerParams.nShellsNbr - 1 - nMaxShellNbrDiff do -- offset della superficie originale - dOffs = dOffs + LayerParams.dStrand - local bOk, bExists, nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs) + dOffs = dOffs + LayerParams.dStrand * ( 1 - LayerParams.nStrandOverlap / 100) + local bOk, bExists, nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs, LayerParams.vtSlicing) if not bOk then EgtOutLog( 'Error on IntOffset (layer '..tostring( nIdx)..') - CalcPaths') elseif not bExists then @@ -1451,7 +2219,12 @@ function CalcPaths.Exec( nPartId) end -- preparo superficie occupata dalle shell da usare per trim - local bOkTrim, bExistsTrim, nSrfTrim = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs - LayerParams.dStrand + s_dOffsCorr) + local dSurfTrimOffs = dOffs + LayerParams.dStrand + if nMaxShellNbrDiff > 0 then + -- se hai extra shell tieni conto anche dell'overlap ammesso + dSurfTrimOffs = dOffs + ( 1 - LayerParams.nStrandOverlap / 100) * LayerParams.dStrand - s_dOffsCorr + end + local bOkTrim, bExistsTrim, nSrfTrim = ComputeSurfOffset( nSrf, nCrvGrpId, - dSurfTrimOffs, LayerParams.vtSlicing) if not bOkTrim then EgtOutLog( 'Error on IntOffset (layer '..tostring( nIdx)..') - CalcPaths') elseif bExistsTrim then @@ -1497,15 +2270,17 @@ function CalcPaths.Exec( nPartId) -- sistemo eventuali costolature if nRibsGrp then - CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, nIdx, nMaxStrandDiff) + CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, nIdx, vPtStart) end end - if EgtProcessEvents( EgtIf( PRINT, 100, 0) + nIdx / #vLayIds * 100, 0) == 1 then + if EgtProcessEvents( EgtIf( PRINT, 200, 0) + nIdx / #vLayIds * 100, 0) == 1 then EgtDraw() - return + return false end end + + return true end --------------------------------------------------------------------- diff --git a/LuaLibs/CalcSlices.lua b/LuaLibs/CalcSlices.lua index ece2511..8d74447 100644 --- a/LuaLibs/CalcSlices.lua +++ b/LuaLibs/CalcSlices.lua @@ -1,4 +1,4 @@ --- CalcSlices.lua by Egaltech s.r.l. 2022/07/06 +-- CalcSlices.lua by Egaltech s.r.l. 2022/10/12 -- Calcolo percorsi di lavoro per Stampa 3d -- Tabella per definizione modulo @@ -16,8 +16,8 @@ local AMD = require( 'AddManData') local s_nPartId --------------------------------------------------------------------- -local function ComputeZSlices( dZmin, dDeltaZ, dZmax) - local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') or 10000 +local function ComputeZSlices( dSliceStep, dZmin, dDeltaZ, dZmax) + local ptSlices = { dZmin + dDeltaZ} local dPosZ = dZmin + dSliceStep while dPosZ < dZmax do @@ -28,9 +28,16 @@ local function ComputeZSlices( dZmin, dDeltaZ, dZmax) end -------------------------------------------------------------------- -local function ComputeMaxH( nStmId, frSlicing, HMax) +local function ComputeMaxH( vIds, frSlicing, HMax, dSliceStep) + + -- calcolo il box globale + local b3BoxGlob = BBox3d() + for i = 1, #vIds do + local b3Box = EgtGetBBoxGlob( vIds[i], GDB_BB.STANDARD) + b3BoxGlob:Add( b3Box) + end + EgtSetInfo( s_nPartId, KEY_BOX_MIN_Z, b3BoxGlob:getMin():getZ()) - local b3BoxGlob = EgtGetBBoxGlob( nStmId, GDB_BB.STANDARD) if b3BoxGlob:getMax():getZ() < b3BoxGlob:getMin():getZ() + HMax + GEO.EPS_SMALL then return GEO.INFINITO end @@ -39,17 +46,27 @@ local function ComputeMaxH( nStmId, frSlicing, HMax) return HMax else -- se slicing inclinato - local nGrpTmp = EgtGroup( EgtGetParent( nStmId)) - local nNewId, nPnt, nCrv, nSrf = EgtPlaneSurfTmInters( Point3d( 0, 0, HMax), Z_AX(), nStmId, nGrpTmp) - if not nNewId then - return GEO.INFINITO + local nGrpTmp = EgtGroup( s_nPartId) + for i = 1, #vIds do + EgtPlaneSurfTmInters( Point3d( 0, 0, HMax), Z_AX(), vIds[i], nGrpTmp, GDB_RT.GLOB) end local b3Box = EgtGetBBoxGlob( nGrpTmp, GDB_BB.STANDARD) EgtErase( nGrpTmp) + if not b3Box then + return GEO.INFINITO + end local ptMin = b3Box:getMin() + local ptMax = b3Box:getMax() + -- la quota dell'ultimo slice è più bassa di dSliceStep rispetto alla quota dell'ultimo toolpath + -- ( andrebbe anche considerata dCorrZ) + ptMin = ptMin - dSliceStep * frSlicing:getVersZ() + ptMax = ptMax - dSliceStep * frSlicing:getVersZ() ptMin:toLoc( frSlicing) - return ptMin:getZ() + ptMax:toLoc( frSlicing) + + return min( ptMin:getZ(), ptMax:getZ()) end + return GEO.INFINITO end @@ -68,7 +85,7 @@ local function AdjustAuxSolids( nSolidsLay) while bInters do bInters = false local nNext = EgtGetNext( nCurr) - while nNext do + while nNext do if EgtGetType( nNext) == GDB_TY.SRF_MESH then -- verifico se le due superfici si intersecano local nFirst = EgtSurfTmSurfTmInters( nCurr, nNext, nGrpTmp) @@ -85,99 +102,76 @@ local function AdjustAuxSolids( nSolidsLay) end nCurr = EgtGetNext( nCurr) end - EgtErase( nGrpTmp) + EgtErase( nGrpTmp) end -------------------------------------------------------------------- -local function ReadParam( nId, sKey, sType, table) - local info = EgtGetInfo( nId, sKey, sType) or EgtGetInfo( s_nPartId, sKey, sType) - table[sKey] = info +local function ReadParam( nId, sKey, sType, defVal, table) + -- verifico se info nell'oggetto specifico + local info = EgtGetInfo( nId, sKey, sType) + -- altrimenti recupero info dai parametri generali + if info == nil then info = EgtGetInfo( s_nPartId, sKey, sType) end + -- o assegno valore di default + if info == nil then info = defVal end + + -- se presente, inserisco l'info nella tabella + if table then table[sKey] = info end + + return info end -------------------------------------------------------------------- local function GetRibParams( nId) local RibParam = {} - ReadParam( nId, KEY_RIBS_SHELLS_NBR, 'i', RibParam) - ReadParam( nId, KEY_RIBS_INVERT_DIR, 'b', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_IN_INVERT, 'b', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_IN_LEN, 'd', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_OUT_INVERT, 'b', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_OUT_LEN, 'd', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_OUT_COASTING, 'd', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE, 'd', RibParam) - ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd', RibParam) - - -- overlap può essere diverso tra le varie costolature solo se non sono collegate - local bLink = EgtGetInfo( s_nPartId, KEY_RIBS_LINK, 'b') or false - if bLink then - RibParam[ KEY_RIBS_OVERLAP] = EgtGetInfo( s_nPartId, KEY_RIBS_OVERLAP, 'i') -- parametro generico - else - ReadParam( nId, KEY_RIBS_OVERLAP, 'i', RibParam) -- parametro specifico della costolatura - end - + ReadParam( nId, KEY_RIBS_SHELLS_NBR, 'i', 0, RibParam) + ReadParam( nId, KEY_RIBS_INVERT_DIR, 'b', false, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_IN_INVERT, 'b', false, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_IN_LEN, 'd', 0, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_INVERT, 'b', false, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_LEN, 'd', 0, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_COASTING, 'd', 0, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE, 'd', 0, RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd', 0, RibParam) + ReadParam( nId, KEY_RIBS_OVERLAP, 'i', 0, RibParam) + ReadParam( nId, KEY_RIBS_LINK, 'b', false, RibParam) + ReadParam( nId, KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL, RibParam) + ReadParam( nId, KEY_RIBS_INVERT_STRAND_ORDER, 'b', false, RibParam) + return RibParam end +------------------------------------------------------------------- +local function GetShellNumberParams( nId) + + local ShellNumberParam = {} + ReadParam( nId, KEY_SHELL_NBR_DIFF, 'i', 0, ShellNumberParam) + ReadParam( nId, KEY_SHELL_NBR_COASTING, 'd', 0, ShellNumberParam) + ReadParam( nId, KEY_SHELL_NBR_WIPE, 'd', 0, ShellNumberParam) + ReadParam( nId, KEY_SHELL_NBR_WIPE_DIR, 'd', 0, ShellNumberParam) + + return ShellNumberParam +end + -------------------------------------------------------------------- local function GetAuxSolidsParams( nId) local AuxSolidsParam = {} - ReadParam( nId, KEY_AUX_SOLIDS_OVERLAP, 'i', AuxSolidsParam) - ReadParam( nId, KEY_AUX_SOLIDS_LINK_PARAM, 'd', AuxSolidsParam) - ReadParam( nId, KEY_AUX_SOLIDS_SP_OFFSET, 'd', AuxSolidsParam) - ReadParam( nId, KEY_AUX_SOLIDS_COASTING_LEN, 'd', AuxSolidsParam) - ReadParam( nId, KEY_AUX_SOLIDS_WIPE_LEN, 'd', AuxSolidsParam) - ReadParam( nId, KEY_AUX_SOLIDS_WIPE_DIR, 'd', AuxSolidsParam) - - local sInfill = EgtGetInfo( nId, KEY_AUX_SOLIDS_INFILL, 's') - if sInfill then - -- se parametro specifico per il solido - if sInfill == 'ZigZag' then - AuxSolidsParam[KEY_AUX_SOLIDS_INFILL] = INFILL_TYPE.ZIGZAG - elseif sInfill == 'Offset' then - AuxSolidsParam[KEY_AUX_SOLIDS_INFILL] = INFILL_TYPE.OFFSET - else - AuxSolidsParam[KEY_AUX_SOLIDS_INFILL] = INFILL_TYPE.NONE - end - else - -- altrimenti recupero il parametro generale dal pezzo - AuxSolidsParam[KEY_AUX_SOLIDS_INFILL] = EgtGetInfo( s_nPartId, KEY_AUX_SOLIDS_INFILL, 'i') - end - - local sPrintOrder = EgtGetInfo( nId, KEY_AUX_SOLIDS_PRINT_ORDER, 's') - if sPrintOrder then - -- se parametro specifico per il solido - if sPrintOrder == 'OutToIn' then - AuxSolidsParam[KEY_AUX_SOLIDS_PRINT_ORDER] = PRINT_ORDER.EXT_INT_INF - else - AuxSolidsParam[KEY_AUX_SOLIDS_PRINT_ORDER] = PRINT_ORDER.INF_INT_EXT - end - else - -- altrimenti recupero il parametro generale dal pezzo - AuxSolidsParam[KEY_AUX_SOLIDS_PRINT_ORDER] = EgtGetInfo( s_nPartId, KEY_AUX_SOLIDS_PRINT_ORDER, 'i') - end - - local sLinkType = EgtGetInfo( nId, KEY_AUX_SOLIDS_LINK_TYPE, 's') - if sLinkType then - -- se parametro specifico per il solido - if sLinkType == 'None' then - AuxSolidsParam[KEY_AUX_SOLIDS_LINK_TYPE] = LINK_TYPE.NONE - elseif sLinkType == 'BiArc' then - AuxSolidsParam[KEY_AUX_SOLIDS_LINK_TYPE] = LINK_TYPE.BIARC - else - AuxSolidsParam[KEY_AUX_SOLIDS_LINK_TYPE] = LINK_TYPE.LINEAR - end - else - -- altrimenti recupero il parametro generale dal pezzo - AuxSolidsParam[KEY_AUX_SOLIDS_LINK_TYPE] = EgtGetInfo( s_nPartId, KEY_AUX_SOLIDS_LINK_TYPE, 'i') - end + ReadParam( nId, KEY_AUX_SOLIDS_OVERLAP, 'i', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_LINK_PARAM, 'd', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_SP_OFFSET, 'd', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_COASTING_LEN, 'd', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_WIPE_LEN, 'd', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_WIPE_DIR, 'd', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_INFILL, 'i', INFILL_TYPE.NONE, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_PRINT_ORDER, 'i', PRINT_ORDER.EXT_INT, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_LINK_TYPE, 'i', LINK_TYPE.NONE, AuxSolidsParam) return AuxSolidsParam end -------------------------------------------------------------------- -local function SlicingExtraObjects( vtSlicing, nLay, nType, sNameGrp, sName) +local function SlicingExtraObjects( vtSlicing, nLay, nType, sNameGrp, sName, nStmId) -- recupero gli oggeti di cui fare slicing local vIds = EgtGetAllInGroup( nLay) @@ -205,7 +199,7 @@ local function SlicingExtraObjects( vtSlicing, nLay, nType, sNameGrp, sName) vParams = GetRibParams( vIds[i]) if vParams[ KEY_RIBS_SHELLS_NBR] == 0 then bToBeDone = false end elseif nType == TYPE.EXTRA_SHELL then - vParams[KEY_SHELL_NBR_DIFF] = EgtGetInfo( vIds[i], KEY_SHELL_NBR_DIFF, 'i') or EgtGetInfo( s_nPartId, KEY_SHELL_NBR_DIFF, 'i') + vParams = GetShellNumberParams( vIds[i]) if vParams[KEY_SHELL_NBR_DIFF] == 0 then bToBeDone = false end elseif nType == TYPE.AUX_SOLID then vParams = GetAuxSolidsParams( vIds[i]) @@ -214,7 +208,27 @@ local function SlicingExtraObjects( vtSlicing, nLay, nType, sNameGrp, sName) table.insert( tabParams, vParams) table.insert( vToBeDone, bToBeDone) end - + + -- taglio i setti unbounded e limitati con il solido + local vEraseIds = {} + if nType == TYPE.RIB then + local bLimitUnbddRibs = EgtGetInfo( s_nPartId, KEY_LIMIT_UNBDD_RIBS, 'b') or false + if bLimitUnbddRibs then + for i = 1, #vIds do + if vToBeDone[i] then + if tabParams[i][KEY_RIBS_TYPE] == RIB_TYPE.UNBOUNDED then + -- creo copia e la taglio con solido + local nCopy = EgtCopyGlob( vIds[i], EgtGetParent( vIds[i])) + EgtSurfTmCut( nCopy, nStmId, true, true) + -- lo slicing viene fatto sulla copia + vIds[i] = nCopy + table.insert( vEraseIds, nCopy) + end + end + end + end + end + local nLayId = EgtGetFirstNameInGroup( s_nPartId, SLICE_LAYER .. '*') while nLayId do -- recupero quota per slicing @@ -279,6 +293,11 @@ local function SlicingExtraObjects( vtSlicing, nLay, nType, sNameGrp, sName) nLayId = EgtGetNextName( nLayId, SLICE_LAYER .. '*') end + -- rimuovo eventuali copie create per lo slicing + for i = 1, #vEraseIds do + EgtErase( vEraseIds[i]) + end + return true end @@ -293,79 +312,86 @@ local function ValueInArray( vArr, nValue) end --------------------------------------------------------------------- -function CalcSlices.Exec( nPartId, nStmId, HMax) +local function SlicingNoSolid( nRibsLay, vZSlices, dDeltaZStart, dZmin, frSlicing, vErr) + + local vtSlicing = frSlicing:getVersZ() + + -- contatore per il calcolo delle intersezioni + if EgtProcessEvents( 100, 0) == 1 then return false end + -- creo i layer dello slicing + for i = 1, #vZSlices do + local nLayGrp = EgtGroup( s_nPartId) + EgtSetName( nLayGrp, SLICE_LAYER .. tostring( i)) + + local dDeltaZ = EgtIf( i == 1, dDeltaZStart, 0) + local dPosZ = vZSlices[i]- dDeltaZ + EgtSetInfo( nLayGrp, KEY_SLICE_Z, dPosZ - dZmin) + EgtSetInfo( nLayGrp, KEY_SLICE_REAL_Z, dPosZ) + EgtSetInfo( nLayGrp, KEY_SLICE_DELTAZ, dDeltaZ) + EgtSetInfo( nLayGrp, KEY_SLICE_NBR, i) + + local nGrpCrv = EgtGroup( nLayGrp) + EgtSetName( nGrpCrv, CONTOUR_GRP .. EgtNumToString( 0)) + end + if EgtProcessEvents( EgtIf( PRINT, 100, 0) + 20, 0) == 1 then return false end + + -- slicing dei setti + SlicingExtraObjects( vtSlicing, nRibsLay, TYPE.RIB, RIBS_GRP, RIBS_CRV) + if EgtProcessEvents( EgtIf( PRINT, 100, 0) + 100, 0) == 1 then return false end + + return true +end + +--------------------------------------------------------------------- +local function SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicing, vErr) + -- costanti - local TOLER = 0.2 - local SMALL_TOLER = 0.02 + local TOLER = 0.05 + local MID_TOLER = 0.1 local BIG_TOLER = 2.0 local MIN_LEN = 20.0 local MIN_AREA = 25.0 - s_nPartId = nPartId - - -- recupero la direzione dello slicing - local vtSlicing = Z_AX() - local bSlicing45 = EgtGetInfo( s_nPartId, KEY_SLICING_45, 'b') - if bSlicing45 then - vtSlicing = VectorFromSpherical( 1, 45, 0) - end - EgtSetInfo( s_nPartId, KEY_SLICING_DIR, vtSlicing) - local frSlicing = Frame3d( ORIG(), vtSlicing) + local vtSlicing = frSlicing:getVersZ() + + -- calcolo delle intersezioni + if EgtProcessEvents( 1, 0) == 1 then return false end + local nLayId = EgtParPlanesSurfTmInters( ORIG(), vtSlicing, vZSlices, nStmId, s_nPartId, GDB_RT.GLOB, TOLER) + if EgtProcessEvents( 100, 0) == 1 then return false end - -- recupero il box della superficie - local b3Box = EgtGetBBoxRef( nStmId, GDB_BB.STANDARD, frSlicing) - if not b3Box or b3Box:isEmpty() then - EgtOutText( 'La superficie selezionata è vuota') - EgtPause( 1000) - return - end - - -- Parametri di slicing - local dZmin = b3Box:getMin():getZ() - local dZmax = b3Box:getMax():getZ() - local dMaxH = ComputeMaxH( nStmId, frSlicing, HMax) - dZmax = min( dZmax, dMaxH) - -- dZmin = 20 - -- dZmax = 230 - - -- Eseguo slicing - local nLayCnt = 1 - local nRecalc = 0 - local dDeltaZStart = 0.2 - --dDeltaZStart = 0 - local vZSlices = ComputeZSlices( dZmin, dDeltaZStart, dZmax) - local nLayId = EgtParPlanesSurfTmInters( ORIG(), vtSlicing, vZSlices, nStmId, nPartId, GDB_RT.GLOB, TOLER) - local vErr = {} local vPrevCen = {} + local nLayCnt = 1 + -- scorro i risultati dello slicing while nLayId do - local dDeltaZ = EgtIf( nLayCnt == 1, dDeltaZStart, 0) + local dDeltaZ = EgtIf( nLayCnt == 1, dDeltaZStart, 0) local dPosZ = vZSlices[nLayCnt]- dDeltaZ EgtSetInfo( nLayId, KEY_SLICE_Z, dPosZ - dZmin) EgtSetInfo( nLayId, KEY_SLICE_REAL_Z, dPosZ) EgtSetInfo( nLayId, KEY_SLICE_NBR, nLayCnt) - -- verifico se necessario ricalcolo - local nId = EgtGetLastInGroup( nLayId) - local bRecalc = not nId + -- verifico se necessario ricalcolo + local nId = EgtGetLastInGroup( nLayId) + local bRecalc = not nId local vtRecalc + local nRecalc = 0 while nId and not bRecalc do local nType = EgtGetType( nId) if nType == GDB_TY.SRF_MESH then - bRecalc = true + bRecalc = true vtRecalc = EgtSurfTmFacetNormVersor( nId, 0) elseif nType == GDB_TY.GEO_POINT then - bRecalc = true + bRecalc = true end nId = EgtGetPrev( nId) end - -- eseguo eventuale ricalcolo + -- eseguo eventuale ricalcolo ::RECALC:: if bRecalc then nRecalc = nRecalc + 1 - EgtEmptyGroup( nLayId) + EgtEmptyGroup( nLayId) dDeltaZ = dDeltaZ + EgtIf( vtRecalc and vtRecalc:getZ() > 0, -0.01, 0.01) -- eseguo il ricalcolo solo a quella quota EgtPlaneSurfTmInters( ORIG() + ( dPosZ + dDeltaZ) * vtSlicing, vtSlicing, nStmId, nLayId, GDB_RT.GLOB, TOLER) @@ -385,7 +411,7 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) -- correggo eventuali spostamenti in Z if abs( dDeltaZ) > GEO.EPS_SMALL then EgtMove( nId, - dDeltaZ * vtSlicing) - end + end -- verifico presenza contorni aperti if EgtCurveIsClosed( nId) then table.insert( vClosedId, nId) @@ -435,33 +461,39 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) table.remove( vClosedId, i) end end - + -- se necessario e possibile, torno a ricalcolo if not bAllClosed and nRecalc < 2 then bRecalc = true goto RECALC end - + -- imposto dati ausiliari EgtSetName( nLayId, EgtIf( bAllClosed, '', '__') .. SLICE_LAYER .. EgtNumToString( nLayCnt)) EgtSetInfo( nLayId, 'CrvCnt', #vClosedId + #vOpenId) EgtSetColor( vClosedId or {}, 'TEAL') EgtSetColor( vOpenId or {}, 'RED') - + -- creo flat region a partire dalle curve chiuse ottenute con lo slicing - local nGrp = EgtGroup( nLayId, frSlicing) + local nGrp = EgtGroup( nLayId, frSlicing, GDB_RT.GLOB) for i = 1, #vClosedId do EgtRelocateGlob( vClosedId[i], nGrp) - EgtApproxCurve( vClosedId[i], GDB_CA.ARCS, SMALL_TOLER) + EgtApproxCurve( vClosedId[i], GDB_CA.ARCS, MID_TOLER) EgtRelocateGlob( vClosedId[i], nLayId) end EgtErase( nGrp) local nSurfFR, nSrfNbr = EgtSurfFlatRegion( nLayId, vClosedId) - for i = 1, #vClosedId do - EgtErase( vClosedId[i]) - end - + if nSurfFR then + -- verifico orientamento della normale + local vtN = EgtSurfFrNormVersor( nSurfFR, GDB_ID.ROOT) + if AreOppositeVectorApprox( vtN, vtSlicing) then + EgtInvertSurf( nSurfFR) + end + -- elimino le curve originali + for i = 1, #vClosedId do + EgtErase( vClosedId[i]) + end -- esplodo in superfici elementari local vSrfId = {} for j = 1, nSrfNbr do @@ -535,50 +567,166 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) local nCsId, nCsCnt = EgtExtractSurfFrChunkLoops( nId, 0, nGrpCrv) for nId2 = nCsId, nCsId + nCsCnt - 1 do EgtSetName( nId2, OUTER_CRV) + EgtSetStatus( nId2, GDB_ST.OFF) EgtSetColor( nId2, 'BLACK') end end else - -- errore - EgtSetName( nLayId, '__' .. SLICE_LAYER .. EgtNumToString( nLayCnt)) - table.insert( vErr, nLayCnt) - end - - -- passo al layer successivo - if EgtProcessEvents( nLayCnt / ( #vZSlices + 3) * 100, 0) == 1 then - EgtDraw() - return + + local bErr = true + -- se nessuna curva + if #vClosedId == 0 and #vOpenId == 0 then + bErr = false + -- se una sola curva, ne verifico larghezza media + elseif #vClosedId == 1 then + local dLen = EgtCurveLength( vClosedId[1]) + local _, _, dArea = EgtCurveArea( vClosedId[1]) + if not dArea or dArea / dLen < MID_TOLER then bErr = false end + end + + -- se vero errore lo segnalo + if bErr then + table.insert( vErr, nLayCnt) + -- cambio nome al layer + EgtSetName( nLayId, '__' .. SLICE_LAYER .. EgtNumToString( nLayCnt)) + else + -- altrimenti creo il CrvGrp da utilizzare nel CalcPath + local nGrpCrv = EgtGroup( nLayId) + EgtSetName( nGrpCrv, CONTOUR_GRP .. EgtNumToString( 1)) + end end - nLayCnt = nLayCnt + 1 + + -- passo al layer successivo + if EgtProcessEvents( EgtIf( PRINT, 100, 0) + nLayCnt / ( #vZSlices + 3) * 100, 0) == 1 then + -- elimino i layer non ancora analizzati + local nNext = EgtGetNext( nLayId) + while nNext do + local nCurr = nNext + nNext = EgtGetNext( nCurr) + EgtErase( nCurr) + end + return false + end + + nLayCnt = nLayCnt + 1 nLayId = EgtGetNext( nLayId) end + + local bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false + if not bSpiralVase then + -- costolature + local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS) + if nRibsLay then + SlicingExtraObjects( vtSlicing, nRibsLay, TYPE.RIB, RIBS_GRP, RIBS_CRV, nStmId) + end + if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 1) / ( #vZSlices + 3) * 100, 0) == 1 then return false end + + -- solidi per regioni con diverso numero di passate + local nShellNbrLay = EgtGetFirstNameInGroup( s_nPartId, LAY_SHELL_NBR) + if nShellNbrLay then + SlicingExtraObjects( vtSlicing, nShellNbrLay, TYPE.EXTRA_SHELL, SHELL_NBR_GRP, SHELL_NBR_CRV, nStmId) + end + if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 2) / ( #vZSlices + 3) * 100, 0) == 1 then return false end + + -- solidi ausiliari + local nAuxSolidsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_AUX_SOLIDS) + if nAuxSolidsLay then + AdjustAuxSolids( nAuxSolidsLay) + SlicingExtraObjects( vtSlicing, nAuxSolidsLay, TYPE.AUX_SOLID, AUX_SOLIDS_GRP, AUX_SOLIDS_CRV, nStmId) + end + if EgtProcessEvents( EgtIf( PRINT, 100, 0) + ( #vZSlices + 3) / ( #vZSlices + 3) * 100, 0) == 1 then return false end + end - -- costolature + return true +end + +--------------------------------------------------------------------- +function CalcSlices.Exec( nPartId, nStmId, HMax) + + s_nPartId = nPartId + + -- recupero la direzione dello slicing + local vtSlicing = Z_AX() + local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i') + if nSlicingType == SLICING_TYPE.DEG45_X then + vtSlicing = VectorFromSpherical( 1, 45, 0) + elseif nSlicingType == SLICING_TYPE.DEG45_Y then + vtSlicing = VectorFromSpherical( 1, 45, -90) + elseif nSlicingType == SLICING_TYPE.HORIZONTAL then + vtSlicing = X_AX() + end + + EgtSetInfo( s_nPartId, KEY_SLICING_DIR, vtSlicing) + local frSlicing = Frame3d( ORIG(), vtSlicing) + + -- recupero la superficie ed eventuali setti esterni/unbounded da usare come riferimenti per quote slicing + local vRefIds = {} + if nStmId then table.insert( vRefIds, nStmId) end local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS) - if nRibsLay then - SlicingExtraObjects( vtSlicing, nRibsLay, TYPE.RIB, RIBS_GRP, RIBS_CRV) + local vRibsIds = EgtGetAllInGroup( nRibsLay) + local bLimitUnbddRibs = EgtGetInfo( s_nPartId, KEY_LIMIT_UNBDD_RIBS, 'b') or false + for i = 1, #vRibsIds do + if EgtGetType( vRibsIds[i]) == GDB_TY.SRF_MESH then + local nType = ReadParam( vRibsIds[i], KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL) + if nType == RIB_TYPE.EXTERNAL or ( nType == RIB_TYPE.UNBOUNDED and not bLimitUnbddRibs) then + table.insert( vRefIds, vRibsIds[i]) + end + end end - if EgtProcessEvents( ( #vZSlices + 1) / ( #vZSlices + 3) * 100, 0) == 1 then return end - -- solidi per regioni con diverso numero di passate - local nShellNbrLay = EgtGetFirstNameInGroup( s_nPartId, LAY_SHELL_NBR) - if nShellNbrLay then - SlicingExtraObjects( vtSlicing, nShellNbrLay, TYPE.EXTRA_SHELL, SHELL_NBR_GRP, SHELL_NBR_CRV) + if bLimitUnbddRibs and not nStmId then + EgtOutBox( "No solid to limit unbounded ribs!", 'Error', 'ERROR') + return end - if EgtProcessEvents( ( #vZSlices + 2) / ( #vZSlices + 3) * 100, 0) == 1 then return end - -- solidi ausiliari - local nAuxSolidsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_AUX_SOLIDS) - if nAuxSolidsLay then - AdjustAuxSolids( nAuxSolidsLay) - SlicingExtraObjects( vtSlicing, nAuxSolidsLay, TYPE.AUX_SOLID, AUX_SOLIDS_GRP, AUX_SOLIDS_CRV) + -- recupero il box + local b3Box = BBox3d() + for i = 1, #vRefIds do + local b3Tmp = EgtGetBBoxRef( vRefIds[i], GDB_BB.STANDARD, frSlicing) + b3Box:Add( b3Tmp) + end + if not b3Box or b3Box:isEmpty() then + EgtOutBox( "No part to be sliced!", 'Error', 'ERROR') + return + end + + -- Parametri di slicing + local dSliceStep = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') or 10000 + if dSliceStep < GEO.EPS_SMALL then + EgtOutLog( 'Warning : SliceStep is 0') + return + end + + local dZmin = b3Box:getMin():getZ() + local dZmax = b3Box:getMax():getZ() + local dMaxH = ComputeMaxH( vRefIds, frSlicing, HMax, dSliceStep) + dZmax = min( dZmax, dMaxH) + --dZmin = 708 + --dZmax = 712 + + -- Eseguo slicing + local nLayCnt = 1 + local nRecalc = 0 + local dDeltaZStart = 0.2 + + local vZSlices = ComputeZSlices( dSliceStep, dZmin, dDeltaZStart, dZmax) + + local vErr = {} + local bOk = true + if not nStmId then + -- caso senza solido e solo setti + bOk = SlicingNoSolid( nRibsLay, vZSlices, dDeltaZStart, dZmin, frSlicing, vErr) + else + -- caso con solido + bOk = SlicingWithSolid( nStmId, vZSlices, dDeltaZStart, dZmin, frSlicing, vErr) end - if EgtProcessEvents( ( #vZSlices + 3) / ( #vZSlices + 3) * 100, 0) == 1 then return end -- eventuale segnalazione errori - if #vErr > 0 then + if bOk and #vErr > 0 then EgtOutBox( 'Slicing Error on layers :\n' .. table.concat( vErr, ','), 'SlicingCalc') - end + end + + return bOk end --------------------------------------------------------------------- diff --git a/LuaLibs/CalcSolids.lua b/LuaLibs/CalcSolids.lua deleted file mode 100644 index e1e2e46..0000000 --- a/LuaLibs/CalcSolids.lua +++ /dev/null @@ -1,287 +0,0 @@ --- CalcSolids.lua by Egaltech s.r.l. 2022/07/01 --- Calcolo percorsi di lavoro per Stampa 3d - --- Tabella per definizione modulo -local CalcSolids = {} - --- Intestazioni -require( 'EgtBase') - -EgtOutLog( ' CalcSolids started', 1) - --- Dati -local AMD = require( 'AddManData') - ---------------------------------------------------------------------- -local s_nPartId - ---------------------------------------------------------------------- -local function GetLayerParamsForSolidCalc() - local LayerParams = {} - LayerParams.bInvert = EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'b') - LayerParams.dLayHeight = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') - LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd') - LayerParams.nOrder = EgtGetInfo( s_nPartId, KEY_PRINT_ORDER, 'i') - LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v') - return LayerParams -end - ---------------------------------------------------------------------- -local function CalcSectionParams( dStrand, dH) - local dL = dStrand - local dLm = dStrand / 10 - local dHm = dH / 6 - -- recupero offset - --local dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd') - dOffs = 0 - if dOffs and dOffs > 0 then - -- calcolo area originale - local dArea = ( dL * dH) - ( dLm * dHm) - local dLM = ( dArea / dH) - ( dLm / 6) - if dOffs / 2 <= ( dL - dLM) then - dL = dL - dOffs / 2 - dLm = dL / 10 - dHm = (( dL * dH) - dArea) / dLm - else - EgtOutLog( 'Strand section not calculated on area. Too much overlap?') - end - end - - 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 -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 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 nId = EgtCurveCompoFromPoints( nSolidGrp, {ptA, ptB, ptC, ptD, ptE, ptF, ptG, ptH, ptA}) - 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}) - - return nId -end - --------------------------------------------------------------------- -local function CreateSolid( nCrvId, nSolidGrp, dStrand, dH, vtSlicing) - -- punti e direzioni all'inizio e fine della curva guida - local ptS = EgtSP( nCrvId) - local vtS = EgtSV( nCrvId) - vtS:rotate( vtSlicing, 90) - local ptE = EgtEP( nCrvId) - local vtE = EgtEV( nCrvId) - vtE:rotate( vtSlicing, -90) - -- creazione del solido aperto (tubo) - local nSectId = CreateSection( ptS, vtS, dStrand, dH, vtSlicing, nSolidGrp) - local nSrfId = EgtSurfTmSwept( nSolidGrp, nSectId, nCrvId, false, 0.1) - EgtErase( nSectId) - if not nSrfId then return nil end - -- creazione del mezzo disco iniziale - local nSectS = CreateHalfSection( ptS, vtS, dStrand, dH, vtSlicing, nSolidGrp) - local nSrfS = EgtSurfTmByScrewing( nSolidGrp, nSectS, ptS, vtSlicing, 180, 0, false, 0.1) - EgtErase( nSectS) - if not nSrfS then return nil end - -- creazione del mezzo disco finale - local nSectE = CreateHalfSection( ptE, vtE, dStrand, dH, vtSlicing, nSolidGrp) - local nSrfE = EgtSurfTmByScrewing( nSolidGrp, nSectE, ptE, vtSlicing, 180, 0, false, 0.1) - EgtErase( nSectE) - if not nSrfE then return nil end - -- unione delle tre superfici - return EgtSurfTmBySewing( nSolidGrp, { nSrfId, nSrfS, nSrfE}) -end - ---------------------------------------------------------------------- -local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams) - - local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i') - if nType == TYPE.WIPE then return true end - -- scelta del colore - local Color = EgtStdColor( 'GRAY') - if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then - Color = EgtStdColor( 'TEAL') - elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then - Color = EgtStdColor( 'ORANGE') - elseif nType == TYPE.LINK then - Color = EgtStdColor( 'GRAY') - elseif nType == TYPE.INFILL then - Color = EgtStdColor( 'YELLOW') - elseif nType == TYPE.COASTING then - Color = EgtStdColor( 'BLUE') - elseif nType == TYPE.WIPE then - Color = EgtStdColor( 'LIME') - elseif nType == TYPE.RIB then - Color = EgtStdColor( 'OLIVE') - elseif nType == TYPE.AUX_SOLID then - Color = EgtStdColor( 'AQUA') - end - - local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp) - local nId = GDB_ID.NULL - local nParts = 1 - local LEN_REF = 100 - local bZigZagInfill = EgtGetInfo( nCopyId, KEY_ZIG_ZAG_INFILL, 'b') or false - if bZigZagInfill then - nId, nParts = EgtSplitCurveAtCorners( nCopyId, 80) - else - local dLen = EgtCurveLength( nCrvId) - if dLen > LEN_REF and nType ~= TYPE.LINK and nType ~= TYPE.COASTING then - nParts = EgtClamp( floor( dLen / LEN_REF), 1, 10) - end - nId = EgtSplitCurve( nCopyId, nParts) - end - - if nId == GDB_ID.NULL then return false end - local bOk = true - for nInd = 0, nParts - 1 do - local nGuideId = nId + nInd - local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams.dStrand - 2 * GEO.EPS_SMALL, LayerParams.dLayHeight, LayerParams.vtSlicing) - - if not nSrfId then - -- ritento con sezione leggermente modificata - nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams.dStrand - 100 * GEO.EPS_SMALL, LayerParams.dLayHeight, LayerParams.vtSlicing) - if not nSrfId then - nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams.dStrand + 100 * GEO.EPS_SMALL, LayerParams.dLayHeight, LayerParams.vtSlicing) - if not nSrfId then - -- ritento spezzando la curva - local nGrp = EgtGroup( nSolidGrp, Frame3d( ORIG(), LayerParams.vtSlicing)) - 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 - 100 * GEO.EPS_SMALL, LayerParams.dLayHeight, LayerParams.vtSlicing) - EgtErase( nFirstCrv + nInd2) - if nSrfId2 then - table.insert( nSrfIds, nSrfId2) - end - end - if #nSrfIds == nCrvNbr then - nSrfId = EgtSurfTmBySewing( nSolidGrp, nSrfIds) - end - end - end - end - end - - if nSrfId then - EgtSetColor( nSrfId, Color) - EgtSetInfo( nSrfId, KEY_TYPE, nType) - else - bOk = false - end - EgtErase( nGuideId) - end - - return bOk -end - ---------------------------------------------------------------------- -function CalcSolids.Exec( nPartId) - - s_nPartId = nPartId - - local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*") - if not vLayIds then - EgtOutBox( 'Error no slice', 'SolidCalc') - return - end - - local vErr = {} - -- recupero i parametri necessari al calcolo dei solidi - local LayerParams = GetLayerParamsForSolidCalc() - - for nIdx = 1, #vLayIds do - - -- scorro tutti i gruppi di contorni - local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*") or GDB_ID.NULL - while nCrvGrpId ~= GDB_ID.NULL do - - -- recupero il gruppo dei percorsi utensile - local nTPathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, TOOLPATH_GRP) or GDB_ID.NULL - if nTPathGrpId == GDB_ID.NULL then - EgtOutBox( 'Error no tool paths', 'SolidCalc') - return - end - - -- recupero il gruppo dei solidi - local nSolidGrpId = EgtGetFirstNameInGroup( nCrvGrpId, SOLID_GRP) or GDB_ID.NULL - if nSolidGrpId == GDB_ID.NULL then - nSolidGrpId = EgtGroup( nCrvGrpId) - EgtSetName( nSolidGrpId, SOLID_GRP) - else - EgtEmptyGroup( nSolidGrpId) - end - - -- scorro le curve del percorso utensile - local nId = EgtGetFirstInGroup( nTPathGrpId) - while nId do - local bOk = CreateSolidFromCurve( nId, nSolidGrpId, LayerParams) - if not bOk then - table.insert( vErr, nIdx) - end - nId = EgtGetNext( nId) - end - - -- nascondo ExternCurve del gruppo - local vExtCrvs = EgtGetNameInGroup( nCrvGrpId, OUTER_CRV) - for nInd = 1, #vExtCrvs do - EgtSetStatus( vExtCrvs[nInd], GDB_ST.OFF) - end - - -- processo gli eventi - if ( nIdx % 20) == 0 then - EgtDraw() - if EgtProcessEvents( nIdx / #vLayIds * 100, 0) == 1 then - return - end - end - - --passo al gruppo di contorni successivo - nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*") or GDB_ID.NULL - end - EgtDraw() - if EgtProcessEvents( EgtIf( PRINT, 300, 0) + nIdx / #vLayIds * 100, 0) == 1 then - return - end - end - - -- eventuale segnalazione errori - -- if #vErr > 0 then - -- EgtOutBox( 'Error on layers :\n' .. table.concat( vErr, ','), 'SolidCalc') - -- end - - for i = 1, #vErr do - EgtOutLog( 'Error on solid creation (layer ' .. vErr[i] .. ') - SolidCalc') - end - -end - ---------------------------------------------------------------------- -return CalcSolids diff --git a/LuaLibs/CalcToolPath.lua b/LuaLibs/CalcToolPath.lua index b4389df..eae9490 100644 --- a/LuaLibs/CalcToolPath.lua +++ b/LuaLibs/CalcToolPath.lua @@ -1,4 +1,4 @@ --- CalcToolPath.lua by Egaltech s.r.l. 2022/08/29 +-- CalcToolPath.lua by Egaltech s.r.l. 2022/12/20 -- Calcolo percorsi di lavoro per Stampa 3d -- Tabella per definizione modulo @@ -15,15 +15,18 @@ 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_dHMin --------------------------------------------------------------------- local function GetLayerParamsForToolPathCalc() local LayerParams = {} + LayerParams.bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd') LayerParams.dLayHeight = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd') LayerParams.bInvert = ( EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW) - LayerParams.nOrder = EgtGetInfo( s_nPartId, KEY_PRINT_ORDER, 'i') + LayerParams.nOrder = EgtGetInfo( s_nPartId, KEY_STRAND_ORDER, 'i') + LayerParams.vPrintOrder = EgtGetInfo( s_nPartId, KEY_PRINT_ORDER, 'vi') or { 1, 2, 3, 4, 5, 6, 7, 8} LayerParams.nLinkType = EgtGetInfo( s_nPartId, KEY_LINK_TYPE, 'i') LayerParams.dLinkParam = EgtGetInfo( s_nPartId, KEY_LINK_PARAM, 'd') LayerParams.nLeadInType = EgtGetInfo( s_nPartId, KEY_LEAD_IN_TYPE, 'i') @@ -32,34 +35,110 @@ local function GetLayerParamsForToolPathCalc() LayerParams.nLeadOutType = EgtGetInfo( s_nPartId, KEY_LEAD_OUT_TYPE, 'i') LayerParams.dLeadOutTangDist = EgtGetInfo( s_nPartId, KEY_LEAD_OUT_TANG_DIST, 'd') LayerParams.dLeadOutOrthoDist = EgtGetInfo( s_nPartId, KEY_LEAD_OUT_ORTHO_DIST, 'd') - LayerParams.dOffsetLP = EgtGetInfo( s_nPartId, KEY_OFFSET_LEAD_POINT, 'd') + LayerParams.dOffsetLP = EgtGetInfo( s_nPartId, KEY_OFFSET_LEAD_POINT, 'd') LayerParams.dSPOffs = EgtGetInfo( s_nPartId, KEY_SP_OFFSET_ON_SLICE, 'd') LayerParams.dCoastingLen = EgtGetInfo( s_nPartId, KEY_COASTING_LEN, 'd') LayerParams.dWipeLen = EgtGetInfo( s_nPartId, KEY_WIPE_LEN, 'd') + LayerParams.dWipeDir = EgtGetInfo( s_nPartId, KEY_WIPE_DIR, 'd') or 0.0 LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v') LayerParams.dTDiam = EgtGetInfo( s_nPartId, KEY_TOOL_DIAM, 'd') - -- Parametri costolature - LayerParams.bRibsLink = EgtGetInfo( s_nPartId, KEY_RIBS_LINK, 'b') - -- Parametri regioni con diverse passate - LayerParams.dShellNbrCoasting = EgtGetInfo( s_nPartId, KEY_SHELL_NBR_COASTING, 'd') - LayerParams.dShellNbrWipe = EgtGetInfo( s_nPartId, KEY_SHELL_NBR_WIPE, 'd') - LayerParams.dShellNbrWipeDir = EgtGetInfo( s_nPartId, KEY_SHELL_NBR_WIPE_DIR, 'd') - + return LayerParams end --------------------------------------------------------------------- -local function ComputeZCorrection( LayerParams) - -- direzione dell'estrusore - local vtN = LayerParams.vtSlicing - local dNxy = sqrt( vtN:getX() * vtN:getX() + vtN:getY() * vtN:getY()) - local dNz = vtN:getZ() - -- correzione per l'offset - local dCorr1 = LayerParams.dOffs * dNxy - -- correzione per il diametro dell'ugello - local dCorr2 = ( LayerParams.dOffs - LayerParams.dStrand / 2 + LayerParams.dTDiam / 2) * dNxy - LayerParams.dLayHeight * dNz - -- massimo tra le due - return max( dCorr1, dCorr2) +------------------------------------------------------------------ +local function ComputeToolPathBox( nTpathGrpId) + + -- calcolo il box del toolpath (escludendo i wipe) + local b3Box = BBox3d() + local nEntId = EgtGetFirstInGroup( nTpathGrpId) + while nEntId do + if EgtGetInfo( nEntId, KEY_TYPE, 'i') ~= TYPE.WIPE then + local b3Ent = EgtGetBBoxGlob( nEntId, GDB_BB.STANDARD) + b3Box:Add( b3Ent) + end + nEntId = EgtGetNext( nEntId) + end + + return b3Box +end + +------------------------------------------------------------------ +local function AddZCorrection( b3Box, LayerParams) + + local dNxy = sqrt( LayerParams.vtSlicing:getX() * LayerParams.vtSlicing:getX() + LayerParams.vtSlicing:getY() * LayerParams.vtSlicing:getY()) + local dNz = LayerParams.vtSlicing:getZ() + -- altezza necessaria per lo strand + local dHStrand = 0.5 * LayerParams.dStrand * dNxy + LayerParams.dLayHeight * dNz + -- altezza necessaria per il tool + local dHTool = LayerParams.dTDiam / 2 * dNxy + -- altezza disponibile + local dHBox = EgtGetInfo( s_nPartId, KEY_BOX_MIN_Z, 'i') or 0 + local dHDisp = b3Box:getMin():getZ() - dHBox + + local dCorrZ = max( 0, max( dHStrand, dHTool) - dHDisp) + + -- applico la correzione al pezzo + local vtMove = dCorrZ * Z_AX() + EgtMove( s_nPartId, vtMove, GDB_RT.GLOB) + EgtSetInfo( s_nPartId, KEY_MOVED_PART2, vtMove) + -- correggo la posizione del riferimento + local nFrameId = EgtGetFirstNameInGroup( s_nPartId, LAY_FRAME) + EgtMove( nFrameId, - vtMove, GDB_RT.GLOB) + +end + +------------------------------------------------------------------ +local function FindWipeEndPoint( ptS, vtDir, dLen, vtSlicing) + + local ptE = ptS + vtDir * dLen + -- verifico soddisfi altezza minima per non entrare nella tavola + local k = 1 + while ptE:getZ() < s_dHMin + GEO.EPS_SMALL and k < 36 do + vtDir:rotate( vtSlicing, 10) + ptE = ptS + vtDir * dLen + k = k + 1 + end + + return ptE +end + +------------------------------------------------------------------- +local function AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, bInvert, vtSlicing, dLayHeight) + + local vIds = {} -- vettore con gli id ordinati delle curve nel gruppo dei ToolPath + + local nStart = EgtIf( nOrder == PRINT_ORDER.EXT_INT, 1, #vEntIds) + local nEnd = EgtIf( nOrder == PRINT_ORDER.EXT_INT, #vEntIds, 1) + local nStep = EgtIf( nOrder == PRINT_ORDER.EXT_INT, 1, -1) + local nIdx = 1 + for i = nStart, nEnd, nStep do + -- copio nel gruppo toolpath + if i == nStart then + vIds[nIdx] = EgtCopyGlob( vEntIds[i], nTpathGrpId, GDB_IN.LAST_SON) + else + vIds[nIdx] = EgtCopyGlob( vEntIds[i], vIds[nIdx-1], GDB_IN.AFTER) + end + + -- mi sposto dell'altezza layer + EgtMove( vIds[nIdx], dLayHeight * vtSlicing, GDB_RT.GLOB) + + if EgtCurveIsClosed( vIds[nIdx]) then + EgtSetInfo( vIds[nIdx], KEY_CLOSED_CRV, 1) + -- eventuale inversione + if bInvert then + EgtInvertCurve( vIds[nIdx]) + EgtSetInfo( vIds[nIdx], KEY_INVERTED_CRV, 1) + end + end + + EgtModifyCurveExtrusion( vIds[nIdx], vtSlicing, GDB_RT.GLOB) + EgtSetColor( vIds[nIdx], EgtStdColor('GRAY')) + EgtSetStatus( vIds[nIdx], GDB_ST.ON) + nIdx = nIdx + 1 + end + + return vIds end ------------------------------------------------------------------- @@ -77,7 +156,7 @@ local function AddLink( vCrv, nTpathGrpId, nLinkType, dLinkParam, dSPOffs, dStra local sPrevName = EgtGetName( vCrv[i-1]) local sCurrName = EgtGetName( vCrv[i]) local nType = EgtGetInfo( vCrv[i], KEY_TYPE, 'i') - if sPrevName ~= sCurrName or nType == TYPE.INFILL or nType == TYPE.AUX_SOLID then + if sPrevName ~= sCurrName or nType == TYPE.INFILL or nType == TYPE.AUX_SOLID or nType == TYPE.RIB then k = k + 1 end @@ -108,7 +187,7 @@ local function AddLink( vCrv, nTpathGrpId, nLinkType, dLinkParam, dSPOffs, dStra nLinkId = EgtCurveCompoFromPoints( nTpathGrpId, {EgtEP( vCrv[i-1]), EgtSP( vCrv[i])}) elseif nLinkType == LINK_TYPE.BIARC then local frLoc = Frame3d( ORIG(), vtSlicing) - local nGrpTmp = EgtGroup( nTpathGrpId, frLoc) + local nGrpTmp = EgtGroup( nTpathGrpId, frLoc, GDB_RT.GLOB) local _, _, dAngIni = SphericalFromVector( EgtEV( vCrv[i-1], nGrpTmp)) local _, _, dAngFin = SphericalFromVector( EgtSV( vCrv[i], nGrpTmp)) nLinkId = EgtBiArc( nGrpTmp, EgtEP( vCrv[i-1], nGrpTmp), EgtSP( vCrv[i], nGrpTmp), dAngIni, dAngFin, 0.5) @@ -120,6 +199,7 @@ local function AddLink( vCrv, nTpathGrpId, nLinkType, dLinkParam, dSPOffs, dStra EgtRelocate( nLinkId, vCrv[i], GDB_IN.BEFORE) EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB) EgtSetInfo( nLinkId, KEY_TYPE, TYPE.LINK) + EgtSetName( nLinkId, LINK_CRV) end end end @@ -128,74 +208,116 @@ local function AddLink( vCrv, nTpathGrpId, nLinkType, dLinkParam, dSPOffs, dStra end end +--------------------------------------------------------------------- +local function AddOffsetLeadPoint( vIds, nFirstCopy, dOffsetLP, nLinkType) + + -- se link va fatto solo sulla shell esterna + local nLast = EgtIf( nLinkType == LINK_TYPE.NONE, #vIds, 1) + + if abs( dOffsetLP) > GEO.EPS_SMALL then + for i = 1, nLast do + if dOffsetLP > GEO.EPS_SMALL then + -- taglio curva + EgtTrimCurveStartAtLen( vIds[i], dOffsetLP) + else + -- è necessario aggiungere un tratto + local nAddCrv = EgtCopyGlob( EgtIf( i == 1, nFirstCopy, vIds[i]), vIds[1], GDB_IN.AFTER) + EgtTrimCurveStartAtLen( nAddCrv, EgtCurveLength( nAddCrv) - abs( dOffsetLP)) + EgtAddCurveCompoCurve( vIds[i], nAddCrv, true, false) + end + end + end + + -- elimino curva aux usata per prima shell + EgtErase( nFirstCopy) +end + -------------------------------------------------------------------- local function AddLeadIn( nCrvId, LayerParams, nGrpId) - local ptE = EgtSP( nCrvId) - local vtTang = EgtSV( nCrvId) + local ptE = EgtSP( nCrvId, GDB_ID.ROOT) + local vtTang = EgtSV( nCrvId, GDB_ID.ROOT) local vtOrtho = Vector3d( vtTang) local dAng = 90 - if ( LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.INF_INT_EXT) or - ( not LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.EXT_INT_INF) then + if ( LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.INT_EXT) or + ( not LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.EXT_INT) then dAng = - 90 end vtOrtho:rotate( LayerParams.vtSlicing, dAng) local ptS = ptE - LayerParams.dLeadInTangDist * vtTang + LayerParams.dLeadInOrthoDist * vtOrtho + -- verifico che non affondi nella tavola + if ptS:getZ() < s_dHMin + GEO.EPS_SMALL then return end - local nLeadInCrv = GDB_ID.NULL + local nLeadInCrv if LayerParams.nLeadInType == LEAD_TYPE.LINEAR then - nLeadInCrv = EgtCurveCompoFromPoints( nGrpId, {ptS, ptE}) + nLeadInCrv = EgtCurveCompoFromPoints( nGrpId, {ptS, ptE}, GDB_RT.GLOB) elseif LayerParams.nLeadInType == LEAD_TYPE.ARC then - nLeadInCrv = EgtArc2PV( nGrpId, ptE, ptS, -vtTang) + nLeadInCrv = EgtArc2PV( nGrpId, ptE, ptS, -vtTang, GDB_RT.GLOB) EgtInvertCurve( nLeadInCrv) - end - 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 + + if nLeadInCrv then + EgtRelocate( nLeadInCrv, nCrvId, GDB_IN.BEFORE) + EgtModifyCurveExtrusion( nLeadInCrv, LayerParams.vtSlicing, GDB_RT.GLOB) + EgtSetInfo( nLeadInCrv, KEY_TYPE, TYPE.LINK) + EgtSetName( nLeadInCrv, LEAD_IN_CRV) + end end -------------------------------------------------------------------- local function AddLeadOut( nCrvId, LayerParams, nGrpId) - local ptS = EgtEP( nCrvId) - local vtTang = EgtEV( nCrvId) + local ptS = EgtEP( nCrvId, GDB_ID.ROOT) + local vtTang = EgtEV( nCrvId, GDB_ID.ROOT) local vtOrtho = Vector3d( vtTang) local dAng = - 90 - if ( LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.INF_INT_EXT) or - ( not LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.EXT_INT_INF) then + if ( LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.INT_EXT) or + ( not LayerParams.bInvert and LayerParams.nOrder == PRINT_ORDER.EXT_INT) then dAng = 90 end vtOrtho:rotate( LayerParams.vtSlicing, dAng) local ptE = ptS + LayerParams.dLeadOutTangDist * vtTang + LayerParams.dLeadOutOrthoDist * vtOrtho - local nLeadOutCrv = GDB_ID.NULL + local nLeadOutCrv if LayerParams.nLeadOutType == LEAD_TYPE.LINEAR then - nLeadOutCrv = EgtCurveCompoFromPoints( nGrpId, {ptS, ptE}) + nLeadOutCrv = EgtCurveCompoFromPoints( nGrpId, {ptS, ptE}, GDB_RT.GLOB) elseif LayerParams.nLeadOutType == LEAD_TYPE.ARC then - nLeadOutCrv = EgtArc2PV( nGrpId, ptS, ptE, vtTang) + nLeadOutCrv = EgtArc2PV( nGrpId, ptS, ptE, vtTang, GDB_RT.GLOB) end - 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) + + if nLeadOutCrv then + EgtRelocate( nLeadOutCrv, nCrvId, GDB_IN.AFTER) + EgtModifyCurveExtrusion( nLeadOutCrv, LayerParams.vtSlicing, GDB_RT.GLOB) + EgtSetInfo( nLeadOutCrv, KEY_TYPE, TYPE.LINK) + EgtSetName( nLeadOutCrv, LEAD_OUT_CRV) + end + return nLeadOutCrv end -------------------------------------------------------------------- -local function AddRetraction( nCrvId, LayerParams, dCoastingLen, dWipeLen, dWipeDir) - +local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDir) + -- recupero i parametri per retrazione local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i') local bClosed = EgtGetInfo( nCrvId, KEY_CLOSED_CRV, 'b') or false local bInverted = EgtGetInfo( nCrvId, KEY_INVERTED_CRV, 'b') or false - + -- curva ausiliaria per generare correttamente wipe local nCopyId = EgtCopyGlob( nCrvId, nCrvId, GDB_IN.AFTER) - EgtCloseCurveCompo( nCopyId) - local ptNewStart = EgtEP( nCrvId) - EgtChangeClosedCurveStartPoint( nCopyId, ptNewStart) + 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 + -- caso con sovrapposizione + EgtTrimCurveStartAtParam( nCopyId, dPar) + end + end local nCoastingId if dCoastingLen > GEO.EPS_SMALL then @@ -212,6 +334,7 @@ local function AddRetraction( nCrvId, LayerParams, dCoastingLen, dWipeLen, dWipe else EgtErase( nCrvId) end + EgtModifyCurveExtrusion( nCoastingId, vtSlicing, GDB_RT.GLOB) EgtSetName( nCoastingId, COASTING_CRV) EgtSetInfo( nCoastingId, KEY_TYPE, TYPE.COASTING) EgtSetColor( nCoastingId, EgtStdColor('ORANGE')) @@ -222,36 +345,36 @@ local function AddRetraction( nCrvId, LayerParams, dCoastingLen, dWipeLen, dWipe local nWipeId if bClosed then -- se era chiusa ( quindi analogo alle shell) - nWipeId = EgtCopyGlob( nCopyId, nCoastingId or nCrvId, GDB_IN.AFTER) + nWipeId = nCopyId + nCopyId = nil EgtTrimCurveEndAtLen( nWipeId, dWipeLen) - else - -- se extra shell o infill a zigzag - local vtDir = EgtEV( nCoastingId or nCrvId) + -- se extra shell, infill a zigzag, spiral vase o rib che non termina sulla parete + local vtDir = EgtEV( nCoastingId or nCrvId, GDB_ID.ROOT) local dAng = dWipeDir + s_nDefaultWipeAng -- verifico se necessario cambiare il segno all'angolo local bChangeSign = false - if nType == TYPE.EXTRA_SHELL then - bChangeSign = bInverted - else + if nType == TYPE.INFILL or nType == TYPE.AUX_SOLID then local vtS = EgtGetInfo( nCrvId, KEY_ZIG_ZAG_DIR, 'v') local bSameDir = AreSameVectorApprox( vtS, vtDir) bChangeSign = ( bInverted == bSameDir) + else + bChangeSign = bInverted end - vtDir:rotate( LayerParams.vtSlicing, EgtIf( bChangeSign, - dAng, dAng)) - local ptS = EgtEP( nCoastingId or nCrvId) - local ptE = ptS + vtDir * dWipeLen - nWipeId = EgtCurveCompoFromPoints( EgtGetParent( nCrvId), {ptS, ptE}) - EgtModifyCurveExtrusion( nWipeId, LayerParams.vtSlicing, GDB_RT.GLOB) + vtDir:rotate( vtSlicing, EgtIf( bChangeSign, - dAng, dAng)) + local ptS = EgtEP( nCoastingId or nCrvId, GDB_ID.ROOT) + local ptE = FindWipeEndPoint( ptS, vtDir, dWipeLen, vtSlicing) + nWipeId = EgtCurveCompoFromPoints( EgtGetParent( nCoastingId or nCrvId), {ptS, ptE}, GDB_RT.GLOB) + EgtModifyCurveExtrusion( nWipeId, vtSlicing, GDB_RT.GLOB) EgtRelocateGlob( nWipeId, nCoastingId or nCrvId, GDB_IN.AFTER) end EgtSetName( nWipeId, WIPE_CRV) EgtSetInfo( nWipeId, KEY_TYPE, TYPE.WIPE) - EgtSetColor( nWipeId, EgtStdColor('TEAL')) + EgtSetColor( nWipeId, EgtStdColor('AQUA')) end - - EgtErase( nCopyId) + + if nCopyId then EgtErase( nCopyId) end return nCoastingId end @@ -259,25 +382,186 @@ end local function AddRetractionOnLastCrv( nCrvId, nTpathGrpId, LayerParams, dCoastingLen, dWipeLen, dWipeDir) if LayerParams.nLeadOutType == LEAD_TYPE.NONE then - AddRetraction( nCrvId, LayerParams, dCoastingLen, dWipeLen, dWipeDir) + AddRetraction( nCrvId, LayerParams.vtSlicing, dCoastingLen, dWipeLen, dWipeDir) else local nLeadOutId = EgtGetLastInGroup( nTpathGrpId) local dLen = EgtCurveLength( nLeadOutId) if dLen > dCoastingLen - 500 * GEO.EPS_SMALL then -- coinvolge solo la curva di lead out local dNewCoastingLen = EgtIf( abs( dCoastingLen - dLen) < 500 * GEO.EPS_SMALL, dLen, dCoastingLen) -- verifico se interamente coinvolta - AddRetraction( nLeadOutId, LayerParams, dNewCoastingLen, 0.0, dWipeDir) + AddRetraction( nLeadOutId, LayerParams.vtSlicing, dNewCoastingLen, dWipeLen, dWipeDir) else -- coinvolge parte dell'ultima shell crv local dNewCoastingLen = dCoastingLen - dLen - local nCoastingId = AddRetraction( nCrvId, LayerParams, dNewCoastingLen, 0.0, dWipeDir) + local nCoastingId = AddRetraction( nCrvId, LayerParams.vtSlicing, dNewCoastingLen, 0.0, dWipeDir) EgtAddCurveCompoCurve( nCoastingId, nLeadOutId) + EgtSetInfo( nCoastingId, KEY_CLOSED_CRV, 0) + -- wipe + AddRetraction( nCoastingId, LayerParams.vtSlicing, 0, dWipeLen, dWipeDir) end end end +--------------------------------------------------------------------- +local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams) + + if not vEntIds then return end + + -- 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 + + -- aggiungo gli opportuni raccordi + AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.dStrand, LayerParams.vtSlicing) + + -- offset lead point + AddOffsetLeadPoint( vIds, nFirstCopy, LayerParams.dOffsetLP, LayerParams.nLinkType) + + -- aggiungo leadin/leadout + if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then + AddLeadIn( vIds[1], LayerParams, nTpathGrpId) + end + if LayerParams.nLeadOutType ~= LEAD_TYPE.NONE then + EgtTrimCurveEndAtLen( vIds[#vIds], EgtCurveLength( vIds[#vIds]) - LayerParams.dOffsetLP) + AddLeadOut( vIds[#vIds], LayerParams, nTpathGrpId) + end + + -- aggiungo coasting/wipe + for i = 1, #vIds - 1 do + local nNextId = EgtGetNext( vIds[i]) + if EgtGetInfo( nNextId, KEY_TYPE, 'i') ~= TYPE.LINK then + AddRetraction( vIds[i], LayerParams.vtSlicing, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir) + end + end + -- sull'ultima curva gestione speciale per eventuale lead out + AddRetractionOnLastCrv( vIds[#vIds], nTpathGrpId, LayerParams, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir) + +end + +--------------------------------------------------------------------- +local function CalcExtraShellToolPath( vEntIds, nTpathGrpId, LayerParams) + + if not vEntIds then return end + -- aggiungo le curve nel toolpath + local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, PRINT_ORDER.EXT_INT, false, LayerParams.vtSlicing, LayerParams.dLayHeight) + + -- aggiungo gli opportuni raccordi + local sPrevName = EgtGetName( vIds[1]) + for i = 2, #vIds do + local sCurrName = EgtGetName( vIds[i]) + -- se hanno lo stesso nome vanno collegate + if sCurrName == sPrevName then + local ptS = EgtEP( vIds[i-1]) + local ptE = EgtSP( vIds[i]) + local nLinkId = EgtCurveCompoFromPoints( nTpathGrpId, {ptS, ptE}) + if nLinkId then + EgtRelocateGlob( nLinkId, vIds[i], GDB_IN.BEFORE) + EgtModifyCurveExtrusion( nLinkId, LayerParams.vtSlicing, GDB_RT.GLOB) + EgtSetInfo( nLinkId, KEY_TYPE, TYPE.LINK) + EgtSetName( nLinkId, LINK_CRV) + end + end + sPrevName = sCurrName + end + + -- aggiungo coasting/wipe + for i = 1, #vIds do + -- verifico non sia collegato al successivo tramite link + local nNextId = EgtGetNext( vIds[i]) + if not nNextId or EgtGetInfo( nNextId, KEY_TYPE, 'i') ~= TYPE.LINK then + -- recupero i parametri + local dCoastingLen, dWipeLen, dWipeDir + local bClosed = EgtGetInfo( vIds[i], KEY_CLOSED_CRV, 'b') or false + if not bClosed then + local bInverted = EgtGetInfo( vIds[i], KEY_INVERTED_CRV, 'b') or false + local vCoastLen = EgtGetInfo( vIds[i], KEY_EXTRA_SHELL_COASTING, 'vd') + local vWipeLen = EgtGetInfo( vIds[i], KEY_EXTRA_SHELL_WIPE, 'vd') + local vWipeDir = EgtGetInfo( vIds[i], KEY_EXTRA_SHELL_WIPE_DIR, 'vd') + -- se curva è stata invertita devo prendere le info legate a quello che era il suo punto di inizio, altrimenti prendo le info legate al punto finale + dCoastingLen = EgtIf( bInverted, vCoastLen[1], vCoastLen[2]) + dWipeLen = EgtIf( bInverted, vWipeLen[1], vWipeLen[2]) + dWipeDir = EgtIf( bInverted, vWipeDir[1], vWipeDir[2]) + else + -- se chiusa considero i parametri delle shell complete + dCoastingLen = LayerParams.dCoastingLen + dWipeLen = LayerParams.dWipeLen + dWipeDir = LayerParams.dWipeDir + end + + AddRetraction( vIds[i], LayerParams.vtSlicing, dCoastingLen, dWipeLen, dWipeDir) + end + end +end + +--------------------------------------------------------------------- +local function CalcInfillToolPath( vEntIds, nTpathGrpId, LayerParams) + + if not vEntIds then return end + -- aggiungo le curve nel toolpath + local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, LayerParams.nOrder, LayerParams.bInvert, LayerParams.vtSlicing, LayerParams.dLayHeight) + + -- aggiungo eventuali link + AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.dStrand, LayerParams.vtSlicing) + + -- aggiungo coasting/wipe + for i = 1, #vIds do + local nNextId = EgtGetNext( vIds[i]) + if not nNextId or EgtGetInfo( nNextId, KEY_TYPE, 'i') ~= TYPE.LINK then + AddRetraction( vIds[i], LayerParams.vtSlicing, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir) + end + end +end + +--------------------------------------------------------------------- +local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGrpId, LayerParams) + + if not nAuxSolidsGrp or not nAuxSolidsPathGrp then return end + + -- recupero le curve relative al primo solido ausiliario + local sPrevName = AUX_SOLID_CRV + local nSolidId = EgtGetFirstNameInGroup( nAuxSolidsGrp, AUX_SOLIDS_CRV .. '*') + while nSolidId do + + local sName = EgtGetName( nSolidId) + if sName ~= sPrevName then + + -- recupero tutti i percorsi relativi a quel solido + local vEntIds = EgtGetNameInGroup( nAuxSolidsPathGrp, sName .. '*') + if vEntIds then + + -- recupero i parametri relativi al solido + local nOrder = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_PRINT_ORDER, 'i') + local nLinkType = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_LINK_TYPE, 'i') + local dLinkParam = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_LINK_PARAM, 'd') + local dSPOffset = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_SP_OFFSET, 'd') + local dCoastingLen = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_COASTING_LEN, 'd') + local dWipeLen = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_WIPE_LEN, 'd') + local dWipeDir = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_WIPE_DIR, 'd') + + -- copio i percorsi nel gruppo toolpath + local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, LayerParams.bInvert, LayerParams.vtSlicing, LayerParams.dLayHeight) + + -- aggiungo link + AddLink( vIds, nTpathGrpId, nLinkType, dLinkParam, dSPOffset, LayerParams.dStrand, LayerParams.vtSlicing) + + -- coasting e wipe + for i = 1, #vIds do + local nNextId = EgtGetNext( vIds[i]) + if not nNextId or EgtGetInfo( nNextId, KEY_TYPE, 'i') ~= TYPE.LINK then + AddRetraction( vIds[i], LayerParams.vtSlicing, dCoastingLen, dWipeLen, dWipeDir) + end + end + end + end + sPrevName = sName + nSolidId = EgtGetNextName( nSolidId, AUX_SOLIDS_CRV .. '*') + end +end + +------------------------------------------------------------------- +--------------------------- RIBS ----------------------------------- -------------------------------------------------------------------- -local function VerifyRibsLink( nLinkId, nCurr, nNext, dStrand) +local function VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp) local nGrp = EgtGetParent( nCurr) @@ -286,43 +570,50 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, dStrand) local ptE = EgtEP( nNext) local dParS = EgtCurveParamAtPoint( nLinkId, ptS) local dParE = EgtCurveParamAtPoint( nLinkId, ptE) - if dParS or dParE then + if nCurr ~= nNext and ( dParS or dParE) then return false end -- verifico se si trova nella regione ammissibile local nSurfId = EgtGetInfo( nCurr, KEY_ASSOCIATED_SURF, 'i') local nRes = EgtCurveWithRegionClassify( nLinkId, nSurfId) - if nRes == GDB_CRC.OUT or nRes == GDB_CRC.INTERS then - return false + local nType1 = EgtGetInfo( nCurr, KEY_RIBS_TYPE, 'i') + local nType2 = EgtGetInfo( nNext, KEY_RIBS_TYPE, 'i') + if ( nType1 == RIB_TYPE.INTERNAL or nType1 == RIB_TYPE.SUPPORT) and ( nType2 == RIB_TYPE.INTERNAL or nType2 == RIB_TYPE.SUPPORT) then + if nRes == GDB_CRC.OUT or nRes == GDB_CRC.INTERS then + return false + end + elseif nType1 == RIB_TYPE.EXTERNAL and nType2 == RIB_TYPE.EXTERNAL then + if nRes == GDB_CRC.IN or nRes == GDB_CRC.INTERS then + return false + end end - + -- verifico se il link interseca una delle altre costolature local vRibsIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*') + local nLinkSrf = EgtSurfFrFatCurve( nGrpTmp, nLinkId, 0.5 * dStrand, false) or GDB_ID.NULL for i = 1, #vRibsIds do if vRibsIds[i] ~= nCurr and vRibsIds[i] ~= nNext then - local ptInt = EgtIP( nLinkId, vRibsIds[i], ORIG()) - if ptInt then + local nRes = EgtCurveWithRegionClassify( vRibsIds[i], nLinkSrf) + if nRes == GDB_CRC.INTERS then return false end end end - - EgtErase( nTotLink) return true end -------------------------------------------------------------------- -local function CalcRibsLink( nCurr, nNext, nLoopGrp, dStrand, bForceLink) +local function CalcRibsLink( nCurr, nNext, nLoopGrp, dStrand, bForceLink, vtSlicing, nGrpTmp) local ptS = EgtEP( nCurr) local ptE = EgtSP( nNext) - local nCrvId = EgtGetFirstInGroup( nLoopGrp) + local nCrvId = EgtGetFirstNameInGroup( nLoopGrp, TRIM_SURF_LOOP) -- recupero la curva di offset su cui calcolare link while nCrvId do - local dParS = EgtCurveParamAtPoint( nCrvId, ptS) - local dParE = EgtCurveParamAtPoint( nCrvId, ptE) + local dParS = EgtCurveParamAtPoint( nCrvId, ptS, 10 * GEO.EPS_SMALL) + local dParE = EgtCurveParamAtPoint( nCrvId, ptE, 10 * GEO.EPS_SMALL) if dParS and dParE then local bInvert = false local bClosed = EgtCurveIsClosed( nCrvId) @@ -354,37 +645,54 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, dStrand, bForceLink) EgtTrimCurveStartEndAtParam( nLinkId, dParS, dParE) EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB) + EgtSetName( nLinkId, LINK_CRV) + EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB) if bInvert then EgtInvertCurve( nLinkId) end -- verifico se è valido - local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, dStrand) + local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp) if not bValid then EgtErase( nLinkId) EgtErase( nCopyId) return end + -- elimino dalle curve di contorno il link appena trovato if bClosed then EgtTrimCurveStartEndAtParam( nCrvId, dParE, dParS) EgtErase( nCopyId) else - EgtTrimCurveEndAtParam( nCrvId, dParS) - EgtTrimCurveStartAtParam( nCopyId, dParE) + if dParS < GEO.EPS_SMALL then + -- forzare la fine della curva nel suo inizio significa cancellarla completamente + EgtErase( nCrvId) + else + EgtTrimCurveEndAtParam( nCrvId, dParS) + end + + local _, dEnd = EgtCurveDomain( nCopyId) + if abs( dParE - dEnd) < GEO.EPS_SMALL then + -- forzare l'inizio della curva nella sua fine significa cancellarla completamente + EgtErase( nCopyId) + else + EgtTrimCurveStartAtParam( nCopyId, dParE) + end end return nLinkId end - nCrvId = EgtGetNext( nCrvId) + nCrvId = EgtGetNextName( nCrvId, TRIM_SURF_LOOP) end -- se non ho trovato un collegamento sul bordo, creo una linea tra ptS e ptE if bForceLink then local nLinkId = EgtCurveCompoFromPoints( EgtGetParent( nCurr), {ptS, ptE}) - local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, dStrand) + local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp) if bValid then EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB) + EgtSetName( nLinkId, LINK_CRV) + EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB) EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER) - else + else EgtErase( nLinkId) end end @@ -392,7 +700,7 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, dStrand, bForceLink) end -------------------------------------------------------------------- -local function VerifyRibsLead( nId, nRibId, dStrand, bInVsOut) +local function VerifyRibsLead( nId, nRibId, dStrand, bInVsOut, nGrpTmp) local nGrp = EgtGetParent( nRibId) local nLeadId = EgtCopyGlob( nId, nGrp) @@ -402,12 +710,14 @@ local function VerifyRibsLead( nId, nRibId, dStrand, bInVsOut) EgtExtendCurveEndByLen( nLeadId, dStrand * 0.5) end - -- verifico che intersechi solo l'estrmo corretto - local pt = EgtIf( bInVsOut, EgtEP( nRibId), EgtSP( nRibId)) - local dPar = EgtCurveParamAtPoint( nLeadId, pt) - if dPar then - EgtErase( nLeadId) - return false + -- verifico che intersechi solo l'estremo corretto + if not EgtCurveIsClosed( nRibId) then + local pt = EgtIf( bInVsOut, EgtEP( nRibId), EgtSP( nRibId)) + local dPar = EgtCurveParamAtPoint( nLeadId, pt) + if dPar then + EgtErase( nLeadId) + return false + end end local pt1 = EgtIf( bInVsOut, EgtSP( nLeadId), EgtEP( nLeadId)) @@ -436,9 +746,11 @@ local function VerifyRibsLead( nId, nRibId, dStrand, bInVsOut) -- verifico non intersechi altri setti local vRibsIds = EgtGetNameInGroup( EgtGetParent( nRibId), RIBS_CRV .. '*') + local nLeadLoc = EgtCopyGlob( nLeadId, nGrpTmp) for i = 1, #vRibsIds do if vRibsIds[i] ~= nRibId then - local ptInt = EgtIP( nLeadId, vRibsIds[i], ORIG()) + local nCrvLoc = EgtCopyGlob( vRibsIds[i], nGrpTmp) + local ptInt = EgtIP( nLeadLoc, nCrvLoc, ORIG()) if ptInt then EgtErase( nLeadId) return false @@ -479,7 +791,7 @@ local function VerifyRibsLead( nId, nRibId, dStrand, bInVsOut) end ------------------------------------------------------------------- -local function FindCorrectRibsLead( dPar, nCrv, nCrvOffs, bLeadInvert, dLeadLen, dStrand, bInVsOut) +local function FindCorrectRibsLead( dPar, nCrv, nCrvOffs, bLeadInvert, dLeadLen, dStrand, bInVsOut, nGrpTmp) local nLeadId local bInvert = bLeadInvert -- valore di default è quello settato nel file dei parametri @@ -489,7 +801,7 @@ local function FindCorrectRibsLead( dPar, nCrv, nCrvOffs, bLeadInvert, dLeadLen, local bOnlyOneCurve = not bClosed and ( dPar < GEO.EPS_SMALL or abs( dPar - dParEnd) < GEO.EPS_SMALL) local nMainCrv = nCrvOffs -- curva preferita da utilizzare per lead in - local nOtherCrv -- altra possibile curva da ultizzare nel caso nMainCrv non sia adatta + local nOtherCrv -- altra possibile curva da ultizzare nel caso nMainCrv non sia adatta if bClosed then EgtChangeClosedCurveStart( nCrvOffs, dPar) @@ -522,7 +834,7 @@ local function FindCorrectRibsLead( dPar, nCrv, nCrvOffs, bLeadInvert, dLeadLen, if bInvert then EgtInvertCurve( nLeadId) end EgtTrimCurveEndAtLen( nLeadId, dLeadLen) if bInVsOut then EgtInvertCurve( nLeadId) end - if VerifyRibsLead( nLeadId, nCrv, dStrand, bInVsOut) then + if VerifyRibsLead( nLeadId, nCrv, dStrand, bInVsOut, nGrpTmp) then -- se valido aggiorno le curve per prossimi lead in/out if bInvert then EgtTrimCurveEndAtLen( nMainCrv, EgtCurveLength( nCrvOffs) - dLeadLen) @@ -535,12 +847,12 @@ local function FindCorrectRibsLead( dPar, nCrv, nCrvOffs, bLeadInvert, dLeadLen, return nil else -- se non è valido ma ho altra curva possibile, tento con quella - EgtErase( nLeadId) + EgtErase( nLeadId) nLeadId = EgtCopyGlob( nOtherCrv, nCrv, EgtIf( bInVsOut, GDB_IN.BEFORE, GDB_IN.AFTER)) if not bInvert then EgtInvertCurve( nLeadId) end EgtTrimCurveEndAtLen( nLeadId, dLeadLen) if bInVsOut then EgtInvertCurve( nLeadId) end - if VerifyRibsLead( nLeadId, nCrv, dStrand, bInVsOut) then + if VerifyRibsLead( nLeadId, nCrv, dStrand, bInVsOut, nGrpTmp) then if bInvert then EgtTrimCurveStartAtLen( nOtherCrv, dLeadLen) else @@ -548,34 +860,35 @@ local function FindCorrectRibsLead( dPar, nCrv, nCrvOffs, bLeadInvert, dLeadLen, end else EgtErase( nLeadId) - bInvert = not bInvert + bInvert = not bInvert return nil end -- aggiorno parametro bInvert - bInvert = not bInvert + bInvert = not bInvert end return nLeadId, bInvert end -------------------------------------------------------------------- -local function AddRibsLeadIn( nCrv, nLoopsGrp, dStrand) - +local function AddRibsLeadIn( nCrv, nLoopsGrp, dStrand, vtSlicing, nGrpTmp) + local dLILen = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_LEN, 'd') local bLIInvert = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_INVERT, 'b') if dLILen < GEO.EPS_SMALL then return end - + -- recupero la curva di offset su cui calcolare leadin local ptS = EgtSP( nCrv) local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp) - while nCrvOffs do + while nCrvOffs do local dParS = EgtCurveParamAtPoint( nCrvOffs, ptS) if dParS then - local nLeadIn = FindCorrectRibsLead( dParS, nCrv, nCrvOffs, bLIInvert, dLILen, dStrand, true) + local nLeadIn = FindCorrectRibsLead( dParS, nCrv, nCrvOffs, bLIInvert, dLILen, dStrand, true, nGrpTmp) -- se lead in possibile if nLeadIn then + EgtModifyCurveExtrusion( nLeadIn, vtSlicing, GDB_RT.GLOB) EgtSetInfo( nLeadIn, KEY_TYPE, TYPE.RIB) EgtSetName( nLeadIn, LEAD_IN_CRV) end @@ -587,7 +900,7 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, dStrand) end -------------------------------------------------------------------- -local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand) +local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand, nGrpTmp, bForceNoBorder) local dRibsLOLen = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_LEN, 'd') local dRibsLOCoasting = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_COASTING, 'd') @@ -599,13 +912,18 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand) abs( dRibsLOCoasting) < GEO.EPS_SMALL and abs( dRibsLOWipe) < GEO.EPS_SMALL then return end - local ptE = EgtEP( nCrv) - local vtE = EgtEV( nCrv) - + -- se setto chiuso oppure non deve stare sul bordo (rib unbounded) applico la stessa uscita delle shell + if EgtCurveIsClosed( nCrv) or bForceNoBorder then + return AddRetraction( nCrv, vtSlicing, dRibsLOCoasting, dRibsLOWipe, dRibsLOWipeAng) + end + + local ptE = EgtEP( nCrv, GDB_ID.ROOT) + local vtE = EgtEV( nCrv, GDB_ID.ROOT) + -- recupero la curva di offset su cui calcolare lead out local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp) while nCrvOffs do - local dParE = EgtCurveParamAtPoint( nCrvOffs, ptE) + local dParE = EgtCurveParamAtPoint( nCrvOffs, ptE, GEO.EPS_SMALL, GDB_RT.GLOB) if dParE then local nCrvLO @@ -613,22 +931,23 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand) local nWipe -- trovo curva opportuna per lead out - local nCrvRef, bInvert = FindCorrectRibsLead( dParE, nCrv, nCrvOffs, bRibsLOInvert, dRibsLOLen + dRibsLOCoasting, dStrand, false) - + local nCrvRef, bInvert = FindCorrectRibsLead( dParE, nCrv, nCrvOffs, bRibsLOInvert, dRibsLOLen + dRibsLOCoasting, dStrand, false, nGrpTmp) + if nCrvRef then -- verifico se la curva ha lunghezza sufficiente local dLen = EgtCurveLength( nCrvRef) local bSkip = ( dLen - dRibsLOLen - dRibsLOCoasting < - GEO.EPS_SMALL) - + -- primo tratto ( segue offset con flusso aperto) if dRibsLOLen > GEO.EPS_SMALL and not bSkip then nCrvLO = EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER) EgtTrimCurveEndAtLen( nCrvLO, dRibsLOLen) + EgtModifyCurveExtrusion( nCrvLO, vtSlicing, GDB_RT.GLOB) EgtSetInfo( nCrvLO, KEY_TYPE, TYPE.RIB) EgtSetName( nCrvLO, LEAD_OUT_CRV) -- aggiorno ptE e vtE - ptE = EgtEP( nCrvLO) - vtE = EgtEV( nCrvLO) + ptE = EgtEP( nCrvLO, GDB_ID.ROOT) + vtE = EgtEV( nCrvLO, GDB_ID.ROOT) end -- secondo tratto ( segue offset con flusso chiuso) @@ -636,73 +955,71 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing, dStrand) nCoasting = EgtCopyGlob( nCrvRef, nCrvLO or nCrv, GDB_IN.AFTER) EgtTrimCurveStartAtLen( nCoasting, dRibsLOLen) EgtTrimCurveEndAtLen( nCoasting, dRibsLOCoasting) + EgtModifyCurveExtrusion( nCoasting, vtSlicing, GDB_RT.GLOB) EgtSetName( nCoasting, COASTING_CRV) EgtSetInfo( nCoasting, KEY_TYPE, TYPE.COASTING) EgtSetColor( nCoasting, EgtStdColor('ORANGE')) -- aggiorno ptE e vtE - ptE = EgtEP( nCoasting) - vtE = EgtEV( nCoasting) + ptE = EgtEP( nCoasting, GDB_ID.ROOT) + vtE = EgtEV( nCoasting, GDB_ID.ROOT) end EgtErase( nCrvRef) + + -- terzo tratto ( diretto verso esterno con ugello chiuso) + if dRibsLOWipe > GEO.EPS_SMALL then + local dAng = dRibsLOWipeAng + s_nDefaultWipeAng + local nType = EgtGetInfo( nCrv, KEY_RIBS_TYPE, 'i') + if nType == RIB_TYPE.EXTERNAL then dAng = - dAng end + vtE:rotate( vtSlicing, EgtIf( bInvert, - dAng, dAng)) + local ptFinal = FindWipeEndPoint( ptE, vtE, dRibsLOWipe, vtSlicing) + nWipe = EgtCurveCompoFromPoints( nTPathGrp, { ptE, ptFinal}, GDB_RT.GLOB) + EgtModifyCurveExtrusion( nWipe, vtSlicing, GDB_RT.GLOB) + EgtRelocateGlob( nWipe, nCoasting or nCrvLO or nCrv, GDB_IN.AFTER) + EgtSetName( nWipe, WIPE_CRV) + EgtSetInfo( nWipe, KEY_TYPE, TYPE.WIPE) + EgtSetColor( nWipe, EgtStdColor('AQUA')) + end + else + -- aggiungo coasting e wipe come sulle shell normali + AddRetraction( nCrv, vtSlicing, dRibsLOCoasting, dRibsLOWipe, dRibsLOWipeAng) end - - -- terzo tratto ( diretto verso esterno con ugello chiuso) - if dRibsLOWipe > GEO.EPS_SMALL then - local dAng = dRibsLOWipeAng + s_nDefaultWipeAng - vtE:rotate( vtSlicing, EgtIf( bInvert, - dAng, dAng)) - local ptFinal = ptE + vtE * dRibsLOWipe - nWipe = EgtCurveCompoFromPoints( nTPathGrp, { ptE, ptFinal}) - EgtModifyCurveExtrusion( nWipe, vtSlicing, GDB_RT.GLOB) - EgtRelocateGlob( nWipe, nCoasting or nCrvLO or nCrv, GDB_IN.AFTER) - EgtSetName( nWipe, WIPE_CRV) - EgtSetInfo( nWipe, KEY_TYPE, TYPE.WIPE) - EgtSetColor( nWipe, EgtStdColor('TEAL')) - end - - return + return end nCrvOffs = EgtGetNext( nCrvOffs) end + -- se non ho trovato curva sul bordo su cui fare il lead out aggiungo coasting e wipe come sulle shell normali + AddRetraction( nCrv, vtSlicing, dRibsLOCoasting, dRibsLOWipe, dRibsLOWipeAng) + end --------------------------------------------------------------------- -local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) +local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams) - local nRibsGrp = EgtGetFirstNameInGroup( nCrvGrp, RIBS_GRP) + if not vEntIds or #vEntIds == 0 then return end + + -- gruppo temporaneo con sistema di riferimento locale per conti + local frLoc = Frame3d( ORIG(), LayerParams.vtSlicing) + local nGrpTmp = EgtGroup( nRibsGrp, frLoc, GDB_RT.GLOB) + -- aggiungo le costolature nel toolpath - local vEntIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') + local nNewFirstEnt for i = 1, #vEntIds do - -- copio entità nel gruppo toolpath + -- copio entità nel gruppo toolpath local nNewEntId = EgtCopyGlob( vEntIds[i], nTpathGrpId, GDB_IN.LAST_SON) - -- correggo posizione in Z ( per essere sicuri di appoggiare sul piano) - EgtMove( nNewEntId, dCorrZ * Z_AX(), GDB_RT.GLOB) -- 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 - - -- estraggo i contorni di tutte le superfici di offset - local nLoopGrp = EgtGroup( nRibsGrp) - local nSrfId = EgtGetFirstNameInGroup( nRibsGrp, TOT_SHELL_TRIM_SURF) - while nSrfId do - EgtMove( nSrfId, dCorrZ * Z_AX(), GDB_RT.GLOB) - -- mi sposto dell'altezza layer - EgtMove( nSrfId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) - local nChunksNbr = EgtSurfFrChunkCount( nSrfId) - for i = 0, nChunksNbr do - local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfId, i, nLoopGrp) - end - nSrfId = EgtGetNextName( nSrfId, TOT_SHELL_TRIM_SURF) + EgtSetColor( nNewEntId, EgtStdColor('MAROON')) + if i == 1 then nNewFirstEnt = nNewEntId end end -- recupero i gruppi delle costolature local tabRibs = {} - local nFirst = EgtGetFirstNameInGroup( nTpathGrpId, RIBS_CRV .. '*') + local nFirst = nNewFirstEnt while nFirst do local sName = EgtGetName( nFirst) local vIds = EgtGetNameInGroup( nTpathGrpId, sName) @@ -710,203 +1027,286 @@ local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) nFirst = EgtGetNextName( vIds[#vIds], RIBS_CRV .. '*') end - local bInters = EgtGetInfo( nRibsGrp, KEY_RIBS_INTERS, 'b') or false - local bAllTwoStrands = EgtGetInfo( nRibsGrp, KEY_RIBS_TWO_STRANDS, 'b') or false - local bSpecialCase = bInters and bAllTwoStrands - local bSwap = false - -- orientamento del primo gruppo di curve - local bInvert = EgtGetInfo( tabRibs[1][1], KEY_RIBS_INVERT_DIR, 'b') - if not bSpecialCase then - for i = 1, #tabRibs do - local nInfo = EgtGetInfo( tabRibs[i][1], KEY_SPLIT_RIB, 'i') - local nShellsNbr = EgtGetInfo( tabRibs[i][1], KEY_RIBS_SHELLS_NBR, 'i') - -- aggiorno bInvert per il gruppo di costolature analizzato - if not LayerParams.bRibsLink then - bInvert = EgtGetInfo( tabRibs[i][1], KEY_RIBS_INVERT_DIR, 'b') - else - if i > 1 and not nInfo then - local nPrevShellsNbr = EgtGetInfo( tabRibs[i-1][1], KEY_RIBS_SHELLS_NBR, 'i') - if nPrevShellsNbr % 2 == 1 then - bInvert = not bInvert + local bSpecialCase = EgtGetInfo( nRibsGrp, KEY_RIBS_SPECIAL_CASE, 'b') or false + + -- Link + local nLoopGrp = EgtGetFirstGroupInGroup( nRibsGrp) + -- collego le passate di una stessa costolatura + for i = 1, #tabRibs do + if EgtCurveIsClosed( tabRibs[i][1]) then + AddLink( tabRibs[i], nTpathGrpId, LINK_TYPE.NONE, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.dStrand, LayerParams.vtSlicing) + else + local bLoopRib = EgtGetInfo( tabRibs[i][1], KEY_LOOP_RIB, 'b') or false + for j = 1, #tabRibs[i] - 1 do + local bUserLink = EgtGetInfo( tabRibs[i][j], KEY_RIBS_USER_LINK, 'b') or false + local nOrig1 = EgtGetInfo( tabRibs[i][j], KEY_ORIGINAL_RIB, 'i') or 0 + local nOrig2 = EgtGetInfo( tabRibs[i][j + 1], KEY_ORIGINAL_RIB, 'i') or 0 + local nSplitId1 = EgtGetInfo( tabRibs[i][j], KEY_SPLIT_ID, 'i') or 0 + local nSplitId2 = EgtGetInfo( tabRibs[i][j + 1], KEY_SPLIT_ID, 'i') or 0 + local bForceLink = ( nOrig1 == nOrig2) + + if ( nOrig1 ~= nOrig2 and bUserLink) or ( nSplitId1 == nSplitId2 and nOrig1 == nOrig2) then + local nLinkId = CalcRibsLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, LayerParams.dStrand, bForceLink, LayerParams.vtSlicing, nGrpTmp) + -- creo link fittizio per eliminare tratto corrispondente sulla curva di offset + if not bSpecialCase and bForceLink then + local nFakeLink = CalcRibsLink( tabRibs[i][j + 1], tabRibs[i][j], nLoopGrp, LayerParams.dStrand, false, LayerParams.vtSlicing, nGrpTmp) + EgtErase( nFakeLink) + end + + -- se LoopRib congiungo i setti in unico percorso + if bLoopRib and 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 end end end - if nShellsNbr == 1 and nInfo and bInvert then - -- se inverto direzione di costolature divise allora devo invertirne anche l'ordine di realizzazione - bSwap = true - EgtRelocateGlob( tabRibs[i][1], tabRibs[i-1][1], GDB_IN.BEFORE) - end - - -- oriento tutte le passate relative ad una stessa costolatura - for j = 1, #tabRibs[i] do - if ( bInvert and j % 2 == 1) or ( not bInvert and j % 2 == 0) then - EgtInvertCurve( tabRibs[i][j]) + -- se LoopRib aggiungo collegamento tra primo e ultimo setto del gruppo + if bLoopRib then + local nTotCrv = #tabRibs[i] + local nLinkId = CalcRibsLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, LayerParams.dStrand, false, LayerParams.vtSlicing, nGrpTmp) + if nLinkId then + -- se curva unica + if tabRibs[i][nTotCrv] == tabRibs[i][1] then + EgtAddCurveCompoCurve( tabRibs[i][1], nLinkId) + -- setto info di curva chiusa per gestire correttamente il wipe + EgtSetInfo( tabRibs[i][1], KEY_CLOSED_CRV, 1) + -- modifica dello start point ( considera quello delle shell) + local nCrvGrp = EgtGetParent( nTpathGrpId) + local ptStart = EgtGetInfo( nCrvGrp, KEY_START_POINT, 'p') + if ptStart then + EgtChangeClosedCurveStartPoint( tabRibs[i][1], ptStart) + end + else + EgtAddCurveCompoCurve( tabRibs[i][1], nLinkId, true, false) + EgtAddCurveCompoCurve( tabRibs[i][1], tabRibs[i][nTotCrv], true, false) + tabRibs[i][nTotCrv] = tabRibs[i][1] + end end end - end - end - - -- Link - -- se modifiche nell'ordine ricalcolo i gruppi di costolature - if bSwap then - tabRibs = {} - nFirst = EgtGetFirstNameInGroup( nTpathGrpId, RIBS_CRV .. '*') - while nFirst do - local sName = EgtGetName( nFirst) - local vIds = EgtGetNameInGroup( nTpathGrpId, sName) - table.insert( tabRibs, vIds) - nFirst = EgtGetNextName( vIds[#vIds], RIBS_CRV .. '*') - end - end - - -- collego le passate di una stessa costolatura - for i = 1, #tabRibs do - for j = 1, #tabRibs[i] - 1 do - CalcRibsLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, LayerParams.dStrand, true) - if not bSpecialCase then - -- creo link fittizio per eliminare tratto corrispondente sulla curva di offset - local nFakeLink = CalcRibsLink( tabRibs[i][j + 1], tabRibs[i][j], nLoopGrp, LayerParams.dStrand, false) + + if bSpecialCase then + local nFakeLink = CalcRibsLink( tabRibs[i][#tabRibs[i]], tabRibs[i][1], nLoopGrp, LayerParams.dStrand, false, LayerParams.vtSlicing, nGrpTmp) EgtErase( nFakeLink) end end - if bSpecialCase then - local nFakeLink = CalcRibsLink( tabRibs[i][#tabRibs[i]], tabRibs[i][1], nLoopGrp, LayerParams.dStrand, false) - EgtErase( nFakeLink) - end end + -- se necessario collego le diverse costolature - if LayerParams.bRibsLink then - for i = 1, #tabRibs - 1 do + for i = 1, #tabRibs - 1 do + local bLink1 = EgtGetInfo( tabRibs[i][1], KEY_RIBS_LINK, 'b') + local bLink2 = EgtGetInfo( tabRibs[i + 1][1], KEY_RIBS_LINK, 'b') + if bLink1 and bLink2 then local nCnt = #tabRibs[i] - CalcRibsLink( tabRibs[i][nCnt], tabRibs[i + 1][1], nLoopGrp, LayerParams.dStrand, false) + CalcRibsLink( tabRibs[i][nCnt], tabRibs[i + 1][1], nLoopGrp, LayerParams.dStrand, false, LayerParams.vtSlicing, nGrpTmp) end end -- leadin/leadout - local nCrvRib = EgtGetFirstNameInGroup( nTpathGrpId, RIBS_CRV .. '*') + local bForceNoBorder = false + local nType = EgtGetInfo( vEntIds[1], KEY_RIBS_TYPE, 'i') + if nType == RIB_TYPE.UNBOUNDED then + bForceNoBorder = true + end + local nCrvRib = nNewFirstEnt while nCrvRib do -- verifico se necessario lead in local nPrev = EgtGetPrev( nCrvRib) - if not nPrev or EgtGetName( nPrev) then - AddRibsLeadIn( nCrvRib, nLoopGrp, LayerParams.dStrand) + if ( not nPrev or EgtGetName( nPrev) ~= LINK_CRV) and not bForceNoBorder then + AddRibsLeadIn( nCrvRib, nLoopGrp, LayerParams.dStrand, LayerParams.vtSlicing, nGrpTmp) end -- verifico se necessario lead out local nNext = EgtGetNext( nCrvRib) - if not nNext or EgtGetName( nNext) then - AddRibsLeadOut( nCrvRib, nTpathGrpId, nLoopGrp, LayerParams.vtSlicing, LayerParams.dStrand) + if not nNext or EgtGetName( nNext) ~= LINK_CRV then + AddRibsLeadOut( nCrvRib, nTpathGrpId, nLoopGrp, LayerParams.vtSlicing, LayerParams.dStrand, nGrpTmp, bForceNoBorder) end nCrvRib = EgtGetNextName( nCrvRib, RIBS_CRV .. '*') end + + EgtErase( nGrpTmp) + +end + +------------------------------------------------------------------- +------------------------- SPIRAL VASE ------------------------------ +-------------------------------------------------------------------- +local function AddSpiralVaseLeadOut( nOldId, LayerParams) + + if LayerParams.nLeadOutType ~= LEAD_TYPE.NONE then + EgtTrimCurveEndAtLen( nOldId, EgtCurveLength( nOldId) - LayerParams.dOffsetLP) + local nLeadOut = AddLeadOut( nOldId, LayerParams, EgtGetParent( nOldId)) + if nLeadOut then + local dDelta = LayerParams.dLayHeight / EgtCurveLength( nOldId) * EgtCurveLength( nLeadOut) + EgtSpiralizeCurveAlongExtrusion( nLeadOut, dDelta) + end + AddRetractionOnLastCrv( nOldId, EgtGetParent( nOldId), LayerParams, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir) + else + AddRetraction( nOldId, LayerParams.vtSlicing, LayerParams.dCoastingLen, LayerParams.dWipeLen, LayerParams.dWipeDir) + end + end --------------------------------------------------------------------- -local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGrpId, LayerParams, dCorrZ) +local function SpiralVase( vLayIds, LayerParams) - -- recupero le curve relative al primo solido ausiliario - local sPrevName = AUX_SOLID_CRV - local nSolidId = EgtGetFirstNameInGroup( nAuxSolidsGrp, AUX_SOLIDS_CRV .. '*') - while nSolidId do - - local sName = EgtGetName( nSolidId) - if sName ~= sPrevName then - - -- recupero tutti i percorsi relativi a quel solido - local vEntIds = EgtGetNameInGroup( nAuxSolidsPathGrp, sName .. '*') - if vEntIds then - - -- recupero i parametri relativi al solido - local nOrder = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_PRINT_ORDER, 'i') - local nLinkType = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_LINK_TYPE, 'i') - local dLinkParam = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_LINK_PARAM, 'd') - local dSPOffset = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_SP_OFFSET, 'd') - local dCoastingLen = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_COASTING_LEN, 'd') - local dWipeLen = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_WIPE_LEN, 'd') - local dWipeDir = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_WIPE_DIR, 'd') - - -- copio i percorsi nel gruppo toolpath - local nPrev = EgtGetLastInGroup( nTpathGrpId) - for i = 1, #vEntIds do - local nNewEnt = EgtCopyGlob( vEntIds[i], nPrev, EgtIf( i == 1 or nOrder == PRINT_ORDER.EXT_INT_INF, GDB_IN.AFTER, GDB_IN.BEFORE)) - - -- correggo posizione - EgtMove( nNewEnt, dCorrZ * Z_AX(), GDB_RT.GLOB) - EgtMove( nNewEnt, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) - EgtModifyCurveExtrusion( nNewEnt, LayerParams.vtSlicing, GDB_RT.GLOB) - EgtSetInfo( nNewEnt, KEY_TYPE, TYPE.AUX_SOLID) - - if EgtCurveIsClosed( nNewEnt) then - EgtSetInfo( nNewEnt, KEY_CLOSED_CRV, 1) - -- eventuale inversione curva - if LayerParams.bInvert then - EgtInvertCurve( nNewEnt) - end - end - - nPrev = nNewEnt - end - - local vNewEntIds = EgtGetNameInGroup( nTpathGrpId, sName .. '*') - - -- Aggiungo link - AddLink( vNewEntIds, nTpathGrpId, nLinkType, dLinkParam, dSPOffset, LayerParams.dStrand, LayerParams.vtSlicing) - - -- Coasting e wipe - for i = 1, #vNewEntIds do - local nNextId = EgtGetNext( vNewEntIds[i]) or GDB_ID.NULL - local nType = EgtGetInfo( nNextId, KEY_TYPE, 'i') - if nType ~= TYPE.LINK then - AddRetraction( vNewEntIds[i], LayerParams, dCoastingLen, dWipeLen, dWipeDir) - end - end - end - end - sPrevName = sName - nSolidId = EgtGetNextName( nSolidId, AUX_SOLIDS_CRV .. '*') + local nOldId, nOldPathId + local bFirst = true + local nSlicingType = EgtGetInfo( s_nPartId, KEY_SLICING_TYPE, 'i') + + -- copio ultimo layer + if nSlicingType ~= SLICING_TYPE.DEG45_X and nSlicingType ~= SLICING_TYPE.DEG45_Y then + local nNewLay = EgtCopyGlob( vLayIds[#vLayIds], vLayIds[#vLayIds], GDB_IN.AFTER) + table.insert( vLayIds, nNewLay) + EgtMove( nNewLay, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) + -- aggiorno nome e info + local sOldIdx = string.sub( EgtGetName( vLayIds[#vLayIds]), 6) + local nNewIdx = tonumber( sOldIdx) + 1 + EgtSetName( nNewLay, SLICE_LAYER .. EgtNumToString( nNewIdx)) + EgtSetInfo( nNewLay, KEY_SLICE_NBR, nNewIdx) + local dZOld = EgtGetInfo( vLayIds[#vLayIds], KEY_SLICE_Z, 'd') or 0 + EgtSetInfo( nNewLay, KEY_SLICE_Z, dZOld + LayerParams.dLayHeight) end + + local b3Tot = BBox3d() + -- ciclo sui layer + for nIdx = 1, #vLayIds do + + -- cerco i gruppi di contorni + local vCrvGrpIds = EgtGetNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*") + if #vCrvGrpIds > 1 then + -- se più di un gruppo di curve warning + EgtOutLog( 'Warning : in spiral vase mode more than one curve (layer '..tostring( nIdx)..') - CalcToolPath') + end + + for i = 1, #vCrvGrpIds do + -- recupero il gruppo dei percorsi + local nPathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[i], PATH_GRP) + if not nPathGrpId then + EgtOutBox( 'Error missing paths', 'ToolPathCalc') + return + else + EgtSetStatus( nPathGrpId, GDB_ST.OFF) + end + + -- recupero il gruppo dei percorsi utensile + local nTpathGrpId = EgtGetFirstNameInGroup( vCrvGrpIds[i], TOOLPATH_GRP) + if not nTpathGrpId then + nTpathGrpId = EgtGroup( vCrvGrpIds[i]) + EgtSetName( nTpathGrpId, TOOLPATH_GRP) + else + EgtEmptyGroup( nTpathGrpId) + end + + -- creo il percorso di lavoro : + local nEntId = EgtGetFirstInGroup( nPathGrpId) + while nEntId do + local nNewEntId = EgtCopyGlob( nEntId, nTpathGrpId, GDB_IN.LAST_SON) + + 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) + -- 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) + 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 + 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) + EgtChangeClosedCurveStartPoint( nGuideId, 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) + end + EgtSpiralizeCurveAlongExtrusion( nNewEntId, LayerParams.dLayHeight) + end + + nOldPathId = nEntId + nOldId = nNewEntId + nEntId = EgtGetNext( nEntId) + end + + -- 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 + EgtDraw() + return false + end + end + + -- aggiungo uscita, coasting e wipe su ultima curva + AddSpiralVaseLeadOut( nOldId, LayerParams) + + -- correzione in z + AddZCorrection( b3Tot, LayerParams) + + return true end --------------------------------------------------------------------- function CalcToolPath.Exec( nPartId) s_nPartId = nPartId - - -- Verifico il pezzo - if not s_nPartId then - EgtOutBox( 'Error missing part', 'ToolPathCalc') - return - end - + -- Recupero i layer da processare - local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*") + local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*") if not vLayIds then EgtOutBox( 'Error missing slices', 'ToolPathCalc') - return + return true end -- recupero i parametri per calcolo dei toolpath local LayerParams = GetLayerParamsForToolPathCalc() - local dCorrZ = ComputeZCorrection( LayerParams) - - -- se necessario sposto anche il solido di partenza - if dCorrZ > 10 * GEO.EPS_SMALL then - local vtMove = Vector3d( 0, 0, dCorrZ) + LayerParams.dLayHeight / 2 * LayerParams.vtSlicing - local SolidLayId = EgtGetFirstNameInGroup( s_nPartId, PRINT_SOLID) - if SolidLayId then - EgtSetInfo( s_nPartId, KEY_MOVED_PART, vtMove) - local EntId = EgtGetFirstInGroup( SolidLayId) - while EntId do - EgtMove( EntId, vtMove) - EntId = EgtGetNext( EntId) - end - end + + -- altezza necessaria per correzione wipe + local dNxy = sqrt( LayerParams.vtSlicing:getX() * LayerParams.vtSlicing:getX() + LayerParams.vtSlicing:getY() * LayerParams.vtSlicing:getY()) + local dHBox = EgtGetInfo( s_nPartId, KEY_BOX_MIN_Z, 'i') or 0 + s_dHMin = LayerParams.dTDiam / 2 * dNxy + dHBox + + -- caso spiral vase + if LayerParams.bSpiralVase then + return SpiralVase( vLayIds, LayerParams) end + local b3Tot = BBox3d() -- box dei toolpath + -- Ciclo sui layer for nIdx = 1, #vLayIds do - - -- recupero eventuale gruppo di solidi ausiliari - nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], AUX_SOLIDS_GRP) + -- scorro tutti i gruppi di contorni local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*") while nCrvGrpId do @@ -914,10 +1314,10 @@ function CalcToolPath.Exec( nPartId) local nPathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, PATH_GRP) if not nPathGrpId then EgtOutBox( 'Error missing paths', 'ToolPathCalc') - return + return else EgtSetStatus( nPathGrpId, GDB_ST.OFF) - end + end -- recupero il gruppo dei percorsi utensile local nTpathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, TOOLPATH_GRP) if not nTpathGrpId then @@ -926,117 +1326,69 @@ function CalcToolPath.Exec( nPartId) else EgtEmptyGroup( nTpathGrpId) end - -- creo il percorso di lavoro : - -- copio le curve, le ordino, le oriento e le muovo in Z - local nEntId = EgtGetFirstInGroup( nPathGrpId) - while nEntId do - local nNewEntId = EgtCopyGlob( nEntId, nTpathGrpId, EgtIf( LayerParams.nOrder == PRINT_ORDER.INF_INT_EXT, GDB_IN.FIRST_SON, GDB_IN.LAST_SON)) - -- correggo posizione in Z ( per essere sicuri di appoggiare sul piano) - EgtMove( nNewEntId, dCorrZ * Z_AX(), GDB_RT.GLOB) - -- mi sposto dell'altezza layer - EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) - -- eventuale inversione - local nType = EgtGetInfo( nNewEntId, KEY_TYPE, 'i') - if LayerParams.bInvert then - if nType == TYPE.OUTER_SHELL or nType == TYPE.INNER_SHELL or ( nType == TYPE.INFILL and EgtCurveIsClosed( nNewEntId)) then - EgtInvertCurve( nNewEntId) - EgtSetInfo( nNewEntId, KEY_INVERTED_CRV, 1) - end - end - - if EgtCurveIsClosed( nNewEntId) then - EgtSetInfo( nNewEntId, KEY_CLOSED_CRV, 1) - end - - EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB) - EgtSetColor( nNewEntId, EgtStdColor('GRAY')) - nEntId = EgtGetNext( nEntId) - end - - -- aggiungo gli opportuni raccordi sulle shell complete - local vIds = EgtGetAllInGroup( nTpathGrpId) - AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.dStrand, LayerParams.vtSlicing) - -- aggiungo gli opportuni raccordi sulle shell con numero diverso di passate - local nPrev = EgtGetFirstNameInGroup( nTpathGrpId, EXTRA_SHELL_CRV .. '*') - local sPrevName = EgtGetName( nPrev or GDB_ID.NULL) - local nCurr = EgtGetNextName( nPrev or GDB_ID.NULL, EXTRA_SHELL_CRV .. '*') - while nCurr do - local sCurrName = EgtGetName( nCurr) - if sCurrName == sPrevName then - local ptS = EgtEP( nPrev) - local ptE = EgtSP( nCurr) - local nLinkId = EgtCurveCompoFromPoints( nTpathGrpId, {ptS, ptE}) - EgtRelocateGlob( nLinkId, nCurr, GDB_IN.BEFORE) - EgtSetInfo( nLinkId, KEY_TYPE, TYPE.LINK) - end - sPrevName = sCurrName - nPrev = nCurr - nCurr = EgtGetNextName( nCurr, EXTRA_SHELL_CRV .. '*') - end - - -- aggiungo leadin/leadout - local nFirstCurve = EgtGetFirstInGroup( nTpathGrpId) - if nFirstCurve and LayerParams.nLeadInType ~= LEAD_TYPE.NONE then - EgtTrimCurveStartAtLen( nFirstCurve, LayerParams.dOffsetLP) - AddLeadIn( nFirstCurve, LayerParams, nTpathGrpId) - end - local nLastCurve = EgtGetLastInGroup( nTpathGrpId) - if nLastCurve and LayerParams.nLeadOutType ~= LEAD_TYPE.NONE then - EgtTrimCurveEndAtLen( nLastCurve, EgtCurveLength( nLastCurve) - LayerParams.dOffsetLP) - AddLeadOut( nLastCurve, LayerParams, nTpathGrpId) - end - - -- aggiungo coasting/wipe - local nId = EgtGetFirstInGroup( nTpathGrpId) - if EgtGetName( nId or GDB_ID.NULL) == LEAD_IN_CRV then nId = EgtGetNext( nId) end - local nFirstId = nId - local nLastId = EgtGetLastInGroup( nTpathGrpId) - if EgtGetName( nLastId or GDB_ID.NULL) == LEAD_OUT_CRV then nLastId = EgtGetPrev( nLastId) end - while nId do - -- recupero i parametri - local nType = EgtGetInfo( nId, KEY_TYPE, 'i') - local bClosed = EgtGetInfo( nId, KEY_CLOSED_CRV, 'b') or false - local dCoastingLen = EgtIf( nType == TYPE.EXTRA_SHELL and not bClosed, LayerParams.dShellNbrCoasting, LayerParams.dCoastingLen) - local dWipeLen = EgtIf( nType == TYPE.EXTRA_SHELL and not bClosed, LayerParams.dShellNbrWipe, LayerParams.dWipeLen) - local dWipeDir = EgtIf( nType == TYPE.EXTRA_SHELL and not bClosed, LayerParams.dShellNbrWipeDir, 0) - - if nId == nLastId then - AddRetractionOnLastCrv( nId, nTpathGrpId, LayerParams, dCoastingLen, dWipeLen, dWipeDir) - else - local nNextId = EgtGetNext( nId) - if EgtGetInfo( nNextId, KEY_TYPE, 'i') ~= TYPE.LINK then - -- aggiungo retrazione - if nId == nFirstId then - AddRetraction( nId, LayerParams, dCoastingLen, EgtIf( LayerParams.nLeadInType == LEAD_TYPE.NONE, dWipeLen, 0), dWipeDir) - else - AddRetraction( nId, LayerParams, dCoastingLen, dWipeLen, dWipeDir) - end - end - end - nId = EgtGetNextName( nId, SHELL_CRV .. "*") or EgtGetNextName( nId, EXTRA_SHELL_CRV .. "*") or EgtGetNextName( nId, INFILL_CRV .. '') - end - - -- sistemo i solid ausiliari - local nAuxSolidsPathGrp = EgtGetFirstNameInGroup( nCrvGrpId, AUX_SOLIDS_GRP) - if nAuxSolidsGrp then - CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGrpId, LayerParams, dCorrZ) - end - -- sistemo le costolature + -- suddivido i ribs per tipologia local nRibsGrp = EgtGetFirstNameInGroup( nCrvGrpId, RIBS_GRP) - if nRibsGrp then - CalcRibsToolPath( nCrvGrpId, nTpathGrpId, LayerParams, dCorrZ) + local tRibs = {{}, {}, {}, {}} + local vRibsIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') or {} + for i = 1, #vRibsIds do + local nType = EgtGetInfo( vRibsIds[i], KEY_RIBS_TYPE, 'i') or 1 + table.insert( tRibs[nType], vRibsIds[i]) end - --passo al gruppo di contorni successivo + -- realizzo le diverse tipologie in base all'ordine selezionato + for j = 1, #LayerParams.vPrintOrder do + + if LayerParams.vPrintOrder[j] == PRINT_ELEMENT.SHELL then + -- shell + local vShellIds = EgtGetNameInGroup( nPathGrpId, SHELL_CRV .. '*') + CalcShellsToolPath( vShellIds, nTpathGrpId, LayerParams) + elseif LayerParams.vPrintOrder[j] == PRINT_ELEMENT.EXTRA_SHELL then + -- extra shell + local vExtraShellIds = EgtGetNameInGroup( nPathGrpId, EXTRA_SHELL_CRV .. '*') + CalcExtraShellToolPath( vExtraShellIds, nTpathGrpId, LayerParams) + elseif LayerParams.vPrintOrder[j] == PRINT_ELEMENT.INFILL then + -- infill + local vInfillIds = EgtGetNameInGroup( nPathGrpId, INFILL_CRV .. '*') + CalcInfillToolPath( vInfillIds, nTpathGrpId, LayerParams) + elseif LayerParams.vPrintOrder[j] == PRINT_ELEMENT.AUX_SOLID then + -- solidi ausiliari + local nAuxSolidsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], AUX_SOLIDS_GRP) + local nAuxSolidsPathGrp = EgtGetFirstNameInGroup( nCrvGrpId, AUX_SOLIDS_GRP) + CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGrpId, LayerParams) + + -- costolature + elseif LayerParams.vPrintOrder[j] == PRINT_ELEMENT.RIB_UNBOUNDED then + CalcRibsToolPath( tRibs[RIB_TYPE.UNBOUNDED], nRibsGrp, nTpathGrpId, LayerParams) + elseif LayerParams.vPrintOrder[j] == PRINT_ELEMENT.RIB_INTERNAL then + CalcRibsToolPath( tRibs[RIB_TYPE.INTERNAL], nRibsGrp, nTpathGrpId, LayerParams) + elseif LayerParams.vPrintOrder[j] == PRINT_ELEMENT.RIB_SUPPORT then + CalcRibsToolPath( tRibs[RIB_TYPE.SUPPORT], nRibsGrp, nTpathGrpId, LayerParams) + elseif LayerParams.vPrintOrder[j] == PRINT_ELEMENT.RIB_EXTERNAL then + CalcRibsToolPath( tRibs[RIB_TYPE.EXTERNAL], nRibsGrp, nTpathGrpId, LayerParams) + end + + end + + -- aggiorno il box dei toolpath + local b3Box = ComputeToolPathBox( nTpathGrpId) + b3Tot:Add( b3Box) + + -- passo al gruppo di contorni successivo nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*") end - if EgtProcessEvents( EgtIf( PRINT, 200, 0) + nIdx / #vLayIds * 100, 0) == 1 then + if EgtProcessEvents( EgtIf( PRINT, 300, 0) + nIdx / #vLayIds * 100, 0) == 1 then EgtDraw() - return + return end - end + end + + -- correzione in z + AddZCorrection( b3Tot, LayerParams) + + return true + end --------------------------------------------------------------------- diff --git a/LuaLibs/RunCalcSolids.lua b/LuaLibs/RunCalcSolids.lua new file mode 100644 index 0000000..59ab7e6 --- /dev/null +++ b/LuaLibs/RunCalcSolids.lua @@ -0,0 +1,408 @@ +-- RunCalcSolids.lua by Egaltech s.r.l. 2022/11/02 +-- Calcolo percorsi di lavoro per Stampa 3d + +-- Tabella per definizione modulo +local RunCalcSolids = {} + +-- Intestazioni +require( 'EgtBase') + +EgtOutLog( ' RunCalcSolids started', 1) + +-- Dati +local AMD = require( 'AddManData') + +-------------------------------------------------------------------- +local s_dTol = 0.1 + +--------------------------------------------------------------------- +local function GetLayerParamsForSolidCalc( nPartId) + local LayerParams = {} + LayerParams.bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false + LayerParams.dLayHeight = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd') + LayerParams.dStrand = EgtGetInfo( nPartId, KEY_STRAND, 'd') + LayerParams.vtSlicing = EgtGetInfo( nPartId, KEY_SLICING_DIR, 'v') + return LayerParams +end + +--------------------------------------------------------------------- +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 +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 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 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 + +------------------------------------------------------------------------------ +local function CreateSpiralVaseCap( nSectId, vtDir, nSolidGrp) + + local vPt = {} + for i = 0, 7 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}) + + for i = 1, #vCrvs do + EgtErase( vCrvs[i]) + end + + return nCapSrf +end + +------------------------------------------------------------------------------- +local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand) + + -- gruppo temporaneo per conti + local nGrpTmp = EgtGroup( nSolidGrp) + + 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) + -- appiattisco la curva + local nCrvCopy = EgtCopyGlob( nCrvId, nGrpTmp) + local dDelta = ( ptE - ptS) * LayerParams.vtSlicing + EgtSpiralizeCurveAlongExtrusion( nCrvCopy, - dDelta) + EgtMergeCurvesInCurveCompo( nCrvCopy) + EgtChangeClosedCurveStartPoint( nCrvCopy, ptS, GDB_RT.GLOB) + + -- calcolo la sezione iniziale + local vtDir = EgtSV( nCrvCopy, GDB_ID.ROOT) + vtDir:rotate( LayerParams.vtSlicing, 90) + local nSectId = CreateSection( ptS, vtDir, dStrand, LayerParams.dLayHeight, LayerParams.vtSlicing, nGrpTmp) + -- creo la sezione finale + local vtDir2 = EgtEV( nCrvCopy, GDB_ID.ROOT) + vtDir2:rotate( LayerParams.vtSlicing, 90) + local nSectE = CreateSection( ptE, vtDir2, dStrand, LayerParams.dLayHeight, LayerParams.vtSlicing, nGrpTmp) + + -- creo il solido aperto (tubo) + local vCrvs = {} + local _, dParE = EgtCurveDomain( nSectId) + for i = 0, dParE do + local ptRef = EgtUP( nSectId, i, GDB_ID.ROOT) + local dOffs = ( ptS - ptRef) * vtDir + vCrvs[i+1] = EgtOffsetCurveAdv( nCrvCopy, dOffs) + if not vCrvs[i+1] or vCrvs[i+1] == GDB_ID.NULL then + EgtErase( nGrpTmp) + return nil + end + 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) + local ptRefEnd = EgtUP( nSectE, i, GDB_ID.ROOT) + EgtAddCurveCompoLine( vCrvs[i+1], ptRefEnd, true, 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) + if not vSurfs[i] or vSurfs[i] == GDB_ID.NULL then + EgtErase( nGrpTmp) + return nil + end + end + local nSrfId = EgtSurfTmBySewing( nSolidGrp, vSurfs) + + -- creazione del mezzo disco iniziale + local nCap1 = CreateSpiralVaseCap( nSectId, - vtS, nSolidGrp) + -- creazione del mezzo disco finale + local nCap2 = CreateSpiralVaseCap( nSectE, vtE, nSolidGrp) + EgtInvertSurf( nCap2) + + -- cancello le curve usate per la costruzione + EgtErase( nGrpTmp) + + return EgtSurfTmBySewing( 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) + return nSrfId +end + +-------------------------------------------------------------------------------------- +local function CreateSolid( nCrvId, nSolidGrp, LayerParams, dStrand) + if LayerParams.bSpiralVase then + return CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand) + else + return CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand) + end +end + +--------------------------------------------------------------------- +local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer) + + local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i') + if nType == TYPE.WIPE then return true end + -- scelta del colore + local Color = EgtStdColor( 'GRAY') + if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then + Color = EgtStdColor( 'TEAL') + elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then + Color = EgtStdColor( 'ORANGE') + elseif nType == TYPE.LINK then + Color = EgtStdColor( 'GRAY') + elseif nType == TYPE.INFILL then + Color = EgtStdColor( 'YELLOW') + elseif nType == TYPE.COASTING then + Color = EgtStdColor( 'BLUE') + elseif nType == TYPE.WIPE then + Color = EgtStdColor( 'LIME') + elseif nType == TYPE.RIB then + Color = EgtStdColor( 'OLIVE') + elseif nType == TYPE.AUX_SOLID then + Color = EgtStdColor( 'AQUA') + end + + local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp) + local nId = GDB_ID.NULL + local nParts = 1 + local LEN_REF = 100 + local bZigZagInfill = EgtGetInfo( nCopyId, KEY_ZIG_ZAG_INFILL, 'b') or false + if bZigZagInfill then + nId, nParts = EgtSplitCurveAtCorners( nCopyId, 80) + else + local dLen = EgtCurveLength( nCrvId) + if dLen > LEN_REF and nType ~= TYPE.LINK and nType ~= TYPE.COASTING then + nParts = EgtClamp( floor( dLen / LEN_REF), 1, 10) + end + nId = EgtSplitCurve( nCopyId, nParts) + end + + if nId == GDB_ID.NULL then return false end + local bOk = true + for nInd = 0, nParts - 1 do + local nGuideId = nId + nInd + local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, LayerParams.dStrand - 5 * GEO.EPS_SMALL) + 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, LayerParams.dStrand - 5 * GEO.EPS_SMALL) + if not nSrfId then + nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, LayerParams.dStrand - 50 * GEO.EPS_SMALL) + end + end + end + -- ritento spezzando la curva + 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, 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) + end + EgtErase( nGrp) + end + end + + if nSrfId then + EgtSetColor( nSrfId, Color) + EgtSetInfo( nSrfId, KEY_TYPE, nType) + else + bOk = false + EgtOutLog( 'Warning : CreateSolid_Sewing failed') + end + EgtErase( nGuideId) + end + + return bOk +end + +--------------------------------------------------------------------- +function RunCalcSolids.Exec() + + -- per determinare il tempo di calcolo + EgtStartCounter() + + local nPartIndex = 1 + local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) or EgtGetFirstNameInGroup( GDB_ID.ROOT, PART) + while nPartId do + + if EgtGetInfo( nPartId, KEY_PART_ON_TABLE, 'b') then + -- verifico se necessario calcolare il solido + local bCalcSolid = EgtGetInfo( nPartId, KEY_CALC_SOLIDS, 'b') or false + + if bCalcSolid then + + -- recupero i suoi slice + local vLayIds = EgtGetNameInGroup( nPartId, SLICE_LAYER .. '*') + if not vLayIds then + EgtOutBox( 'No sliced part in this project!', 'Error', 'ERROR') + return + end + + EgtSetInfo( nPartId, KEY_HAS_SOLIDS, 1) + + -- recupero i parametri necessari al calcolo dei solidi + local LayerParams = GetLayerParamsForSolidCalc( nPartId) + + for nIdx = 1, #vLayIds do + -- flag di interruzione perchè trovati solidi già ok + local bSolidsOk = false + -- indice layer (per log) + local nLayer = EgtGetInfo( vLayIds[ nIdx], KEY_SLICE_NBR, 'i') + -- scorro tutti i gruppi di contorni + local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*") or GDB_ID.NULL + while nCrvGrpId ~= GDB_ID.NULL do + + -- recupero il gruppo dei percorsi utensile + local nTPathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, TOOLPATH_GRP) or GDB_ID.NULL + if nTPathGrpId == GDB_ID.NULL then + EgtOutBox( 'Error no tool paths', 'SolidCalc') + return + end + + -- recupero il gruppo dei solidi + local nSolidGrpId = EgtGetFirstNameInGroup( nCrvGrpId, SOLID_GRP) or GDB_ID.NULL + if nSolidGrpId == GDB_ID.NULL then + nSolidGrpId = EgtGroup( nCrvGrpId) + EgtSetName( nSolidGrpId, SOLID_GRP) + EgtSetLevel( nSolidGrpId, GDB_LV.TEMP) + -- scorro le curve del percorso utensile + local nId = EgtGetFirstInGroup( nTPathGrpId) + while nId do + local bOk = CreateSolidFromCurve( nId, nSolidGrpId, LayerParams, nLayer) + nId = EgtGetNext( nId) + end + else + bSolidsOk = true + break + end + + --passo al gruppo di contorni successivo + nCrvGrpId = EgtGetNextName( nCrvGrpId, CONTOUR_GRP.."*") or GDB_ID.NULL + end + if bSolidsOk then + break + end + local nStep = 10 + if nIdx > 400 then + nStep = 80 + elseif nIdx > 200 then + nStep = 40 + elseif nIdx > 100 then + nStep = 20 + end + if ( nIdx % nStep) == 0 then + EgtDraw() + end + + if EgtProcessEvents( EgtIf( PRINT, 400, 0) + nIdx / #vLayIds * 100, 0) == 1 then + -- se interrompo cancello i solidi realizzati + for i = 1, #vLayIds do + local vGrpId = EgtGetNameInGroup( vLayIds[i], CONTOUR_GRP .. '*') or {} + for j = 1, #vGrpId do + local nSolidId = EgtGetNameInGroup( vGrpId[j], SOLID_GRP .. '*') or GDB_ID.NULL + EgtErase( nSolidId) + end + end + -- rimuovo info della presenza solidi + EgtSetInfo( nPartId, KEY_HAS_SOLIDS, false) + EgtDraw() + return + end + end + + -- eventuale aggiornamento delle ViewInfo + local nViewId = EgtGetFirstNameInGroup( GDB_ID.ROOT, VIEWPARAMS) + if nViewId then + EgtSetInfo( nViewId, SOLID_GRP, true) + end + end + + end + + nPartIndex = nPartIndex + 1 + nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) or EgtGetNextName( nPartId, PART) + end + + EgtDraw() + + -- report tempo di calcolo in log + EgtOutLog( string.format( ' CalcSolidsTime = %.2f ms', EgtStopCounter())) + +end + +--------------------------------------------------------------------- +return RunCalcSolids diff --git a/LuaLibs/RunGcodeGenerate.lua b/LuaLibs/RunGcodeGenerate.lua index e5918c4..03c878d 100644 --- a/LuaLibs/RunGcodeGenerate.lua +++ b/LuaLibs/RunGcodeGenerate.lua @@ -1,4 +1,4 @@ --- RunGcodeGenerate.lua by Egaltech s.r.l. 2022/06/14 +-- RunGcodeGenerate.lua by Egaltech s.r.l. 2023/02/02 -- Calcoli prima fase per Stampa 3d -- Tabella per definizione modulo @@ -23,6 +23,9 @@ end --------------------------------------------------------------------- function RunGcodeGenerate.Exec() + -- aggiorno interfaccia + EgtProcessEvents( 601, 0) + -- Recupero il pezzo (per ora primo e unico) local nPartIndex = 1 local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) or EgtGetFirstNameInGroup( GDB_ID.ROOT, PART) @@ -41,6 +44,9 @@ function RunGcodeGenerate.Exec() -- Recupero i parametri relativi al layer local LayerParams = GetLayerParamsForGcodeGenerate( nPartId) + -- aggiorno interfaccia + EgtProcessEvents( 605, 0) + -- Ciclo sui layer local vEntId = {} for nIdx = 1, #vLayIds do @@ -50,7 +56,7 @@ function RunGcodeGenerate.Exec() -- recupero il gruppo dei percorsi utensile local nTpathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, TOOLPATH_GRP) if not nTpathGrpId then - EgtOutBox( 'Error missing toolpaths', 'GcodeGenerate') + EgtOutBox( 'Error missing toolpaths', 'GcodeGenerate') return end -- recupero le entità nel gruppo @@ -68,6 +74,9 @@ function RunGcodeGenerate.Exec() return end + -- aggiorno interfaccia + EgtProcessEvents( 610, 0) + -- Imposto gruppo di lavoro EgtSetCurrMachGroup() @@ -87,6 +96,9 @@ function RunGcodeGenerate.Exec() return end + -- aggiorno interfaccia + EgtProcessEvents( 620, 0) + EgtSetMachiningGeometry( vEntId) local sNotes = EgtAdjustNotes( '', 'LinkZup', LayerParams.LinkZup) @@ -94,35 +106,59 @@ function RunGcodeGenerate.Exec() if not EgtApplyMachining() then local nErr, sErr = EgtGetLastMachMgrError() - local sMsg = 'Error applying Extrusion' + local sMsg = '' if nErr == 2803 and string.find( sErr, '(3)', 1, true) then - sMsg = sMsg .. ' (missing Feed & Speed)' + sMsg = ' Missing Feed & Speed.' + elseif nErr == 2804 then + sMsg = ' Axes Values not calculable.' + elseif nErr == 2805 then + sMsg = ' Outstroke Axes (see Log File).' + else + sMsg = ' See Log File.' end EgtResetCurrMachGroup() - EgtOutBox( sMsg, 'GcodeGenerate') + if PRINT and PRINT.PROGRAM == 1 then + PRINT.ERR = 1 + PRINT.MSG = sMsg + else + EgtOutBox( 'Error in Machining :'..sMsg, 'GcodeGenerate') + end return end + -- aggiorno interfaccia + EgtProcessEvents( 650, 0) + -- Salvo il progetto local sFilePath = EgtGetCurrFilePath() sFilePath = EgtChangePathExtension( sFilePath, 'nge') EgtSetCurrFilePath( sFilePath) EgtSaveFile() + -- aggiorno interfaccia + EgtProcessEvents( 680, 0) + -- Genero il programma CN - local sInfo = 'EgtCAM5 ver.' .. EgtGetExeVersion() .. ' - ' .. sPath - local bGenOk = EgtGenerate( '', sInfo) + local sInfo = 'Icarus ver.' .. EgtGetExeVersion() .. ' - ' .. sPath + local sISOFilePath = '' + if PRINT and PRINT.PROGRAM == 1 and PRINT.ISOFILEPATH then + sISOFilePath = PRINT.ISOFILEPATH + end + local bGenOk = EgtGenerate( sISOFilePath, sInfo) if bGenOk then EgtEstimate('') end + -- aggiorno interfaccia + EgtProcessEvents( 690, 0) + EgtResetCurrMachGroup() if PRINT and PRINT.PROGRAM == 1 then if bGenOk then PRINT.ERR = 0 else - PRINT.ERR = 999 + PRINT.ERR = 2 end else if bGenOk then @@ -131,6 +167,10 @@ function RunGcodeGenerate.Exec() EgtOutBox( 'Generation failed.', 'GcodeGeneration', 'ERROR') end end + + -- aggiorno interfaccia + EgtProcessEvents( 700, 0) + end --------------------------------------------------------------------- diff --git a/LuaLibs/RunMachParamFromSWCalc.lua b/LuaLibs/RunMachParamFromSWCalc.lua index 22fb09e..f0e332f 100644 --- a/LuaLibs/RunMachParamFromSWCalc.lua +++ b/LuaLibs/RunMachParamFromSWCalc.lua @@ -1,4 +1,4 @@ --- RunMachParamFromSWCalc.lua by Egaltech s.r.l. 2022/09/15 +-- RunMachParamFromSWCalc.lua by Egaltech s.r.l. 2022/12/28 -- Calcolo dei parametri di stampa -- Tabella per definizione modulo @@ -12,9 +12,12 @@ EgtOutLog( ' RunMachParamFromSWCalc started', 1) -- Costanti generali local AMD = require( 'AddManData') +--local MACHINING = {} +--MACHINING.K = 103 --local MATERIAL = {} --MATERIAL.Name = 'AKROMID® B3 ICF 40' ---MATERIAL.K = 0.1 +--MATERIAL.K_EXTRUSION = 110 +--MATERIAL.K_LAYERTIME = 105 --MATERIAL.C1 = 0.8742 --MATERIAL.C2 = 0.8964 --MATERIAL.Density = 1.31 @@ -31,6 +34,14 @@ local AMD = require( 'AddManData') --------------------------------------------------------------------- function RunMachParamFromSWCalc.Exec() + -- valori default per nuovi parametri + MATERIAL.K_LAYERTIME = MATERIAL.K_LAYERTIME or 100 + MATERIAL.K_EXTRUSION = MATERIAL.K_EXTRUSION or 100 + if not MACHINING then + MACHINING = {} + MACHINING.K = 100 + end + -- layer dei risultati local nResultLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, LAY_TFSCALC) if not nResultLayerId then @@ -57,41 +68,54 @@ function RunMachParamFromSWCalc.Exec() local dSliceStep = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd') local dStrand = EgtGetInfo( nPartId, KEY_STRAND, 'd') local dStrandCount = EgtGetInfo( nPartId, KEY_SHELLS_NBR, 'd') + -- recupero numero di strati per progress + local nLastLayerId = EgtGetLastNameInGroup( nPartId, SLICE_LAYER .. '*') or GDB_ID.NULL + local nLayerQty = EgtGetInfo( nLastLayerId, KEY_SLICE_NBR, 'i') or 0 -- ciclo sui layer local nLayerIndex = 1 - local nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) + local nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) or EgtGetFirstNameInGroup( nPartId, "__" .. SLICE_LAYER .. nLayerIndex) while nLayerId do -- 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 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) - 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 + 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 local nLayerResultId = EgtGetFirstNameInGroup( nResultLayerId, nLayerIndex) if nLayerResultId then dLayerFeed = EgtGetInfo( nLayerResultId, KEY_FCUR, 'd') or 0 + dLayerWait = EgtGetInfo( nLayerResultId, KEY_WAITING_TIME, 'd') or 0 else nLayerResultId = EgtGroup( nResultLayerId) EgtSetName( nLayerResultId, nLayerIndex) @@ -109,11 +133,27 @@ function RunMachParamFromSWCalc.Exec() end EgtSetInfo( nLayerResultId, KEY_SLICEID, nOrigLayers) -- calcolo costante MF - local dMF = dTotLayerLength * dStrand / dTotLayerArea * 100 + local dMF = 1 + local dSC = 1 + if dTotLayerArea > 1 then + dMF = dTotLayerLength * dStrand / dTotLayerArea * 100 + dSC = dStrandCount + else + dMF = 100 + local nRibsLayId = EgtGetFirstNameInGroup( nLayerId, RIBS_GRP) or GDB_ID.NULL + local nCrvId = EgtGetFirstInGroup( nRibsLayId) + while nCrvId do + if EgtGetInfo( nCrvId, KEY_RIBS_TYPE, 'i') == RIB_TYPE.UNBOUNDED then + dSC = ( EgtGetInfo( nCrvId, KEY_RIBS_SHELLS_NBR, 'd') or dSC) / 2 + break + end + nCrvId = EgtGetNext( nCrvId) + end + end -- calcolo tempi stimati del layer - local dTMin = ( dMF + MATERIAL.AMin) / MATERIAL.BMin * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dStrandCount, MATERIAL.KN) - local dTTrg = ( dMF + MATERIAL.ATrg) / MATERIAL.BTrg * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dStrandCount, MATERIAL.KN) - local dTMax = ( dMF + MATERIAL.AMax) / MATERIAL.BMax * pow( 0.25 * dStrand, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dStrandCount, MATERIAL.KN) + local dTMin = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMin) / MATERIAL.BMin * pow( 0.25 * dStrand, 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 * dStrand, 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 * dStrand, 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 @@ -123,10 +163,11 @@ function RunMachParamFromSWCalc.Exec() else dLayerTime = dTotLayerLength / dLayerFeed * 60 end + dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5) -- calcolo la portata local Vf = dLayerFeed * ( ( dStrand - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2)) / 1000 -- calcolo speed - local dSpeed = ( 1 + MATERIAL.K) * pow( Vf / MATERIAL.C1, 1 / MATERIAL.C2) + local dSpeed = ( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0) * pow( Vf / MATERIAL.C1, 1 / MATERIAL.C2) -- verifico se speed esce da minimo e massimo della macchina local bSpeedOk = true if dSpeed < dSMin then @@ -138,11 +179,12 @@ function RunMachParamFromSWCalc.Exec() dSpeed = dSMax end if not bSpeedOk then - dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / ( 1 + MATERIAL.K)), MATERIAL.C2)) * 1000 / ( ( dStrand - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2)) + dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / ( ( dStrand - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2)) dLayerTime = dTotLayerLength / dLayerFeed * 60 + dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5) end -- calcolo massa dello strato - local dLayerMass = dTotLayerLength * dSliceStep * dStrand * MATERIAL.Density * 1e-6 + local dLayerMass = dTotLayerLengthForMass * dSliceStep * dStrand * MATERIAL.Density * 1e-6 if dLayerMass and dLayerMass > 0 then dPrintMass = dPrintMass + dLayerMass end @@ -154,6 +196,11 @@ function RunMachParamFromSWCalc.Exec() EgtSetInfo( nToolPathId, KEY_SPEED, dSpeed) nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*') end + -- scrivo info attesa + if dLayerWait > 0 then + EgtSetInfo( nLayerId, KEY_WAITING_TIME, dLayerWait) + EgtSetInfo( nLayerResultId, KEY_WAITING_TIME, dLayerWait) + end -- scrivo valori in struttura dati --local nLayerResultId = EgtGetFirstNameInGroup( nResultLayerId, nLayerIndex) EgtSetInfo( nLayerResultId, KEY_TMIN, dTMin) @@ -166,8 +213,16 @@ function RunMachParamFromSWCalc.Exec() EgtSetInfo( nLayerResultId, KEY_FCUR, dLayerFeed) EgtSetInfo( nLayerResultId, KEY_LENGTH, dTotLayerLength) EgtSetInfo( nLayerResultId, KEY_SPEED, dSpeed) + EgtSetInfo( nLayerResultId, KEY_MF, dMF) + EgtSetInfo( nLayerResultId, KEY_TOTAREA, dTotLayerArea) + -- aggiorno interfaccia + if EgtProcessEvents( 500 + ( nLayerIndex / nLayerQty * 100), 0) == 1 then + EgtEmptyGroup( nResultLayerId) + return + end + nLayerIndex = nLayerIndex + 1 - nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) + nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) or EgtGetFirstNameInGroup( nPartId, "__" .. SLICE_LAYER .. nLayerIndex) end if nMaxIndex < nLayerIndex then nMaxIndex = nLayerIndex end nPartId = EgtGetNextPart( nPartId) diff --git a/LuaLibs/RunMachiningParamCalc.lua b/LuaLibs/RunMachiningParamCalc.lua deleted file mode 100644 index f73bf5e..0000000 --- a/LuaLibs/RunMachiningParamCalc.lua +++ /dev/null @@ -1,198 +0,0 @@ --- RunMachiningParamCalc.lua by Egaltech s.r.l. 2022/04/13 --- Gestione visualizzazione per Stampa 3d - --- Tabella per definizione modulo -local RunMachiningParamCalc = {} - --- Intestazioni -require( 'EgtBase') - -EgtOutLog( ' RunMachiningParamCalc started', 1) - --- Costanti generali -local AMD = require( 'AddManData') -local CSV = require( 'CSVManager') - ---------------------------------------------------------------------- -function RunMachiningParamCalc.Exec() - - -- Dati recuperati dalla macchina - local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini' - local dCoeffX = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_COEFF_X, 0, sMachIni)) - local dCoeffY = tonumber( EgtGetStringFromIni( SEC_3DPRINTING, KEY_COEFF_Y, 0, sMachIni)) - - -- File dei risultati - local sCalcBaseDir = EgtGetStringFromIni( '3dPrinting', 'BaseDir', 'C:\\ProgramData\\Egaltech\\EgtCam5\\3dPrinting', EgtGetIniFile()) - local sCurrProjectPath = EgtGetCurrFilePath() - local sResultFile = EgtChangePathExtension( sCurrProjectPath, '.csv') - local bResultFile = EgtExistsFile( sResultFile) - - -- carico eventuale file dei risultati - local CSVOldResult - if bResultFile then - CSVOldResult = read_file( sResultFile) - end - - -- tabella del csv del risultato - local CSVNewResult = {} - - -- ciclo sui pezzi - local nPartId = EgtGetFirstPart() - while nPartId do - if not EgtGetInfo( nPartId, KEY_PART_ON_TABLE, 'b') then - nPartId = EgtGetNextPart( nPartId) - goto continue - end - -- recupero i parametri di lavorazione del pezzo - local dMachiningFeed = EgtGetInfo( nPartId, KEY_FEED, 'd') - local dSliceStep = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd') - local dStrand = EgtGetInfo( nPartId, KEY_STRAND, 'd') - local sMaterial = EgtGetInfo( nPartId, KEY_MATERIAL) - -- verifico la definizione dei parametri - if not dMachiningFeed then - EgtOutBox( 'Impossible calculating before applying a machining.', 'Error', 'ERROR') - return - end - -- calcolo intervallo tempi consentito - local sMaterialPath = sCalcBaseDir .. '\\Materials\\' .. sMaterial .. '.csv' - local MaterialCSV = read_file( sMaterialPath) - local dMinTime = 0 - local dMaxTime = 0 - if not MaterialCSV then - EgtOutBox( 'Material csv file not found.', 'Error', 'ERROR') - return - end - local bSectionFound = false - for nSectionIndex = 1, #MaterialCSV do - local Section = MaterialCSV[nSectionIndex] - if tonumber( Section[1]) == dStrand and tonumber( Section[2]) == dSliceStep then - dMinTime = tonumber(Section[3]) - dMaxTime = tonumber(Section[4]) - bSectionFound = true - break - end - end - if not bSectionFound then - EgtOutBox( 'Section not found in Material csv file.', 'Error', 'ERROR') - return - end - -- ciclo sui layer - local nLayerIndex = 1 - local nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) - while nLayerId do - local sLayerName = EgtGetName( nLayerId) - local nLayerIndex = tonumber( sLayerName:sub( #SLICE_LAYER + 1)) - -- rimuovo eventuale info precedente del tempo di attesa - EgtRemoveInfo( nLayerId, KEY_WAITING_TIME) - -- calcolo lunghezza totale del layer - local dTotLayerLength = 0 - local nCrvId = EgtGetFirstGroupInGroup( nLayerId) - while nCrvId do - local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP) - -- sommo lunghezze percorsi - local dTotCrvLength = 0 - nShellId = EgtGetFirstInGroup( nToolPathId) - while nShellId do - --local nType = EgtGetInfo( nShellId, KEY_TYPE, 'i') - dTotCrvLength = dTotCrvLength + EgtCurveLength( nShellId) - nShellId = EgtGetNext( nShellId) - end - dTotLayerLength = dTotLayerLength + dTotCrvLength - nCrvId = EgtGetNext( nCrvId) - end - -- recupero feed del layer - local dLayerFeed = 0 - if bResultFile then - -- leggo il valore dal file - local bResultFound = false - for nResultIndex = 1, #CSVOldResult do - local OldResult = CSVOldResult[nResultIndex] - if tonumber( OldResult[1]) == nLayerIndex then - dLayerFeed = tonumber( OldResult[5]) - bResultFound = true - break - end - end - if not bResultFound then - -- uso valore di default - dLayerFeed = dMachiningFeed - end - else - -- uso valore di default - dLayerFeed = dMachiningFeed - end - -- calcolo tempo stimato del layer - local dEsteemedTime = dTotLayerLength / dLayerFeed * 60 - -- calcolo speed - local dSpeed = ((( dLayerFeed * dSliceStep * dStrand ) / 60) - dCoeffX) / dCoeffY - -- scrivo info feed e speed in group toolpath - nCrvId = EgtGetFirstNameInGroup( nLayerId, CONTOUR_GRP .. '*') - while nCrvId do - local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP) - EgtSetInfo( nToolPathId, KEY_FEED, dLayerFeed) - EgtSetInfo( nToolPathId, KEY_SPEED, dSpeed) - nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*') - end - -- salvo e riporto valori calcolati in tabella per csv - local sStatus = '' - if dEsteemedTime < dMinTime then - EgtSetInfo( nLayerId, KEY_RESULT, RESULT.KO_MINUS) - EgtSetInfo( nLayerId, KEY_WAITING_TIME, dMinTime - dEsteemedTime) - sStatus = 'KO(-)' - elseif dEsteemedTime > dMinTime and dEsteemedTime < dMaxTime then - EgtSetInfo( nLayerId, KEY_RESULT, RESULT.OK) - sStatus = 'OK' - elseif dEsteemedTime > dMaxTime then - EgtSetInfo( nLayerId, KEY_RESULT, RESULT.KO_PLUS) - sStatus = 'KO(+)' - end - --table.insert( CSVOutTable, { Index = nLayerIndex, EsteemedTime = dEsteemedTime, Feed = dLayerFeed, Speed = dSpeed}) - table.insert( CSVNewResult, { nLayerIndex, dTotLayerLength, dEsteemedTime, sStatus, dLayerFeed, dSpeed}) - nLayerIndex = nLayerIndex + 1 - nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) - end - nPartId = EgtGetNextPart( nPartId) - ::continue:: - end - - -- aggiorno palette - local nViewId = EgtGetFirstNameInGroup( GDB_ID.ROOT, VIEWPARAMS) - local nPaletteType = EgtGetInfo( nViewId, KEY_PALETTE, 'i') - if nPaletteType == PALETTE_TYPE.RESULTS then - local RSP = require( 'RunSlicePalette') - RSP.UpdateColors( nPaletteType) - end - -- scrivo nuovo file csv di risultato - local file = io.open( sResultFile, "w") - if file then - file:write('LayerIndex; Len; Time; Status; Feed; Speed') - file:write('\n') - for NewResultIndex = 1, #CSVNewResult do - local CSVOutLine = CSVNewResult[NewResultIndex] - local sParams = '' - for ParamIndex = 1, #CSVOutLine do - if ParamIndex > 1 then - sParams = sParams .. ";" - end - if ParamIndex == 4 then - sParams = sParams .. CSVOutLine[ParamIndex] - else - sParams = sParams .. EgtNumToString( CSVOutLine[ParamIndex], 1) - end - end - file:write(sParams) - file:write('\n') - end - file:close() - local sReadProgPath = EgtGetStringFromIni( '3dPrinting', RESULT_READ_PROG, "", EgtGetIniFile()) - if not sReadProgPath or not EgtWinExec( '"'..sReadProgPath..'" "'..sResultFile..'"') then - EgtOutBox( 'Impossible opening software to show results. You can find them in ' .. sResultFile, 'Error', 'ERROR') - end - else - EgtOutBox( 'Impossible writing results file in ' .. sResultFile, 'Error', 'ERROR') - end - -end - ---------------------------------------------------------------------- -return RunMachiningParamCalc diff --git a/LuaLibs/RunMachiningParamEdit.lua b/LuaLibs/RunMachiningParamEdit.lua deleted file mode 100644 index 2cf8f29..0000000 --- a/LuaLibs/RunMachiningParamEdit.lua +++ /dev/null @@ -1,57 +0,0 @@ --- RunMachiningParamEdit.lua by Egaltech s.r.l. 2022/04/05 --- Gestione visualizzazione per Stampa 3d - --- Tabella per definizione modulo -local RunMachiningParamEdit = {} - --- Intestazioni -require( 'EgtBase') - -EgtOutLog( ' RunMachiningParamEdit started', 1) - --- Costanti generali -local AMD = require( 'AddManData') - ---------------------------------------------------------------------- -function RunMachiningParamEdit.Exec() - -- recupero cartella delle lavorazioni - local sCalcBaseDir = EgtGetStringFromIni( '3dPrinting', 'BaseDir', 'C:\\ProgramData\\Egaltech\\EgtCam5\\3dPrinting', EgtGetIniFile()) - local sMachiningDirPath = sCalcBaseDir .. '\\Machinings\\' - - -- recupero file delle lavorazioni - --local Machinings = {} - local sMachinings = '' - - local f = io.popen("dir " .. sMachiningDirPath .. " /B", "r") - for entry in f:lines() do - --Machinings[#Machinings + 1] = entry - local sDir, sFile, sExt = EgtSplitPath(entry) - if sExt == '.ini' then - if sMachinings ~= "" then - sMachinings = sMachinings .. ',' - end - sMachinings = sMachinings .. sFile - end - end - - -- chiedo quale file aprire - MachiningValues = EgtDialogBox( 'Machinings edit', { 'Machining', 'CB:' .. sMachinings}) - if not MachiningValues or #MachiningValues < 1 then return end - - -- verifico esistenza file - local sSelMachiningPath = sMachiningDirPath .. MachiningValues[1] .. '.ini' - if not EgtExistsFile( sSelMachiningPath) then - EgtOutBox( 'Machining file not found', 'Error', 'ERROR') - return - end - - -- apro programma di edit - local sEditProgPath = EgtGetStringFromIni( '3dPrinting', 'MachiningEditProg', "", EgtGetIniFile()) - if not sEditProgPath or not EgtWinExec( '"'..sEditProgPath..'" "'.. sSelMachiningPath..'"') then - EgtOutBox( 'Impossible opening software to show Machining. You can find it in ' .. sSelMachiningPath, 'Error', 'ERROR') - end - -end - ---------------------------------------------------------------------- -return RunMachiningParamEdit diff --git a/LuaLibs/RunMaterialParamEdit.lua b/LuaLibs/RunMaterialParamEdit.lua deleted file mode 100644 index eb8ad75..0000000 --- a/LuaLibs/RunMaterialParamEdit.lua +++ /dev/null @@ -1,56 +0,0 @@ --- RunMaterialParamEdit.lua by Egaltech s.r.l. 2022/04/09 --- Gestione edit parametri materiali per Stampa 3d - --- Tabella per definizione modulo -local RunMaterialParamEdit = {} - --- Intestazioni -require( 'EgtBase') - -EgtOutLog( ' RunMaterialParamEdit started', 1) - --- Costanti generali -local AMD = require( 'AddManData') - ---------------------------------------------------------------------- -function RunMaterialParamEdit.Exec() - -- recupero cartella dei materiali - local sCalcBaseDir = EgtGetStringFromIni( '3dPrinting', 'BaseDir', 'C:\\ProgramData\\Egaltech\\EgtCam5\\3dPrinting', EgtGetIniFile()) - local sMaterialDirPath = sCalcBaseDir .. '\\Materials\\' - - -- recupero elenco file dei materiali - local Files = EgtFindAllFiles( sMaterialDirPath..'*.csv') - if not Files then - EgtOutBox( 'Material files not found', 'Error', 'ERROR') - return - end - local sMaterials = '' - for i = 1, #Files do - local sDir, sFile, sExt = EgtSplitPath( Files[i]) - if sMaterials ~= "" then - sMaterials = sMaterials .. ',' - end - sMaterials = sMaterials .. sFile - end - - -- chiedo quale file aprire - MaterialValues = EgtDialogBox( 'Materials edit', { 'Material', 'CB:' .. sMaterials}) - if not MaterialValues or #MaterialValues < 1 then return end - - -- verifico esistenza file - local sSelMaterialPath = sMaterialDirPath .. MaterialValues[1] .. '.csv' - if not EgtExistsFile( sSelMaterialPath) then - EgtOutBox( 'Material file not found', 'Error', 'ERROR') - return - end - - -- apro programma di edit - local sEditProgPath = EgtGetStringFromIni( '3dPrinting', RESULT_READ_PROG, "", EgtGetIniFile()) - if not sEditProgPath or not EgtWinExec( '"'..sEditProgPath..'" "'..sSelMaterialPath..'"') then - EgtOutBox( 'Impossible opening software to show Material. You can find them it in ' .. sSelMaterialPath, 'Error', 'ERROR') - end - -end - ---------------------------------------------------------------------- -return RunMaterialParamEdit diff --git a/LuaLibs/RunPartPositioning.lua b/LuaLibs/RunPartPositioning.lua deleted file mode 100644 index 14ffef8..0000000 --- a/LuaLibs/RunPartPositioning.lua +++ /dev/null @@ -1,209 +0,0 @@ --- RunPartPositioning.lua by Egaltech s.r.l. 2022/08/29 --- Gestione calcolo disposizione e lavorazioni per stampa 3d --- 2022/03/21 Creazione file - --- Tabella per definizione modulo -local RunPartPositioning = {} - --- Intestazioni -require( 'EgtBase') - -EgtOutLog( ' RunPartPositioning started', 1) - --- Costanti generali -local AMD = require( 'AddManData') - ---------------------------------------------------------------------- -function RunPartPositioning.Exec() - -- Verifico che la macchina corrente sia adatta alla stampa 3d - local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini' - local sMachMaterial = EgtGetStringFromIni( 'General', 'Material', '', sMachIni) - if sMachMaterial ~= 'Additive' then - EgtOutBox( 'Current machine unsuitable for additive manufacturing', 'Warning', 'WARNING') - return - end - -- Recupero ultimo oggetto selezionato - local nSolidId = EgtGetLastSelectedObj() - local nLayerId = EgtGetParent( nSolidId) - local nPartId = EgtGetParent( nLayerId) - -- Verifico sia in un pezzo valido - if nPartId then - if EgtIsPart( nPartId) then - local sName = EgtGetName( nPartId) - if sName == TABLE then - EgtOutBox( 'No selected part. Please select a part before moving it on the table.', 'Warning', 'WARNING') - return - end - local sLayer = EgtGetName( nLayerId) - if sLayer == LAY_RIBS or sLayer == LAY_AUX_SOLIDS or sLayer == LAY_SHELL_NBR then - EgtOutBox( 'No selected solid. Please select a solid before moving it on the table.', 'Warning', 'WARNING') - return - end - else - EgtOutBox( 'No selected part. Please select a part before moving it on the table.', 'Warning', 'WARNING') - return - end - else - EgtOutBox( 'No selected part. Please select a part before moving it on the table.', 'Warning', 'WARNING') - return - end - - -- Assegno nome pezzo e layer - if not EgtGetName( nPartId) then - local nPartIndex = 1 - while EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) do - nPartIndex = nPartIndex + 1 - end - EgtSetName( nPartId, PART .. nPartIndex) - EgtSetName( nLayerId, PRINT_SOLID) - end - -- Recupero o creo layer ausiliario - local nAuxId = EgtGetFirstNameInGroup( nPartId, LAY_AUX) - if not nAuxId then - nAuxId = EgtGroup( nPartId) - EgtSetName( nAuxId, LAY_AUX) - else - EgtEmptyGroup( nAuxId) - end - - -- Rimuovo eventuale gruppo di lavoro - local nMchGrpId = EgtGetMachGroupId( '3dPrint') - EgtRemoveMachGroup( nMchGrpId or GDB_ID.NULL) - - -- Recupero dati tavola (creando gruppo di lavoro temporaneo) - local nQqqId = EgtAddMachGroup( 'qqq') - EgtSetTable( 'Tab') - local b3Tab = EgtGetTableArea() - dTabX = b3Tab:getDimX() - dTabY = b3Tab:getDimY() - EgtRemoveMachGroup( nQqqId or GDB_ID.NULL) - - -- Richiedo posizione origine e offset pezzo - local b3Solid = EgtGetBBoxGlob( nSolidId, GDB_BB.EXACT) - local b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.EXACT) - local nRefX = 1 - local nRefY = 1 - local dPosX = b3Tab:getDimX() / 2 - b3Solid:getDimX() / 2 - local dPosY = b3Tab:getDimY() / 2 - b3Solid:getDimY() / 2 - local Positions = EgtDialogBox( 'Part position on table:', { 'Reference', 'CB:Left,Center,Right'}, - { '', 'CB:Bottom,Middle,Top'}, - { 'X', EgtNumToString( EgtToUiUnits( dPosX), 1)}, - { 'Y', EgtNumToString( EgtToUiUnits( dPosY), 1)}) - if not Positions then return end - dPosX = EgtFromUiUnits( tonumber( Positions[3])) - dPosY = EgtFromUiUnits( tonumber( Positions[4])) - if Positions[1] == 'Center' then - nRefX = 2 - dPosX = dPosX - b3Solid:getDimX() / 2 - elseif Positions[1] == 'Right' then - nRefX = 3 - dPosX = dPosX - b3Solid:getDimX() - end - if Positions[2] == 'Middle' then - nRefY = 2 - dPosY = dPosY - b3Solid:getDimY() / 2 - elseif Positions[2] == 'Top' then - nRefY = 3 - dPosY = dPosY - b3Solid:getDimY() - end - - -- Creo disegno tavola - local nTabPart = EgtGetFirstNameInGroup( GDB_ID.ROOT, TABLE) - EgtErase( nTabPart) - -- Disegno tavola - nTabPart = EgtGroup( GDB_ID.ROOT) - EgtSetMode( nTabPart, GDB_MD.LOCKED) - EgtSetLevel( nTabPart, GDB_LV.SYSTEM) - EgtSetName( nTabPart, TABLE) - local nTabLayer = EgtGroup( nTabPart) - EgtSetName( nTabLayer, TABLE) - local nTabOutlineId = EgtRectangle2P( nTabLayer, Point3d( 0, 0, 0), Point3d( dTabX, dTabY, 0)) - local nTabSurfId = EgtSurfFlatRegion( nTabLayer, nTabOutlineId) - EgtSetColor( nTabSurfId, 'GRAY') - EgtSetAlpha( nTabSurfId, 70) - - -- Aggiungo il box del solido - local nBoxId = EgtSurfTmBBox( nAuxId, b3Solid, false, GDB_RT.GLOB) - - -- Posiziono il pezzo e aggiorno il suo box - local vtMove = Point3d( dPosX, dPosY, 0) - b3Solid:getMin() - EgtMove( nPartId, vtMove) - b3Solid:move( vtMove) - b3Part:move( vtMove) - - -- Creo il frame del pezzo - local ptOrig = b3Solid:getMin() - if nRefX == 2 then - ptOrig = ptOrig + b3Solid:getDimX() / 2 * X_AX() - elseif nRefX == 3 then - ptOrig = ptOrig + b3Solid:getDimX() * X_AX() - end - if nRefY == 2 then - ptOrig = ptOrig + b3Solid:getDimY() / 2 * Y_AX() - elseif nRefY == 3 then - ptOrig = ptOrig + b3Solid:getDimY() * Y_AX() - end - - -- Svuoto o creo layer per il frame - local nFrameLay = EgtGetFirstNameInGroup( nPartId, LAY_FRAME) - if not nFrameLay then - nFrameLay = EgtGroup( nPartId) - EgtSetName( nFrameLay, LAY_FRAME) - else - EgtEmptyGroup( nFrameLay) - end - - local frPart = Frame3d( ptOrig, Z_AX()) - nFrameId = EgtFrame( nFrameLay, frPart, GDB_RT.GLOB) - if nFrameId then - EgtSetName( nFrameId, FRAME_PART) - EgtSetMode( nFrameId, GDB_MD.LOCKED) - end - - -- Definisco e posiziono il grezzo sulla tavola - EgtAddMachGroup( '3dPrint') - EgtSetTable( 'Tab') - - local nRawId = EgtAddRawPartWithPart( nPartId, nBoxId, 0, Color3d( 128, 128, 128, 30)) - EgtMoveToCornerRawPart( nRawId, Point3d( dPosX, dPosY, 0), MCH_CR.BL) - - EgtResetCurrMachGroup() - - -- Recupero/creo gruppo per punti e curve di partenza - local nMachStartId = EgtGetFirstNameInGroup( nPartId, LAY_MACH_START) - if not nMachStartId then - nMachStartId = EgtGroup( nPartId) - EgtSetName( nMachStartId, LAY_MACH_START) - end - - local vStartId = EgtGetNameInGroup( nLayerId, START_GEOM) - if vStartId then - for j = 1, #vStartId do - EgtRelocateGlob( vStartId[j], nMachStartId) - EgtSetColor( vStartId[j], EgtStdColor( "RED")) - end - else - -- se non ci sono punti/curve di inizio definiti e non ve ne sono nemmeno nel gruppo, creo un punto - local vOldStart = EgtGetNameInGroup( nMachStartId, START_GEOM) - if not vOldStart then - local ptStart = b3Solid:getCenter() - 0.6 * b3Solid:getDimY() * Y_AX() - 0.5 * b3Solid:getDimZ() * Z_AX() - nPtStartId = EgtPoint( nMachStartId, ptStart, GDB_RT.GLOB) - EgtSetName( nPtStartId, START_GEOM) - EgtSetColor( nPtStartId, EgtStdColor( "RED")) - end - end - - -- Dichiaro pezzo posizionato - EgtSetInfo( nPartId, KEY_PART_ON_TABLE, 1) - - -- Deseleziono tutto - EgtDeselectAll() - - EgtSetView( SCE_VD.ISO_SW, false) - EgtZoom( SCE_ZM.ALL) - - EgtOutLog( ' +++ RunPartPositioning completed') -end - ---------------------------------------------------------------------- -return RunPartPositioning diff --git a/LuaLibs/RunShowManager.lua b/LuaLibs/RunShowManager.lua deleted file mode 100644 index f4f257f..0000000 --- a/LuaLibs/RunShowManager.lua +++ /dev/null @@ -1,127 +0,0 @@ --- RunShowManager.lua by Egaltech s.r.l. 2022/09/15 --- Gestione visualizzazione per Stampa 3d - --- Tabella per definizione modulo -local RunShowManager = {} - --- Intestazioni -require( 'EgtBase') - -EgtOutLog( ' RunShowManager started', 1) - --- Costanti generali -local AMD = require( 'AddManData') - ---------------------------------------------------------------------- -local function ShowImportedSolid( nPartId, bShow) - local nSolidLayId = EgtGetFirstNameInGroup( nPartId, PRINT_SOLID) - EgtSetStatus( nSolidLayId or GDB_ID.NULL, EgtIf( bShow, GDB_ST.ON, GDB_ST.OFF)) - local nRibsLayId = EgtGetFirstNameInGroup( nPartId, LAY_RIBS) - EgtSetStatus( nRibsLayId or GDB_ID.NULL, EgtIf( bShow, GDB_ST.ON, GDB_ST.OFF)) - local nShellNbrLay = EgtGetFirstNameInGroup( nPartId, LAY_SHELL_NBR) - EgtSetStatus( nShellNbrLay or GDB_ID.NULL, EgtIf( bShow, GDB_ST.ON, GDB_ST.OFF)) - local nAuxSolidsLay = EgtGetFirstNameInGroup( nPartId, LAY_AUX_SOLIDS) - EgtSetStatus( nAuxSolidsLay or GDB_ID.NULL, EgtIf( bShow, GDB_ST.ON, GDB_ST.OFF)) -end - ---------------------------------------------------------------------- -function RunShowManager.Exec() - -- Verifico esistenza gruppo stato visualizzazione progetto - local nViewId = EgtGetFirstNameInGroup( GDB_ID.ROOT, VIEWPARAMS) - local bImportedSolid = false - local bOuterCrv = false - local bPath = false - local bSolid = false - local bToolPath = false - - if not nViewId then - nViewId = EgtGroup( GDB_ID.ROOT) - EgtSetName( nViewId, VIEWPARAMS) - EgtSetLevel( nViewId, GDB_LV.SYSTEM) - else - bImportedSolid = EgtGetInfo( nViewId, IMPORTED_SOLID, 'b') - bOuterCrv = EgtGetInfo( nViewId, OUTER_CRV, 'b') - bPath = EgtGetInfo( nViewId, PATH_GRP, 'b') - bSolid = EgtGetInfo( nViewId, SOLID_GRP, 'b') - bToolPath = EgtGetInfo( nViewId, TOOLPATH_GRP, 'b') - end - - local bCurrImportedSolid = bImportedSolid - local bCurrOuterCrv = bOuterCrv - local bCurrPath = bPath - local bCurrSolid = bSolid - local bCurrToolPath = bToolPath - - if EgtGetUserLevel() == 1 then - local ViewValues = EgtDialogBox( 'Show Manager', { 'Imported Solid', 'CK:' .. EgtIf( bImportedSolid, '1', '0')}, - { 'Solid', 'CK:' .. EgtIf( bSolid, '1', '0')}, - { 'ToolPath', 'CK:' .. EgtIf( bToolPath, '1', '0')}) - if not ViewValues or #ViewValues < 3 then return end - bCurrImportedSolid = ( ViewValues[1] == '1') - bCurrSolid = ( ViewValues[2] == '1') - bCurrToolPath = ( ViewValues[3] == '1') - else - local ViewValues = EgtDialogBox( 'Show Manager', { 'Imported Solid', 'CK:' .. EgtIf( bImportedSolid, '1', '0')}, - { 'OuterCrv', 'CK:' .. EgtIf( bOuterCrv, '1', '0')}, - { 'Path', 'CK:' .. EgtIf( bPath, '1', '0')}, - { 'Solid', 'CK:' .. EgtIf( bSolid, '1', '0')}, - { 'ToolPath', 'CK:' .. EgtIf( bToolPath, '1', '0')}) - if not ViewValues or #ViewValues < 5 then return end - bCurrImportedSolid = ( ViewValues[1] == '1') - bCurrOuterCrv = ( ViewValues[2] == '1') - bCurrPath = ( ViewValues[3] == '1') - bCurrSolid = ( ViewValues[4] == '1') - bCurrToolPath = ( ViewValues[5] == '1') - end - - -- ciclo sui pezzi - local nPartIndex = 1 - local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) - while nPartId do - if bImportedSolid ~= bCurrImportedSolid then - ShowImportedSolid( nPartId, bCurrImportedSolid) - end - -- ciclo sui layer per dis/attivare il resto - local nLayerIndex = 1 - local nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) or EgtGetFirstNameInGroup( nPartId, "__" .. SLICE_LAYER .. nLayerIndex) - while nLayerId do - local nCrvId = EgtGetFirstGroupInGroup( nLayerId) - while nCrvId do - if bOuterCrv ~= bCurrOuterCrv then - local nOuterCrvId = EgtGetFirstNameInGroup( nCrvId, OUTER_CRV) - EgtSetStatus( nOuterCrvId or GDB_ID.NULL, EgtIf( bCurrOuterCrv, GDB_ST.ON, GDB_ST.OFF)) - end - if bPath ~= bCurrPath then - local nPathId = EgtGetFirstNameInGroup( nCrvId, PATH_GRP) - EgtSetStatus( nPathId or GDB_ID.NULL, EgtIf( bCurrPath, GDB_ST.ON, GDB_ST.OFF)) - end - if bSolid ~= bCurrSolid then - local nSolidId = EgtGetFirstNameInGroup( nCrvId, SOLID_GRP) - EgtSetStatus( nSolidId or GDB_ID.NULL, EgtIf( bCurrSolid, GDB_ST.ON, GDB_ST.OFF)) - end - if bToolPath ~= bCurrToolPath then - local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP) - EgtSetStatus( nToolPathId or GDB_ID.NULL, EgtIf( bCurrToolPath, GDB_ST.ON, GDB_ST.OFF)) - end - nCrvId = EgtGetNext( nCrvId) - end - nLayerIndex = nLayerIndex + 1 - nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) or EgtGetFirstNameInGroup( nPartId, "__" .. SLICE_LAYER .. nLayerIndex) - end - nPartIndex = nPartIndex + 1 - nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) - end - - -- riporto impostazioni in gruppo apposito - EgtSetInfo( nViewId, IMPORTED_SOLID, bCurrImportedSolid) - EgtSetInfo( nViewId, OUTER_CRV, bCurrOuterCrv) - EgtSetInfo( nViewId, PATH_GRP, bCurrPath) - EgtSetInfo( nViewId, SOLID_GRP, bCurrSolid) - EgtSetInfo( nViewId, TOOLPATH_GRP, bCurrToolPath) - - EgtDraw() - -end - ---------------------------------------------------------------------- -return RunShowManager diff --git a/LuaLibs/RunSliceAdvancement.lua b/LuaLibs/RunSliceAdvancement.lua deleted file mode 100644 index 89b52d0..0000000 --- a/LuaLibs/RunSliceAdvancement.lua +++ /dev/null @@ -1,174 +0,0 @@ --- RunSliceAdvancement.lua by Egaltech s.r.l. 2022/06/28 --- Gestione visualizzazione per Stampa 3d - --- Tabella per definizione modulo -local RunSliceAdvancement = {} - --- Intestazioni -require( 'EgtBase') - -EgtOutLog( ' RunSliceAdvancement started', 1) - --- Costanti generali -local AMD = require( 'AddManData') - ---------------------------------------------------------------------- -local function ManageSegmentVisibility( SegmentList, nLastActiveIndex, ToHideList) - for Index = 1, #SegmentList do - EgtSetStatus( SegmentList[Index], EgtIf( Index <= nLastActiveIndex, GDB_ST.ON, GDB_ST.OFF)) - end - if ToHideList and #ToHideList > 0 then - for Index = 1, #ToHideList do - EgtSetStatus( ToHideList[Index], GDB_ST.OFF) - end - end -end - ---------------------------------------------------------------------- -local function CalcType( nEntId, nOldType) - local nType = EgtGetInfo( nEntId, KEY_TYPE, 'i') - if not nType or nType == TYPE.LINK or nType == TYPE.COASTING or nType == TYPE.WIPE then - nType = nOldType - end - if nType == TYPE.RIB or nType == TYPE.AUX_SOLID then - nType = TYPE.INFILL - end - if nType == TYPE.EXTRA_SHELL then - nType = TYPE.INNER_SHELL - end - return nType -end - ---------------------------------------------------------------------- -function RunSliceAdvancement.Exec() - -- verifico ci sia almeno uno slice - local nFirstPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. 1) - if not nFirstPartId then - EgtOutBox( 'No sliced part in this project!', 'Error', 'ERROR') - return - else - local nLayerId = EgtGetFirstNameInGroup( nFirstPartId, SLICE_LAYER .. 1) or EgtGetFirstNameInGroup( nFirstPartId, "__" .. SLICE_LAYER .. 1) - if not nLayerId then - EgtOutBox( 'No sliced part in this project!', 'Error', 'ERROR') - return - end - end - local nAdvancementType = 1 -- 1 = All, 2 = Only Outer, 3 = Only Inner, 4 = Only Infill - local nPercentage = 30 - -- leggo ultimi valori - local nViewId = EgtGetFirstNameInGroup( GDB_ID.ROOT, VIEWPARAMS) - if nViewId then - nAdvancementType = EgtGetInfo( nViewId, KEY_SLICE_ADV_MODE, 'i') or SLICE_ADV_TYPE.ALL - nPercentage = EgtGetInfo( nViewId, KEY_SLICE_ADV_PERC, 'i') or 30 - end - local sAdvTypeCombo = '' - if nAdvancementType == SLICE_ADV_TYPE.ALL then - sAdvTypeCombo = 'CB:*All,Only Outer,Only Inner,Only Infill' - elseif nAdvancementType == SLICE_ADV_TYPE.OUTER then - sAdvTypeCombo = 'CB:All,*Only Outer,Only Inner,Only Infill' - elseif nAdvancementType == SLICE_ADV_TYPE.INNER then - sAdvTypeCombo = 'CB:All,Only Outer,*Only Inner,Only Infill' - elseif nAdvancementType == SLICE_ADV_TYPE.INFILL then - sAdvTypeCombo = 'CB:All,Only Outer,Only Inner,*Only Infill' - end - ViewValues = EgtDialogBox( 'Slice advancement', { 'Type', sAdvTypeCombo}, - { 'Percentage (0-100)', tostring( nPercentage)}) - if not ViewValues or #ViewValues < 1 then return end - - if ViewValues[1] == 'All' then - nAdvancementType = SLICE_ADV_TYPE.ALL - elseif ViewValues[1] == 'Only Outer' then - nAdvancementType = SLICE_ADV_TYPE.OUTER - elseif ViewValues[1] == 'Only Inner' then - nAdvancementType = SLICE_ADV_TYPE.INNER - elseif ViewValues[1] == 'Only Infill' then - nAdvancementType = SLICE_ADV_TYPE.INFILL - end - nPercentage = tonumber( ViewValues[2]) - - -- ciclo sui pezzi - local nPartIndex = 1 - local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) - while nPartId do - local nPrintOrder = EgtGetInfo( nPartId, KEY_PRINT_ORDER, 'i') - -- ciclo sui layer per dis/attivare il resto - local nLayerIndex = 1 - local nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) or EgtGetFirstNameInGroup( nPartId, "__" .. SLICE_LAYER .. nLayerIndex) - while nLayerId do - local nCrvId = EgtGetFirstGroupInGroup( nLayerId) - while nCrvId do - local nSolidId = EgtGetFirstNameInGroup( nCrvId, SOLID_GRP) - local ShellList = { {}, {}, {}} - local nSurfId = EgtGetFirstInGroup( nSolidId) - local nOldType = TYPE.OUTER_SHELL - while nSurfId do - local nType = CalcType( nSurfId, nOldType) - nOldType = nType - table.insert( ShellList[nType], nSurfId) - nSurfId = EgtGetNext( nSurfId) - end - local nSegmentQty = 1 - local SegmentList - local ToHideList - if nAdvancementType == SLICE_ADV_TYPE.ALL then - nSegmentQty = #ShellList[1] + #ShellList[2] + #ShellList[3] - if nPrintOrder == PRINT_ORDER.EXT_INT_INF then - SegmentList = ShellList[1] - for i = 1, #ShellList[2] do - SegmentList[#SegmentList + 1] = ShellList[2][i] - end - for i = 1, #ShellList[3] do - SegmentList[#SegmentList + 1] = ShellList[3][i] - end - else - SegmentList = ShellList[3] - for i = 1, #ShellList[2] do - SegmentList[#SegmentList + 1] = ShellList[2][i] - end - for i = 1, #ShellList[1] do - SegmentList[#SegmentList + 1] = ShellList[1][i] - end - end - elseif nAdvancementType == SLICE_ADV_TYPE.OUTER then - nSegmentQty = #ShellList[1] - SegmentList = ShellList[1] - ToHideList = ShellList[2] - for i = 1, #ShellList[3] do - ToHideList[#ToHideList + 1] = ShellList[3][i] - end - elseif nAdvancementType == SLICE_ADV_TYPE.INNER then - nSegmentQty = #ShellList[2] - SegmentList = ShellList[2] - ToHideList = ShellList[1] - for i = 1, #ShellList[3] do - ToHideList[#ToHideList + 1] = ShellList[3][i] - end - elseif nAdvancementType == SLICE_ADV_TYPE.INFILL then - nSegmentQty = #ShellList[3] - SegmentList = ShellList[3] - ToHideList = ShellList[1] - for i = 1, #ShellList[2] do - ToHideList[#ToHideList + 1] = ShellList[2][i] - end - end - local nLastActiveIndex = ceil( nSegmentQty * nPercentage / 100) - ManageSegmentVisibility( SegmentList, nLastActiveIndex, ToHideList) - nCrvId = EgtGetNext( nCrvId) - end - nLayerIndex = nLayerIndex + 1 - nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) or EgtGetFirstNameInGroup( nPartId, "__" .. SLICE_LAYER .. nLayerIndex) - end - nPartIndex = nPartIndex + 1 - nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) - end - - -- riporto impostazioni in gruppo apposito - EgtSetInfo( nViewId, KEY_SLICE_ADV_MODE, nAdvancementType) - EgtSetInfo( nViewId, KEY_SLICE_ADV_PERC, nPercentage) - - EgtDraw() - -end - ---------------------------------------------------------------------- -return RunSliceAdvancement diff --git a/LuaLibs/RunSlicePalette.lua b/LuaLibs/RunSlicePalette.lua deleted file mode 100644 index beb3af9..0000000 --- a/LuaLibs/RunSlicePalette.lua +++ /dev/null @@ -1,102 +0,0 @@ --- RunSlicePalette.lua by Egaltech s.r.l. 2022/08/23 --- Gestione visualizzazione per Stampa 3d - --- Tabella per definizione modulo -local RunSlicePalette = {} - --- Intestazioni -require( 'EgtBase') - -EgtOutLog( ' RunSlicePalette started', 1) - --- Costanti generali -local AMD = require( 'AddManData') - ---------------------------------------------------------------------- -function RunSlicePalette.UpdateColors( nPaletteType) - -- ciclo sui pezzi - local nPartIndex = 1 - local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) - while nPartId do - -- ciclo sui layer per dis/attivare il resto - local nLayerIndex = 1 - local nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) - while nLayerId do - local nCrvId = EgtGetFirstGroupInGroup( nLayerId) - while nCrvId do - local nSolidId = EgtGetFirstNameInGroup( nCrvId, SOLID_GRP) - local nSurfId = EgtGetFirstInGroup( nSolidId) - local nOldType = 0 - while nSurfId do - local Color = EgtStdColor( 'GRAY') - if nPaletteType == PALETTE_TYPE.IN_OUT then - local nType = EgtGetInfo( nSurfId, KEY_TYPE, 'i') - if not nType or nType < TYPE.OUTER_SHELL or nType > TYPE.AUX_SOLID then nType = nOldType end - nOldType = nType - -- scelta del colore - if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then - Color = EgtStdColor( 'TEAL') - elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then - Color = EgtStdColor( 'ORANGE') - elseif nType == TYPE.INFILL then - Color = EgtStdColor( 'YELLOW') - elseif nType == TYPE.LINK then - Color = EgtStdColor( 'GRAY') - elseif nType == TYPE.COASTING then - Color = EgtStdColor( 'BLUE') - elseif nType == TYPE.WIPE then - Color = EgtStdColor( 'LIME') - elseif nType == TYPE.RIB then - Color = EgtStdColor( 'OLIVE') - elseif nType == TYPE.AUX_SOLID then - Color = EgtStdColor( 'AQUA') - end - else - local nResult = EgtGetInfo( nLayerId, KEY_RESULT, 'i') - if nResult == RESULT.OK then - Color = EgtStdColor( 'GREEN') - elseif nResult == RESULT.KO_MINUS then - Color = EgtStdColor( 'ORANGE') - elseif nResult == RESULT.KO_PLUS then - Color = EgtStdColor( 'RED') - end - end - EgtSetColor( nSurfId, Color) - nSurfId = EgtGetNext( nSurfId) - end - nCrvId = EgtGetNext( nCrvId) - end - nLayerIndex = nLayerIndex + 1 - nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) - end - nPartIndex = nPartIndex + 1 - nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) - end - - EgtDraw() - -end - ---------------------------------------------------------------------- -function RunSlicePalette.Exec() - - local nViewId = EgtGetFirstNameInGroup( GDB_ID.ROOT, VIEWPARAMS) or GDB_ID.NULL - - local nOldPaletteType = EgtGetInfo( nViewId, KEY_PALETTE, 'i') - local sCombo = EgtIf( not nOldPaletteType or nOldPaletteType == 1, 'CB:*In/Out,Results', 'CB:In/Out,*Results') - ViewValues = EgtDialogBox( 'Slice Palette', { 'Type', sCombo}) - if not ViewValues or #ViewValues < 1 then return end - - local nPaletteType = PALETTE_TYPE.IN_OUT -- 1 = In/Out, 2 = Results - if ViewValues[1] == 'In/Out' then - nPaletteType = PALETTE_TYPE.IN_OUT - elseif ViewValues[1] == 'Results' then - nPaletteType = PALETTE_TYPE.RESULTS - end - EgtSetInfo( nViewId, KEY_PALETTE, nPaletteType) - - RunSlicePalette.UpdateColors( nPaletteType) -end - ---------------------------------------------------------------------- -return RunSlicePalette diff --git a/LuaLibs/RunSlicing.lua b/LuaLibs/RunSlicing.lua index 02d10f1..6dc72d4 100644 --- a/LuaLibs/RunSlicing.lua +++ b/LuaLibs/RunSlicing.lua @@ -1,4 +1,4 @@ --- RunSlicing.lua by Egaltech s.r.l. 2022/09/15 +-- RunSlicing.lua by Egaltech s.r.l. 2022/09/16 -- Calcoli prima fase per Stampa 3d -- Tabella per definizione modulo @@ -20,181 +20,39 @@ _G.package.loaded.CalcSlices = nil local CSLICES = require( 'CalcSlices') _G.package.loaded.CalcPaths = nil local CPATHS = require( 'CalcPaths') -_G.package.loaded.CalcSolids = nil -local CSOLIDS = require( 'CalcSolids') +_G.package.loaded.RunCalcSolids = nil +local CSOLIDS = require( 'RunCalcSolids') _G.package.loaded.CalcToolPath = nil local CTP = require( 'CalcToolPath') --------------------------------------------------------------------- -local function SetParamInfo( sFile, nParamsGrp, sSection, sKey, sDefaultVal) - local sVal = EgtGetStringFromIni( sSection, sKey, sDefaultVal, sFile) - EgtSetInfo( nParamsGrp, sKey, sVal) -end - ---------------------------------------------------------------------- -local function LoadParams( sFile, nPartId) - - EgtSetInfo( nPartId, KEY_PARAMS, sFile) - - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SLICING_45, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SLICE_STEP, '1.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_STRAND, '6.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SHELLS_NBR, '3') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_OFFSET_SLICE, '0.0') - - local sStrandOrder = EgtGetStringFromIni( SEC_DEFAULT, KEY_PRINT_ORDER, 'InToOut', sFile) - if sStrandOrder == 'OutToIn' then - EgtSetInfo( nPartId, KEY_PRINT_ORDER, PRINT_ORDER.EXT_INT_INF) - else -- 'InToOut' - EgtSetInfo( nPartId, KEY_PRINT_ORDER, PRINT_ORDER.INF_INT_EXT) - end - - local sStrandDirection = EgtGetStringFromIni( SEC_DEFAULT, KEY_PRINT_DIRECTION, 'CCW', sFile) - if sStrandDirection == 'CW' then - EgtSetInfo( nPartId, KEY_PRINT_DIRECTION, PRINT_DIRECTION.CW) - else -- 'CCW' - EgtSetInfo( nPartId, KEY_PRINT_DIRECTION, PRINT_DIRECTION.CCW) - end - - local sLinkType = EgtGetStringFromIni( SEC_DEFAULT, KEY_LINK_TYPE, 'None', sFile) - if sLinkType == 'None' then - EgtSetInfo( nPartId, KEY_LINK_TYPE, LINK_TYPE.NONE) - elseif sLinkType == 'BiArc' then - EgtSetInfo( nPartId, KEY_LINK_TYPE, LINK_TYPE.BIARC) - else -- 'Linear' - EgtSetInfo( nPartId, KEY_LINK_TYPE, LINK_TYPE.LINEAR) - end - - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SP_OFFSET_ON_SLICE, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_LINK_PARAM, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_LINK_ZUP, '0') - - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_FLOOR_NBR, '0') - local sFloorInfill = EgtGetStringFromIni( SEC_DEFAULT, KEY_FLOOR_TYPE, 'Offset', sFile) - if sFloorInfill == 'ZigZag' then - EgtSetInfo( nPartId, KEY_FLOOR_TYPE, INFILL_TYPE.ZIGZAG) - else - EgtSetInfo( nPartId, KEY_FLOOR_TYPE, INFILL_TYPE.OFFSET) - end - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_CEIL_NBR, '0') - local sCeilInfill = EgtGetStringFromIni( SEC_DEFAULT, KEY_CEIL_TYPE, 'Offset', sFile) - if sCeilInfill == 'ZigZag' then - EgtSetInfo( nPartId, KEY_CEIL_TYPE, INFILL_TYPE.ZIGZAG) - else - EgtSetInfo( nPartId, KEY_CEIL_TYPE, INFILL_TYPE.OFFSET) - end - - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SPEED, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_FEED, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_EXT_FEED, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_INT_FEED, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_INFILL_FEED, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_LEAD_IN_FEED, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_LEAD_OUT_FEED, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SUPPORT_FEED, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_G0_FEED, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_MATERIAL, '') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_TOOL_DIAM, '0.0') - - local sLeadInType = EgtGetStringFromIni( SEC_DEFAULT, KEY_LEAD_IN_TYPE, 'None', sFile) - if sLeadInType == 'Linear' then - EgtSetInfo( nPartId, KEY_LEAD_IN_TYPE, LEAD_TYPE.LINEAR) - elseif sLeadInType == 'Arc' then - EgtSetInfo( nPartId, KEY_LEAD_IN_TYPE, LEAD_TYPE.ARC) - else -- 'None' - EgtSetInfo( nPartId, KEY_LEAD_IN_TYPE, LEAD_TYPE.NONE) - end - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_LEAD_IN_TANG_DIST, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_LEAD_IN_ORTHO_DIST, '0.0') - local sLeadOutType = EgtGetStringFromIni( SEC_DEFAULT, KEY_LEAD_OUT_TYPE, 'None', sFile) - if sLeadOutType == 'Linear' then - EgtSetInfo( nPartId, KEY_LEAD_OUT_TYPE, LEAD_TYPE.LINEAR) - elseif sLeadOutType == 'Arc' then - EgtSetInfo( nPartId, KEY_LEAD_OUT_TYPE, LEAD_TYPE.ARC) - else -- 'None' - EgtSetInfo( nPartId, KEY_LEAD_OUT_TYPE, LEAD_TYPE.NONE) - end - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_LEAD_OUT_TANG_DIST, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_LEAD_OUT_ORTHO_DIST, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_OFFSET_LEAD_POINT, '0.0') - - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_COASTING_LEN, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_COASTING_FEED, '20000.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_WIPE_LEN, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_WIPE_FEEDPU, '0.9') - - -- parametri per costolature - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_OVERLAP, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_SHELLS_NBR, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_INVERT_DIR, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_INVERT_ORDER, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LINK, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_IN_INVERT, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_IN_LEN, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_OUT_INVERT, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_OUT_LEN, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_OUT_COASTING, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_OUT_WIPE, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_RIBS_LEAD_OUT_WIPE_DIR, '0.0') - - -- parametri per regioni con diverso numero di passate - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SHELL_NBR_DIFF, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SHELL_NBR_COASTING, EgtGetInfo( nPartId, KEY_COASTING_LEN, 'd')) - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SHELL_NBR_WIPE, EgtGetInfo( nPartId, KEY_WIPE_LEN, 'd')) - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SHELL_NBR_WIPE_DIR, '0.0') - - -- parametri per solidi ausiliari - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_AUX_SOLIDS_OVERLAP, '0') - - local sAuxSolidsInfill = EgtGetStringFromIni( SEC_DEFAULT, KEY_AUX_SOLIDS_INFILL, 'None', sFile) - if sAuxSolidsInfill == 'ZigZag' then - EgtSetInfo( nPartId, KEY_AUX_SOLIDS_INFILL, INFILL_TYPE.ZIGZAG) - elseif sAuxSolidsInfill == 'Offset' then - EgtSetInfo( nPartId, KEY_AUX_SOLIDS_INFILL, INFILL_TYPE.OFFSET) - else - EgtSetInfo( nPartId, KEY_AUX_SOLIDS_INFILL, INFILL_TYPE.NONE) - end - - local sAuxSolidsStrandOrder = EgtGetStringFromIni( SEC_DEFAULT, KEY_AUX_SOLIDS_PRINT_ORDER, 'InToOut', sFile) - if sAuxSolidsStrandOrder == 'OutToIn' then - EgtSetInfo( nPartId, KEY_AUX_SOLIDS_PRINT_ORDER, PRINT_ORDER.EXT_INT_INF) - else -- 'InToOut' - EgtSetInfo( nPartId, KEY_AUX_SOLIDS_PRINT_ORDER, PRINT_ORDER.INF_INT_EXT) - end - - local sAuxSolidsLinkType = EgtGetStringFromIni( SEC_DEFAULT, KEY_AUX_SOLIDS_LINK_TYPE, 'None', sFile) - if sAuxSolidsLinkType == 'None' then - EgtSetInfo( nPartId, KEY_AUX_SOLIDS_LINK_TYPE, LINK_TYPE.NONE) - elseif sAuxSolidsLinkType == 'BiArc' then - EgtSetInfo( nPartId, KEY_AUX_SOLIDS_LINK_TYPE, LINK_TYPE.BIARC) - else -- 'Linear' - EgtSetInfo( nPartId, KEY_AUX_SOLIDS_LINK_TYPE, LINK_TYPE.LINEAR) - end - - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_AUX_SOLIDS_LINK_PARAM, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_AUX_SOLIDS_SP_OFFSET, '0.0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_AUX_SOLIDS_COASTING_LEN, EgtGetInfo( nPartId, KEY_COASTING_LEN, 'd')) - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_AUX_SOLIDS_WIPE_LEN, EgtGetInfo( nPartId, KEY_WIPE_LEN, 'd')) - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_AUX_SOLIDS_WIPE_DIR, '0.0') -end - ---------------------------------------------------------------------- -local function RestoreSolidPosition( nPartId) +local function RestoreOriginalPosition( nPartId) if not nPartId then return end - -- recupero vecchio movimento - local vtMove = EgtGetInfo( nPartId, KEY_MOVED_PART, 'v') - if vtMove then - vtMove = -vtMove + + -- correzione solo del solido ( progetti vecchi) + local vtMove1 = EgtGetInfo( nPartId, KEY_MOVED_PART, 'v') + if vtMove1 then + vtMove1 = - vtMove1 EgtRemoveInfo( nPartId, KEY_MOVED_PART) local SolidLayId = EgtGetFirstNameInGroup( nPartId, PRINT_SOLID) if SolidLayId then local EntId = EgtGetFirstInGroup( SolidLayId) while EntId do - EgtMove( EntId, vtMove) + EgtMove( EntId, vtMove1, GDB_RT.GLOB) EntId = EgtGetNext( EntId) end end end + + -- correzione dell'intero pezzo + local vtMove = EgtGetInfo( nPartId, KEY_MOVED_PART2, 'v') + if vtMove then + EgtRemoveInfo( nPartId, KEY_MOVED_PART2) + EgtMove( nPartId, - vtMove, GDB_RT.GLOB) + -- sistemo il riferimento + local nFrameId = EgtGetFirstNameInGroup( nPartId, LAY_FRAME) + EgtMove( nFrameId, vtMove, GDB_RT.GLOB) + end end --------------------------------------------------------------------- @@ -219,7 +77,7 @@ local function RemoveOldTFS() end --------------------------------------------------------------------- -local function SetViewInfo() +local function SetViewInfo( bCalcSolids) local nViewId = EgtGetFirstNameInGroup( GDB_ID.ROOT, VIEWPARAMS) if not nViewId then nViewId = EgtGroup( GDB_ID.ROOT) @@ -229,18 +87,33 @@ local function SetViewInfo() EgtSetInfo( nViewId, IMPORTED_SOLID, false) EgtSetInfo( nViewId, OUTER_CRV, false) EgtSetInfo( nViewId, PATH_GRP, false) - EgtSetInfo( nViewId, SOLID_GRP, true) + EgtSetInfo( nViewId, SOLID_GRP, bCalcSolids) EgtSetInfo( nViewId, TOOLPATH_GRP, true) end +--------------------------------------------------------------------- +local function VerifyNgeFile( sFilePath) + if not sFilePath or type( sFilePath) ~= 'string' then + return false + end + if EgtGetFileType then + return ( EgtGetFileType( sFilePath) == EEX_FT.NGE) + else + local _, _, sExt = EgtSplitPath( sFilePath or '') + return ( sExt:lower() == '.nge') + end +end + --------------------------------------------------------------------- function RunSlicing.Exec() - -- Verifico che il progetto abbia un nome + -- Verifico che il progetto abbia un nome valido local sCurrProjectPath = EgtGetCurrFilePath() - if not sCurrProjectPath or sCurrProjectPath == '' then - EgtOutBox( 'Save project before calculating slices!', 'Warning', 'WARNING') - return + if not PRINT or PRINT.PROGRAM ~= 1 then + if not VerifyNgeFile( sCurrProjectPath) then + EgtOutBox( 'Save project before calculating slices!', 'Warning', 'WARNING') + return + end end -- Recupero il primo pezzo già posizionato in macchina @@ -257,72 +130,61 @@ function RunSlicing.Exec() end local nSolidLayId = EgtGetFirstNameInGroup( nPartId, PRINT_SOLID) local nStmId = EgtGetFirstInGroup( nSolidLayId or GDB_ID.NULL) - if not nStmId or EgtGetType( nStmId) ~= GDB_TY.SRF_MESH then - EgtOutBox( "Part without surface!", 'Warning', 'WARNING') - return + if nStmId and EgtGetType( nStmId) ~= GDB_TY.SRF_MESH then + EgtOutBox( "Part without surface!", 'Warning', 'WARNING') + return end local nRibsLayId = EgtGetFirstNameInGroup( nPartId, LAY_RIBS) local nShellNbrLay = EgtGetFirstNameInGroup( nPartId, LAY_SHELL_NBR) local nAuxSolidsLay = EgtGetFirstNameInGroup( nPartId, LAY_AUX_SOLIDS) local nStartLayId = EgtGetFirstNameInGroup( nPartId, LAY_MACH_START) - - local sParamFile - if not PRINT or PRINT.PROGRAM ~= 1 then - --Scelta del file dei parametri - local sPrevParamFile = EgtGetInfo( nPartId, KEY_PARAMS) - if not sPrevParamFile or not EgtExistsFile( sPrevParamFile) then - local sLastParamFile = EgtGetStringFromIni( '3dPrinting', 'ParamFile', '', EgtGetIniFile()) - local sDir = EgtSplitPath( sLastParamFile) - sPrevParamFile = sDir..'*.ini' - end - sParamFile = EgtFileDialog( true, sPrevParamFile, 'Param Files (*.ini)|*.ini||') - if not sParamFile then - EgtOutBox( 'No param file selected', 'Warning', 'WARNING') - return - end - EgtWriteStringToIni( '3dPrinting', 'ParamFile', sParamFile, EgtGetIniFile()) - end - - -- Elimino eventuale precedente file dei risultati - local sResultFile = EgtChangePathExtension( sCurrProjectPath, '.csv') - EgtEraseFile( sResultFile) - + -- Elimino eventuale precedente lavorazione EgtSetCurrMachGroup() EgtRemoveAllOperations() EgtResetCurrMachGroup() - -- Lettura dei parametri - if not PRINT or PRINT.PROGRAM ~= 1 then - LoadParams( sParamFile, nPartId) - end -- Lettura dati macchina local sMachIni = EgtGetCurrMachineDir() .. '\\' .. EgtGetCurrMachineName() .. '.ini' local HMax = tonumber( EgtGetStringFromIni( '3dPrinting', 'HMax', 500, sMachIni)) - -- Eventuale ripristino posizione solido - RestoreSolidPosition( nPartId) + -- Eventuale ripristino posizione originaria + RestoreOriginalPosition( nPartId) -- Rimozione vecchi conti RemoveOldSlices( nPartId) -- Rimozione vecchi TFS RemoveOldTFS() - + -- Calcolo delle fette - CSLICES.Exec( nPartId, nStmId, HMax) + local bOk = CSLICES.Exec( nPartId, nStmId, HMax) EgtDraw() -- Calcolo dei percorsi sul centro strand in basso - CPATHS.Exec( nPartId, nStmId) + bOk = bOk and CPATHS.Exec( nPartId) EgtDraw() -- Calcolo dei percorsi di lavoro - CTP.Exec( nPartId) + bOk = bOk and CTP.Exec( nPartId) EgtDraw() -- Calcolo dei solidi degli strand a partire dai percorsi di lavoro - CSOLIDS.Exec( nPartId) + local bCalcSolids = EgtGetInfo( nPartId, KEY_CALC_SOLIDS, 'b') + EgtRemoveInfo( nPartId, KEY_HAS_SOLIDS) + if bCalcSolids and bOk then + CSOLIDS.Exec( nPartId) + end + + if not bOk then + -- eventuale ripristino posizione originaria + RestoreOriginalPosition( nPartId) + -- rimozione vecchi conti + RemoveOldSlices( nPartId) + EgtDraw() + return false + end + EgtSetStatus( nSolidLayId, GDB_ST.OFF) EgtSetStatus( nRibsLayId or GDB_ID.NULL, GDB_ST.OFF) EgtSetStatus( nShellNbrLay or GDB_ID.NULL, GDB_ST.OFF) @@ -331,8 +193,9 @@ function RunSlicing.Exec() EgtDraw() -- Aggiorno impostazioni di visibilita' per ShowManager - SetViewInfo() - + SetViewInfo( bCalcSolids) + + return true end --------------------------------------------------------------------- diff --git a/LuaLibs/RunViewManager.lua b/LuaLibs/RunViewManager.lua deleted file mode 100644 index fcb3110..0000000 --- a/LuaLibs/RunViewManager.lua +++ /dev/null @@ -1,195 +0,0 @@ --- RunViewManager.lua by Egaltech s.r.l. 2022/07/03 --- Gestione visualizzazione per Stampa 3d - --- Tabella per definizione modulo -local RunViewManager = {} - --- Intestazioni -require( 'EgtBase') - -EgtOutLog( ' RunViewManager started', 1) - --- Costanti generali -local AMD = require( 'AddManData') - ---------------------------------------------------------------------- -local function CalcShow( nShellView, nType) - if nShellView == SHELL_VIEW_TYPE.OUTER then - return ( nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL) - elseif nShellView == SHELL_VIEW_TYPE.INNER then - return ( nType == TYPE.INNER_SHELL) - elseif nShellView == SHELL_VIEW_TYPE.INFILL then - return ( nType == TYPE.INFILL) - else --nShellView == SHELL_VIEW_TYPE.ALL - return true - end -end - ---------------------------------------------------------------------- -local function CalcType( nEntId, nOldType) - local nType = EgtGetInfo( nEntId, KEY_TYPE, 'i') - if not nType or nType == TYPE.LINK or nType == TYPE.COASTING or nType == TYPE.WIPE then - nType = nOldType - end - if nType == TYPE.RIB or nType == TYPE.AUX_SOLID then - nType = TYPE.INFILL - end - if nType == TYPE.EXTRA_SHELL then - nType = TYPE.INNER_SHELL - end - return nType -end - ---------------------------------------------------------------------- -function RunViewManager.Exec() - local nVisibilityMode = LAYER_VIEW_TYPE.ALL -- 1 = All, 2 = Till Selected, 3 = Only Selected, 4 = From Selected - local nShellType = SHELL_VIEW_TYPE.ALL -- 1 = All, 2 = Outer, 3 = Inner, 4 = infill - local nOldSelLayerId = GDB_ID.NULL - - -- leggo ultimi valori - local nViewId = EgtGetFirstNameInGroup( GDB_ID.ROOT, VIEWPARAMS) - if nViewId then - nVisibilityMode = EgtGetInfo( nViewId, KEY_LAYER_VIEW, 'i') - nShellType = EgtGetInfo( nViewId, KEY_SHELL_VIEW, 'i') - nOldSelLayerId = EgtGetInfo( nViewId, KEY_SEL_LAYER, 'i') or GDB_ID.NULL - end - local sLayerViewCombo = '' - if nVisibilityMode == LAYER_VIEW_TYPE.TILL_SEL then - sLayerViewCombo = 'CB:All,*Till Selected,Only Selected,From Selected' - elseif nVisibilityMode == LAYER_VIEW_TYPE.ONLY_SEL then - sLayerViewCombo = 'CB:All,Till Selected,*Only Selected,From Selected' - elseif nVisibilityMode == LAYER_VIEW_TYPE.FROM_SEL then - sLayerViewCombo = 'CB:All,Till Selected,Only Selected,*From Selected' - else - sLayerViewCombo = 'CB:*All,Till Selected,Only Selected,From Selected' - end - local sShellViewCombo = '' - if nShellType == SHELL_VIEW_TYPE.OUTER then - sShellViewCombo = 'CB:All,*Outer,Inner,Infill' - elseif nShellType == SHELL_VIEW_TYPE.INNER then - sShellViewCombo = 'CB:All,Outer,*Inner,Infill' - elseif nShellType == SHELL_VIEW_TYPE.INFILL then - sShellViewCombo = 'CB:All,Outer,Inner,*Infill' - else - sShellViewCombo = 'CB:*All,Outer,Inner,Infill' - end - - ViewValues = EgtDialogBox( 'Slicing visibility manager', { 'Visibility Mode', sLayerViewCombo}, - { 'Shell type', sShellViewCombo}) - if not ViewValues or #ViewValues < 2 then return end - - if ViewValues[1] == 'All' then - nVisibilityMode = LAYER_VIEW_TYPE.ALL - elseif ViewValues[1] == 'Till Selected' then - nVisibilityMode = LAYER_VIEW_TYPE.TILL_SEL - elseif ViewValues[1] == 'Only Selected' then - nVisibilityMode = LAYER_VIEW_TYPE.ONLY_SEL - elseif ViewValues[1] == 'From Selected' then - nVisibilityMode = LAYER_VIEW_TYPE.FROM_SEL - end - if ViewValues[2] == 'All' then - nShellType = SHELL_VIEW_TYPE.ALL - elseif ViewValues[2] == 'Outer' then - nShellType = SHELL_VIEW_TYPE.OUTER - elseif ViewValues[2] == 'Inner' then - nShellType = SHELL_VIEW_TYPE.INNER - elseif ViewValues[2] == 'Infill' then - nShellType = SHELL_VIEW_TYPE.INFILL - end - - -- Recupero ultimo layer selezionato - -- verifico sia un pezzo valido - local sSelLayerName = '' - local bFound = false - local nSelLayerId = EgtGetLastSelectedObj() - while nSelLayerId do - local sSelLayerName = EgtGetName( nSelLayerId) - if sSelLayerName and ( sSelLayerName:sub(1, 5) == SLICE_LAYER or sSelLayerName:sub(3, 7) == SLICE_LAYER) then - bFound = true - break - end - nSelLayerId = EgtGetParent( nSelLayerId) - end - if not bFound then - if nOldSelLayerId and nOldSelLayerId ~= GDB_ID.NULL then - nSelLayerId = nOldSelLayerId - else - if nVisibilityMode ~= LAYER_VIEW_TYPE.ALL then - EgtOutBox( 'No selected element!', 'Warning', 'WARNING') - return - else - nSelLayerId = GDB_ID.NULL - sSelLayerName = '' - end - end - end - - -- ciclo sui pezzi - local nPartIndex = 1 - local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) - while nPartId do - -- ciclo sui layer per dis/attivare il resto - local nLayerIndex = 1 - local nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) or EgtGetFirstNameInGroup( nPartId, "__" .. SLICE_LAYER .. nLayerIndex) - while nLayerId do - if nVisibilityMode == LAYER_VIEW_TYPE.ALL then - EgtSetStatus( nLayerId, GDB_ST.ON) - elseif nVisibilityMode == LAYER_VIEW_TYPE.TILL_SEL then - EgtSetStatus( nLayerId, EgtIf( nLayerId <= nSelLayerId, GDB_ST.ON, GDB_ST.OFF)) - elseif nVisibilityMode == LAYER_VIEW_TYPE.ONLY_SEL then - EgtSetStatus( nLayerId, EgtIf( nLayerId == nSelLayerId, GDB_ST.ON, GDB_ST.OFF)) - elseif nVisibilityMode == LAYER_VIEW_TYPE.FROM_SEL then - EgtSetStatus( nLayerId, EgtIf( nLayerId >= nSelLayerId, GDB_ST.ON, GDB_ST.OFF)) - end - local nCrvId = EgtGetFirstGroupInGroup( nLayerId) - while nCrvId do - ---- - local nOldType = TYPE.OUTER_SHELL - local nPathId = EgtGetFirstNameInGroup( nCrvId, PATH_GRP) - local nShellId = EgtGetFirstInGroup( nPathId) - while nShellId do - local nType = CalcType( nShellId, nOldType) - nOldType = nType - EgtSetStatus( nShellId, EgtIf( CalcShow( nShellType, nType), GDB_ST.ON, GDB_ST.OFF)) - nShellId = EgtGetNext( nShellId) - end - ---- - nOldType = TYPE.OUTER_SHELL - local nSolidId = EgtGetFirstNameInGroup( nCrvId, SOLID_GRP) - local nSurfId = EgtGetFirstInGroup( nSolidId) - while nSurfId do - local nType = CalcType( nSurfId, nOldType) - nOldType = nType - EgtSetStatus( nSurfId, EgtIf( CalcShow( nShellType, nType), GDB_ST.ON, GDB_ST.OFF)) - nSurfId = EgtGetNext( nSurfId) - end - ---- - nOldType = TYPE.OUTER_SHELL - local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP) - nShellId = EgtGetFirstInGroup( nToolPathId) - while nShellId do - local nType = CalcType( nShellId, nOldType) - nOldType = nType - EgtSetStatus( nShellId, EgtIf( CalcShow( nShellType, nType), GDB_ST.ON, GDB_ST.OFF)) - nShellId = EgtGetNext( nShellId) - end - nCrvId = EgtGetNext( nCrvId) - end - nLayerIndex = nLayerIndex + 1 - nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) or EgtGetFirstNameInGroup( nPartId, "__" .. SLICE_LAYER .. nLayerIndex) - end - nPartIndex = nPartIndex + 1 - nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) - end - - -- riporto impostazioni in gruppo apposito - EgtSetInfo( nViewId, KEY_LAYER_VIEW, nVisibilityMode) - EgtSetInfo( nViewId, KEY_SHELL_VIEW, nShellType) - EgtSetInfo( nViewId, KEY_SEL_LAYER, nSelLayerId) - - EgtDraw() - -end - ---------------------------------------------------------------------- -return RunViewManager diff --git a/MachiningParamCalc.lua b/MachiningParamCalc.lua deleted file mode 100644 index 42ec772..0000000 --- a/MachiningParamCalc.lua +++ /dev/null @@ -1,18 +0,0 @@ --- MachiningParamCalc.lua by Egaltech s.r.l. 2022/04/05 --- Gestione visualizzazione per Stampa 3d - --- Intestazioni -require( 'EgtBase') -_ENV = EgtProtectGlobal() -EgtEnableDebug( false) - --- Imposto direttorio libreria specializzata per Stampa 3d -local sBaseDir = EgtGetSourceDir() -EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') - --- Librerie -_G.package.loaded.RunMachiningParamCalc = nil -local RMPC = require( 'RunMachiningParamCalc') - --- Calcolo -RMPC.Exec() diff --git a/MachiningParamEdit.lua b/MachiningParamEdit.lua deleted file mode 100644 index b66dc0d..0000000 --- a/MachiningParamEdit.lua +++ /dev/null @@ -1,18 +0,0 @@ --- MachiningParamCalc.lua by Egaltech s.r.l. 2022/04/05 --- Gestione visualizzazione per Stampa 3d - --- Intestazioni -require( 'EgtBase') -_ENV = EgtProtectGlobal() -EgtEnableDebug( false) - --- Imposto direttorio libreria specializzata per Stampa 3d -local sBaseDir = EgtGetSourceDir() -EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') - --- Librerie -_G.package.loaded.RunMachiningParamEdit = nil -local RMPE = require( 'RunMachiningParamEdit') - --- Calcolo -RMPE.Exec() diff --git a/MaterialParamEdit.lua b/MaterialParamEdit.lua deleted file mode 100644 index 6c39045..0000000 --- a/MaterialParamEdit.lua +++ /dev/null @@ -1,18 +0,0 @@ --- MachiningParamCalc.lua by Egaltech s.r.l. 2022/04/09 --- Gestione edit parametri materiali per Stampa 3d - --- Intestazioni -require( 'EgtBase') -_ENV = EgtProtectGlobal() -EgtEnableDebug( false) - --- Imposto direttorio libreria specializzata per Stampa 3d -local sBaseDir = EgtGetSourceDir() -EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') - --- Librerie -_G.package.loaded.RunMaterialParamEdit = nil -local RMPE = require( 'RunMaterialParamEdit') - --- Calcolo -RMPE.Exec() diff --git a/PartPositioning.lua b/PartPositioning.lua deleted file mode 100644 index 76a378e..0000000 --- a/PartPositioning.lua +++ /dev/null @@ -1,20 +0,0 @@ --- PlacePart.lua by Egaltech s.r.l. 2022/04/11 --- Gestione calcolo disposizione e lavorazioni per stampa 3d --- 2022/03/21 Creazione file - - --- Intestazioni -require( 'EgtBase') -_ENV = EgtProtectGlobal() -EgtEnableDebug( false) - --- Imposto direttorio libreria specializzata per Stampa 3d -local sBaseDir = EgtGetSourceDir() -EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') - --- Librerie -_G.package.loaded.RunPartPositioning = nil -local RPP = require( 'RunPartPositioning') - --- Calcolo -RPP.Exec() diff --git a/ShowManager.lua b/ShowManager.lua deleted file mode 100644 index 2509cc0..0000000 --- a/ShowManager.lua +++ /dev/null @@ -1,18 +0,0 @@ --- ShowManager.lua by Egaltech s.r.l. 2022/04/05 --- Gestione visualizzazione per Stampa 3d - --- Intestazioni -require( 'EgtBase') -_ENV = EgtProtectGlobal() -EgtEnableDebug( false) - --- Imposto direttorio libreria specializzata per Stampa 3d -local sBaseDir = EgtGetSourceDir() -EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') - --- Librerie -_G.package.loaded.RunShowManager = nil -local RSM = require( 'RunShowManager') - --- Calcolo -RSM.Exec() diff --git a/SliceAdvancement.lua b/SliceAdvancement.lua deleted file mode 100644 index 54d95d1..0000000 --- a/SliceAdvancement.lua +++ /dev/null @@ -1,18 +0,0 @@ --- SliceAdvancement.lua by Egaltech s.r.l. 2022/04/05 --- Gestione visualizzazione per Stampa 3d - --- Intestazioni -require( 'EgtBase') -_ENV = EgtProtectGlobal() -EgtEnableDebug( false) - --- Imposto direttorio libreria specializzata per Stampa 3d -local sBaseDir = EgtGetSourceDir() -EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') - --- Librerie -_G.package.loaded.RunSliceAdvancement = nil -local RSA = require( 'RunSliceAdvancement') - --- Calcolo -RSA.Exec() diff --git a/SlicePalette.lua b/SlicePalette.lua deleted file mode 100644 index e47e78f..0000000 --- a/SlicePalette.lua +++ /dev/null @@ -1,18 +0,0 @@ --- SlicePalette.lua by Egaltech s.r.l. 2022/04/05 --- Gestione visualizzazione per Stampa 3d - --- Intestazioni -require( 'EgtBase') -_ENV = EgtProtectGlobal() -EgtEnableDebug( false) - --- Imposto direttorio libreria specializzata per Stampa 3d -local sBaseDir = EgtGetSourceDir() -EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') - --- Librerie -_G.package.loaded.RunSlicePalette = nil -local RSP = require( 'RunSlicePalette') - --- Calcolo -RSP.Exec() diff --git a/Slicing.lua b/Slicing.lua index 4248f09..4d1e223 100644 --- a/Slicing.lua +++ b/Slicing.lua @@ -1,4 +1,4 @@ --- Slicing.lua by Egaltech s.r.l. 2022/03/30 +-- Slicing.lua by Egaltech s.r.l. 2023/01/11 -- Calcoli prima fase per Stampa 3d -- Intestazioni @@ -7,8 +7,7 @@ _ENV = EgtProtectGlobal() EgtEnableDebug( false) -- Imposto direttorio libreria specializzata per Stampa 3d -local sBaseDir = EgtGetSourceDir() -EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') +EgtAddToPackagePath( PRINT.BASEDIR .. '\\LuaLibs\\?.lua') -- Librerie _G.package.loaded.RunSlicing = nil diff --git a/Version.lua b/Version.lua new file mode 100644 index 0000000..d615f4e --- /dev/null +++ b/Version.lua @@ -0,0 +1,4 @@ +-- Version.lua by Egaltech s.r.l. 2023/02/28 +-- Gestione della versione di 3dPrinting + +VERSION = '2.5c2' \ No newline at end of file diff --git a/ViewManager.lua b/ViewManager.lua deleted file mode 100644 index 07d1b4b..0000000 --- a/ViewManager.lua +++ /dev/null @@ -1,18 +0,0 @@ --- ViewManager.lua by Egaltech s.r.l. 2022/04/05 --- Gestione visualizzazione per Stampa 3d - --- Intestazioni -require( 'EgtBase') -_ENV = EgtProtectGlobal() -EgtEnableDebug( false) - --- Imposto direttorio libreria specializzata per Stampa 3d -local sBaseDir = EgtGetSourceDir() -EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') - --- Librerie -_G.package.loaded.RunViewManager = nil -local RVM = require( 'RunViewManager') - --- Calcolo -RVM.Exec() diff --git a/32/Images/.placeholder b/bin/LuaLibs/.placeholder similarity index 100% rename from 32/Images/.placeholder rename to bin/LuaLibs/.placeholder