diff --git a/LuaLibs/WProcessFreeContour.lua b/LuaLibs/WProcessFreeContour.lua index 785dc81..c8f9e7b 100644 --- a/LuaLibs/WProcessFreeContour.lua +++ b/LuaLibs/WProcessFreeContour.lua @@ -1,4 +1,4 @@ --- ProcessFreeContour.lua by Egaltech s.r.l. 2023/04/17 +-- ProcessFreeContour.lua by Egaltech s.r.l. 2023/09/12 -- Gestione calcolo profilo libero per Pareti -- 2021/11/15 Penna e chiodature sono sempre riportate sulla faccia sopra anche se nel progetto sono sotto. -- 2021/12/10 In taglio con lama aggiunta gestione SCC per testa Gearbox. @@ -21,6 +21,7 @@ -- 2023/05/25 Funzioni EgtAddMachining sostituite da WM.AddMachining in modo da trascrivere le priorità da btl alle lavorazioni. -- 2023/06/06 Aggiunta gestione lavorazione per lamatura speciale affondata con Tool_ID specifico. -- 2023/07/26 In MakeByCut migliorata la scelta della fresa secondaria nel caso non sia disponibile una fresa di lunghezza sufficiente. +-- 2023/09/12 Modifiche a GetTunnelDimension (asse deve essere com Z globale) e MakeLocalSurf per gestire finestre con lati inclinati. -- Tabella per definizione modulo local WPF = {} @@ -545,86 +546,62 @@ end --------------------------------------------------------------------- local function GetTunnelDimension( nId, nPartId, nAddGrpId) - -- ottengo i versori delle 4 facce e ottengo l'orientamento del tunnel - -- recupero il numero di facce + -- sono necessarie almeno 2 facce local nFacCnt = EgtSurfTmFacetCount( nId) if nFacCnt < 2 then return end - -- recupero l'ingombro della trave + -- recupero l'ingombro del pezzo local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD) - -- variabili dimensioni fessura e id faccia lunga - local dDimMin - local dDimMax - local nLongIdFace = 0 - local bNegFace - local bOppoFace = false - -- ottengo il versore ortogonale - local ptN1, vtN1 = EgtSurfTmFacetCenter( nId, 0, GDB_ID.ROOT) - local vtN2 = EgtSurfTmFacetNormVersor( nId, 1, GDB_ID.ROOT) - local vtOrtho = vtN1 ^ vtN2 - if vtOrtho:isSmall() then - vtN2 = EgtSurfTmFacetNormVersor( nId, 2, GDB_ID.ROOT) or V_NULL() - vtOrtho = vtN1 ^ vtN2 - bOppoFace = true + -- recupero centro e normale delle facce + local ptC = {} + local vtN = {} + for i = 1, nFacCnt do + ptC[i], vtN[i] = EgtSurfTmFacetCenter( nId, i - 1, GDB_ID.ROOT) end - if not vtOrtho:normalize() then return end - if vtOrtho:getZ() < -0.5 then - vtOrtho = -vtOrtho - bNegFace = true + -- determino l'asse medio (le facce sono già ordinate consecutivamente) + local vtAx = V_NULL() + for i = 1, nFacCnt do + local j = i % nFacCnt + 1 + local vtOrtho = vtN[i] ^ vtN[j] + if vtOrtho:normalize() then + vtAx = vtAx + vtOrtho + end end - -- ottengo il boundingBox e prendo le dimensioni lungo la normale (Z locale) che rappresenta la profondità della fessura - local frFc = Frame3d( ptN1, vtOrtho) ; - local bBoxLoc = EgtGetBBoxRef( nId, GDB_BB.STANDARD, frFc) - local dDepth = bBoxLoc:getDimZ() - -- mi assicuro che la Z del punto utilizzato per creare la superficie sia alla Z inferiore del bounding box locale - local ptN2 = Point3d(ptN1) - ptN2:toLoc(frFc) - ptN2 = Point3d( ptN2:getX(), ptN2:getY(), bBoxLoc:getMin():getZ() + 2*GEO.EPS_SMALL) - ptN2:toGlob(frFc) - -- creo superficie intermedia - local nSurfInt = EgtSurfTmPlaneInBBox( nAddGrpId, ptN2, vtOrtho, b3Solid, GDB_ID.ROOT) + if not vtAx:normalize() or abs( vtAx:getZ()) < 0.5 then return end + -- impongo come asse Z globale + vtAx = Z_AX() + -- recupero ingombro del tunnel nel riferimento globale + local b3Box = EgtGetBBoxGlob( nId, GDB_BB.STANDARD) + local dDepth = b3Box:getDimZ() + -- creo faccia in basso (di poco sollevata) + local nSurfInt = EgtSurfTmPlaneInBBox( nAddGrpId, b3Box:getMin() + 2 * GEO.EPS_SMALL * vtAx, vtAx, b3Solid, GDB_ID.ROOT) if not nSurfInt then return end -- ritaglio la superficie con le facce della fessura for i = 1, nFacCnt do local ptN, vtN = EgtSurfTmFacetCenter( nId, i - 1, GDB_ID.ROOT) EgtCutSurfTmPlane( nSurfInt, ptN, -vtN, false, GDB_ID.ROOT) end - -- sposto la geometria trovata sulla Z minima (era su di 2 * GEO.EPS_SMALL) - EgtMove( nSurfInt, Point3d(0,0,-2*GEO.EPS_SMALL) - ORIG(), GDB_RT.GLOB) + -- sposto la geometria trovata sulla Z minima del pezzo + EgtMove( nSurfInt, -2 * GEO.EPS_SMALL * vtAx, GDB_RT.GLOB) -- mi faccio dare il contorno della superfice e la ricreo in modo più corretto local nIdCont, nIdNum = EgtExtractSurfTmLoops( nSurfInt, nAddGrpId) if not nIdCont then return end -- elimino le entità allineate dello stesso tipo - EgtMergeCurvesInCurveCompo( nIdCont, 2*GEO.EPS_SMALL) - EgtErase(nSurfInt) - nSurfInt = EgtSurfTmByFlatContour( nAddGrpId, nIdCont, 2*GEO.EPS_SMALL) - -- elimino il contorno + EgtMergeCurvesInCurveCompo( nIdCont, 2 * GEO.EPS_SMALL) + EgtErase( nSurfInt) + nSurfInt = EgtSurfTmByFlatContour( nAddGrpId, nIdCont, 2 * GEO.EPS_SMALL) EgtErase(nIdCont) - -- se normale negativa inverto - _, vtN1 = EgtSurfTmFacetCenter( nSurfInt, 0, GDB_ID.ROOT) - if vtN1:getZ() < -0.5 then EgtInvertSurf( nSurfInt) end - local _, DimH, DimV = EgtSurfTmFacetMinAreaRectangle( nSurfInt, 0, GDB_ID.ROOT) - dDimMin = min( DimH, DimV) - dDimMax = max( DimH, DimV) - _, DimH, DimV = EgtSurfTmFacetMinAreaRectangle( nId, nFacCnt-1, GDB_ID.ROOT) - -- se faccia pari alla larghezza fessura - if abs(DimH - dDimMax) < GEO.EPS_SMALL or abs(DimV - dDimMax) < GEO.EPS_SMALL then - nLongIdFace = nFacCnt-1 - -- altrimenti verifico anche con la faccia precedente - else - local nFaceToCheck = EgtIf( bOppoFace, nFacCnt-3, nFacCnt-2) - -- prendo le dimensioni della faccia e poi confronto con il minimo - _, DimH, DimV = EgtSurfTmFacetMinAreaRectangle( nId, nFaceToCheck, GDB_ID.ROOT) - -- se trovato con il minimo, questa seconda faccia non è la più lunga - if abs(DimH - dDimMin) < GEO.EPS_SMALL or abs(DimV - dDimMin) < GEO.EPS_SMALL then - nLongIdFace = nFacCnt-1 - else - nLongIdFace = nFaceToCheck + -- ne recupero le dimensioni + local _, dDimMax, dDimMin = EgtSurfTmFacetMinAreaRectangle( nSurfInt, 0, GDB_ID.ROOT) + -- cerco faccia del contorno con lunghezza vicino alla massima + local nLongIdFace + for i = 1, nFacCnt do + local _, DimH, DimV = EgtSurfTmFacetMinAreaRectangle( nId, i - 1, GDB_ID.ROOT) + if DimH > dDimMax - 100 * GEO.EPS_SMALL then + nLongIdFace = i - 1 + break end end - if not dDimMax then - return dDimMin, dDimMax, dDepth, nil, nil - end - return dDimMin, dDimMax, dDepth, vtOrtho, nLongIdFace, nSurfInt + return dDimMin, dDimMax, dDepth, vtAx, nLongIdFace, nSurfInt end --------------------------------------------------------------------- @@ -790,40 +767,28 @@ end --------------------------------------------------------------------- local function MakeLocalSurf( ptP1, ptP2, ptP3, nAddGrpId) - + -- verifico che i tre punti siano definiti if not ptP1 or not ptP2 or not ptP3 then return nil end - - local pAuxId = {} - local nAuxId, AuxId - nAuxId = EgtLine( nAddGrpId, ptP1, ptP2, GDB_RT.GLOB) - table.insert( pAuxId, nAuxId) - nAuxId = EgtLine( nAddGrpId, ptP2, ptP3, GDB_RT.GLOB) - table.insert( pAuxId, nAuxId) - nAuxId = EgtLine( nAddGrpId, ptP3, ptP1, GDB_RT.GLOB) - table.insert( pAuxId, nAuxId) - -- trasformo in percorso - if #pAuxId ~= 3 then + -- creo il contorno + local nLoopId = EgtCurveCompoFromPoints( nAddGrpId, { ptP1, ptP2, ptP3, ptP1}, GDB_RT.GLOB) + if not nLoopId then return nil end - AuxId = EgtCurveCompo( nAddGrpId, pAuxId, true) - -- se non c'é il percorso esco - if not AuxId then - return nil - end - -- creo la superfice piana - local nidFace = EgtSurfTmByFlatContour( nAddGrpId, AuxId, 0.01) - if not nidFace then - EgtErase(AuxId) + -- creo la superfice triangolare (quindi piana) + local nFaceId = EgtSurfTmByFlatContour( nAddGrpId, nLoopId, 0.01) + EgtErase( nLoopId) + if not nFaceId then return nil end -- se normale negativa inverto - local _, vtN1 = EgtSurfTmFacetCenter( nidFace, 0, GDB_ID.ROOT) - if vtN1:getZ() < -0.5 then EgtInvertSurf( nidFace) end + local vtN1 = EgtSurfTmFacetNormVersor( nFaceId, 0, GDB_ID.ROOT) + if vtN1:getZ() < -0.01 then + EgtInvertSurf( nFaceId) + end - EgtErase(AuxId) - return nidFace + return nFaceId end --------------------------------------------------------------------- @@ -840,7 +805,7 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp -- se devo creare superfice locale if bMakeLocSurf then -- creo superfice locale o esco - local nSurfToAdd = MakeLocalSurf( tFacAdj[1][7], tFacAdj[1][8], tFacAdj[1][9], nAddGrpId) + local nSurfToAdd = MakeLocalSurf( tFacAdj[7], tFacAdj[8], tFacAdj[9], nAddGrpId) if nSurfToAdd then local nFacCntPre = EgtSurfTmFacetCount( nNewProc) -- creo copia del percorso principale e gli aggiungo la nuova faccia @@ -859,28 +824,31 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp end -- prendo il primo versore local _, vtN1 = EgtSurfTmFacetCenter( nNewProcLoc, nFacInd, GDB_ID.ROOT) - local _, vtN2 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[1][1], GDB_ID.ROOT) - local _, vtN3 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[1][2], GDB_ID.ROOT) + local _, vtN2 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[1], GDB_ID.ROOT) + local _, vtN3 = EgtSurfTmFacetCenter( nNewProcLoc, tFacAdj[2], GDB_ID.ROOT) -- trovo il punto sulla superfice di riferimento - local _, ptLocP1, ptLocP2, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[1][1], GDB_ID.ROOT) - local _, ptLocP3, ptLocP4, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[1][2], GDB_ID.ROOT) + local _, ptLocP1, ptLocP2, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[1], GDB_ID.ROOT) + local _, ptLocP3, ptLocP4, _ = EgtSurfTmFacetsContact( nNewProcLoc, nFacInd, tFacAdj[2], GDB_ID.ROOT) -- se ho creato faccia locale su copia superficie, cancella la copia if bMakeLocSurf then EgtErase( nNewProcLoc) end + if not ptLocP1 or not ptLocP2 then + return false, 'Error : clean corner with non adjacent faces' + end local nIdIniPoint local nIdEndPoint if ptLocP1 and ptLocP2 then - if ( dist( ptLocP1, tFacAdj[1][4]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[1][4]) < GEO.EPS_SMALL) then + if ( dist( ptLocP1, tFacAdj[4]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[4]) < GEO.EPS_SMALL) then nIdEndPoint = 4 nIdIniPoint = 5 - elseif ( dist( ptLocP1, tFacAdj[1][5]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[1][5]) < GEO.EPS_SMALL) then + elseif ( dist( ptLocP1, tFacAdj[5]) < GEO.EPS_SMALL) or ( dist( ptLocP2, tFacAdj[5]) < GEO.EPS_SMALL) then nIdEndPoint = 5 nIdIniPoint = 4 end end -- versore direzione - local vtExtr = tFacAdj[1][nIdIniPoint] - tFacAdj[1][nIdEndPoint] + local vtExtr = tFacAdj[nIdIniPoint] - tFacAdj[nIdEndPoint] vtExtr:normalize() -- versore direzione di uscita local vtExtrExit @@ -909,44 +877,44 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp vtCheck:rotate( Z_AX(), dOffsAng) end -- controllo se c'è collisione con le facce della superfice - if nTypeConeCut == 1 and CalcInterference( nNewProc, vtCheck, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), dDiam1, dDiam2, + if nTypeConeCut == 1 and CalcInterference( nNewProc, vtCheck, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), dDiam1, dDiam2, dTall1, dTall2, dDiam3, dTall3) then local sErr = 'Collision detect from clean corner tool and surface' EgtOutLog( sErr) return true, '' end - nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdIniPoint], tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB) + nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdIniPoint], tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB) table.insert( pAuxId, nAuxId) -- se uso utensile cono 60° if nTypeConeCut == 1 then -- se offset angolare valido e/o negativo creo il baffo precedente if dOffsAng < ( 100 * GEO.EPS_SMALL) then -- se il punto finale corrisponde con il punto utilizzato in precedenza, uso l'altro - if dist( tFacAdj[1][nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then + if dist( tFacAdj[nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then ptApPoint = ptLocP2 else ptApPoint = ptLocP1 end - nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB) - local dLenTrimExt = dist( tFacAdj[1][nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 0.2) + nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB) + local dLenTrimExt = dist( tFacAdj[nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 0.2) -- se la distanza dei due punti della linea è maggiore dal raggio fresa + delta, trimmo al raggio fresa + delta if dLenTrimExt > 10 * GEO.EPS_SMALL then EgtTrimExtendCurveByLen( nAuxId , -dLenTrimExt, ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB) -- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata if abs(dOffsAng) > 100 * GEO.EPS_SMALL then - EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB) + EgtRotate( nAuxId, tFacAdj[nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB) end -- prendo il nuovo punto finale ptApPoint = EgtEP( nAuxId, GDB_RT.GLOB) + Point3d( 0, 0, dDepthMach) else -- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata if abs(dOffsAng) > 100 * GEO.EPS_SMALL then - EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB) + EgtRotate( nAuxId, tFacAdj[nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB) end end table.insert( pAuxId, nAuxId) -- creo linea di ritorno - nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB) + nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB) table.insert( pAuxId, nAuxId) end end @@ -956,7 +924,7 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp ptLocP1, ptLocP2 = ptLocP3, ptLocP4 if ptLocP1 and ptLocP2 then -- se il punto finale corrisponde con il punto utilizzato in precedenza, uso l'altro - if dist( tFacAdj[1][nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then + if dist( tFacAdj[nIdEndPoint], ptLocP1) < 10 * GEO.EPS_SMALL then ptApPoint = ptLocP2 else ptApPoint = ptLocP1 @@ -965,36 +933,36 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp if nTypeConeCut == 1 then -- se offset angolare valido e/o negativo creo il baffo precedente if dOffsAng > -( 100 * GEO.EPS_SMALL) then - nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB) - local dLenTrimExt = dist( tFacAdj[1][nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 0.2) + nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB) + local dLenTrimExt = dist( tFacAdj[nIdEndPoint], ptApPoint) - (( dToolDiam/2) + 0.2) -- se la distanza dei due punti della linea è maggiore dal raggio fresa + delta, trimmo al raggio fresa + delta if dLenTrimExt > 10 * GEO.EPS_SMALL then EgtTrimExtendCurveByLen( nAuxId , -dLenTrimExt, ptApPoint + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB) -- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata if abs(dOffsAng) > 100 * GEO.EPS_SMALL then - EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB) + EgtRotate( nAuxId, tFacAdj[nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB) end -- prendo il nuovo punto finale ptApPoint = EgtEP( nAuxId, GDB_RT.GLOB) + Point3d( 0, 0, dDepthMach) else -- se ho l'offset angolare ruoto la linea per compensare la rotazione che verrà applicata if abs(dOffsAng) > 100 * GEO.EPS_SMALL then - EgtRotate( nAuxId, tFacAdj[1][nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB) + EgtRotate( nAuxId, tFacAdj[nIdEndPoint], Z_AX(), -dOffsAng, GDB_RT.GLOB) end end table.insert( pAuxId, nAuxId) -- creo linea di ritorno - nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB) + nAuxId = EgtLine( nAddGrpId, ptApPoint + Point3d( 0, 0, -dDepthMach), tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), GDB_RT.GLOB) table.insert( pAuxId, nAuxId) end -- ultima linea di distacco (5mm in direzione utensile) - local pEnd = tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach) + ( 5 * vtExtr) - nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint] + Point3d( 0, 0, -dDepthMach), pEnd, GDB_RT.GLOB) + local pEnd = tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach) + ( 5 * vtExtr) + nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdEndPoint] + Point3d( 0, 0, -dDepthMach), pEnd, GDB_RT.GLOB) table.insert( pAuxId, nAuxId) else -- linea di distacco (2mm in direzione utensile) - local pEnd = tFacAdj[1][nIdEndPoint] + ( 2 * vtExtr) - nAuxId = EgtLine( nAddGrpId, tFacAdj[1][nIdEndPoint], pEnd, GDB_RT.GLOB) + local pEnd = tFacAdj[nIdEndPoint] + ( 2 * vtExtr) + nAuxId = EgtLine( nAddGrpId, tFacAdj[nIdEndPoint], pEnd, GDB_RT.GLOB) table.insert( pAuxId, nAuxId) -- ultima linea di risalita in Z local pIni = pEnd @@ -1017,7 +985,7 @@ local function AddMillCornerMachining( nPartId, nNewProc, nFacInd, tFacAdj, nTyp EgtModifyCurveExtrusion( AuxId, vtExtr, GDB_RT.GLOB) -- se ho un offset angolare ruoto il percorso if abs(dOffsAng) > 100 * GEO.EPS_SMALL then - EgtRotate( AuxId, tFacAdj[1][nIdEndPoint], Z_AX(), dOffsAng, GDB_RT.GLOB) + EgtRotate( AuxId, tFacAdj[nIdEndPoint], Z_AX(), dOffsAng, GDB_RT.GLOB) end -- inserisco la lavorazione local sName = 'Clean_' .. ( EgtGetName( nNewProc) or tostring( nNewProc)) @@ -1111,7 +1079,7 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw, dToolLength = EgtTdbGetCurrToolParam( MCH_TP.LEN) or dToolLength dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth -- qui è la distanza dal portautensile -- calcolo il secondo diametro del cono - dMillTotDiam = dMillDiam + ( abs(dThickTool) * tan(dSideAng)) * 2 + dMillTotDiam = dMillDiam + ( abs( dThickTool) * tan( dSideAng)) * 2 end end -- copio la feature nel layer di appoggio @@ -1122,25 +1090,21 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw, nNewProc = EgtCopyGlob( Proc.Id, nAddGrpId) or GDB_ID.NULL end local nFacCnt = EgtSurfTmFacetCount( nNewProc) - local nFacInd, dDimMin, dDimMax, dDepth, nSurfInt + local nFacInd, dDepth, nSurfInt local bMakeLocSurf if nFacCnt <= 4 then - -- ottengo le dimensioni apertura, la normale e la faccia inferiore - dDimMin, dDimMax, dDepth, _, _, nSurfInt = GetTunnelDimension( nNewProc, Proc.PartId, nAddGrpId) + -- recupero profondità e faccia di fondo + _, _, dDepth, _, _, nSurfInt = GetTunnelDimension( nNewProc, Proc.PartId, nAddGrpId) if nSurfInt then - -- uso la dimensione minima anche nel caso che la cava sborda perchè la lavorazione potrebbe collidere con un pezzo limitrofo - local dMinWidth = dDimMin - nNewProc = EgtSurfTmBySewing( nAddGrpId, {nNewProc,nSurfInt} , true) + -- aggiungo la faccia di fondo appena calcolata + nNewProc = EgtSurfTmBySewing( nAddGrpId, { nNewProc, nSurfInt}, true) -- riordino le facce ReorderFacesFromTab( nNewProc, vFace) - -- acquisisco il numero della faccia + -- aggiorno numero di facce e assegno indice di quella di fondo (sempre ultima) nFacCnt = EgtSurfTmFacetCount( nNewProc) nFacInd = nFacCnt - 1 else return true - --local sErr = 'Error : cannot create base surface' - --EgtOutLog( sErr) - --return false, sErr end else bMakeLocSurf = true @@ -1161,10 +1125,8 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw, while i <= #vFace do -- se tutta la faccia o la sua fine senza taglio, inserisco una fresatura if ( vFace[i].Type & 2) ~= 0 or vFace[i].Type == 4 then - -- variabili costruzione geometria - local tFacAdj = {} + -- variabili costruzione geometria (nface1, nFace2, tFacAdj) local nFace1 = vFace[i].Fac - local nFace2 -- ricavo i tre punti per eventuale superficie locale local ptLoc1, ptLoc2, ptLoc3 -- punto precedente (punto precedente della faccia [i]) @@ -1175,7 +1137,7 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw, if not j then return true end - nFace2 = vFace[j].Fac + local nFace2 = vFace[j].Fac -- punto in comune tra le due facce (punto precedente della faccia [j]) ptLoc1 = vFace[j].PPrev -- punto successivo ( precedente della faccia successiva) @@ -1190,9 +1152,10 @@ local function AddMillCorner( nTypeConeCut, vFace, Proc, nRawId, b3Raw, -- ricavo i punti e l'angolo interno local _, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( nNewProc, nFace1, nFace2, GDB_ID.ROOT) -- se punti validi e angolo è interno e non è quasi piatto e >= 90 creo istanza + local tFacAdj = {} if ptP1 and ptP2 and dAng < 0 and dAng < -6 and dAng > EgtIf( nTypeConeCut == 1, -(90 + 10 * GEO.EPS_SMALL), -(180-dAngleSmall + 10 * GEO.EPS_SMALL)) then local dLen = dist( ptP1, ptP2) - table.insert( tFacAdj, { nFace1, nFace2, dLen, ptP1, ptP2, dAng, ptLoc1, ptLoc2, ptLoc3}) + tFacAdj = { nFace1, nFace2, dLen, ptP1, ptP2, dAng, ptLoc1, ptLoc2, ptLoc3} end -- se ho un elemento creo percorso o percorsi in base al tipo di cono e all'apertura dall'angolo rispetto ai 90° -- con una tolleranza di 2 gradi diff --git a/Version.lua b/Version.lua index b47f7f8..47156cd 100644 --- a/Version.lua +++ b/Version.lua @@ -1,6 +1,6 @@ --- Version.lua by Egalware s.r.l. 2023/08/01 +-- Version.lua by Egalware s.r.l. 2023/09/12 -- Gestione della versione di Wall NAME = 'Wall' -VERSION = '2.5h1' +VERSION = '2.5i1' MIN_EXE = '2.5b3'