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

Corretti errori vm additivo

Browse Source
This commit is contained in:
LorenzoM
2022-01-14 17:54:51 +01:00
parent 78d4d79cbf
commit 4f62467320
3 changed files with 112 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmapVolume.cpp
+106 -142
View File
@@ -315,7 +315,7 @@ VolZmap::AddIntervals( int nGrid, int nI, int nJ,
bool bModified = false ;
// Non esistono segmenti
if ( m_Values[nGrid][nPos].size() == 0) {
if ( int( vDexel.size()) == 0) {
vDexel.emplace_back() ;
vDexel.back().dMin = dMin ;
@@ -495,16 +495,6 @@ VolZmap::AddIntervals( int nGrid, int nI, int nJ,
if ( ! bModified)
return true ;
// Elimino residui di intervalli inutili
for ( int i = 0 ; i < int( vDexel.size()) ; ++ i) {
int nMaxN = int( floor( ( vDexel[i].dMax + 2 * EPS_SMALL - 0.5 * m_dStep) / m_dStep)) ;
int nMinN = int( floor( ( vDexel[i].dMin - 2 * EPS_SMALL - 0.5 * m_dStep) / m_dStep)) ;
if ( nMinN == nMaxN) {
vDexel.erase( vDexel.begin() + i) ;
-- i ;
}
}
// Imposto ricalcolo della grafica
m_OGrMgr.Reset() ;
// Imposto forma generica
@@ -737,9 +727,6 @@ VolZmap::MillingTranslationStep( const Point3d& ptPs, const Point3d& ptPe, const
Vector3d vtALs[N_MAPS] ;
InitializePointsAndVectors( ptPs, ptPe, vtD, vtA, ptLs, ptLe, vtLs, vtALs) ;
// Ciclo sulle mappe
/*for ( int i = 0 ; i < m_nMapNum ; ++ i) {
SelectMotion( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
}*/
vector< future<bool>> vRes ;
vRes.resize( m_nMapNum) ;
for ( int i = 0 ; i < m_nMapNum ; ++ i) {
@@ -7816,117 +7803,88 @@ VolZmap::AddingMotion( int nGrid, const Point3d& ptS, const Point3d& ptE, const
AddingCylinder( nGrid, ptS, ptE, vtAx, dHei, dRad) ;
}
else {
;
AddingGeneral( nGrid, ptS, ptE, vtAx) ;
}
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::AddingGeneral( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir)
VolZmap::AddingGeneral( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx)
{
//// Descrizione geometrica del moto
// Point3d ptI = ptS ;
// Point3d ptF = ptE ;
// Vector3d vtMove = ptE - ptS ;
//// Vettore delle normali agli archi
// const VCT3DVECTOR& vArcNorm = m_vTool[m_nCurrTool].GetArcNormalVec() ;
//// Poinch� l'asse utensile � parallelo all'asse Z, definisco un sistema di
//// riferimento ad hoc in cui le normali agli archi giacciano nel piano XZ.
// Frame3d frNormFrame ;
// frNormFrame.Set( ORIG, X_AX, -Z_AX, Y_AX) ;
//// Ciclo sulle curve del profilo
// const CurveComposite& ToolProfile = m_vTool[m_nCurrTool].GetApproxOutline() ;
// int i = - 1 ;
// const ICurve* pPrevCurve = nullptr ;
// const ICurve* pCurve = ToolProfile.GetCurve( ++ i) ;
// while ( pCurve != nullptr) {
//
// double dHeight = 0 ;
// // Se segmento
// if ( pCurve->GetType() == CRV_LINE) {
// // Recupero gli estremi
// const ICurveLine* pLine = GetCurveLine( pCurve) ;
// Point3d ptStart = pLine->GetStart() ;
// Point3d ptEnd = pLine->GetEnd() ;
// int nNormNum = pLine->GetTempProp();
// Vector3d vtNormSt, vtNormEn;
// if ( nNormNum != 0) {
// vtNormSt = vArcNorm[nNormNum - 1] ;
// vtNormEn = vArcNorm[nNormNum] ;
// vtNormSt.ToLoc(frNormFrame);
// vtNormEn.ToLoc(frNormFrame);
// }
// // Ne determino l'altezza
// dHeight = ptStart.y - ptEnd.y ;
// if ( dHeight > EPS_SMALL) {
// // verifiche curva precedente per eventuale tappo sopra
// if ( pPrevCurve != nullptr && pPrevCurve->GetType() == CRV_LINE) {
// const ICurveLine* pOthLine = GetCurveLine( pPrevCurve) ;
// Point3d ptOthStart = pOthLine->GetStart() ;
// Point3d ptOthEnd = pOthLine->GetEnd() ;
// }
// // verifiche curva successiva per eventuale tappo sotto
// int j = i ;
// const ICurve* pNextCurve = ToolProfile.GetCurve( ++ j) ;
// if ( pNextCurve != nullptr && pNextCurve->GetType() == CRV_LINE) {
// const ICurveLine* pOthLine = GetCurveLine( pNextCurve) ;
// Point3d ptOthStart = pOthLine->GetStart() ;
// Point3d ptOthEnd = pOthLine->GetEnd() ;
// }
// // Se X costante, � un cilindro
// if ( abs( ptStart.x - ptEnd.x) < EPS_SMALL) {
// double dRadius = ptStart.x ;
// if ( dRadius > 10 * EPS_SMALL) {
// CompCyl_Milling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius, bTapB, bTapT) ;
// }
// }
// // Se X crescente, � un cono con vettore equiverso a quello dell'utensile
// else if ( ptStart.x > ptEnd.x) {
// double dMaxRad = ptStart.x ;
// double dMinRad = ptEnd.x ;
// CompConus_Milling( nGrid, ptI, ptF, vtToolDir, dHeight, dMaxRad, dMinRad, bTapB, bTapT, vtNormSt, vtNormEn) ;
// }
// // Se X decrescente, � un cono con vettore opposto a quello dell'utensile
// else if ( ptStart.x < ptEnd.x) {
// double dMaxRad = ptEnd.x ;
// double dMinRad = ptStart.x ;
// Point3d ptIn = ptI - vtToolDir * dSignedHeight ;
// Point3d ptFn = ptIn + vtMove ;
// vtNormEn.z *= -1 ;
// vtNormSt.z *= -1 ;
// CompConus_Milling( nGrid, ptIn, ptFn, - vtToolDir, dHeight, dMaxRad, dMinRad, bTapT, bTapB, vtNormEn, vtNormSt) ;
// }
// }
// }
// Descrizione geometrica del moto
Point3d ptI = ptS ;
Point3d ptF = ptE ;
Vector3d vtMove = ptE - ptS ;
// Vettore delle normali agli archi
const VCT3DVECTOR& vArcNorm = m_vTool[m_nCurrTool].GetArcNormalVec() ;
// Poinché l'asse utensile è parallelo all'asse Z, definisco un sistema di
// riferimento ad hoc in cui le normali agli archi giacciano nel piano XZ.
Frame3d frNormFrame ;
frNormFrame.Set( ORIG, X_AX, -Z_AX, Y_AX) ;
// Ciclo sulle curve del profilo
const CurveComposite& ToolProfile = m_vTool[m_nCurrTool].GetApproxOutline() ;
int i = - 1 ;
const ICurve* pCurve = ToolProfile.GetCurve( ++ i) ;
while ( pCurve != nullptr) {
double dHeight = 0 ;
// // Se arco
// else if ( pCurve->GetType() == CRV_ARC) {
// // Recupero estremi, centro e raggio
// const ICurveArc* pArc = GetCurveArc( pCurve) ;
// Point3d ptStart ; pArc->GetStartPoint( ptStart) ;
// Point3d ptEnd ; pArc->GetEndPoint( ptEnd) ;
// Point3d ptCen = pArc->GetCenter() ;
// double dRadius = pArc->GetRadius() ;
// // Determino le posizioni iniziale e finale del centro della sfera
// Point3d ptCenS = ptI - vtToolDir * ( ptStart.y - ptCen.y) ;
// Point3d ptCenE = ptCenS + vtMove ;
// // Eseguo l'asportazione del materiale
// CompBall_Milling( nGrid, ptCenS, ptCenE, dRadius) ;
// // aggiorno l'altezza
// //dHeight = abs( ptStart.y - ptEnd.y) ;
// }
// Se segmento
if ( pCurve->GetType() == CRV_LINE) {
// Recupero gli estremi
const ICurveLine* pLine = GetCurveLine( pCurve) ;
Point3d ptStart = pLine->GetStart() ;
Point3d ptEnd = pLine->GetEnd() ;
int nNormNum = pLine->GetTempProp();
Vector3d vtNormSt, vtNormEn;
if ( nNormNum != 0) {
vtNormSt = vArcNorm[nNormNum - 1] ;
vtNormEn = vArcNorm[nNormNum] ;
vtNormSt.ToLoc(frNormFrame);
vtNormEn.ToLoc(frNormFrame);
}
// Ne determino l'altezza
dHeight = abs( ptStart.y - ptEnd.y) ;
if ( dHeight > EPS_SMALL) {
// Se X costante, è un cilindro
if ( abs( ptStart.x - ptEnd.x) < EPS_SMALL) {
double dRadius = ptStart.x ;
if (dRadius > 10 * EPS_SMALL)
AddingCylinder( nGrid, ptI, ptF, vtAx, dHeight, dRadius) ;
}
// Se X crescente, è un cono con vettore equiverso a quello dell'utensile
else if ( ptStart.x > ptEnd.x) {
double dMaxRad = ptStart.x ;
double dMinRad = ptEnd.x ;
AddingTruncatedCone( nGrid, ptI, ptF, vtAx, dMaxRad, dMinRad, dHeight, vtNormSt, vtNormEn) ;
}
// Se X decrescente, è un cono con vettore opposto a quello dell'utensile
else if ( ptStart.x < ptEnd.x) {
double dMaxRad = ptEnd.x ;
double dMinRad = ptStart.x ;
Point3d ptIn = ptI - vtAx * dHeight ;
Point3d ptFn = ptIn + vtMove ;
vtNormEn.z *= -1 ;
vtNormSt.z *= -1 ;
AddingTruncatedCone( nGrid, ptIn, ptFn, - vtAx, dMaxRad, dMinRad, dHeight, vtNormEn, vtNormSt) ;
}
// Passo alla curva successiva
pCurve = ToolProfile.GetCurve( ++ i) ;
}
else {
// Passo alla curva successiva
pCurve = ToolProfile.GetCurve( ++ i) ;
}
}
// // Determino le posizioni iniziale e finale del componente successivo
// ptI = ptI - vtToolDir * dSignedHeight ;
// ptF = ptI + vtMove ;
// Determino le posizioni iniziale e finale del componente successivo
ptI = ptI - vtAx * dHeight ;
ptF = ptI + vtMove ;
}
// // Passo alla curva successiva
// pPrevCurve = pCurve ;
// pCurve = ToolProfile.GetCurve( ++ i) ;
// }
// return true ;
return true ;
}
//----------------------------------------------------------------------------
@@ -7993,39 +7951,39 @@ VolZmap::AddingCylinder( int nGrid, const Point3d& ptS, const Point3d& ptE, cons
}
}
}
return true
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx,
double dHei, double dMaxRad, double dMinRad,
double dMaxRad, double dMinRad, double dHei,
const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR)
{
// Verifico interferenza
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtAx, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
return true ;
// Geometria del cono
double dDeltaR = dMaxRad - dMinRad ;
// Studio simmetrie
Point3d ptI = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) ;
Point3d ptF = ( vtToolDir * ( ptE - ptS) > 0 ? ptE : ptS) ;
Point3d ptI = ( vtAx * ( ptE - ptS) > 0 ? ptS : ptE) ;
Point3d ptF = ( vtAx * ( ptE - ptS) > 0 ? ptE : ptS) ;
double dL = ( dMaxRad * dHei) / dDeltaR ;
double dl = dL - dHei ;
Point3d ptV = ptI - vtToolDir * dL ;
Point3d ptV = ptI - vtAx * dL ;
// Vettori caratteristici del movimento
Vector3d vtMove = ptF - ptI ;
Vector3d vtMvLong = ( vtMove * vtToolDir) * vtToolDir ;
Vector3d vtMvLong = ( vtMove * vtAx) * vtAx ;
Vector3d vtMvOrt = vtMove - vtMvLong ;
// Terna destrorsa e unitaria
Vector3d vtV1 = vtToolDir ;
Vector3d vtV1 = vtAx ;
Vector3d vtV2 = vtMvOrt ; vtV2.Normalize() ;
Vector3d vtV3 = vtV1 ^ vtV2 ;
@@ -8080,7 +8038,7 @@ VolZmap::AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE,
for ( int i = nStartI ; i <= nEndI ; ++ i) {
for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ;
Point3d ptInt1, ptInt2 ;
@@ -8089,25 +8047,27 @@ VolZmap::AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE,
// Cono iniziale
ConusFrame.ChangeOrig( ptV) ;
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, true, true, ptInt1, vtN1, ptInt2, vtN2)) {
vtN1 *= - 1 ;
vtN2 *= - 1 ;
if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) {
if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtToolDir, 0.1 * EPS_SMALL)) {
if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtAx, 0.1 * EPS_SMALL)) {
Vector3d vtL1 = ptInt1 - ptV ;
vtL1 -= ( vtL1 * vtToolDir) * vtToolDir ;
vtL1 -= ( vtL1 * vtAx) * vtAx ;
double dL1 = vtL1.Len() ;
vtL1 /= dL1 ;
Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ((dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR;
vtOriginalN1.Normalize() ;
vtN1 = vtOriginalN1.z * vtToolDir + vtOriginalN1.x * vtL1 ;
vtN1 = vtOriginalN1.z * vtAx + vtOriginalN1.x * vtL1 ;
vtN1.Normalize() ;
}
if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtToolDir, 0.1 * EPS_SMALL)) {
if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtAx, 0.1 * EPS_SMALL)) {
Vector3d vtL2 = ptInt2 - ptV ;
vtL2 -= ( vtL2 * vtToolDir) * vtToolDir ;
vtL2 -= ( vtL2 * vtAx) * vtAx ;
double dL2 = vtL2.Len() ;
vtL2 /= dL2 ;
Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ;
vtOriginalN2.Normalize() ;
vtN2 = vtOriginalN2.z * vtToolDir + vtOriginalN2.x * vtL2 ;
vtN2 = vtOriginalN2.z * vtAx + vtOriginalN2.x * vtL2 ;
vtN2.Normalize() ;
}
}
@@ -8117,25 +8077,27 @@ VolZmap::AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE,
// Cono finale
ConusFrame.ChangeOrig( ptV + vtMove) ;
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, true, true, ptInt1, vtN1, ptInt2, vtN2)) {
vtN1 *= - 1 ;
vtN2 *= - 1 ;
if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) {
if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtToolDir, 0.1 * EPS_SMALL)) {
if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtAx, 0.1 * EPS_SMALL)) {
Vector3d vtL1 = ptInt1 - ptV - vtMove ;
vtL1 -= ( vtL1 * vtToolDir) * vtToolDir ;
vtL1 -= ( vtL1 * vtAx) * vtAx ;
double dL1 = vtL1.Len() ;
vtL1 /= dL1 ;
Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR ;
vtOriginalN1.Normalize() ;
vtN1 = vtOriginalN1.z * vtToolDir + vtOriginalN1.x * vtL1 ;
vtN1 = vtOriginalN1.z * vtAx + vtOriginalN1.x * vtL1 ;
vtN1.Normalize() ;
}
if ( ! AreSameOrOppositeVectorEpsilon(vtN2, vtToolDir, 0.1 * EPS_SMALL)) {
if ( ! AreSameOrOppositeVectorEpsilon(vtN2, vtAx, 0.1 * EPS_SMALL)) {
Vector3d vtL2 = ptInt2 - ptV - vtMove ;
vtL2 -= (vtL2 * vtToolDir) * vtToolDir;
vtL2 -= (vtL2 * vtAx) * vtAx;
double dL2 = vtL2.Len() ;
vtL2 /= dL2 ;
Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ;
vtOriginalN2.Normalize() ;
vtN2 = vtOriginalN2.z * vtToolDir + vtOriginalN2.x * vtL2 ;
vtN2 = vtOriginalN2.z * vtAx + vtOriginalN2.x * vtL2 ;
vtN2.Normalize() ;
}
}
@@ -8339,25 +8301,27 @@ VolZmap::AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE,
// Cono
ConusFrame.ChangeOrig( ptV) ;
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, true, true, ptInt1, vtN1, ptInt2, vtN2)) {
vtN1 *= - 1 ;
vtN2 *= - 1 ;
if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) {
if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtToolDir, 0.1 * EPS_SMALL)) {
if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtAx, 0.1 * EPS_SMALL)) {
Vector3d vtL1 = ptInt1 - ptV ;
vtL1 -= ( vtL1 * vtToolDir) * vtToolDir ;
vtL1 -= ( vtL1 * vtAx) * vtAx ;
double dL1 = vtL1.Len() ;
vtL1 /= dL1 ;
Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR ;
vtOriginalN1.Normalize() ;
vtN1 = vtOriginalN1.z * vtToolDir + vtOriginalN1.x * vtL1 ;
vtN1 = vtOriginalN1.z * vtAx + vtOriginalN1.x * vtL1 ;
vtN1.Normalize() ;
}
if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtToolDir, 0.1 * EPS_SMALL)) {
if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtAx, 0.1 * EPS_SMALL)) {
Vector3d vtL2 = ptInt2 - ptV ;
vtL2 -= ( vtL2 * vtToolDir) * vtToolDir ;
vtL2 -= ( vtL2 * vtAx) * vtAx ;
double dL2 = vtL2.Len() ;
vtL2 /= dL2 ;
Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ;
vtOriginalN2.Normalize() ;
vtN2 = vtOriginalN2.z * vtToolDir + vtOriginalN2.x * vtL2 ;
vtN2 = vtOriginalN2.z * vtAx + vtOriginalN2.x * vtL2 ;
vtN2.Normalize() ;
}
}