- correzioni cambio profilo.
This commit is contained in:
SaraP
Binary file not shown.
Binary file not shown.
@@ -234,8 +234,7 @@ WIN_GAPDELTAIN = 'GapDeltaIn'
|
||||
WIN_GAPDELTAOUT = 'GapDeltaOut'
|
||||
WIN_FIXED_REF = 'FixedRef'
|
||||
WIN_SASH_REF = 'SashRef'
|
||||
WIN_MIXED_DEPTH = 'MixedDepth'
|
||||
WIN_MIXED_FILLET = 'MixedFillet'
|
||||
WIN_SASH_DEPTH = 'SashDepth'
|
||||
WIN_PRC_PHASE = 'PHASE'
|
||||
WIN_PRC_PROFILE_TYPE = 'PROFILE_TYPE'
|
||||
WIN_PRC_NTOOLS = 'NTOOLS'
|
||||
|
||||
+186
-277
@@ -991,7 +991,7 @@ local function GetProfileCtrIn( nPrevOutlineId, nOutlineId, nPrevProfileId)
|
||||
else
|
||||
-- 2) pezzo del telaio con cambio profilo
|
||||
-- il profilo da usare dipende dal pezzo corrente: se ha figli di tipo fill allora è legato alla parte fill del cambio profilo, se ha figli di tipo sash è legato alla parte sash,
|
||||
-- se ha entrambe le tipologie di figli allora è mixed split e conviene considerare parte sash perchè ha DeltaCP minore
|
||||
-- se ha entrambe le tipologie di figli allora è mixed split e va considerata la parte sash ( perchè è quella utilizzata per tagliare il pezzo)
|
||||
local vSashChildren = EgtGetInfo( nOutlineId, WIN_SASH_CHILDREN, 'vi')
|
||||
if vSashChildren then
|
||||
sPrevCtrIn = WIN_SASH .. WIN_CTRIN
|
||||
@@ -1205,7 +1205,7 @@ local function CreateFrameGeo( nOutlineId, vPrevOutlineId, vNextOutlineId, nStar
|
||||
EgtSetInfo( nNextCurveId, WIN_SEMI_PROFILE, nNextSemiProfile)
|
||||
EgtSetInfo( nNextCurveId, WIN_REF_OUTLINE, vNextOutlineId[i])
|
||||
EgtRelocateGlob( nNextCurveId, nCurrOffsetId, GDB_IN.BEFORE)
|
||||
end
|
||||
end
|
||||
|
||||
-- trim delle curve
|
||||
TrimAndOrientOrderedCurveLayer( nGeoLayerId, false)
|
||||
@@ -1387,7 +1387,7 @@ local function CalcMixedOutlines( nPartId, nOutlineId)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- funzione che crea la curva di lavorazione sulla giunzione tra il pezzo di split e il pezzo di telaio con cambio profilo
|
||||
-- funzione che crea la curva di riferimento sulla giunzione tra il pezzo di split e il pezzo di telaio con cambio profilo
|
||||
local function CalcMixedIntersections( nPartId, nOutline, vOutlines)
|
||||
|
||||
local nGrp = EgtGroup( nPartId)
|
||||
@@ -1423,48 +1423,18 @@ local function CalcMixedIntersections( nPartId, nOutline, vOutlines)
|
||||
vtDir45:rotate( Z_AX(), EgtIf( bSashFill, 225, -45))
|
||||
local nCrv3 = EgtLinePVL( nGrp, ptRef1, vtDir45, 100)
|
||||
local nCrv4 = EgtCopyGlob( nOutline, nGrp)
|
||||
local dDeltaSashFrame = EgtGetInfo( nMainProfileId, WIN_SASH_REF, 'd')
|
||||
local dDeltaSashFrame = EgtGetInfo( nMainProfileId, WIN_SASH_REF .. '1', 'd')
|
||||
EgtOffsetCurve( nCrv4, - dDeltaSashFrame)
|
||||
local ptRef2 = EgtIP( nCrv3, nCrv4, ORIG())
|
||||
|
||||
-- ricavo il punto finale del tratto del telaio contro anta
|
||||
local nCrv5 = EgtCopyGlob( nSplitId, nGrp)
|
||||
local dSizeSplit = EgtGetInfo( nSplitProfileId, WIN_SASH_REF, 'd')
|
||||
EgtOffsetCurve( nCrv5, - dSizeSplit)
|
||||
local ptRef3 = EgtIP( nCrv4, nCrv5, ORIG())
|
||||
|
||||
-- creo la curva di intersezione :
|
||||
-- a) taglio a 45°
|
||||
-- curva di intersezione da usare come riferimento per i conti successivi
|
||||
local nCrv = EgtCurveCompoFromPoints( nGrp, { ptRef1, ptRef2})
|
||||
-- b) tratto lungo il telaio
|
||||
if bSashFill then
|
||||
EgtInvertCurve( nCrv4)
|
||||
end
|
||||
local dParS = EgtCurveParamAtPoint( nCrv4, ptRef2)
|
||||
local dParE = EgtCurveParamAtPoint( nCrv4, ptRef3)
|
||||
EgtTrimCurveStartEndAtParam( nCrv4, dParS, dParE)
|
||||
|
||||
-- c) fillet
|
||||
local dFillet = 0 -- EgtGetInfo( nSplitProfileId, WIN_MIXED_FILLET, 'd')
|
||||
local nFillet = EgtCurveFillet( nGrp, nCrv, EgtMP( nCrv), nCrv4, EgtMP( nCrv4), dFillet, true) or GDB_ID.NULL
|
||||
EgtAddCurveCompoCurve( nCrv, nFillet)
|
||||
EgtAddCurveCompoCurve( nCrv, nCrv4)
|
||||
|
||||
-- d) tratto lungo split
|
||||
if not EgtCurveParamAtPoint( nOutline, EgtSP( nSplitId)) then
|
||||
EgtInvertCurve( nCrv5)
|
||||
end
|
||||
local dPar = EgtCurveParamAtPoint( nCrv5, ptRef3)
|
||||
EgtTrimCurveStartAtParam( nCrv5, dPar)
|
||||
EgtTrimCurveEndAtLen( nCrv5, 100)
|
||||
EgtAddCurveCompoCurve( nCrv, nCrv5)
|
||||
|
||||
|
||||
-- cancello curve di costruzione
|
||||
EgtErase( { nCrv1, nCrv2, nCrv3, nCrv4, nCrv5})
|
||||
|
||||
EgtErase( { nCrv1, nCrv2, nCrv3, nCrv4})
|
||||
|
||||
-- assegno riferimento
|
||||
EgtSetInfo( vOutlines[i], WIN_MIXED_INTERS_REF, nCrv)
|
||||
|
||||
end
|
||||
end
|
||||
|
||||
@@ -1505,11 +1475,52 @@ local function GetProcessingInfoFromSemiProfile( nCrv, nSemiProfile)
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- funzione che calcola la lavorazione per l'innesto dello split sul telaio nel caso di cambio profilo
|
||||
local function CalcMixedFrameMillingProcessings( nIntersCrv, nOutlineId, dOffs, dDepth, nSplitRef, bSashFill, nProcLayerId, nSurfGeoId)
|
||||
|
||||
local nMilling = EgtCopyGlob( nIntersCrv, nProcLayerId)
|
||||
EgtExtendCurveStartByLen( nMilling, 100)
|
||||
|
||||
-- calcolo il tratto di outline
|
||||
local nOutlineCrv = EgtCopyGlob( nOutlineId, nProcLayerId)
|
||||
EgtOffsetCurve( nOutlineCrv, - dOffs)
|
||||
if bSashFill then
|
||||
EgtInvertCurve( nOutlineCrv)
|
||||
end
|
||||
local pt1 = EgtIP( nMilling, nOutlineCrv, ORIG())
|
||||
local pt2 = EgtIP( nOutlineCrv, nSplitRef, ORIG())
|
||||
local dParS = EgtCurveParamAtPoint( nOutlineCrv, pt1)
|
||||
local dParE = EgtCurveParamAtPoint( nOutlineCrv, pt2)
|
||||
EgtTrimCurveStartEndAtParam( nOutlineCrv, dParS, dParE)
|
||||
|
||||
-- aggiungo il tratto derivante dall'outline
|
||||
if not AreSamePointApprox( pt1, EgtEP( nMilling)) then
|
||||
local dParTrim = EgtCurveParamAtPoint( nMilling, pt1)
|
||||
EgtTrimCurveEndAtParam( nMilling, dParTrim)
|
||||
end
|
||||
EgtAddCurveCompoCurve( nMilling, nOutlineCrv)
|
||||
|
||||
-- aggiungo tratto di uscita a 45°
|
||||
local vtDir2 = EgtEV( nMilling)
|
||||
vtDir2:rotate( Z_AX(), EgtIf( bSashFill, - 45, 45))
|
||||
EgtAddCurveCompoLine( nMilling, EgtEP( nMilling) + vtDir2 * 100)
|
||||
|
||||
if bSashFill then
|
||||
EgtInvertCurve( nMilling)
|
||||
end
|
||||
EgtModifyCurveThickness( nMilling, - dDepth)
|
||||
EgtSetInfo( nMilling, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING)
|
||||
EgtTrimCurveWithRegion( nMilling, nSurfGeoId, true, false)
|
||||
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- funzione che calcola le lavorazioni di profiling per un pezzo di telaio con cambio profilo
|
||||
local function CalcMixedFrameProfilingProcessings( nPartId, nProcLayerId, nGeoLayerId, nMainProfileId, nSurfGeoId)
|
||||
|
||||
-- per le lavorazioni dei profili out, left, right e in comune uso le corrispondenti curve del geo
|
||||
-- a) lavorazioni profili
|
||||
-- per le lavorazioni dei profili out, left, right e in comune si usano le corrispondenti curve del geo
|
||||
local vGeoCrvs = EgtGetAllInGroup( nGeoLayerId)
|
||||
for i = 1, #vGeoCrvs do
|
||||
-- copio curva
|
||||
@@ -1519,7 +1530,7 @@ local function CalcMixedFrameProfilingProcessings( nPartId, nProcLayerId, nGeoLa
|
||||
GetProcessingInfoFromSemiProfile( nCrv, nSemiProfile)
|
||||
end
|
||||
|
||||
-- lavorazione dei sottotratti in di sash e fill
|
||||
-- lavorazioni dei sottotratti in di sash e fill
|
||||
local nOutlinesGrp = EgtGetFirstNameInGroup( nPartId, WIN_MIXED_OUTLINES)
|
||||
local vCrvs = EgtGetAllInGroup( nOutlinesGrp)
|
||||
local b3Profile = GetProfileLocalBox( nMainProfileId)
|
||||
@@ -1527,7 +1538,6 @@ local function CalcMixedFrameProfilingProcessings( nPartId, nProcLayerId, nGeoLa
|
||||
for i = #vCrvs, 1, -1 do
|
||||
-- calcolo la curva di lavorazione
|
||||
local nCrv = EgtCopyGlob( vCrvs[i], nProcLayerId)
|
||||
EgtSetName( nCrv, WIN_GEO_IN)
|
||||
EgtOffsetCurve( nCrv, dOffs)
|
||||
EgtInvertCurve( nCrv)
|
||||
nCrv = EgtTrimCurveWithRegion( nCrv, nSurfGeoId, true, true)
|
||||
@@ -1536,87 +1546,72 @@ local function CalcMixedFrameProfilingProcessings( nPartId, nProcLayerId, nGeoLa
|
||||
GetProcessingInfoFromSemiProfile( nCrv, nSemiProfile)
|
||||
end
|
||||
|
||||
-- lavorazioni sulle intersezioni con gli split
|
||||
-- b) lavorazioni sulle intersezioni con gli split
|
||||
local nIntersGrp = EgtGetFirstNameInGroup( nPartId, WIN_MIXED_INTERSECTIONS)
|
||||
local vInters = EgtGetAllInGroup( nIntersGrp)
|
||||
local dDepth = EgtGetInfo( nMainProfileId, WIN_MIXED_DEPTH, 'd')
|
||||
local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i')
|
||||
for i = 1, #vInters do
|
||||
local nCrv = EgtCopyGlob( vInters[i], nProcLayerId)
|
||||
EgtSetName( nCrv, WIN_GEO_IN)
|
||||
nCrv = EgtTrimCurveWithRegion( nCrv, nSurfGeoId, true, true)
|
||||
EgtSetInfo( nCrv, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING)
|
||||
|
||||
local bSashFill = ( EgtGetName( vCrvs[i]) == WIN_SASH)
|
||||
-- recupero lo split associato e creo la curva di riferimento per le fresature
|
||||
local nSplitId = EgtGetInfo( vCrvs[i], WIN_MIXED_SPLIT_REF, 'i')
|
||||
local nSplitProfileId = GetOutlineProfileId( nSplitId, false)
|
||||
local dRefSplit = EgtGetInfo( nSplitProfileId, WIN_SASH_REF .. '2', 'd')
|
||||
local nSplitRef = EgtCopyGlob( nSplitId, nProcLayerId)
|
||||
EgtOffsetCurve( nSplitRef, - dRefSplit)
|
||||
|
||||
-- Fresatura 1
|
||||
local dOffs1 = EgtGetInfo( nMainProfileId, WIN_SASH_REF .. '1', 'd')
|
||||
local dDepth1 = EgtGetInfo( nMainProfileId, WIN_SASH_DEPTH .. '1', 'd')
|
||||
CalcMixedFrameMillingProcessings( vInters[i], nOutlineId, dOffs1, dDepth1, nSplitRef, bSashFill, nProcLayerId, nSurfGeoId)
|
||||
-- Fresatura 2
|
||||
local dOffs2 = EgtGetInfo( nMainProfileId, WIN_SASH_REF .. '2', 'd')
|
||||
local dDepth2 = EgtGetInfo( nMainProfileId, WIN_SASH_DEPTH .. '2', 'd')
|
||||
CalcMixedFrameMillingProcessings( vInters[i], nOutlineId, dOffs2, dDepth2, nSplitRef, bSashFill, nProcLayerId, nSurfGeoId)
|
||||
|
||||
EgtErase( nSplitRef)
|
||||
end
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
local function CalcMixedSplitLeftRightProcessing( nOutlineId, nProfileId, sSemiProfileName, nSurfGeoId, nProcLayerId, sName)
|
||||
|
||||
local nCrv = EgtCopyGlob( nOutlineId, nProcLayerId)
|
||||
EgtSetName( nCrv, sName)
|
||||
-- posiziono correttamente
|
||||
local dDelta = GetDeltaProfile( nProfileId, sSemiProfileName)
|
||||
EgtOffsetCurve( nCrv, - dDelta)
|
||||
-- taglio con geo
|
||||
nCrv = EgtTrimCurveWithRegion( nCrv, nSurfGeoId, true, true)
|
||||
-- setto info di lavorazione
|
||||
local nSemiProfile = EgtGetFirstNameInGroup( nProfileId, sSemiProfileName)
|
||||
GetProcessingInfoFromSemiProfile( nCrv, nSemiProfile)
|
||||
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- funzione che calcola le lavorazioni di profiling nel caso di uno split coinvolto da cambio profilo
|
||||
local function CalcMixedSplitProfilingProcessings( nSplitId, nProcLayerId, nGeoLayerId, nProfileLayerId, nSurfGeoId)
|
||||
local function CalcMixedSplitProfilingProcessings( nSplitId, nProcLayerId, nGeoLayerId)
|
||||
|
||||
-- 1) lavorazione profilo out
|
||||
local nGeoOutId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_OUT)
|
||||
local nCrvOutId = EgtCopyGlob( nGeoOutId, nProcLayerId)
|
||||
local nSemiProfileOutId = EgtGetInfo( nCrvOutId, WIN_SEMI_PROFILE, 'i')
|
||||
GetProcessingInfoFromSemiProfile( nCrvOutId, nSemiProfileOutId)
|
||||
|
||||
-- 2) lavorazione profilo in
|
||||
local nGeoInId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN)
|
||||
local nCrvInId = EgtCopyGlob( nGeoInId, nProcLayerId)
|
||||
local nSemiProfileInId = EgtGetInfo( nCrvInId, WIN_SEMI_PROFILE, 'i')
|
||||
GetProcessingInfoFromSemiProfile( nCrvInId, nSemiProfileInId)
|
||||
-- a) lavorazione dei profili
|
||||
local vGeoCrvs = EgtGetAllInGroup( nGeoLayerId)
|
||||
for i = 1, #vGeoCrvs do
|
||||
-- copio la curva
|
||||
local nCrvId = EgtCopyGlob( vGeoCrvs[i], nProcLayerId)
|
||||
-- recupero il semiprofilo associato ( per left e right è stato salvato il profilo di tipo sash)
|
||||
local nSemiProfileId = EgtGetInfo( nCrvId, WIN_SEMI_PROFILE, 'i')
|
||||
-- setto le info dal semiprofilo
|
||||
GetProcessingInfoFromSemiProfile( nCrvId, nSemiProfileId)
|
||||
end
|
||||
|
||||
-- b) tagli a 45°
|
||||
-- left
|
||||
local nMixedLeft = EgtGetInfo( nSplitId, WIN_MIXED_REF_START, 'i')
|
||||
local nIntersLeft = EgtGetInfo( nMixedLeft, WIN_MIXED_INTERS_REF, 'i')
|
||||
local nMillingLeft = EgtCopyGlob( nIntersLeft, nProcLayerId)
|
||||
EgtSetName( nMillingLeft, WIN_LEFT)
|
||||
EgtSetInfo( nMillingLeft, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING)
|
||||
-- recupero profondità
|
||||
local vOutlineLeft = EgtGetInfo( nSplitId, WIN_PREV_OUTLINES, 'vi')
|
||||
local nProfileLeft = GetOutlineProfileId( vOutlineLeft[1], false)
|
||||
local dDepthLeft = EgtGetInfo( nProfileLeft, WIN_SASH_DEPTH .. '2', 'd')
|
||||
EgtModifyCurveThickness( nMillingLeft, - dDepthLeft)
|
||||
|
||||
-- 3) lavorazioni profili left
|
||||
local nStartProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_START)
|
||||
-- a) parte comune dell'outline del telaio
|
||||
local nOutlineLId = EgtGetInfo( nSplitId, WIN_PREV_OUTLINES, 'i')
|
||||
CalcMixedSplitLeftRightProcessing( nOutlineLId, nStartProfileId, WIN_MIXED_COMMON .. WIN_CTRIN, nSurfGeoId, nProcLayerId, WIN_LEFT)
|
||||
-- b) sottotratti sash e fill
|
||||
local nOutlineL1Id = EgtGetInfo( nSplitId, WIN_MIXED_REF_START, 'i')
|
||||
CalcMixedSplitLeftRightProcessing( nOutlineL1Id, nStartProfileId, EgtGetName( nOutlineL1Id) .. WIN_CTRIN, nSurfGeoId, nProcLayerId, WIN_LEFT)
|
||||
local nOutlineL2Id = EgtGetNext( nOutlineL1Id)
|
||||
CalcMixedSplitLeftRightProcessing( nOutlineL2Id, nStartProfileId, EgtGetName( nOutlineL2Id) .. WIN_CTRIN, nSurfGeoId, nProcLayerId, WIN_LEFT)
|
||||
-- c) curva di intersezione
|
||||
local nOutlineL3Id = EgtGetInfo( nOutlineL1Id, WIN_MIXED_INTERS_REF, 'i')
|
||||
local nLeftId = EgtCopyGlob( nOutlineL3Id, nProcLayerId)
|
||||
EgtSetName( nLeftId, WIN_LEFT)
|
||||
local _, dParEL = EgtCurveDomain( nOutlineL3Id)
|
||||
EgtTrimCurveEndAtParam( nLeftId, dParEL - 1)
|
||||
-- setto info di lavorazione
|
||||
EgtSetInfo( nLeftId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING)
|
||||
|
||||
-- 4) lavorazioni profili right
|
||||
local nEndProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_END)
|
||||
-- a) parte comune dell'outline del telaio
|
||||
local nOutlineRId = EgtGetInfo( nSplitId, WIN_NEXT_OUTLINES, 'i')
|
||||
CalcMixedSplitLeftRightProcessing( nOutlineRId, nEndProfileId, WIN_MIXED_COMMON .. WIN_CTRIN, nSurfGeoId, nProcLayerId, WIN_RIGHT)
|
||||
-- b) sottotratti sash e fill
|
||||
local nOutlineR1Id = EgtGetInfo( nSplitId, WIN_MIXED_REF_END, 'i')
|
||||
CalcMixedSplitLeftRightProcessing( nOutlineR1Id, nEndProfileId, EgtGetName( nOutlineR1Id) .. WIN_CTRIN, nSurfGeoId, nProcLayerId, WIN_RIGHT)
|
||||
local nOutlineR2Id = EgtGetNext( nOutlineR1Id)
|
||||
CalcMixedSplitLeftRightProcessing( nOutlineR2Id, nEndProfileId, EgtGetName( nOutlineR2Id) .. WIN_CTRIN, nSurfGeoId, nProcLayerId, WIN_RIGHT)
|
||||
-- b) curva di intersezione
|
||||
local nOutlineR3Id = EgtGetInfo( nOutlineR1Id, WIN_MIXED_INTERS_REF, 'i')
|
||||
local nRightId = EgtCopyGlob( nOutlineR3Id, nProcLayerId)
|
||||
EgtSetName( nRightId, WIN_RIGHT)
|
||||
local _, dParER = EgtCurveDomain( nOutlineR3Id)
|
||||
EgtTrimCurveEndAtParam( nRightId, dParER - 1)
|
||||
-- setto info di lavorazione
|
||||
EgtSetInfo( nRightId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING)
|
||||
-- right
|
||||
local nMixedRight = EgtGetInfo( nSplitId, WIN_MIXED_REF_END, 'i')
|
||||
local nIntersRight = EgtGetInfo( nMixedRight, WIN_MIXED_INTERS_REF, 'i')
|
||||
local nMillingRight = EgtCopyGlob( nIntersRight, nProcLayerId)
|
||||
EgtSetName( nMillingRight, WIN_RIGHT)
|
||||
EgtSetInfo( nMillingRight, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING)
|
||||
local vOutlineRight = EgtGetInfo( nSplitId, WIN_NEXT_OUTLINES, 'vi')
|
||||
local nProfileRight = GetOutlineProfileId( vOutlineRight[1], false)
|
||||
local dDepthRight = EgtGetInfo( nProfileRight, WIN_SASH_DEPTH .. '2', 'd')
|
||||
EgtModifyCurveThickness( nMillingRight, - dDepthRight)
|
||||
EgtInvertCurve( nMillingRight)
|
||||
|
||||
end
|
||||
|
||||
@@ -1643,7 +1638,7 @@ local function CalcProfilingProcessings( nPartId, nOutlineId)
|
||||
if bChangeProfile then
|
||||
-- 1) caso cambio profilo : telaio o split
|
||||
if EgtGetName( nOutlineId) == WIN_SPLIT then
|
||||
CalcMixedSplitProfilingProcessings( nOutlineId, nProcLayerId, nGeoLayerId, nProfileLayerId, nSurfGeo)
|
||||
CalcMixedSplitProfilingProcessings( nOutlineId, nProcLayerId, nGeoLayerId)
|
||||
else
|
||||
CalcMixedFrameProfilingProcessings( nPartId, nProcLayerId, nGeoLayerId, nMainProfileId, nSurfGeo)
|
||||
end
|
||||
@@ -1774,87 +1769,33 @@ local function CreateTrimSurf( nGeoId, nProfileId, dGeoWidth, nLayerId)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- funzione che crea la superficie di trim per uno split coinvolto da cambio profilo
|
||||
local function CreateMixedSplitTrimSurf( nOutlineId1, nProfileId, dExtraLen, nLayerId)
|
||||
-- funzione che crea le superfici di trim per uno split coinvolto da cambio profilo ( controprofilo della parte sash del telaio e taglio a 45°)
|
||||
local function CreateMixedSplitTrimSurf( nMixedOutlineId, nProfileId, dExtraLen, nLayerId)
|
||||
|
||||
-- recupero il frame del profilo
|
||||
local nFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
|
||||
local frProfile = EgtFR( nFrameId, GDB_ID.ROOT)
|
||||
local vtDirX = frProfile:getVersX()
|
||||
frProfile:invert()
|
||||
|
||||
-- punto di riferimento per le estensioni degli outlines del telaio
|
||||
local nIntersCrvId = EgtGetInfo( nOutlineId1, WIN_MIXED_INTERS_REF, 'i')
|
||||
local nPartId = EgtGetParent( EgtGetParent( nOutlineId1))
|
||||
-- estrudo il controprofilo di tipo sash
|
||||
local nPartId = EgtGetParent( EgtGetParent( nMixedOutlineId))
|
||||
local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i')
|
||||
local _, dParE = EgtCurveDomain( nIntersCrvId)
|
||||
local _, ptOutline = EgtPointCurveDist( EgtUP( nIntersCrvId, dParE - 2), nOutlineId)
|
||||
|
||||
-- primo tratto
|
||||
local nGuideId1 = EgtCopy( nOutlineId1, nLayerId)
|
||||
EgtExtendCurveStartByLen( nGuideId1, 2 * dExtraLen)
|
||||
EgtModifyCurveEndPoint( nGuideId1, ptOutline)
|
||||
-- recupero il controprofilo corrispondente
|
||||
local sProfileName1 = WIN_OFST .. EgtGetName( nGuideId1) .. WIN_CTRIN
|
||||
local nOrigProfileId1 = EgtGetFirstNameInGroup( nProfileId, sProfileName1)
|
||||
-- aggiungo un tratto di chiusura superiore per le operazioni booleane
|
||||
local nProfileId1 = EgtCopyGlob( nOrigProfileId1, nLayerId)
|
||||
EgtAddCurveCompoLine( nProfileId1, EgtEP( nProfileId1) + dExtraLen * vtDirX)
|
||||
-- posiziono il controprofilo grazie ai riferimenti
|
||||
EgtTransform( nProfileId1, frProfile, GDB_RT.GLOB)
|
||||
EgtTransform( nProfileId1, Frame3d( EgtSP( nGuideId1), - EgtSV( nGuideId1)))
|
||||
-- creo la superficie di estrusione
|
||||
local nStmId1 = EgtSurfTmSwept( nLayerId, nProfileId1, nGuideId1, false, WIN_SURF_APPROX)
|
||||
|
||||
-- secondo tratto
|
||||
local nOutlineId2 = EgtGetNext( nOutlineId1)
|
||||
local nGuideId2 = EgtCopy( nOutlineId2, nLayerId)
|
||||
EgtExtendCurveEndByLen( nGuideId2, 2 * dExtraLen)
|
||||
EgtModifyCurveStartPoint( nGuideId2, ptOutline)
|
||||
-- recupero il controprofilo corrispondente
|
||||
local sProfileName2 = WIN_OFST .. EgtGetName( nGuideId2) .. WIN_CTRIN
|
||||
local nOrigProfileId2 = EgtGetFirstNameInGroup( nProfileId, sProfileName2)
|
||||
-- aggiungo un tratto di chiusura superiore per le operazioni booleane
|
||||
local nProfileId2 = EgtCopyGlob( nOrigProfileId2, nLayerId)
|
||||
EgtAddCurveCompoLine( nProfileId2, EgtEP( nProfileId2) + dExtraLen * vtDirX)
|
||||
-- posiziono grazie ai riferimenti
|
||||
EgtTransform( nProfileId2, frProfile, GDB_RT.GLOB)
|
||||
EgtTransform( nProfileId2, Frame3d( EgtSP( nGuideId2), - EgtSV( nGuideId2)))
|
||||
-- creo la superficie di estrusione
|
||||
local nStmId2 = EgtSurfTmSwept( nLayerId, nProfileId2, nGuideId2, false, WIN_SURF_APPROX)
|
||||
|
||||
-- creo un solido chiuso per la regione di intersezione
|
||||
local nGuideId3 = EgtCopy( nIntersCrvId, nLayerId)
|
||||
EgtExtendCurveEndByLen( nGuideId3, 2 * dExtraLen)
|
||||
EgtExtendCurveStartByLen( nGuideId3, 2 * dExtraLen)
|
||||
EgtCloseCurveCompo( nGuideId3)
|
||||
EgtMove( nGuideId3, Z_AX())
|
||||
local dDepth = EgtGetInfo( nProfileId, WIN_MIXED_DEPTH, 'd')
|
||||
local nStmCutId = EgtSurfTmByRegionExtrusion( nLayerId, nGuideId3, - ( dDepth + 1) * Z_AX())
|
||||
local nTrimStmId = CreateProfileSurf( nOutlineId, nProfileId, WIN_OFST .. WIN_SASH .. WIN_CTRIN, dExtraLen, nLayerId)
|
||||
|
||||
-- creo superficie complessiva
|
||||
local nTrimStmId = EgtSurfTmByTriangles( nLayerId, { nStmId1, nStmId2})
|
||||
-- operazione booleana di add e non di subtract perchè nTrimStmId è invertita rispetto al solido del telaio, essendo stata costruita a partire dai controprofili
|
||||
EgtSurfTmAdd( nTrimStmId, nStmCutId)
|
||||
|
||||
-- chiudo eventuali buchi
|
||||
local nLoop, nCnt = EgtExtractSurfTmLoops( nTrimStmId, nLayerId)
|
||||
if nCnt == 2 then
|
||||
local nStmHoleId = EgtSurfTmByFlatContour( nLayerId, nLoop + 1)
|
||||
EgtInvertSurf( nStmHoleId)
|
||||
nTrimStmId = EgtSurfTmByTriangles( nLayerId, { nTrimStmId, nStmHoleId})
|
||||
EgtErase( nLoop + 1)
|
||||
-- creo la superficie per il taglio a 45°
|
||||
local nIntersCrvId = EgtGetInfo( nMixedOutlineId, WIN_MIXED_INTERS_REF, 'i')
|
||||
local nGuideId = EgtCopyGlob( nIntersCrvId, nLayerId)
|
||||
EgtExtendCurveStartByLen( nGuideId, 10)
|
||||
EgtExtendCurveEndByLen( nGuideId, 10)
|
||||
EgtMove( nGuideId, Z_AX())
|
||||
if EgtGetName( nMixedOutlineId) ~= WIN_SASH then
|
||||
EgtInvertCurve( nGuideId)
|
||||
end
|
||||
|
||||
-- cancello curve di costruzione
|
||||
EgtErase( { nProfileId1, nProfileId2, nGuideId1, nGuideId2, nGuideId3, nStmCutId, nLoop})
|
||||
|
||||
return nTrimStmId
|
||||
local dDepth = EgtGetInfo( nProfileId, WIN_SASH_DEPTH .. '2', 'd')
|
||||
local nCutStmId = EgtSurfTmByRegionExtrusion( nLayerId, nGuideId, - ( dDepth + 2) * Z_AX())
|
||||
EgtErase( nGuideId)
|
||||
|
||||
return nTrimStmId, nCutStmId
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- funzione che crea il solido di estrusione principale
|
||||
local function CreateMainSurf( nOutlineId, dExtraLen, nProfileId, nLayerId)
|
||||
local function CreateMainSurf( nOutlineId, dExtraLen, nProfileId, sSectionName, nLayerId)
|
||||
|
||||
-- curva guida
|
||||
local nGuideId = EgtCopy( nOutlineId, nLayerId)
|
||||
@@ -1874,10 +1815,10 @@ local function CreateMainSurf( nOutlineId, dExtraLen, nProfileId, nLayerId)
|
||||
EgtChangeGroupFrame( nProfileId, Frame3d( EgtSP( nGuideId), - EgtSV( nGuideId)))
|
||||
|
||||
-- recupero outline del profilo Main e lo estrudo
|
||||
local nSectionId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTION)
|
||||
local nSectionId = EgtGetFirstNameInGroup( nProfileId, sSectionName)
|
||||
local nMainExtrusionId = EgtSurfTmSwept( nLayerId, nSectionId, nGuideId, false, WIN_SURF_APPROX)
|
||||
EgtSetName( nMainExtrusionId, WIN_SRF_MAIN)
|
||||
|
||||
|
||||
return nMainExtrusionId
|
||||
end
|
||||
|
||||
@@ -1887,93 +1828,57 @@ local function CalcMixedFrameSolid( nOutlineId, nSolidLayerId, nProfileLayerId,
|
||||
|
||||
-- a) SOLIDO PRINCIPALE
|
||||
local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
|
||||
-- recupero i vari sottotratti uniformi del pezzo
|
||||
-- creo i solidi corrispondenti ai diversi sottotratti uniformi del pezzo
|
||||
local nMixedOutlinesGrp = EgtGetFirstNameInGroup( EgtGetParent( nSolidLayerId), WIN_MIXED_OUTLINES)
|
||||
local vMixedOutlines = EgtGetAllInGroup( nMixedOutlinesGrp)
|
||||
-- recupero le curve di intersezione con gli split
|
||||
local nMixedIntersectionsGrp = EgtGetFirstNameInGroup( EgtGetParent( nSolidLayerId), WIN_MIXED_INTERSECTIONS)
|
||||
local vIntersections = EgtGetAllInGroup( nMixedIntersectionsGrp)
|
||||
|
||||
-- creo i solidi corrispondenti ai diversi sottotratti
|
||||
local vMainExtrusions = {}
|
||||
for i = 1, #vMixedOutlines do
|
||||
|
||||
-- creo curva guida con estensione opportuna agli estremi per facilitare il calcolo del solido : se all'estremo del pezzo estensione
|
||||
-- arbitraria, altrimenti estendo fino ad incontrare il pezzo precedente/successivo nella regione dove si innesta lo split
|
||||
local nGuideId = EgtCopyGlob( vMixedOutlines[i], nSolidLayerId)
|
||||
if i == 1 then
|
||||
EgtExtendCurveStartByLen( nGuideId, 2 * dGeoWidth)
|
||||
else
|
||||
local _, dParE = EgtCurveDomain( vIntersections[i-1])
|
||||
local _, ptOutline = EgtPointCurveDist( EgtUP( vIntersections[i-1], dParE - 2), nOutlineId)
|
||||
EgtModifyCurveStartPoint( nGuideId, ptOutline)
|
||||
end
|
||||
if i == #vMixedOutlines then
|
||||
EgtExtendCurveEndByLen( nGuideId, 2 * dGeoWidth)
|
||||
else
|
||||
local _, dParE = EgtCurveDomain( vIntersections[i])
|
||||
local _, ptOutline = EgtPointCurveDist( EgtUP( vIntersections[i], dParE - 2), nOutlineId)
|
||||
EgtModifyCurveEndPoint( nGuideId, ptOutline)
|
||||
end
|
||||
|
||||
-- posiziono il profilo sulla guida
|
||||
local nMainProfileFrameId = EgtGetFirstNameInGroup( nMainProfileId, WIN_SECTIONFRAME)
|
||||
local frInvertMainProfile = EgtFR( nMainProfileFrameId)
|
||||
frInvertMainProfile:invert()
|
||||
EgtTransform( EgtGetAllInGroup( nMainProfileId), frInvertMainProfile)
|
||||
EgtChangeGroupFrame( nMainProfileId, Frame3d( EgtSP( nGuideId), - EgtSV( nGuideId)))
|
||||
|
||||
-- recupero la sezione e la estrudo
|
||||
local nSectionId = EgtGetFirstNameInGroup( nMainProfileId, EgtGetName( vMixedOutlines[i]) .. WIN_SECTION)
|
||||
local nMainExtrusionId = EgtSurfTmSwept( nSolidLayerId, nSectionId, nGuideId, false, WIN_SURF_APPROX)
|
||||
local nMainExtrusionId = CreateMainSurf( vMixedOutlines[i], 2 * dGeoWidth, nMainProfileId, EgtGetName( vMixedOutlines[i]) .. WIN_SECTION, nSolidLayerId)
|
||||
table.insert( vMainExtrusions, nMainExtrusionId)
|
||||
EgtErase( nGuideId)
|
||||
end
|
||||
|
||||
-- taglio i sottopezzi nei punti di intersezione per unirli
|
||||
local nMixedIntersectionsGrp = EgtGetFirstNameInGroup( EgtGetParent( nSolidLayerId), WIN_MIXED_INTERSECTIONS)
|
||||
local vIntersections = EgtGetAllInGroup( nMixedIntersectionsGrp)
|
||||
for i = 1, #vIntersections do
|
||||
-- creo la superficie di separazione tra i due sottopezzi
|
||||
local bSashFill = ( EgtGetName( vMixedOutlines[i]) == WIN_SASH)
|
||||
local vtDirS = EgtSV( vIntersections[i])
|
||||
vtDirS:rotate( Z_AX(), EgtIf( bSashFill, -135, 135))
|
||||
local vtDirE = EgtSV( vIntersections[i])
|
||||
vtDirE:rotate( Z_AX(), EgtIf( bSashFill, 45, -45))
|
||||
local nCrvTrim = EgtCurveCompo( nSolidLayerId, vIntersections[i], false)
|
||||
EgtAddCurveCompoLine( nCrvTrim, EgtSP( nCrvTrim) + dGeoWidth * vtDirS, false)
|
||||
EgtAddCurveCompoLine( nCrvTrim, EgtEP( nCrvTrim) + dGeoWidth * vtDirE)
|
||||
EgtMove( nCrvTrim, Z_AX())
|
||||
local nStmTrim = EgtSurfTmByExtrusion( nSolidLayerId, nCrvTrim, - 2 * dGeoWidth * Z_AX())
|
||||
|
||||
-- taglio i due sottopezzi
|
||||
EgtSurfTmSubtract( vMainExtrusions[i+1], nStmTrim)
|
||||
EgtInvertSurf( nStmTrim)
|
||||
EgtSurfTmSubtract( vMainExtrusions[i], nStmTrim)
|
||||
|
||||
EgtErase( nCrvTrim)
|
||||
EgtErase( nStmTrim)
|
||||
end
|
||||
|
||||
-- unisco i sottopezzi in una sola superficie
|
||||
for i = 2, #vMainExtrusions do
|
||||
EgtSurfTmAdd( vMainExtrusions[1], vMainExtrusions[i])
|
||||
EgtErase( vMainExtrusions[i])
|
||||
end
|
||||
|
||||
-- creo una copia dell'estrusione principale ( usata per ferramenta)
|
||||
local nOrigMainExtrusionId = EgtCopy( vMainExtrusions[1], nSolidLayerId)
|
||||
EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN)
|
||||
EgtSetStatus( nOrigMainExtrusionId, GDB_ST.OFF)
|
||||
|
||||
-- come guida tengo solo una copia della curva di outline
|
||||
local vMainGuideIds = EgtGetNameInGroup( nSolidLayerId, WIN_MAINGUIDE)
|
||||
EgtErase( vMainGuideIds)
|
||||
local nMainGuideId = EgtCopyGlob( nOutlineId, nSolidLayerId)
|
||||
EgtSetName( nMainGuideId, WIN_MAINGUIDE)
|
||||
EgtSetStatus( nMainGuideId, GDB_ST.OFF)
|
||||
|
||||
-- unifico i diversi tratti di superficie calcolati
|
||||
local nMainExtrusionId = EgtSurfTmByTriangles( nSolidLayerId, vMainExtrusions)
|
||||
EgtSetName( nMainExtrusionId, WIN_SRF_MAIN)
|
||||
|
||||
-- taglio il solido con gli innesti degli split
|
||||
for i = 1, #vIntersections do
|
||||
-- creo una curva chiusa a partire dalla curva di intersezione
|
||||
local nCompo = EgtCopyGlob( vIntersections[i], nSolidLayerId)
|
||||
EgtExtendCurveEndByLen( nCompo, 2 * dGeoWidth)
|
||||
EgtExtendCurveStartByLen( nCompo, 2 * dGeoWidth)
|
||||
EgtCloseCurveCompo( nCompo)
|
||||
-- creo il solido
|
||||
EgtMove( nCompo, Z_AX())
|
||||
local dDepth = EgtGetInfo( nMainProfileId, WIN_MIXED_DEPTH, 'i')
|
||||
local nSrfCut = EgtSurfTmByRegionExtrusion( nSolidLayerId, nCompo, - ( dDepth + 1) * Z_AX())
|
||||
-- sottraggo
|
||||
EgtSurfTmSubtract( nMainExtrusionId, nSrfCut)
|
||||
EgtErase( nCompo)
|
||||
EgtErase( nSrfCut)
|
||||
end
|
||||
|
||||
-- chiudo i buchi ( caps ed eventuali parti on del solido di intersezione sul pezzo)
|
||||
local nLoop, nCnt = EgtExtractSurfTmLoops( nMainExtrusionId, nSolidLayerId)
|
||||
if nLoop then
|
||||
local vSurfs = { nMainExtrusionId}
|
||||
for nId = nLoop, nLoop + nCnt - 1 do
|
||||
local nHoleStmId = EgtSurfTmByFlatContour( nSolidLayerId, nId)
|
||||
EgtInvertSurf( nHoleStmId)
|
||||
table.insert( vSurfs, nHoleStmId)
|
||||
EgtErase( nId)
|
||||
end
|
||||
nMainExtrusionId = EgtSurfTmByTriangles( nSolidLayerId, vSurfs)
|
||||
EgtSetName( nMainExtrusionId, WIN_SRF_MAIN)
|
||||
end
|
||||
|
||||
-- creo una copia dell'estrusione principale ( usata per ferramenta)
|
||||
local nOrigMainExtrusionId = EgtCopy( nMainExtrusionId, nSolidLayerId)
|
||||
EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN)
|
||||
EgtSetStatus( nOrigMainExtrusionId, GDB_ST.OFF)
|
||||
|
||||
-- b) TRIM START
|
||||
local nPrevGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_LEFT)
|
||||
@@ -1981,7 +1886,7 @@ local function CalcMixedFrameSolid( nOutlineId, nSolidLayerId, nProfileLayerId,
|
||||
local nTrimSurfStart = CreateTrimSurf( nPrevGeoId, nStartProfileId, dGeoWidth, nSolidLayerId)
|
||||
EgtSetName( nTrimSurfStart, WIN_SRF_START)
|
||||
EgtSetStatus( nTrimSurfStart, GDB_ST.OFF)
|
||||
EgtSurfTmIntersect( nMainExtrusionId, nTrimSurfStart)
|
||||
EgtSurfTmIntersect( vMainExtrusions[1], nTrimSurfStart)
|
||||
|
||||
-- c) TRIM END
|
||||
local nNextGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_RIGHT)
|
||||
@@ -1989,7 +1894,7 @@ local function CalcMixedFrameSolid( nOutlineId, nSolidLayerId, nProfileLayerId,
|
||||
local nTrimSurfEnd = CreateTrimSurf( nNextGeoId, nEndProfileId, dGeoWidth, nSolidLayerId)
|
||||
EgtSetName( nTrimSurfEnd, WIN_SRF_END)
|
||||
EgtSetStatus( nTrimSurfEnd, GDB_ST.OFF)
|
||||
EgtSurfTmIntersect( nMainExtrusionId, nTrimSurfEnd)
|
||||
EgtSurfTmIntersect( vMainExtrusions[1], nTrimSurfEnd)
|
||||
|
||||
end
|
||||
|
||||
@@ -1999,7 +1904,7 @@ local function CalcMixedSplitSolid( nOutlineId, nSolidLayerId, nProfileLayerId,
|
||||
|
||||
-- a) creo il solido di estrusione principale
|
||||
local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
|
||||
local nMainExtrusionId = CreateMainSurf( nOutlineId, 2 * dGeoWidth, nMainProfileId, nSolidLayerId)
|
||||
local nMainExtrusionId = CreateMainSurf( nOutlineId, 2 * dGeoWidth, nMainProfileId, WIN_SECTION, nSolidLayerId)
|
||||
-- creo una copia
|
||||
local nOrigMainExtrusionId = EgtCopy( nMainExtrusionId, nSolidLayerId)
|
||||
EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN)
|
||||
@@ -2007,19 +1912,23 @@ local function CalcMixedSplitSolid( nOutlineId, nSolidLayerId, nProfileLayerId,
|
||||
|
||||
-- b) trim start
|
||||
local nPrevProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_START)
|
||||
local nPrevOutlineRef = EgtGetInfo( nOutlineId, WIN_MIXED_REF_START, 'i')
|
||||
local nStmTrimStart = CreateMixedSplitTrimSurf( nPrevOutlineRef, nPrevProfileId, dGeoWidth, nSolidLayerId)
|
||||
local nPrevMixedOutline = EgtGetInfo( nOutlineId, WIN_MIXED_REF_START, 'i')
|
||||
local nStmTrimStart, nAuxStart = CreateMixedSplitTrimSurf( nPrevMixedOutline, nPrevProfileId, dGeoWidth, nSolidLayerId)
|
||||
EgtSetName( nStmTrimStart, WIN_SRF_START)
|
||||
EgtSetStatus( nStmTrimStart, GDB_ST.OFF)
|
||||
EgtSurfTmIntersect( nMainExtrusionId, nStmTrimStart)
|
||||
EgtSurfTmIntersect( nMainExtrusionId, nAuxStart)
|
||||
EgtErase( nAuxStart)
|
||||
|
||||
-- c) trim end
|
||||
local nNextProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_END)
|
||||
local nNextOutlineRef = EgtGetInfo( nOutlineId, WIN_MIXED_REF_END, 'i')
|
||||
local nStmTrimEnd = CreateMixedSplitTrimSurf( nNextOutlineRef, nNextProfileId, dGeoWidth, nSolidLayerId)
|
||||
local nNextMixedOutline = EgtGetInfo( nOutlineId, WIN_MIXED_REF_END, 'i')
|
||||
local nStmTrimEnd, nAuxEnd = CreateMixedSplitTrimSurf( nNextMixedOutline, nNextProfileId, dGeoWidth, nSolidLayerId)
|
||||
EgtSetName( nStmTrimEnd, WIN_SRF_END)
|
||||
EgtSetStatus( nStmTrimEnd, GDB_ST.OFF)
|
||||
EgtSurfTmIntersect( nMainExtrusionId, nStmTrimEnd)
|
||||
EgtSurfTmIntersect( nMainExtrusionId, nAuxEnd)
|
||||
EgtErase( nAuxEnd)
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
@@ -2049,7 +1958,7 @@ local function CalcSolid( nPartId, nOutlineId)
|
||||
|
||||
-- a) creo il solido di estrusione principale
|
||||
local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
|
||||
local nMainExtrusionId = CreateMainSurf( nOutlineId, 2 * dGeoWidth, nMainProfileId, nSolidLayerId)
|
||||
local nMainExtrusionId = CreateMainSurf( nOutlineId, 2 * dGeoWidth, nMainProfileId, WIN_SECTION, nSolidLayerId)
|
||||
-- creo una copia ( usata per calcolo ferramenta)
|
||||
local nOrigMainExtrusionId = EgtCopy( nMainExtrusionId, nSolidLayerId)
|
||||
EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN)
|
||||
@@ -2551,14 +2460,14 @@ local function CalcSplitDowels( nSplitId, vOutlines, bStartOrEnd)
|
||||
-- è la stessa superficie utilizzata per il trim del solido
|
||||
nTestSurf = EgtCopyGlob( vTestSurf[i], nSplitLayerId)
|
||||
else
|
||||
local sCtr
|
||||
local bChangeProfile = EgtGetInfo( nSplitId, WIN_PRF_CHANGE, 'b') or false
|
||||
if not bChangeProfile then
|
||||
local sCtr = WIN_OFST .. GetProfileCtrIn( nOutlineId, nSplitId, nProfileId)
|
||||
nTestSurf = CreateProfileSurf( nOutlineId, nProfileId, sCtr, 100, nSplitLayerId)
|
||||
if bChangeProfile then
|
||||
sCtr = WIN_OFST .. WIN_SASH .. WIN_CTRIN
|
||||
else
|
||||
local nMixedOutlineRef = EgtGetInfo( nSplitId, EgtIf( bStartOrEnd, WIN_MIXED_REF_START, WIN_MIXED_REF_END), 'i')
|
||||
nTestSurf = CreateMixedSplitTrimSurf( nMixedOutlineRef, nProfileId, 100, nSplitLayerId)
|
||||
sCtr = WIN_OFST .. GetProfileCtrIn( nOutlineId, nSplitId, nProfileId)
|
||||
end
|
||||
nTestSurf = CreateProfileSurf( nOutlineId, nProfileId, sCtr, 100, nLayerId)
|
||||
end
|
||||
local nTestSurfInverted = EgtCopyGlob( nTestSurf, nSplitLayerId)
|
||||
EgtInvertSurf( nTestSurfInverted)
|
||||
|
||||
Reference in New Issue
Block a user