Aggiunto utensile additivo generico
This commit is contained in:
LorenzoM
+542
-145
@@ -7805,13 +7805,134 @@ VolZmap::SurfSphericalShell_Milling( int nGrid, const Point3d& ptS, const Point3
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
VolZmap::AddingMotion( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx/*, double dHei, double dRad, double dCornerRad*/)
|
||||
VolZmap::AddingMotion( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx)
|
||||
{
|
||||
// Dimensioni lineari dell'utensile
|
||||
double dHei = m_vTool[m_nCurrTool].GetHeigth() ;
|
||||
double dRad = m_vTool[m_nCurrTool].GetRadius() ;
|
||||
double dCornerRad = m_vTool[m_nCurrTool].GetCornRadius() ;
|
||||
|
||||
if ( dCornerRad < EPS_SMALL) {
|
||||
AddingCylinder( nGrid, ptS, ptE, vtAx, dHei, dRad) ;
|
||||
}
|
||||
else {
|
||||
;
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
VolZmap::AddingGeneral( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir)
|
||||
{
|
||||
//// 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) ;
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
||||
// // 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) ;
|
||||
// }
|
||||
|
||||
// // Determino le posizioni iniziale e finale del componente successivo
|
||||
// ptI = ptI - vtToolDir * dSignedHeight ;
|
||||
// ptF = ptI + vtMove ;
|
||||
|
||||
// // Passo alla curva successiva
|
||||
// pPrevCurve = pCurve ;
|
||||
// pCurve = ToolProfile.GetCurve( ++ i) ;
|
||||
// }
|
||||
|
||||
// return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
VolZmap::AddingCylinder( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx, double dHei, double dRad)
|
||||
{
|
||||
// Verifica sull'interferenza utensile Zmap
|
||||
int nStartI, nStartJ, nEndI, nEndJ ;
|
||||
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtAx, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
|
||||
@@ -7821,162 +7942,438 @@ VolZmap::AddingMotion( int nGrid, const Point3d& ptS, const Point3d& ptE, const
|
||||
double dLen1 = vtV1.Len() ;
|
||||
vtV1 /= dLen1 ;
|
||||
|
||||
if ( dCornerRad < EPS_SMALL) {
|
||||
|
||||
if ( nGrid == 0) {
|
||||
|
||||
Vector3d vtV2 = Z_AX ^ vtV1 ;
|
||||
|
||||
for ( int i = nStartI ; i <= nEndI ; ++ i) {
|
||||
for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
|
||||
|
||||
Vector3d vtStC( ( i + 0.5) * m_dStep - ptS.x, ( j + 0.5) * m_dStep - ptS.y, 0) ;
|
||||
Vector3d vtEnC = vtStC - dLen1 * vtV1 ;
|
||||
|
||||
double dX1 = vtStC * vtV1 ;
|
||||
double dX2 = vtStC * vtV2 ;
|
||||
|
||||
if ( ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dRad + EPS_SMALL) ||
|
||||
vtStC.SqLen() < dRad * dRad + 2 * dRad * EPS_SMALL ||
|
||||
vtEnC.SqLen() < dRad * dRad + 2 * dRad * EPS_SMALL) {
|
||||
AddIntervals( nGrid, i, j, ptS.z - dHei, ptS.z, - Z_AX, Z_AX) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
double dMyTol = 0/*EPS_SMALL*/;
|
||||
Frame3d CylFrame, PolyFrame ;
|
||||
CylFrame.Set( ptS - dHei * vtAx, vtAx) ;
|
||||
PolyFrame.Set( ptS - ( dHei + dMyTol) * vtAx, vtV1, vtAx ^ vtV1, vtAx) ;
|
||||
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 ;
|
||||
Vector3d vtN1, vtN2 ;
|
||||
|
||||
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, true, true,
|
||||
ptInt1, vtN1, ptInt2, vtN2)) {
|
||||
AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, - vtN1, - vtN2) ;
|
||||
}
|
||||
|
||||
if ( IntersLineCylinder( ptC - dLen1 * vtV1, Z_AX, CylFrame, dHei, dRad, true, true,
|
||||
ptInt1, vtN1, ptInt2, vtN2)) {
|
||||
AddIntervals( nGrid, i, j, ptInt1.z + dLen1 * vtV1.z, ptInt2.z + dLen1 * vtV1.z, - vtN1, - vtN2) ;
|
||||
}
|
||||
|
||||
if ( IntersLineMyPolyhedron( ptC, Z_AX, PolyFrame, dLen1, 2 * ( dRad + dMyTol), dHei + 2 * dMyTol, 0,
|
||||
ptInt1, vtN1, ptInt2, vtN2, false)) {
|
||||
AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, - vtN1, - vtN2) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
;
|
||||
}
|
||||
return true ;
|
||||
|
||||
/*
|
||||
if ( nGrid == 0) {
|
||||
|
||||
Vector3d vtV1 = ptE - ptS ;
|
||||
double dLen1 = vtV1.Len() ;
|
||||
vtV1 / dLen1 ;
|
||||
Vector3d vtV2 = Z_AX ^ vtV1 ;
|
||||
|
||||
double dSqareCornerRadProj = dCornerRad * dCornerRad - 0.25 * dHei * dHei ;
|
||||
for ( int i = nStartI ; i <= nEndI ; ++ i) {
|
||||
for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
|
||||
|
||||
if ( dSqareCornerRadProj > 0) {
|
||||
double dCylRad = dRad - dCornerRad + sqrt( dSquareCornerRadProj) ;
|
||||
// Ciclo sui punti
|
||||
for ( int i = nStartI ; i <= nEndI ; ++ i) {
|
||||
for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
|
||||
Vector3d vtStC( ( i + 0.5) * m_dStep - ptS.x, ( j + 0.5) * m_dStep - ptS.y, 0) ;
|
||||
Vector3d vtEnC = vtStC - dLen1 * vtV1 ;
|
||||
|
||||
Vector3d vtStC( ( i + 0.5) * m_dStep - ptS.x, ( j + 0.5) * m_dStep - ptS.y, 0) ;
|
||||
Vector3d vtEnC = vtStC - dLen1 * vtV1 ;
|
||||
double dX1 = vtStC * vtV1 ;
|
||||
double dX2 = vtStC * vtV2 ;
|
||||
|
||||
double dX1 = vtC * vtV1 ;
|
||||
double dX2 = vtC * vtV2 ;
|
||||
|
||||
if ( ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dCylRad) ||
|
||||
vtStC.SqLen() < dCylRad * dCylRad ||
|
||||
vtEnC.SqLen() < dCylRad * dCylRad) {
|
||||
AddIntervals( nGrid, i, j, ptS.z - dHei, ptS.z, Z_AX, - Z_AX) ;
|
||||
}
|
||||
else if ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dRad) {
|
||||
double dr = dCornerRad - ( dRad - abs( dX2)) ;
|
||||
double dDeltaH = sqrt( max( dCornerRad * dCornerRad - dr * dr, 0)) ;
|
||||
Vector3d vtMinN = ( dX2 > 0 ? - dr : dr) * vtV2 + Vector3d( 0, 0, dDeltaH) ;
|
||||
Vector3d vtMaxN = ( dX2 > 0 ? - dr : dr) * vtV2 - Vector3d( 0, 0, dDeltaH) ;
|
||||
vtMinN.Normalize() ;
|
||||
vtMaxN.Normalize() ;
|
||||
AddIntervals( nGrid, i, j, ptS.z - 0.5 * dHei - dDeltaH, ptS.z - 0.5 * dHei + dDeltaH, vtMinN, vtMaxN) ;
|
||||
}
|
||||
else if ( vtStC.SqLen() < dRad * dRad || vtEnC.SqLen() < dRad * dRad) {
|
||||
Vector3d vtR = dX1 > 0 ? vtEnC : vtStC ;
|
||||
double dLenR = vtR.Len() ;
|
||||
vtR /= dLenR ;
|
||||
double dr = dCornerRad - ( dRad - dLenR) ;
|
||||
double dDeltaH = sqrt( max( dCornerRad * dCornerRad - dr * dr, 0)) ;
|
||||
Vector3d vtMinN = - dr * vtR + Vector3d( 0, 0, dDeltaH) ;
|
||||
Vector3d vtMaxN = - dr * vtR - Vector3d( 0, 0, dDeltaH) ;
|
||||
vtMinN.Normalize() ;
|
||||
vtMaxN.Normalize() ;
|
||||
AddIntervals( nGrid, i, j, ptS.z - 0.5 * dHei - dDeltaH, ptS.z - 0.5 * dHei + dDeltaH, vtMinN, vtMaxN) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
double dCylRad = dRad - dCornerRad ;
|
||||
// Ciclo sui punti
|
||||
for ( int i = nStartI ; i <= nEndI ; ++ i) {
|
||||
for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
|
||||
|
||||
Vector3d vtStC( ( i + 0.5) * m_dStep - ptS.x, ( j + 0.5) * m_dStep - ptS.y, 0) ;
|
||||
Vector3d vtEnC = vtStC - dLen1 * vtV1 ;
|
||||
|
||||
double dX1 = vtC * vtV1 ;
|
||||
double dX2 = vtC * vtV2 ;
|
||||
|
||||
if ( ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dCylRad) ||
|
||||
vtStC.SqLen() < dCylRad * dCylRad ||
|
||||
vtEnC.SqLen() < dCylRad * dCylRad) {
|
||||
AddIntervals( nGrid, i, j, ptS.z - dHei, ptS.z, Z_AX, - Z_AX) ;
|
||||
}
|
||||
else if ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dRad) {
|
||||
double dr = abs( dX2) - dCylRad ;
|
||||
double dDeltaH = sqrt( max( dCornerRad * dCornerRad - dr * dr, 0)) ;
|
||||
Vector3d vtMinN = ( dX2 > 0 ? - dr : dr) * vtV2 + Vector3d( 0, 0, dDeltaH) ;
|
||||
Vector3d vtMaxN = ( dX2 > 0 ? - dr : dr) * vtV2 - Vector3d( 0, 0, dDeltaH) ;
|
||||
vtMinN.Normalize() ;
|
||||
vtMaxN.Normalize() ;
|
||||
AddIntervals( nGrid, i, j, ptS.z - dHei + dCornerRad - dDeltaH, ptS.z - dCornerRad + dDeltaH, vtMinN, vtMaxN) ;
|
||||
}
|
||||
else if ( vtStC.SqLen() < dRad * dRad || vtEnC.SqLen() < dRad * dRad) {
|
||||
Vector3d vtR = dX1 > 0 ? vtEnC : vtStC ;
|
||||
double dLenR = vtR.Len() ;
|
||||
vtR /= dLenR ;
|
||||
double dr = dLenR - dCylRad) ;
|
||||
double dDeltaH = sqrt( max( dCornerRad * dCornerRad - dr * dr, 0)) ;
|
||||
Vector3d vtMinN = - dr * vtR + Vector3d( 0, 0, dDeltaH) ;
|
||||
Vector3d vtMaxN = - dr * vtR - Vector3d( 0, 0, dDeltaH) ;
|
||||
vtMinN.Normalize() ;
|
||||
vtMaxN.Normalize() ;
|
||||
AddIntervals( nGrid, i, j, ptS.z - dHei + dCornerRad - dDeltaH, ptS.z - dCornerRad + dDeltaH, vtMinN, vtMaxN) ;
|
||||
}
|
||||
}
|
||||
if ( ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dRad + EPS_SMALL) ||
|
||||
vtStC.SqLen() < dRad * dRad + 2 * dRad * EPS_SMALL ||
|
||||
vtEnC.SqLen() < dRad * dRad + 2 * dRad * EPS_SMALL) {
|
||||
AddIntervals( nGrid, i, j, ptS.z - dHei, ptS.z, - Z_AX, Z_AX) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
;
|
||||
double dMyTol = 0/*EPS_SMALL*/;
|
||||
Frame3d CylFrame, PolyFrame ;
|
||||
CylFrame.Set( ptS - dHei * vtAx, vtAx) ;
|
||||
PolyFrame.Set( ptS - ( dHei + dMyTol) * vtAx, vtV1, vtAx ^ vtV1, vtAx) ;
|
||||
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 ;
|
||||
Vector3d vtN1, vtN2 ;
|
||||
|
||||
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, true, true,
|
||||
ptInt1, vtN1, ptInt2, vtN2)) {
|
||||
AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, - vtN1, - vtN2) ;
|
||||
}
|
||||
|
||||
if ( IntersLineCylinder( ptC - dLen1 * vtV1, Z_AX, CylFrame, dHei, dRad, true, true,
|
||||
ptInt1, vtN1, ptInt2, vtN2)) {
|
||||
AddIntervals( nGrid, i, j, ptInt1.z + dLen1 * vtV1.z, ptInt2.z + dLen1 * vtV1.z, - vtN1, - vtN2) ;
|
||||
}
|
||||
|
||||
if ( IntersLineMyPolyhedron( ptC, Z_AX, PolyFrame, dLen1, 2 * ( dRad + dMyTol), dHei + 2 * dMyTol, 0,
|
||||
ptInt1, vtN1, ptInt2, vtN2, false)) {
|
||||
AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, - vtN1, - vtN2) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
VolZmap::AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx,
|
||||
double dHei, double dMaxRad, double dMinRad,
|
||||
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))
|
||||
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) ;
|
||||
|
||||
double dL = ( dMaxRad * dHei) / dDeltaR ;
|
||||
double dl = dL - dHei ;
|
||||
|
||||
Point3d ptV = ptI - vtToolDir * dL ;
|
||||
|
||||
// Vettori caratteristici del movimento
|
||||
Vector3d vtMove = ptF - ptI ;
|
||||
Vector3d vtMvLong = ( vtMove * vtToolDir) * vtToolDir ;
|
||||
Vector3d vtMvOrt = vtMove - vtMvLong ;
|
||||
|
||||
// Terna destrorsa e unitaria
|
||||
Vector3d vtV1 = vtToolDir ;
|
||||
Vector3d vtV2 = vtMvOrt ; vtV2.Normalize() ;
|
||||
Vector3d vtV3 = vtV1 ^ vtV2 ;
|
||||
|
||||
// Sistema di riferimento intrinseco del movimento
|
||||
Frame3d ConusFrame ; ConusFrame.Set( ptV, vtV2, vtV3, vtV1) ;
|
||||
|
||||
// Dimensioni lineari movimento
|
||||
double dLongLen = vtMvLong.Len() ;
|
||||
double dOrtLen = vtMvOrt.Len() ;
|
||||
|
||||
// Apertura del cono
|
||||
double dTan = dDeltaR / dHei ;
|
||||
double dRatio = dLongLen / dOrtLen ;
|
||||
|
||||
// Per costruire piani laterali poliedro interno
|
||||
double dCos = dTan * dRatio ;
|
||||
double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ;
|
||||
|
||||
// Dimensioni lineari descriventi il poliedro interno
|
||||
double dLenX = dLongLen ;
|
||||
double dLenY = dOrtLen ;
|
||||
double dLenZ = dSin * dMinRad ;
|
||||
double dDeltaX = dHei ;
|
||||
double dDeltaY = dCos * dDeltaR ;
|
||||
double dDeltaZ = dSin * dDeltaR ;
|
||||
|
||||
// Sistema di riferimento poliedro
|
||||
Point3d ptO = ptV + vtV1 * dl + vtV2 * ( dCos * dMinRad) ;
|
||||
Frame3d PolyFrame ;
|
||||
PolyFrame.Set( ptO, vtV1, vtV2, vtV3) ;
|
||||
|
||||
// Versori piani nel riferimento poliedro ( riferiti al sistema di riferimento) :
|
||||
// Sx, Dx
|
||||
Vector3d vtNs( - dTan, dCos, dSin) ;
|
||||
vtNs.Normalize() ;
|
||||
Vector3d vtNd( - dTan, dCos, - dSin) ;
|
||||
vtNd.Normalize() ;
|
||||
// Iniziale e finale
|
||||
Vector3d vtIF( - dDeltaY, dDeltaX, 0) ;
|
||||
vtIF.Normalize() ;
|
||||
// Up e Down
|
||||
Vector3d vtUD( - dLenY, dLenX, 0) ;
|
||||
vtUD.Normalize() ;
|
||||
|
||||
// Punti dei piani (sempre espressi nel sistema PolyFrame)
|
||||
Point3d ptFacet135( 0, 0, dLenZ) ;
|
||||
Point3d ptFacet246( dLenX + dDeltaX, dLenY + dDeltaY, - dLenZ - dDeltaZ) ;
|
||||
|
||||
Vector3d vtUmv = vtMove ; vtUmv.Normalize() ;
|
||||
|
||||
if ( dRatio * dTan <= 1) {
|
||||
|
||||
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 ;
|
||||
Vector3d vtN1, vtN2 ;
|
||||
|
||||
// Cono iniziale
|
||||
ConusFrame.ChangeOrig( ptV) ;
|
||||
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, true, true, ptInt1, vtN1, ptInt2, vtN2)) {
|
||||
if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) {
|
||||
if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtToolDir, 0.1 * EPS_SMALL)) {
|
||||
Vector3d vtL1 = ptInt1 - ptV ;
|
||||
vtL1 -= ( vtL1 * vtToolDir) * vtToolDir ;
|
||||
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.Normalize() ;
|
||||
}
|
||||
if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtToolDir, 0.1 * EPS_SMALL)) {
|
||||
Vector3d vtL2 = ptInt2 - ptV ;
|
||||
vtL2 -= ( vtL2 * vtToolDir) * vtToolDir ;
|
||||
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.Normalize() ;
|
||||
}
|
||||
}
|
||||
AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ;
|
||||
}
|
||||
|
||||
// Cono finale
|
||||
ConusFrame.ChangeOrig( ptV + vtMove) ;
|
||||
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, true, true, ptInt1, vtN1, ptInt2, vtN2)) {
|
||||
if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) {
|
||||
if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtToolDir, 0.1 * EPS_SMALL)) {
|
||||
Vector3d vtL1 = ptInt1 - ptV - vtMove ;
|
||||
vtL1 -= ( vtL1 * vtToolDir) * vtToolDir ;
|
||||
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.Normalize() ;
|
||||
}
|
||||
if ( ! AreSameOrOppositeVectorEpsilon(vtN2, vtToolDir, 0.1 * EPS_SMALL)) {
|
||||
Vector3d vtL2 = ptInt2 - ptV - vtMove ;
|
||||
vtL2 -= (vtL2 * vtToolDir) * vtToolDir;
|
||||
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.Normalize() ;
|
||||
}
|
||||
}
|
||||
AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ;
|
||||
}
|
||||
|
||||
// Solido interno
|
||||
Point3d ptPoly = ptC ;
|
||||
Vector3d vtPoly = Z_AX ;
|
||||
|
||||
ptPoly.ToLoc( PolyFrame) ;
|
||||
vtPoly.ToLoc( PolyFrame) ;
|
||||
|
||||
Point3d ptPoly1 = ptPoly + ( ( ( ptFacet135 - ptPoly) * vtNs) / ( vtPoly * vtNs)) * vtPoly ;
|
||||
Point3d ptPoly2 = ptPoly + ( ( ( ptFacet246 - ptPoly) * vtNd) / ( vtPoly * vtNd)) * vtPoly ;
|
||||
Point3d ptPoly3 = ptPoly + ( ( ( ptFacet135 - ptPoly) * vtIF) / ( vtPoly * vtIF)) * vtPoly ;
|
||||
Point3d ptPoly4 = ptPoly + ( ( ( ptFacet246 - ptPoly) * vtIF) / ( vtPoly * vtIF)) * vtPoly ;
|
||||
Point3d ptPoly5 = ptPoly + ( ( ( ptFacet135 - ptPoly) * vtUD) / ( vtPoly * vtUD)) * vtPoly ;
|
||||
Point3d ptPoly6 = ptPoly + ( ( ( ptFacet246 - ptPoly) * vtUD) / ( vtPoly * vtUD)) * vtPoly ;
|
||||
|
||||
int nIntNum = 0 ;
|
||||
|
||||
// Intersezione con la prima faccia
|
||||
if ( abs( vtPoly * vtNs) > COS_ORTO_ANG_ZERO) {
|
||||
if ( dLenY * ptPoly1.x >= dLenX * ptPoly1.y &&
|
||||
dLenY * ( ptPoly1.x - dDeltaX) <= dLenX * ( ptPoly1.y - dDeltaY) &&
|
||||
dDeltaX * ptPoly1.y >= dDeltaY * ptPoly1.x &&
|
||||
dDeltaX * ( ptPoly1.y - dLenY) <= dDeltaY * ( ptPoly1.x - dLenX)) {
|
||||
ptInt1 = ptPoly1 ;
|
||||
vtN1 = - vtNs ;
|
||||
if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) {
|
||||
Vector3d vtRadial( 0, dMinRad * dCos, dMinRad * dSin) ;
|
||||
vtRadial.Normalize() ;
|
||||
Vector3d vtOrigMaxR = - vtArcNormMaxR.x * vtRadial - vtArcNormMaxR.z * X_AX ;
|
||||
Vector3d vtOrigMinR = - vtArcNormMinR.x * vtRadial - vtArcNormMinR.z * X_AX ;
|
||||
vtOrigMaxR.Normalize() ;
|
||||
vtOrigMinR.Normalize() ;
|
||||
vtN1 = - ( ( dDeltaZ - ptInt1.z + dLenZ) / dDeltaZ) * vtOrigMinR - ( ( ptInt1.z - dLenZ) / dDeltaZ) * vtOrigMaxR ;
|
||||
vtN1.Normalize() ;
|
||||
}
|
||||
++ nIntNum ;
|
||||
}
|
||||
}
|
||||
// Intersezione con la seconda faccia
|
||||
if ( abs( vtPoly * vtNd) > COS_ORTO_ANG_ZERO) {
|
||||
if ( dLenY * ptPoly2.x >= dLenX * ptPoly2.y &&
|
||||
dLenY * ( ptPoly2.x - dDeltaX) <= dLenX * ( ptPoly2.y - dDeltaY) &&
|
||||
dDeltaX * ptPoly2.y >= dDeltaY * ptPoly2.x &&
|
||||
dDeltaX * ( ptPoly2.y - dLenY) <= dDeltaY * ( ptPoly2.x - dLenX)) {
|
||||
|
||||
if ( nIntNum == 0) {
|
||||
ptInt1 = ptPoly2 ;
|
||||
vtN1 = - vtNd ;
|
||||
if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) {
|
||||
Vector3d vtRadial( 0, dMinRad * dCos, - dMinRad * dSin) ;
|
||||
vtRadial.Normalize() ;
|
||||
Vector3d vtOrigMaxR = - vtArcNormMaxR.x * vtRadial - vtArcNormMaxR.z * X_AX ;
|
||||
Vector3d vtOrigMinR = - vtArcNormMinR.x * vtRadial - vtArcNormMinR.z * X_AX ;
|
||||
vtOrigMaxR.Normalize() ;
|
||||
vtOrigMinR.Normalize() ;
|
||||
vtN1 = - ( ( dDeltaZ - abs( ptInt1.z) + dLenZ) / dDeltaZ) * vtOrigMinR - ( ( abs( ptInt1.z) - dLenZ) / dDeltaZ) * vtOrigMaxR ;
|
||||
vtN1.Normalize() ;
|
||||
}
|
||||
++ nIntNum ;
|
||||
}
|
||||
else if ( ( ptInt1 - ptPoly2).SqLen() > SQ_EPS_SMALL) {
|
||||
ptInt2 = ptPoly2 ;
|
||||
vtN2 = - vtNd ;
|
||||
if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) {
|
||||
Vector3d vtRadial( 0, dMinRad * dCos, -dMinRad * dSin) ;
|
||||
vtRadial.Normalize() ;
|
||||
Vector3d vtOrigMaxR = -vtArcNormMaxR.x * vtRadial - vtArcNormMaxR.z * X_AX ;
|
||||
Vector3d vtOrigMinR = -vtArcNormMinR.x * vtRadial - vtArcNormMinR.z * X_AX ;
|
||||
vtOrigMaxR.Normalize() ;
|
||||
vtOrigMinR.Normalize() ;
|
||||
vtN2 = - ( ( dDeltaZ - abs( ptInt2.z) + dLenZ) / dDeltaZ) * vtOrigMinR - ( ( abs( ptInt2.z) - dLenZ) / dDeltaZ) * vtOrigMaxR ;
|
||||
vtN2.Normalize() ;
|
||||
}
|
||||
++ nIntNum ;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Intersezione con la terza faccia
|
||||
if ( abs( vtPoly * vtIF) > COS_ORTO_ANG_ZERO) {
|
||||
if ( nIntNum < 2 &&
|
||||
ptPoly3.x >= 0 && ptPoly3.x <= dDeltaX &&
|
||||
dDeltaX * abs( ptPoly3.z) < dDeltaX * dLenZ + dDeltaZ * ptPoly3.x) {
|
||||
|
||||
if ( nIntNum == 0) {
|
||||
ptInt1 = ptPoly3 ;
|
||||
vtN1 = - vtIF ;
|
||||
++ nIntNum ;
|
||||
}
|
||||
else if ( ( ptInt1 - ptPoly3).SqLen() > SQ_EPS_SMALL) {
|
||||
ptInt2 = ptPoly3 ;
|
||||
vtN2 = - vtIF ;
|
||||
++ nIntNum ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Intersezione con la quarta faccia
|
||||
if ( abs( vtPoly * vtIF) > COS_ORTO_ANG_ZERO) {
|
||||
if ( nIntNum < 2 &&
|
||||
ptPoly4.x >= dLenX && ptPoly4.x <= dLenX + dDeltaX &&
|
||||
dDeltaX * abs( ptPoly4.z) < dDeltaX * dLenZ + dDeltaZ * ( ptPoly4.x - dLenX)) {
|
||||
|
||||
if ( nIntNum == 0) {
|
||||
ptInt1 = ptPoly4 ;
|
||||
vtN1 = vtIF ;
|
||||
++ nIntNum ;
|
||||
}
|
||||
else if ( ( ptInt1 - ptPoly4).SqLen() > SQ_EPS_SMALL) {
|
||||
ptInt2 = ptPoly4 ;
|
||||
vtN2 = vtIF ;
|
||||
++ nIntNum ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Intersezione con la quinta faccia
|
||||
if ( abs( vtPoly * vtUD) > COS_ORTO_ANG_ZERO) {
|
||||
if ( nIntNum < 2 &&
|
||||
ptPoly5.y >= 0 && ptPoly5.y <= dLenY &&
|
||||
abs( ptPoly5.z) <= dLenZ) {
|
||||
|
||||
if ( nIntNum == 0) {
|
||||
ptInt1 = ptPoly5 ;
|
||||
vtN1 = vtUD ;
|
||||
++ nIntNum ;
|
||||
}
|
||||
else if ( ( ptInt1 - ptPoly5).SqLen() > SQ_EPS_SMALL) {
|
||||
ptInt2 = ptPoly5 ;
|
||||
vtN2 = vtUD ;
|
||||
++ nIntNum ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Intersezione con la sesta faccia
|
||||
if ( abs( vtPoly * vtUD) > COS_ORTO_ANG_ZERO) {
|
||||
if ( nIntNum < 2 &&
|
||||
ptPoly6.y >= dDeltaY && ptPoly6.y <= dLenY + dDeltaY &&
|
||||
abs( ptPoly6.z) <= dLenZ + dDeltaZ) {
|
||||
|
||||
if ( nIntNum == 0) {
|
||||
ptInt1 = ptPoly6;
|
||||
vtN1 = - vtUD ;
|
||||
++ nIntNum ;
|
||||
}
|
||||
else if ( ( ptInt1 - ptPoly6).SqLen() > SQ_EPS_SMALL) {
|
||||
ptInt2 = ptPoly6;
|
||||
vtN2 = - vtUD ;
|
||||
++ nIntNum ;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Se il poliedro � attraversato taglio
|
||||
if ( nIntNum == 2) {
|
||||
|
||||
// Riporto le intersezioni nel sistema griglia
|
||||
ptInt1.ToGlob( PolyFrame) ;
|
||||
vtN1.ToGlob( PolyFrame) ;
|
||||
ptInt2.ToGlob( PolyFrame) ;
|
||||
vtN2.ToGlob( PolyFrame) ;
|
||||
|
||||
AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ;
|
||||
}
|
||||
|
||||
// Se movimento non ortogonale all'asse sottraggo i cilindri ellittici
|
||||
if ( dLongLen > EPS_SMALL) {
|
||||
|
||||
// Traslazione ellisse di punta
|
||||
ConusFrame.ChangeOrig( ptV + vtV1 * dl) ;
|
||||
if ( IntersLineEllipticalCylinder( ptC, Z_AX, ConusFrame, dMinRad, dLongLen, dOrtLen,
|
||||
true, true, ptInt1, vtN1, ptInt2, vtN2)) {
|
||||
AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ;
|
||||
}
|
||||
|
||||
// Traslazione ellisse di base
|
||||
ConusFrame.ChangeOrig( ptV + vtV1 * dL) ;
|
||||
if ( IntersLineEllipticalCylinder( ptC, Z_AX, ConusFrame, dMaxRad, dLongLen, dOrtLen,
|
||||
true, true, ptInt1, vtN1, ptInt2, vtN2)) {
|
||||
AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
|
||||
else {
|
||||
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 ;
|
||||
Vector3d vtN1, vtN2 ;
|
||||
|
||||
// Cono
|
||||
ConusFrame.ChangeOrig( ptV) ;
|
||||
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, true, true, ptInt1, vtN1, ptInt2, vtN2)) {
|
||||
if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) {
|
||||
if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtToolDir, 0.1 * EPS_SMALL)) {
|
||||
Vector3d vtL1 = ptInt1 - ptV ;
|
||||
vtL1 -= ( vtL1 * vtToolDir) * vtToolDir ;
|
||||
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.Normalize() ;
|
||||
}
|
||||
if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtToolDir, 0.1 * EPS_SMALL)) {
|
||||
Vector3d vtL2 = ptInt2 - ptV ;
|
||||
vtL2 -= ( vtL2 * vtToolDir) * vtToolDir ;
|
||||
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.Normalize() ;
|
||||
}
|
||||
}
|
||||
AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ;
|
||||
}
|
||||
|
||||
// Traslazione ellisse
|
||||
ConusFrame.ChangeOrig( ptV + vtV1 * dL) ;
|
||||
if ( IntersLineEllipticalCylinder( ptC, Z_AX, ConusFrame, dMaxRad, dLongLen, dOrtLen,
|
||||
true, true, ptInt1, vtN1, ptInt2, vtN2)) {
|
||||
AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
// ------------------------- BOUNDING BOX --------------------------------------------------------------------------------------
|
||||
|
||||
Reference in New Issue
Block a user