Egalware/EgtMachKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtMachKernel 1.6k10 :

Browse Source 
- sistemazioni varie in grezzi, lavorazioni, ....
This commit is contained in:
Dario Sassi
2015-12-07 08:03:39 +00:00
parent 5eb5cb387f
commit 42e1a696a1
33 changed files with 1354 additions and 277 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Sawing.cpp
+308 -95
View File
@@ -49,8 +49,6 @@ Sawing::Clone( void) const
// eseguo copia dei dati
if ( pSaw != nullptr) {
try {
pSaw->m_nOwnerId = GDB_ID_NULL ;
pSaw->m_pGeomDB = nullptr ;
pSaw->m_Params = m_Params ;
pSaw->m_TParams = m_TParams ;
}
@@ -125,8 +123,6 @@ Sawing::Load( const STRVECTOR& vString)
//----------------------------------------------------------------------------
Sawing::Sawing( void)
{
m_nOwnerId = GDB_ID_NULL ;
m_pGeomDB = nullptr ;
m_Params.m_sName = "*" ;
m_Params.m_sToolName = "*" ;
m_TParams.m_sName = "*" ;
@@ -170,9 +166,6 @@ Sawing::SetParam( int nType, bool bVal)
case MPA_INVERT :
m_Params.m_bInvert = bVal ;
return true ;
case MPA_TOANDFROM :
m_Params.m_bToAndFrom = bVal ;
return true ;
}
return false ;
}
@@ -192,6 +185,11 @@ Sawing::SetParam( int nType, int nVal)
return false ;
m_Params.m_nHeadSide = nVal ;
return true ;
case MPA_STEPTYPE :
if ( ! m_Params.VerifyStepType( nVal))
return false ;
m_Params.m_nStepType = nVal ;
return true ;
case MPA_LEADINTYPE :
if ( ! m_Params.VerifyLeadInType( nVal))
return false ;
@@ -247,6 +245,12 @@ Sawing::SetParam( int nType, double dVal)
case MPA_DEPTH :
m_Params.m_sDepth = ToString( dVal) ;
return true ;
case MPA_STARTPOS :
m_Params.m_dStartPos = dVal ;
return true ;
case MPA_STEP :
m_Params.m_dStep = dVal ;
return true ;
case MPA_SIDEANGLE :
if ( ! m_Params.VerifySideAngle( dVal))
return false ;
@@ -359,7 +363,14 @@ Sawing::Apply( void)
}
// calcolo gli assi macchina
return CalculateAxesValues() ;
if ( ! CalculateAxesValues())
return false ;
// gestione movimenti all'inizio di ogni singolo percorso di lavorazione
if ( ! AdjustStartMovements())
return false ;
return true ;
}
//----------------------------------------------------------------------------
@@ -370,9 +381,6 @@ Sawing::GetParam( int nType, bool& bVal) const
case MPA_INVERT :
bVal = m_Params.m_bInvert ;
return true ;
case MPA_TOANDFROM :
bVal = m_Params.m_bToAndFrom ;
return true ;
}
return false ;
}
@@ -382,12 +390,18 @@ bool
Sawing::GetParam( int nType, int& nVal) const
{
switch ( nType) {
case MPA_TYPE :
nVal = MT_SAWING ;
return true ;
case MPA_WORKSIDE :
nVal = m_Params.m_nWorkSide ;
return true ;
case MPA_HEADSIDE :
nVal = m_Params.m_nHeadSide ;
return true ;
case MPA_STEPTYPE :
nVal = m_Params.m_nStepType ;
return true ;
case MPA_LEADINTYPE :
nVal = m_Params.m_nLeadInType ;
return true ;
@@ -430,6 +444,12 @@ Sawing::GetParam( int nType, double& dVal) const
case MPA_TOOLOFFSL :
dVal = m_TParams.m_dOffsL ;
return true ;
case MPA_STARTPOS :
dVal = m_Params.m_dStartPos ;
return true ;
case MPA_STEP :
dVal = m_Params.m_dStep ;
return true ;
case MPA_SIDEANGLE :
dVal = m_Params.m_dSideAngle ;
return true ;
@@ -472,6 +492,16 @@ Sawing::GetToolData( void) const
return m_TParams ;
}
//----------------------------------------------------------------------------
bool
Sawing::AdjustPositionForAxesCalc( const CamData* pCamData, Point3d& ptP)
{
// compenso il raggio dell'utensile
ptP += pCamData->GetCorrDir() * ( m_TParams.m_dDiam / 2) ;
return true ;
}
//----------------------------------------------------------------------------
bool
Sawing::VerifyGeometry( SelData Id, int& nSubs)
@@ -776,21 +806,24 @@ Sawing::PathApply( int nPathId, int nClId)
ExeLuaSetGlobNumVar( "RB", dRbDist) ;
double dDepth ;
if ( ! ExeLuaEvalNumExpr( m_Params.m_sDepth, &dDepth)) {
string sOut = "Depth not computable by Sawing" ;
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
LOG_INFO( GetEMkLogger(), "Error in Sawing : Depth not computable") ;
return false ;
}
// determino l'eccesso di taglio
double dExtraCut = max( 0., dDepth - dRbDist) ;
// correzione per angolo di fianco
if ( fabs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) {
// generale
dDepth /= cos( m_Params.m_dSideAngle * DEGTORAD) ;
double dCoeff = 1 / cos( m_Params.m_dSideAngle * DEGTORAD) ;
dDepth *= dCoeff ;
dExtraCut *= dCoeff ;
// se sottosquadra (controllo il lato opposto della lama, quindi ...)
if ( m_Params.m_dSideAngle < 0)
dDepth += m_TParams.m_dThick * tan( abs( m_Params.m_dSideAngle) * DEGTORAD) ;
}
// verifico di non superare il massimo materiale
if ( dDepth > m_TParams.m_dMaxMat) {
string sOut = "Depth bigger than MaxMaterial" ;
string sOut = "Error in Sawing : Depth bigger than MaxMaterial" ;
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
return false ;
}
@@ -813,7 +846,7 @@ Sawing::PathApply( int nPathId, int nClId)
const ICurve* pCrvN = pCompo->GetCurve( k) ;
// elaborazioni sulla curva corrente
string sName = sPathName + "_" + ToString( i) ;
if ( ! EntityApply( pCrvP, pCrvC, pCrvN, dDepth, i == 0, i == nMaxInd, sName, nClId))
if ( ! EntityApply( pCrvP, pCrvC, pCrvN, dDepth, dExtraCut, i == 0, i == nMaxInd, sName, nClId))
return false ;
}
@@ -823,7 +856,8 @@ Sawing::PathApply( int nPathId, int nClId)
//----------------------------------------------------------------------------
bool
Sawing::EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCrvN,
double dDepth, bool bIsFirst, bool bIsLast, const string& sName, int nClId)
double dDepth, double dExtraCut, bool bIsFirst, bool bIsLast,
const string& sName, int nClId)
{
// se non è una linea, la salto
if ( pCrvC->GetType() != CRV_LINE)
@@ -839,14 +873,12 @@ Sawing::EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCr
// calcolo i versori fresa e correzione
Vector3d vtTool, vtCorr ;
if ( ! CalculateToolAndCorrVersors( Get( pLine), vtTool, vtCorr)) {
string sOut = "Entity not versorable by Sawing" ;
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
LOG_INFO( GetEMkLogger(), "Error in Sawing : Entity CalculateToolAndCorrVersors") ;
return false ;
}
// correzioni per lato lama, lato mandrino
if ( ! AdjustForSide( Get( pLine))) {
string sOut = "Entity not offsetable by Sawing" ;
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
LOG_INFO( GetEMkLogger(), "Error in Sawing : Entity AdjustForSide") ;
return false ;
}
// aggiungo affondamento
@@ -856,8 +888,7 @@ Sawing::EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCr
Vector3d vtThick = vtTool * m_TParams.m_dThick ;
if ( ! GetElevation( pLine->GetStart(), pLine->GetEnd(), vtCorr, dElev) ||
! GetElevation( pLine->GetStart() + vtThick, pLine->GetEnd() + vtThick, vtCorr, dElev2) ) {
string sOut = "Entity not elevation-enabled by Sawing" ;
LOG_INFO( GetEMkLogger(), sOut.c_str()) ;
LOG_INFO( GetEMkLogger(), "Error in Sawing : Entity GetElevation") ;
return false ;
}
dElev = max( dElev, dElev2) ;
@@ -887,35 +918,184 @@ Sawing::EntityApply( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* pCr
bExtAngCN = false ;
}
// aggiusto per tipo estremi
AdjustForEdges( Get( pLine), dElev, bIsFirst, bIsLast, bExtAngPC, bExtAngCN) ;
// recupero distanza di approccio
double dAppr = GetApproachDist() ;
// correzione per angolo di fianco
if ( fabs( m_Params.m_dSideAngle) > EPS_ANG_SMALL)
dAppr /= cos( m_Params.m_dSideAngle * DEGTORAD) ;
// imposto dati comuni
bool bToSkip = false ;
if ( ! AdjustForEdges( Get( pLine), dElev, vtThick, bIsFirst, bIsLast, bExtAngPC, bExtAngCN, bToSkip)) {
LOG_INFO( GetEMkLogger(), "Error in Sawing : Entity AdjustForEdges") ;
return false ;
}
if ( bToSkip) {
LOG_INFO( GetEMkLogger(), "Warning in Sawing : skipped Entity too small") ;
return true ;
}
// Imposto dati comuni
SetPathId( nPxId) ;
SetToolDir( vtTool) ;
SetCorrDir( vtCorr) ;
// 1 -> punto sopra inizio
Point3d ptP1 = pLine->GetStart() + vtCorr * ( dElev + dAppr) ;
if ( AddStart( ptP1) == GDB_ID_NULL)
return false ;
// 2 -> movimento al punto iniziale
SetFeed( m_TParams.m_dTipFeed) ;
Point3d ptP2 = pLine->GetStart() ;
if ( AddLinearMove( ptP2) == GDB_ID_NULL)
return false ;
// 3 -> movimento al punto finale
SetFeed( m_TParams.m_dFeed) ;
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
// 4 -> movimento di risalita sopra il punto finale
SetFeed( m_TParams.m_dFeed) ;
Point3d ptP4 = pLine->GetEnd() + vtCorr * ( dElev + dAppr) ;
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
return false ;
// recupero distanza di sicurezza
double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
// lunghezza di approccio/retrazione
double dAppr = m_Params.m_dStartPos ;
if ( fabs( m_Params.m_dSideAngle) > EPS_ANG_SMALL)
dAppr /= cos( m_Params.m_dSideAngle * DEGTORAD) ;
// Se una sola passata
if ( m_Params.m_dStep < EPS_SMALL) {
// 1 -> approccio
if ( ! AddApproach( pLine->GetStart(), vtCorr, dSafeZ, dElev, dAppr))
return false ;
// 2 -> movimento in affondo al punto iniziale
SetFlag( 0) ;
SetFeed( m_TParams.m_dTipFeed) ;
Point3d ptP2 = pLine->GetStart() ;
if ( AddLinearMove( ptP2) == GDB_ID_NULL)
return false ;
// 3 -> movimento di lato al punto finale
SetFeed( m_TParams.m_dFeed) ;
Point3d ptP3 = pLine->GetEnd() ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
// 4 -> retrazione
if ( ! AddRetract( pLine->GetEnd(), vtCorr, dSafeZ, dElev, dAppr))
return false ;
}
// Se step a Zig-Zag o ToAndFrom
else if ( m_Params.m_nStepType == SAW_ST_ZIGZAG || m_Params.m_nStepType == SAW_ST_TOANDFROM) {
// 1 -> approccio
if ( ! AddApproach( pLine->GetStart(), vtCorr, dSafeZ, dElev, dAppr))
return false ;
// 2-3 -> lavorazione (sempre numero pari di passate)
// calcolo numero e valore degli step
double dCutH = dElev - dExtraCut ;
int nStep = 2 ;
if ( m_Params.m_nStepType == SAW_ST_ZIGZAG) {
nStep = static_cast<int>( ceil( dCutH / m_Params.m_dStep)) ;
if ( ( nStep % 2) == 1)
nStep += 1 ;
}
double dStep = dCutH / nStep ;
// esecuzione degli step
for ( int i = nStep - 1 ; i >= 0 ; -- i) {
// distanza dal fondo
double dDelta = ( ( i != 0) ? dExtraCut + i * dStep : 0) ;
// estremi del movimento (dispari vanno, pari tornano)
Point3d ptP2 = pLine->GetStart() + vtCorr * dDelta ;
Point3d ptP3 = pLine->GetEnd() + vtCorr * dDelta ;
if ( ( i % 2) == 0)
swap( ptP2, ptP3) ;
// movimento in affondo
SetFlag( 0) ;
SetFeed( m_TParams.m_dTipFeed) ;
if ( AddLinearMove( ptP2) == GDB_ID_NULL)
return false ;
// movimento di lato
SetFeed( m_TParams.m_dFeed) ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
}
// 4 -> retrazione
if ( ! AddRetract( pLine->GetStart(), vtCorr, dSafeZ, dElev, dAppr))
return false ;
}
// Altrimenti step a una via
else {
// 1 -> approccio
if ( ! AddApproach( pLine->GetStart(), vtCorr, dSafeZ, dElev, dAppr))
return false ;
// 2-3 -> lavorazione
// calcolo numero e valore degli step
double dCutH = dElev - dExtraCut ;
int nStep = static_cast<int>( ceil( dCutH / m_Params.m_dStep)) ;
double dStep = dCutH / nStep ;
// esecuzione degli step
for ( int i = nStep - 1 ; i >= 0 ; -- i) {
// distanza dal fondo
double dDelta = ( ( i != 0) ? dExtraCut + i * dStep : 0) ;
// movimento in affondo al punto iniziale
SetFlag( 0) ;
SetFeed( m_TParams.m_dTipFeed) ;
Point3d ptP2 = pLine->GetStart() + vtCorr * dDelta ;
if ( AddLinearMove( ptP2) == GDB_ID_NULL)
return false ;
// movimento di lato al punto finale
SetFeed( m_TParams.m_dFeed) ;
Point3d ptP3 = pLine->GetEnd() + vtCorr * dDelta ;
if ( AddLinearMove( ptP3) == GDB_ID_NULL)
return false ;
// se non è ultimo passo
if ( i != 0) {
// movimento di risalita sopra il punto finale
SetFeed( m_TParams.m_dEndFeed) ;
Point3d ptP4 = pLine->GetEnd() + vtCorr * ( dElev + dAppr) ;
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
return false ;
// movimento di ritorno spora il punto iniziale
SetFeed( m_TParams.m_dEndFeed) ;
Point3d ptP5 = pLine->GetStart() + vtCorr * ( dElev + dAppr) ;
if ( AddLinearMove( ptP5) == GDB_ID_NULL)
return false ;
}
}
// 4 -> retrazione
if ( ! AddRetract( pLine->GetEnd(), vtCorr, dSafeZ, dElev, dAppr))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Sawing::AddApproach( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dElev, double dAppr)
{
// se distanza di sicurezza minore di distanza di inizio
if ( dSafeZ < m_Params.m_dStartPos + 10 * EPS_SMALL) {
// 1 -> punto sopra inizio
SetFlag( 1) ;
Point3d ptP1 = ptP + vtCorr * ( dElev + dAppr) ;
if ( AddRapidStart( ptP1) == GDB_ID_NULL)
return false ;
}
else {
// 1a -> punto sopra inizio
SetFlag( 1) ;
Point3d ptP1b = ptP + vtCorr * ( dElev + dAppr) ;
Point3d ptP1a = ptP1b + Z_AX * ( dSafeZ - m_Params.m_dStartPos) ;
if ( AddRapidStart( ptP1a) == GDB_ID_NULL)
return false ;
// 1b -> punto appena sopra inizio
SetFlag( 0) ;
if ( AddRapidMove( ptP1b) == GDB_ID_NULL)
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Sawing::AddRetract( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dElev, double dAppr)
{
if ( dSafeZ < m_Params.m_dStartPos + 10 * EPS_SMALL) {
// 4 -> movimento di risalita sopra il punto finale
SetFeed( m_TParams.m_dEndFeed) ;
Point3d ptP4 = ptP + vtCorr * ( dElev + dAppr) ;
if ( AddLinearMove( ptP4) == GDB_ID_NULL)
return false ;
}
else {
// 4a -> movimento di risalita appena sopra il punto finale
SetFeed( m_TParams.m_dEndFeed) ;
Point3d ptP4a = ptP + vtCorr * ( dElev + dAppr) ;
if ( AddLinearMove( ptP4a) == GDB_ID_NULL)
return false ;
// 4b -> movimento di risalita sopra il punto finale
Point3d ptP4b = ptP4a + Z_AX * ( dSafeZ - m_Params.m_dStartPos) ;
if ( AddRapidMove( ptP4b) == GDB_ID_NULL)
return false ;
}
return true ;
}
@@ -983,7 +1163,8 @@ Sawing::AdjustForSide( ICurve* pCurve)
//----------------------------------------------------------------------------
bool
Sawing::AdjustForEdges( ICurveLine* pLine, double dElev, bool bIsFirst, bool bIsLast, bool bExtAngPC, bool bExtAngCN)
Sawing::AdjustForEdges( ICurveLine* pLine, double dElev, const Vector3d& vtThick,
bool bIsFirst, bool bIsLast, bool bExtAngPC, bool bExtAngCN, bool& bToSkip)
{
// distanza XY tra centro e bordo taglio
double dDeltaT = (( dElev < 0.5 * m_TParams.m_dDiam) ? sqrt( dElev * m_TParams.m_dDiam - dElev * dElev) : 0) ;
@@ -993,18 +1174,58 @@ Sawing::AdjustForEdges( ICurveLine* pLine, double dElev, bool bIsFirst, bool bIs
dDeltaI = - dDeltaT ;
else if ( bIsFirst) {
if ( m_Params.m_nLeadInType == SAW_LI_STRICT)
// all'interno
dDeltaI = - dDeltaT ;
else if ( m_Params.m_nLeadInType == SAW_LI_OUT)
// all'esterno
dDeltaI = dDeltaT ;
else if ( m_Params.m_nLeadInType == SAW_LI_EXT_CENT)
; // estendere al bordo del grezzo
else if ( m_Params.m_nLeadInType == SAW_LI_EXT_OUT)
; // estendere al bordo del grezzo e aggiungere dDeltaT
else if ( m_Params.m_nLeadInType == SAW_LI_EXT_CENT) {
// porto il centro lama sul bordo del grezzo
// calcolo punto di inizio e direzione (sono in globale)
Point3d ptP ;
pLine->GetStartPoint( ptP) ;
Vector3d vtDir ;
pLine->GetStartDir( vtDir) ;
// determino la distanza dal bordo del grezzo
double dDist = 0, dDist2 = 0 ;
if ( ! GetDistanceFromRawSide( ptP, - vtDir, dDist) &&
! GetDistanceFromRawSide( ptP + vtThick, - vtDir, dDist2))
return false ;
dDeltaI = max( dDist, dDist2) ;
}
else if ( m_Params.m_nLeadInType == SAW_LI_EXT_OUT) {
// estendo all'esterno del bordo del grezzo
// calcolo punto di inizio e direzione (sono in globale)
Point3d ptP ;
pLine->GetStartPoint( ptP) ;
Vector3d vtDir ;
pLine->GetStartDir( vtDir) ;
// determino la distanza dal bordo del grezzo
double dDist = 0, dDist2 = 0 ;
if ( ! GetDistanceFromRawSide( ptP, - vtDir, dDist) ||
! GetDistanceFromRawSide( ptP + vtThick, - vtDir, dDist2))
return false ;
dDeltaI = max( dDist, dDist2) + dDeltaT ;
}
}
else {
if ( m_Params.m_nExtLinkType == SAW_EL_EXT_NEXT ||
m_Params.m_nExtLinkType == SAW_EL_EXT_BOTH) {
; // estendere al bordo del grezzo se LeadIn EXT_OUT aggiungere dDeltaT
// estendere al bordo del grezzo
// calcolo punto di inizio e direzione (sono in globale)
Point3d ptP ;
pLine->GetStartPoint( ptP) ;
Vector3d vtDir ;
pLine->GetStartDir( vtDir) ;
// determino la distanza dal bordo del grezzo
double dDist = 0, dDist2 = 0 ;
if ( ! GetDistanceFromRawSide( ptP, - vtDir, dDist) ||
! GetDistanceFromRawSide( ptP + vtThick, - vtDir, dDist2))
return false ;
dDeltaI = max( dDist, dDist2) ;
// se LeadIn EXT_OUT vado all'esterno
if ( m_Params.m_nLeadInType == SAW_LI_EXT_OUT)
dDeltaI += dDeltaT ;
}
}
// verifiche e aggiustamenti sulla fine
@@ -1012,22 +1233,48 @@ Sawing::AdjustForEdges( ICurveLine* pLine, double dElev, bool bIsFirst, bool bIs
if ( ! bExtAngCN)
dDeltaF = - dDeltaT ;
else if ( bIsLast) {
if ( m_Params.m_nLeadOutType == SAW_LI_STRICT)
if ( m_Params.m_nLeadOutType == SAW_LO_STRICT)
dDeltaF = - dDeltaT ;
else if ( m_Params.m_nLeadInType == SAW_LO_EXT)
; // estendere al bordo del grezzo
else if ( m_Params.m_nLeadInType == SAW_LO_EXT) {
// estendo al bordo del grezzo
// calcolo punto di fine e direzione (sono in globale)
Point3d ptP ;
pLine->GetEndPoint( ptP) ;
Vector3d vtDir ;
pLine->GetEndDir( vtDir) ;
// determino la distanza dal bordo del grezzo
double dDist = 0, dDist2 = 0 ;
if ( ! GetDistanceFromRawSide( ptP, vtDir, dDist) ||
! GetDistanceFromRawSide( ptP + vtThick, vtDir, dDist2))
return false ;
dDeltaF = max( dDist, dDist2) ;
}
}
else {
if ( m_Params.m_nExtLinkType == SAW_EL_EXT_PREV ||
m_Params.m_nExtLinkType == SAW_EL_EXT_BOTH) {
; // estendere al bordo del grezzo
// estendo al bordo del grezzo
// calcolo punto di fine e direzione (sono in globale)
Point3d ptP ;
pLine->GetEndPoint( ptP) ;
Vector3d vtDir ;
pLine->GetEndDir( vtDir) ;
// determino la distanza dal bordo del grezzo
double dDist = 0, dDist2 = 0 ;
if ( ! GetDistanceFromRawSide( ptP, vtDir, dDist) ||
! GetDistanceFromRawSide( ptP + vtThick, vtDir, dDist2))
return false ;
dDeltaF = max( dDist, dDist2) ;
}
}
// controllo se lunghezza entità accettabile
const double MIN_LEN = 10 ;
double dLenXY = DistXY( pLine->GetStart(), pLine->GetEnd()) ;
if ( dDeltaI + dLenXY + dDeltaF < MIN_LEN)
return false ;
if ( dDeltaI + dLenXY + dDeltaF < MIN_LEN) {
bToSkip = true ;
return true ;
}
bToSkip = false ;
// modifico gli estremi
if ( dDeltaF > EPS_SMALL)
pLine->ExtendEndByLen( dDeltaF) ;
@@ -1040,37 +1287,3 @@ Sawing::AdjustForEdges( ICurveLine* pLine, double dElev, bool bIsFirst, bool bIs
return true ;
}
//----------------------------------------------------------------------------
bool
Sawing::AdjustPositionForAxesCalc( const CamData* pCamData, Point3d& ptP)
{
// compenso il raggio dell'utensile
ptP += pCamData->GetCorrDir() * ( m_TParams.m_dDiam / 2) ;
return true ;
}
//----------------------------------------------------------------------------
bool
Sawing::GetDistanceFromRawBottom( int nPathId, double dToler, double & dRbDist)
{
// recupero distanza da fondo dei grezzi interessati dal percorso
dRbDist = 0 ;
BBox3d b3Compo ;
if ( ! m_pGeomDB->GetGlobalBBox( nPathId, b3Compo))
return false ;
b3Compo.Expand( dToler, dToler, 0) ;
int nRawId = m_pMchMgr->GetFirstRawPart() ;
while ( nRawId != GDB_ID_NULL) {
BBox3d b3Raw ;
int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
if ( m_pGeomDB->GetGlobalBBox( nRawSolidId, b3Raw) && b3Compo.OverlapsXY( b3Raw)) {
double dDist = b3Compo.GetMax().z - b3Raw.GetMin().z ;
if ( dDist > dRbDist)
dRbDist = dDist ;
}
nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
}
return true ;
}