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

EgtGeomKernel :

Browse Source 
- correzione a creazione arco con Set2PNB quando deltaN < epsilon
- dump di CurveComposite limitato a 1000 entità
- correzione in Zmap a calcolo spillone con movimento ortogonale di sfera.
This commit is contained in:
Dario Sassi
2018-05-23 13:28:32 +00:00
parent 6d82a47214
commit 67cd4ef923
5 changed files with 80 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files
BBox3d.cpp
+16
View File
@@ -77,6 +77,14 @@ BBox3d::IsSmallXY( void) const
m_ptMax.y - m_ptMin.y < EPS_SMALL) ;
}
//----------------------------------------------------------------------------
bool
BBox3d::IsSmallZ( void) const
{
return ( ! IsValid() ||
m_ptMax.z - m_ptMin.z < EPS_SMALL) ;
}
//----------------------------------------------------------------------------
bool
BBox3d::IsEpsilon( double dToler) const
@@ -96,6 +104,14 @@ BBox3d::IsEpsilonXY( double dToler) const
m_ptMax.y - m_ptMin.y < dToler) ;
}
//----------------------------------------------------------------------------
bool
BBox3d::IsEpsilonZ( double dToler) const
{
return ( ! IsValid() ||
m_ptMax.z - m_ptMin.z < dToler) ;
}
//----------------------------------------------------------------------------
void
BBox3d::Add( const Point3d& ptP)
CurveArc.cpp
+2 -3
View File
@@ -242,9 +242,8 @@ CurveArc::Set2PNB( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& v
return false ;
// deltaN eventuale ( è componente parallela a VtN)
m_dDeltaN = vtDiff * m_VtN ;
if ( fabs( m_dDeltaN) > EPS_SMALL)
vtDiff -= m_dDeltaN * m_VtN ;
else
vtDiff -= m_dDeltaN * m_VtN ;
if ( fabs( m_dDeltaN) < EPS_SMALL)
m_dDeltaN = 0 ;
// verifico sia un arco (uso la lunghezza della saetta)
double dDist = vtDiff.Len() ;
CurveComposite.cpp
+7 -2
View File
@@ -587,12 +587,15 @@ CurveComposite::Dump( string& sOut, bool bMM, const char* szNewLine) const
// dati generali di una curva
if ( ! CurveDump( *this, sOut, bMM, szNewLine))
return false ;
// prealloco la stringa
const int MAX_CRV = 1000 ;
sOut.reserve( 100 + min( int (m_CrvSmplS.size()), MAX_CRV) * 60) ;
// parametri : numero di curve
sOut += "CrvNbr=" + ToString( int( m_CrvSmplS.size())) + szNewLine ;
// ciclo sulle curve componenti
// ciclo sulle curve componenti
int i = 0 ;
const ICurve* pCrvSmpl = GetFirstCurve() ;
while ( pCrvSmpl != nullptr) {
while ( pCrvSmpl != nullptr && i < MAX_CRV) {
// assegno ed emetto nome e tipo della curva semplice
sOut += "#" + ToString( ++i) + " " + pCrvSmpl->GetTitle() + szNewLine ;
// salvataggio della curva semplice
@@ -601,6 +604,8 @@ CurveComposite::Dump( string& sOut, bool bMM, const char* szNewLine) const
// passo alla successiva
pCrvSmpl = GetNextCurve() ;
}
if ( pCrvSmpl != nullptr)
sOut += string( ". . .") + szNewLine ;
return true ;
}
VolZmapCalculus.cpp
+30 -41
View File
@@ -699,7 +699,7 @@ VolZmap::AvoidCylinder( const Frame3d& frCyl, double dL, double dR) const
// La funzione restituisce true in caso di intersezione, false altrimenti.
bool
VolZmap::IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
const Frame3d& CylFrame, double dH, double dR, bool bTapO, bool bTapL,
const Frame3d& CylFrame, double dH, double dR, bool bTapB, bool bTapT,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2)
{
Point3d ptP = ptLineSt ;
@@ -740,7 +740,7 @@ VolZmap::IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
ptInt1.ToGlob( CylFrame) ;
ptInt2.ToGlob( CylFrame) ;
vtN1.ToGlob( CylFrame) ;
vtN2.ToGlob( CylFrame) ;
vtN2.ToGlob( CylFrame) ;
return true ;
}
// Nessuna intersezione
@@ -757,54 +757,43 @@ VolZmap::IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
// appartiene alla superficie
if ( nRoot == 2) {
// Tolleranze per tagliare o meno i dexel a filo sulle
// circonferenze di base e di top.
double dEpsO = ( bTapO ? - EPS_SMALL : EPS_SMALL) ;
double dEpsL = ( bTapL ? EPS_SMALL : - EPS_SMALL) ;
// Punti d'intersezione trovati
// Ordino i parametri di intersezione
double dUmin = vdRoots[0] ;
double dUmax = vdRoots[1] ;
if ( dUmin > dUmax)
swap( dUmin, dUmax) ;
// Calcolo i punti d'intersezione (ordinati secondo Z crescente)
ptInt1 = ptP + vdRoots[0] * vtV ;
ptInt2 = ptP + vdRoots[1] * vtV ;
if ( ptInt1.z > ptInt2.z)
swap( ptInt1, ptInt2) ;
// Setto le normali
vtN1.Set( ( ORIG - ptInt1).x, ( ORIG - ptInt1).y, 0) ;
vtN2.Set( ( ORIG - ptInt2).x, ( ORIG - ptInt2).y, 0) ;
vtN1.Normalize() ;
vtN2.Normalize() ;
// Studio le soluzioni
if ( ptInt1.z < dH + dEpsL) {
if ( ptInt1.z > dEpsO) {
if ( ptInt2.z > dH + dEpsL) {
ptInt2 = ptP + ( ( dH - ptP.z) / vtV.z) * vtV ;
vtN2.Set( 0, 0, -1) ;
}
}
else {
if ( ptInt2.z > dH + dEpsL) {
ptInt1 = ptP - ( ptP.z / vtV.z) * vtV ;
ptInt2 = ptP + ( ( dH - ptP.z) / vtV.z) * vtV ;
vtN1.Set( 0, 0, 1) ;
vtN2.Set( 0, 0, -1) ;
}
else if ( ptInt2.z > dEpsO) {
ptInt1 = ptP - ( ptP.z / vtV.z) * vtV ;
vtN1.Set( 0, 0, 1) ;
}
else
return false ;
}
}
else
// Quote limitazione, dipendenti dalla tappatura estremità
double dZbot = ( bTapB ? -EPS_SMALL : EPS_SMALL) ;
double dZtop = ( bTapT ? dH + EPS_SMALL : dH - EPS_SMALL) ;
// Se intersezioni entrambe fuori dal cilindro limitato, non vanno considerate
if ( ptInt2.z < dZbot || ptInt1.z > dZtop)
return false ;
// Calcolo le normali
vtN1.Set( ( ORIG - ptInt1).x, ( ORIG - ptInt1).y, 0) ;
vtN1.Normalize() ;
vtN2.Set( ( ORIG - ptInt2).x, ( ORIG - ptInt2).y, 0) ;
vtN2.Normalize() ;
// Limitazioni per intersezione con piano basso
if ( ptInt1.z < dZbot - EPS_ZERO) {
ptInt1 = ptP + Clamp( ( dZbot - ptP.z / vtV.z), dUmin, dUmax) * vtV ;
vtN1.Set( 0, 0, 1) ;
}
// Limitazioni per intersezione con piano alto
if ( ptInt2.z > dZtop + EPS_ZERO) {
ptInt2 = ptP + Clamp( ( ( dZtop - ptP.z) / vtV.z), dUmin, dUmax) * vtV ;
vtN2.Set( 0, 0, -1) ;
}
// Riporto le coordinate nel sistema di riferimento griglia
ptInt1.ToGlob( CylFrame) ;
ptInt2.ToGlob( CylFrame) ;
vtN1.ToGlob( CylFrame) ;
vtN2.ToGlob( CylFrame) ;
}
vtN2.ToGlob( CylFrame) ;
}
return true ;
}
VolZmapVolume.cpp
+25 -55
View File
@@ -4760,38 +4760,21 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double
bool
VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d & ptLs, const Point3d & ptLe, double dRad)
{
// Verifico interferisca
unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool bInterf = BBoxComponent( nGrid, ptLs, ptLe, V_NULL, nStartI, nStartJ, nEndI, nEndJ, dRad, 0, 0) ;
if ( ! bInterf)
if ( ! bInterf)
return true ;
// Vettore modivemnto
Vector3d vtV = ptLe - ptLs ;
double dLengthPath = vtV.Len() ;
vtV.Normalize() ;
Vector3d vtW ;
// Costruisco sistema di riferimento
if ( vtV.x * vtV.x > 0.09)
vtW.Set( - ( vtV.y + vtV.z) / vtV.x, 1, 1) ;
else if ( vtV.y * vtV.y > 0.09)
vtW.Set( 1, - ( vtV.x + vtV.z) / vtV.y, 1) ;
else
vtW.Set( 1, 1, - ( vtV.x + vtV.y) / vtV.z) ;
//Point3d ptOnX = ptLs + vtW ;
Frame3d CylFrame ; CylFrame.Set( ptLs, vtV, vtW) ;
// Riferimento per cilindro inviluppo della sfera lungo il movimento
Frame3d CylFrame ;
CylFrame.Set( ptLs, vtV) ;
double dSqRad = dRad * dRad ;
double dMin, dMax ;
Vector3d vtNmin, vtNmax ;
for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
@@ -4803,62 +4786,49 @@ VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d & ptLs, const Point
double dStSqDXY = SqDistXY( ptC, ptLs) ;
double dEnSqDXY = SqDistXY( ptC, ptLe) ;
// Prima sfera
// Sfera in posizione start
if ( dStSqDXY < dSqRad) {
dMin = ptLs.z - sqrt( dSqRad - dStSqDXY) ;
dMax = ptLs.z + sqrt( dSqRad - dStSqDXY) ;
Point3d ptIntMin( dX, dY, dMin) ;
Point3d ptIntMax( dX, dY, dMax) ;
vtNmin = ptLs - ptIntMin ;
vtNmax = ptLs - ptIntMax ;
double dMin = ptLs.z - sqrt( dSqRad - dStSqDXY) ;
double dMax = ptLs.z + sqrt( dSqRad - dStSqDXY) ;
Vector3d vtNmin = ptLs - Point3d( dX, dY, dMin) ;
vtNmin.Normalize() ;
Vector3d vtNmax = ptLs - Point3d( dX, dY, dMax) ;
vtNmax.Normalize() ;
SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
}
// Seconda sfera
// Sfera in posizione end
if ( dEnSqDXY < dSqRad) {
dMin = ptLe.z - sqrt( dSqRad - dEnSqDXY) ;
dMax = ptLe.z + sqrt( dSqRad - dEnSqDXY) ;
Point3d ptIntMin( dX, dY, dMin) ;
Point3d ptIntMax( dX, dY, dMax) ;
vtNmin = ptLe - ptIntMin ;
vtNmax = ptLe - ptIntMax ;
double dMin = ptLe.z - sqrt( dSqRad - dEnSqDXY) ;
double dMax = ptLe.z + sqrt( dSqRad - dEnSqDXY) ;
Vector3d vtNmin = ptLe - Point3d( dX, dY, dMin) ;
vtNmin.Normalize() ;
Vector3d vtNmax = ptLe - Point3d( dX, dY, dMax) ;
vtNmax.Normalize() ;
SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
}
// Cilindro inviluppo della sfera
Point3d ptInt1, ptInt2 ;
Vector3d vtN1, vtN2 ;
// Cilindro
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dLengthPath, dRad, false, false, ptInt1, ptInt2, vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z ;
dMax = ptInt2.z ;
vtNmin = vtN1 ;
vtNmax = vtN2 ;
double dMin = ptInt1.z ;
double dMax = ptInt2.z ;
Vector3d vtNmin = vtN1 ;
Vector3d vtNmax = vtN2 ;
if ( ptInt1.z > ptInt2.z) {
swap( dMin, dMax) ;
swap( vtNmin, vtNmax) ;
}
else {
dMin = ptInt2.z ;
dMax = ptInt1.z ;
vtNmin = vtN2 ;
vtNmax = vtN1 ;
}
SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
}
}
}
return true ;
}