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

EgtGeomKernel 1.8e4 :

Browse Source 
- correzione a ApproxOnSide e MakeConvex di PolyLine per percorsi chiusi
- migliorie e correzioni Zmap.
This commit is contained in:
Dario Sassi
2017-05-25 09:40:56 +00:00
parent 0a98461e3e
commit 98299d118c
7 changed files with 304 additions and 2293 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolTriZmapVolume.cpp
+1 -744
View File
@@ -767,7 +767,7 @@ VolZmap::CylBall_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point
double dSqLen = vtC.SqLen() ;
// Se il punto si trova dentro il cerchio taglio
if ( dSqLen < dSqRad)
if ( dSqLen < dSqRad - 2 * m_dRadius * EPS_SMALL)
// utensile cilindrico
if ( m_nToolType == CylindricalMill)
SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ, Z_AX, - Z_AX) ;
@@ -2812,261 +2812,6 @@ VolZmap::Conus_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d &
}
// ---------- Utensile generico ----------------------------------------------
/*
//----------------------------------------------------------------------------
bool
VolZmap::GenTool_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir)
{
// Posizioni iniziale e finale dell'utensile
Point3d ptI = ptS ;
Point3d ptF = ptE ;
// vettore movimento
Vector3d vtMove = ptE - ptS ;
// Settaggio profilo
CurveComposite* pToolProfile ;
if ( m_ToolArcLineApprox.GetCurveCount() == 0)
// Se l'utensile non è stato approssimato uso l'originale
pToolProfile = & m_ToolOutline ;
else
// altrimenti usi l'approssimazione
pToolProfile = &m_ToolArcLineApprox ;
// Ciclo sulle curve
const ICurve* pCurve = pToolProfile->GetFirstCurve() ;
while ( pCurve != nullptr) {
double dHeight ;
int nCurveType = pCurve -> GetType() ;
// Caso di semento
if ( nCurveType == CRV_LINE) {
Point3d ptStart, ptEnd ;
pCurve -> GetStartPoint( ptStart) ;
pCurve -> GetEndPoint( ptEnd) ;
if ( abs( ptStart.y - ptEnd.y) > EPS_SMALL) {
dHeight = abs( ptStart.y - ptEnd.y) ;
// Il componente è un cilindro
if ( abs( ptStart.x - ptEnd.x) < EPS_SMALL) {
double dRadius = ptStart.x ;
// CompCyl_Drilling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius) ;
}
// Il componente è un cono con vettore equiverso a quello dell'utensile
else if ( ptStart.x > ptEnd.x) {
double dMaxRad = ptStart.x ;
double dMinRad = ptEnd.x ;
CompConus_Drilling( nGrid, ptI, ptF, vtToolDir, dHeight, dMaxRad, dMinRad) ;
}
// Il componente è 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 * dHeight ;
Point3d ptFn = ptIn + vtMove ;
CompConus_Drilling( nGrid, ptIn, ptFn, - vtToolDir, dHeight, dMaxRad, dMinRad) ;
}
}
else
dHeight = 0 ;
}
// Caso arco
else if ( nCurveType == CRV_ARC) {
// Centro e Punti iniziale e finale del cerchio
Point3d ptStart, ptEnd, ptO ;
pCurve -> GetStartPoint( ptStart) ;
pCurve -> GetEndPoint( ptEnd) ;
pCurve -> GetCenterPoint( ptO) ;
// Determino il raggio
Vector3d vtStRad = ptStart - ptO ;
Vector3d vtEnRad = ptEnd - ptO ;
double dRadius = 0.5 * ( vtStRad.LenXY() + vtEnRad.LenXY()) ;
// Determino le posizioni iniziale e finale del centrodella sfera
Point3d ptOSt = ptI - vtToolDir * ( ptStart.y - ptO.y) ;
Point3d ptOEn = ptOSt + vtMove ;
// Eseguo l'asportazione del materiale
CompBall_Milling( nGrid, ptOSt, ptOEn, dRadius) ;
// aggiorno l'altezza
dHeight = abs( ptStart.y - ptEnd.y) ;
}
// Determino le posizioni iniziale e finale del componente successivo
ptI = ptI - vtToolDir * dHeight ;
ptF = ptI + vtMove ;
// Aggiorno il puntatore
pCurve = pToolProfile->GetNextCurve() ;
}
return true ;
}*/
/*
//----------------------------------------------------------------------------
bool
VolZmap::GenTool_Drilling( unsigned 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 ;
// Settaggio profilo
CurveComposite* pToolProfile ;
if ( m_ToolArcLineApprox.GetCurveCount() == 0)
// Se l'utensile non è stato approssimato uso l'originale
pToolProfile = & m_ToolOutline ;
else
// altrimenti uso l'approssimazione
pToolProfile = &m_ToolArcLineApprox ;
// Ciclo sulle curve
const ICurve* pCurve = pToolProfile->GetFirstCurve() ;
const ICurve* pFirstConst = pCurve ;
while ( pCurve != nullptr) {
double dHeight ;
int nCurveType = pCurve -> GetType() ;
// Caso di segmento
if ( nCurveType == CRV_LINE) {
Point3d ptStart, ptEnd ;
pCurve -> GetStartPoint( ptStart) ;
pCurve -> GetEndPoint( ptEnd) ;
if ( abs( ptStart.y - ptEnd.y) > EPS_SMALL) {
dHeight = abs( ptStart.y - ptEnd.y) ;
bool bTapB, bTapT ;
CurveComposite* pToolPrev = pToolProfile ;
CurveComposite* ptToolNext = pToolProfile ;
const ICurve* pPrev = pToolPrev -> GetPrevCurve() ;
const ICurve* pNext = ptToolNext -> GetNextCurve() ;
// Dettagli curva precedente
int nPrevType = pPrev -> GetType() ;
Point3d ptPrevLast ;
pPrev -> GetEndPoint( ptPrevLast) ;
// Setto le variabili per il tappo superiore
if ( pPrev == pFirstConst ||
nPrevType == CRV_ARC ||
ptPrevLast.x < ptStart.x)
bTapB = false ;
else
bTapB = true ;
// Dettagli curva successiva
int nNextType = pNext -> GetType() ;
Point3d ptNextFirst ;
pNext -> GetEndPoint( ptNextFirst) ;
if ( pNext == nullptr ||
nNextType == CRV_ARC ||
ptNextFirst.x < ptEnd.x)
bTapT = false ;
else
bTapT = true ;
// Il componente è un cilindro
if ( abs( ptStart.x - ptEnd.x) < EPS_SMALL) {
double dRadius = ptStart.x ;
CompCyl_Drilling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius, bTapB, bTapT) ;
}
// Il componente è un cono con vettore equiverso a quello dell'utensile
else if ( ptStart.x > ptEnd.x) {
double dMaxRad = ptStart.x ;
double dMinRad = ptEnd.x ;
CompConus_Drilling( nGrid, ptI, ptF, vtToolDir, dHeight, dMaxRad, dMinRad, bTapB, bTapT) ;
}
// Il componente è 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 * dHeight ;
Point3d ptFn = ptIn + vtMove ;
CompConus_Drilling( nGrid, ptIn, ptFn, - vtToolDir, dHeight, dMaxRad, dMinRad, bTapT, bTapB) ;
}
}
else
dHeight = 0 ;
}
// Caso arco
else if ( nCurveType == CRV_ARC) {
// Centro e Punti iniziale e finale del cerchio
Point3d ptStart, ptEnd, ptO ;
pCurve -> GetStartPoint( ptStart) ;
pCurve -> GetEndPoint( ptEnd) ;
pCurve -> GetCenterPoint( ptO) ;
// Determino il raggio
Vector3d vtStRad = ptStart - ptO ;
Vector3d vtEnRad = ptEnd - ptO ;
double dRadius = 0.5 * ( vtStRad.LenXY() + vtEnRad.LenXY()) ;
// Determino le posizioni iniziale e finale del centro della sfera
Point3d ptOSt = ptI - vtToolDir * ( ptStart.y - ptO.y) ;
Point3d ptOEn = ptOSt + vtMove ;
// Eseguo l'asportazione del materiale
CompBall_Milling( nGrid, ptOSt, ptOEn, dRadius) ;
// aggiorno l'altezza
dHeight = abs( ptStart.y - ptEnd.y) ;
}
// Determino le posizioni iniziale e finale del componente successivo
ptI = ptI - vtToolDir * dHeight ;
ptF = ptI + vtMove ;
// Aggiorno il puntatore
pCurve = pToolProfile->GetNextCurve() ;
}
return true ;
}*/
//----------------------------------------------------------------------------
bool
@@ -3229,116 +2974,6 @@ VolZmap::GenTool_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3
return true ;
}
/*
//----------------------------------------------------------------------------
bool
VolZmap::GenTool_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir)
{
// Posizioni iniziale e finale dell'utensile
Point3d ptI = ptS ;
Point3d ptF = ptE ;
// vettore movimento
Vector3d vtMove = ptE - ptS ;
// Settaggio profilo
CurveComposite* pToolProfile ;
if ( m_ToolArcLineApprox.GetCurveCount() == 0)
// Se l'utensile non è stato approssimato uso l'originale
pToolProfile = &m_ToolOutline ;
else
// altrimenti usi l'approssimazione
pToolProfile = &m_ToolArcLineApprox ;
// Ciclo sulle curve
const ICurve* pCurve = pToolProfile->GetFirstCurve() ;
while ( pCurve != nullptr) {
double dHeight ;
int nCurveType = pCurve -> GetType() ;
// Caso di semento
if ( nCurveType == CRV_LINE) {
Point3d ptStart, ptEnd ;
pCurve -> GetStartPoint( ptStart) ;
pCurve -> GetEndPoint( ptEnd) ;
if ( abs( ptStart.y - ptEnd.y) > EPS_SMALL) {
dHeight = abs( ptStart.y - ptEnd.y) ;
// Il componente è un cilindro
if ( abs( ptStart.x - ptEnd.x) < EPS_SMALL) {
double dRadius = ptStart.x ;
CompCyl_Milling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius) ;
}
// Il componente è 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) ;
}
// Il componente è 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 * dHeight ;
Point3d ptFn = ptIn + vtMove ;
CompConus_Milling( nGrid, ptIn, ptFn, - vtToolDir, dHeight, dMaxRad, dMinRad) ;
}
}
else
dHeight = 0 ;
}
// Caso arco
else if ( nCurveType == CRV_ARC) {
// Centro e Punti iniziale e finale del cerchio
Point3d ptStart, ptEnd, ptO ;
pCurve -> GetStartPoint( ptStart) ;
pCurve -> GetEndPoint( ptEnd) ;
pCurve -> GetCenterPoint( ptO) ;
// Determino il raggio
Vector3d vtStRad = ptStart - ptO ;
Vector3d vtEnRad = ptEnd - ptO ;
double dRadius = 0.5 * ( vtStRad.LenXY() + vtEnRad.LenXY()) ;
// Determino le posizioni iniziale e finale del centrodella sfera
Point3d ptOSt = ptI - vtToolDir * ( ptStart.y - ptO.y) ;
Point3d ptOEn = ptOSt + vtMove ;
// Eseguo l'asportazione del materiale
CompBall_Milling( nGrid, ptOSt, ptOEn, dRadius) ;
// aggiorno l'altezza
dHeight = abs( ptStart.y - ptEnd.y) ;
}
// Determino le posizioni iniziale e finale del componente successivo
ptI = ptI - vtToolDir * dHeight ;
ptF = ptI + vtMove ;
// Aggiorno il puntatore
pCurve = pToolProfile->GetNextCurve() ;
}
return true ;
}*/
//----------------------------------------------------------------------------
bool
VolZmap::GenTool_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir)
@@ -3784,163 +3419,6 @@ VolZmap::CompCyl_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
return true ;
}
/*
//----------------------------------------------------------------------------
bool
VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dMaxRad, double dMinRad)
{
double dMin, dMax, dPLim, dMLim ;
unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool Control = BBoxComponent( nGrid, ptS, ptE, vtToolDir, vtToolDir, nStartI, nStartJ, nEndI, nEndJ, dMaxRad, dMinRad, dHei) ;
if ( ! Control)
return true ;
Point3d ptI = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) ;
Point3d ptF = ( vtToolDir * ( ptE - ptS) > 0 ? ptE : ptS) ;
Point3d ptIxy( ptI.x, ptI.y, 0) ;
Point3d ptFxy( ptF.x, ptF.y, 0) ;
Vector3d vtMove = ptF - ptI ; double dLen = vtMove.Len() ;
Vector3d vtMLong = ( vtMove * vtToolDir) * vtToolDir ; double dLLong = vtMLong.Len() ;
Vector3d vtMOrt = vtMove - vtMLong ; double dLOrt = vtMOrt.Len() ;
Vector3d vtV1 = vtToolDir ;
Vector3d vtV2 = vtMOrt ; vtV2.Normalize() ;
Vector3d vtV3 = vtV1 ^ vtV2 ;
double dZI = ptI.z ;
double dZTI = ptI.z - vtV1.z * dHei ;
double dDeltaZ = ptF.z - ptI.z ;
double dDeltaR = dMaxRad - dMinRad ;
double dTan = dDeltaR / dHei ;
double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ;
double dCos = dTan * dRatio ;
double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ;
double dDen = sqrt( 1 + dTan * dTan) ;
Point3d ptV = ptI - vtV1 * ( dHei * dMaxRad / dDeltaR) ;
Vector3d vtNs = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 + ( dSin / dDen) * vtV3 ;
Vector3d vtNd = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 - ( dSin / dDen) * vtV3 ;
Vector3d vtR0 = ptV - ORIG ;
double dDots = vtR0 * vtNs ;
double dDotd = vtR0 * vtNd ;
for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
for ( unsigned 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 vtCI = ptC - ptIxy ; double dSqDI = vtCI.SqLenXY() ;
Vector3d vtCF = ptC - ptFxy ; double dSqDF = vtCF.SqLenXY() ;
double dIDO = vtCI * vtV3 ;
double dIDL = vtCI * vtV2 ;
double dIVarCos = dIDL / sqrt( dSqDI) ;
double dFDL = vtCF * vtV2 ;
double dFVarCos = dFDL / sqrt( dSqDF) ;
if ( dSqDI < dMaxRad * dMaxRad || dSqDF < dMaxRad * dMaxRad ||
(abs( dIDO) < dMaxRad && dIDL > 0 && dIDL < dLOrt)) {
// Caso dTan > 1 / dRatio
if ( dRatio > 1 / dTan) {
// Limiti nella direzione positiva di vtV1
if ( dSqDF < dMaxRad * dMaxRad)
dPLim = dZI + dDeltaZ ;
else
dPLim = dZI + ( dIDL + sqrt( dMaxRad * dMaxRad - dIDO * dIDO)) * dDeltaZ / dLOrt ;
// Limiti nella direzione negativa di vtV1
if ( dSqDI < dMinRad * dMinRad)
dMLim = dZTI ;
else if ( dSqDI < dMaxRad * dMaxRad)
dMLim = dZTI + ( sqrt( dSqDI) - dMinRad) * ( dZI - dZTI) / dDeltaR ;
else
dMLim = dZI + ( dIDL - sqrt( dMaxRad * dMaxRad - dIDO * dIDO)) * dDeltaZ / dLOrt ;
}
else {
// Limiti nella direzione positiva di vtV1
if ( dSqDF < dMaxRad * dMaxRad)
dPLim = dZI + dDeltaZ ;
else
dPLim = dZI + ( dIDL + sqrt( dMaxRad * dMaxRad - dIDO * dIDO)) * dDeltaZ / dLOrt ;
// Limiti nella direzione negativa di vtV1
if ( dSqDI < dMinRad * dMinRad)
dMLim = dZTI ;
else if ( dSqDI >= dMinRad * dMinRad && dSqDI < dMaxRad * dMaxRad && dIVarCos < dCos)
dMLim = dZTI + ( sqrt( dSqDI) - dMinRad) * ( dZI - dZTI) / dDeltaR ;
else if ( dSqDI >= dMinRad * dMinRad && dIVarCos >= dCos && dFVarCos < dCos && abs( dIDO) < dMaxRad * dSin) { // da qui
if ( dIDO > - dMaxRad * dSin && dIDO <= - dMinRad * dSin)
dMLim = ( dDotd - dX * vtNd.x - dY * vtNd.y) / vtNd.z ;
else if ( dIDO > - dMinRad * dSin && dIDO < dMinRad * dSin)
dMLim = dZTI + ( dIDL - sqrt( dMinRad * dMinRad - dIDO * dIDO)) * dDeltaZ / dLOrt ;
else if ( dIDO >= dMinRad * dSin && dIDO < dMaxRad * dSin)
dMLim = ( dDots - dX * vtNs.x - dY * vtNs.y) / vtNs.z ; // a qui
}
else if ( dFVarCos >= dCos) {
if ( dSqDF < dMinRad * dMinRad)
dMLim = dZTI + ( dIDL - sqrt( dMinRad * dMinRad - dIDO * dIDO)) * dDeltaZ / dLOrt ;
else
dMLim = dZTI + dDeltaZ + ( sqrt( dSqDF) - dMinRad) * ( dZI - dZTI) / dDeltaR ;
}
else
dMLim = dZI + ( dIDL - sqrt( dMaxRad * dMaxRad - dIDO * dIDO)) * dDeltaZ / dLOrt ;
}
dMin = min( dPLim, dMLim) ;
dMax = max( dPLim, dMLim) ;
SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
}
}
}
return true ;
} */
//----------------------------------------------------------------------------
bool
VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dMaxRad, double dMinRad)
@@ -4231,227 +3709,6 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin
}
return true ;
}
/*
//----------------------------------------------------------------------------
bool
VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dMaxRad, double dMinRad)
{
unsigned int nStartI, nStartJ, nEndI, nEndJ ;
bool Control = BBoxComponent( nGrid, ptS, ptE, vtToolDir, vtToolDir, nStartI, nStartJ, nEndI, nEndJ, dMaxRad, dMinRad, dHei) ;
if ( ! Control)
return true ;
Point3d ptI = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) ;
Point3d ptF = ( vtToolDir * ( ptE - ptS) > 0 ? ptE : ptS) ;
Point3d ptIT = ptI - vtToolDir * dHei ;
Point3d ptFT = ptF - vtToolDir * dHei ;
Point3d ptIxy( ptI.x, ptI.y, 0) ;
Point3d ptFxy( ptF.x, ptF.y, 0) ;
Vector3d vtMove = ptF - ptI ; double dLen = vtMove.Len() ;
Vector3d vtMLong = ( vtMove * vtToolDir) * vtToolDir ; double dLLong = vtMLong.Len() ;
Vector3d vtMOrt = vtMove - vtMLong ; double dLOrt = vtMOrt.Len() ;
Vector3d vtV1 = vtToolDir ;
Vector3d vtV2 = vtMOrt ; vtV2.Normalize() ;
Vector3d vtV3 = vtV1 ^ vtV2 ;
double dZI = ptI.z ;
double dZTI = ptI.z - vtV1.z * dHei ;
double dDeltaZ = ptF.z - ptI.z ;
double dDeltaR = dMaxRad - dMinRad ;
double dTan = dDeltaR / dHei ;
double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ;
bool bCase = ( dRatio * dTan > 1 ? false : true) ;
double dCos = dTan * dRatio ;
double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ;
double dDen = sqrt( 1 + dTan * dTan) ;
Point3d ptV = ptI - vtV1 * ( dHei * dMaxRad / dDeltaR) ;
Point3d ptVF = ptV + vtMove ;
Vector3d vtNs = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 + ( dSin / dDen) * vtV3 ;
Vector3d vtNd = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 - ( dSin / dDen) * vtV3 ;
Vector3d vtR0 = ptV - ORIG ;
vtNs.Normalize() ;
vtNd.Normalize() ;
double dDots = vtR0 * vtNs ;
double dDotd = vtR0 * vtNd ;
double dMin, dMax, dPLim, dMLim ;
Vector3d vtMin, vtMax, vtP, vtM ;
Vector3d vtUmv = vtMove ;
vtUmv.Normalize() ;
Point3d ptInt ;
for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
for ( unsigned 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 vtCI = ptC - ptIxy ; double dSqDI = vtCI.SqLenXY() ;
Vector3d vtCF = ptC - ptFxy ; double dSqDF = vtCF.SqLenXY() ;
double dIDO = vtCI * vtV3 ;
double dIDL = vtCI * vtV2 ;
double dIVarCos = dIDL / sqrt( dSqDI) ;
double dFDL = vtCF * vtV2 ;
double dFVarCos = dFDL / sqrt( dSqDF) ;
if ( dSqDI < dMaxRad * dMaxRad || dSqDF < dMaxRad * dMaxRad ||
(abs( dIDO) < dMaxRad && dIDL > 0 && dIDL < dLOrt)) {
// Caso dTan * dRatio < 1
if ( bCase) {
// Limiti nella direzione positiva di vtV1
if ( dSqDF < dMaxRad * dMaxRad) {
dPLim = dZI + dDeltaZ ;
vtP = - vtToolDir ;
}
else {
dPLim = dZI + ( dIDL + sqrt( dMaxRad * dMaxRad - dIDO * dIDO)) * dDeltaZ / dLOrt ;
ptInt.Set( dX, dY, dPLim) ;
vtP = - ( ptInt - ptI) + ( ptInt - ptI) * vtUmv * vtUmv ;
vtP.Normalize() ;
}
// Limiti nella direzione negativa di vtV1
if ( dSqDI < dMinRad * dMinRad) {
dMLim = dZTI ;
vtM = vtToolDir ;
}
else if ( dSqDI < dMaxRad * dMaxRad) {
dMLim = dZTI + ( sqrt( dSqDI) - dMinRad) * ( dZI - dZTI) / dDeltaR ;
ptInt.Set( dX, dY, dMLim) ;
Vector3d vtU = ( ptInt - ptV) - ( ptInt - ptV) * vtToolDir * vtToolDir ;
vtU.Normalize() ;
vtM = dDeltaR * vtToolDir - dHei * vtU ;
vtM.Normalize() ;
}
else {
dMLim = dZI + ( dIDL - sqrt( dMaxRad * dMaxRad - dIDO * dIDO)) * dDeltaZ / dLOrt ;
ptInt.Set( dX, dY, dMLim) ;
vtM = - ( ptInt - ptI) + ( ptInt - ptI) * vtUmv * vtUmv ;
vtM.Normalize() ;
}
}
else {
// Limiti nella direzione positiva di vtV1
if ( dSqDF < dMaxRad * dMaxRad) {
dPLim = dZI + dDeltaZ ;
vtP = - vtToolDir ;
}
else {
dPLim = dZI + ( dIDL + sqrt( dMaxRad * dMaxRad - dIDO * dIDO)) * dDeltaZ / dLOrt ;
ptInt.Set( dX, dY, dPLim) ;
vtP = - ( ptInt - ptI) + ( ptInt - ptI) * vtUmv * vtUmv ;
vtP.Normalize() ;
}
// Limiti nella direzione negativa di vtV1
if ( dSqDI < dMinRad * dMinRad) {
dMLim = dZTI ;
vtM = vtToolDir ;
}
else if ( dSqDI < dMaxRad * dMaxRad) {
dMLim = dZTI + ( sqrt( dSqDI) - dMinRad) * ( dZI - dZTI) / dDeltaR ;
ptInt.Set( dX, dY, dMLim) ;
Vector3d vtU = ( ptInt - ptV) - ( ptInt - ptV) * vtToolDir * vtToolDir ;
vtU.Normalize() ;
vtM = dDeltaR * vtToolDir - dHei * vtU ;
vtM.Normalize() ;
}
else {
dMLim = dZI + ( dIDL - sqrt( dMaxRad * dMaxRad - dIDO * dIDO)) * dDeltaZ / dLOrt ;
ptInt.Set( dX, dY, dMLim) ;
vtM = - ( ptInt - ptI) + ( ptInt - ptI) * vtUmv * vtUmv ;
vtM.Normalize() ;
}
}
//dMin = min( dPLim, dMLim) ;
//dMax = max( dPLim, dMLim) ;
if ( dMLim < dPLim) {
dMin = dMLim ;
dMax = dPLim ;
vtMin = vtM ;
vtMax = vtP ;
}
else {
dMin = dPLim ;
dMax = dMLim ;
vtMin = vtP ;
vtMax = vtM ;
}
SubtractIntervals( nGrid, i, j, dMin, dMax, vtMin, vtMax) ;
}
}
}
return true ;
}*/
// Asse di simmetria con orientazione generica: FORATURA