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

EgtGeomKernel :

Browse Source 
- aggiunta creazione solidi Zmap per estrusione di regione.
This commit is contained in:
Dario Sassi
2016-10-31 19:22:55 +00:00
parent 78e5b03411
commit afce50e1c8
4 changed files with 353 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmap.cpp
+308 -128
View File
@@ -371,15 +371,20 @@ VolZmap::CreateMap( const Point3d& ptO, double dLengthX, double dLengthY, double
if ( dLengthX < EPS_SMALL || dLengthY < EPS_SMALL || dLengthZ < EPS_SMALL)
return false ;
// Definisco il sistema di riferimento in trinseco dello Zmap
m_LocalFrame.Set( ptO, X_AX, Y_AX, Z_AX) ;
// Il passo di discretizzazione non può essere inferiore a 100 * EPS_SMALL
m_dStep = max( dPrec, 100 * EPS_SMALL) ;
// A partire dalle dimensioni di xy del grezzo determino il numero di colonne e righe
// della griglia Zmap e da questi la dimensione del vettore di dexel
m_nNx = static_cast <unsigned int> ( ceil( dLengthX / m_dStep)) ;
m_nNy = static_cast <unsigned int> ( ceil( dLengthY / m_dStep)) ;
m_nDim = m_nNx * m_nNy ;
// Ridimensiono il vettore di dexel e creo lo Zmap
m_ZValues.resize( m_nDim) ;
for ( int i = 0 ; i < int( m_nDim) ; i++) {
@@ -388,6 +393,7 @@ VolZmap::CreateMap( const Point3d& ptO, double dLengthX, double dLengthY, double
m_ZValues[i][1] = dLengthZ ;
}
// Assegno il minimo e massimo valore di Z della mappa
m_dMinZ = 0 ;
m_dMaxZ = dLengthZ ;
@@ -395,6 +401,97 @@ VolZmap::CreateMap( const Point3d& ptO, double dLengthX, double dLengthY, double
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::CreateMapFromFlatRegion( const ISurfFlatRegion& Surf, double dLengthZ, double dPrec)
{
Point3d ptMapOrig, ptMapEnd ;
// Determino il bounding box della flat region
BBox3d SurfBBox ;
Surf.GetLocalBBox( SurfBBox, 2) ;
// Determino i punti estremi del bounding box
SurfBBox.GetMinMax( ptMapOrig, ptMapEnd) ;
// Sistema di riferimento mappa
m_LocalFrame.Set( ptMapOrig, X_AX, Y_AX, Z_AX) ;
// Il passo di discretizzazione non può essere inferiore a 100 * EPS_SMALL
m_dStep = max( dPrec, 100 * EPS_SMALL) ;
// Determino le dimensioni lineari X Y della griglia
double dLengthX = ptMapEnd.x - ptMapOrig.x ;
double dLengthY = ptMapEnd.y - ptMapOrig.y ;
// A partire dalle dimensioni di xy del grezzo determino il numero di colonne e righe
// della griglia Zmap e da questi la dimensione del vettore di dexel
m_nNx = static_cast <unsigned int> ( ceil( dLengthX / m_dStep)) ;
m_nNy = static_cast <unsigned int> ( ceil( dLengthY / m_dStep)) ;
m_nDim = m_nNx * m_nNy ;
// Ridimensiono il vettore di dexel e creo lo Zmap
m_ZValues.resize( m_nDim) ;
// Determinazione e ridimensionamento dei dexel
// interni alla regione
for( unsigned int i = 0 ; i < m_nNx ; ++ i) {
// Definisco la retta da intersecare con la regione
double dX = ( i + 0.5) * m_dStep ;
Point3d ptP0 = ptMapOrig + Vector3d( dX, 0, 0) ;
CurveLine GridLine ;
GridLine.SetPVL( ptP0, Y_AX, dLengthY) ;
// Determino le intersezioni della retta con la regione
CRVCVECTOR IntersectionResults ;
Surf.GetCurveClassification( GridLine, IntersectionResults) ;
// Parti di cui la retta analizzata è composta
int nPart = int( IntersectionResults.size()) ;
// Analizzio le parti
for ( int k = 0 ; k < nPart ; ++ k) {
// Tipo di curva
int nType = IntersectionResults[k].nClass ;
// Se la retta è interna alla regione o coincidente con parte della sua frontiera
if ( nType == CRVC_IN || nType == CRVC_ON_P || nType == CRVC_ON_M) {
// Parametri iniziale e finale
double dt1 = IntersectionResults[k].dParS ;
double dt2 = IntersectionResults[k].dParE ;
// Indici corrispondenti alle coordinate dei punti
unsigned int nStartJ = static_cast <unsigned int> ( floor( dt1 * m_nNy)) ;
unsigned int nEndJ = static_cast <unsigned int> ( floor( dt2 * m_nNy)) ;
nEndJ = ( nEndJ >= m_nNy ? m_nNy - 1 : nEndJ) ;
// Ridimensiono e riempio i dexel
for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
// Determino il dexel
unsigned int nPos = j * m_nNx + i ;
m_ZValues[nPos].resize( 2) ;
// Aggiorno le quote estreme del segmento
m_ZValues[nPos][0] = 0 ;
m_ZValues[nPos][1] = dLengthZ ;
}
}
}
}
// Assegno il minimo e massimo valore di Z della mappa
m_dMinZ = 0 ;
m_dMaxZ = dLengthZ ;
m_nStatus = OK ;
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::SubtractIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMax)
@@ -994,10 +1091,10 @@ VolZmap::SetAdvTool( const string& sToolName, double dH, double dR,
//----------------------------------------------------------------------------
bool
VolZmap::SetGenTool( const string& pToolName, const ICurveComposite* pToolOutline)
VolZmap::SetGenTool( const string& sToolName, const ICurveComposite* pToolOutline)
{
// Aggiorno il nome dell'utensile
m_sToolName = pToolName ;
m_sToolName = sToolName ;
// Aggiorno il tipo di utensile
m_nToolType = GenericTool ;
@@ -1017,46 +1114,60 @@ VolZmap::SetGenTool( const string& pToolName, const ICurveComposite* pToolOutlin
// Se la curva è un arco valuto approssimarlo
if ( pCurve->GetType() == CRV_ARC) {
// Centro e punti iniziale e finale dell'arco
Point3d ptStart, ptEnd, ptO ;
pCurve->GetStartPoint( ptStart) ;
pCurve->GetEndPoint( ptEnd) ;
pCurve->GetCenterPoint( ptO) ;
// Vettore congiungente il centro con i punti iniziale e finale
Vector3d vtStRad = ptStart - ptO ;
Vector3d vtEnRad = ptEnd - ptO ;
// Calcolo del raggio dell'arco
double dRadius = GetBasicCurveArc( pCurve)->GetRadius() ;
// Recupero la curva precedente e quella successiva
const ICurve* pPrev = m_ToolOutline.GetPrevCurve() ;
const ICurve* pNext = m_ToolOutline.GetNextCurve() ;
pNext = m_ToolOutline.GetNextCurve() ;
Point3d ptPs, ptCt, ptCb, ptNe ;
Vector3d vtNPf, vtNCi, vtNCf, vtNNi ;
// Valuto la necessità di approssimare l'arco o meno
// Punto Iniziale della curva precedente e finale della successiva
Point3d ptStartPrev, ptEndNext ;
// Vettori tangenti alle curve precedente corrente e successiva
// rispettivamente nei punti finale, iniziale e finale e iniziale
// e prodotti vettore fra i suddetti
Vector3d vtPrevEndDir, vtCurrentStartDir, vtCurrentEndDir, vtNextStartDir ;
Vector3d vtIProd, vtFProd ;
ptCt = ptO + Y_AX * dRadius ;
ptCb = ptO - Y_AX * dRadius ;
Point3d ptTopCurrent = ptO + Y_AX * dRadius ;
Point3d ptBottomCurrent = ptO - Y_AX * dRadius ;
pPrev->GetStartPoint( ptPs) ;
pPrev->GetEndDir( vtNPf) ;
pCurve->GetStartDir( vtNCi) ;
vtIProd = vtNPf ^ vtNCi ;
// Valuto le relazioni geometriche fra la
// curva corrente e quella precedente.
pPrev->GetStartPoint( ptStartPrev) ;
pPrev->GetEndDir( vtPrevEndDir) ;
pCurve->GetStartDir( vtCurrentStartDir) ;
vtIProd = vtPrevEndDir ^ vtCurrentStartDir ;
// Se la curva successiva esiste valuto le
// medesime relazioni con la quest'ultima
if ( pNext != nullptr) {
pNext->GetEndPoint( ptNe) ;
pCurve->GetEndDir( vtNCf) ;
pNext->GetStartDir( vtNNi) ;
vtFProd = vtNCf ^ vtNNi ;
pNext->GetEndPoint( ptEndNext) ;
pCurve->GetEndDir( vtCurrentEndDir) ;
pNext->GetStartDir( vtNextStartDir) ;
vtFProd = vtCurrentEndDir ^ vtNextStartDir ;
}
// Se devo approssimare
if ( ! ( ( abs( ptO.x) < EPS_SMALL && vtIProd.z > 0 && ptPs.y > ptCt.y) &&
if ( ! ( ( abs( ptO.x) < EPS_SMALL && vtIProd.z > 0 && ptStartPrev.y > ptTopCurrent.y) &&
( ( pNext == nullptr && abs( ptEnd.x) < EPS_SMALL) ||
( pNext != nullptr && vtFProd.z > 0 && ptCb.y > ptNe.y)))) {
( pNext != nullptr && vtFProd.z > 0 && ptBottomCurrent.y > ptEndNext.y)))) {
// Copio la parte precedente
const ICurve* pAux = m_ToolOutline.GetFirstCurve() ;
@@ -1088,14 +1199,16 @@ VolZmap::SetGenTool( const string& pToolName, const ICurveComposite* pToolOutlin
}
// Se non deve essere approssimato
else {
// Se è già stato definito m_ToolArcLineApprox deve essere completo
// Se è già stato definito m_ToolArcLineApprox deve
// essere completo, aggiungo quindi l'arco corrente
if ( m_ToolArcLineApprox.GetCurveCount() != 0)
m_ToolArcLineApprox.AddCurve( * pCurve, true) ;
}
}
// Se è segmento
else {
// Se è già stato definito m_ToolArcLineApprox deve essere completo
// Se è già stato definito m_ToolArcLineApprox deve
// essere completo, aggiungo quindi il segmento corrente
if ( m_ToolArcLineApprox.GetCurveCount() != 0)
m_ToolArcLineApprox.AddCurve( * pCurve, true) ;
}
@@ -1256,12 +1369,12 @@ VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Point3d&
bool
VolZmap::DrillingZ( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtToolDir)
{
// Cilindro sfera toro
if ( m_nToolType == CylindricalMill || m_nToolType == BallEndMill ||
m_nToolType == BullNoseMill)
return CBTDrillZ( ptLs, ptLe, vtToolDir) ;
// Coni
else if ( m_nToolType == ConusMill)
return ConusDrillingZ( ptLs, ptLe, vtToolDir) ;
@@ -1360,11 +1473,10 @@ VolZmap::ConusDrillingZ( const Point3d ptLs, const Point3d ptLe, const Vector3d
if ( m_dRadius < m_dTipRadius)
// Coda di rondine
return GetMinMaxZSw( ptO, nStartI, nEndI, nStartJ, nEndJ, dMinZ, dMaxZ, dMinRad, dMaxRad, vtToolDir.z, dDeltaZ) ;
// Punta di trapano
else
return GetMinMaxZDr( ptO, nStartI, nEndI, nStartJ, nEndJ, dMinZ, dMaxZ, dMinRad, dMaxRad, vtToolDir.z, dDeltaZ) ;
}
@@ -1378,6 +1490,8 @@ VolZmap::GetMinMaxZSw( const Point3d ptO, unsigned int nStartI, unsigned int nEn
for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
// Determinazione della posizione xy del dexel rispetto
// all'asse di simmetria dell'utensile
double dX = ( i + 0.5) * m_dStep ;
double dY = ( j + 0.5) * m_dStep ;
@@ -1386,21 +1500,24 @@ VolZmap::GetMinMaxZSw( const Point3d ptO, unsigned int nStartI, unsigned int nEn
double dSqDist = vtC * vtC ;
double dMin, dMax ;
// Se il dexel cade nel cerchio di interesse taglio
if ( dSqDist < dMaxRad * dMaxRad) {
double dMin, dMax ;
if ( dSqDist < dMinRad * dMinRad) {
dMin = dMinZ ;
dMax = dMaxZ ;
}
else {
double dR = sqrt( dSqDist) ;
if ( dDir > 0) {
dMin = dMinZ ;
dMax = dMinZ + dDeltaZ + ( m_dTipHeight * ( dMaxRad - sqrt( dSqDist))) / ( dMaxRad - dMinRad) ;
dMax = dMinZ + dDeltaZ + ( m_dTipHeight * ( dMaxRad - dR)) / ( dMaxRad - dMinRad) ;
}
else {
dMin = dMaxZ - dDeltaZ + ( m_dTipHeight * ( sqrt( dSqDist) - dMaxRad)) / ( dMaxRad - dMinRad) ;
dMin = dMaxZ - dDeltaZ + ( m_dTipHeight * ( dR - dMaxRad)) / ( dMaxRad - dMinRad) ;
dMax = dMaxZ ;
}
}
@@ -1431,22 +1548,25 @@ VolZmap::GetMinMaxZDr( const Point3d ptO, unsigned int nStartI, unsigned int nEn
double dSqDist = vtC * vtC ;
double dMin, dMax ;
// Se il dexel cade nel cerchio di interesse taglio
if ( dSqDist < dMaxRad * dMaxRad) {
double dMin, dMax ;
if ( dSqDist < dMinRad * dMinRad) {
dMin = dMinZ ;
dMax = dMaxZ ;
}
else {
double dR = sqrt( dSqDist) ;
if ( dDir > 0) {
dMin = dMinZ + ( m_dTipHeight * ( sqrt( dSqDist) - dMinRad)) / ( dMaxRad - dMinRad) ;
dMin = dMinZ + ( m_dTipHeight * ( dR - dMinRad)) / ( dMaxRad - dMinRad) ;
dMax = dMaxZ ;
}
else {
dMin = dMinZ ;
dMax = dMaxZ + ( m_dTipHeight * ( sqrt( dSqDist) - dMinRad)) / ( dMinRad - dMaxRad) ;
dMax = dMaxZ + ( m_dTipHeight * ( dR - dMinRad)) / ( dMinRad - dMaxRad) ;
}
}
@@ -1461,19 +1581,19 @@ VolZmap::GetMinMaxZDr( const Point3d ptO, unsigned int nStartI, unsigned int nEn
//----------------------------------------------------------------------------
bool
VolZmap::MillingPerpZ( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtToolDir) {
// Cilindro sfera toro
if ( m_nToolType == CylindricalMill ||
m_nToolType == BallEndMill ||
m_nToolType == BullNoseMill)
return CBTMillingPerpZ( ptLs, ptLe, vtToolDir) ;
// Coni
else if ( m_nToolType == ConusMill)
return ConusPerpZ( ptLs, ptLe, vtToolDir) ;
else
return true ; // forse qui ci va il nuovo
return false ;
}
//----------------------------------------------------------------------------
@@ -1601,14 +1721,16 @@ VolZmap::ConusPerpZ( const Point3d ptLs, const Point3d ptLe, const Vector3d vtTo
else if ( dSqDist >= dMinRad * dMinRad && dSqDist < dMaxRad * dMaxRad) {
if ( m_dRadius < m_dTipRadius) {
dMin = min( dZTip, dZStem + ( sqrt( dSqDist) - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ;
dMax = max( dZTip, dZStem+ ( sqrt( dSqDist) - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ;
}
double dr = sqrt( dSqDist) ;
if ( m_dRadius < m_dTipRadius) {
dMin = min( dZTip, dZStem + ( dr - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ;
dMax = max( dZTip, dZStem + ( dr - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ;
}
else {
dMin = min( dZBase, dZTip + ( sqrt( dSqDist) - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ;
dMax = max( dZBase, dZTip + ( sqrt( dSqDist) - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ;
dMin = min( dZBase, dZTip + ( dr - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ;
dMax = max( dZBase, dZTip + ( dr - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ;
}
SubtractIntervals( i, j, dMin, dMax) ;
}
@@ -1628,14 +1750,16 @@ VolZmap::ConusPerpZ( const Point3d ptLs, const Point3d ptLe, const Vector3d vtTo
else if ( dSqDist >= dMinRad * dMinRad && dSqDist < dMaxRad * dMaxRad) {
double dr = sqrt( dSqDist) ;
if ( m_dRadius < m_dTipRadius) {
dMin = min( dZTip, dZStem + ( sqrt( dSqDist) - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ;
dMax = max( dZTip, dZStem + ( sqrt( dSqDist) - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ;
dMin = min( dZTip, dZStem + ( dr - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ;
dMax = max( dZTip, dZStem + ( dr - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ;
}
else {
dMin = min( dZBase, dZTip + ( sqrt( dSqDist) - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ;
dMax = max( dZBase, dZTip + ( sqrt( dSqDist) - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ;
dMin = min( dZBase, dZTip + ( dr - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ;
dMax = max( dZBase, dZTip + ( dr - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ;
}
SubtractIntervals( i, j, dMin, dMax) ;
}
@@ -1656,14 +1780,16 @@ VolZmap::ConusPerpZ( const Point3d ptLs, const Point3d ptLe, const Vector3d vtTo
else if ( dSqDist >= dMinRad * dMinRad && dSqDist < dMaxRad * dMaxRad) {
double dr = sqrt( dSqDist) ;
if ( m_dRadius < m_dTipRadius) {
dMin = min( dZTip, dZStem + ( sqrt( dSqDist) - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ;
dMax = max( dZTip, dZStem + ( sqrt( dSqDist) - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ;
dMin = min( dZTip, dZStem + ( dr - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ;
dMax = max( dZTip, dZStem + ( dr - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ;
}
else {
dMin = min( dZBase, dZTip + ( sqrt( dSqDist) - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ;
dMax = max( dZBase, dZTip + ( sqrt( dSqDist) - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ;
dMin = min( dZBase, dZTip + ( dr - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ;
dMax = max( dZBase, dZTip + ( dr - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ;
}
SubtractIntervals( i, j, dMin, dMax) ;
}
@@ -1710,15 +1836,17 @@ VolZmap::GetMinMaxZ( unsigned int nI, unsigned int nJ, double dZCutBase,
else if ( m_nToolType == 2) {
double dMin, dMax ;
double dH = sqrt( dSqRad - dSqDist) ;
if ( abs( vtToolDir.z * dDeltaZ) < EPS_SMALL) {
dMin = min( dZCutBase, dZtip + dFactor*( m_dRadius - sqrt( dSqRad - dSqDist))) ;
dMax = max( dZCutBase, dZtip + dFactor*( m_dRadius - sqrt( dSqRad - dSqDist))) ;
dMin = min( dZCutBase, dZtip + dFactor*( m_dRadius - dH)) ;
dMax = max( dZCutBase, dZtip + dFactor*( m_dRadius - dH)) ;
}
else if ( vtToolDir.z * dDeltaZ < 0) {
dMin = min( dZtip + dFactor*( m_dRadius - sqrt( dSqRad - dSqDist)),
dZtip + dFactor*( m_dRadius - sqrt( dSqRad - dSqDist)) + dDeltaZ) ;// ocio
dMax = max( dZtip + dFactor*( m_dRadius - sqrt( dSqRad - dSqDist)),
dZtip + dFactor*( m_dRadius - sqrt( dSqRad - dSqDist)) + dDeltaZ) ;// ocio
dMin = min( dZtip + dFactor*( m_dRadius - dH),
dZtip + dFactor*( m_dRadius - dH) + dDeltaZ) ;// ocio
dMax = max( dZtip + dFactor*( m_dRadius - dH),
dZtip + dFactor*( m_dRadius - dH) + dDeltaZ) ;// ocio
}
else {
dMin = min( dZCutBase, dZCutBase + dDeltaZ) ;
@@ -1755,17 +1883,18 @@ VolZmap::GetMinMaxZ( unsigned int nI, unsigned int nJ, double dZCutBase,
double dSqRadC = m_dRCorner * m_dRCorner ;
double dSqd = dSqDist + dDeltaR * dDeltaR - 2 * sqrt( dSqDist) * dDeltaR ;
double dSqrt = sqrt(dSqRadC - dSqd) ;
double dMin, dMax ;
if ( abs( vtToolDir.z * dDeltaZ) < EPS_SMALL) {
dMin = min( dZCutBase, dZtip + dFactor*( m_dRCorner - sqrt(dSqRadC - dSqd))) ;
dMax = max( dZCutBase, dZtip + dFactor*( m_dRCorner - sqrt(dSqRadC - dSqd))) ;
dMin = min( dZCutBase, dZtip + dFactor*( m_dRCorner - dSqrt)) ;
dMax = max( dZCutBase, dZtip + dFactor*( m_dRCorner - dSqrt)) ;
}
else if ( vtToolDir.z * dDeltaZ < 0) {
dMin = min( dZtip + dFactor *( m_dRCorner - sqrt( dSqRadC - dSqd)),
dZtip + dFactor *( m_dRCorner - sqrt( dSqRadC - dSqd)) + dDeltaZ) ;
dMax = max( dZtip + dFactor *( m_dRCorner - sqrt( dSqRadC - dSqd)),
dZtip + dFactor *( m_dRCorner - sqrt( dSqRadC - dSqd)) + dDeltaZ) ;
dMin = min( dZtip + dFactor *( m_dRCorner - dSqrt),
dZtip + dFactor *( m_dRCorner - dSqrt) + dDeltaZ) ;
dMax = max( dZtip + dFactor *( m_dRCorner - dSqrt),
dZtip + dFactor *( m_dRCorner - dSqrt) + dDeltaZ) ;
}
else {
dMin = min( dZCutBase, dZCutBase + dDeltaZ) ;
@@ -1934,15 +2063,20 @@ VolZmap::ConusMillingZDr( const Point3d ptLs, const Point3d ptLe, const Vector3d
// Apertura del cono e parametri per determinare i piani
double dTanAlpha = ( dMaxRad - dMinRad) / m_dTipHeight ;
double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ;
double dCos = dTanAlpha * dRatio ;
double dSin = ( abs( dCos) < 1 ? sqrt( 1 - dCos * dCos) : 0) ;
double dDen = sqrt( 1 + dTanAlpha * dTanAlpha) ;
// Versori normali e prodotti scalari per per determinare i piani
Vector3d vtNs = - ( dTanAlpha / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV1 +
( dCos / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV2 +
( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV3 ;
Vector3d vtNd = - ( dTanAlpha / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV1 +
( dCos / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV2 -
( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV3 ;
Vector3d vtNs = - ( dTanAlpha / dDen) * vtV1 +
( dCos / dDen) * vtV2 +
( dSin / dDen) * vtV3 ;
Vector3d vtNd = - ( dTanAlpha / dDen) * vtV1 +
( dCos / dDen) * vtV2 -
( dSin / dDen) * vtV3 ;
Vector3d vtR0 = ptV - ORIG ;
double dDots = vtR0 * vtNs ;
double dDotd = vtR0 * vtNd ;
@@ -1956,7 +2090,7 @@ VolZmap::ConusMillingZDr( const Point3d ptLs, const Point3d ptLe, const Vector3d
for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
// Grandezze per determinare la configurazione geometrica dell'utensile
double dMin, dMax ;
double dX = ( i + 0.5) * m_dStep ;
double dY = ( j + 0.5) * m_dStep ;
@@ -1978,10 +2112,13 @@ VolZmap::ConusMillingZDr( const Point3d ptLs, const Point3d ptLe, const Vector3d
double dSqDistM = vtOrt * vtOrt ;
double dSqDistF = vtCf * vtCf ;
// Se dentro la zona interessata dalla lavorazione valuto
// la tipologia di tale zona
if ( ( dProj < 0 && dSqDistI < dMaxRad * dMaxRad) ||
( dProj >= 0 && dProj < dLen && dSqDistM < dMaxRad * dMaxRad) ||
( dProj >= dLen && dSqDistF < dMaxRad * dMaxRad)) {
// Caso vettore utensile equiverso all'asse Z
if ( vtToolDir.z > 0) {
// Massimi
double dPMaxI = ( dMaxRad * dMaxRad - dSqDistM > 0 ? sqrt( dMaxRad * dMaxRad - dSqDistM) : 0) ;
@@ -2050,7 +2187,7 @@ VolZmap::ConusMillingZDr( const Point3d ptLs, const Point3d ptLe, const Vector3d
}
}
}
// Caso vettore utensile opposto all'asse Z
else {
// Massimi
double dPMaxI = ( dMaxRad * dMaxRad - dSqDistM > 0 ? sqrt( dMaxRad * dMaxRad - dSqDistM) : 0) ;
@@ -2198,15 +2335,20 @@ VolZmap::ConusMillingZSw( const Point3d ptLs, const Point3d ptLe, const Vector3d
// Apertura del cono e parametri per determinare i piani
double dTanAlpha = ( dMaxRad - dMinRad) / m_dTipHeight ;
double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ;
double dCos = dTanAlpha * dRatio ;
double dSin = ( abs( dCos) < 1 ? sqrt( 1- dCos * dCos) : 0) ;
double dDen = sqrt( 1 + dTanAlpha * dTanAlpha) ;
// Versori normali e prodotti scalari per per determinare i piani
Vector3d vtNp = - ( dTanAlpha / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV1 +
( dCos / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV2 +
( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV3 ;
Vector3d vtNm = - ( dTanAlpha / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV1 +
( dCos / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV2 -
( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV3 ;
Vector3d vtNp = - ( dTanAlpha / dDen) * vtV1 +
( dCos / dDen) * vtV2 +
( dSin / dDen) * vtV3 ;
Vector3d vtNm = - ( dTanAlpha / dDen) * vtV1 +
( dCos / dDen) * vtV2 -
( dSin / dDen) * vtV3 ;
Vector3d vtR0 = ptV - ORIG ;
double dDotp = vtR0 * vtNp ;
double dDotm = vtR0 * vtNm ;
@@ -2240,7 +2382,7 @@ VolZmap::ConusMillingZSw( const Point3d ptLs, const Point3d ptLe, const Vector3d
if ( ( dProj < 0 && dSqDistI < dMaxRad * dMaxRad) ||
( dProj >= 0 && dProj < dLen && dSqDistM < dMaxRad * dMaxRad) ||
( dProj >= dLen && dSqDistF < dMaxRad * dMaxRad)) {
// Caso vettore utensile equiverso all'asse Z
if ( vtV1.z < 0) {
double dPMaxI = ( dMaxRad * dMaxRad - dSqDistM > 0 ? sqrt( dMaxRad * dMaxRad - dSqDistM) : 0) ;
@@ -2318,7 +2460,8 @@ VolZmap::ConusMillingZSw( const Point3d ptLs, const Point3d ptLe, const Vector3d
dMin = dZIS - m_dTipHeight + ( dProj + dPMaxI) * dDeltaZ / dLen ;
} // Fine vtV1 < 0
}
// Caso vettore utensile opposto all'asse Z
else {
double dPMaxI = ( dMaxRad * dMaxRad - dSqDistM > 0 ? sqrt( dMaxRad * dMaxRad - dSqDistM) : 0) ;
@@ -3582,16 +3725,22 @@ VolZmap::ConusPlaneGen( const Point3d& ptLs, const Point3d& ptLe, const Vector3d
Vector3d vtV3 = vtV1 ^ vtV2 ;
double dTan = ( dMaxRad - dMinRad) / m_dTipHeight ;
double dCos = dTan * ( vtMove * vtV1) / ( vtMove * vtV2) ;
double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ;
double dCos = dTan * dRatio ;
double dSin = ( abs( dCos) < 1 ? sqrt( 1 - dCos * dCos) : 0) ;
double dDen = sqrt( 1 + dTan * dTan) ;
double dDeltaR = dMaxRad - dMinRad ;
double dMinLim = dMinRad * dCos ;
double dMaxLim = dMaxRad * dCos ;
// Versori normali e prodotti scalari per per determinare i piani
Vector3d vtNInf = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 + ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTan * dTan)) * vtV3 ;
Vector3d vtNSup = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 - ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTan * dTan)) * vtV3 ;
// Versori normali e prodotti scalari per determinare i piani
Vector3d vtNInf = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 + ( dSin / dDen) * vtV3 ;
Vector3d vtNSup = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 - ( dSin / dDen) * vtV3 ;
Point3d ptV = ptI - vtV1 * ( dMaxRad * m_dTipHeight) / ( dMaxRad - dMinRad) ;
Vector3d vtR0 = ptV - ORIG ;
double dDotInf = vtR0 * vtNInf ;
@@ -4260,12 +4409,15 @@ VolZmap::XYLongVertConus( const Point3d& ptLs, const Point3d& ptLe, const Vector
// Apertura del cono e parametri per determinare i piani
double dTan = ( dMaxRad - dMinRad) / m_dTipHeight ;
double dRatio = ( dDeltaZ > 0 ? - ( vtMove * vtV1) / ( vtMove * vtV3) : ( vtMove * vtV1) / ( vtMove * vtV3)) ;
double dCos = dTan * dRatio ;
double dSen = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ;
double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ;
double dDen = sqrt( 1 + dTan * dTan) ;
// Versori normali e prodotti scalari per per determinare i piani
Vector3d vtNs = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + dFactor * ( dCos / sqrt( 1 + dTan * dTan)) * vtV3 - dFactor * ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTan * dTan)) * vtV2 ;
Vector3d vtNd = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + dFactor * ( dCos / sqrt( 1 + dTan * dTan)) * vtV3 + dFactor * ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTan * dTan)) * vtV2 ;
Vector3d vtNs = - ( dTan / dDen) * vtV1 + dFactor * ( dCos / dDen) * vtV3 - dFactor * ( dSin / dDen) * vtV2 ;
Vector3d vtNd = - ( dTan /dDen) * vtV1 + dFactor * ( dCos / dDen) * vtV3 + dFactor * ( dSin / dDen) * vtV2 ;
Vector3d vtR0 = ptV - ORIG ;
double dDots = vtR0 * vtNs ;
double dDotd = vtR0 * vtNd ;
@@ -4289,7 +4441,7 @@ VolZmap::XYLongVertConus( const Point3d& ptLs, const Point3d& ptLe, const Vector
if ( dRatio <= 1 / dTan) {
if ( dProj1 < m_dTipHeight && dOrtLen < dMaxRad * dSen - dProj1 * dDeltaR * dSen / m_dTipHeight) { // Il limite inferiore d dProj1 è già stato imposto dall' if più esterno
if ( dProj1 < m_dTipHeight && dOrtLen < dMaxRad * dSin - dProj1 * dDeltaR * dSin / m_dTipHeight) { // Il limite inferiore d dProj1 è già stato imposto dall' if più esterno
double dr = dMaxRad - dProj1 * dDeltaR / m_dTipHeight ;
double dH = sqrt( dr * dr - dOrtLen * dOrtLen) ;
@@ -4297,21 +4449,21 @@ VolZmap::XYLongVertConus( const Point3d& ptLs, const Point3d& ptLe, const Vector
dZL1 = dZI + dFactor * dH ;
}
else if ( dProj1 > 0 && dProj1 < dPLen &&
dOrtLen > dMaxRad * dSen && dOrtLen < dMaxRad) {
dOrtLen > dMaxRad * dSin && dOrtLen < dMaxRad) {
double dH = sqrt( dMaxRad * dMaxRad - dOrtLen * dOrtLen) ;
dZL1 = dZI + dFactor * dH + dProj1 * dDeltaZ / dPLen ;
}
else if ( dProj1 > m_dTipHeight && dProj1 < dPLen + m_dHeight &&
dOrtLen < dMinRad * dSen) {
dOrtLen < dMinRad * dSin) {
double dH = sqrt( dMinRad * dMinRad - dOrtLen * dOrtLen) ;
dZL1 = dZI + dFactor * dH + ( dProj1 - m_dTipHeight) * dDeltaZ / dPLen ;
}
else if ( dProj1 >= dPLen &&
dOrtLen > dMaxRad * dSen - ( dProj1 - dPLen) * dDeltaR * dSen / m_dTipHeight) { // I limiti superiori sono già stati imposti dall' if più esterno
dOrtLen > dMaxRad * dSin - ( dProj1 - dPLen) * dDeltaR * dSin / m_dTipHeight) { // I limiti superiori sono già stati imposti dall' if più esterno
double dr = dMaxRad - ( dProj1 - dPLen) * dDeltaR / m_dTipHeight ;
@@ -4810,11 +4962,16 @@ VolZmap::MillingXYConus( const Point3d& ptLs, const Point3d& ptLe, const Vector3
// Apertura del cono e parametri per determinare i piani
double dTanAlpha = ( dMaxRad - dMinRad) / m_dTipHeight ;
double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ;
double dCos = dTanAlpha * dRatio ;
double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ;
double dDen = sqrt( 1 + dTanAlpha * dTanAlpha) ;
// Versori normali e prodotti scalari per per determinare i piani
Vector3d vtNs = - ( dTanAlpha / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV1 + ( dCos / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV2 + ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV3 ;
Vector3d vtNd = - ( dTanAlpha / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV1 + ( dCos / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV2 - ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV3 ;
Vector3d vtNs = - ( dTanAlpha / dDen) * vtV1 + ( dCos / dDen) * vtV2 + ( dSin / dDen) * vtV3 ;
Vector3d vtNd = - ( dTanAlpha / dDen) * vtV1 + ( dCos / dDen) * vtV2 - ( dSin / dDen) * vtV3 ;
Vector3d vtR0 = ptV - ORIG ;
double dDots = vtR0 * vtNs ;
double dDotd = vtR0 * vtNd ;
@@ -5392,7 +5549,11 @@ VolZmap::MillingXYPlusConus( const Point3d& ptLs, const Point3d& ptLe, const Vec
// Apertura del cono e parametri per determinare i piani
double dTan = ( dMaxRad - dMinRad) / m_dTipHeight ;
double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ;
double dCos = dTan * dRatio ; // dCos è compreso fra 0 e 1 poiché alpha è compreso fra 0 e Pi mezzi
double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ;
double dDen = sqrt( 1 + dTan * dTan) ;
double dZI = ptI.z ;
double dDeltaZ = ptF.z - ptI.z ;
@@ -5410,9 +5571,11 @@ VolZmap::MillingXYPlusConus( const Point3d& ptLs, const Point3d& ptLe, const Vec
Point3d ptrSup = ( ptPrs.z < ptPrd.z ? ptPrd : ptPrs) ;
// Versori normali e prodotti scalari per per determinare i piani
Vector3d vtNs = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 + ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTan * dTan)) * vtV3 ;
Vector3d vtNd = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 - ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTan * dTan)) * vtV3 ;
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 ;
@@ -6048,31 +6211,31 @@ VolZmap::MillCylV( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtT
double dX1 = vtC * vtV1 ; double dX2 = vtC * vtV2 ;
double dLimX1 = sqrt( dRad * dRad - dX2 * dX2) ;
if ( dX2 > - dRad && dX2 < dRad &&
dX1 > - sqrt( dRad * dRad - dX2 * dX2) &&
dX1 < dPLen + sqrt( dRad * dRad - dX2 * dX2)) {
dX1 > - dLimX1 &&
dX1 < dPLen + dLimX1) {
// Massimi
if( dX1 > - sqrt( dRad * dRad - dX2 * dX2) &&
dX1 < dPLen - sqrt( dRad * dRad - dX2 * dX2))
if( dX1 > - dLimX1 && dX1 < dPLen - dLimX1)
dMax = dZI + ( dX1 + sqrt( dRad * dRad - dX2 * dX2)) * dDeltaZ / dPLen ;
dMax = dZI + ( dX1 + dLimX1) * dDeltaZ / dPLen ;
else if ( dX1 >= dPLen - sqrt( dRad * dRad - dX2 * dX2) &&
dX1 < dPLen + sqrt( dRad * dRad - dX2 * dX2))
else if ( dX1 >= dPLen - dLimX1 &&
dX1 < dPLen + dLimX1)
dMax = dZI + dDeltaZ ;
// Minimi
if ( dX1 > - sqrt( dRad * dRad - dX2 * dX2) &&
dX1 < sqrt( dRad * dRad - dX2 * dX2))
if ( dX1 > - dLimX1 && dX1 < dLimX1)
dMin = dZI - dHei ;
else if ( dX1 >= sqrt( dRad * dRad - dX2 * dX2) &&
dX1 < dPLen + sqrt( dRad * dRad - dX2 * dX2))
else if ( dX1 >= dLimX1 &&
dX1 < dPLen + dLimX1)
dMin = dZI - dHei + ( dX1 - sqrt( dRad * dRad - dX2 * dX2)) * dDeltaZ / dPLen ;
dMin = dZI - dHei + ( dX1 - dLimX1) * dDeltaZ / dPLen ;
SubtractIntervals( i, j, dMin, dMax) ;
}
@@ -6116,13 +6279,16 @@ VolZmap::MillConusV( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& v
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 / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 + ( dSin / sqrt( 1 + dTan * dTan)) * vtV3 ;
Vector3d vtNd = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 - ( dSin / sqrt( 1 + dTan * dTan)) * vtV3 ;
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 ;
@@ -6447,7 +6613,9 @@ VolZmap::LongCyl( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtTo
if ( vtU1.LenXY() < EPS_SMALL) {
vtU1 = ( 1 + sqrt(vtCyl.x * vtCyl.x + vtCyl.y * vtCyl.y)) / sqrt(vtCyl.x * vtCyl.x + vtCyl.y * vtCyl.y) * vtU1 ;
double dLenVector = sqrt(vtCyl.x * vtCyl.x + vtCyl.y * vtCyl.y) ;
vtU1 = ( 1 + dLenVector) / dLenVector * vtU1 ;
}
vtU1.Normalize() ;
@@ -6536,8 +6704,13 @@ VolZmap::LongBall( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtT
// Definizione del sistema di riferimento nel piano
Vector3d vtU1 = vtMoveOri ;
if ( vtU1.LenXY() < EPS_SMALL)
vtU1 = ( 1 + sqrt(vtMove.x * vtMove.x + vtMove.y * vtMove.y)) / sqrt(vtMove.x * vtMove.x + vtMove.y * vtMove.y) * vtU1 ;
if ( vtU1.LenXY() < EPS_SMALL) {
double dLenVector = sqrt(vtMove.x * vtMove.x + vtMove.y * vtMove.y) ;
vtU1 = ( 1 + dLenVector) / dLenVector * vtU1 ;
}
vtU1.Normalize() ;
@@ -6566,18 +6739,20 @@ VolZmap::LongBall( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtT
double dPI1 = vtCI * vtU1 ; double dPI2 = vtCI * vtU2 ;
double dPF1 = vtCF * vtU1 ; double dPF2 = vtCF * vtU2 ;
// Massimi
if ( ( dPI1 > - dCos * sqrt( dRad * dRad - dPI2 * dPI2) &&
double dLimP1 = sqrt( dRad * dRad - dPI2 * dPI2) ;
// Dexel nella regione interessata dalla lavorazione
if ( ( dPI1 > - dCos * dLimP1 &&
dPI1 < dLOri && dPI2 * dPI2 < dRad * dRad) ||
( dPF1 * dPF1 + dPF2 * dPF2 < dRad * dRad)) {
if ( dDeltaZ > 0) {
// Massimi
if ( dPI1 < dLOri - dCos * sqrt( dRad * dRad - dPI2 * dPI2)) {
if ( dPI1 < dLOri - dCos * dLimP1) {
double dPI0 = - dCos * sqrt( dRad * dRad - dPI2 * dPI2) ;
double dZ0 = dSin * sqrt( dRad * dRad - dPI2 * dPI2) ;
double dPI0 = - dCos * dLimP1 ;
double dZ0 = dSin * dLimP1 ;
dMax = dZI + dZ0 + ( dPI1 - dPI0) * dDeltaZ / dLOri ;
}
@@ -6590,14 +6765,14 @@ VolZmap::LongBall( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtT
}
// Minimi
if ( dPI1 < dCos * sqrt( dRad * dRad - dPI2 * dPI2))
if ( dPI1 < dCos * dLimP1)
dMin = ( dDotI - dX * vtV.x - dY * vtV.y) / vtV.z ;
else if ( dPI1 < dLOri + dCos * sqrt( dRad * dRad - dPI2 * dPI2)) {
else if ( dPI1 < dLOri + dCos * dLimP1) {
double dPI0 = dCos * sqrt( dRad * dRad - dPI2 * dPI2) ;
double dZ0 = - dSin * sqrt( dRad * dRad - dPI2 * dPI2) ;
double dPI0 = dCos * dLimP1 ;
double dZ0 = - dSin * dLimP1 ;
dMin = dZI + dZ0 + ( dPI1 - dPI0) * dDeltaZ / dLOri ;
}
@@ -6612,14 +6787,14 @@ VolZmap::LongBall( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtT
else {
// Massimi
if ( dPI1 < dCos * sqrt( dRad * dRad - dPI2 * dPI2))
if ( dPI1 < dCos * dLimP1)
dMax = ( dDotI - dX * vtV.x - dY * vtV.y) / vtV.z ;
else if ( dPI1 < dLOri + dCos * sqrt( dRad * dRad - dPI2 * dPI2)) {
else if ( dPI1 < dLOri + dCos * dLimP1) {
double dPI0 = dCos * sqrt( dRad * dRad - dPI2 * dPI2) ;
double dZ0 = + dSin * sqrt( dRad * dRad - dPI2 * dPI2) ;
double dPI0 = dCos * dLimP1 ;
double dZ0 = + dSin * dLimP1 ;
dMax = dZI + dZ0 + ( dPI1 - dPI0) * dDeltaZ / dLOri ;
}
@@ -6632,10 +6807,10 @@ VolZmap::LongBall( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtT
}
// Minimi
if ( dPI1 < dLOri - dCos * sqrt( dRad * dRad - dPI2 * dPI2)) {
if ( dPI1 < dLOri - dCos * dLimP1) {
double dPI0 = - dCos * sqrt( dRad * dRad - dPI2 * dPI2) ;
double dZ0 = - dSin * sqrt( dRad * dRad - dPI2 * dPI2) ;
double dPI0 = - dCos * dLimP1 ;
double dZ0 = - dSin * dLimP1 ;
dMin = dZI + dZ0 + ( dPI1 - dPI0) * dDeltaZ / dLOri ;
}
@@ -8181,8 +8356,11 @@ VolZmap::MillConus( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vt
// Apertura del cono e parametri per determinare i piani
double dTan = dDeltaR / dHei ;
double dRatio = dLLong / dLOrt ;
double dCos = dTan * dRatio ;
double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ;
double dDen = sqrt( 1 + dTan * dTan) ;
double dCoef = dLOrt / dLLong ; // Per traslazione ellissi
if ( dRatio > 1 / dTan)
@@ -8192,8 +8370,8 @@ VolZmap::MillConus( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vt
// Versori normali e prodotti scalari per per determinare i piani
// Piani laterali:
Vector3d vtNs = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 + ( dSin / sqrt( 1 + dTan * dTan)) * vtV3 ;
Vector3d vtNd = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 - ( dSin / sqrt( 1 + dTan * dTan)) * vtV3 ;
Vector3d vtNs = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 + ( dSin / dDen) * vtV3 ;
Vector3d vtNd = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 - ( dSin / dDen) * vtV3 ;
Vector3d vtRIV = ptIV - ORIG ;
// double dDots = vtRIV * vtNs ; // forse qui è meglio due punti ptIT + vtV3 * dMinRad e ptIT - vtV3 * dMinRad
// double dDotd = vtRIV * vtNd ;
@@ -9045,8 +9223,10 @@ VolZmap::Ball( const Point3d& ptLs, const Point3d& ptLe, double dRad)
if ( dSqLen < dRad * dRad) {
dMin = dZI - sqrt( dRad * dRad - dSqLen) ;
dMax = dZI + dDeltaZ + sqrt( dRad * dRad - dSqLen) ;
double dH = sqrt( dRad * dRad - dSqLen) ;
dMin = dZI - dH ;
dMax = dZI + dDeltaZ + dH ;
SubtractIntervals( i, j, dMin, dMax) ;
}