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

EgtGeomKernel :

Browse Source 
- razionalizzazione di alcune funzioni di Zmap per taglio spilloni.
This commit is contained in:
Dario Sassi
2023-09-14 17:25:04 +02:00
parent 73a65d8cf9
commit 29c00caf4a
2 changed files with 266 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmapVolume.cpp
+265 -219
View File
@@ -18,8 +18,8 @@
#include "CurveArc.h"
#include "VolZmap.h"
#include "GeoConst.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EgtPerfCounter.h"
#include <future>
@@ -600,7 +600,15 @@ VolZmap::MillingTranslationStep( const Point3d& ptPs, const Point3d& ptPe, const
Vector3d vtLs[N_MAPS] ;
Vector3d vtALs[N_MAPS] ;
InitializePointsAndVectors( ptPs, ptPe, vtD, vtA, ptLs, ptLe, vtLs, vtALs) ;
// Ciclo sulle mappe
// Ciclo sulle mappe (scommentare solo per DEBUG)
//{
// bool bOk = true ;
// for ( int i = 0 ; i < m_nMapNum ; ++ i) {
// bOk = SelectMotion( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) && bOk ;
// }
// return true ;
//}
// Ciclo sulle mappe
vector< future<bool>> vRes ;
vRes.resize( m_nMapNum) ;
for ( int i = 0 ; i < m_nMapNum ; ++ i) {
@@ -3222,13 +3230,13 @@ VolZmap::GenTool_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, con
const ICurveLine* pLine = GetCurveLine( pCurve) ;
Point3d ptStart = pLine->GetStart() ;
Point3d ptEnd = pLine->GetEnd() ;
int nNormNum = pLine->GetTempProp();
Vector3d vtNormSt, vtNormEn;
int nNormNum = pLine->GetTempProp() ;
Vector3d vtNormSt, vtNormEn ;
if ( nNormNum != 0) {
vtNormSt = vArcNorm[nNormNum - 1] ;
vtNormEn = vArcNorm[nNormNum] ;
vtNormSt.ToLoc(frNormFrame);
vtNormEn.ToLoc(frNormFrame);
vtNormSt.ToLoc( frNormFrame) ;
vtNormEn.ToLoc( frNormFrame) ;
}
// Ne determino l'altezza
dHeight = abs( ptStart.y - ptEnd.y) ;
@@ -3258,21 +3266,21 @@ VolZmap::GenTool_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, con
if ( dRadius > 10 * EPS_SMALL)
CompCyl_Milling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius, bTapB, bTapT, CurrTool.GetToolNum()) ;
}
// Se X crescente, è un cono con vettore equiverso a quello dell'utensile
// se altrimenti X decrescente, è 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, CurrTool.GetToolNum()) ;
}
// Se X decrescente, è un cono con vettore opposto a quello dell'utensile
else if ( ptStart.x < ptEnd.x) {
// altrimenti X crescente, è un cono con vettore opposto a quello dell'utensile
else {
double dMaxRad = ptEnd.x ;
double dMinRad = ptStart.x ;
Point3d ptIn = ptI - vtToolDir * dHeight ;
Point3d ptFn = ptIn + vtMove ;
vtNormEn.z *= -1 ;
vtNormSt.z *= -1 ;
vtNormEn.z = -vtNormEn.z ;
vtNormSt.z = -vtNormSt.z ;
CompConus_Milling( nGrid, ptIn, ptFn, - vtToolDir, dHeight, dMaxRad, dMinRad,
bTapT, bTapB, vtNormEn, vtNormSt, CurrTool.GetToolNum()) ;
}
@@ -4287,7 +4295,23 @@ VolZmap::CompCyl_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE,
}
return true ;
}
//----------------------------------------------------------------------------
static Vector3d
AdjustConeNormal( const Point3d& ptInt, const Vector3d& vtN, const Point3d& ptV, const Vector3d& vtToolDir,
double dMinRad, double dDeltaR, const Vector3d& vtArcNormMinR, const Vector3d& vtArcNormMaxR)
{
if ( AreSameOrOppositeVectorEpsilon( vtN, vtToolDir, 0.1 * EPS_SMALL))
return vtN ;
Vector3d vtL = ( ptInt - ptV) - (( ptInt - ptV) * vtToolDir) * vtToolDir ;
double dL = vtL.Len() ;
vtL /= dL ;
Vector3d vtOriginalN = ( ( dDeltaR - dL + dMinRad) / dDeltaR) * vtArcNormMinR + ((dL - dMinRad) / dDeltaR) * vtArcNormMaxR ;
Vector3d vtNewN = - vtOriginalN.z * vtToolDir - vtOriginalN.x * vtL ;
vtNewN.Normalize() ;
return vtNewN ;
}
//----------------------------------------------------------------------------
bool
VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir,
@@ -4303,8 +4327,10 @@ VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
double dDeltaR = dMaxRad - dMinRad ;
// Studio simmetrie
Point3d ptI = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) ;
Point3d ptF = ( vtToolDir * ( ptE - ptS) > 0 ? ptE : ptS) ;
Point3d ptI = ptS ;
Point3d ptF = ptE ;
if ( vtToolDir * ( ptE - ptS) <= 0)
swap( ptI, ptF) ;
double dL = ( dMaxRad * dHei) / dDeltaR ;
double dl = dL - dHei ;
@@ -4366,7 +4392,8 @@ VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
Point3d ptFacet135( 0, 0, dLenZ) ;
Point3d ptFacet246( dLenX + dDeltaX, dLenY + dDeltaY, - dLenZ - dDeltaZ) ;
Vector3d vtUmv = vtMove ; vtUmv.Normalize() ;
// Necessità ricalcolo normali (perchè variabili per approx curve)
bool bRecalNorm = ( ! vtArcNormMaxR.IsSmall() && ! vtArcNormMinR.IsSmall()) ;
if ( dRatio * dTan <= 1) {
@@ -4381,27 +4408,9 @@ VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
// Cono iniziale
ConusFrame.ChangeOrig( ptV) ;
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, bTapB, bTapT, 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() ;
}
if ( bRecalNorm) {
vtN1 = AdjustConeNormal( ptInt1, vtN1, ptV, vtToolDir, dMinRad, dDeltaR, vtArcNormMinR, vtArcNormMaxR) ;
vtN2 = AdjustConeNormal( ptInt2, vtN2, ptV, vtToolDir, dMinRad, dDeltaR, vtArcNormMinR, vtArcNormMaxR) ;
}
SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
}
@@ -4409,191 +4418,246 @@ VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
// Cono finale
ConusFrame.ChangeOrig( ptV + vtMove) ;
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, bTapB, bTapT, 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() ;
}
if ( bRecalNorm) {
vtN1 = AdjustConeNormal( ptInt1, vtN1, ptV + vtMove, vtToolDir, dMinRad, dDeltaR, vtArcNormMinR, vtArcNormMaxR) ;
vtN2 = AdjustConeNormal( ptInt2, vtN2, ptV + vtMove, vtToolDir, dMinRad, dDeltaR, vtArcNormMinR, vtArcNormMaxR) ;
}
SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
}
// Solido interno
Point3d ptPoly = ptC ;
Vector3d vtPoly = Z_AX ;
Point3d ptPoly = GetToLoc( ptC, PolyFrame) ;
Vector3d vtPoly = GetToLoc( Z_AX, PolyFrame) ;
ptPoly.ToLoc( PolyFrame) ;
vtPoly.ToLoc( PolyFrame) ;
// Intervallo di intersezione (infinito) e normali (nulle)
bool bValid = true ;
double dPar1 = -INFINITO ;
double dPar2 = +INFINITO ;
vtN1 = V_NULL ;
vtN2 = V_NULL ;
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() ;
// Verifica con facce iniziale e finale
if ( bValid) {
// Distanza con segno del punto di riferimento del dexel dal piano delle facce iniziale e finale
double dDistI = ( ptPoly - ptFacet135) * -vtIF ;
double dDistF = ( ptPoly - ptFacet246) * vtIF ;
// Se dexel non parallelo alle facce
if ( abs( vtPoly * vtIF) > COS_ORTO_ANG_ZERO) {
// posizione parametrica delle intersezioni
double dParI = -dDistI / ( vtPoly * -vtIF) ;
double dParF = -dDistF / ( vtPoly * vtIF) ;
// se intervallo tra intersezioni praticamente nullo
if ( abs( dParI - dParF) < EPS_ZERO)
bValid = false ;
// altrimenti
else {
if ( dParI < dParF) {
dPar1 = dParI ;
vtN1 = vtIF ;
dPar2 = dParF ;
vtN2 = -vtIF ;
}
else {
dPar1 = dParF ;
vtN1 = -vtIF ;
dPar2 = dParI ;
vtN2 = vtIF ;
}
}
++ nIntNum ;
}
// altrimenti praticamente parallelo
else {
// se esterno ad almeno uno invalida tutto
if ( dDistI > 0 || dDistF > 0)
bValid = false ;
// altrimenti non cambia niente
}
}
// 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) ;
// Verifica con facce sopra e sotto
if ( bValid) {
// Distanza con segno del punto di riferimento del dexel dal piano delle facce sopra e sotto
double dDistU = ( ptPoly - ptFacet246) * -vtUD ;
double dDistD = ( ptPoly - ptFacet135) * vtUD ;
// Se dexel non parallelo alle facce
if ( abs( vtPoly * vtUD) > COS_ORTO_ANG_ZERO) {
// posizione parametrica delle intersezioni
double dParU = -dDistU / ( vtPoly * -vtUD) ;
double dParD = -dDistD / ( vtPoly * vtUD) ;
// se intervallo tra intersezioni praticamente nullo
if ( abs( dParU - dParD) < EPS_ZERO)
bValid = false ;
// altrimenti
else {
if ( dParU < dParD) {
if ( dParD < dPar1 + EPS_ZERO || dParU > dPar2 - EPS_ZERO)
bValid = false ;
else {
if ( dParU > dPar1) {
dPar1 = dParU ;
vtN1 = vtUD ;
}
if ( dParD < dPar2) {
dPar2 = dParD ;
vtN2 = -vtUD ;
}
}
}
else {
if ( dParU < dPar1 + EPS_ZERO || dParD > dPar2 - EPS_ZERO)
bValid = false ;
else {
if ( dParD > dPar1) {
dPar1 = dParD ;
vtN1 = -vtUD ;
}
if ( dParU < dPar2) {
dPar2 = dParU ;
vtN2 = vtUD ;
}
}
}
}
}
// altrimenti praticamente parallelo
else {
// se esterno ad almeno uno invalida tutto
if ( dDistU > 0 || dDistD > 0)
bValid = false ;
// altrimenti non cambia niente
}
}
// Taglio con la faccia sinistra
if ( bValid) {
// Distanza con segno del punto di riferimento del dexel dal piano della faccia sinistra
double dDistS = ( ptPoly - ptFacet135) * vtNs ;
// Se dexel non parallelo alla faccia
if ( abs( vtPoly * vtNs) > COS_ORTO_ANG_ZERO) {
// posizione parametrica della intersezione
double dParS = -dDistS / ( vtPoly * vtNs) ;
// verifico limitazioni su inizio e fine dell'intervallo
int nLimit = 0 ;
// se limita inizio
if ( vtPoly * vtNs < 0) {
// se oltre la fine, invalida tutto
if ( dParS > dPar2 - EPS_ZERO)
bValid = false ;
// se altrimenti solo oltre inizio, riduce
else if ( dParS >= dPar1) {
dPar1 = dParS ;
nLimit = 1 ;
}
}
// altrimenti limita fine
else {
// se prima dell'inizio, invalida tutto
if ( dParS < dPar1 + EPS_ZERO)
bValid = false ;
// se altrimenti solo prima della fine, riduce
else if ( dParS <= dPar2) {
dPar2 = dParS ;
nLimit = 2 ;
}
}
// se limita, devo aggiornare la normale
if ( nLimit != 0) {
Vector3d vtNewN = -vtNs ;
if ( bRecalNorm) {
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() ;
Point3d ptInt = ptPoly + dParS * vtPoly ;
vtNewN = ( ( dDeltaZ - ptInt.z + dLenZ) / dDeltaZ) * vtOrigMinR + ( ( ptInt.z - dLenZ) / dDeltaZ) * vtOrigMaxR ;
vtNewN.Normalize() ;
}
++ nIntNum ;
}
else if ( ( ptInt1 - ptPoly2).SqLen() > SQ_EPS_SMALL) {
ptInt2 = ptPoly2 ;
vtN2 = - vtNd ;
if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) {
if ( nLimit == 1)
vtN1 = vtNewN ;
else
vtN2 = vtNewN ;
}
}
// altrimenti praticamente parallelo
else {
// se esterno invalida tutto
if ( dDistS > 0)
bValid = false ;
// altrimenti non cambia niente
}
}
// Taglio con la faccia destra
if ( bValid) {
// Distanza con segno del punto di riferimento del dexel dal piano della faccia destra
double dDistD = ( ptPoly - ptFacet246) * vtNd ;
// Se dexel non parallelo alla faccia
if ( abs( vtPoly * vtNd) > COS_ORTO_ANG_ZERO) {
// posizione parametrica della intersezione
double dParD = -dDistD / ( vtPoly * vtNd) ;
// verifico limitazioni su inizio e fine dell'intervallo
int nLimit = 0 ;
// se limita inizio
if ( vtPoly * vtNd < 0) {
// se oltre la fine, invalida tutto
if ( dParD > dPar2 - EPS_ZERO)
bValid = false ;
// se altrimenti solo oltre inizio, riduce
else if ( dParD >= dPar1) {
dPar1 = dParD ;
nLimit = 1 ;
}
}
// altrimenti limita fine
else {
// se prima dell'inizio, invalida tutto
if ( dParD < dPar1 + EPS_ZERO)
bValid = false ;
// se altrimenti solo prima della fine, riduce
else if ( dParD <= dPar2) {
dPar2 = dParD ;
nLimit = 2 ;
}
}
// se limita, devo aggiornare la normale
if ( nLimit != 0) {
Vector3d vtNewN = -vtNd ;
if ( bRecalNorm) {
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 ;
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() ;
Point3d ptInt = ptPoly + dParD * vtPoly ;
vtNewN = ( ( dDeltaZ - abs( ptInt.z) + dLenZ) / dDeltaZ) * vtOrigMinR + ( ( abs( ptInt.z) - dLenZ) / dDeltaZ) * vtOrigMaxR ;
vtNewN.Normalize() ;
}
++ nIntNum ;
if ( nLimit == 1)
vtN1 = vtNewN ;
else
vtN2 = vtNewN ;
}
}
}
// 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 ;
}
// altrimenti praticamente parallelo
else {
// se esterno invalida tutto
if ( dDistD > 0)
bValid = false ;
// altrimenti non cambia niente
}
}
// 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) ;
// Se rimasto qualcosa lo sottraggo al dexel
if ( bValid) {
// Punti di intersezione e normali nel sistema griglia
ptInt1 = ptC + dPar1 * Z_AX ;
vtN1.ToGlob( PolyFrame) ;
ptInt2.ToGlob( PolyFrame) ;
ptInt2 = ptC + dPar2 * Z_AX ;
vtN2.ToGlob( PolyFrame) ;
// Eseguo sottrazione
SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
}
@@ -4631,27 +4695,9 @@ VolZmap::CompConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
// Cono
ConusFrame.ChangeOrig( ptV) ;
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, bTapB, 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() ;
}
if ( bRecalNorm) {
vtN1 = AdjustConeNormal( ptInt1, vtN1, ptV, vtToolDir, dMinRad, dDeltaR, vtArcNormMinR, vtArcNormMaxR) ;
vtN2 = AdjustConeNormal( ptInt2, vtN2, ptV, vtToolDir, dMinRad, dDeltaR, vtArcNormMinR, vtArcNormMaxR) ;
}
SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
}
@@ -4876,7 +4922,7 @@ VolZmap::TestCompoBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, con
// I punti e i vettori devono essere nel sistema di riferimento opportuno
// Controllo sull'ammissibilità del numero di griglia
if ( nGrid < 0 || nGrid > 2)
if ( nGrid < 0 || nGrid > 2)
return false ;
// BBox dello Zmap
@@ -4939,10 +4985,10 @@ VolZmap::TestParaBBox( int nGrid, const Point3d& ptS, const Point3d& ptE, const
return false ;
// Limiti su indici
nStI = ( dMinX < EPS_SMALL ? 0 : static_cast<int> ( dMinX / m_dStep)) ;
nEnI = ( dMaxX > dMaxXValue - EPS_SMALL ? nMaxNx - 1 : static_cast<int> ( dMaxX / m_dStep)) ;
nStJ = ( dMinY < EPS_SMALL ? 0 : static_cast<int> ( dMinY / m_dStep)) ;
nEnJ = ( dMaxY > dMaxYValue - EPS_SMALL ? nMaxNy - 1 : static_cast<int> ( dMaxY / m_dStep)) ;
nStI = ( dMinX < EPS_SMALL ? 0 : int( dMinX / m_dStep)) ;
nEnI = ( dMaxX > dMaxXValue - EPS_SMALL ? nMaxNx - 1 : int( dMaxX / m_dStep)) ;
nStJ = ( dMinY < EPS_SMALL ? 0 : int( dMinY / m_dStep)) ;
nEnJ = ( dMaxY > dMaxYValue - EPS_SMALL ? nMaxNy - 1 : int ( dMaxY / m_dStep)) ;
return true ;
}