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

EgtMachKernel 3.1g4 :

Browse Source 
- in PocketingNT correzioni e migliorie per Elevazioni, MaxMaterial e Proiezioni di grezzo presso i lati aperti.
This commit is contained in:
Riccardo Elitropi
2026-07-21 17:33:37 +02:00
parent 68a850268f
commit 043a81366f
3 changed files with 292 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtMachKernel.rc
BIN
View File
Binary file not shown.
PocketingNT.cpp
+281 -125
View File
@@ -2220,9 +2220,45 @@ PocketingNT::GetExtrusionStm( const ISurfFlatRegion* pSfr, const Vector3d& vtExt
return ( Release( pStmExtrusion)) ;
}
//----------------------------------------------------------------------------
ISurfTriMesh*
PocketingNT::GetStmRawSliced( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, const Vector3d& vtTool) const
{
// controllo dei parametri
if ( pStmRaw == nullptr || ! pStmRaw->IsValid())
return nullptr ;
if ( pSfr == nullptr || ! pSfr->IsValid())
return CloneSurfTriMesh( pStmRaw) ;
PtrOwner<ISurfTriMesh> pStmRawSliced( CloneSurfTriMesh( pStmRaw)) ;
Point3d ptCenPrev ; pSfr->GetCentroid( ptCenPrev) ;
Plane3d plProjPrev ;
if ( ! plProjPrev.Set( ptCenPrev, vtTool))
return nullptr ;
pStmRawSliced->Cut( plProjPrev, true) ;
if ( pStmRawSliced->IsValid() && pStmRawSliced->GetTriangleCount() > 0 ) {
// chiudo la TriMesh
POLYLINEVECTOR vPL ;
if ( ! pStmRawSliced->GetLoops( vPL))
return CloneSurfTriMesh( pStmRaw) ;
for ( const PolyLine& PL : vPL) {
PtrOwner<ICurveComposite> pCompoLoop( CreateCurveComposite()) ;
if ( IsNull( pCompoLoop) || ! pCompoLoop->FromPolyLine( PL))
return CloneSurfTriMesh( pStmRaw) ;
PtrOwner<ISurfTriMesh> pStmCap( GetSurfTriMeshByFlatContour( pCompoLoop, EPS_SMALL)) ;
if ( IsNull( pStmCap) || ! pStmCap->IsValid() || ! pStmCap->Invert())
return CloneSurfTriMesh( pStmRaw) ;
if ( ! pStmRawSliced->DoSewing( *pStmCap))
return CloneSurfTriMesh( pStmRaw) ;
}
}
return ( ( ! IsNull( pStmRawSliced) && pStmRawSliced->IsValid()) ? Release( pStmRawSliced) : nullptr) ;
}
//----------------------------------------------------------------------------
ISurfFlatRegion*
PocketingNT::GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs)
PocketingNT::GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs) const
{
// interseco la superficie alla quota corrente
PNTVECTOR vPnt ;
@@ -2302,8 +2338,8 @@ PocketingNT::GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, doubl
//----------------------------------------------------------------------------
ISurfFlatRegion*
PocketingNT::GetSfrRawProjection( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, const Vector3d& vtTool,
const Frame3d& frAtTop, ICAvParSilhouettesSurfTm** ppCavParSil)
PocketingNT::GetSfrRawProjection( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr,
const Vector3d& vtTool, const Frame3d& frAtTop, ICAvParSilhouettesSurfTm** ppCavParSil)
{
// controllo dei parametri
if ( pStmRaw == nullptr || ! pStmRaw->IsValid() || pSfr == nullptr || ! pSfr->IsValid())
@@ -2967,7 +3003,7 @@ PocketingNT::ExtendOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm)
//----------------------------------------------------------------------------
bool
PocketingNT::ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmExtrusion)
PocketingNT::ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmExtrusion) const
{
// controllo parametri :
if ( pSfr == nullptr || ! pSfr->IsValid() || pStmExtrusion == nullptr)
@@ -3246,6 +3282,54 @@ PocketingNT::ChooseRawPart( const ISurfFlatRegion* pSfrChunk, ISurfTriMesh* pStm
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::TrimRawByMaxElev( ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dMaxElev) const
{
// se grezzo non definito, errore
if ( pStmRaw == nullptr || ! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0)
return false ;
// se regione non definita, errore
if ( pSfr == nullptr || ! pSfr->IsValid())
return false ;
// se massima elevazione poco significativa, non faccio nulla
if ( dMaxElev < 10. * EPS_SMALL)
return true ;
// dalla regione definisco un piano di taglio tenendo conto della massima elevazione
Point3d ptCentroid ; pSfr->GetCentroid( ptCentroid) ;
Plane3d plCut ; plCut.Set( ptCentroid + vtTool * dMaxElev, vtTool) ;
// eseguo il taglio del grezzo
if ( ! pStmRaw->Cut( plCut, true))
return false ;
// se non è rimasto un grezzo valido, ho finito
if ( ! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0)
return true ;
// chiudo il grezzo trimmato definnendo un volume
POLYLINEVECTOR vPL ;
if ( ! pStmRaw->GetLoops( vPL))
return false ;
for ( const PolyLine& PL : vPL) {
PtrOwner<ICurveComposite> pCompoLoop( CreateCurveComposite()) ;
if ( IsNull( pCompoLoop) || ! pCompoLoop->FromPolyLine( PL))
return false ;
PtrOwner<ISurfTriMesh> pStmCap( GetSurfTriMeshByFlatContour( pCompoLoop)) ;
if ( IsNull( pStmCap) || ! pStmCap->IsValid() || pStmCap->GetTriangleCount() == 0)
return false ;
// verifico che la superficie sia orientata correttamente per la cucitura
Triangle3d Tria ; pStmCap->GetFirstTriangle( Tria) ;
if ( AreOppositeVectorApprox( Tria.GetN(), vtTool))
pStmCap->Invert() ;
if ( ! pStmRaw->DoSewing( *pStmCap))
return false ;
}
return ( pStmRaw->IsValid() && pStmRaw->GetTriangleCount() > 0) ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::ManageOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm)
@@ -3568,7 +3652,7 @@ PocketingNT::ManageOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm)
bool
PocketingNT::CheckMaxDepth( const ISurfFlatRegion* pSfr, double dDepth, const Vector3d& vtTool,
const ISurfTriMesh* pStmRaw, const ISurfTriMesh* pStmExtrusion,
const IntersParPlanesSurfTm& IPPStm, bool& bSkipMaxDepth)
const IntersParPlanesSurfTm& IPPStm, bool& bSkipMaxDepth) const
{
// controllo dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid() ||
@@ -3947,66 +4031,34 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId)
const double MIN_ZSTEP = 1.0 ;
if ( dOkStep >= EPS_SMALL && dOkStep < MIN_ZSTEP) {
dOkStep = MIN_ZSTEP + EPS_SMALL ;
string sInfo = "Warning in PocketingNT : machining step too small (" +
ToString( m_Params.m_dStep, 2) + ")" ;
string sInfo = "Warning in PocketingNT : machining step too small (" + ToString( m_Params.m_dStep, 2) + ")" ;
m_pMchMgr->SetWarning( 2456, sInfo) ;
}
// calcolo l'elevazione inversa per definire la Depth massima
double dInvElev = 0. ;
pSfr->Invert() ;
if ( ! CalcRegionElevation( pSfr, vtTool, 0., m_TParams.m_dDiam / 2., m_TParams.m_dLen, dInvElev)) {
m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ;
return false ;
}
pSfr->Invert() ;
double dExtraDepth = ( dOkStep < EXTRA_DEPTH ? dOkStep / 2. : EXTRA_DEPTH) ;
if ( dOkStep < EPS_SMALL)
dExtraDepth = EXTRA_DEPTH ;
dDepth = min( dDepth, dInvElev + dExtraDepth) ;
// calcolo l'elevazione massima
double dElev = 0. ;
if ( ! CalcRegionElevation( pSfr, vtTool, dDepth, m_TParams.m_dDiam / 2., m_TParams.m_dLen, dElev)) {
m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ;
return false ;
}
double dMaxElev ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_MAXELEV, dMaxElev) && dElev > dMaxElev)
dElev = dMaxElev ;
// verifico che il massimo materiale dell'utensile sia sensato
const double MIN_MAXMAT = 1.0 ;
if ( m_TParams.m_dMaxMat < dElev && m_TParams.m_dMaxMat < MIN_MAXMAT) {
string sInfo = "Error in PocketingNT : Tool MaxMaterial too small (" +
ToString( m_TParams.m_dMaxMat, 2) + ")" ;
m_pMchMgr->SetLastError( 2422, sInfo) ;
return false ;
}
// verifico di non superare il massimo materiale (se lo step supera la capacità dell'utensile)
if ( m_Params.m_dStep > m_TParams.m_dMaxMat + EPS_SMALL) {
dOkStep = m_TParams.m_dMaxMat + EPS_SMALL ;
string sInfo = "Warning in PocketingNT : machining step (" + ToString( m_Params.m_dStep, 1) +
") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
m_pMchMgr->SetWarning( 2457, sInfo) ;
}
// recupero il grezzo e la superficie di Trim [nullptr se non presente]
PtrOwner<ISurfTriMesh> pStmRaw( GetRaw()) ;
if ( IsNull( pStmRaw) || ! ChooseRawPart( pSfr, pStmRaw) ||
! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0) {
if ( IsNull( pStmRaw) || ! ChooseRawPart( pSfr, pStmRaw) || ! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0) {
m_pMchMgr->SetLastError( 2436, "Error in PocketingNT : not valid Raw") ;
return false ;
}
PtrOwner<ISurfTriMesh> pStmTrim( GetStmTrim()) ;
if ( ! IsNull( pStmTrim)) {
if ( ! ChooseRawPart( pSfr, pStmTrim) || ! pStmTrim->IsValid() ||
pStmTrim->GetTriangleCount() == 0) {
if ( ! ChooseRawPart( pSfr, pStmTrim) || ! pStmTrim->IsValid() || pStmTrim->GetTriangleCount() == 0) {
m_pMchMgr->SetLastError( 2436, "Error in PocketingNT : not valid Raw") ;
return false ;
}
}
double dMaxElev = 0. ;
if ( GetValInNotes( m_Params.m_sUserNotes, UN_MAXELEV, dMaxElev) && dMaxElev > EPS_SMALL) {
if ( m_Params.m_bToolInvert)
pSfr->Translate( - vtTool * dDepth) ;
if ( ! TrimRawByMaxElev( ( pStmTrim == nullptr ? pStmRaw : pStmTrim), pSfr, vtTool, dMaxElev)) {
m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ;
return false ;
}
if ( m_Params.m_bToolInvert)
pSfr->Translate( vtTool * dDepth) ;
}
#if DEBUG_SFR_RAW
int nGrpSR = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
int nLaySR = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrpSR, GLOB_FRM) ;
@@ -4019,6 +4071,50 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId)
}
#endif
// calcolo l'elevazione inversa per definire la Depth massima
ISurfTriMesh* pStmElev = ( dMaxElev > EPS_SMALL ? ( pStmTrim == nullptr ? pStmRaw : pStmTrim) : nullptr) ;
double dInvElev = 0. ;
pSfr->Invert() ;
if ( ! CalcRegionElevation( pSfr, vtTool, 0., m_TParams.m_dDiam / 2., m_TParams.m_dLen, pStmElev, dInvElev)) {
m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ;
return false ;
}
pSfr->Invert() ;
double dExtraDepth = ( dOkStep < EXTRA_DEPTH ? dOkStep / 2. : EXTRA_DEPTH) ;
if ( dOkStep < EPS_SMALL)
dExtraDepth = EXTRA_DEPTH ;
dDepth = min( dDepth, dInvElev + dExtraDepth) ;
// calcolo l'elevazione massima
double dElev = 0. ;
if ( ! CalcRegionElevation( pSfr, vtTool, dDepth, m_TParams.m_dDiam / 2., m_TParams.m_dLen, pStmElev, dElev)) {
m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ;
return false ;
}
// calcolo l'elevazione al di sopra della geometria originale
double dOrigElev = 0. ;
if ( ! CalcOrigRegionElevation( pSfr, ( pStmTrim == nullptr ? pStmRaw : pStmTrim), vtTool, dDepth, m_TParams.m_dDiam / 2., m_TParams.m_dLen, dOrigElev)) {
m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ;
return false ;
}
// verifico che il massimo materiale dell'utensile sia sensato
const double MIN_MAXMAT = 1.0 ;
if ( m_TParams.m_dMaxMat < dOrigElev && m_TParams.m_dMaxMat < MIN_MAXMAT) {
string sInfo = "Error in PocketingNT : Tool MaxMaterial too small (" + ToString( m_TParams.m_dMaxMat, 2) + ")" ;
m_pMchMgr->SetLastError( 2422, sInfo) ;
return false ;
}
// verifico di non superare il massimo materiale (se lo step supera la capacità dell'utensile)
if ( m_Params.m_dStep > m_TParams.m_dMaxMat + EPS_SMALL) {
dOkStep = m_TParams.m_dMaxMat + EPS_SMALL ;
string sInfo = "Warning in PocketingNT : machining step (" + ToString( m_Params.m_dStep, 1) + ") bigger than MaxMaterial (" +
ToString( m_TParams.m_dMaxMat, 1) + ")" ;
m_pMchMgr->SetWarning( 2457, sInfo) ;
}
// definisco la classe di calcolo della Silhoette del grezzo nel caso mi servisse
PtrOwner<ICAvParSilhouettesSurfTm> pCavParSil( nullptr) ;
Point3d ptAtTop ; pSfr->GetCentroid( ptAtTop) ;
@@ -4057,43 +4153,47 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId)
m_pGeomDB->SetStatus( _a, GDB_ST_OFF) ;
#endif
// se lavorazione singola
if ( dOkStep < EPS_SMALL || dOkStep > dElev) {
// se l'elevazione supera la capacità dell'utensile
if ( dElev > m_TParams.m_dMaxMat + EPS_SMALL) {
// se l'elevazione sopra alla faccia è maggiore del massimo materiale, limito la faccia
bool bBlockStepByElev = false ;
if ( dOrigElev < dElev + 10. * EPS_SMALL && dOrigElev > m_TParams.m_dMaxMat + EPS_SMALL) {
// se lavorazione singola
if ( dOkStep < EPS_SMALL || dOkStep > dElev) {
// se l'elevazione supera la capacità dell'utensile
string sInfo = "Warning in Pocketing : machining depth (" + ToString( dElev, 1) +
") bigger than MaxMaterial (" + ToString( m_TParams.m_dMaxMat, 1) + ")" ;
m_pMchMgr->SetWarning( 2458, sInfo) ;
dDepth -= dElev - m_TParams.m_dMaxMat ;
dElev = m_TParams.m_dMaxMat ;
}
}
// altrimenti lavorazione a step
else {
// se l'elevazione supera il massimo affondamento dell'utensile
double dSafe = GetMaxDepthSafe() ;
double dMaxDepth = m_TParams.m_dLen - ( m_TParams.m_dDiam > m_dTHoldDiam ? m_dTHoldBase : m_dTHoldLen) - dSafe ;
if ( dElev > dMaxDepth + EPS_SMALL) {
// controllo se posso evitare il controllo
Frame3d frSfr ;
Point3d ptCen ; pSfr->GetCentroid( ptCen) ;
Frame3d frPocket ;
if ( ! frPocket.Set( ptCen, vtTool) || ! frPocket.IsValid())
return false ;
IntersParPlanesSurfTm IPPStm( frPocket, *pStmRaw) ;
bool bSkipMaxDepth = false ;
if ( ! CheckMaxDepth( pSfr, dDepth, vtTool, pStmRaw, pStmExtrusion, IPPStm, bSkipMaxDepth))
return false ;
if ( ! bSkipMaxDepth) {
// segnalo, riduco e continuo
string sInfo = "Warning in PocketingNT : machining depth (" + ToString( dElev, 1) +
") bigger than MaxDepth (" + ToString( dMaxDepth, 1) + ")" ;
m_pMchMgr->SetWarning( 2458, sInfo) ;
dDepth -= dElev - dMaxDepth ;
dElev = dMaxDepth ;
// altrimenti lavorazione a step
else {
// se l'elevazione supera il massimo affondamento dell'utensile
double dSafe = GetMaxDepthSafe() ;
double dMaxDepth = m_TParams.m_dLen - ( m_TParams.m_dDiam > m_dTHoldDiam ? m_dTHoldBase : m_dTHoldLen) - dSafe ;
if ( dElev > dMaxDepth + EPS_SMALL) {
// controllo se posso evitare il controllo
Frame3d frSfr ;
Point3d ptCen ; pSfr->GetCentroid( ptCen) ;
Frame3d frPocket ;
if ( ! frPocket.Set( ptCen, vtTool) || ! frPocket.IsValid())
return false ;
IntersParPlanesSurfTm IPPStm( frPocket, *pStmRaw) ;
bool bSkipMaxDepth = false ;
if ( ! CheckMaxDepth( pSfr, dDepth, vtTool, pStmRaw, pStmExtrusion, IPPStm, bSkipMaxDepth))
return false ;
if ( ! bSkipMaxDepth) {
// segnalo, riduco e continuo
string sInfo = "Warning in PocketingNT : machining depth (" + ToString( dElev, 1) +
") bigger than MaxDepth (" + ToString( dMaxDepth, 1) + ")" ;
m_pMchMgr->SetWarning( 2458, sInfo) ;
dDepth -= dElev - dMaxDepth ;
dElev = dMaxDepth ;
}
}
}
}
else
bBlockStepByElev = true ;
// verifico se tavola basculante
bool bTiltTab = false ;
@@ -4217,8 +4317,10 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId)
// adatto la regione piana alla geometria del grezzo
ICAvParSilhouettesSurfTm* pCavParSilTmp = Get( pCavParSil) ;
PtrOwner<ISurfFlatRegion> pSfrTrim( GetSfrRawProjection( ( pStmTrim == nullptr ? pStmRaw : pStmTrim), pSfrPock, vtTool, frAtTop,
&pCavParSilTmp)) ;
PtrOwner<ISurfTriMesh> pStmRawSliced( GetStmRawSliced( pStmRaw, vStepInfo.empty() ? nullptr : vStepInfo.back().pSfrPock, vtTool)) ;
PtrOwner<ISurfFlatRegion> pSfrTrim( GetSfrRawProjection( ( pStmTrim == nullptr ? pStmRawSliced : pStmTrim), pSfrPock,
vtTool, frAtTop,
&pCavParSilTmp)) ;
if ( IsNull( pSfrTrim)) {
m_pMchMgr->SetLastError( 3027, "Error in PocketingNT : Slicing Raw failed") ;
return false ;
@@ -4248,6 +4350,18 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId)
// se regione risultante non vuota
if ( pSfrPock->IsValid() && pSfrPock->GetChunkCount() > 0) {
// Verifico se bloccare gli step in base all'elevazione o meno
if ( bBlockStepByElev) {
double dStepElev = 0. ;
if ( ! CalcRegionElevation( pSfrPock, vtTool, 0., m_TParams.m_dDiam / 2., m_TParams.m_dLen, pStmRaw, dStepElev)) {
m_pMchMgr->SetLastError( 2433, "Error in PocketingNT : Calc Region Elevation failed") ;
return false ;
}
if ( dStepElev > m_TParams.m_dMaxMat + EPS_SMALL)
break ;
}
// determino i lati aperti
if ( ! ChooseCloseOrOpenEdge( pSfrPock, pStmExtrusion)) {
m_pMchMgr->SetLastError( 2441, "Error in PocketingNT : Detecting open edges failed") ;
@@ -4327,7 +4441,7 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId)
//----------------------------------------------------------------------------
bool
PocketingNT::CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dDepth,
double dRad, double dLen, double& dElev)
double dRad, double dLen, const ISurfTriMesh* pStmRaw, double& dElev) const
{
// controllo dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid())
@@ -4359,37 +4473,46 @@ PocketingNT::CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& v
// inizializzo elevazioni per ogni grezzo
INTDBLVECTOR vRawElev ;
// ciclo sui grezzi della fase
int nRawId = m_pMchMgr->GetFirstRawPart() ;
while ( nRawId != GDB_ID_NULL) {
// verifico che il grezzo compaia nella fase
if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
// recupero la trimesh del grezzo
int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
const ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nStmId)) ;
if ( pStm != nullptr) {
// recupero il riferimento della trimesh
Frame3d frStm ;
m_pGeomDB->GetGlobFrame( nStmId, frStm) ;
// porto il poligono in questo riferimento
Polygon3d pgFacetL = pgFacet ;
pgFacetL.ToLoc( frStm) ;
// calcolo l'elevazione
double dCurrElev ;
if ( ! PolygonElevationInClosedSurfTm( pgFacetL, *pStm, true, dCurrElev))
return false ;
if ( dCurrElev > EPS_SMALL)
vRawElev.emplace_back( nStmId, dCurrElev) ;
if ( pStmRaw == nullptr) {
// ciclo sui grezzi della fase
int nRawId = m_pMchMgr->GetFirstRawPart() ;
while ( nRawId != GDB_ID_NULL) {
// verifico che il grezzo compaia nella fase
if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
// recupero la trimesh del grezzo
int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
const ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nStmId)) ;
if ( pStm != nullptr) {
// recupero il riferimento della trimesh
Frame3d frStm ;
m_pGeomDB->GetGlobFrame( nStmId, frStm) ;
// porto il poligono in questo riferimento
Polygon3d pgFacetL = pgFacet ;
pgFacetL.ToLoc( frStm) ;
// calcolo l'elevazione
double dCurrElev ;
if ( ! PolygonElevationInClosedSurfTm( pgFacetL, *pStm, true, dCurrElev))
return false ;
if ( dCurrElev > EPS_SMALL)
vRawElev.emplace_back( nStmId, dCurrElev) ;
}
}
// passo al grezzo successivo
nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
}
// passo al grezzo successivo
nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
}
else {
double dCurrElev ;
if ( ! PolygonElevationInClosedSurfTm( pgFacet, *pStmRaw, true, dCurrElev))
return false ;
if ( dCurrElev > EPS_SMALL)
vRawElev.emplace_back( GDB_ID_NULL, dCurrElev) ;
}
// se trovate elevazioni
if ( ! vRawElev.empty()) {
// ordino il vettore secondo l'elevazione crescente
sort( vRawElev.begin(), vRawElev.end(), []( const INTDBL& a, const INTDBL& b)
{ return a.second < b.second ; }) ;
sort( vRawElev.begin(), vRawElev.end(), []( const INTDBL& a, const INTDBL& b) { return a.second < b.second ; }) ;
// box dell'insieme delle posizioni utensile all'inizioe
const double MAX_DIST_RAW = 200.0 ;
BBox3d b3Tool ;
@@ -4410,10 +4533,13 @@ PocketingNT::CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& v
}
b3Tool.Expand( MAX_DIST_RAW) ;
// verifico la reale interferenza dell'utensile con i diversi grezzi
for ( int i = 0 ; i < int( vRawElev.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vRawElev) ; ++ i) {
// box del grezzo
BBox3d b3Raw ;
m_pGeomDB->GetGlobalBBox( vRawElev[i].first, b3Raw) ;
BBox3d b3Raw ;
if ( pStmRaw == nullptr)
m_pGeomDB->GetGlobalBBox( vRawElev[i].first, b3Raw) ;
else
pStmRaw->GetLocalBBox( b3Raw) ;
// confronto con il box dell'utensile nella posizione precedente
BBox3d b3CurrTool = b3Tool ;
b3CurrTool.Translate( dMyElev * vtTool) ;
@@ -4428,6 +4554,51 @@ PocketingNT::CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& v
return true ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::CalcOrigRegionElevation( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw, const Vector3d& vtTool, double dDepth,
double dRad, double dLen, double& dElev) const
{
// controllo dei parametri
if ( pSfr == nullptr || ! pSfr->IsValid() ||
pStmRaw == nullptr || ! pStmRaw->IsValid() || pStmRaw->GetTriangleCount() == 0)
return false ;
// taglio il grezzo sulla faccia corrispondente
Point3d ptCentroid ; pSfr->GetCentroid( ptCentroid) ;
Plane3d plCut ; plCut.Set( ptCentroid, - vtTool) ;
PtrOwner<ISurfTriMesh> pStmCut( CloneSurfTriMesh( pStmRaw)) ;
if ( IsNull( pStmCut) || ! pStmCut->IsValid() || ! pStmCut->Cut( plCut, false))
return false ;
// recupero il bordo come regione
POLYLINEVECTOR vPL ;
if ( ! pStmCut->GetLoops( vPL))
return false ;
// se il piano di taglio non ha intersecato il grezzo, allora la superficie origale è definita al fuori di esso
if ( vPL.empty())
return CalcRegionElevation( pSfr, vtTool, dDepth, dRad, dLen, pStmRaw, dElev) ;
// altrimenti recupero il bordo corrente come regione
SurfFlatRegionByContours SfrByC ;
for ( const PolyLine& PL : vPL) {
PtrOwner<ICurveComposite> pCompoLoop( CreateCurveComposite()) ;
if ( IsNull( pCompoLoop) || ! pCompoLoop->FromPolyLine( PL))
return false ;
SfrByC.AddCurve( ::Release( pCompoLoop)) ;
}
PtrOwner<ISurfFlatRegion> pSfrOrigFace( SfrByC.GetSurf()) ;
if ( IsNull( pSfrOrigFace) || ! pSfrOrigFace->IsValid())
return false ;
// per sicurezza oriento correttamente
if ( AreOppositeVectorApprox( pSfrOrigFace->GetNormVersor(), pSfr->GetNormVersor()))
pSfrOrigFace->Invert() ;
// la faccia originale è l'intersezione
if ( ! pSfrOrigFace->Intersect( *pSfr) || ! pSfrOrigFace->IsValid())
return CalcRegionElevation( pSfr, vtTool, dDepth, dRad, dLen, pStmRaw, dElev) ;
return ( CalcRegionElevation( pSfrOrigFace, vtTool, dDepth, dRad, dLen, pStmRaw, dElev)) ;
}
//----------------------------------------------------------------------------
bool
PocketingNT::VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool)
@@ -4922,21 +5093,6 @@ PocketingNT::CalcPaths( STEPINFOPOVECTOR& vStepInfo, bool& bEmpty)
m_pMchMgr->SetLastError( 2431, "Error in Pocketing : LeadIn with Mill NoTip in material") ;
return false ;
}
if ( vStepInfo[i].vPaths[j].bOutStart && ! m_bOpenOutRaw) {
// se richiesto, controllo di essere davvero fuori dal grezzo [controllo basilare, migliorabile]
Point3d ptStart ; vCrvPaths[j]->GetStartPoint( ptStart) ;
double dElev ;
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
pCrvArc->Set( ptStart, m_vtTool, 50. * EPS_SMALL) ;
PtrOwner<ISurfFlatRegion> pSfrCheck( CreateSurfFlatRegion()) ;
if ( IsNull( pSfrCheck) || ! pSfrCheck->AddExtLoop( Release( pCrvArc)))
return false ;
if ( CalcRegionElevation( pSfrCheck, m_vtTool, 0., m_TParams.m_dDiam / 2., m_TParams.m_dLen, dElev) &&
dElev > EPS_SMALL) {
vStepInfo[i].vPaths[j].bOutStart = false ;
delete( vCrvPaths[j]->RemoveFirstOrLastCurve( false)) ;
}
}
// controllo se il percorso ha un'uscita presso un lato aperto
vStepInfo[i].vPaths[j].bOutEnd = ( vCrvPaths[j]->GetCurveCount() > 0 &&
vCrvPaths[j]->GetLastCurve()->GetTempProp( 0) == TEMP_PROP_OUT_START) ;
PocketingNT.h
+11 -8
View File
@@ -115,23 +115,26 @@ class PocketingNT : public Machining
ISurfTriMesh* GetRaw( void) ;
ISurfTriMesh* GetStmTrim( void) ;
ISurfTriMesh* GetExtrusionStm( const ISurfFlatRegion* pSfr, const Vector3d& vtExtr) ;
ISurfFlatRegion* GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs = 0) ;
ISurfFlatRegion* GetSfrRawProjection( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, const Vector3d& vtTool,
const Frame3d& frAtTop, ICAvParSilhouettesSurfTm** ppCavParSil = nullptr) ;
ISurfTriMesh* GetStmRawSliced( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, const Vector3d& vtTool) const ;
ISurfFlatRegion* GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs = 0) const ;
ISurfFlatRegion* GetSfrRawProjection( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr,
const Vector3d& vtTool, const Frame3d& frAtTop, ICAvParSilhouettesSurfTm** ppCavParSil = nullptr) ;
Point3d GetStartPointByUser( const ISurfFlatRegion* pSfr) const ;
Point3d GetStartPointsByHead( const STEPINFOPOVECTOR& vStepInfo) const ;
Point3d GetStartPointsBySteps( const STEPINFOPOVECTOR& vStepInfo, int nCrvType) const ;
bool ChooseRawPart( const ISurfFlatRegion* pSfrChunk, ISurfTriMesh* pStm) const ;
bool TrimRawByMaxElev( ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dMaxElev) const ;
bool ManageOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmPart) ;
bool GetHomogeneousParts( const ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vpCrvs) const ;
bool ExtendOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm) ;
bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmExtrusion) ;
bool CheckMaxDepth( const ISurfFlatRegion* pSfr, double dDepth, const Vector3d& vtTool,
const ISurfTriMesh* pStmRaw, const ISurfTriMesh* pStmExtrusion,
const IntersParPlanesSurfTm& IPPStm, bool& bSkipMaxDepth) ;
bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmExtrusion) const ;
bool CheckMaxDepth( const ISurfFlatRegion* pSfr, double dDepth, const Vector3d& vtTool, const ISurfTriMesh* pStmRaw,
const ISurfTriMesh* pStmExtrusion, const IntersParPlanesSurfTm& IPPStm, bool& bSkipMaxDepth) const ;
bool ProcessPath( int nPathId, int nPvId, int nClId) ;
bool CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dDepth,
double dRad, double dLen, double& dElev) ;
double dRad, double dLen, const ISurfTriMesh* pStmRaw, double& dElev) const ;
bool CalcOrigRegionElevation( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw, const Vector3d& vtTool, double dDepth,
double dRad, double dLen, double& dElev) const ;
bool VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) ;
bool GeneratePocketingPv( int nPathId, const ICurveComposite* pCompo) ;
bool CalcGeoExtSurfFr( const ISurfFlatRegion* pSfrPock, const Vector3d& vtTool, double dDepth, const ISurfTriMesh* pStmRaw,