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

Merge branch 'master' into NewRuled

Browse Source
This commit is contained in:
Daniele Bariletti
2025-12-15 15:07:21 +01:00
parent 961acdbc76 11a46ca58c
commit 36422c43b3
29 changed files with 2255 additions and 921 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Color.cpp
+1 -1
View File
@@ -127,7 +127,7 @@ GetHSVFromColor( const Color& cCol)
hsv.dSat = dDelta / dMax ;
if ( cCol.GetRed() >= dMax) // tra giallo e magenta
hsv.dHue = ( cCol.GetGreen() - cCol.GetBlue()) / dDelta ;
else if( cCol.GetGreen() >= dMax) // tra ciano e giallo
else if ( cCol.GetGreen() >= dMax) // tra ciano e giallo
hsv.dHue = 2.0 + ( cCol.GetBlue() - cCol.GetRed()) / dDelta ;
else // tra magenta e ciano
hsv.dHue = 4.0 + ( cCol.GetRed() - cCol.GetGreen()) / dDelta ;
CurveAux.cpp
+20 -20
View File
@@ -687,7 +687,7 @@ EditBezierCurve( const ICurveBezier* pCrvBezier, int nDeg, bool bMakeRatOrNot, d
// adatto ogni sottocurva cubica
PtrOwner<ICurveComposite> pCCEdited( CreateCurveComposite()) ;
for ( int i = 0 ; i < pBezCubics->GetCurveCount() ; ++i) {
if( ! pCCEdited->AddCurve( EditBezierCurve( GetCurveBezier( pBezCubics->GetCurve( i)), nDeg, bMakeRatOrNot, dTol)) )
if ( ! pCCEdited->AddCurve( EditBezierCurve( GetCurveBezier( pBezCubics->GetCurve( i)), nDeg, bMakeRatOrNot, dTol)) )
return nullptr ;
}
return Release( pCCEdited) ;
@@ -1149,7 +1149,7 @@ FindSpan( double dU, int nDeg, const DBLVECTOR& vKnots, int& nSpan)
else
nLow = nMid ;
nMid = ( nLow + nHigh) / 2 ;
if( nMid == nDeg - 1)
if ( nMid == nDeg - 1)
break ;
}
nSpan = nMid ;
@@ -1174,7 +1174,7 @@ CalcBasisFunc( double dU, int nSpan, int nDeg, const DBLVECTOR& vKnots, DBLVECTO
for ( int r = 0 ; r < j ; ++r) {
double dSum = vRight[r+1] + vLeft[j-r] ;
double dTemp = 0 ;
if( dSum > EPS_ZERO)
if ( dSum > EPS_ZERO)
dTemp = vBasis[r] / dSum ;
vBasis[r] = dSaved + vRight[r+1] * dTemp ;
dSaved = vLeft[j-r] * dTemp ;
@@ -1198,7 +1198,7 @@ InterpolatePointSetWithBezierNoIntermedLines( const PNTVECTOR& vPnt, int nStart,
// se ho solo due punti restituisco una linea
CurveLine cl ; cl.Set( vPnt[nStart], vPnt[nEnd]) ;
pCrvInt.Set( LineToBezierCurve( &cl, nDeg, false)) ;
if( ! IsNull( pCrvInt) && pCrvInt->IsValid())
if ( ! IsNull( pCrvInt) && pCrvInt->IsValid())
return Release( pCrvInt) ;
else
return nullptr ;
@@ -1206,10 +1206,10 @@ InterpolatePointSetWithBezierNoIntermedLines( const PNTVECTOR& vPnt, int nStart,
else if (nPoints == 3) {
// se ho solo tre punti uso un altro algoritmo
CurveByInterp cbi ;
for( int i = nStart ; i <= nEnd ; ++i)
for ( int i = nStart ; i <= nEnd ; ++i)
cbi.AddPoint( vPnt[i]) ;
pCrvInt.Set( cbi.GetCurve( CurveByInterp::AKIMA_CORNER, CurveByInterp::CUBIC_BEZIERS)) ;
if( ! IsNull( pCrvInt) && pCrvInt->IsValid())
if ( ! IsNull( pCrvInt) && pCrvInt->IsValid())
return Release( pCrvInt) ;
else
return nullptr ;
@@ -1248,7 +1248,7 @@ InterpolatePointSetWithBezierNoIntermedLines( const PNTVECTOR& vPnt, int nStart,
int nSpan = 0 ; FindSpan( vPntParam[i], nDeg, vKnots, nSpan) ;
DBLVECTOR vBasis ; vBasis.resize( nDeg + 1) ;
CalcBasisFunc( vPntParam[i], nSpan, nDeg, vKnots, vBasis) ;
for( int j = nSpan - nDeg + 1 ; j <= nSpan + 1 ; ++j)
for ( int j = nSpan - nDeg + 1 ; j <= nSpan + 1 ; ++j)
mA.row(i).col(j) << vBasis[j - nSpan + nDeg - 1] ;
}
}
@@ -1273,7 +1273,7 @@ InterpolatePointSetWithBezierNoIntermedLines( const PNTVECTOR& vPnt, int nStart,
pCrvInt.Set( NurbsToBezierCurve( cNurbs)) ;
if( ! IsNull(pCrvInt) && pCrvInt->IsValid())
if ( ! IsNull(pCrvInt) && pCrvInt->IsValid())
return Release( pCrvInt) ;
else
return nullptr ;
@@ -1292,7 +1292,7 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
// scelgo il parametro associato ad ogni punto in modo che rispecchi la distanza tra i punti
double dErr = INFINITO ;
int nItCount = 0 ;
while( dErr > dLinTol && nItCount < 10) {
while ( dErr > dLinTol && nItCount < 10) {
pCrvInt->Clear() ;
int nPoints = int( vPnt.size()) ;
int nDeg = 3 ;
@@ -1302,7 +1302,7 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
// se ho solo due punti restituisco una linea
CurveLine cl ; cl.Set( vPnt[0], vPnt[1]) ;
pCrvInt->AddCurve( LineToBezierCurve( &cl, nDeg, false)) ;
if( ! IsNull( pCrvInt) && pCrvInt->IsValid())
if ( ! IsNull( pCrvInt) && pCrvInt->IsValid())
return Release( pCrvInt) ;
else
return nullptr ;
@@ -1310,10 +1310,10 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
else if ( nPoints == 3) {
// se ho solo tre punti uso un altro algoritmo
CurveByInterp cbi ;
for( int i = 0 ; i < int( vPnt.size()) ; ++i)
for ( int i = 0 ; i < int( vPnt.size()) ; ++i)
cbi.AddPoint( vPnt[i]) ;
pCrvInt->AddCurve( cbi.GetCurve( CurveByInterp::AKIMA_CORNER, CurveByInterp::CUBIC_BEZIERS)) ;
if( ! IsNull( pCrvInt) && pCrvInt->IsValid())
if ( ! IsNull( pCrvInt) && pCrvInt->IsValid())
return Release( pCrvInt) ;
else
return nullptr ;
@@ -1324,14 +1324,14 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
int nStart = 0, nEnd = 0 ;
bool bOk = true ;
bool bFoundLine = false ;
while( nStart < nPoints - 1 && bOk) {
while ( nStart < nPoints - 1 && bOk) {
bFoundLine = false ;
nEnd = 0 ;
DBLVECTOR vLen ;
double dLenTot = 0 ;
for ( int i = nStart ; i < nPoints - 1 ; ++i) {
double dLen = Dist( vPnt[i], vPnt[i+1]) ;
if( dLen < dMaxLen) {
if ( dLen < dMaxLen) {
vLen.push_back( dLen) ;
dLenTot += dLen ;
}
@@ -1342,8 +1342,8 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
}
}
if( vLen.size() != 0) {
if( nEnd == 0)
if ( vLen.size() != 0) {
if ( nEnd == 0)
nEnd = nPoints - 1 ;
pCrvInt->AddCurve( InterpolatePointSetWithBezierNoIntermedLines( vPnt, nStart, nEnd, nDeg, vLen, dLenTot)) ;
}
@@ -1358,13 +1358,13 @@ InterpolatePointSetWithBezier( const PNTVECTOR& vPnt, double dLinTol, double dMa
}
CalcApproxError( pCrvOri, pCrvInt, dErr) ;
if( dErr > dLinTol && dMaxLen > 200 * EPS_SMALL)
if ( dErr > dLinTol && dMaxLen > 200 * EPS_SMALL)
dMaxLen /= 2 ;
++ nItCount ;
}
if( ! IsNull( pCrvInt) && pCrvInt->IsValid() && dErr < dLinTol)
if ( ! IsNull( pCrvInt) && pCrvInt->IsValid() && dErr < dLinTol)
return Release( pCrvInt) ;
else
return nullptr ;
@@ -1382,12 +1382,12 @@ ApproxCurveWithBezier( const ICurve* pCrv , double dTol, int nType)
Point3d pt ; plApprox.GetFirstPoint( pt) ;
do {
vPnt.push_back( pt) ;
}while( plApprox.GetNextPoint( pt)) ;
} while ( plApprox.GetNextPoint( pt)) ;
// campiono punti lungo la curva e poi li interpolo
PtrOwner<ICurve> pCC( InterpolatePointSetWithBezier( vPnt, dTol, 100)) ;
if( ! IsNull( pCC) && pCC->IsValid())
if ( ! IsNull( pCC) && pCC->IsValid())
return Release( pCC) ;
else
return nullptr ;
CurveBezier.cpp
+10 -10
View File
@@ -373,7 +373,7 @@ CurveBezier::CopyFrom( const CurveBezier& cbSrc)
{
if ( &cbSrc == this)
return true ;
if( ! cbSrc.IsValid())
if ( ! cbSrc.IsValid())
return false ;
if ( ! Init( cbSrc.m_nDeg, cbSrc.m_bRat))
return false ;
@@ -1825,19 +1825,19 @@ CurveBezier::TrimStartEndAtParam( double dUStartTrim, double dUEndTrim)
return false ;
// se razionale devo trovare il punto di trim iniziale per ricalcolare il parametro di trim
Point3d ptStart ;
if( m_bRat)
if ( m_bRat)
GetPointD1D2( dUStartTrim, ptStart) ;
// trim finale
if ( ! TrimEndAtParam( dUEndTrim))
return false ;
// trim iniziale con il parametro opportunamente ricalcolato
double dNewUStartTrim ;
if( m_bRat)
if ( m_bRat)
GetParamAtPoint( ptStart, dNewUStartTrim) ;
else
dNewUStartTrim = dUStartTrim / dUEndTrim ;
//trim iniziale
if( ! TrimStartAtParam( dNewUStartTrim))
if ( ! TrimStartAtParam( dNewUStartTrim))
return false ;
return true ;
@@ -1860,7 +1860,7 @@ CurveBezier::TrimStartAtLen( double dLenTrim)
return false ;
// utilizzo il trim sui parametri
if( ! TrimStartAtParam( dUTrim))
if ( ! TrimStartAtParam( dUTrim))
return false ;
return true ;
@@ -1883,7 +1883,7 @@ CurveBezier::TrimEndAtLen( double dLenTrim)
return false ;
// utilizzo il trim sui parametri
if( ! TrimEndAtParam( dUTrim))
if ( ! TrimEndAtParam( dUTrim))
return false ;
return true ;
@@ -2377,10 +2377,10 @@ CurveBezier::MakeNonRational( double dTol)
Point3d ptCen = iccInfo.IciA[0].ptI ;
// se sia l'inizio che la fine della curva distano uguale dal punto di intersezione tra i due assi trovati allora la curva è un arco di circonferenza
if( abs(Dist( pt0, ptCen) - Dist( pt3, ptCen)) < EPS_SMALL) {
if ( abs(Dist( pt0, ptCen) - Dist( pt3, ptCen)) < EPS_SMALL) {
PtrOwner<ICurveBezier> pNew ( ApproxArcCurveBezierWithSingleCubic( this, ptCen, vtN)) ;
if( IsNull( pNew) || ! pNew->IsValid())
if ( IsNull( pNew) || ! pNew->IsValid())
return false ;
Init( 3, false) ;
for ( int i = 0 ; i < 3 ; ++i)
@@ -2412,7 +2412,7 @@ CurveBezier::MakeNonRational( double dTol)
Point3d pt ; pNewBez->GetPointD1D2( double( p) / nDeg, pt) ;
Vector3d vDiff = vPntSampling[p] - pt ;
double dErrLoc = vDiff.Len() ;
if( dErrLoc > dErrMax)
if ( dErrLoc > dErrMax)
dErrMax = dErrLoc ;
// aggiorno il vettore dei punti di controllo della nuova curva
vPntCtrl[p] += vDiff ;
@@ -2456,7 +2456,7 @@ CurveBezier::IsALine( void) const
Point3d ptCtrl = GetControlPoint( i) ;
DistPointLine dpl( ptCtrl, ptStart, ptEnd) ;
double dDist = 0 ; dpl.GetDist( dDist) ;
if( dDist > EPS_SMALL)
if ( dDist > EPS_SMALL)
return false ;
}
return true ;
DistPointSurfBz.cpp
+1 -1
View File
@@ -55,7 +55,7 @@ DistPointSurfBz::Calculate( const Point3d& ptP, const ISurfBezier& srfBz)
//salvo il punto corrispondente nel parametrico
srfBz.UnprojectPointFromStm( nT, ptMinTm, m_ptParam) ;
// salvo il punto a minima distanza sulla superficie e la normale alla superficie in quel punto
srfBz.GetPointNrmD1D2( m_ptParam.x / SBZ_TREG_COEFF, m_ptParam.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, m_ptMinDistPoint, m_vtN) ;
srfBz.GetPointNrmD1D2( m_ptParam.x, m_ptParam.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, m_ptMinDistPoint, m_vtN) ;
// salvo la distanza minima
m_dDist = Dist( ptP, m_ptMinDistPoint) ;
EgtGeomKernel.rc
BIN
View File
Binary file not shown.
GeomDB.cpp
+6 -4
View File
@@ -38,16 +38,18 @@ using namespace std ;
class LockAddErase
{
public :
LockAddErase( atomic_flag& bAddEraseOn, bool bUse = true): m_bAddEraseOn( bAddEraseOn), m_bUse( bUse)
LockAddErase( atomic_flag& bAddEraseOn, bool bUse = true)
: m_bAddEraseOn( bAddEraseOn), m_bUse( bUse)
{ if ( ! m_bUse) return ;
while ( m_bAddEraseOn.test_and_set()) {
this_thread::sleep_for( chrono::nanoseconds{ 1}) ;
while ( m_bAddEraseOn.test_and_set( memory_order_acquire)) {
m_bAddEraseOn.wait( true, memory_order_relaxed) ;
}
} ;
~LockAddErase( void)
{ if ( ! m_bUse) return ;
m_bAddEraseOn.clear() ;
m_bAddEraseOn.clear( memory_order_release) ;
m_bAddEraseOn.notify_one() ;
} ;
private :
IntersCurveCurve.cpp
+42
View File
@@ -291,6 +291,24 @@ IntersCurveCurve::GetIntersCount( void)
return m_nIntersCount ;
}
//----------------------------------------------------------------------------
int
IntersCurveCurve::GetInters3DCount( void)
{
int nCount = 0 ;
for( int i = 0 ; i < m_nIntersCount ; ++i) {
if( ! m_Info[i].bOverlap || ( m_Info[i].bOverlap && m_Info[i].bCBOverEq)) {
if ( abs( m_Info[i].IciA[0].ptI.z - m_Info[i].IciB[0].ptI.z) < EPS_SMALL)
++nCount ;
}
else {
if ( abs( m_Info[i].IciA[0].ptI.z - m_Info[i].IciB[1].ptI.z) < EPS_SMALL)
++nCount ;
}
}
return nCount ;
}
//----------------------------------------------------------------------------
int
IntersCurveCurve::GetCrossIntersCount( void)
@@ -340,6 +358,30 @@ IntersCurveCurve::GetIntCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo)
return true ;
}
//----------------------------------------------------------------------------
bool
IntersCurveCurve::GetInt3DCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo)
{
if ( nInd < 0 || nInd >= GetInters3DCount())
return false ;
int nCount = - 1 ;
for( int i = 0 ; i < m_nIntersCount ; ++i) {
if( ! m_Info[i].bOverlap || ( m_Info[i].bOverlap && m_Info[i].bCBOverEq)) {
if ( abs( m_Info[i].IciA[0].ptI.z - m_Info[i].IciB[0].ptI.z) < EPS_SMALL)
++nCount ;
}
else {
if ( abs( m_Info[i].IciA[0].ptI.z - m_Info[i].IciB[1].ptI.z) < EPS_SMALL)
++nCount ;
}
if( nCount == nInd) {
aInfo = m_Info[nInd] ;
return true ;
}
}
return false ;
}
//----------------------------------------------------------------------------
bool
IntersCurveCurve::GetIntersPointNearTo( int nCrv, const Point3d& ptNear, Point3d& ptI)
IntersCurvePlane.cpp
+17 -18
View File
@@ -63,11 +63,11 @@ IntersCurvePlane::IntersCurvePlane( const ICurve& Curve, const Point3d& ptOrig,
pCalcCrv = m_pCurve ;
m_Info.clear() ;
if( pCalcCrv->GetType() == CRV_LINE) {
if ( pCalcCrv->GetType() == CRV_LINE) {
CalcIntersLinePlane( m_plPlane, *pCalcCrv) ;
}
else if( pCalcCrv->GetType() == CRV_COMPO){
for( int i = 0 ; i < GetBasicCurveComposite( pCalcCrv)->GetCurveCount(); ++i) {
else if ( pCalcCrv->GetType() == CRV_COMPO){
for ( int i = 0 ; i < GetBasicCurveComposite( pCalcCrv)->GetCurveCount(); ++i) {
const ICurve& subCurve = *GetBasicCurveComposite( pCalcCrv)->GetCurve( i) ;
CalcIntersLinePlane( m_plPlane, subCurve, i) ;
}
@@ -82,7 +82,7 @@ IntersCurvePlane::IntersCurvePlane( const ICurve& Curve, const Point3d& ptOrig,
bool
IntersCurvePlane::CalcIntersLinePlane( const Plane3d& plPlane, const ICurve& Curve, int nCrv)
{
if( Curve.GetType() != CRV_LINE)
if ( Curve.GetType() != CRV_LINE)
return false ;
Point3d ptStart ; Curve.GetStartPoint( ptStart) ;
Point3d ptEnd ; Curve.GetEndPoint( ptEnd) ;
@@ -90,7 +90,7 @@ IntersCurvePlane::CalcIntersLinePlane( const Plane3d& plPlane, const ICurve& Cur
double dLen = 0 ; Curve.GetLength( dLen) ;
int nIntersType = IntersLinePlane( ptStart, ptEnd, m_plPlane, ptInt, true) ;
// intersezione con attraversamento
if( nIntersType == ILPT_YES) {
if ( nIntersType == ILPT_YES) {
IntCrvPlnInfo icpi ;
icpi.Ici[0].ptI = ptInt ;
icpi.Ici[0].dU = Dist( ptInt, ptStart) / dLen + nCrv ;
@@ -100,17 +100,17 @@ IntersCurvePlane::CalcIntersLinePlane( const Plane3d& plPlane, const ICurve& Cur
m_Info.push_back( icpi) ;
}
// intersezione con tocco
else if( nIntersType == ILPT_START || nIntersType == ILPT_END) {
else if ( nIntersType == ILPT_START || nIntersType == ILPT_END) {
IntCrvPlnInfo icpi ;
icpi.Ici[0].ptI = ptInt ;
icpi.Ici[0].dU = nIntersType == ILPT_START ? 0 : 1 + nCrv ;
if( nIntersType == ILPT_START) {
if ( nIntersType == ILPT_START) {
Vector3d vtPos = ptEnd - m_plPlane.GetPoint() ;
icpi.Ici[0].nNextTy = vtPos * m_plPlane.GetVersN() > 0 ? ICPT_OUT : ICPT_IN ;
icpi.Ici[0].nPrevTy = ICPT_NULL ;
}
else{
else {
Vector3d vtPos = ptStart - m_plPlane.GetPoint() ;
icpi.Ici[0].nPrevTy = vtPos * m_plPlane.GetVersN() > 0 ? ICPT_OUT : ICPT_IN ;
icpi.Ici[0].nNextTy = ICPT_NULL ;
@@ -118,7 +118,7 @@ IntersCurvePlane::CalcIntersLinePlane( const Plane3d& plPlane, const ICurve& Cur
m_Info.push_back( icpi) ;
}
// intersezione con sovrapposizione
else if( nIntersType == ILPT_INPLANE) {
else if ( nIntersType == ILPT_INPLANE) {
IntCrvPlnInfo icpi ;
icpi.bOverlap = true ;
icpi.Ici[0].ptI = ptStart ;
@@ -139,22 +139,22 @@ IntersCurvePlane::CalcIntersLinePlane( const Plane3d& plPlane, const ICurve& Cur
void
IntersCurvePlane::OrderAndCompleteIntersections()
{
if( m_Info.size() < 2)
if ( m_Info.size() < 2)
return ;
// cancello le interesezioni puntuali adiacenti a tratti di sovrapposizione
// riempio le info PrevTy e NexyTy
sort( m_Info.begin(), m_Info.end(), []( IntCrvPlnInfo& icpA, IntCrvPlnInfo& icpB) { return icpA.Ici[0].dU < icpA.Ici[0].dU ;}) ;
for( int curr = m_Info.size() - 1 ; curr > - 1 ; --curr) {
for ( int curr = m_Info.size() - 1 ; curr > - 1 ; --curr) {
int prev = curr == 0 ? m_Info.size() - 1 : curr - 1 ;
int next = curr == m_Info.size() - 1 ? 0 : curr + 1 ;
bool bErasedCurr = false ;
// solo le intersezioni di sovrapposizione o puntuali sullo start o end delle curve possono avere il PrevTy o NextTy non definito
if( ! m_Info[curr].bOverlap) {
if ( ! m_Info[curr].bOverlap) {
if ( m_Info[curr].Ici[0].nPrevTy == ICPT_NULL) {
if( ! m_Info[prev].bOverlap) {
if ( ! m_Info[prev].bOverlap) {
m_Info[curr].Ici[0].nPrevTy = m_Info[prev].Ici[0].nNextTy ;
// se ho due puntuali che coincidono cancello il successivo tra i due ( corrente)
if( AreSamePointApprox( m_Info[curr].Ici[0].ptI, m_Info[prev].Ici[0].ptI)) {
if ( AreSamePointApprox( m_Info[curr].Ici[0].ptI, m_Info[prev].Ici[0].ptI)) {
m_Info.erase(m_Info.begin() + curr) ;
bErasedCurr = true ;
}
@@ -167,7 +167,7 @@ IntersCurvePlane::OrderAndCompleteIntersections()
}
}
if ( ! bErasedCurr && m_Info[curr].Ici[0].nNextTy == ICPT_NULL){
if( ! m_Info[prev].bOverlap)
if ( ! m_Info[prev].bOverlap)
m_Info[curr].Ici[0].nNextTy = m_Info[next].Ici[0].nPrevTy ;
// se ho un'intersezione puntuale che in realtà è la fine di un tratto di sovrapposizione, la cancello
else {
@@ -178,13 +178,13 @@ IntersCurvePlane::OrderAndCompleteIntersections()
}
else {
if ( m_Info[curr].Ici[0].nPrevTy == ICPT_NULL) {
if( ! m_Info[prev].bOverlap)
if ( ! m_Info[prev].bOverlap)
m_Info[curr].Ici[0].nPrevTy = m_Info[prev].Ici[0].nNextTy ;
else
m_Info[curr].Ici[0].nPrevTy = m_Info[prev].Ici[1].nNextTy ;
}
if ( m_Info[curr].Ici[1].nNextTy == ICPT_NULL) {
if( ! m_Info[next].bOverlap)
if ( ! m_Info[next].bOverlap)
m_Info[curr].Ici[0].nNextTy = m_Info[prev].Ici[0].nPrevTy ;
else
m_Info[curr].Ici[0].nNextTy = m_Info[prev].Ici[1].nPrevTy ;
@@ -194,7 +194,6 @@ IntersCurvePlane::OrderAndCompleteIntersections()
m_nIntersCount = m_Info.size() ;
}
//----------------------------------------------------------------------------
bool
IntersCurvePlane::IsArcToApprox( const ICurve& Curve)
IntersLineBox.cpp
+17 -5
View File
@@ -113,7 +113,7 @@ IntersLineBox( const Point3d& ptL, const Vector3d& vtL, double dLen, const BBox3
double dU1, dU2 ;
bool bInters = IntersLineBox( ptL, vtL, b3Box.GetMin(), b3Box.GetMax(), dU1, dU2) ;
// Se non c'è intersezione
// Se non c'è intersezione
if ( ! bInters || ( bFinite && ( dU1 > dLen + EPS_SMALL || dU2 < -EPS_SMALL)))
return true ;
@@ -144,8 +144,14 @@ IntersLineBox( const Point3d& ptL, const Vector3d& vtL, double dLen, const BBox3
else if ( dU2 < EPS_SMALL)
vInters.emplace_back( ILBT_OUT, 0) ;
else {
vInters.emplace_back( ILBT_TG_INI, Clamp( dU1, 0., dLen)) ;
vInters.emplace_back( ILBT_TG_FIN, Clamp( dU2, 0., dLen)) ;
if ( dU1 < - EPS_SMALL)
vInters.emplace_back( ILBT_TG_INSIDE, 0.) ;
else
vInters.emplace_back( ILBT_TG_INI, Clamp( dU1, 0., dLen)) ;
if ( dU2 > dLen + EPS_SMALL)
vInters.emplace_back( ILBT_TG_INSIDE, dLen) ;
else
vInters.emplace_back( ILBT_TG_FIN, Clamp( dU2, 0., dLen)) ;
}
}
return true ;
@@ -162,8 +168,14 @@ IntersLineBox( const Point3d& ptL, const Vector3d& vtL, double dLen, const BBox3
else if ( dU2 < EPS_SMALL)
vInters.emplace_back( ILBT_OUT, 0) ;
else {
vInters.emplace_back( ILBT_IN, Clamp( dU1, 0., dLen)) ;
vInters.emplace_back( ILBT_OUT, Clamp( dU2, 0., dLen)) ;
if ( dU1 < - EPS_SMALL)
vInters.emplace_back( ILBT_INSIDE, 0.) ;
else
vInters.emplace_back( ILBT_IN, Clamp( dU1, 0., dLen)) ;
if ( dU2 > dLen + EPS_SMALL)
vInters.emplace_back( ILBT_INSIDE, dLen) ;
else
vInters.emplace_back( ILBT_OUT, Clamp( dU2, 0., dLen)) ;
}
}
return true ;
IntersLineSurfBez.cpp
+35 -36
View File
@@ -34,7 +34,6 @@ RefineIntersNewton( const Point3d& ptL, const Vector3d& vtL, double dLen, bool b
const ISurfBezier* pSurfBz, Point3d& ptSP, Point3d& ptIBz)
{
// la funzione raffina la posisione del punto ptSP, minimizzando la distanza dalla retta e restituisce il punto di intersezione ptIBz
pSurfBz->GetPointD1D2( ptSP.x / SBZ_TREG_COEFF, ptSP.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz) ;
// usando un algoritmo di newton cerco di avvicinarmi il più possibile alla retta
DistPointLine dpl( ptIBz, ptL, vtL, dLen, bFinite) ;
double dDistNew = 0, dDistPre = 0 ;
@@ -48,18 +47,18 @@ RefineIntersNewton( const Point3d& ptL, const Vector3d& vtL, double dLen, bool b
while ( dDistNew > EPS_SMALL && nCount < 100) {
dDistPre = dDistNew ;
Point3d ptIBzNew1 ;
pSurfBz->GetPointD1D2( ( ptSP.x + dh) / SBZ_TREG_COEFF, ptSP.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew1) ;
pSurfBz->GetPointD1D2( ( ptSP.x + dh), ptSP.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew1) ;
DistPointLine dplNewU( ptIBzNew1, ptL, vtL, dLen, bFinite) ;
dplNewU.GetDist( dDistNew) ;
double dfdU = ( dDistNew - dDistPre) / dh ;
Point3d ptIBzNew2 ;
pSurfBz->GetPointD1D2( ptSP.x / SBZ_TREG_COEFF, ( ptSP.y + dh) / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew2) ;
pSurfBz->GetPointD1D2( ptSP.x, ( ptSP.y + dh), ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew2) ;
DistPointLine dplNewV( ptIBzNew2, ptL, vtL, dLen, bFinite) ;
dplNewV.GetDist( dDistNew) ;
double dfdV = ( dDistNew - dDistPre) / dh ;
// mi avvicino cercando di annullare la distanza in un colpo solo
double dr = - dDistPre / ( dfdU + dfdV) ;
pSurfBz->GetPointD1D2(( ptSP.x + dr * dfdU) / SBZ_TREG_COEFF, ( ptSP.y + dr * dfdV) / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz) ;
pSurfBz->GetPointD1D2(( ptSP.x + dr * dfdU), ( ptSP.y + dr * dfdV), ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz) ;
DistPointLine dplNew( ptIBz, ptL, vtL, dLen, bFinite) ;
dplNew.GetDist( dDistNew) ;
++ nCount ;
@@ -143,12 +142,12 @@ IntersLineSurfBz( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
pSurfTm->GetTriangle( InfoTm.nT, nVert) ;
double dU0, dV0 ;
pSurfTm->GetVertexParam( nVert[0], dU0, dV0) ;
ptSP = ptSP + Point3d(dU0, dV0, 0) ;
ptSP = ptSP + Point3d( dU0, dV0, 0) ;
if ( ! RefineIntersNewton( ptL,vtL, dLen, bFinite, pSurfBz, ptSP, ptIBz))
return false ;
}
Vector3d vtN ;
pSurfBz->GetPointNrmD1D2(ptSP.x / SBZ_TREG_COEFF, ptSP.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz, vtN) ;
pSurfBz->GetPointNrmD1D2(ptSP.x, ptSP.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz, vtN) ;
double dCos = vtN * vtL ;
double dCos2 = 0 ;
// eventualmente ripeto tutto per ptI2 ( se ho un'intersezione con sovrapposizione)
@@ -163,7 +162,7 @@ IntersLineSurfBz( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
if ( ! RefineIntersNewton( ptL,vtL, dLen, bFinite, pSurfBz, ptSP, ptIBz))
return false ;
}
pSurfBz->GetPointNrmD1D2( ptSP2.x / SBZ_TREG_COEFF, ptSP2.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz2, vtN) ;
pSurfBz->GetPointNrmD1D2( ptSP2.x, ptSP2.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz2, vtN) ;
dCos2 = vtN * vtL ;
}
UpdateInfoIntersLineSurfBz( ptL, vtL, InfoTm.nILTT, InfoTm.nT, ptSP, ptIBz, dCos, ptSP2, ptIBz2, dCos2, vInfo) ;
@@ -251,13 +250,13 @@ IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen,
pSurfBz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bRat, bTrimmed) ;
// funzione pensata per funzionare solo con una monopatch bilineare
if( nDegU > 1 || nDegV > 1 || nSpanU > 1 || nSpanV > 1 || bRat)
if ( nDegU > 1 || nDegV > 1 || nSpanU > 1 || nSpanV > 1 || bRat)
return false ;
int nInters = int( vInfo.size()) ;
PNTVECTOR vPntCtrl ;
for( int p = 0 ; p < 4 ; ++p) {
for ( int p = 0 ; p < 4 ; ++p) {
bool bOk = false ;
vPntCtrl.push_back( pSurfBz->GetControlPoint( p, &bOk)) ;
}
@@ -281,14 +280,14 @@ IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen,
vdCoeff = { (B2 * D1 - B1 * D2), ( A2 * D1 - A1 * D2 + B2 * C1 - B1 * C2), ( A2 * C1 - A1 * C2)} ;
int nRoots = PolynomialRoots( 2, vdCoeff, vdRoots) ;
bool bFound = false ;
for( int w = 0 ; w < nRoots ; ++w) {
for ( int w = 0 ; w < nRoots ; ++w) {
if ( vdRoots[w] > 0 - EPS_ZERO && vdRoots[w] < 1 + EPS_ZERO ) {
double dU = 0, dV = vdRoots[w] ;
// verifico che non sia una soluzione con molteplicità > 1
bool bAlreadyFound = false ;
for ( int k = w - 1 ; k >= 0 && ! bAlreadyFound ; --k)
bAlreadyFound = abs( dV - vdRoots[k]) < EPS_PARAM ;
if( ! bAlreadyFound) {
if ( ! bAlreadyFound) {
dU = (dV * (C1 - C2) + ( D1 - D2)) / ( dV * ( A2 - A1) + ( B2 - B1)) ;
if ( dU > - EPS_ZERO && dU < 1 + EPS_ZERO) {
Point3d ptIBez, ptIBez2 ;
@@ -305,14 +304,14 @@ IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen,
// se tutti i coefficienti sono zero allora potrei avere una linea che giace sulla superficie
// per trovare i punti di inizio e fine sovrapposizione trovo i punti a minima distanza tra la linea e gli edge della superficie
if( ! bFound && abs( vdCoeff[0]) < EPS_ZERO && abs( vdCoeff[1]) < EPS_ZERO && abs( vdCoeff[2]) < EPS_ZERO) {
if ( ! bFound && abs( vdCoeff[0]) < EPS_ZERO && abs( vdCoeff[1]) < EPS_ZERO && abs( vdCoeff[2]) < EPS_ZERO) {
ICRVCOMPOPOVECTOR vCrvEdge( 4) ;
vCrvEdge[0].Set(pSurfBz->GetCurveOnU( 0)) ;
vCrvEdge[1].Set(pSurfBz->GetCurveOnV( 1)) ;
vCrvEdge[2].Set(pSurfBz->GetCurveOnU( 1)) ;
vCrvEdge[3].Set(pSurfBz->GetCurveOnV( 0)) ;
double dAngTolDeg = 5 ;
for( int i = 0 ; i < 4 ; ++i) {
for ( int i = 0 ; i < 4 ; ++i) {
PolyLine plApprox ; vCrvEdge[0]->ApproxWithLines( EPS_SMALL, dAngTolDeg, ICurve::ApprLineType::APL_STD, plApprox) ;
//CurveComposite cCC ;
//cCC.FromPolyLine( plApprox) ;
@@ -322,7 +321,7 @@ IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen,
Point3d ptClosest ;
int c = 0 ;
int nTot = plApprox.GetPointNbr() ;
for( int j = 0 ; j < nTot ; ++j) {
for ( int j = 0 ; j < nTot ; ++j) {
DistPointLine dpl( pt, ptL, vtL, dLen, bFinite) ;
double dDist = INFINITO ;
dpl.GetDist( dDist) ;
@@ -339,7 +338,7 @@ IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen,
// tra i due tratti dell'approssimazione che arrivano al punto selezionato come più vicino, devo trovare quale si avvicina di più
Point3d ptStart ; plApprox.GetFirstPoint( ptStart) ;
Point3d ptEnd ;
for( int z = 1 ; z < nClosestLine - 1 ; ++z)
for ( int z = 1 ; z < nClosestLine - 1 ; ++z)
plApprox.GetNextPoint( ptStart) ;
plApprox.GetNextPoint( ptEnd) ;
// linea precedente al punto
@@ -357,12 +356,12 @@ IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen,
double dDistCurr = INFINITO ;
dllCurr.GetDist( dDistCurr) ;
if( dDistPre < dDistCurr)
if ( dDistPre < dDistCurr)
dllPre.GetMinDistPoints( ptInt1, ptInt2) ;
else
dllCurr.GetMinDistPoints( ptInt1, ptInt2) ;
}
else if ( nClosestLine == 0){
else if ( nClosestLine == 0) {
// il punto più vicino è sulla prima linea
Point3d ptStart ; plApprox.GetFirstPoint( ptStart) ;
Point3d ptEnd ; plApprox.GetNextPoint( ptEnd) ;
@@ -375,7 +374,7 @@ IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen,
// il punto più vicino è sull'ultima linea
Point3d ptStart ; plApprox.GetFirstPoint( ptStart) ;
Point3d ptEnd ;
for( int z = 1 ; z < nClosestLine - 1 ; ++z)
for ( int z = 1 ; z < nClosestLine - 1 ; ++z)
plApprox.GetNextPoint( ptStart) ;
plApprox.GetNextPoint( ptEnd) ;
Vector3d vtLinePre = ptEnd - ptStart ;
@@ -386,23 +385,23 @@ IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen,
double dU1 = 0, dV1 = 0, dU2 = 0, dV2 = 0 ;
// se ho trovato due punti vuol dire che la linea coincide con un edge e ho trovato tutto quello che serve
if( ! AreSamePointExact( ptInt2, ORIG)) {
if( i == 0) {
if ( ! AreSamePointExact( ptInt2, ORIG)) {
if ( i == 0) {
//dV1 = 0 ; dV2 = 0 ;
vCrvEdge[0]->GetParamAtPoint( ptInt1, dU1) ;
vCrvEdge[0]->GetParamAtPoint( ptInt2, dU2) ;
}
else if( i == 1) {
else if ( i == 1) {
//dU1 = 1 ; dU2 = 1 ;
vCrvEdge[1]->GetParamAtPoint( ptInt1, dV1) ;
vCrvEdge[1]->GetParamAtPoint( ptInt2, dV2) ;
}
else if( i == 2){
else if ( i == 2){
//dV1 = 1 ; dV2 = 1 ;
vCrvEdge[2]->GetParamAtPoint( ptInt1, dU1) ;
vCrvEdge[2]->GetParamAtPoint( ptInt2, dU2) ;
}
else if( i == 3){
else if ( i == 3){
//dU1 = 0 ; dU2 = 0 ;
vCrvEdge[3]->GetParamAtPoint( ptInt1, dV1) ;
vCrvEdge[3]->GetParamAtPoint( ptInt2, dV2) ;
@@ -417,11 +416,11 @@ IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen,
double dCos2 = vtN2 * vtL ;
// se avevo già trovato un punto singolo che coincide col primo punto di questa intersezione sovrapposta, allora cancello l'intersezione singola che
// avevo salvato e aggiungo quella sovrapposto che ho trovato ora
if( bFound) {
if ( bFound) {
int nNewTot = int(vInfo.size()) ;
int nNewInters = nNewTot - nInters ;
bool bAlreadyFound = false ;
for( int i = 0 ; i < nNewInters ; ++i) {
for ( int i = 0 ; i < nNewInters ; ++i) {
bAlreadyFound = AreSamePointApprox(vInfo[nNewTot - i].ptUV, ptSP1) || AreSamePointApprox(vInfo[nNewTot - i].ptUV, ptSP2) ;
if ( bAlreadyFound) {
vInfo.erase( vInfo.begin() + nNewTot - i) ;
@@ -434,32 +433,32 @@ IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen,
break ;
}
// se ho trovato un punto a distanza zero dalla linea allora ho trovato l'intersezione
else if( dMinDist < EPS_SMALL) {
if( i == 0) {
else if ( dMinDist < EPS_SMALL) {
if ( i == 0) {
//dV1 = 0 ;
vCrvEdge[0]->GetParamAtPoint( ptInt1, dU1) ;
}
else if( i == 1) {
else if ( i == 1) {
//dU1 = 1 ;
vCrvEdge[1]->GetParamAtPoint( ptInt1, dV1) ;
}
else if( i == 2){
else if ( i == 2) {
//dV1 = 1 ;
vCrvEdge[2]->GetParamAtPoint( ptInt1, dU1) ;
}
else if( i == 3){
else if ( i == 3) {
//dU1 = 0 ;
vCrvEdge[3]->GetParamAtPoint( ptInt1, dV1) ;
}
Point3d ptSP1( dU1, dV1, 0), ptSP2 ;
// se avevo trovato già altri punti controllo di non essere esattamente su una diagonale ( e quindi avere un'intersezione con ogni edge, ma due sono doppie)
if( bFound) {
if ( bFound) {
int nNewTot = int(vInfo.size()) ;
int nNewInters = nNewTot - nInters ;
bool bAlreadyFound = false ;
for( int i = 0 ; i < nNewInters ; ++i)
for ( int i = 0 ; i < nNewInters ; ++i)
bAlreadyFound = AreSamePointApprox(vInfo[nNewTot - i].ptUV, ptSP1) ;
if( bAlreadyFound)
if ( bAlreadyFound)
continue ;
}
@@ -474,16 +473,16 @@ IntersLineSurfBzBilinear( const Point3d& ptL, const Vector3d& vtL, double dLen,
}
// se la superficie è trimmed verifico che i punti trovati siano all'interno del parametrico trimmato
if( bTrimmed && bFound) {
if ( bTrimmed && bFound) {
int nNewTot = int(vInfo.size()) ;
int nNewInters = nNewTot - nInters ;
const ISurfFlatRegion* pFRTrim = pSurfBz->GetTrimRegion() ;
for( int i = 0 ; i < nNewInters ; ++i) {
for ( int i = 0 ; i < nNewInters ; ++i) {
Point3d ptTest = vInfo[nNewTot - i].ptUV * SBZ_TREG_COEFF ;
bool bInside = false ;
double dDist = INFINITO ;
IsPointInsideSurfFr( ptTest, pFRTrim, dDist, bInside) ;
if( ! bInside)
if ( ! bInside)
vInfo.erase( vInfo.begin() + nNewTot - i) ;
}
}
IntersLineSurfStd.cpp
+1 -1
View File
@@ -1662,7 +1662,7 @@ LineTorus( const Point3d& ptLine, const Vector3d& vtLine,
// Riordino le soluzioni
for ( int ni = 0 ; ni < int( vdPar.size()) - 1 ; ++ ni) {
for ( int nj = ni ; nj < int( vdPar.size()) ; ++ nj) {
if( vdPar[ni] > vdPar[nj]) {
if ( vdPar[ni] > vdPar[nj]) {
swap( vdPar[ni], vdPar[nj]) ;
}
}
IntersPlaneVolZmap.cpp
+1 -4
View File
@@ -19,7 +19,7 @@
using namespace std ;
//----------------------------------------------------------------------------
// Intersezione di unpiano con la superficie di un solido VolZmap
// Intersezione di un piano con la superficie di un solido VolZmap
//----------------------------------------------------------------------------
bool
IntersPlaneVolZmap( const Plane3d& plPlane, const IVolZmap& Vzm, ICURVEPOVECTOR& vpLoop)
@@ -28,9 +28,6 @@ IntersPlaneVolZmap( const Plane3d& plPlane, const IVolZmap& Vzm, ICURVEPOVECTOR&
const VolZmap* pVzm = GetBasicVolZmap( &Vzm) ;
if ( pVzm == nullptr)
return false ;
// verifico parametro di ritorno
if ( &vpLoop == nullptr)
return false ;
// eseguo intersezione
return pVzm->GetPlaneIntersection( plPlane, vpLoop) ;
PolyLine.cpp
+1 -1
View File
@@ -1974,7 +1974,7 @@ MatchPolyLinesAddingPoints( const PolyLine& PL1, const PolyLine& PL2, int nType,
for ( int z = int( vbRep2.size()) - 1 ; z >= nCrv2 ; --z)
vbRep2[z] = true ;
}
if( nCrv1 < nPnt1) {
if ( nCrv1 < nPnt1) {
nRep1 += nPnt1 - nCrv1 ;
for ( int z = int( vbRep1.size()) - 1 ; z >= nCrv1 ; --z)
vbRep1[z] = true ;
ProjectCurveSurf.cpp
+212 -180
View File
@@ -59,6 +59,77 @@ PointsInTolerance( const PNT5AXVECTOR& vPt5ax, int nPrec, int nCurr, int nNext,
return true ;
}
//----------------------------------------------------------------------------
static bool
AddPointsOnCorners( PNT5AXVECTOR& vPt5ax)
{
for ( int i = 1 ; i < ssize( vPt5ax) ; ++ i) {
// precedente
int j = i - 1 ;
// se normali tra corrente e precedente oltre limite e punti abbastanza lontani
if ( vPt5ax[i].vtDir1 * vPt5ax[j].vtDir1 < COS_ANG_MAX_CORNER &&
SqDist( vPt5ax[i].ptP, vPt5ax[j].ptP) > 25 * SQ_EPS_SMALL) {
// intersezione tra le due facce
Plane3d plPlane1 ; plPlane1.Set( vPt5ax[j].ptP, vPt5ax[j].vtDir1) ;
Plane3d plPlane2 ; plPlane2.Set( vPt5ax[i].ptP, vPt5ax[i].vtDir1) ;
Point3d ptEdge ; Vector3d vtEdge ;
if ( IntersPlanePlane( plPlane1, plPlane2, ptEdge, vtEdge) == IPPT_YES) {
Plane3d plPlane3 ; plPlane3.Set(vPt5ax[i].ptP, (vPt5ax[i].ptP - vPt5ax[j].ptP) ^ ( vPt5ax[i].vtDir1 + vPt5ax[j].vtDir1)) ;
Point3d ptInt ;
if ( IntersLinePlane( ptEdge, vtEdge, 1, plPlane3, ptInt, false) == ILPT_YES) {
// verifico se spigolo convesso o concavo
bool bConvex ;
if ( ! AreSamePointApprox( ptInt, vPt5ax[j].ptP))
bConvex = ( ( vPt5ax[j].vtDir1 ^ ( ptInt - vPt5ax[j].ptP)) * vtEdge > 0) ;
else
bConvex = (( vPt5ax[i].vtDir1 ^ ( ptInt - vPt5ax[i].ptP)) * vtEdge < 0) ;
// se convesso, metto due punti con direzione appena prima e appena dopo
if ( bConvex) {
Vector3d vtLine1 = ptInt - vPt5ax[j].ptP ; double dLen1 = vtLine1.Len() ;
Vector3d vtLine2 = vPt5ax[i].ptP - ptInt ; double dLen2 = vtLine2.Len() ;
if ( dLen1 > 2 * EPS_SMALL) {
Point5ax Pt5ax ;
Pt5ax.ptP = ptInt - vtLine1 / dLen1 * 2 * EPS_SMALL ;
Pt5ax.vtDir1 = vPt5ax[j].vtDir1 ;
Pt5ax.vtDir2 = vPt5ax[j].vtDir2 ;
Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
Pt5ax.nFlag = P5AX_CVEX ;
vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
++ i ;
}
else
vPt5ax[j].nFlag = P5AX_CVEX ;
if ( dLen2 > 2 * EPS_SMALL) {
Point5ax Pt5ax ;
Pt5ax.ptP = ptInt + vtLine2 / dLen2 * 2 * EPS_SMALL ;
Pt5ax.vtDir1 = vPt5ax[i].vtDir1 ;
Pt5ax.vtDir2 = vPt5ax[i].vtDir2 ;
Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
Pt5ax.nFlag = P5AX_CVEX ;
vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
++ i ;
}
else
vPt5ax[i].nFlag = P5AX_CVEX ;
}
// altrimenti concavo, aggiungo un solo punto con la direzione media
else {
Point5ax Pt5ax ;
Pt5ax.ptP = ptInt ;
Pt5ax.vtDir1 = Media( vPt5ax[i].vtDir1, vPt5ax[j].vtDir1) ; Pt5ax.vtDir1.Normalize() ;
Pt5ax.vtDir2 = Media( vPt5ax[i].vtDir2, vPt5ax[j].vtDir2) ; Pt5ax.vtDir2.Normalize() ;
Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
Pt5ax.nFlag = P5AX_CONC ;
vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
++ i ;
}
}
}
}
}
return true ;
}
//----------------------------------------------------------------------------
static bool
RemovePointsInExcess( PNT5AXVECTOR& vPt5ax, double dLinTol, double dMaxSegmLen, bool bTestDir)
@@ -70,7 +141,7 @@ RemovePointsInExcess( PNT5AXVECTOR& vPt5ax, double dLinTol, double dMaxSegmLen,
double dCosAngLim = 1 - dSqTol / ( 2 * LENREF * LENREF) ;
// Cerco gli angoli interni e marco opportunamente i punti nelle vicinanze fino ai limiti prima e dopo
int nInd = 0 ;
while ( nInd < int( vPt5ax.size())) {
while ( nInd < ssize( vPt5ax)) {
if ( vPt5ax[nInd].nFlag == P5AX_CONC) {
// analizzo i punti appena precedenti
int nIpv = nInd - 1 ;
@@ -86,7 +157,7 @@ RemovePointsInExcess( PNT5AXVECTOR& vPt5ax, double dLinTol, double dMaxSegmLen,
}
// analizzo i punti appena successivi
int nInx = nInd + 1 ;
while ( nInx < int( vPt5ax.size())) {
while ( nInx < ssize( vPt5ax)) {
double dSqLen = SqDist( vPt5ax[nInd].ptP, vPt5ax[nInx].ptP) ;
if ( dSqLen < dSqMaxLen)
vPt5ax[nInx].nFlag = P5AX_TO_DELETE ;
@@ -104,7 +175,7 @@ RemovePointsInExcess( PNT5AXVECTOR& vPt5ax, double dLinTol, double dMaxSegmLen,
int nPrec = 0 ;
int nCurr = 1 ;
int nNext = 2 ;
while ( nNext < int( vPt5ax.size())) {
while ( nNext < ssize( vPt5ax)) {
bool bRemove = false ;
// lunghezza del segmento che unisce gli adiacenti
double dSqLen = SqDist( vPt5ax[nPrec].ptP, vPt5ax[nNext].ptP) ;
@@ -161,6 +232,121 @@ RemovePointsInExcess( PNT5AXVECTOR& vPt5ax, double dLinTol, double dMaxSegmLen,
return true ;
}
//----------------------------------------------------------------------------
static bool
ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, double dPar, Point5ax& Pt5ax)
{
// punto sulle supefici a minima distanza
int nSurfMin = -1 ;
int nTriaMin ;
Point3d ptMin ;
double dMinDist ;
for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
// punto sulla superficie a minima distanza
DistPointSurfTm dPS( ptP, *vpStm[i]) ;
double dDist ;
if ( dPS.GetDist( dDist) && ( nSurfMin == -1 || dDist < dMinDist)) {
nSurfMin = i ;
dPS.GetMinDistPoint( ptMin) ;
dPS.GetMinDistTriaIndex ( nTriaMin) ;
dMinDist = dDist ;
}
}
// se trovato
if ( nSurfMin >= 0) {
// assegno il punto
Point3d ptInt = ptMin ;
// calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
Triangle3dEx trTria ;
if ( ! vpStm[nSurfMin]->GetTriangle( nTriaMin, trTria))
return false ;
Vector3d vtN ;
if ( ! CalcNormal( ptMin, trTria, vtN))
vtN = trTria.GetN() ;
// assegno valori al punto 5assi
Pt5ax.ptP = ptInt ;
Pt5ax.vtDir1 = vtN ;
Pt5ax.vtDir2 = vtN ;
Pt5ax.dPar = dPar ;
Pt5ax.nFlag = P5AX_STD ;
// ritorno con successo
return true ;
}
return false ;
}
//----------------------------------------------------------------------------
bool
ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf,
double dLinTol, double dMaxSegmLen, bool bSharpEdges, PNT5AXVECTOR& vPt5ax)
{
// sistemazioni per tipo di superficie
CISRFTMPVECTOR vpSurfTm ;
for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
const SurfTriMesh* pSurfTm = nullptr ;
switch ( vpSurf[i]->GetType()) {
case SRF_TRIMESH :
pSurfTm = GetBasicSurfTriMesh( vpSurf[i]) ;
break ;
case SRF_BEZIER :
{ double dOldLinTol = GetSurfBezierAuxSurfRefinedTol() ;
SetSurfBezierAuxSurfRefinedTol( GetSurfBezierTol( dLinTol)) ;
pSurfTm = GetBasicSurfBezier( vpSurf[i])->GetAuxSurfRefined() ;
SetSurfBezierAuxSurfRefinedTol( dOldLinTol) ;
} break ;
case SRF_FLATRGN :
pSurfTm = GetBasicSurfFlatRegion( vpSurf[i])->GetAuxSurf() ;
break ;
default :
break ;
}
if ( pSurfTm == nullptr)
return false ;
vpSurfTm.emplace_back( pSurfTm) ;
}
// controllo le tolleranze
dLinTol = max( dLinTol, LIN_TOL_MIN) ;
dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
// approssimo la curva con una polilinea entro la metà della tolleranza
PolyLine PL ;
if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
return false ;
const double MAX_SEG_LEN = min( dMaxSegmLen, 0.977) ;
if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
return false ;
// Pulisco e riservo spazio nel vettore dei punti risultanti
vPt5ax.clear() ;
vPt5ax.reserve( PL.GetPointNbr()) ;
// proietto i punti della polilinea sulla superficie secondo la direzione di minima distanza
double dPar ;
Point3d ptP ;
bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
while ( bFound) {
// se trovo proiezione, la salvo
Point5ax Pt5ax ;
if ( ProjectPointOnSurf( ptP, vpSurfTm, dPar, Pt5ax))
vPt5ax.emplace_back( Pt5ax) ;
// passo al successivo
bFound = PL.GetNextUPoint( &dPar, &ptP) ;
}
// se richiesto, inserimento punti intermedi in presenza di spigoli
if ( bSharpEdges)
AddPointsOnCorners( vPt5ax) ;
// rimozione punti in eccesso rispetto alle tolleranze
RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
return true ;
}
//----------------------------------------------------------------------------
// --- vettore di oggetti intersezione massiva rette parallele SurfTM --------
typedef std::vector<IntersParLinesSurfTm*> INTPARLINESTMPVECTOR ;
@@ -173,11 +359,11 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const Frame
Point3d ptL = GetToLoc( ptP, frRefLine) ;
int nInd = -1 ;
IntLinStmInfo IntRes ;
for ( int i = 0 ; i < int( vpIntPLSTM.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vpIntPLSTM) ; ++ i) {
ILSIVECTOR vIntRes ;
if ( vpIntPLSTM[i]->GetInters( ptL, 1, vIntRes, false)) {
// cerco la prima intersezione valida a partire dall'ultima (è la più alta)
int nI = int( vIntRes.size()) - 1 ;
int nI = ssize( vIntRes) - 1 ;
while ( nI >= 0 && abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
--nI ;
// se trovata
@@ -231,7 +417,7 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vect
{
// sistemazioni per tipo di superficie
CISRFTMPVECTOR vpSurfTm ;
for ( int i = 0 ; i < int( vpSurf.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
const SurfTriMesh* pSurfTm = nullptr ;
switch ( vpSurf[i]->GetType()) {
case SRF_TRIMESH :
@@ -270,10 +456,10 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vect
if ( ! frRefLine.Set( ORIG, vtDir))
return false ;
INTPARLINESTMPVECTOR vpIntPLSTM ; vpIntPLSTM.reserve( vpSurfTm.size()) ;
for ( int i = 0 ; i < int( vpSurfTm.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vpSurfTm) ; ++ i) {
IntersParLinesSurfTm* pIntPLSTM = new IntersParLinesSurfTm( frRefLine, *vpSurfTm[i]) ;
if ( pIntPLSTM == nullptr) {
for ( int j = 0 ; j < int( vpIntPLSTM.size()) ; ++ j)
for ( int j = 0 ; j < ssize( vpIntPLSTM) ; ++ j)
delete vpIntPLSTM[j] ;
return false ;
}
@@ -298,72 +484,12 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const Vect
}
// Libero oggetti per calcolo massivo
for ( int i = 0 ; i < int( vpIntPLSTM.size()) ; ++ i)
for ( int i = 0 ; i < ssize( vpIntPLSTM) ; ++ i)
delete vpIntPLSTM[i] ;
// se richiesto, inserimento punti intermedi in presenza di spigoli
if ( bSharpEdges) {
for ( int i = 1 ; i < int( vPt5ax.size()) ; ++ i) {
// precedente
int j = i - 1 ;
// se normali tra corrente e precedente oltre limite e punti abbastanza lontani
if ( vPt5ax[i].vtDir1 * vPt5ax[j].vtDir1 < COS_ANG_MAX_CORNER &&
SqDist( vPt5ax[i].ptP, vPt5ax[j].ptP) > 25 * SQ_EPS_SMALL) {
// intersezione tra le due facce
Plane3d plPlane1 ; plPlane1.Set( vPt5ax[j].ptP, vPt5ax[j].vtDir1) ;
Plane3d plPlane2 ; plPlane2.Set( vPt5ax[i].ptP, vPt5ax[i].vtDir1) ;
Point3d ptEdge ; Vector3d vtEdge ;
if ( IntersPlanePlane( plPlane1, plPlane2, ptEdge, vtEdge) == IPPT_YES) {
Plane3d plPlane3 ; plPlane3.Set( vPt5ax[i].ptP, ( vPt5ax[i].ptP - vPt5ax[j].ptP) ^ vtDir) ;
Point3d ptInt ;
if ( IntersLinePlane( ptEdge, vtEdge, 1, plPlane3, ptInt, false) == ILPT_YES) {
// verifico se spigolo convesso o concavo
bool bConvex ;
if ( ! AreSamePointApprox( ptInt, vPt5ax[j].ptP))
bConvex = ( ( vPt5ax[j].vtDir1 ^ ( ptInt - vPt5ax[j].ptP)) * vtEdge > 0) ;
else
bConvex = (( vPt5ax[i].vtDir1 ^ ( ptInt - vPt5ax[i].ptP)) * vtEdge < 0) ;
// se convesso, metto due punti con direzione appena prima e appena dopo
if ( bConvex) {
Vector3d vtLine1 = ptInt - vPt5ax[j].ptP ; double dLen1 = vtLine1.Len() ;
Vector3d vtLine2 = vPt5ax[i].ptP - ptInt ; double dLen2 = vtLine2.Len() ;
if ( dLen1 > 2 * EPS_SMALL) {
Point5ax Pt5ax ;
Pt5ax.ptP = ptInt - vtLine1 / dLen1 * 2 * EPS_SMALL ;
Pt5ax.vtDir1 = vPt5ax[j].vtDir1 ;
Pt5ax.vtDir2 = vtDir ;
Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
Pt5ax.nFlag = P5AX_CVEX ;
vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
++ i ;
}
if ( dLen2 > 2 * EPS_SMALL) {
Point5ax Pt5ax ;
Pt5ax.ptP = ptInt + vtLine2 / dLen2 * 2 * EPS_SMALL ;
Pt5ax.vtDir1 = vPt5ax[i].vtDir1 ;
Pt5ax.vtDir2 = vtDir ;
Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
Pt5ax.nFlag = P5AX_CVEX ;
vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
++ i ;
}
}
// altrimenti concavo, aggiungo un solo punto con la direzione media
else {
Point5ax Pt5ax ;
Pt5ax.ptP = ptInt ;
Pt5ax.vtDir1 = Media( vPt5ax[i].vtDir1, vPt5ax[j].vtDir1) ;
Pt5ax.vtDir2 = vtDir ;
Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
Pt5ax.nFlag = P5AX_CONC ;
vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
++ i ;
}
}
}
}
}
}
if ( bSharpEdges)
AddPointsOnCorners( vPt5ax) ;
// rimozione punti in eccesso rispetto alle tolleranze
RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
@@ -385,11 +511,11 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const IGeoP
// conservo l'intersezione più alta
int nInd = -1 ;
IntLinStmInfo IntRes ;
for ( int i = 0 ; i < int( vpStm.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
ILSIVECTOR vIntRes ;
if ( IntersLineSurfTm( ptP, vtLine, dLineLen, *vpStm[i], vIntRes, false)) {
// cerco la prima intersezione valida a partire dall'ultima (è la più alta)
int nI = int( vIntRes.size()) - 1 ;
int nI = ssize( vIntRes) - 1 ;
while ( nI >= 0 && abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
--nI ;
// se trovata
@@ -444,7 +570,7 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const IGeo
{
// sistemazioni per tipo di superficie
CISRFTMPVECTOR vpSurfTm ;
for ( int i = 0 ; i < int( vpSurf.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
const SurfTriMesh* pSurfTm = nullptr ;
switch ( vpSurf[i]->GetType()) {
case SRF_TRIMESH :
@@ -497,25 +623,8 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const IGeo
}
// se richiesto, inserimento punti intermedi in presenza di spigoli
if ( bSharpEdges) {
for ( int i = 1 ; i < int( vPt5ax.size()) ; ++ i) {
// precedente
int j = i - 1 ;
// se normali tra corrente e precedente oltre limite e punti abbastanza lontani
if ( vPt5ax[i].vtDir1 * vPt5ax[j].vtDir1 < COS_ANG_MAX_CORNER &&
SqDist( vPt5ax[i].ptP, vPt5ax[j].ptP) > 25 * SQ_EPS_SMALL) {
// punto medio
Point3d ptMid = Media( vPt5ax[i].ptP, vPt5ax[j].ptP) ;
double dMid = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
// se trovo proiezione, la salvo
Point5ax Pt5ax ;
if ( ProjectPointOnSurf( ptMid, vpSurfTm, gpRef, dMid, Pt5ax)) {
vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
-- i ;
}
}
}
}
if ( bSharpEdges)
AddPointsOnCorners( vPt5ax) ;
// rimozione punti in eccesso rispetto alle tolleranze
RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
@@ -540,11 +649,11 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const ICurv
// conservo l'intersezione più alta
int nInd = -1 ;
IntLinStmInfo IntRes ;
for ( int i = 0 ; i < int( vpStm.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
ILSIVECTOR vIntRes ;
if ( IntersLineSurfTm( ptP, vtLine, dLineLen, *vpStm[i], vIntRes, false)) {
// cerco la prima intersezione valida a partire dall'ultima (è la più alta)
int nI = int( vIntRes.size()) - 1 ;
int nI = ssize( vIntRes) - 1 ;
while ( nI >= 0 && abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
--nI ;
// se trovata
@@ -600,7 +709,7 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ICur
{
// Sistemazioni per tipo di superficie
CISRFTMPVECTOR vpSurfTm ;
for ( int i = 0 ; i < int( vpSurf.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
const SurfTriMesh* pSurfTm = nullptr ;
switch ( vpSurf[i]->GetType()) {
case SRF_TRIMESH :
@@ -653,68 +762,8 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ICur
}
// se richiesto, inserimento punti intermedi in presenza di spigoli
if ( bSharpEdges) {
for ( int i = 1 ; i < int( vPt5ax.size()) ; ++ i) {
// precedente
int j = i - 1 ;
// se normali tra corrente e precedente oltre limite e punti abbastanza lontani
if ( vPt5ax[i].vtDir1 * vPt5ax[j].vtDir1 < COS_ANG_MAX_CORNER &&
SqDist( vPt5ax[i].ptP, vPt5ax[j].ptP) > 25 * SQ_EPS_SMALL) {
// intersezione tra le due facce
Plane3d plPlane1 ; plPlane1.Set( vPt5ax[j].ptP, vPt5ax[j].vtDir1) ;
Plane3d plPlane2 ; plPlane2.Set( vPt5ax[i].ptP, vPt5ax[i].vtDir1) ;
Point3d ptEdge ; Vector3d vtEdge ;
if ( IntersPlanePlane( plPlane1, plPlane2, ptEdge, vtEdge) == IPPT_YES) {
Plane3d plPlane3 ; plPlane3.Set( vPt5ax[i].ptP, vPt5ax[i].vtDir2 ^ vPt5ax[j].vtDir2) ;
Point3d ptInt ;
if ( IntersLinePlane( ptEdge, vtEdge, 1, plPlane3, ptInt, false) == ILPT_YES) {
// verifico se spigolo convesso o concavo
bool bConvex ;
if ( ! AreSamePointApprox( ptInt, vPt5ax[j].ptP))
bConvex = ( ( vPt5ax[j].vtDir1 ^ ( ptInt - vPt5ax[j].ptP)) * vtEdge > 0) ;
else
bConvex = (( vPt5ax[i].vtDir1 ^ ( ptInt - vPt5ax[i].ptP)) * vtEdge < 0) ;
// se convesso, metto due punti con direzione appena prima e appena dopo
if ( bConvex) {
Vector3d vtLine1 = ptInt - vPt5ax[j].ptP ; double dLen1 = vtLine1.Len() ;
Vector3d vtLine2 = vPt5ax[i].ptP - ptInt ; double dLen2 = vtLine2.Len() ;
if ( dLen1 > 2 * EPS_SMALL) {
Point5ax Pt5ax ;
Pt5ax.ptP = ptInt - vtLine1 / dLen1 * 2 * EPS_SMALL ;
Pt5ax.vtDir1 = vPt5ax[j].vtDir1 ;
Pt5ax.vtDir2 = Media( vPt5ax[i].vtDir2, vPt5ax[j].vtDir2) ;
Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
Pt5ax.nFlag = P5AX_CVEX ;
vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
++ i ;
}
if ( dLen2 > 2 * EPS_SMALL) {
Point5ax Pt5ax ;
Pt5ax.ptP = ptInt + vtLine2 / dLen2 * 2 * EPS_SMALL ;
Pt5ax.vtDir1 = vPt5ax[i].vtDir1 ;
Pt5ax.vtDir2 = Media( vPt5ax[i].vtDir2, vPt5ax[j].vtDir2) ;
Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
Pt5ax.nFlag = P5AX_CVEX ;
vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
++ i ;
}
}
// altrimenti concavo, aggiungo un solo punto con la direzione media
else {
Point5ax Pt5ax ;
Pt5ax.ptP = ptInt ;
Pt5ax.vtDir1 = Media( vPt5ax[i].vtDir1, vPt5ax[j].vtDir1) ;
Pt5ax.vtDir2 = Media( vPt5ax[i].vtDir2, vPt5ax[j].vtDir2) ;
Pt5ax.dPar = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
Pt5ax.nFlag = P5AX_CONC ;
vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
++ i ;
}
}
}
}
}
}
if ( bSharpEdges)
AddPointsOnCorners( vPt5ax) ;
// rimozione punti in eccesso rispetto alle tolleranze
RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
@@ -748,11 +797,11 @@ ProjectPointOnSurf( const Point3d& ptP, const CISRFTMPVECTOR& vpStm, const SurfT
// intersezione della retta con le superfici (conservo l'intersezione più alta)
int nInd = -1 ;
IntLinStmInfo IntRes ;
for ( int i = 0 ; i < int( vpStm.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vpStm) ; ++ i) {
ILSIVECTOR vIntRes ;
if ( IntersLineSurfTm( ptP, vtLine, dLineLen, *vpStm[i], vIntRes, false)) {
// cerco la prima intersezione valida a partire dall'ultima (è la più alta)
int nI = int( vIntRes.size()) - 1 ;
int nI = ssize( vIntRes) - 1 ;
while ( nI >= 0 && abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
--nI ;
// se trovata
@@ -814,7 +863,7 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ISur
{
// sistemazioni per tipo di superficie
CISRFTMPVECTOR vpSurfTm ;
for ( int i = 0 ; i < int( vpSurf.size()) ; ++ i) {
for ( int i = 0 ; i < ssize( vpSurf) ; ++ i) {
const SurfTriMesh* pSurfTm = nullptr ;
switch ( vpSurf[i]->GetType()) {
case SRF_TRIMESH :
@@ -888,25 +937,8 @@ ProjectCurveOnSurf( const ICurve& crCrv, const CISURFPVECTOR& vpSurf, const ISur
}
// se richiesto, inserimento punti intermedi in presenza di spigoli
if ( bSharpEdges) {
for ( int i = 1 ; i < int( vPt5ax.size()) ; ++ i) {
// precedente
int j = i - 1 ;
// se normali tra corrente e precedente oltre limite e punti abbastanza lontani
if ( vPt5ax[i].vtDir1 * vPt5ax[j].vtDir1 < COS_ANG_MAX_CORNER &&
SqDist( vPt5ax[i].ptP, vPt5ax[j].ptP) > 25 * SQ_EPS_SMALL) {
// punto medio
Point3d ptMid = Media( vPt5ax[i].ptP, vPt5ax[j].ptP) ;
double dMid = ( vPt5ax[i].dPar + vPt5ax[j].dPar) / 2 ;
// se trovo proiezione, la salvo
Point5ax Pt5ax ;
if ( ProjectPointOnSurf( ptMid, vpSurfTm, *pRefTm, dMid, Pt5ax)) {
vPt5ax.insert( vPt5ax.begin() + i, Pt5ax) ;
-- i ;
}
}
}
}
if ( bSharpEdges)
AddPointsOnCorners( vPt5ax) ;
// rimozione punti in eccesso rispetto alle tolleranze
RemovePointsInExcess( vPt5ax, dLinTol, dMaxSegmLen, bSharpEdges) ;
SbzFromCurves.cpp
+20 -20
View File
@@ -78,7 +78,7 @@ GetSurfBezierByRegion( const CICURVEPVECTOR& vpCurve, double dLinTol)
for ( int i = 0 ; i < int( vnPLIndMat.size()) ; ++i) {
for ( int j = 0 ; j < int( vnPLIndMat[i].size()) ; ++j){
vPLOrd.push_back(vPL[vnPLIndMat[i][j]]) ;
if( vbInvert[vnPLIndMat[i][j]])
if ( vbInvert[vnPLIndMat[i][j]])
vPLOrd.back().Invert() ;
}
}
@@ -221,7 +221,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
const ICurveComposite* pCC = GetCurveComposite( pGuide) ;
for ( int i = 0 ; i < pCC->GetCurveCount() && bGuideIsPolyLine ; ++i) {
const ICurve* pCrv = pCC->GetCurve( i) ;
if( pCrv->GetType() != CRV_LINE) {
if ( pCrv->GetType() != CRV_LINE) {
if ( pCrv->GetType() == CRV_BEZIER) {
const ICurveBezier* pCrvBez = GetCurveBezier( pCrv) ;
bGuideIsPolyLine = pCrvBez->IsALine() ;
@@ -249,7 +249,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
int nSpanV = 0 ;
PtrOwner<ICurveComposite> pCrvV( CreateCurveComposite()) ;
if ( bGuideIsPolyLine ) {
if( pGuide->GetType() == CRV_LINE)
if ( pGuide->GetType() == CRV_LINE)
nSpanV = 1 ;
else if ( pGuide->GetType() == CRV_COMPO)
nSpanV = GetCurveComposite( pGuide)->GetCurveCount() ;
@@ -260,7 +260,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
pCrvV->AddCurve( CurveToBezierCurve( pGuide, 3, false)) ;
else {
const ICurveBezier* pGuideBez = GetCurveBezier( pGuide) ;
if( ! pGuideBez->IsRational())
if ( ! pGuideBez->IsRational())
pCrvV->AddCurve( pGuide->Clone()) ;
else
pCrvV->AddCurve( EditBezierCurve( pGuideBez, 3, false)) ;
@@ -297,7 +297,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
ICRVCOMPOPOVECTOR vCC ;
INTMATRIX mRep ; mRep.resize( nSpanU * nDegU + 1) ;
int nMaxSpanV = nSpanV ;
for( int i = 0 ; i < nSpanU ; ++i) {
for ( int i = 0 ; i < nSpanU ; ++i) {
const ICurveBezier* pSubCrv = GetCurveBezier( pCrvU->GetCurve( i)) ;
for ( int j = i==0 ? 0 : 1 ; j < nDegU + 1 ; ++j ) {
Point3d ptCtrl = pSubCrv->GetControlPoint( j) ;
@@ -327,7 +327,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
for ( int w = 0 ; w < int( vCC.size()) ; ++w) {
const ICurveComposite* pCCOther = vCC[w] ;
int nPropCheck = -1 ; pCCOther->GetCurveTempProp( z, nPropCheck) ;
if( nPropCheck != 0)
if ( nPropCheck != 0)
mRep[w][z] = 1 ;
}
}
@@ -337,11 +337,11 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
// conto in quante colonne di mRep la somma degli elementi è != 0
// questo numero va aggiunto all'attuale nSpanV
int nSpanPlus = 0 ;
for( int z = 0 ; z < nMaxSpanV ; ++z) {
for ( int z = 0 ; z < nMaxSpanV ; ++z) {
int nPosTot = 0 ;
for ( int k = 0 ; k < int( mRep.size()) ; ++k )
nPosTot += mRep[k][z] ;
if( nPosTot != 0)
if ( nPosTot != 0)
nSpanPlus += 1 ;
}
nMaxSpanV = max( nMaxSpanV, nSpanV + nSpanPlus) ;
@@ -349,14 +349,14 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
pSurfBez->Init( nDegU,nDegV, nSpanU, nSpanV, bRat) ;
//// aggiungo i punti di controllo alla superficie
//for( int i = 0 ; i < nSpanU ; ++i) {
//for ( int i = 0 ; i < nSpanU ; ++i) {
// for ( int j = i==0 ? 0 : 1 ; j < nDegU + 1 ; ++j ) {
// const ICurveComposite* pOffsetCrv = vCC[i*nDegU + j] ;
// for ( int z = 0 ; z < pOffsetCrv->GetCurveCount() ; ++z) {
// const ICurveLine* pCL = GetCurveLine( pOffsetCrv->GetCurve( z)) ;
// if( pCL == nullptr)
// if ( pCL == nullptr)
// return nullptr ;
// if( z == 0) {
// if ( z == 0) {
// Point3d ptSubStart ; pCL->GetStartPoint( ptSubStart) ;
// pSurfBez->SetControlPoint( i * nDegU + j, 0, ptSubStart) ;
// }
@@ -367,13 +367,13 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
//}
//// aggiungo i punti di controllo alla superficie /// DA CORREGGERE L'AGGIUNTA DEI PUNTI DI CONTROLLO
//for( int i = 0 ; i < int( vCC.size()) ; ++i) {
//for ( int i = 0 ; i < int( vCC.size()) ; ++i) {
// const ICurveComposite* pOffsetCrv = vCC[i] ;
// for ( int z = 0 ; z < pOffsetCrv->GetCurveCount() ; ++z) {
// const ICurveLine* pCL = GetCurveLine( pOffsetCrv->GetCurve( z)) ;
// if( pCL == nullptr)
// if ( pCL == nullptr)
// return nullptr ;
// if( z == 0) {
// if ( z == 0) {
// Point3d ptSubStart ; pCL->GetStartPoint( ptSubStart) ;
// pSurfBez->SetControlPoint( i * nDegU + j, 0, ptSubStart) ;
// }
@@ -422,7 +422,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
//frStart.Set( ptStart, -vtStart, vtStart ^ vtNorm) ;
//// porto la sezione nel sistema di riferimento del piano in cui giace
//pCrvU->ToLoc( frStart) ;
//for( int i = 0 ; i < nSpanU ; ++i) {
//for ( int i = 0 ; i < nSpanU ; ++i) {
// const ICurveBezier* pSubCrv = GetCurveBezier( pCrvU->GetCurve( i)) ;
// for ( int j = i==0 ? 0 : 1 ; j < nDegU + 1 ; ++j ) {
// Point3d ptCtrl = pSubCrv->GetControlPoint( j) ;
@@ -458,7 +458,7 @@ GetSurfBezierSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vect
// // aggiungo i punti di controllo alla superficie
// for ( int z = 0 ; z < nSpanV ; ++z) {
// const ICurveBezier* pCrvBez = GetCurveBezier( pCrvV->GetCurve( z)) ;
// if( pCrvBez == nullptr)
// if ( pCrvBez == nullptr)
// return nullptr ;
// for ( int k = z == 0 ? 0 : 1 ; k < nDegV ; ++k) {
// Point3d ptCtrl = pCrvBez->GetControlPoint( k) ;
@@ -572,7 +572,7 @@ GetSurfBezierSwept3d( const ICurve* pSect, const ICurve* pGuide, const Vector3d&
pCrvU->AddCurve( CurveToBezierCurve( pSect, 3, false)) ;
else {
const ICurveBezier* pSectBez = GetCurveBezier( pSect) ;
if( ! pSectBez->IsRational())
if ( ! pSectBez->IsRational())
pCrvU->AddCurve( pSect->Clone()) ; ///// questa curva potrebbe non essere di grado 3!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
else
pCrvU->AddCurve( EditBezierCurve( pSectBez, 3, false)) ;
@@ -775,12 +775,12 @@ GetSurfBezierSkinned( const CICURVEPVECTOR& vCrv, double dLinTol)
{
// verifico che le curve siano valide
for ( int i = 0 ; i < int( vCrv.size()) ; ++i) {
if( vCrv[i] == nullptr || ! vCrv[i]->IsValid())
if ( vCrv[i] == nullptr || ! vCrv[i]->IsValid())
return nullptr ;
}
// se ho solo due curve allora faccio la rigata
if( vCrv.size() == 2)
if ( vCrv.size() == 2)
return GetSurfBezierRuled( vCrv[0], vCrv[1], ISurfBezier::RLT_B_MINDIST_PLUS, dLinTol) ;
//trasformo le curve in curve di bezier, pareggio il numero di sottocurve e il grado
@@ -788,7 +788,7 @@ GetSurfBezierSkinned( const CICURVEPVECTOR& vCrv, double dLinTol)
// dLinTol servirà quando ci sarà la funzione ApproxWithCurveBezier
// se la curva è già una bezier singola la tengo, sennò la converto
ICURVEPOVECTOR vCrvBez ;
for( int c = 0 ; c < int( vCrv.size()) ; ++c){
for ( int c = 0 ; c < int( vCrv.size()) ; ++c){
PtrOwner<ICurveComposite> pCC( CreateCurveComposite()) ;
if ( vCrv[c]->GetType() != CRV_BEZIER )
pCC->AddCurve( CurveToBezierCurve( vCrv[c])) ;
StmFromCurves.cpp
+2 -2
View File
@@ -73,7 +73,7 @@ GetSurfTriMeshByRegion( const CICURVEPVECTOR& vpCurve, double dLinTol)
return nullptr ;
for ( int i = 0 ; i < int( vnPLIndMat.size()) ; ++i) {
for ( int j = 0 ; j < int( vnPLIndMat[i].size()) ; ++j){
if( vbInvert[vnPLIndMat[i][j]])
if ( vbInvert[vnPLIndMat[i][j]])
vPL[vnPLIndMat[i][j]].Invert() ;
}
}
@@ -165,7 +165,7 @@ GetSurfTriMeshByRegionExtrusion( const CICURVEPVECTOR& vpCurve, const Vector3d&
if ( ! CalcRegionPolyLines( vPL, vtN, vnPLIndMat, vbInvert))
return nullptr ;
for ( int i = 0 ; i < int( vPL.size()) ; ++i) {
if( vbInvert[i])
if ( vbInvert[i])
vPL[i].Invert() ;
}
// verifico la direzione di estrusione
SubtractProjectedFacesOnStmFace.cpp
+1 -1
View File
@@ -302,7 +302,7 @@ SetTmpPropByOverlap( ICurveComposite* pCrvCheck, const int nInd, const ICurveCom
// ultimo tratto di curva della Composita iniziale
PtrOwner<CurveComposite> pCrvB( GetBasicCurveComposite( pCrvCheck->CopyParamRange( nInd + 1, pCrvCheck->GetCurveCount()))) ;
if ( ! IsNull( pCrvB) && pCrvB->GetCurveCount() > 0 && pCrvB->IsValid())
if( ! pCrvToReturn->AddCurve( Release( pCrvB))) {
if ( ! pCrvToReturn->AddCurve( Release( pCrvB))) {
nStat = 2 ;
return true ;
}
SurfAux.cpp
+4 -4
View File
@@ -42,7 +42,7 @@ NurbsSurfaceCanonicalize( SNurbsSurfData& snData)
double dKnot = snData.vU[k] ;
vU.push_back( dKnot) ;
}
for( int j = 0 ; j < snData.nCPV ; ++j) {
for ( int j = 0 ; j < snData.nCPV ; ++j) {
CNurbsData nuCurve ;
nuCurve.bPeriodic = true ;
nuCurve.bRat = snData.bRat ;
@@ -66,12 +66,12 @@ NurbsSurfaceCanonicalize( SNurbsSurfData& snData)
if ( NurbsCurveCanonicalize( nuCurve)) { // se NurbsCurveCanonicalize ha restituito false (la curva potrebbe esserre un punto di polo) allora non modifico i punti e il vettore dei nodi della superficie
if ( snData.mCP.size() != nuCurve.vCP.size() ) {
snData.mCP.resize( nuCurve.vCP.size()) ;
if( snData.bRat)
if ( snData.bRat)
snData.mW.resize( nuCurve.vW.size()) ;
}
for ( int i = 0 ; i < snData.nCPU ; ++i) {
snData.mCP[i][j] = nuCurve.vCP[i] ;
if( snData.bRat) {
if ( snData.bRat) {
snData.mW[i][j] = nuCurve.vW[i] ;
snData.mCP[i][j] *= nuCurve.vW[i] ;
}
@@ -91,7 +91,7 @@ NurbsSurfaceCanonicalize( SNurbsSurfData& snData)
double dKnot = snData.vV[k] ;
vV.push_back( dKnot) ;
}
for( int i = 0 ; i < snData.nCPU ; ++i) {
for ( int i = 0 ; i < snData.nCPU ; ++i) {
CNurbsData nuCurve ;
nuCurve.bPeriodic = true ;
nuCurve.bRat = snData.bRat ;
SurfBezier.cpp
+317 -212
View File
File diff suppressed because it is too large Load Diff
SurfTriMesh.cpp
+3 -3
View File
@@ -517,9 +517,9 @@ SurfTriMesh::GetVertexParam( int nId, double& dU, double& dV) const
// verifico esistenza del vertice
if ( nId < 0 || nId >= GetVertexSize() || m_vVert[nId].nIdTria == SVT_DEL)
return false ;
// recupero i dati
dU = m_vVert[nId].dU ;
dV = m_vVert[nId].dV ;
// recupero i dati (verso l'esterno sempre in 0..1..2..3..)
dU = m_vVert[nId].dU / PREC_SCALE_COEFF ;
dV = m_vVert[nId].dV / PREC_SCALE_COEFF ;
return true ;
}
SurfTriMeshBooleans.cpp
+1 -1
View File
@@ -41,7 +41,7 @@
using namespace std ;
//----------------------------------------------------------------------------
const double BOOLEAN_SCALE = 1024 ;
const double BOOLEAN_SCALE = PREC_SCALE_COEFF ;
//----------------------------------------------------------------------------
bool
SurfTriMeshCuts.cpp
+1 -1
View File
@@ -26,7 +26,7 @@
using namespace std ;
//----------------------------------------------------------------------------
const double CUT_SCALE = 1024 ;
const double CUT_SCALE = PREC_SCALE_COEFF ;
//----------------------------------------------------------------------------
bool
SurfTriMeshOffset.cpp
+641 -93
View File
@@ -9,6 +9,7 @@
// Modifiche : 10.06.25 RE Creazione modulo.
// 10.06.25 RE Offset di superfici chiuse.
// 04.07.25 RE Thickening Offset di superfici generiche.
// 10.12.25 RE Creazione superfici Shell.
//
//----------------------------------------------------------------------------
@@ -16,11 +17,17 @@
#include "stdafx.h"
#include "VolZmap.h"
#include "SurfTriMesh.h"
#include "EgtDev/Include/EGkDistPointSurfTm.h"
#include "\EgtDev\Include\EGkSurfTriMeshAux.h"
#include "/EgtDev/Include/EGkDistPointSurfTm.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGkDistPointTria.h"
#include "/EgtDev/Include/EGkSurfTriMeshAux.h"
#include "/EgtDev/Include/EGkStmFromCurves.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include <future>
#define DEBUG 0
#if DEBUG
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EGkGeoObjSave.h"
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkGeoVector3d.h"
@@ -58,6 +65,255 @@ SumStm( const CISURFTMPVECTOR& vStm)
return ( Release( pStmAdd)) ;
}
//----------------------------------------------------------------------------
// Funzioni per la distanza tra punto e superficie TriMesh in parallelo
//----------------------------------------------------------------------------
static bool
BoundingBoxDifference( const BBox3d& boxA, const BBox3d& boxB, BOXVECTOR& vBoxDiff)
{
// svuoto il risultato
vBoxDiff.clear() ;
// se box A vuoto, risultato vuoto
if ( boxA.IsEmpty())
return false ;
// se box B vuoto o i box non si intersecano, risultato è ancora A
BBox3d boxInt ;
if ( boxB.IsSmall() || ! boxA.FindIntersection( boxB, boxInt)) {
vBoxDiff.emplace_back( boxA) ;
return true ;
}
// recupero i punti estremi dei box A e Intersezione
Point3d ptMinA, ptMaxA ; boxA.GetMinMax( ptMinA, ptMaxA) ;
Point3d ptMinInt, ptMaxInt ; boxInt.GetMinMax( ptMinInt, ptMaxInt) ;
// sotto
if ( ptMinInt.z - ptMinA.z > EPS_SMALL) {
BBox3d boxD( ptMinA, Point3d( ptMaxA.x, ptMaxA.y, ptMinInt.z)) ;
vBoxDiff.emplace_back( boxD) ;
}
// sopra
if ( ptMaxA.z - ptMaxInt.z > EPS_SMALL) {
BBox3d boxD( Point3d( ptMinA.x, ptMinA.y, ptMaxInt.z), ptMaxA) ;
vBoxDiff.emplace_back( boxD) ;
}
// davanti
if ( ptMinInt.y - ptMinA.y > EPS_SMALL) {
BBox3d boxD( Point3d( ptMinA.x, ptMinA.y, ptMinInt.z), Point3d( ptMaxA.x, ptMinInt.y, ptMaxInt.z)) ;
vBoxDiff.emplace_back( boxD) ;
}
// dietro
if ( ptMaxA.y - ptMaxInt.y > EPS_SMALL) {
BBox3d boxD( Point3d( ptMinA.x, ptMaxInt.y, ptMinInt.z), Point3d( ptMaxA.x, ptMaxA.y, ptMaxInt.z)) ;
vBoxDiff.emplace_back( boxD) ;
}
// sinistra
if ( ptMinInt.x - ptMinA.x > EPS_SMALL) {
BBox3d boxD( Point3d( ptMinA.x, ptMinInt.y, ptMinInt.z), Point3d( ptMinInt.x, ptMaxInt.y, ptMaxInt.z)) ;
vBoxDiff.emplace_back( boxD) ;
}
// destra
if ( ptMaxA.y - ptMaxInt.y > EPS_SMALL) {
BBox3d boxD( Point3d( ptMaxInt.x, ptMinInt.y, ptMinInt.z), Point3d( ptMaxA.x, ptMaxInt.y, ptMaxInt.z)) ;
vBoxDiff.emplace_back( boxD) ;
}
// risultato
return ( ! vBoxDiff.empty()) ;
}
//----------------------------------------------------------------------------
static bool
DistPointSurfTmMultiThread( const Point3d& ptP, const SurfTriMesh& SurfTm, double& dDist,
bool& bIsInside, INTVECTOR& vIndClosestTria)
{
// verifico che la supercicie sia valida
if ( ! SurfTm.IsValid())
return false ;
// inizializzo distanza non calcolata
dDist = - 1. ;
// vettore di indici dei triangoli più vicini inizialmente vuoto
vIndClosestTria.clear() ;
// vettore dei flag temporanei inizialmente tutto a 0
INTVECTOR vIntFlags( SurfTm.GetTriangleCount(), 0) ;
// recupero e verifico il box locale della superficie
BBox3d b3Stm = SurfTm.GetAllTriaBox() ;
if ( b3Stm.IsEmpty())
return false ;
// cerco triangoli in box centrati sul punto dato di ampiezza crescente ed escludendo le parti già verificate.
// termino quando non trovo più triangoli che possano soddisfare la richiesta.
Point3d ptMin, ptMax ; b3Stm.GetMinMax( ptMin, ptMax) ;
double dDeltaLen = max( min( min( b3Stm.GetDimX(), b3Stm.GetDimY()), b3Stm.GetDimZ()) / 40., 20.) ;
double dBoxHalfLenX = max( max( ptMin.x - ptP.x, ptP.x - ptMax.x), 0.) + dDeltaLen ;
double dBoxHalfLenY = max( max( ptMin.y - ptP.y, ptP.y - ptMax.y), 0.) + dDeltaLen ;
double dBoxHalfLenZ = max( max( ptMin.z - ptP.z, ptP.z - ptMax.z), 0.) + dDeltaLen ;
// considero anche il box precedente per poter analizzare solo il volume differenza tra i due
BBox3d boxPPrev( ptP) ;
BBox3d boxP( ptP, dBoxHalfLenX, dBoxHalfLenY, dBoxHalfLenZ) ;
// variabili distanza minima, indice del triangolo di distanza minima, punto di distanza minima
double dMinDist = DBL_MAX ;
int nMinDistTriaIndex = SVT_NULL ;
Point3d ptMinDistPoint ;
// finché non si verifica la condizione di terminazione ingrandisco il box.
bool bContinue = true ;
// creazione del vettore dei triangoli più vicini a ptP
vector<pair<int, Triangle3d>> vTria ; // <indice triangolo, Triangolo>
while ( bContinue) {
// calcolo il box differenza con il precedente per non esplorare parti già considerate
BOXVECTOR vBox ;
BoundingBoxDifference( boxP, boxPPrev, vBox) ;
// Ciclo sui box differenza
bool bCollide = false ;
for ( const auto& b3Box : vBox) {
// interseco il box con quello della superficie e ne verifico la distanza minima dal punto
BBox3d b3Int ;
if ( ! b3Box.FindIntersection( b3Stm, b3Int) || b3Int.DistFromPoint( ptP) > dMinDist)
continue ;
// ricerca sui triangoli nel box
bCollide = true ;
INTVECTOR vnIds ;
if ( SurfTm.GetAllTriaOverlapBox( b3Int, vnIds)) {
// ciclo sui triangoli del sotto-box corrente
for ( auto nT : vnIds) {
Triangle3d trCurTria ;
if ( vIntFlags[nT] == 0 && SurfTm.GetTriangle( nT, trCurTria)) {
vIntFlags[nT] = 1 ;
DistPointTriangle distPT( ptP, trCurTria) ;
double dCurrDist ;
// se la distanza del triangolo è valida e minore di quella attuale aggiorno
if ( distPT.GetDist( dCurrDist)) {
// se distanze uguali...
if ( abs( dCurrDist - dMinDist) < EPS_SMALL)
// aggiungo il triangolo
vTria.emplace_back( make_pair( nT, trCurTria)) ;
// se minore...
else if ( dCurrDist < dMinDist) {
// pulisco il vettore
vTria.clear() ;
dMinDist = dCurrDist ;
nMinDistTriaIndex = nT ;
distPT.GetMinDistPoint( ptMinDistPoint) ;
// aggiungo il triangolo
vTria.emplace_back( make_pair( nT, trCurTria)) ;
}
}
}
}
}
}
// se si verifica la condizione di terminazione arresto il ciclo altrimenti aggiorno i box
if ( ! bCollide || dMinDist < EPS_SMALL)
bContinue = false ;
else {
boxPPrev = boxP ;
boxP.Expand( dDeltaLen) ;
}
}
// se non ho trovato nessun triangolo, errore
if ( nMinDistTriaIndex == SVT_NULL)
return false ;
// riempio il vettore dei triangoli a minima distanza
for ( auto& Tria : vTria)
vIndClosestTria.emplace_back( Tria.first) ;
// salvo la distanza
dDist = dMinDist ;
// determino il Side
if ( dDist < EPS_SMALL) {
bIsInside = false ;
return true ;
}
// se ho solo un triangolo
else if ( int( vTria.size()) == 1) {
bIsInside = ( ( ptP - ptMinDistPoint) * vTria.back().second.GetN() < - EPS_SMALL) ;
return true ;
}
// controllo se tutti i triangoli a minima distanza forniscono la stessa informazione
// ( il punto potrebbe essere esterno a tutti, interno a tutti o indefinito )
bool bInside = false ;
bool bOutside = false ;
for ( int i = 0 ; i < int( vTria.size()) ; ++ i) {
if ( ( ptP - vTria[i].second.GetP( 0)) * vTria[i].second.GetN() < - EPS_SMALL)
bInside = true ;
else
bOutside = true ;
}
bIsInside = false ;
if ( bOutside == bInside) {
Point3d ptBar_tot ;
for ( const auto& Tria : vTria)
ptBar_tot += Tria.second.GetCentroid() ;
for ( const auto& Tria : vTria) {
Point3d ptInters1, ptInters2 ;
int nType = IntersLineTria( ptP, ptBar_tot, Tria.second, ptInters1, ptInters2) ;
if ( nType == ILTT_IN) {
DistPointTriangle( ptP, Tria.second).GetMinDistPoint( ptMinDistPoint) ;
bIsInside = ( ( ptP - ptMinDistPoint) * Tria.second.GetN() < - EPS_SMALL) ;
nMinDistTriaIndex = Tria.first ;
break ;
}
}
}
else
bIsInside = bInside ;
return true ;
}
//----------------------------------------------------------------------------
static bool
ClassifyTrianglesMultiThread( const TRIA3DEXVECTOR& vTria, int nIndS, int nIndE,
const SurfTriMesh& SurfTm, double dOffs, double dPrec,
bool bSaveInside, BOOLVECTOR& vbSafe)
{
// verifico che la superficie sia valida
if ( ! SurfTm.IsValid())
return false ;
// verifico la validità degli indici
if ( nIndS < 0 || nIndE >= int( vTria.size()))
return false ;
// verifico la dimensione dei vettori
if ( vTria.size() != vbSafe.size())
return false ;
// scorro gli indici dei triangoli da classificare
for ( int k = nIndS ; k <= nIndE ; ++ k) {
// recupero il triangolo corrente
const Triangle3dEx& Tria = vTria[k] ;
// preparo gli elementi di classificazione
DBLVECTOR vDists ; vDists.resize( 3) ;
INTMATRIX matIndClosestTria ; matIndClosestTria.resize( 3) ;
// verifico che i suoi punti siano distanti almeno |dOffs| - dTol dalla superficie
vbSafe[k] = true ;
for ( int i = 0 ; vbSafe[k] && i < 3 ; ++ i) {
bool bIsInside = false ;
DistPointSurfTmMultiThread( Tria.GetP( i), SurfTm, vDists[i], bIsInside, matIndClosestTria[i]) ;
vbSafe[k] = ( ( vDists[i] > abs( dOffs) - 0.25 * dPrec) &&
( vDists[i] < abs( dOffs) + 0.25 * dPrec) &&
( bIsInside == bSaveInside)) ;
}
// se tutti sufficientemente distanti
if ( vbSafe[k]) {
// i triangoli a minima distanza devono avere normale simile
bool bPerp = true ;
for ( int i = 0 ; bPerp && i < 3 ; ++ i) {
for ( int j = 0 ; bPerp && j < int( matIndClosestTria[i].size()) ; ++ j) {
Triangle3d TriaCloser ;
SurfTm.GetTriangle( matIndClosestTria[i][j], TriaCloser) ;
bPerp = ( abs( Tria.GetN() * TriaCloser.GetN()) < cos( 30. * DEGTORAD)) ;
}
}
vbSafe[k] = ( ! bPerp) ;
}
}
return true ;
}
//----------------------------------------------------------------------------
// Funzione che crea l'Offset di una superficie TriMesh
//----------------------------------------------------------------------------
@@ -94,123 +350,138 @@ CreateSurfTriMeshesOffset( const CISURFTMPVECTOR& vStm, double dOffs, double dPr
return SumStm( vStm) ;
// creo lo Zmap associato alle superfici TriMesh
VolZmap OneVolZmap ;
if ( ! OneVolZmap.CreateFromTriMeshOffset( vStm, dOffs, dMyPrec, nType))
VolZmap myVolZmap ;
if ( ! myVolZmap.CreateFromTriMeshOffset( vStm, dOffs, dMyPrec, nType))
return nullptr ;
if ( ! OneVolZmap.IsValid())
if ( ! myVolZmap.IsValid())
return nullptr ;
// recupero le superfici aperte
CISURFTMPVECTOR vStmOpen ;
for ( const ISurfTriMesh* pStm : vStm) {
if ( pStm != nullptr && pStm->IsValid() && ! pStm->IsClosed())
if ( pStm != nullptr && pStm->IsValid() && ! pStm->IsClosed())
vStmOpen.emplace_back( pStm) ;
}
// --- se non ho superfici aperte
if ( vStmOpen.empty()) {
// restituisco la superficie TriMesh di Offset
return ( OneVolZmap.GetSurfTriMesh()) ;
return ( myVolZmap.GetSurfTriMesh()) ;
}
// --- se ho delle superfici aperte
// lo Zmap creato è orientato e definisce una superficie chiusa; devo rimuovere i triangoli in eccesso
// anzitutto controllo che lo Zmap sia valido
if ( ! OneVolZmap.IsValid())
return nullptr ;
// inzializzo la superficie TriMesh da restituire
PtrOwner<SurfTriMesh> pStm( CreateBasicSurfTriMesh()) ;
if ( IsNull( pStm) || ! pStm->Init( 3, 1))
return nullptr ;
PointGrid3d VertGrid ; VertGrid.Init( 50000) ;
// tolleranza di vicinanza alla superficie
double dTolDist = 30. * EPS_SMALL ;
#if DEBUG
VT.emplace_back( OneVolZmap.Clone()) ;
VC.emplace_back( BLACK) ;
#endif
// ciclo lungo i blocchi dello ZMap
for ( int nB = 0 ; nB < OneVolZmap.GetBlockCount() ; ++ nB) {
// recupero i triangoli
// --- se ho delle superfici chiuse
TRIA3DEXVECTOR vAllTria, vTriaOffs ;
for ( int nB = 0 ; nB < myVolZmap.GetBlockCount() ; ++ nB) {
TRIA3DEXVECTOR vTria, vTriaSafe ;
OneVolZmap.GetBlockTriangles( nB, vTria) ;
// un triangolo viene ritenuto valido se è non è troppo vicino ( dOffs) alle superfici aperte
myVolZmap.GetBlockTriangles( nB, vTria) ;
#if DEBUG
TRIA3DVECTOR vTriaUnsafe ;
#endif
for ( int nT = 0 ; nT < int( vTria.size()) ; ++ nT) {
// recupero il triangolo
Triangle3dEx& Tria = vTria[nT] ;
// scorro le superficie aperte
bool bInsert = true ;
for ( int nS = 0 ; bInsert && nS < int( vStm.size()) ; ++ nS) {
// controllo se posso inserirlo
vector<DistPointSurfTm> vDistPtStm ;
for ( int i = 0 ; i < 3 && bInsert ; ++ i) {
double dDist = 0. ;
vDistPtStm.emplace_back( DistPointSurfTm( Tria.GetP( i), *vStm[nS])) ;
bInsert = ( vDistPtStm.back().GetDist( dDist) && dDist > abs( dOffs) - dTolDist) ;
}
// se il triangolo è al più a distanza di |dOffs| - dTolDist
if ( bInsert) {
// recupero i triangoli a distanza minima dai vertici del triangolo corrente
bool bPerp = true ;
for ( int i = 0 ; i < 3 && bPerp ; ++ i) {
INTVECTOR vTria ;
vDistPtStm[i].GetMinDistTriaIndices( vTria) ;
for ( int j = 0 ; j < int( vTria.size()) && bPerp ; ++ j) {
Triangle3d TriaCloser ;
vStm[nS]->GetTriangle( vTria[j], TriaCloser) ;
bPerp = ( abs( Tria.GetN() * TriaCloser.GetN()) < dTolDist) ;
}
}
// se tutti i triangoli a distanza minima sono perpendicolari, allora non lo inserisco
bInsert = ( ! bPerp) ;
BBox3d BBoxTria ;
Tria.GetLocalBBox( BBoxTria) ;
// azzero flag di colore
vAllTria.push_back( Tria) ;
}
}
// classifico i triangoli
PtrOwner<const SurfTriMesh> pStmBasic( nullptr) ;
if ( int( vStmOpen.size() == 1))
pStmBasic.Set( GetBasicSurfTriMesh( CloneSurfTriMesh( vStmOpen[0]))) ;
else {
StmFromTriangleSoup AllOpenStmSoup ; AllOpenStmSoup.Start() ;
for ( const ISurfTriMesh* pStmOpen : vStmOpen) {
if ( pStmOpen != nullptr && pStmOpen->IsValid()) {
for ( int nT = 0 ; nT < pStmOpen->GetTriangleCount() ; ++ nT) {
Triangle3d Tria ;
if ( pStmOpen->GetTriangle( nT, Tria))
AllOpenStmSoup.AddTriangle( Tria) ;
}
}
// se triangolo da inserire
if ( bInsert)
vTriaSafe.emplace_back( Tria) ;
#if DEBUG
ICurveComposite* pCompo = CreateCurveComposite() ;
pCompo->AddPoint( Tria.GetP( 0)) ;
pCompo->AddLine( Tria.GetP( 1)) ;
pCompo->AddLine( Tria.GetP( 2)) ;
pCompo->Close() ;
Color myCol = ( bInsert ? Color( 0., 1., 0., .5) : Color( 1., 0., 0., .5)) ;
VT.emplace_back( CloneCurveComposite( pCompo)) ;
VC.emplace_back( myCol) ;
ISurfFlatRegion* pSfrTria = CreateSurfFlatRegion() ;
pSfrTria->AddExtLoop( pCompo) ;
VT.emplace_back( pSfrTria) ;
VC.emplace_back( myCol) ;
#endif
}
// inserisco tutti i triangoli validi
if ( ! pStm->AddTriaFromZMap( vTriaSafe, VertGrid))
return nullptr ;
AllOpenStmSoup.End() ;
pStmBasic.Set( GetBasicSurfTriMesh( AllOpenStmSoup.GetSurf())) ;
}
if ( pStmBasic == nullptr)
return nullptr ;
BBox3d b3Stm = pStmBasic->GetAllTriaBox() ;
if ( b3Stm.IsEmpty())
return nullptr ;
// numero di triangoli da analizzare
int nTriaCnt = int( vAllTria.size()) ;
// definisco un vettore di Flag per i triangoli già visitati
INTVECTOR vIntFlags( pStmBasic->GetTriangleCount()) ;
// numero massimo di thread concorrenti
int nThreadMax = thread::hardware_concurrency() ;
bool bOk = true ;
BOOLVECTOR vbSafeTria( vAllTria.size(), true) ;
if ( nThreadMax <= 1 || nTriaCnt < 50)
ClassifyTrianglesMultiThread( vAllTria, 0, nTriaCnt - 1, *pStmBasic, abs( dOffs), dPrec, ( dOffs < 0.), vbSafeTria) ;
else {
const int MAX_PARTS = 32 ;
INTINTVECTOR vFstLst( MAX_PARTS) ;
// calcolo le parti del vettore
int nPartCnt = min( nThreadMax, MAX_PARTS) ;
int nPartDim = nTriaCnt / nPartCnt + 1 ;
for ( int i = 0 ; i < nPartCnt ; ++ i) {
vFstLst[i].first = i * nPartDim ;
vFstLst[i].second = min( ( i + 1) * nPartDim, nTriaCnt) - 1 ;
}
// processo le parti
future<bool> vRes[MAX_PARTS] ;
for ( int i = 0 ; i < nPartCnt ; ++ i) {
vRes[i] = async( launch::async, &ClassifyTrianglesMultiThread, cref( vAllTria), vFstLst[i].first,
vFstLst[i].second, cref( *pStmBasic), abs( dOffs), dPrec, ( dOffs < 0.), ref( vbSafeTria)) ;
}
// attendo i risultati
int nFin = 0 ;
while ( nFin < nPartCnt) {
for ( int i = 0 ; i < nPartCnt ; ++ i) {
if ( vRes[i].valid() && vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
bOk = vRes[i].get() && bOk ;
++ nFin ;
}
}
}
}
if ( ! bOk)
return nullptr ;
TRIA3DEXVECTOR vTriaSafe ; vTriaSafe.reserve( vAllTria.size()) ;
#if DEBUG
TRIA3DEXVECTOR vTriaUnSafe ; vTriaUnSafe.reserve( vAllTria.size()) ;
#endif
for ( int i = 0 ; i < int( vAllTria.size()) ; ++ i) {
if ( vbSafeTria[i])
vTriaSafe.emplace_back( vAllTria[i]) ;
#if DEBUG
if ( ! vbSafeTria[i])
vTriaUnSafe.emplace_back( vAllTria[i]) ;
#endif
}
// definisco la superficie con i soli triangoli validi
StmFromTriangleSoup TriaSoup ; TriaSoup.Start() ;
for ( const Triangle3d& SafeTria : vTriaSafe)
TriaSoup.AddTriangle( SafeTria) ;
TriaSoup.End() ;
PtrOwner<ISurfTriMesh> pStmOffs( TriaSoup.GetSurf()) ;
if ( IsNull( pStmOffs) || ! pStmOffs->IsValid() || pStmOffs->GetTriangleCount() == 0)
return nullptr ;
#if DEBUG
StmFromTriangleSoup _invalidSoup ; _invalidSoup.Start() ;
for ( const Triangle3d& _unsafeTria : vTriaUnSafe)
_invalidSoup.AddTriangle( _unsafeTria) ;
_invalidSoup.End() ;
VT.emplace_back( pStmOffs->Clone()) ;
VC.emplace_back( LIME) ;
VT.emplace_back( _invalidSoup.GetSurf()) ;
VC.emplace_back( RED) ;
SaveGeoObj( VT, VC, "C:\\Temp\\TriangleSelection.nge") ;
#endif
// sistemo la topologia
if ( ! pStm->AdjustTopologyFromZMap())
return nullptr ;
return ( Release( pStm)) ;
return ( Release( pStmOffs)) ;
}
//----------------------------------------------------------------------------
@@ -240,3 +511,280 @@ CreateSurfTriMeshesThickeningOffset( const CISURFTMPVECTOR& vStm, double dOffs,
// restituisco la superficie TriMesh
return ( OneVolZmap.GetSurfTriMesh()) ;
}
//----------------------------------------------------------------------------
// Funzione per creare la Superficie TriMesh Shell da una Trimesh aperta
//----------------------------------------------------------------------------
ISurfTriMesh*
CreateSurfTriMeshShell( const ISurfTriMesh* pStm, double dThick, double dPrec)
{
// verifico che la superficie sia valida ed aperta
if ( pStm == nullptr || ! pStm->IsValid() || pStm->IsClosed())
return nullptr ;
// lo spessore deve essere sempre positivo, il verso è sempre dato dalla normale dei triangoli
dThick = - max( 10. * EPS_SMALL, abs( dThick)) ;
// creo il suo Offset ( salvandomi lo Zmap per l'orientamento)
#if DEBUG
PerformanceCounter PC ; PC.Start() ;
#endif
VolZmap myVolZMap ;
if ( ! myVolZMap.CreateFromTriMeshOffset( { pStm}, dThick, dPrec))
return nullptr ;
if ( ! myVolZMap.IsValid())
return nullptr ;
#if DEBUG
LOG_INFO( GetEGkLogger(), ( string{ "Tria Time : "} + ToString( PC.Stop())).c_str()) ;
VT.clear() ; VC.clear() ;
VT.emplace_back( myVolZMap.Clone()) ;
VC.emplace_back( BLACK) ;
VT.emplace_back( pStm->Clone()) ;
VC.emplace_back( YELLOW) ;
SaveGeoObj( VT, VC, "C:\\Temp\\VolZMapOffs.nge") ;
#endif
#if DEBUG
VT.clear() ; VC.clear() ;
PC.Start() ;
#endif
// recupero i triangoli dallo ZMap creato
TRIA3DEXVECTOR vAllTria, vTriaOffs ;
for ( int nB = 0 ; nB < myVolZMap.GetBlockCount() ; ++ nB) {
TRIA3DEXVECTOR vTria, vTriaSafe ;
myVolZMap.GetBlockTriangles( nB, vTria) ;
#if DEBUG
TRIA3DVECTOR vTriaUnsafe ;
#endif
for ( int nT = 0 ; nT < int( vTria.size()) ; ++ nT) {
Triangle3dEx& Tria = vTria[nT] ;
BBox3d BBoxTria ;
Tria.GetLocalBBox( BBoxTria) ;
// azzero flag di colore
vAllTria.push_back( Tria) ;
}
}
// classifico i triangoli
const SurfTriMesh* pStmBasic = GetBasicSurfTriMesh( pStm) ;
if ( pStmBasic == nullptr)
return nullptr ;
BBox3d b3Stm = pStmBasic->GetAllTriaBox() ;
if ( b3Stm.IsEmpty())
return nullptr ;
// numero di triangoli da analizzare
int nTriaCnt = int( vAllTria.size()) ;
// definisco un vettore di Flag per i triangoli già visitati
INTVECTOR vIntFlags( pStmBasic->GetTriangleCount()) ;
// numero massimo di thread concorrenti
int nThreadMax = thread::hardware_concurrency() ;
bool bOk = true ;
BOOLVECTOR vbSafeTria( vAllTria.size(), true) ;
if ( nThreadMax <= 1 || nTriaCnt < 50)
ClassifyTrianglesMultiThread( vAllTria, 0, nTriaCnt - 1, *pStmBasic, dThick, dPrec, true, vbSafeTria) ;
else {
const int MAX_PARTS = 32 ;
INTINTVECTOR vFstLst( MAX_PARTS) ;
// calcolo le parti del vettore
int nPartCnt = min( nThreadMax, MAX_PARTS) ;
int nPartDim = nTriaCnt / nPartCnt + 1 ;
for ( int i = 0 ; i < nPartCnt ; ++ i) {
vFstLst[i].first = i * nPartDim ;
vFstLst[i].second = min( ( i + 1) * nPartDim, nTriaCnt) - 1 ;
}
// processo le parti
future<bool> vRes[MAX_PARTS] ;
for ( int i = 0 ; i < nPartCnt ; ++ i) {
vRes[i] = async( launch::async, &ClassifyTrianglesMultiThread, cref( vAllTria), vFstLst[i].first,
vFstLst[i].second, cref( *pStmBasic), dThick, dPrec, true, ref( vbSafeTria)) ;
}
// attendo i risultati
int nFin = 0 ;
while ( nFin < nPartCnt) {
for ( int i = 0 ; i < nPartCnt ; ++ i) {
if ( vRes[i].valid() && vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
bOk = vRes[i].get() && bOk ;
++ nFin ;
}
}
}
}
if ( ! bOk)
return nullptr ;
TRIA3DEXVECTOR vTriaSafe ; vTriaSafe.reserve( vAllTria.size()) ;
#if DEBUG
TRIA3DEXVECTOR vTriaUnSafe ; vTriaUnSafe.reserve( vAllTria.size()) ;
#endif
for ( int i = 0 ; i < int( vAllTria.size()) ; ++ i) {
if ( vbSafeTria[i])
vTriaSafe.emplace_back( vAllTria[i]) ;
#if DEBUG
if ( ! vbSafeTria[i])
vTriaUnSafe.emplace_back( vAllTria[i]) ;
#endif
}
// definisco la superficie con i soli triangoli validi
StmFromTriangleSoup TriaSoup ; TriaSoup.Start() ;
for ( const Triangle3d& SafeTria : vTriaSafe)
TriaSoup.AddTriangle( SafeTria) ;
TriaSoup.End() ;
PtrOwner<ISurfTriMesh> pStmOffs( TriaSoup.GetSurf()) ;
if ( IsNull( pStmOffs) || ! pStmOffs->IsValid() || pStmOffs->GetTriangleCount() == 0)
return nullptr ;
#if DEBUG
LOG_INFO( GetEGkLogger(), ( string{ "Tria Time ( exceed Approx) : "} + ToString( PC.Stop())).c_str()) ;
StmFromTriangleSoup _invalidSoup ; _invalidSoup.Start() ;
for ( const Triangle3d& _unsafeTria : vTriaUnSafe)
_invalidSoup.AddTriangle( _unsafeTria) ;
_invalidSoup.End() ;
VT.emplace_back( pStmOffs->Clone()) ;
VC.emplace_back( LIME) ;
VT.emplace_back( _invalidSoup.GetSurf()) ;
VC.emplace_back( RED) ;
SaveGeoObj( VT, VC, "C:\\Temp\\TriangleSelection.nge") ;
VT.clear() ; VC.clear() ;
PC.Start() ;
#endif
// recupero i loops della superficie originaria e del suo Offset orientato ( non devono essere diminuiti)
POLYLINEVECTOR vPL, vPLOffs ;
if ( ! pStm->GetLoops( vPL) || ! pStmOffs->GetLoops( vPLOffs))
return nullptr ;
// trasformo ogni loop in curve composite ( devono essere chiuse)
ICRVCOMPOPOVECTOR vCompoLoops ; vCompoLoops.reserve( vPL.size()) ;
for ( const PolyLine& PL : vPL) {
if ( PL.IsClosed()) {
if ( ! vCompoLoops.emplace_back( CreateCurveComposite()) ||
! vCompoLoops.back()->FromPolyLine( PL) ||
! vCompoLoops.back()->IsValid())
return nullptr ;
}
}
ICRVCOMPOPOVECTOR vCompoOffsLoops ; vCompoOffsLoops.reserve( vPLOffs.size()) ;
for ( const PolyLine& PLOffs : vPLOffs) {
if ( PLOffs.IsClosed()) {
if ( ! vCompoOffsLoops.emplace_back( CreateCurveComposite()) ||
! vCompoOffsLoops.back()->FromPolyLine( PLOffs) ||
! vCompoOffsLoops.back()->IsValid())
return nullptr ;
}
}
#if DEBUG
VT.emplace_back( pStmOffs->Clone()) ;
VC.emplace_back( YELLOW) ;
for ( ICurveComposite* pCompo : vCompoLoops) {
VT.emplace_back( pCompo->Clone()) ;
VC.emplace_back( AQUA) ;
}
for ( ICurveComposite* pCompoOffs : vCompoOffsLoops) {
VT.emplace_back( pCompoOffs->Clone()) ;
VC.emplace_back( ORANGE) ;
}
SaveGeoObj( VT, VC, "C:\\Temp\\myCurve.nge") ;
VT.clear() ; VC.clear() ;
#endif
// per ogni curva della superficie originale cerco la sua associata
// NB. per la creazione della superficie ruled la prima curva è quellla che determina il verso
// dei triangoli associati. Per un corretto ed automatico orientamento della superficie
// la prima curva deve essere sempre definita dalla superficie originale ed invertita ( le
// curve nella rigata devono seguire lo stesso orientamento
ISURFTMPOVECTOR vStmRuled ; vStmRuled.reserve( vCompoLoops.size()) ;
BOOLVECTOR vIndMatched( vCompoOffsLoops.size(), false) ;
for ( ICurveComposite* pCompoLoop : vCompoLoops) {
// sposto il punto iniziale della curva nel tratto più lungo
double dMaxLen = - INFINITO ;
int nIndCrv = 0 ;
for ( int nCrv = 0 ; nCrv < pCompoLoop->GetCurveCount() ; ++ nCrv) {
const ICurve* pCurve = pCompoLoop->GetCurve( nCrv) ;
if ( pCurve != nullptr && pCurve->IsValid()) {
double dCurrLen = 0. ;
pCurve->GetLength( dCurrLen) ;
if ( dCurrLen > dMaxLen) {
dMaxLen = dCurrLen ;
nIndCrv = nCrv ;
}
}
}
pCompoLoop->ChangeStartPoint( nIndCrv + 0.5) ;
Point3d ptStart ; pCompoLoop->GetStartPoint( ptStart) ;
// dalle altre curve derivanti dalla superficie di Offset cerco quella più vicina al punto inziale
double dMinSqDist = INFINITO ;
int nIndOffsCrv = -1 ;
Point3d ptMinDist ;
for ( int nOffsCrv = 0 ; nOffsCrv < int( vCompoOffsLoops.size()) ; ++ nOffsCrv) {
if ( vIndMatched[nOffsCrv])
continue ;
// recupero la curva e calcolo la distanza
const ICurveComposite* pCompoOffsLoop = vCompoOffsLoops[nOffsCrv] ;
int nFlag = 0 ;
Point3d ptCurrMinDist ;
if ( DistPointCurve( ptStart, *pCompoOffsLoop).GetMinDistPoint( 0., ptCurrMinDist, nFlag)) {
double dCurrSqDist = SqDist( ptStart, ptCurrMinDist) ;
if ( dCurrSqDist < dMinSqDist) {
dMinSqDist = dCurrSqDist ;
nIndOffsCrv = nOffsCrv ;
ptMinDist = ptCurrMinDist ;
}
}
}
if ( nIndOffsCrv == -1)
return nullptr ;
// associo le due curve
ICurveComposite* pCompoOffsLoop = vCompoOffsLoops[nIndOffsCrv] ;
double dParMinDist = 0. ;
pCompoOffsLoop->GetParamAtPoint( ptMinDist, dParMinDist, 10. * EPS_SMALL) ;
pCompoOffsLoop->ChangeStartPoint( dParMinDist) ;
#if DEBUG
Color _cCol = Color( double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, double( rand()) / RAND_MAX, 1.) ;
VT.emplace_back( pCompoLoop->Clone()) ;
VC.emplace_back( _cCol) ;
VT.emplace_back( pCompoOffsLoop->Clone()) ;
VC.emplace_back( _cCol) ;
#endif
// creo la superficie tra queste due curve e la oriento in modo da definire un volume
pCompoLoop->Invert() ;
PtrOwner<ISurfTriMesh> pStmRuled( GetSurfTriMeshRuled( pCompoLoop, pCompoOffsLoop, ISurfTriMesh::RuledType::RLT_MINDIST)) ;
if ( IsNull( pStmRuled) || ! pStmRuled->IsValid() ||
! vStmRuled.emplace_back( Release( pStmRuled)))
return nullptr ;
#if DEBUG
LOG_INFO( GetEGkLogger(), ( string{ "Strip generation : "} + ToString( PC.Stop())).c_str()) ;
VT.emplace_back( vStmRuled.back()->Clone()) ;
VC.emplace_back( _cCol) ;
_cCol.SetAlpha( .5) ;
#endif
}
#if DEBUG
SaveGeoObj( VT, VC, "C:\\Temp\\Strips.nge") ;
PC.Start() ;
#endif
// compongo la superficie finale
PtrOwner<ISurfTriMesh> pStmOrig( CloneSurfTriMesh( pStm)) ;
if ( IsNull( pStmOrig) || ! pStmOrig->IsValid())
return nullptr ;
PtrOwner<ISurfTriMesh> pStmRef( Release( pStmOrig)) ;
if ( IsNull( pStmRef) || ! pStmRef->IsValid())
return nullptr ;
for ( int nStrip = 0 ; nStrip < int( vStmRuled.size()) ; ++ nStrip) {
if ( ! pStmRef->DoSewing( *vStmRuled[nStrip]))
return nullptr ;
}
if ( ! pStmRef->DoSewing( *pStmOffs))
return nullptr ;
pStmRef->Repair() ;
#if DEBUG
LOG_INFO( GetEGkLogger(), ( string{ "Sewing : "} + ToString( PC.Stop())).c_str()) ;
#endif
return ( ( ! IsNull( pStmRef) && pStmRef->IsValid()) ? Release( pStmRef) : nullptr) ;
}
Tree.cpp
+111 -76
View File
@@ -455,11 +455,46 @@ Tree::Split( int nId, double dSplitValue)
{
Cell& cToSplit = m_mTree.at(nId) ;
// controllo che lo split non venga fatto sul lato della cella
if ( ( cToSplit.IsSplitVert() && dSplitValue > cToSplit.GetBottomLeft().x + EPS_SMALL &&
dSplitValue < cToSplit.GetTopRight().x - EPS_SMALL) ||
( ! cToSplit.IsSplitVert() && dSplitValue > cToSplit.GetBottomLeft().y + EPS_SMALL &&
dSplitValue < cToSplit.GetTopRight().y - EPS_SMALL)) {
// quando si implementerà lo split a parametro libero bisognerà impedire che si facciano split troppo vicini al bordo della cella!!!!!!!!!!!!!!!!!!!
bool bGoodSplitVert = cToSplit.IsSplitVert() && dSplitValue > cToSplit.GetBottomLeft().x + 10 * EPS_SMALL &&
dSplitValue < cToSplit.GetTopRight().x - 10 * EPS_SMALL ;
bool bGoodSplitHoriz = ! cToSplit.IsSplitVert() && dSplitValue > cToSplit.GetBottomLeft().y + 10 * EPS_SMALL &&
dSplitValue < cToSplit.GetTopRight().y - 10 * EPS_SMALL ;
Point3d ptP00, ptP01, ptP10, ptP11 ;
if( bGoodSplitVert) {
if( cToSplit.GetBottomRight().x - dSplitValue > dSplitValue - cToSplit.GetBottomLeft().x) {
GetPoint( cToSplit.GetBottomLeft().x, cToSplit.GetBottomLeft().y, ptP00) ;
GetPoint( dSplitValue, cToSplit.GetBottomRight().y, ptP10) ;
GetPoint( cToSplit.GetTopLeft().x, cToSplit.GetTopLeft().y, ptP01) ;
GetPoint( dSplitValue, cToSplit.GetTopRight().y, ptP11) ;
}
else {
GetPoint( dSplitValue, cToSplit.GetBottomLeft().y, ptP00) ;
GetPoint( cToSplit.GetBottomRight().x, cToSplit.GetBottomRight().y, ptP10) ;
GetPoint( dSplitValue, cToSplit.GetTopLeft().y, ptP01) ;
GetPoint( cToSplit.GetTopRight().x, cToSplit.GetTopRight().y, ptP11) ;
}
if( AreSamePointApprox( ptP00, ptP10) && AreSamePointApprox( ptP01, ptP11))
bGoodSplitVert = false ;
}
if( bGoodSplitHoriz) {
if( cToSplit.GetTopLeft().y - dSplitValue > dSplitValue - cToSplit.GetBottomLeft().y) {
GetPoint( cToSplit.GetBottomLeft().x, cToSplit.GetBottomLeft().y, ptP00) ;
GetPoint( cToSplit.GetBottomRight().x, cToSplit.GetBottomRight().y, ptP10) ;
GetPoint( cToSplit.GetTopLeft().x, dSplitValue, ptP01) ;
GetPoint( cToSplit.GetTopRight().x, dSplitValue, ptP11) ;
}
else {
GetPoint( cToSplit.GetBottomLeft().x, dSplitValue, ptP00) ;
GetPoint( cToSplit.GetBottomRight().x, dSplitValue, ptP10) ;
GetPoint( cToSplit.GetTopLeft().x, cToSplit.GetTopLeft().y, ptP01) ;
GetPoint( cToSplit.GetTopRight().x, cToSplit.GetTopRight().y, ptP11) ;
}
if( AreSamePointApprox( ptP00, ptP01) && AreSamePointApprox( ptP10, ptP11))
bGoodSplitHoriz = false ;
}
if ( bGoodSplitVert || bGoodSplitHoriz) {
cToSplit.m_dSplit = dSplitValue ;
Cell cChild1, cChild2 ;
cChild1.m_nDepth = cToSplit.m_nDepth + 1 ;
@@ -728,13 +763,13 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax)
// ( dSideMinVal è zero se entrambi i lati da splittare sono collassati in un punto, controllo dLengMinVal)
bool bSplit = false ;
bool bParamDimOk = false ;
if( bVert)
if ( bVert)
bParamDimOk = ( pcToSplit->GetTopRight().x - pcToSplit->GetBottomLeft().x) / 2 > 100 * EPS_PARAM ;
else
bParamDimOk = ( pcToSplit->GetTopRight().y - pcToSplit->GetBottomLeft().y) / 2 > 100 * EPS_PARAM ;
bool bDimOk = ( dSideMinVal / 2 >= dSideMin || ( dSideMinVal < EPS_SMALL && dLengMinVal / 2 >= dSideMin)) && bParamDimOk ;
if ( dSideMaxVal > dSideMax) {
bSplit = true ;
bSplit = true ;
//LOG_DBG_INFO( GetEGkLogger(), " Split by SideMax")
}
else if ( dSagV > dLinTol || dSagU > dLinTol) {
@@ -746,18 +781,19 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax)
if ( bSplit) {
pcToSplit->SetSplitDirVert( bVert) ;
// effettuo lo split
Split( nCToSplit) ;
// procedo con lo split del Child1
nCToSplit = pcToSplit->m_nChild1 ;
pcToSplit = &m_mTree[nCToSplit] ;
if ( Split( nCToSplit)) {
// procedo con lo split del Child1
nCToSplit = pcToSplit->m_nChild1 ;
pcToSplit = &m_mTree[nCToSplit] ;
}
}
else {
// sono arrivato ad una cella Leaf, quindi salvo la cella
m_vnLeaves.push_back( nCToSplit) ;
pcToSplit->SetProcessed() ;
if( AreSamePointApprox( ptP00, ptP01) && AreSamePointApprox( ptP10, ptP11))
if ( AreSamePointApprox( ptP00, ptP01) && AreSamePointApprox( ptP10, ptP11))
pcToSplit->m_nCollapsed = Cell::Collapsed::VERT_EDGES ;
else if( AreSamePointApprox( ptP00, ptP10) && AreSamePointApprox( ptP01, ptP11))
else if ( AreSamePointApprox( ptP00, ptP10) && AreSamePointApprox( ptP01, ptP11))
pcToSplit->m_nCollapsed = Cell::Collapsed::HORIZ_EDGES ;
else
pcToSplit->m_nCollapsed = Cell::Collapsed::NO_COLLAPSE ;
@@ -858,22 +894,23 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax)
if ( dSideMinVal / 2 >= dSideMin && dSideMaxVal < dSideMax && dErr > dLinTol) {
pcToSplit->SetSplitDirVert( bVert) ;
// effettuo lo split
Split( nCToSplit) ;
// procedo con lo split del Child1
nCToSplit = pcToSplit->m_nChild1 ;
pcToSplit = &m_mTree[nCToSplit] ;
if ( Split( nCToSplit)){
// procedo con lo split del Child1
nCToSplit = pcToSplit->m_nChild1 ;
pcToSplit = &m_mTree[nCToSplit] ;
}
}
else {
// sono arrivato ad una cella Leaf, quindi salvo la cella
m_vnLeaves.push_back( nCToSplit) ;
pcToSplit->SetProcessed() ;
if( AreSamePointApprox( ptP00, ptP01) && AreSamePointApprox( ptP10, ptP11))
if ( AreSamePointApprox( ptP00, ptP01) && AreSamePointApprox( ptP10, ptP11))
pcToSplit->m_nCollapsed = Cell::Collapsed::VERT_EDGES ;
else if( AreSamePointApprox( ptP00, ptP10) && AreSamePointApprox( ptP01, ptP11))
else if ( AreSamePointApprox( ptP00, ptP10) && AreSamePointApprox( ptP01, ptP11))
pcToSplit->m_nCollapsed = Cell::Collapsed::HORIZ_EDGES ;
else
else {
pcToSplit->m_nCollapsed = Cell::Collapsed::NO_COLLAPSE ;
m_vnLeaves.push_back( nCToSplit) ;
}
// risalgo i parent finché non trovo il primo Child2 da processare
nCToSplit = pcToSplit->m_nParent ;
@@ -1473,7 +1510,7 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygonsBasic, POLYLINEVECTOR& vPolygon
int c = 0 ;
for ( int nId : m_vnLeaves) {
Cell& cell = m_mTree.at( nId) ;
if( cell.m_nCollapsed != Cell::Collapsed::NO_COLLAPSE)
if ( cell.m_nCollapsed != Cell::Collapsed::NO_COLLAPSE)
continue ;
vVertices.clear() ;
vVertices3d.clear() ;
@@ -1486,7 +1523,7 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygonsBasic, POLYLINEVECTOR& vPolygon
std::fill( vbBonusVert.begin(), vbBonusVert.end(), false) ;
vnVert.push_back( int(vVertices.size()) - 1) ;
GetBottomNeigh( nId, vNeigh) ;
if( ! vNeigh.empty() && m_mTree.at(vNeigh[0]).m_nCollapsed == Cell::Collapsed::VERT_EDGES)
if ( ! vNeigh.empty() && m_mTree.at(vNeigh[0]).m_nCollapsed == Cell::Collapsed::VERT_EDGES)
GetBottomNeigh( vNeigh[0], vNeigh, DBLDBL( cell.GetBottomLeft().x, cell.GetTopRight().x)) ;
Point3d ptP00, ptP10, ptP11, ptP01 ;
GetPoint( cell.GetBottomLeft().x, cell.GetBottomLeft().y, ptP00) ;
@@ -1522,7 +1559,7 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygonsBasic, POLYLINEVECTOR& vPolygon
bBottomRight = false ;
vNeigh.clear() ;
GetRightNeigh ( nId, vNeigh) ;
if( ! vNeigh.empty() && m_mTree.at(vNeigh[0]).m_nCollapsed == Cell::Collapsed::HORIZ_EDGES)
if ( ! vNeigh.empty() && m_mTree.at(vNeigh[0]).m_nCollapsed == Cell::Collapsed::HORIZ_EDGES)
GetRightNeigh( vNeigh[0], vNeigh, DBLDBL( cell.GetBottomLeft().y, cell.GetTopRight().y)) ;
// aggiungo i vertici che sono sul lato right, solo se ho più di un vicino right
if ( vNeigh.size() > 1){
@@ -1564,7 +1601,7 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygonsBasic, POLYLINEVECTOR& vPolygon
vVertices3d.push_back( pt3d) ;
vnVert.push_back( int(vVertices.size()) - 1) ;
GetTopNeigh ( nId, vNeigh) ;
if( ! vNeigh.empty() && m_mTree.at(vNeigh[0]).m_nCollapsed == Cell::Collapsed::VERT_EDGES)
if ( ! vNeigh.empty() && m_mTree.at(vNeigh[0]).m_nCollapsed == Cell::Collapsed::VERT_EDGES)
GetTopNeigh( vNeigh[0], vNeigh, DBLDBL( cell.GetBottomLeft().x, cell.GetTopRight().x)) ;
std::reverse( vNeigh.begin(), vNeigh.end()) ;
// aggiungo i vertici che sono sul lato top, solo se ho più di un vicino top
@@ -1596,7 +1633,7 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygonsBasic, POLYLINEVECTOR& vPolygon
bTopLeft = false ;
vNeigh.clear() ;
GetLeftNeigh ( nId, vNeigh) ;
if( ! vNeigh.empty() && m_mTree.at(vNeigh[0]).m_nCollapsed == Cell::Collapsed::HORIZ_EDGES)
if ( ! vNeigh.empty() && m_mTree.at(vNeigh[0]).m_nCollapsed == Cell::Collapsed::HORIZ_EDGES)
GetLeftNeigh( vNeigh[0], vNeigh, DBLDBL( cell.GetBottomLeft().y, cell.GetTopRight().y)) ;
std::reverse( vNeigh.begin(), vNeigh.end()) ;
// aggiungo i vertici che sono sul lato left, solo se ho più di un vicino left
@@ -1679,7 +1716,7 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygonsBasic, POLYLINEVECTOR& vPolygon
bAlreadyCropped = true ;
}
if ( AreSamePointApprox(ptP10, ptP11)) {
if( bAlreadyCropped)
if ( bAlreadyCropped)
continue ;
// sennò devo togliere l'estremo del lato su cui NON ho punti bonus
if ( vbBonusVert[0] && ! vbBonusVert[2]){ // lati contati a partire da quello sopra in senso CCW
@@ -1707,7 +1744,7 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygonsBasic, POLYLINEVECTOR& vPolygon
bAlreadyCropped = true ;
}
if ( AreSamePointApprox(ptP11, ptP01)) {
if( bAlreadyCropped)
if ( bAlreadyCropped)
continue ;
// sennò devo togliere l'estremo del lato su cui NON ho punti bonus
if ( vbBonusVert[1] && ! vbBonusVert[3]){ // lati contati a partire da quello sopra in senso CCW
@@ -1735,7 +1772,7 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygonsBasic, POLYLINEVECTOR& vPolygon
bAlreadyCropped = true ;
}
if ( AreSamePointApprox(ptP01, ptP00)) {
if( bAlreadyCropped)
if ( bAlreadyCropped)
continue ;
// sennò devo togliere l'estremo del lato su cui NON ho punti bonus
if ( vbBonusVert[0] && ! vbBonusVert[2]) { // lati contati a partire da quello sopra in senso CCW
@@ -1801,10 +1838,10 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygonsBasic, POLYLINEVECTOR& vPolygon
int nVertCorr = int(vVerticesCorr.size());
for ( int i = 0 ; i < (int) vVertices.size() ; ++i) {
int dPar = i ;
if( ! vbKeepPoint[i])
if ( ! vbKeepPoint[i])
dPar = -1 ;
vPolygonsBasic.back().AddUPoint( dPar, vVertices.at( i)) ;
if( i < nVertCorr){
if ( i < nVertCorr){
vPolygonsCorrected.back().AddUPoint( dPar, vVerticesCorr.at( i)) ;
vPolygons3d.back().AddUPoint( dPar, vVertices3d.at( i)) ;
}
@@ -2000,7 +2037,7 @@ Tree::UpdateSplitLoop( ICurveComposite* pCC, Point3d& pt)
}
bAdded = true ;
}
if( pCC->IsValid()) {
if ( pCC->IsValid()) {
if ( ! bAdded)
pCC->AddLine( pt) ;
Vector3d vtDir = pt - ptLast ;
@@ -2131,7 +2168,7 @@ Tree::TraceLoopLabelCell( const POLYLINEVECTOR& vplPolygons)
UpdateSplitLoop( pCCLoopSplit, vptInters.back()) ;
}
// controllo di aggiungere un punto abbastanza distante dal precedente
if( ! AreSamePointXYEpsilon( vptInters.back(), ptCurr, 10 * EPS_SMALL)) {
if ( ! AreSamePointXYEpsilon( vptInters.back(), ptCurr, 10 * EPS_SMALL)) {
// aggiungo la fine del segmento nel vettore delle intersezioni
vptInters.push_back( ptCurr) ;
// aggiorno la compo splittata
@@ -2370,7 +2407,7 @@ Tree::FindInters( int& nId, const CurveLine& clTrim, const PolyLine& plPolygon,
if ( icc.GetOverlaps()) {
for ( int i = 0 ; i < icc.GetIntersCount() ; ++i) {
icc.GetIntCrvCrvInfo( i, iccInfo) ;
if( iccInfo.bOverlap){
if ( iccInfo.bOverlap){
ptInters = iccInfo.IciA[1].ptI ;
break ;
}
@@ -2378,14 +2415,14 @@ Tree::FindInters( int& nId, const CurveLine& clTrim, const PolyLine& plPolygon,
}
else {
int nLastInters = icc.GetIntersCount() -1 ;
if( nLastInters < 0)
if ( nLastInters < 0)
return false ;
icc.GetIntCrvCrvInfo( nLastInters, iccInfo) ;
ptInters = iccInfo.IciA[0].ptI ;
}
// determino il lato/vertice di uscita
if( ! OnWhichEdge( nId, ptInters, nEdge))
if ( ! OnWhichEdge( nId, ptInters, nEdge))
return false ;
pCell->m_vInters.back().nOut = nEdge ;
// se è risultato che sono abbastanza vicino( di EPS_SMALL) ad un vertice allora il punto aggiunto sarà il vertice vero e proprio
@@ -2746,10 +2783,10 @@ Tree::FindInters( int& nId, const CurveLine& clTrim, const PolyLine& plPolygon,
//----------------------------------------------------------------------------
bool
Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX& vPolygons3d, INTVECTOR& vToCheck, int& nPoly, INTVECTOR& vnParentChunk,
const PolyLine& plCell, const PolyLine& plCell3d)
Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX& vPolygons3d, INTVECTOR& vToCheck, int& nPoly,
INTVECTOR& vnParentChunk, const PolyLine& plCell, const PolyLine& plCell3d)
{
// conto quanti vertici in più ho per lato e creo un vettore dei vertici per lato
// conto quanti vertici in più ho per lato e creo un vettore dei vertici per lato
int nId = m_vnLeaves[nLeafId] ;
Cell& cCell = m_mTree[nId] ;
PNTMATRIX vEdgeVertex(4) ;
@@ -2759,38 +2796,36 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX
Point3d ptTl = cCell.GetTopLeft() ;
Point3d ptBr = cCell.GetBottomRight() ;
int nVertToErase = m_mTree.at(nId).m_nVertToErase ;
if( nVertToErase != 2)
if ( nVertToErase != 2)
vEdgeVertex[0].push_back( ptTR) ;
if( nVertToErase != 3)
if ( nVertToErase != 3)
vEdgeVertex[1].push_back( ptTl) ;
if( nVertToErase != 0)
if ( nVertToErase != 0)
vEdgeVertex[2].push_back( ptBL) ;
if( nVertToErase != 1)
if ( nVertToErase != 1)
vEdgeVertex[3].push_back( ptBr) ;
// capisco se sono in modalità ForTriangulation
bool bForTriangulation = plCell3d.GetPointNbr() != 0 ;
if ( bForTriangulation) {
if( nVertToErase != 2) {
if ( nVertToErase != 2) {
Point3d pt3d ; GetPoint( cCell.GetTopRight().x, cCell.GetTopRight().y, pt3d) ;
vEdgeVertex3d[0].push_back( pt3d) ;
}
if( nVertToErase != 3){
if ( nVertToErase != 3) {
Point3d pt3d ; GetPoint( cCell.GetBottomLeft().x, cCell.GetTopRight().y, pt3d) ;
vEdgeVertex3d[1].push_back( pt3d) ;
}
if( nVertToErase != 0) {
if ( nVertToErase != 0) {
Point3d pt3d ; GetPoint( cCell.GetBottomLeft().x, cCell.GetBottomLeft().y, pt3d) ;
vEdgeVertex3d[2].push_back( pt3d) ;
}
if( nVertToErase != 1) {
if ( nVertToErase != 1) {
Point3d pt3d ; GetPoint( cCell.GetTopRight().x, cCell.GetBottomLeft().y, pt3d) ;
vEdgeVertex3d[3].push_back( pt3d) ;
}
}
// la PolyLine è riempita a partire dal lato bottom
// la PolyLine è riempita a partire dal lato bottom
Point3d ptStart, pt3d ;
plCell.GetFirstPoint( ptStart) ;
if ( bForTriangulation)
@@ -3052,7 +3087,7 @@ Tree::CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX
if ( dArea > 0) {
vPolygons.emplace_back() ;
vPolygons.back().push_back(std::move(plTrimmedPoly)) ;
if( bForTriangulation) {
if ( bForTriangulation) {
vPolygons3d.emplace_back() ;
vPolygons3d.back().push_back(std::move(plTrimmedPoly3d)) ;
}
@@ -3108,7 +3143,7 @@ Tree::CreateIslandAndHoles( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATR
nChunkBiggestCW = inA.nChunk ;
bContained = false ;
Inters inB = cCell.m_vInters[0] ;
for( int c = 0 ; c < nInters ; ++ c){
for ( int c = 0 ; c < nInters ; ++ c){
inB = cCell.m_vInters[c] ;
if ( inB.nIn == -1) {
if ( inB != inA && inB.nChunk == inA.nChunk && inB.bCCW) {
@@ -3367,12 +3402,12 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
int nVertToSkip = m_mTree.at(nId).m_nVertToErase ;
// se è il primo punto della PolyLine lo aggiungo
if ( plTrimmedPoly.GetPointNbr() == 0) {
// se cerco di aggiungere il vertice che devo saltare, non faccio nulla
if( ( nVertToSkip == 0 && AreSamePointXYApprox( ptToAdd, ptBL)) ||
// se cerco di aggiungere il vertice che devo saltare, non faccio nulla
if (( nVertToSkip == 0 && AreSamePointXYApprox( ptToAdd, ptBL)) ||
( nVertToSkip == 1 && AreSamePointXYApprox( ptToAdd, ptBr)) ||
( nVertToSkip == 2 && AreSamePointXYApprox( ptToAdd, ptTR)) ||
( nVertToSkip == 3 && AreSamePointXYApprox( ptToAdd, ptTl))) {
// aggiorno l'ultimo punto aggiunto
// aggiorno l'ultimo punto aggiunto
ptLast.Set( ptToAdd.x, ptToAdd.y, 0) ;
return true ;
}
@@ -3421,7 +3456,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
ptVert = ptToAdd ;
if ( nVert != nVertToSkip) {
plTrimmedPoly.AddUPoint( c, ptVert) ;
if( bForTriangulation){
if ( bForTriangulation){
Point3d pt3d ; GetPoint( ptVert.x, ptVert.y, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
@@ -3439,7 +3474,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
Point3d ptIntermed = vEdgeVertex[0][t] ;
if ( ptIntermed.x > ptToAdd.x && ptIntermed.x < ptLast.x) {
plTrimmedPoly.AddUPoint( c, ptIntermed) ;
if( bForTriangulation)
if ( bForTriangulation)
plTrimmedPoly3d.AddUPoint( c, vEdgeVertex3d[0][t]) ;
++ c ;
}
@@ -3447,7 +3482,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
bool bVert = AreSamePointXYApprox( ptToAdd, ptTl) ;
if ( ! ( nVertToSkip == 3 && bVert)) {
plTrimmedPoly.AddUPoint( c, ptToAdd) ;
if( bForTriangulation){
if ( bForTriangulation){
Point3d pt3d ; GetPoint( ptToAdd.x, ptToAdd.y, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
@@ -3460,7 +3495,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
Point3d ptIntermed = vEdgeVertex[1][t] ;
if ( ptIntermed.y > ptToAdd.y && ptIntermed.y < ptLast.y) {
plTrimmedPoly.AddUPoint( c, ptIntermed) ;
if( bForTriangulation)
if ( bForTriangulation)
plTrimmedPoly3d.AddUPoint( c, vEdgeVertex3d[1][t]) ;
++ c ;
}
@@ -3468,7 +3503,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
bool bVert = AreSamePointXYApprox( ptToAdd, ptBL) ;
if ( ! ( nVertToSkip == 0 && bVert)) {
plTrimmedPoly.AddUPoint( c, ptToAdd) ;
if( bForTriangulation) {
if ( bForTriangulation) {
Point3d pt3d ; GetPoint( ptToAdd.x, ptToAdd.y, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
@@ -3481,7 +3516,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
Point3d ptIntermed = vEdgeVertex[2][t] ;
if ( ptIntermed.x < ptToAdd.x && ptIntermed.x > ptLast.x) {
plTrimmedPoly.AddUPoint( c, ptIntermed) ;
if( bForTriangulation)
if ( bForTriangulation)
plTrimmedPoly3d.AddUPoint( c, vEdgeVertex3d[2][t]) ;
++ c ;
}
@@ -3489,7 +3524,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
bool bVert = AreSamePointXYApprox( ptToAdd, ptBr) ;
if ( ! ( nVertToSkip == 1 && bVert)) {
plTrimmedPoly.AddUPoint( c, ptToAdd) ;
if( bForTriangulation){
if ( bForTriangulation){
Point3d pt3d ; GetPoint( ptToAdd.x, ptToAdd.y, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
@@ -3502,7 +3537,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
Point3d ptIntermed = vEdgeVertex[3][t] ;
if ( ptIntermed.y < ptToAdd.y && ptIntermed.y > ptLast.y) {
plTrimmedPoly.AddUPoint( c, ptIntermed) ;
if( bForTriangulation)
if ( bForTriangulation)
plTrimmedPoly3d.AddUPoint( c, vEdgeVertex3d[3][t]) ;
++ c ;
}
@@ -3510,7 +3545,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
bool bVert = AreSamePointXYApprox( ptToAdd, ptTR) ;
if ( ! ( nVertToSkip == 2 && bVert)) {
plTrimmedPoly.AddUPoint( c, ptToAdd) ;
if( bForTriangulation) {
if ( bForTriangulation) {
Point3d pt3d ; GetPoint( ptToAdd.x, ptToAdd.y, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
@@ -3521,7 +3556,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
// aggiungo e basta
else {
plTrimmedPoly.AddUPoint( c, ptToAdd) ;
if( bForTriangulation) {
if ( bForTriangulation) {
Point3d pt3d ; GetPoint( ptToAdd.x, ptToAdd.y, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
@@ -3531,7 +3566,7 @@ Tree::AddVertex( int nId, const PNTMATRIX& vEdgeVertex, const PNTMATRIX& vEdgeVe
// non su un edge, quindi aggiungo e basta
else {
plTrimmedPoly.AddUPoint( c, ptToAdd) ;
if( bForTriangulation) {
if ( bForTriangulation) {
Point3d pt3d ; GetPoint( ptToAdd.x, ptToAdd.y, pt3d) ;
plTrimmedPoly3d.AddUPoint( c, pt3d) ;
}
@@ -4010,14 +4045,14 @@ Tree::GetEdges3D( vector<ICRVCOMPOPOVECTOR>& mCCEdges, POLYLINEVECTOR& vPolygons
// scorro sui poligoni delle celle di un lato
for ( int c = 0 ; c < int( vEdges[i].size()) ; ++c) {
Cell& cNeigh = m_mTree.at(vEdges[i][c]) ;
if( cNeigh.m_vnPolyId.empty())
if ( cNeigh.m_vnPolyId.empty())
continue ;
PolyLine& plCell = vPolygons[cNeigh.m_vnPolyId[0]] ;
Point3d pt ; plCell.GetFirstPoint( pt) ;
Point3d pt3d ;
// a seconda del lato controllo di stare scorrendo il poligono prendendo solo i punti su quel lato
if ( i == 0) {
while ( ! AreSamePointXYApprox(pt, cNeigh.GetTopRight()) && plCell.GetNextPoint(pt) ) {
while ( ! AreSamePointXYApprox(pt, cNeigh.GetTopRight()) && plCell.GetNextPoint(pt)) {
continue ;
}
Point3d pt3d ; GetPoint( cNeigh.GetTopRight().x, cNeigh.GetTopRight().y, pt3d) ;
@@ -4090,13 +4125,13 @@ Tree::GetEdges3D( vector<ICRVCOMPOPOVECTOR>& mCCEdges, POLYLINEVECTOR& vPolygons
mCCEdges.emplace_back() ;
INTVECTOR vId ;
Point3d ptNear = m_mTree.at(-1).GetBottomLeft() ;
while( m_vCEdge2D[i].second.GetChainFromNear(ptNear, false, vId) ) {
while ( m_vCEdge2D[i].second.GetChainFromNear(ptNear, false, vId)) {
PtrOwner<ICurveComposite> pCC3D( CreateCurveComposite()) ;
int nInd = abs( vId[0]) - 1 ;
Point3d pt2D = m_vCEdge2D[i].first[nInd].first ;
Point3d pt3D ; GetPoint( pt2D.x, pt2D.y, pt3D) ;
pCC3D->AddPoint( pt3D) ;
for ( int j = 1 ; j < int( vId.size()) ; ++j) {
for ( int j = 1 ; j < ssize( vId) ; ++j) {
nInd = abs( vId[j]) - 1 ;
pt2D = m_vCEdge2D[i].first[nInd].second ;
GetPoint( pt2D.x, pt2D.y, pt3D) ;
@@ -4105,7 +4140,7 @@ Tree::GetEdges3D( vector<ICRVCOMPOPOVECTOR>& mCCEdges, POLYLINEVECTOR& vPolygons
if ( ! pCC3D->IsValid())
pCC3D->AddPoint( pt3D) ;
// qui devo fare dei controlli prima di aggiungere questa polyline?
mCCEdges[i].emplace_back( Release(pCC3D)) ;
mCCEdges[i].emplace_back( Release( pCC3D)) ;
}
}
}
@@ -4225,11 +4260,11 @@ Tree::AdjustCuts( void)
bool
Tree::CreateCellContour( POLYLINEMATRIX& vPolygons)
{
// questa funzione è pensata per essere chiamata dopo la AddCutsToRoot, per creare il poligono di un'unica cella a cui sono stati aggiunti dei tagli
// questa funzione è pensata per essere chiamata dopo la AddCutsToRoot, per creare il poligono di un'unica cella a cui sono stati aggiunti dei tagli
if ( m_mTree.size() > 1)
return false ;
int nRoot = -1 ;
// preparo tutto per poter chiamare la createCellPolygon
// preparo tutto per poter chiamare la createCellPolygon
m_vnLeaves.push_back( nRoot) ;
INTVECTOR vToCheck( m_mTree.at(nRoot).m_vInters.size()) ;
iota( vToCheck.begin(), vToCheck.end(), 0) ;
@@ -4254,7 +4289,7 @@ Tree::CreateCellContour( POLYLINEMATRIX& vPolygons)
pl3d.Close() ;
// ora posso creare il poligono della cella con i tagli
POLYLINEMATRIX vPolygons3d ;
while( ! vToCheck.empty()) {
while ( ! vToCheck.empty()) {
int nPolyBefore = nPoly ;
CreateCellPolygons( 0, vPolygons, vPolygons3d, vToCheck, nPoly, vnParentChunk, pl, pl3d) ;
// l'aggiunta di vPolygons3d forse è un problema in questo punto.
@@ -4264,4 +4299,4 @@ Tree::CreateCellContour( POLYLINEMATRIX& vPolygons)
break ;
}
return true ;
}
}
VolZmap.cpp
+9 -1
View File
@@ -507,11 +507,15 @@ VolZmap::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
}
// passo al punto successivo
dX += m_dStep ;
if ( m_nMapNum == N_MAPS)
dX = min( dX, m_dMaxZ[1]) ;
}
// passo alla riga successiva
dY += m_dStep ;
if ( m_nMapNum == N_MAPS)
dY = min( dY, m_dMaxZ[2]) ;
}
//
return true ;
}
@@ -551,9 +555,13 @@ VolZmap::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
}
// passo al punto successivo
dX += m_dStep ;
if ( m_nMapNum == N_MAPS)
dX = min( dX, m_dMaxZ[1]) ;
}
// passo alla riga successiva
dY += m_dStep ;
if ( m_nMapNum == N_MAPS)
dY = min( dY, m_dMaxZ[2]) ;
}
return true ;
VolZmap.h
+5 -2
View File
@@ -472,15 +472,18 @@ class VolZmap : public IVolZmap, public IGeoObjRW
bool UpdateVolZMapBySurfThickeningSharpedOffset( const ISurfTriMesh* Surf, int nType, double dOffs, double dTol) ;
bool CreateOffsetSphereOnVertex( const Point3d& ptV, double dOffs, int nGrid, int nVertexType = 0) ;
bool CreateOffsetCylinderOnEdge( const Point3d& ptP1, const Point3d& ptP2, double dOffs, int nGrid, int nVertexType = 0) ;
bool CreateFatOffsetExtrusionFace( const ISurfTriMesh* Surf, double dOffs, bool bThickle) ;
bool CreateFatOffsetExtrusionFace( const ISurfTriMesh* Surf, double dOffs, bool bThickle, int nTool = 0) ;
bool CreateOrientedOffsetExtrusionFace( const ISurfTriMesh* Surf, double dOffs) ;
bool SubtractIntervalsForOffset( int nGrid, int nI, int nJ,
double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax,
int nToolNum, bool bSkipSwap = false) ;
bool AddIntervalsForOffset( int nGrid, int nI, int nJ,
double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax,
int nToolNum, bool bSkipSwap = false) ;
int nToolMin, int nToolMax, bool bSkipSwap = false) ;
bool CutByPlaneForOffset( const Plane3d& plCut) ;
bool AddSurfTmForOffset( const ISurfTriMesh* pStm, int nTool) ;
bool AddMapPartForOffset( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, const Vector3d& vtLen, const Point3d& ptMapOrig,
const ISurfTriMesh& Surf, int nTool, IntersParLinesSurfTm& intPLSTM) ;
// Funzioni per Offset di Zmap
bool OffsetFillet( double dOffs) ;
bool OffsetSharped( double dOffs, int nType) ;
VolZmapCalculus.cpp
+23 -22
View File
@@ -2294,7 +2294,7 @@ VolZmap::IntersLineConus( const Point3d& ptLineSt, const Vector3d& vtLineDir,
vtN1.Normalize() ;
}
// altrimenti piano inferiore
else if( nBasInt == 1) {
else if ( nBasInt == 1) {
// Punto di intersezione
ptInt2 = ptP + vdRoots[0] * vtV ;
// Normale alla superficie del cono verso l'interno
@@ -3080,17 +3080,18 @@ VolZmap::GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) c
return false ;
// Se c'è intersezione valuto tutti i voxel interni
if ( TestIntersPlaneBox( plPlaneLoc, b3BlockBox)) {
// Ciclo sui voxel del blocco.
// Triangoli smooth
for ( int nV = 0 ; nV < int( m_BlockSmoothTria[nB].size()) ; ++ nV) {
// ciclo sui voxel del blocco.
for ( int nV = 0 ; nV < ssize( m_BlockSmoothTria[nB]) ; ++ nV) {
// Box del voxel
BBox3d b3Vox ;
GetVoxelBox( m_BlockSmoothTria[nB][nV].i, m_BlockSmoothTria[nB][nV].j, m_BlockSmoothTria[nB][nV].k, b3Vox) ;
// Se non c'è intersezione col voxel, passo al successivo.
// Se non c'è intersezione col voxel, passo al successivo.
if ( ! TestIntersPlaneBox( plPlaneLoc, b3Vox))
continue ;
for ( int nT = 0 ; nT < int( m_BlockSmoothTria[nB][nV].vTria.size()) ; ++ nT) {
Triangle3d trTria = m_BlockSmoothTria[nB][nV].vTria[nT] ;
// ciclo sui triangoli del voxel
for ( int nT = 0 ; nT < ssize( m_BlockSmoothTria[nB][nV].vTria) ; ++ nT) {
const Triangle3d& trTria = m_BlockSmoothTria[nB][nV].vTria[nT] ;
Point3d ptSt, ptEn ;
int nIntersType = IntersPlaneTria( plPlane, trTria, ptSt, ptEn) ;
if ( nIntersType == IPTT_EDGE || nIntersType == IPTT_YES) {
@@ -3102,18 +3103,18 @@ VolZmap::GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) c
}
}
// Triangoli sharp interni al blocco
for ( int nV = 0 ; nV < int( m_BlockSharpTria[nB].size()) ; ++ nV) {
// ciclo sui voxel del blocco.
for ( int nV = 0 ; nV < ssize( m_BlockSharpTria[nB]) ; ++ nV) {
// Box del voxel
BBox3d b3Vox ;
GetVoxelBox( m_BlockSharpTria[nB][nV].i, m_BlockSharpTria[nB][nV].j, m_BlockSharpTria[nB][nV].k, b3Vox) ;
// Se non c'è intersezione col voxel, passo al successivo.
// Ciclo sulle componenti connesse
for ( int nC = 0 ; nC < int( m_BlockSharpTria[nB][nV].vCompoTria.size()) ; ++ nC) {
for ( int nT = 0 ; nT < int( m_BlockSharpTria[nB][nV].vCompoTria[nC].size()) ; ++ nT) {
Triangle3d trTria = m_BlockSharpTria[nB][nV].vCompoTria[nC][nT] ;
for ( int nC = 0 ; nC < ssize( m_BlockSharpTria[nB][nV].vCompoTria) ; ++ nC) {
for ( int nT = 0 ; nT < ssize( m_BlockSharpTria[nB][nV].vCompoTria[nC]) ; ++ nT) {
const Triangle3d& trTria = m_BlockSharpTria[nB][nV].vCompoTria[nC][nT] ;
Point3d ptSt, ptEn ;
int nIntersType = IntersPlaneTria(plPlane, trTria, ptSt, ptEn) ;
if (nIntersType == IPTT_EDGE || nIntersType == IPTT_YES) {
int nIntersType = IntersPlaneTria( plPlane, trTria, ptSt, ptEn) ;
if ( nIntersType == IPTT_EDGE || nIntersType == IPTT_YES) {
// Costruisco il tratto di curva
CurveLine cvLine ;
if ( cvLine.Set(ptSt, ptEn))
@@ -3123,10 +3124,10 @@ VolZmap::GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) c
}
}
// Triangoli grandi del blocco
for ( int nT = 0 ; nT < int( m_BlockBigTria[nB].size()) ; ++ nT) {
Triangle3d trTria = m_BlockBigTria[nB][nT] ;
for ( int nT = 0 ; nT < ssize( m_BlockBigTria[nB]) ; ++ nT) {
const Triangle3d& trTria = m_BlockBigTria[nB][nT] ;
Point3d ptSt, ptEn ;
int nIntersType = IntersPlaneTria(plPlane, trTria, ptSt, ptEn) ;
int nIntersType = IntersPlaneTria( plPlane, trTria, ptSt, ptEn) ;
if ( nIntersType == IPTT_EDGE || nIntersType == IPTT_YES) {
// Costruisco il tratto di curva
CurveLine cvLine ;
@@ -3136,11 +3137,11 @@ VolZmap::GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) c
}
}
// In ogni caso valuto i triangoli sharp fra blocchi
for ( int nV = 0 ; nV < int( m_InterBlockSharpTria[nB].size()) ; ++ nV) {
for ( int nV = 0 ; nV < ssize( m_InterBlockSharpTria[nB]) ; ++ nV) {
// Ciclo sulle componenti connesse
for ( int nC = 0 ; nC < int( m_InterBlockSharpTria[nB][nV].vCompoTria.size()) ; ++ nC) {
for ( int nT = 0 ; nT < int( m_InterBlockSharpTria[nB][nV].vCompoTria[nC].size()) ; ++ nT) {
Triangle3d trTria = m_InterBlockSharpTria[nB][nV].vCompoTria[nC][nT] ;
for ( int nC = 0 ; nC < ssize( m_InterBlockSharpTria[nB][nV].vCompoTria) ; ++ nC) {
for ( int nT = 0 ; nT < ssize( m_InterBlockSharpTria[nB][nV].vCompoTria[nC]) ; ++ nT) {
const Triangle3d& trTria = m_InterBlockSharpTria[nB][nV].vCompoTria[nC][nT] ;
Point3d ptSt, ptEn ;
int nIntersType = IntersPlaneTria( plPlane, trTria, ptSt, ptEn) ;
if ( nIntersType == IPTT_EDGE || nIntersType == IPTT_YES) {
@@ -3156,9 +3157,9 @@ VolZmap::GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) c
// Creo i loop
ChainCurves LoopCreator ;
LoopCreator.Init( false, EPS_SMALL, int( vLine.size())) ;
LoopCreator.Init( false, EPS_SMALL, ssize( vLine)) ;
// Carico le curve per concatenarle
for ( int nCv = 0 ; nCv < int( vLine.size()) ; ++ nCv) {
for ( int nCv = 0 ; nCv < ssize( vLine) ; ++ nCv) {
Point3d ptSt = vLine[nCv].GetStart() ;
Point3d ptEn = vLine[nCv].GetEnd() ;
Vector3d vtDir; vLine[nCv].GetStartDir(vtDir) ;
VolZmapOffset.cpp
+747 -196
View File
File diff suppressed because it is too large Load Diff
VolZmapVolume.cpp
+6 -6
View File
@@ -935,7 +935,7 @@ VolZmap::TestCompoBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, con
BBox3d b3Box ;
if ( vtV.IsSmall())
b3Box = GetSphereMoveBBox( ptP1, ptP2, dRad) ;
else if( AreSameVectorExact( vtV2, V_NULL))
else if ( AreSameVectorExact( vtV2, V_NULL))
b3Box = GetCylMoveBBox( ptP1, ptP2, vtV, dMaxRad, dHei) ;
else
b3Box = GetCylMoveRotBBox( ptP1, ptP2, vtV, vtV2, dRad, dHei) ;
@@ -1385,7 +1385,7 @@ IntersLineBezierSurfSet( const Point3d& ptLineStart, const Vector3d& vtLineDir,
if ( vInterv.size() == 0)
bIntersVol = true ;
if( bIntersVol) {
if ( bIntersVol) {
// interseco con le bezier
for ( int s = 0 ; s < int( vSurfBez.size()) ; ++s) {
// se ho già trovato l'intersezione con questa superficie vado avanti
@@ -2699,7 +2699,7 @@ VolZmap::CylBall_ZDrilling( int nGrid, const Point3d & ptS, const Point3d & ptE,
double dMaxStemZ = max( max( ptS.z, ptTStemS.z), max( ptE.z, ptTStemE.z)) ;
for ( int i = nStartI ; i <= nEndI ; ++ i) {
for( int j = nStartJ ; j <= nEndJ ; ++ j) {
for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ;
Point3d ptC( dX, dY, 0) ; Vector3d vtC = ptC - ptSxy ;
@@ -2769,7 +2769,7 @@ VolZmap::CylBall_ZPerp( int nGrid, const Point3d& ptS, const Point3d& ptE, const
vtV2.Rotate( Z_AX, 0, 1) ;
for ( int i = nStartI ; i <= nEndI ; ++ i) {
for( int j = nStartJ ; j <= nEndJ ; ++ j) {
for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ;
@@ -3189,7 +3189,7 @@ VolZmap::Conus_ZPerp( int nGrid, const Point3d & ptS, const Point3d & ptE, const
Point3d ptVE = ptE - vtToolDir * ( dStemHeigth + dL) ;
for ( int i = nStartI ; i <= nEndI ; ++ i) {
for( int j = nStartJ ; j <= nEndJ ; ++ j) {
for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
double dX = ( i + 0.5) * m_dStep ;
double dY = ( j + 0.5) * m_dStep ;
@@ -3316,7 +3316,7 @@ VolZmap::Conus_ZPerp( int nGrid, const Point3d & ptS, const Point3d & ptE, const
Point3d ptVE = ptE - vtToolDir * ( CurrTool.GetHeigth() - dL) ;
for ( int i = nStartI ; i <= nEndI ; ++ i) {
for( int j = nStartJ ; j <= nEndJ ; ++ j) {
for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
double dX = ( i + 0.5) * m_dStep ;
double dY = ( j + 0.5) * m_dStep ;