- calcolo tronchetti
- aggiunto GeoRaw per automatismo lavorazioni - nel file dei profili aggiunto layer con info per tronchetti.
This commit is contained in:
SaraP
Binary file not shown.
Binary file not shown.
@@ -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'
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user