diff --git a/Profiles/Profilo78 - Offset - Copy (55).nge b/Profiles/Profilo78 - Offset - Copy (55).nge new file mode 100644 index 0000000..8f6e5b1 Binary files /dev/null and b/Profiles/Profilo78 - Offset - Copy (55).nge differ diff --git a/Profiles/Profilo78 - Offset.nge b/Profiles/Profilo78 - Offset.nge index 8f6e5b1..0b43bf1 100644 Binary files a/Profiles/Profilo78 - Offset.nge and b/Profiles/Profilo78 - Offset.nge differ diff --git a/Profiles/WinConst.lua b/Profiles/WinConst.lua index a58f8cd..503acae 100644 --- a/Profiles/WinConst.lua +++ b/Profiles/WinConst.lua @@ -169,6 +169,7 @@ WIN_FRAME_SPLIT = 'Frame_Split' WIN_MIXED_BOTTOM = 'Mixed_Bottom' WIN_MIXED_TOP = 'Mixed_Top' WIN_MIXED_SPLIT = 'Mixed_Split' +WIN_INFO_GRP = 'Info' WIN_REF = 'Ref' WIN_SECTION = 'Section' @@ -207,6 +208,7 @@ WIN_GEO_IN = 'In' WIN_GEO_OUT = 'Out' WIN_GEO_LEFT = 'Left' WIN_GEO_RIGHT = 'Right' +WIN_GEO_RAW = 'GeoRaw' WIN_PRF_TYPE = 'Type' WIN_PRF_MAIN = 'Main' @@ -239,7 +241,6 @@ WIN_SASH_DEPTH = 'SashDepth' WIN_RAD_REF = 'RefRad' WIN_EXTRA_DIST = 'ExtraDist' WIN_PRC_PHASE = 'PHASE' -WIN_PRC_PROFILE_INFO = 'PROFILE_INFO' WIN_PRC_NTOOLS = 'NTOOLS' WIN_PRC_TOOL_NAME = 'TOOL_NAME' WIN_PRC_OFFL = 'OFFL' @@ -286,6 +287,7 @@ WIN_PRC_TYPE = { CUT = 'Cut', STRIP_CUT = 'StripCut' } +WIN_PRC_PROFILE_INFO = 'PROFILE_INFO' WIN_PRC_PROFILE_TYPE = { HEAD = 'Head', LONGITUDINAL = 'Longitudinal', @@ -305,6 +307,7 @@ WIN_PRC_SIDETYPE = { } WIN_DOWEL = 'Dowel' +WIN_DWL_DIAM = 'DowelsDiam' WIN_DWL_TOP_PERP_LEN = 'TopPerpLen' WIN_DWL_TOP_PARA_LEN = 'TopParaLen' WIN_DWL_BOTTOM_PERP_LEN = 'BottomPerpLen' @@ -313,7 +316,9 @@ WIN_DWL_RAILBOTTOM_PERP_LEN = 'RailBottomPerpLen' WIN_DWL_RAILBOTTOM_PARA_LEN = 'RailBottomParaLen' WIN_DWL_SPLIT_PERP_LEN = 'SplitPerpLen' WIN_DWL_SPLIT_PARA_LEN = 'SplitParaLen' +WIN_DWL_LOG_LEN = 'DowelsLogLen' +WIN_LOGS = 'Log' WIN_PRJ_ORIGSPLIT = 'OrigSplit' diff --git a/Profiles/WinLib/WinCalculate.lua b/Profiles/WinLib/WinCalculate.lua index 50b4737..94730d0 100644 --- a/Profiles/WinLib/WinCalculate.lua +++ b/Profiles/WinLib/WinCalculate.lua @@ -96,32 +96,30 @@ local function FindIntersectionPoint( nCrv1, nCrv2, ptRef) end --------------------------------------------------------------------- --- funzione che dato un gruppo contenente curve ordinate che creano una curva chiusa, +-- funzione che data una lista di curve ordinate che creano una curva chiusa, -- ne estende/taglia i contorni per ottenere una curva chiusa continua -local function TrimAndOrientOrderedCurveLayer( nLayerId, bOrient) +local function TrimAndOrientOrderedCurves( vCrvs, bOrient) + local IntersCurveList = {} local LastCurveInters - local nCurveId = EgtGetFirstInGroup( nLayerId) - -- ciclo sui segmenti per ottenere lista intersezioni - while nCurveId do - local nPrevId = EgtGetPrev( nCurveId) - if not nPrevId then - nPrevId = EgtGetLastInGroup( nLayerId) - end - local ptInters = FindIntersectionPoint( nCurveId, nPrevId, EgtSP( nCurveId)) + -- ciclo sulle curve per ottenere lista intersezioni + for i = 1, #vCrvs do + -- recupero la precedente + local nPrevIndex = EgtIf( i == 1, #vCrvs, i - 1) + -- calcolo intersezione + local ptInters = FindIntersectionPoint( vCrvs[i], vCrvs[ nPrevIndex], EgtSP( vCrvs[i])) if LastCurveInters then LastCurveInters.EndInters = Point3d( ptInters) -- se il punto di intersezione è lo stesso trovato nell'iterazione precedente cerco una seconda -- intersezione tra le due curve if AreSamePointApprox( ptInters, LastCurveInters.StartInters) then - ptInters = FindIntersectionPoint( nCurveId, nPrevId, EgtEP( nCurveId)) + ptInters = FindIntersectionPoint( vCrvs[i], vCrvs[ nPrevIndex], EgtEP( vCrvs[i])) LastCurveInters.EndInters = Point3d( ptInters) end end - local NewCurveInters = { CurveId = nCurveId, StartInters = Point3d( ptInters)} + local NewCurveInters = { CurveId = vCrvs[i], StartInters = Point3d( ptInters)} table.insert( IntersCurveList, NewCurveInters) LastCurveInters = NewCurveInters - nCurveId = EgtGetNext( nCurveId) end IntersCurveList[#IntersCurveList].EndInters = IntersCurveList[1].StartInters @@ -160,11 +158,11 @@ end local function GetOutlineProfileId( nOutlineId, bUseBottomRail) -- ciclo fino a trovare il primo parent che abbia un AreaType definito ( frame o sash) - local nCurrId = nOutlineId + local nParentId = EgtGetParent( nOutlineId) local nAreaType = WIN_AREATYPES.NULL - while nCurrId and ( nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL) do - nCurrId = EgtGetParent( nCurrId) - nAreaType = EgtGetInfo( nCurrId or GDB_ID.NULL, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL + while nParentId and ( nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL) do + nParentId = EgtGetParent( nParentId) + nAreaType = EgtGetInfo( nParentId or GDB_ID.NULL, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL end -- recupero il gruppo contenente il profilo @@ -181,7 +179,7 @@ local function GetOutlineProfileId( nOutlineId, bUseBottomRail) -- verifico se bottom rail if bUseBottomRail then - local nOutlineLay = EgtGetParent( nOutlineId) + local nOutlineLay = EgtGetFirstNameInGroup( nParentId, WIN_AREAOUTLINE) local bBottomRail = EgtGetInfo( nOutlineLay, WIN_BOTTOMRAIL, 'b') or false local sOutlineName = EgtGetName( nOutlineId) if sOutlineName == WIN_BOTTOM and bBottomRail then @@ -655,7 +653,7 @@ local function CalculateOutlineFromAreaOutline( nAreaId) nBaseOutlineId = EgtGetNext( nBaseOutlineId) end -- taglio tutti i contorni - TrimAndOrientOrderedCurveLayer( nOutlineLayerId, true) + TrimAndOrientOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), true) -- se presente, copio split local nBaseSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT) @@ -750,7 +748,7 @@ local function CalculateOutlineFromAreaOutline( nAreaId) nBaseOutlineId = EgtGetNext( nBaseOutlineId) end -- accorcio gli offset - TrimAndOrientOrderedCurveLayer( nOutlineLayerId, true) + TrimAndOrientOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), true) -- se presente, copio split local nBaseSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT) @@ -816,7 +814,7 @@ local function CalculateOutlineFromAreaOutline( nAreaId) nBaseOutlineId = EgtGetNext( nBaseOutlineId) end -- accorcio gli offset - TrimAndOrientOrderedCurveLayer( nOutlineLayerId, true) + TrimAndOrientOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), true) end end @@ -1012,25 +1010,53 @@ local function GetProfileCtrIn( nPrevOutlineId, nOutlineId, nPrevProfileId) end --------------------------------------------------------------------- --- funzione che crea la superficie corrispondente al Geo di un pezzo +-- funzione che crea la superficie corrispondente al Geo di un pezzo gestendo i casi di autointersezione local function CreateGeoArea( nGeoLayId, nDestLayId) - local vCrvs = EgtGetAllInGroup( nGeoLayId) - local nCompoId = EgtCurveCompoByChain( nDestLayId, vCrvs, EgtSP( vCrvs[1]), false) - EgtChangeClosedCurveStartPoint( nCompoId, EgtSP( vCrvs[1])) - -- verifico che orientamento della composita rispecchi quello della curva out - if not AreSameVectorApprox( EgtSV( nCompoId), EgtSV( vCrvs[1])) then - EgtInvertCurve( nCompoId) + -- recupero le curve left e right e verifico se hanno orientamento coerente ( quindi non generano autointersezioni) + local bAutointers = false + local vLeft = EgtGetNameInGroup( nGeoLayId, WIN_LEFT) + local vRight = EgtGetNameInGroup( nGeoLayId, WIN_RIGHT) + if #vLeft == 2 and not AreSamePointApprox( EgtEP( vLeft[1]), EgtSP( vLeft[2])) then + bAutointers = true + -- se orientamento non coerente devo ignorare la prima curva + vLeft[1] = GDB_ID.NULL end + if #vRight == 2 and not AreSamePointApprox( EgtEP( vRight[1]), EgtSP( vRight[2])) then + bAutointers = true + -- se orientamento non coerente devo ignorare la seconda curva + vRight[2] = GDB_ID.NULL + end + + local nCompoId + if not bAutointers then + -- se no autointersezioni costruisco il bordo del geo usando direttamente le sue curve + local vCrvs = EgtGetAllInGroup( nGeoLayId) + nCompoId = EgtCurveCompo( nDestLayId, vCrvs, false) + else + -- nel caso di autointersezione devo ignorare le curve left e right con orientamento non coerente + local vGeoCrvs = {} + local nOutId = EgtGetFirstNameInGroup( nGeoLayId, WIN_GEO_OUT) + vGeoCrvs[1] = EgtCopyGlob( nOutId, nDestLayId) + for i = 1, #vRight do + if vRight[i] ~= GDB_ID.NULL then + table.insert( vGeoCrvs, EgtCopyGlob( vRight[i], nDestLayId)) + end + end + local nInId = EgtGetFirstNameInGroup( nGeoLayId, WIN_GEO_IN) + table.insert( vGeoCrvs, EgtCopyGlob( nInId, nDestLayId)) + for i = 1, #vLeft do + if vLeft[i] ~= GDB_ID.NULL then + table.insert( vGeoCrvs, EgtCopyGlob( vLeft[i], nDestLayId)) + end + end + -- taglio le curve + TrimAndOrientOrderedCurves( vGeoCrvs, false) + -- creo compo + nCompoId = EgtCurveCompo( nDestLayId, vGeoCrvs) + end + local nArea = EgtSurfFlatRegion( nDestLayId, nCompoId) - -- controllo per eventuale autointersezione del geo di un pezzo di split - local vtN = EgtSurfFrNormVersor( nArea) - if AreOppositeVectorApprox( vtN, Z_AX()) then - EgtErase( nArea) - local nGeoIn = EgtGetFirstNameInGroup( nGeoLayId, WIN_GEO_IN) - EgtChangeClosedCurveStartPoint( nCompoId, EgtSP( nGeoIn)) - nArea = EgtSurfFlatRegion( nDestLayId, nCompoId) - end EgtErase( nCompoId) return nArea @@ -1215,7 +1241,7 @@ local function CreateFrameGeo( nOutlineId, vPrevOutlineId, vNextOutlineId, nStar end -- trim delle curve - TrimAndOrientOrderedCurveLayer( nGeoLayerId, false) + TrimAndOrientOrderedCurves( EgtGetAllInGroup( nGeoLayerId), false) -- salvo spessore serramento nel gruppo local dGeoWidth = b3CurrProfileFrame:getDimX() @@ -2131,6 +2157,28 @@ end ---------------------------------------------------------------------------------- ---------------------------------- DOWELS ---------------------------------------- ---------------------------------------------------------------------------------- +-- funzione che sottrae il dowel al solido +local function UpdateSolidWithDowel( nDowelId, nSolidId, vtDir, dLen, nLayerId) + + -- creo il solido del dowel a partire dalla circonferenza che lo definisce + local nDowelSolidId + if s_bSimplSolid then + -- se solidi semplificati creo foro grossolano per velocizzare operazioni di subtract + local nDowelApprox = EgtCopyGlob( nDowelId, nLayerId) + EgtApproxCurve( nDowelApprox, GDB_CA.LINES, 0.2) + nDowelSolidId = EgtSurfTmByRegionExtrusion( nLayerId, nDowelApprox, vtDir * dLen) + EgtErase( nDowelApprox) + else + nDowelSolidId = EgtSurfTmByRegionExtrusion( nLayerId, nDowelId, vtDir * dLen) + end + + -- sottraggo il dowel al solido + EgtSurfTmSubtract( nSolidId, nDowelSolidId) + EgtErase( nDowelSolidId) + +end + +--------------------------------------------------------------------- -- funzione che calcola il riferimento dove posizionare i dowels local function CreateDowelFrameDest( nRefProfileType, nPrevGeo, nGeo, nRefOutline, bFullOrShort, bSashOrFrame) @@ -2215,20 +2263,7 @@ local function CreateDowel( nOrigDowelId, nLayerId, frOrig, frDest, vtDir, nTest -- eventuale aggiornamento del solido if nMainExtrusionId then - -- creo solido di estrusione del dowel - local nDowelExtrusionId - if s_bSimplSolid then - -- creo foro grossolano per velocizzare operazioni di subtract - local nDowelApprox = EgtCopyGlob( nDowelId, nLayerId) - EgtApproxCurve( nDowelApprox, GDB_CA.LINES, 0.2) - nDowelExtrusionId = EgtSurfTmByRegionExtrusion( nLayerId, nDowelApprox, vtDir * dLen) - EgtErase( nDowelApprox) - else - nDowelExtrusionId = EgtSurfTmByRegionExtrusion( nLayerId, nDowelId, vtDir * dLen) - end - -- sottraggo il dowel al solido - EgtSurfTmSubtract( nMainExtrusionId, nDowelExtrusionId) - EgtErase( nDowelExtrusionId) + UpdateSolidWithDowel( nDowelId, nMainExtrusionId, vtDir, dLen, nLayerId) end return nDowelId @@ -3027,6 +3062,288 @@ end +---------------------------------------------------------------------------------- +---------------------------------- TRONCHETTI ---------------------------------- +---------------------------------------------------------------------------------- +-- funzione che spezza l'anta in corrispondenza dei tronchetti del telaio +local function SplitArcByAlignment( nGeoIn, nGrp) + + -- recupero il pezzo del telaio corrispondente + local nPartId = EgtGetParent( EgtGetParent( nGeoIn)) + local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i') + local nSouId = EgtGetInfo( nOutlineId, WIN_COPY, 'i') + local nAreaType = WIN_AREATYPES.NULL + while nSouId and nAreaType ~= WIN_AREATYPES.FRAME do + nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i') or GDB_ID.NULL + local nParentArea = EgtGetParent( EgtGetParent( nSouId)) or GDB_ID.NULL + nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i') + end + if not nSouId then return end + local nFrameOutlineId = EgtGetInfo( nSouId, WIN_COPY, 'i') + local nFramePartId = EgtGetInfo( nFrameOutlineId, WIN_REF_PART, 'i') + + -- recupero le parti in cui era stato diviso l'arco del telaio + local nFrameLogsLayer = EgtGetFirstNameInGroup( nFramePartId, WIN_LOGS) + local vFrameLogs = EgtGetNameInGroup( nFrameLogsLayer, WIN_GEO_IN) + local ptC = EgtCP( vFrameLogs[1]) + + local nCurrCrvId = EgtCopyGlob( nGeoIn, nGrp) + local bInters = false + for i = 1, #vFrameLogs - 1 do + -- ricavo il punto di split sull'arco dell'anta + local ptFrame = EgtEP( vFrameLogs[i]) + local vtDir = ptFrame - ptC + local nLineSplit = EgtLinePVL( nGrp, ptC, vtDir, vtDir:len() + 1000) + local ptInt = EgtIP( nCurrCrvId, nLineSplit, ORIG()) + EgtErase( nLineSplit) + if ptInt then + nCurrCrvId = EgtSplitCurveAtPoint( nCurrCrvId, ptInt) or GDB_ID.NULL + bInters = true + elseif bInters then + -- se non ci sono più intersezioni esco + return + end + end +end + +--------------------------------------------------------------------- +-- funzione che spezza l'arco in base al numero di pezzi +local function SplitArcByNumber( nLogsNbr, nGeoIn, nGrp) + local nCopy = EgtCopyGlob( nGeoIn, nGrp) + EgtSplitCurve( nCopy, nLogsNbr) +end + +--------------------------------------------------------------------- +-- funzione che spezza gli archi per i tronchetti +local function SplitArc( nLogsNbr, vSections, bAlign, dOverMatTot, nGeoIn, nGeoOut, nGrp) + + -- per allineamento con telaio + if bAlign then + return SplitArcByAlignment( nGeoIn, nGrp) + + -- per sezione + elseif #vSections == 1 and nLogsNbr == 0 then + -- dalla sezione ricavo il numero minimo di pezzi + local dSection = vSections[1] - dOverMatTot + local dROut = EgtArcRadius( nGeoOut) + local dRIn = EgtArcRadius( nGeoIn) + local dAng = abs( EgtArcAngCenter( nGeoIn)) + local nParts + if dSection < dROut - dRIn + GEO.EPS_SMALL then + -- sezione troppo piccola + -- TO DO : gestione errore + EgtOutBox( 'Sezione tronchetto troppo piccola', '') + elseif dSection > dROut + dRIn - GEO.EPS_SMALL then + -- la sezione comprende già l'intero pezzo + nParts = 1 + else + nParts = dAng / 2 / acos( ( dROut - dSection) / dRIn) + nParts = ceil( nParts) + end + return SplitArcByNumber( nParts, nGeoIn, nGrp) + + -- per numero di pezzi + else + return SplitArcByNumber( nLogsNbr, nGeoIn, nGrp) + end +end + +--------------------------------------------------------------------- +-- funzione che calcola la sezione dei tronchetti +local function CalcLogsSection( nLogsNbr, vSections, bAlign, dOverMatTot, nGeoIn, nGeoOut, nGrp) + + -- se richiesta una sezione specifica senza vincoli sul numero di pezzi + if not bAlign and #vSections == 1 and nLogsNbr == 0 then + return vSections[1] + end + + -- calcolo la sezione necessaria per la suddivisione scelta + local dMySection = 0 + local dROut = EgtArcRadius( nGeoOut) + local dRIn = EgtArcRadius( nGeoIn) + if bAlign then + -- calcolo la massima sezione dai tronchetti ottenuti + local vSplits = EgtGetAllInGroup( nGrp) + for i = 1, #vSplits do + local dAng = abs( EgtArcAngCenter( vSplits[i])) + local dCurrSection = dROut - dRIn * cos( dAng / 2) + if dCurrSection > dMySection then + dMySection = dCurrSection + end + end + dMySection = dMySection + dOverMatTot + + else + -- ricavo la sezione dal numero di pezzi + local dAng = abs( EgtArcAngCenter( nGeoIn)) + dMySection = dROut - dRIn * cos( dAng / nLogsNbr / 2) + dOverMatTot + end + + if #vSections == 0 then + -- se no vincoli sulla sezione + return dMySection + else + -- cerco la sezione più adatta dalla lista di sezioni disponibili + table.sort( vSections) + for i = 1, #vSections do + if vSections[i] > dMySection - GEO.EPS_SMALL then + return vSections[i] + end + end + -- se non ho trovato la sezione errore + EgtOutBox( 'Sezioni tronchetti troppo piccole per suddivisione richiesta', '') + return nil + end +end + +--------------------------------------------------------------------- +local function CalcLogs( nGrp, nGeoOut, dOverMatIn, dOverMatOut, dOverMatExt, dOverMatInt, dRefSection, bCutExtremities) + + -- recupero tutti i tratti dell'arco + local vCrvsIn = EgtGetAllInGroup( nGrp) + local ptC = EgtCP( vCrvsIn[1]) + + -- calcolo i tronchetti + for i = 1, #vCrvsIn do + + local ptSIn = EgtSP( vCrvsIn[i]) + local ptEIn = EgtEP( vCrvsIn[i]) + + -- recupero il tratto corrispondente sulla curva out + local ptSOut, dParSOut, ptEOut, dParEOut + if i == 1 then + -- forzo a coincidere con l'estremo della curva out + ptEOut = EgtEP( nGeoOut) + dParEOut = 1 + else + _, ptEOut, dParEOut = EgtPointCurveDist( ptSIn, nGeoOut) + end + if i == #vCrvsIn then + -- forzo a coincidere con l'estremo della curva out + ptSOut = EgtSP( nGeoOut) + dParSOut = 0 + else + _, ptSOut, dParSOut = EgtPointCurveDist( ptEIn, nGeoOut) + end + local nOut = EgtCopyGlob( nGeoOut, nGrp) + EgtTrimCurveStartEndAtParam( nOut, dParSOut, dParEOut) + + -- creo composita corrispondente al pezzo + local nCompo = EgtCurveCompo( nGrp, {vCrvsIn[i]}, false) + EgtAddCurveCompoLine( nCompo, ptSOut) + EgtAddCurveCompoCurve( nCompo, nOut, false) + EgtCloseCurveCompo( nCompo) + + -- calcolo il frame per il tronchetto + local ptM = EgtMP( vCrvsIn[i]) + local vtRad = ptM - ptC + local frRef = Frame3d( ptM, vtRad ^ Z_AX(), vtRad, Z_AX()) + + -- calcolo il box locale al frame + local b3Ref = EgtGetBBoxRef( nCompo, GDB_BB.STANDARD, frRef) + local ptMin = b3Ref:getMin() + local ptMax = b3Ref:getMax() + + -- verifico se necessario sovramateriale extra per raggiungere la sezione desiderata + local dExtraSection = max( 0, dRefSection - b3Ref:getDimY() - dOverMatIn - dOverMatOut) + + -- lato bottom + local nLineBottom = EgtLinePVL( nGrp, ptMin - ( dOverMatIn + 0.5 * dExtraSection) * Y_AX(), X_AX(), 10000) + EgtExtendCurveStartByLen( nLineBottom, 10000) + EgtTransform( nLineBottom, frRef) + + -- lato top + local nLineTop = EgtLinePVL( nGrp, ptMax + ( dOverMatOut + 0.5 * dExtraSection) * Y_AX(), - X_AX(), 10000) + EgtExtendCurveStartByLen( nLineTop, 10000) + EgtTransform( nLineTop, frRef) + + -- lato right + local nLineRight + if i == 1 and not bCutExtremities then + nLineRight = EgtLinePVL( nGrp, ptMin, - Y_AX(), 10000) + EgtTransform( nLineRight, frRef) + else + nLineRight = EgtLine( nGrp, ptEOut, ptSIn) + EgtExtendCurveEndByLen( nLineRight, 10000) + end + EgtOffsetCurve( nLineRight, EgtIf( i == 1, dOverMatExt, dOverMatInt)) + EgtExtendCurveStartByLen( nLineRight, 10000) + + -- lato left + local nLineLeft + if i == #vCrvsIn and not bCutExtremities then + nLineLeft = EgtLinePVL( nGrp, ptMax, Y_AX(), 10000) + EgtTransform( nLineLeft, frRef) + else + nLineLeft = EgtLine( nGrp, ptEIn, ptSOut) + EgtExtendCurveEndByLen( nLineLeft, 10000) + end + EgtOffsetCurve( nLineLeft, EgtIf( i == #vCrvsIn, dOverMatExt, dOverMatInt)) + EgtExtendCurveStartByLen( nLineLeft, 10000) + + -- taglio le curve nei loro punti di intersezione + local vCrvs = { nLineTop, nLineRight, nLineBottom, nLineLeft} + TrimAndOrientOrderedCurves( vCrvs, false) + + -- TO DO : controllo lunghezza minima + -- local dLenTop = EgtCurveLength( nLineTop) + + -- creo il tronchetto + local nLogCrv = EgtCurveCompo( nGrp, vCrvs) + EgtSetName( nLogCrv, WIN_LOGS) + EgtSetColor( nLogCrv, EgtStdColor( 'BLUE')) + + -- salvo i sovramateriali utilizzati nella curva + EgtSetInfo( nLogCrv, WIN_PRC_OVERMAT_IN, dOverMatIn) + EgtSetInfo( nLogCrv, WIN_PRC_OVERMAT_OUT, dOverMatOut) + EgtSetInfo( nLogCrv, WIN_PRC_OVERMAT_LEFT, EgtIf( i == #vCrvsIn, dOverMatExt, dOverMatInt)) + EgtSetInfo( nLogCrv, WIN_PRC_OVERMAT_RIGHT, EgtIf( i == 1, dOverMatExt, dOverMatInt)) + + EgtSetStatus( vCrvsIn[i], GDB_ST.OFF) + EgtSetStatus( nOut, GDB_ST.OFF) + EgtErase( nCompo) + end +end + +--------------------------------------------------------------------- +-- funzione che calcola i tronchetti di un pezzo ad arco +function WinCalculate.CreateArcLogs( nPartId, nLogsNbr, vSections, bAlign, dOverMatOut, dOverMatIn, dOverMatExt, dOverMatInt, bCutExtremities) + + -- verifico dati in ingresso + if bAlign then nLogsNbr = 0 end + if not bAlign and nLogsNbr == 0 and ( #vSections == 0 or #vSections > 1) then + return + end + + -- recupero o creo il gruppo per i tronchetti + local nGrp = EgtGetFirstNameInGroup( nPartId, WIN_LOGS) + if not nGrp then + nGrp = EgtGroup( nPartId) + EgtSetName( nGrp, WIN_LOGS) + else + EgtEmptyGroup( nGrp) + end + + -- recupero il geo del pezzo + local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO) + local nGeoIn = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN) + local nGeoOut = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_OUT) + + -- spezzo l'arco interno + SplitArc( nLogsNbr, vSections, bAlign, dOverMatOut + dOverMatIn, nGeoIn, nGeoOut, nGrp) + + -- calcolo la sezione di riferimento per i tronchetti + local dSection = CalcLogsSection( nLogsNbr, vSections, bAlign, dOverMatOut + dOverMatIn, nGeoIn, nGeoOut, nGrp) + if not dSection then + return + end + + -- creo i tronchetti + CalcLogs( nGrp, nGeoOut, dOverMatIn, dOverMatOut, dOverMatExt, dOverMatInt, dSection, bCutExtremities) +end + + + ---------------------------------------------------------------------------------- ------------------------------ FUNZIONI ---------------------------------------- ---------------------------------------------------------------------------------- @@ -3099,61 +3416,420 @@ function WinCalculate.AssembleFrame() --EgtChangeGroupFrame( nRightPartId, frRight) end + + +---------------------------------------------------------------------------------- +------------------- POST PROCESSING PER AUTOMATISMO LAVORAZIONI ------------------ +---------------------------------------------------------------------------------- +-- funzione che crea la spina per tronchetti +local function CalcLogDowel( nOrigPartId, nCrvOut, bLeftOrRight, nProcLayerId, nProfileId, nInfoGrp, nSolidId) + + -- creo il frame per il posizionamento del dowel + local nOutlineRef = EgtGetInfo( nOrigPartId, WIN_REF_OUTLINE, 'i') + local ptRef = EgtIf( bLeftOrRight, EgtSP( nCrvOut), EgtEP( nCrvOut)) + local _, ptOrig, dParOrig = EgtPointCurveDist( ptRef, nOutlineRef) + local vtFrame = EgtUV( nOutlineRef, dParOrig, -1) + local frDest = Frame3d( ptOrig, - vtFrame) + + -- calcolo direzione verso interno del pezzo + local vtDir = frDest:getVersZ() + if bLeftOrRight then + vtDir = - vtDir + end + + -- recupero i dati del dowel + local dDowelDiam = EgtGetInfo( nInfoGrp, WIN_DWL_DIAM, 'd') + local dDowelLen = EgtGetInfo( nInfoGrp, WIN_DWL_LOG_LEN, 'd') + + -- creo il dowel nel riferimento della sezione + -- TO DO : recupero della sezione corretta nel caso di cambio profilo + local nSectionId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTION) or EgtGetFirstNameInGroup( nProfileId, WIN_SASH .. WIN_SECTION) + local nDowelId = EgtCircle( nProcLayerId, EgtGP( nSectionId), 0.5 * dDowelDiam) + + -- posiziono il dowel usando i riferimenti + local nFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME) + local frOrig = EgtFR( nFrameId) + frOrig:invert() + EgtTransform( nDowelId, frOrig) + EgtTransform( nDowelId, frDest) + + local nPartId = EgtGetParent( nProcLayerId) + local dOverMat = EgtGetInfo( nPartId, EgtIf( bLeftOrRight, WIN_PRC_OVERMAT_LEFT, WIN_PRC_OVERMAT_RIGHT)) + EgtMove( nDowelId, - vtDir * ( s_dDowelTol + dOverMat)) + EgtModifyCurveExtrusion( nDowelId, - vtDir) + local dLen = dDowelLen + dOverMat + s_dDowelTol + EgtModifyCurveThickness( nDowelId, - dLen) + + -- setto info di lavorazione + EgtSetInfo( nDowelId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE) + EgtSetInfo( nDowelId, WIN_PRC_SIDE, EgtIf( bLeftOrRight, WIN_PRC_SIDETYPE.LEFT, WIN_PRC_SIDETYPE.RIGHT)) + + -- eventuale aggiornamento del solido + if nSolidId then + UpdateSolidWithDowel( nDowelId, nSolidId, vtDir, dLen, nProcLayerId) + end +end + +--------------------------------------------------------------------- +-- funzione che crea il pezzo del tronchetto +local function PrepareLogPart( nOrigPartId, nCrvIn, nCrvOut, bFirst, bLast, bFinishedLog, nInfoGrp) + + local nPartId = EgtGroup( GDB_ID.ROOT) + EgtSetName( nPartId, WIN_LOGS) + EgtSetColor( nPartId, Color3d( 204, 102, 0)) + + local nLogCrv = EgtGetNext( nCrvOut) + + -- setto le info con i sovramateriali corrispondenti + CopyInfo( nPartId, nLogCrv, WIN_PRC_OVERMAT_IN, 0) + CopyInfo( nPartId, nLogCrv, WIN_PRC_OVERMAT_OUT, 0) + CopyInfo( nPartId, nLogCrv, WIN_PRC_OVERMAT_LEFT, 0) + CopyInfo( nPartId, nLogCrv, WIN_PRC_OVERMAT_RIGHT, 0) + + -- recupero il profilo + local nProfileLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_PROFILE) + local nProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) + + -- a) GEORAW + local nGeoRawLayerId = EgtGroup( nPartId) + EgtSetName( nGeoRawLayerId, WIN_GEO_RAW) + EgtCopyGlob( nLogCrv, nGeoRawLayerId) + -- creo il frame ausiliario + local vtX = EgtSV( nLogCrv) + local frGeo = Frame3d( EgtSP( nLogCrv), vtX, Z_AX() ^ vtX, Z_AX()) + local nFrameId = EgtFrame( nGeoRawLayerId, frGeo) + EgtSetName( nFrameId, WIN_PRC_FRAME) + + -- b) SOLIDO + local nSolidId + if s_bCalcSolid then + local nSolidLayerId = EgtGroup( nPartId) + EgtSetName( nSolidLayerId, WIN_SOLID) + if bFirst and bLast then + -- essendo singolo pezzo il solido è quello originale + local nOrigSolidLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_SOLID) + local nOrigSolidId = EgtGetFirstNameInGroup( nOrigSolidLayerId, WIN_SRF_MAIN) + EgtRelocateGlob( nOrigSolidId, nSolidLayerId) + elseif bFinishedLog then + -- recupero il solido originale e lo taglio opportunamente agli estremi + local nOrigSolidLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_SOLID) + local nOrigSolidId = EgtGetFirstNameInGroup( nOrigSolidLayerId, WIN_SRF_MAIN) + nSolidId = EgtCopyGlob( nOrigSolidId, nSolidLayerId) + + local bBox = GetProfileLocalBox( nProfileId) + local dDimY = bBox:getDimY() + if not bFirst then + local nTrimCrv = EgtLine( nSolidLayerId, EgtUP( nLogCrv, 2), EgtUP( nLogCrv, 1)) + EgtMove( nTrimCrv, Z_AX()) + local nTrimSrf = EgtSurfTmByExtrusion( nSolidLayerId, nTrimCrv, - Z_AX() * ( dDimY + 2), WIN_SURF_APPROX) + EgtSurfTmIntersect( nSolidId, nTrimSrf) + EgtErase( { nTrimCrv, nTrimSrf}) + end + if not bLast then + local nTrimCrv = EgtLine( nSolidLayerId, EgtSP( nLogCrv), EgtUP( nLogCrv, 3)) + EgtMove( nTrimCrv, Z_AX()) + local nTrimSrf = EgtSurfTmByExtrusion( nSolidLayerId, nTrimCrv, - Z_AX() * ( dDimY + 2), WIN_SURF_APPROX) + EgtSurfTmIntersect( nSolidId, nTrimSrf) + EgtErase( { nTrimCrv, nTrimSrf}) + end + else + -- il solido è esattamente il tronchetto + local bBox = GetProfileLocalBox( nProfileId) + nSolidId = EgtSurfTmByRegionExtrusion( nSolidLayerId, nLogCrv, - bBox:getDimY() * Z_AX()) + EgtSetName( nSolidId, WIN_SOLID) + end + end + + -- c) LAVORAZIONI + local nOrigProcLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_PRC) + + -- se unico tronchetto le lavorazioni sono quelle del pezzo originale + if bFirst and bLast then + EgtRelocateGlob( nOrigProcLayerId, nPartId) + EgtSetStatus( nOrigProcLayerId, GDB_ST.ON) + return + end + + local nProcLayerId = EgtGroup( nPartId) + EgtSetName( nProcLayerId, WIN_PRC) + + -- profili in e out + if bFinishedLog then + EgtRelocateGlob( nCrvIn, nProcLayerId) + local nSemiProfileInId = EgtGetInfo( nCrvIn, WIN_SEMI_PROFILE, 'i') + GetProcessingInfoFromSemiProfile( nCrvIn, nSemiProfileInId) + EgtSetStatus( nCrvIn, GDB_ST.ON) + EgtRelocateGlob( nCrvOut, nProcLayerId) + local nSemiProfileOutId = EgtGetInfo( nCrvOut, WIN_SEMI_PROFILE, 'i') + GetProcessingInfoFromSemiProfile( nCrvOut, nSemiProfileOutId) + EgtSetStatus( nCrvOut, GDB_ST.ON) + end + + -- profilo left + if bLast and bFinishedLog then + -- recupero la curva di lavorazione dal pezzo originale + local nLeftPrc = EgtGetFirstNameInGroup( nOrigProcLayerId, WIN_GEO_LEFT) + EgtRelocateGlob( nLeftPrc, nProcLayerId) + elseif not bLast then + -- minizinken + local nLeftId = EgtLine( nProcLayerId, EgtUP( nLogCrv, 3), EgtSP( nLogCrv)) + EgtSetName( nLeftId, WIN_LEFT) + -- assegno le info di lavorazione + EgtSetInfo( nLeftId, WIN_PRC_NTOOLS, 1) + local sToolName = EgtGetInfo( nInfoGrp, WIN_PRC_TOOL_NAME) + EgtSetInfo( nLeftId, WIN_PRC_TOOL_NAME .. '_1', sToolName) + local dOffR = EgtGetInfo( nInfoGrp, WIN_PRC_OFFR, 'd') + -- TO DO : verificare valore OffsR + EgtSetInfo( nLeftId, WIN_PRC_OFFR .. '_1', dOffR) + local dOffL = EgtGetInfo( nInfoGrp, WIN_PRC_OFFL .. '_1', 'd') + EgtSetInfo( nLeftId, WIN_PRC_OFFL .. '_1', dOffL) + end + + -- profilo right + if bFirst and bFinishedLog then + -- recupero la curva di lavorazione dal pezzo originale + local nRightPrc = EgtGetFirstNameInGroup( nOrigProcLayerId, WIN_GEO_RIGHT) + EgtRelocateGlob( nRightPrc, nProcLayerId) + elseif not bFirst then + -- minizinken + local nRightId = EgtLine( nProcLayerId, EgtUP( nLogCrv, 1), EgtUP( nLogCrv, 2)) + EgtSetName( nRightId, WIN_RIGHT) + -- assegno info di lavorazione + EgtSetInfo( nRightId, WIN_PRC_NTOOLS, 1) + local sToolName = EgtGetInfo( nInfoGrp, WIN_PRC_TOOL_NAME) + EgtSetInfo( nRightId, WIN_PRC_TOOL_NAME .. '_1', sToolName) + local dOffR = EgtGetInfo( nInfoGrp, WIN_PRC_OFFR, 'd') + -- TO DO : verificare valore OffsR + EgtSetInfo( nRightId, WIN_PRC_OFFR .. '_1', dOffR) + local dOffL = EgtGetInfo( nInfoGrp, WIN_PRC_OFFL .. '_2', 'd') + EgtSetInfo( nRightId, WIN_PRC_OFFL .. '_1', dOffL) + end + + -- dowels per incastro dei tronchetti + if not bFirst then + CalcLogDowel( nOrigPartId, nCrvOut, false, nProcLayerId, nProfileId, nInfoGrp, nSolidId) + end + if not bLast then + CalcLogDowel( nOrigPartId, nCrvOut, true, nProcLayerId, nProfileId, nInfoGrp, nSolidId) + end + + -- se i tronchetti sono gestiti come pezzi finiti cerco le lavorazioni del pezzo orginale che appartengono al tronchetto + if bFinishedLog then + local vProcessings = EgtGetAllInGroup( nOrigProcLayerId) + local nSurfTest = EgtSurfFlatRegion( nProcLayerId, nLogCrv) + for i = 1, #vProcessings do + local sPrcType = EgtGetInfo( vProcessings[i], WIN_PRC_FEATURE_TYPE) + -- forature + if sPrcType == WIN_PRC_TYPE.HOLE then + local sSide = EgtGetInfo( vProcessings[i], WIN_PRC_SIDE) + -- se dowel sull'estremo lo assegno direttamente al tronchetto corrispondente + if ( sSide == WIN_PRC_SIDETYPE.LEFT and bLast) or ( sSide == WIN_PRC_SIDETYPE.RIGHT and bFirst) then + EgtRelocateGlob( vProcessings[i], nProcLayerId) + end + -- altrimenti verifico se interno al tronchetto corrente + if sSide == WIN_PRC_SIDETYPE.IN then + local _, _, nSide = EgtPointCurveDistSide( EgtCP( vProcessings[i]), nLogCrv, Z_AX()) + if nSide == -1 then + -- copio perchè la stessa lavorazione potrebbe coinvolgere più tronchetti + EgtCopyGlob( vProcessings[i], nProcLayerId) + else + -- verifico anche la faccia di fondo + local vtExtr = EgtCurveExtrusion( vProcessings[i]) + local dThickness = EgtCurveThickness( vProcessings[i]) + _, _, nSide = EgtPointCurveDistSide( EgtCP( vProcessings[i]) + dThickness * vtExtr, nLogCrv, Z_AX()) + if nSide == -1 then + EgtCopyGlob( vProcessings[i], nProcLayerId) + end + end + end + -- fermavetro + elseif sPrcType == WIN_PRC_TYPE.STRIP_CUT then + -- TO DO da sistemare + local nStrip = EgtCopyGlob( vProcessings[i], nProcLayerId) + EgtTrimCurveWithRegion( nStrip, nSurfTest, true, false) + else + -- TO DO lavorazioni legate alla ferramenta, cambio profilo + end + end + EgtErase( nSurfTest) + end +end + +--------------------------------------------------------------------- +-- funzione che crea gli elementi ausiliari per la creazione del grezzo nell'automatismo +local function PrepareGeoRawCurve( nPartId, nGeoRawLayerId, nGeoLayerId) + + -- recupero le curve del geo + local nOut = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_OUT) + local nIn = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN) + local vRight = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_RIGHT) + local vLeft = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_LEFT) + -- verifico se le curve right e left hanno direzioni coerenti + if #vRight == 2 and not AreSamePointApprox( EgtEP( vRight[1]), EgtSP( vRight[2])) then + -- la seconda curva va ignorata + EgtErase( vRight[2]) + vRight = { vRight[1]} + end + if #vLeft == 2 and not AreSamePointApprox( EgtEP( vLeft[1]), EgtSP( vLeft[2])) then + -- la prima curva va ignorata + EgtErase( vLeft[1]) + vLeft = { vLeft[2]} + end + + -- recupero i sovramateriali da applicare alle curve + local dOvermatOut = EgtGetInfo( nPartId, WIN_PRC_OVERMAT_OUT, 'd') + local dOvermatRight = EgtGetInfo( nPartId, WIN_PRC_OVERMAT_RIGHT, 'd') + local dOvermatIn = EgtGetInfo( nPartId, WIN_PRC_OVERMAT_IN, 'd') + local dOvermatLeft = EgtGetInfo( nPartId, WIN_PRC_OVERMAT_LEFT, 'd') + + -- applico i sovramateriali + EgtOffsetCurve( nOut, dOvermatOut) + for i = 1, #vRight do + EgtOffsetCurve( vRight[i], dOvermatRight) + end + EgtOffsetCurve( nIn, dOvermatIn) + for i = 1, #vLeft do + EgtOffsetCurve( vLeft[i], dOvermatLeft) + end + + -- creo la composita a partire dalle curve + local vCrvs = EgtGetAllInGroup( nGeoLayerId) + TrimAndOrientOrderedCurves( vCrvs, false) + local nCompo = EgtCurveCompo( nGeoRawLayerId, vCrvs) + + return nCompo +end + +--------------------------------------------------------------------- +-- funzione che crea gli elementi ausiliari per la creazione del grezzo nell'automatismo nel caso di arco spezzato in tronchetti +local function PrepareGeoRawCurveFromLogs( nPartId, nGeoRawLayerId, nLogsLayerId) + + -- recupero i vari tronchetti + local vLogCrvs = EgtGetNameInGroup( nLogsLayerId, WIN_LOGS) + + -- salvo le info di sovramateriale nel pezzo + CopyInfo( nPartId, vLogCrvs[1], WIN_PRC_OVERMAT_IN, 0) + CopyInfo( nPartId, vLogCrvs[1], WIN_PRC_OVERMAT_OUT, 0) + local nOvermatLateral = EgtGetInfo( vLogCrvs[1], WIN_PRC_OVERMAT_RIGHT, 'd') + EgtSetInfo( nPartId, WIN_PRC_OVERMAT_RIGHT, nOvermatLateral) + EgtSetInfo( nPartId, WIN_PRC_OVERMAT_LEFT, nOvermatLateral) + + -- costruisco il grezzo a partire dai tronchetti + local vCrvs = {} + local vIdIn = {} + -- recupero le curve in e out dei tronchetti + for i = #vLogCrvs, 1, -1 do + local nLineOut = EgtLine( nGeoRawLayerId, EgtUP( vLogCrvs[i], 0), EgtUP( vLogCrvs[i], 1)) + local nLineIn = EgtLine( nGeoRawLayerId, EgtUP( vLogCrvs[i], 2), EgtUP( vLogCrvs[i], 3)) + table.insert( vCrvs, nLineOut) + table.insert( vIdIn, nLineIn) + end + local nLineR = EgtLine( nGeoRawLayerId, EgtEP( vCrvs[#vCrvs]), EgtSP( vIdIn[#vIdIn])) + table.insert( vCrvs, nLineR) + for i = #vIdIn, 1, -1 do + table.insert( vCrvs, vIdIn[i]) + end + local nLineL = EgtLine( nGeoRawLayerId, EgtEP( vIdIn[1]), EgtSP( vCrvs[1])) + table.insert( vCrvs, nLineL) + + -- taglio le curve nelle intersezioni ( va eliminato il sovramateriale per minizinken) + TrimAndOrientOrderedCurves( vCrvs, false) + + -- costruisco la compo del grezzo + local nCompo = EgtCurveCompo( nGeoRawLayerId, vCrvs) + + return nCompo +end + --------------------------------------------------------------------- -- funzione che prepara il progetto per passarlo all'automatismo delle lavorazioni function WinCalculate.PrepareProject() - -- elimino il gruppo dei profili + -- recupero il gruppo dei profili local nProfileLay = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) - EgtErase( nProfileLay) - -- elimino il gruppo delle aree - local nAreaLay = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AREA .. '*') - EgtErase( nAreaLay) + local nInfoGrp = EgtGetFirstNameInGroup( nProfileLay, WIN_INFO_GRP) + -- elimino i pezzi di tipo fill local vFills = EgtGetNameInGroup( GDB_ID.ROOT, WIN_FILL) EgtErase( vFills) - -- in ogni pezzo - local nPartId = EgtGetFirstInGroup( GDB_ID.ROOT) - while nPartId do + -- TO DO : recupero modalità di lavorazione dei tronchetti + local bFinishedLogs = true + + -- preparo ogni pezzo per l'automatismo ( quindi salto i primi due che sono il gruppo dei profili e delle aree) + local vParts = EgtGetAllInGroup( GDB_ID.ROOT) + for i = 3, #vParts do + + local bDeletePart = false - -- cancello il gruppo dei profili - local nProfileGrp = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) - EgtErase( nProfileGrp) - - -- cancello eventuali gruppi ausiliari per cambio profilo - local nMixedOutlines = EgtGetFirstNameInGroup( nPartId, WIN_MIXED_OUTLINES) - EgtErase( nMixedOutlines or GDB_ID.NULL) - local nMixedIntersections = EgtGetFirstNameInGroup( nPartId, WIN_MIXED_INTERSECTIONS) - EgtErase( nMixedIntersections or GDB_ID.NULL) - - -- accendo gruppo delle lavorazioni - local nProcLay = EgtGetFirstNameInGroup( nPartId, WIN_PRC) - EgtSetStatus( nProcLay, GDB_ST.ON) - - -- nel gruppo dei solidi conservo solo quello principale - local nSolidGrp = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) - if nSolidGrp then - local nMainSolid = EgtGetFirstNameInGroup( nSolidGrp, WIN_SRF_MAIN) - local vIds = EgtGetAllInGroup( nSolidGrp) - for i = 1, #vIds do - if vIds[i] ~= nMainSolid then - EgtErase( vIds[i]) - end + -- verifico se tronchetti + local nLogsLayerId = EgtGetFirstNameInGroup( vParts[i], WIN_LOGS) + if nLogsLayerId then + -- calcolo i pezzi corrispondenti ai tronchetti + local vCrvIn = EgtGetNameInGroup( nLogsLayerId, WIN_GEO_IN) + local vCrvOut = EgtGetNameInGroup( nLogsLayerId, WIN_GEO_OUT) + for j = 1, #vCrvIn do + PrepareLogPart( vParts[i], vCrvIn[j], vCrvOut[j], j == 1, j == #vCrvIn, bFinishedLogs, nInfoGrp) end + -- il pezzo originale va cancellato se i tronchetti sono lavorati come pezzi finiti oppure se c'è un solo tronchetto + bDeletePart = bFinishedLogs or ( #vCrvIn == 1) end - -- nel gruppo geo creo frame ausiliario - local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO) - local nOutCrv = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_OUT) - local vtS = EgtSV( nOutCrv) - local frGeo = Frame3d( EgtSP( nOutCrv), vtS, Z_AX() ^ vtS, Z_AX()) - local nFrameId = EgtFrame( nGeoLayerId, frGeo) - EgtSetName( nFrameId, WIN_PRC_FRAME) - - -- passo al pezzo successivo - nPartId = EgtGetNext( nPartId) + if bDeletePart then + EgtErase( vParts[i]) + else + -- cancello il gruppo dei profili + local nProfileGrp = EgtGetFirstNameInGroup( vParts[i], WIN_PROFILE) + EgtErase( nProfileGrp or GDB_ID.NULL) + + -- cancello eventuali gruppi ausiliari per cambio profilo + local nMixedOutlines = EgtGetFirstNameInGroup( vParts[i], WIN_MIXED_OUTLINES) + EgtErase( nMixedOutlines or GDB_ID.NULL) + local nMixedIntersections = EgtGetFirstNameInGroup( vParts[i], WIN_MIXED_INTERSECTIONS) + EgtErase( nMixedIntersections or GDB_ID.NULL) + + -- accendo gruppo delle lavorazioni + local nProcLay = EgtGetFirstNameInGroup( vParts[i], WIN_PRC) + EgtSetStatus( nProcLay, GDB_ST.ON) + + -- nel gruppo dei solidi conservo solo quello principale + local nSolidGrp = EgtGetFirstNameInGroup( vParts[i], WIN_SOLID) + if nSolidGrp then + local nMainSolid = EgtGetFirstNameInGroup( nSolidGrp, WIN_SRF_MAIN) + local vIds = EgtGetAllInGroup( nSolidGrp) + for i = 1, #vIds do + if vIds[i] ~= nMainSolid then + EgtErase( vIds[i]) + end + end + end + + -- creo il GeoRaw per il calcolo del grezzo + local nGeoRawLayerId = EgtGroup( vParts[i]) + EgtSetName( nGeoRawLayerId, WIN_GEO_RAW) + local nGeoLayerId = EgtGetFirstNameInGroup( vParts[i], WIN_GEO) + local nCompo + if nLogsLayerId then + nCompo = PrepareGeoRawCurveFromLogs( vParts[i], nGeoRawLayerId, nLogsLayerId) + EgtErase( nLogsLayerId) + else + nCompo = PrepareGeoRawCurve( vParts[i], nGeoRawLayerId, nGeoLayerId) + end + EgtErase( nGeoLayerId) + -- creo frame ausiliario + local vtX = EgtSV( nCompo) + local frGeo = Frame3d( EgtSP( nCompo), vtX, Z_AX() ^ vtX, Z_AX()) + local nFrameId = EgtFrame( nGeoRawLayerId, frGeo) + EgtSetName( nFrameId, WIN_PRC_FRAME) + end end + + -- elimino il gruppo delle aree + local nAreaLay = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AREA .. '*') + EgtErase( nAreaLay) + -- elimino il gruppo dei profili + EgtErase( nProfileLay) + end