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

EgtGeomKernel :

Browse Source 
- in Zmap aggiunta AvoidSphere
- aggiunta funzione IntersLineSphere
- migliorie a visualizzazione Zmap.
This commit is contained in:
Dario Sassi
2018-02-05 07:14:03 +00:00
parent fdef0bb7a3
commit 5649e228a0
8 changed files with 177 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtGeomKernel.vcxproj
+3
View File
@@ -268,6 +268,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClCompile Include="CurveByInterp.cpp" />
<ClCompile Include="CurveCompositeOffset.cpp" />
<ClCompile Include="DistPointTria.cpp" />
<ClCompile Include="IntersLineSphere.cpp" />
<ClCompile Include="IntersPlanePlane.cpp" />
<ClCompile Include="IntersPlaneSurfTm.cpp" />
<ClCompile Include="IntersPlaneTria.cpp" />
@@ -414,6 +415,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClInclude Include="..\Include\EGkGeoVector3d.h" />
<ClInclude Include="..\Include\EGkIntersCurves.h" />
<ClInclude Include="..\Include\EGkIntersLinePlane.h" />
<ClInclude Include="..\Include\EGkIntersLineSphere.h" />
<ClInclude Include="..\Include\EGkIntersLineSurfTm.h" />
<ClInclude Include="..\Include\EGkIntersLineTria.h" />
<ClInclude Include="..\Include\EGkIntersPlanePlane.h" />
@@ -502,6 +504,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClInclude Include="IntersLineArc.h" />
<ClInclude Include="IntersLineLine.h" />
<ClInclude Include="IntersLineSurfTm.h" />
<ClInclude Include="IntersLineTria.h" />
<ClInclude Include="IterManager.h" />
<ClInclude Include="Material.h" />
<ClInclude Include="FontNfe.h" />
EgtGeomKernel.vcxproj.filters
+9
View File
@@ -372,6 +372,9 @@
<ClCompile Include="Tool.cpp">
<Filter>File di origine\Base</Filter>
</ClCompile>
<ClCompile Include="IntersLineSphere.cpp">
<Filter>File di origine\GeoInters</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="stdafx.h">
@@ -845,6 +848,12 @@
<ClInclude Include="Tool.h">
<Filter>File di intestazione</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGkIntersLineSphere.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="IntersLineTria.h">
<Filter>File di intestazione</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="EgtGeomKernel.rc">
IdManager.h
+1 -1
View File
@@ -21,7 +21,7 @@ class IdManager
{
public :
IdManager( void)
{ m_nMaxId = 0 ; }
: m_nMaxId( 0) {}
bool Init( int nBuckets)
{ m_GdbIdMap.rehash( nBuckets) ; return true ; }
bool Clear( void)
IntersLineSphere.cpp
+45
View File
@@ -0,0 +1,45 @@
//----------------------------------------------------------------------------
// EgalTech 2018-2018
//----------------------------------------------------------------------------
// File : IntersLineSphere.cpp Data : 04.02.18 Versione : 1.9b1
// Contenuto : Implementazione della intersezione linea/sfera.
//
//
//
// Modifiche : 04.02.18 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "/EgtDev/Include/EGkIntersLineSphere.h"
//----------------------------------------------------------------------------
int
IntersLineSphere( const Point3d& ptL, const Vector3d& vtL, const Point3d& ptCen, double dRad,
Point3d& ptI1, Point3d& ptI2)
{
// Verifiche su versore linea
Vector3d vtDir = vtL ;
if ( ! vtDir.Normalize( EPS_ZERO))
return ILST_NO ;
// Proiezione del centro della sfera sulla linea
Point3d ptP = ptL + (( ptCen - ptL) * vtL) * vtL ;
// Distanza di questo punto di proiezione dal centro della sfera
double dDist = Dist( ptCen, ptP) ;
// Se distanza uguale al raggio, intersezione tangente
if ( abs( dDist - dRad) < EPS_SMALL) {
ptI1 = ptP ;
ptI2 = ptP ;
return ILST_TG ;
}
// Se distanza superiore al raggio, nessuna intersezione
if ( dDist > dRad)
return ILST_NO ;
// Distanza inferiore al raggio, due intersezioni secanti
double dDist2 = sqrt( dRad * dRad - dDist * dDist) ;
ptI1 = ptP - dDist2 * vtL ;
ptI2 = ptP + dDist2 * vtL ;
return ILST_SEC ;
}
IntersLineTria.cpp
+1 -1
View File
@@ -17,8 +17,8 @@
#include "CurveLine.h"
#include "IntersLineLine.h"
#include "IntersLineTria.h"
#include "/EgtDev/Include/EGkFrame3d.h"
#include "/EgtDev/Include/EGkIntersLinePlane.h"
#include "/EgtDev/Include/EGkFrame3d.h"
#include <array>
using namespace std ;
VolZmap.h
+8 -11
View File
@@ -112,6 +112,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW
bool GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtDir, double& dInLength, double& dOutLength, bool bEnh) const ;
bool GetPlaneIntersection( const Plane3d& plPlane, POCRVVECTOR& vpLoop) const override ;
bool AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag) const override ;
bool AvoidSphere( const Point3d& ptCenter, double dRad) const override ;
bool AvoidCylinder( const Frame3d& frCyl, double dL, double dR) const override ;
VolZmap* ClonePart( int nPart) const override ;
bool RemovePart( int nPart) override ;
@@ -265,23 +267,18 @@ class VolZmap : public IVolZmap, public IGeoObjRW
bool IntersRayDexel( const Point3d& ptP, const Vector3d& vtV, unsigned int nGrid, unsigned int nI, unsigned int nJ,
double& dU1, double& dU2) const ;
bool IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
const Frame3d& CylFrame, double dL, double dR,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2,
bool bTapO, bool bTapL) ;
const Frame3d& CylFrame, double dL, double dR, bool bTapO, bool bTapL,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2) ;
bool IntersZLineCylinder( const Point3d& ptLine,
const Point3d& ptBase, const Point3d& ptTop, double dCylR,
double& dInfZ, double& dSupZ) ;
bool IntersLineEllipticalCylinder( const Vector3d& vtLineDir, const Point3d& ptLineSt,
const Frame3d& CircFrame, double dSqRad, double dLongMvLen, double dOrtMvLen,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2,
bool bTapLow, bool bTapUp) ;
bool bTapLow, bool bTapUp,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2) ;
bool IntersLineConus( const Point3d& ptLineSt, const Vector3d& vtLineDir,
const Frame3d& ConusFrame, double dTan, double dl, double dL,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2,
bool bTapLow, bool bTapUp) ;
bool IntersLineSphere( const Point3d& ptLineSt, const Vector3d& vtLineDir,
const Point3d& ptCenter, double dRad,
Point3d& ptInt1, Point3d& ptInt2) ;
const Frame3d& ConusFrame, double dTan, double dl, double dL, bool bTapLow, bool bTapUp,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2) ;
bool IntersLineMyPolyhedron( const Point3d& ptLineSt, const Vector3d& vtLineDir,
const Frame3d& PolyFrame, double dLenX, double dLenY, double dLenZ, double dDeltaX,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2) ;
VolZmapCalculus.cpp
+94 -29
View File
@@ -20,6 +20,7 @@
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EGkIntersLineTria.h"
#include "/EgtDev/Include/EGkIntersLinePlane.h"
#include "/EgtDev/Include/EGkIntersLineSphere.h"
#include "/EgtDev/Include/EGkChainCurves.h"
using namespace std ;
@@ -595,18 +596,20 @@ VolZmap::AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag) const
int nSize = int( m_Values[0][nPos].size()) ;
if ( nSize == 0)
continue ;
for ( int k = 0 ; k < 4 ; ++ k) {
Point3d ptC = ptO + i * m_dStep * vtX + j * m_dStep * vtY ;
for ( int k = 0 ; k < 5 ; ++ k) {
Point3d ptT = ptO + ( i + 0.5) * m_dStep * vtX + ( j + 0.5) * m_dStep * vtY ;
if ( k == 0)
ptC += 0.1 * m_dStep * vtX + 0.1 * m_dStep * vtY ;
;
else if ( k == 1)
ptC += 0.9 * m_dStep * vtX + 0.1 * m_dStep * vtY ;
ptT += - 0.4 * m_dStep * vtX - 0.4 * m_dStep * vtY ;
else if ( k == 2)
ptC += 0.9 * m_dStep * vtX + 0.9 * m_dStep * vtY ;
ptT += + 0.4 * m_dStep * vtX - 0.4 * m_dStep * vtY ;
else if ( k == 3)
ptC += 0.1 * m_dStep * vtX + 0.9 * m_dStep * vtY ;
ptT += + 0.4 * m_dStep * vtX + 0.4 * m_dStep * vtY ;
else if ( k == 4)
ptT += - 0.4 * m_dStep * vtX + 0.4 * m_dStep * vtY ;
double dZmin, dZmax ;
if ( IntersLineBox( ptC, vtK, ORIG, ORIG + vtDiag, dZmin, dZmax)) {
if ( IntersLineBox( ptT, vtK, ORIG, ORIG + vtDiag, dZmin, dZmax)) {
for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 1) {
if ( ! ( dZmax < m_Values[0][nPos][nIndex].dMin - EPS_SMALL ||
dZmin > m_Values[0][nPos][nIndex].dMax + EPS_SMALL))
@@ -620,18 +623,85 @@ VolZmap::AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag) const
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::AvoidSphere( const Point3d& ptCenter, double dRad) const
{
// Porto la sfera nel riferimento intrinseco dello Zmap
Point3d ptC = ptCenter ;
ptC.ToLoc( m_MapFrame) ;
// BBox della sfera
BBox3d b3Box( ptC) ;
b3Box.Expand( dRad) ;
// BBox dello Zmap nel suo riferimento intrinseco
BBox3d b3Zmap( ORIG, Point3d( m_nNx[0] * m_dStep, m_nNy[0] * m_dStep, m_dMaxZ[0])) ;
// Se non interferiscono, posso uscire
BBox3d b3Int ;
if ( ! b3Zmap.FindIntersection( b3Box, b3Int))
return true ;
// Limiti su indici
int nStI = Clamp( int( b3Int.GetMin().x / m_dStep), 0, m_nNx[0] -1) ;
int nEnI = Clamp( int( b3Int.GetMax().x / m_dStep), 0, m_nNx[0] -1) ;
int nStJ = Clamp( int( b3Int.GetMin().y / m_dStep), 0, m_nNy[0] -1) ;
int nEnJ = Clamp( int( b3Int.GetMax().y / m_dStep), 0, m_nNy[0] -1) ;
// Ciclo di intersezione dei dexel con la sfera (nel riferimento intrinseco)
for ( int i = nStI ; i <= nEnI ; ++ i) {
for ( int j = nStJ ; j <= nEnJ ; ++ j) {
int nPos = j * m_nNx[0] + i ;
int nSize = int( m_Values[0][nPos].size()) ;
if ( nSize == 0)
continue ;
for ( int k = 0 ; k < 5 ; ++ k) {
Point3d ptT = ORIG + ( i + 0.5) * m_dStep * X_AX + ( j + 0.5) * m_dStep * Y_AX ;
if ( k == 0)
;
else if ( k == 1)
ptT += - 0.4 * m_dStep * X_AX - 0.4 * m_dStep * Y_AX ;
else if ( k == 2)
ptT += + 0.4 * m_dStep * X_AX - 0.4 * m_dStep * Y_AX ;
else if ( k == 3)
ptT += + 0.4 * m_dStep * X_AX + 0.4 * m_dStep * Y_AX ;
else if ( k == 4)
ptT += - 0.4 * m_dStep * X_AX + 0.4 * m_dStep * Y_AX ;
Point3d ptI1, ptI2 ;
if ( IntersLineSphere( ptT, Z_AX, ptC, dRad, ptI1, ptI2) != ILST_NO) {
double dZmin = ptI1.z ;
double dZmax = ptI2.z ;
for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 1) {
if ( ! ( dZmax < m_Values[0][nPos][nIndex].dMin - EPS_SMALL ||
dZmin > m_Values[0][nPos][nIndex].dMax + EPS_SMALL))
return false ;
}
}
}
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::AvoidCylinder( const Frame3d& frCyl, double dL, double dR) const
{
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
const Frame3d& CylFrame, double dL, double dR,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2,
bool bTapO, bool bTapL)
const Frame3d& CylFrame, double dL, double dR, bool bTapO, bool bTapL,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2)
{
// NB: L'origine del sistema di riferimento deve essere
// nel centro della circonferenza di base e l'asse di simmetria
// deve coincidere con l'asse x.
// La funzione restituisce true in caso di intersezione,
// false altrimenti.
// NB: L'origine del sistema di riferimento è nel centro della circonferenza di base
// e l'asse di simmetria coincide con l'asse x.
// La funzione restituisce true in caso di intersezione, false altrimenti.
Point3d ptP = ptLineSt ;
Vector3d vtV = vtLineDir ;
@@ -755,8 +825,7 @@ VolZmap::IntersZLineCylinder( const Point3d& ptLine,
double& dInfZ, double& dSupZ)
{
// NB: Le coordinate sono espresse nel sistema griglia
// La funzione restituisce true in caso di intersezione,
// false altrimenti.
// La funzione restituisce true in caso di intersezione, false altrimenti.
double dSqRad = dCylR * dCylR ;
@@ -857,15 +926,12 @@ VolZmap::IntersZLineCylinder( const Point3d& ptLine,
//----------------------------------------------------------------------------
bool
VolZmap::IntersLineConus( const Point3d& ptLineSt, const Vector3d& vtLineDir,
const Frame3d& ConusFrame, double dTan, double dl, double dL,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2,
bool bTapLow, bool bTapUp)
const Frame3d& ConusFrame, double dTan, double dl, double dL, bool bTapLow, bool bTapUp,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2)
{
// NB: L'origine del sistema di riferimento deve essere
// nel vertice del cono e l'asse di simmetria deve coincidere
// con l'asse x.
// La funzione restituisce true in caso di intersezione,
// false altrimenti.
// nel vertice del cono e l'asse di simmetria deve coincidere con l'asse x.
// La funzione restituisce true in caso di intersezione, false altrimenti.
Point3d ptP = ptLineSt ;
Vector3d vtV = vtLineDir ;
@@ -1062,15 +1128,14 @@ VolZmap::IntersLineConus( const Point3d& ptLineSt, const Vector3d& vtLineDir,
bool
VolZmap::IntersLineEllipticalCylinder( const Vector3d& vtLineDir, const Point3d& ptLineSt,
const Frame3d& CircFrame, double dSqRad, double dLongMvLen, double dOrtMvLen,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2,
bool bTapLow, bool bTapUp)
bool bTapLow, bool bTapUp,
Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2)
{
// NB: L'origine del sistema di riferimento deve essere
// nel centro della circonferenza di base, la cui tralsazione obliqua
// nel centro della circonferenza di base, la cui traslazione obliqua
// genera il cilindro ellittico, e l'asse x deve essere l'asse
// di simmetria di tale circonferenza.
// La funzione restituisce true in caso di intersezione,
// false altrimenti.
// La funzione restituisce true in caso di intersezione, false altrimenti.
// NB: dSqRad è il quadrato del raggio della circonferenza la cui
// traslazione obliqua genera il cilindro ellittico, dLongMvLen e
// dOrtMvLen sono rispettivamente le lunghezze delle proiezioni del
VolZmapVolume.cpp
+16 -16
View File
@@ -3940,7 +3940,7 @@ VolZmap::CompCyl_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d
Point3d ptInt1, ptInt2 ;
Vector3d vtN1, vtN2 ;
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dLen, dRad, ptInt1, ptInt2,vtN1, vtN2, bTapB, bTapT)) {
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dLen, dRad, bTapB, bTapT, ptInt1, ptInt2,vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z ;
@@ -4018,8 +4018,8 @@ VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d & ptS, const Poin
Vector3d vtN1, vtN2 ;
// Cilindro
if ( IntersLineCylinder( ptC - vtV1 * dL, Z_AX, ConusFrame, dLen, dMaxRad,
ptInt1, ptInt2, vtN1, vtN2, true, bTapCylEn)) {
if ( IntersLineCylinder( ptC - vtV1 * dL, Z_AX, ConusFrame, dLen, dMaxRad, true, bTapCylEn,
ptInt1, ptInt2, vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z + vtV1.z * dL ;
dMax = ptInt2.z + vtV1.z * dL ;
@@ -4037,8 +4037,8 @@ VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d & ptS, const Poin
}
// Cono
if ( IntersLineConus( ptC , Z_AX, ConusFrame, dTan, dl, dL,
ptInt1, ptInt2, vtN1, vtN2, bTapT, true)) {
if ( IntersLineConus( ptC , Z_AX, ConusFrame, dTan, dl, dL, bTapT, true,
ptInt1, ptInt2, vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z /*+ vtV1.z * dL*/ ;
dMax = ptInt2.z /*+ vtV1.z * dL*/ ;
@@ -4175,7 +4175,7 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
Vector3d vtN1, vtN2 ;
// Cilindro iniziale
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, ptInt1, ptInt2, vtN1, vtN2, bCylSt, bCylEn)) {
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, bCylSt, bCylEn, ptInt1, ptInt2, vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z ;
dMax = ptInt2.z ;
@@ -4195,7 +4195,7 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
// Cilindro finale:L'unica differenza rispetto a prima è l'origine
// del sistema di riferimento, quindi usiamo lo stesso sistema sommando a ptC
// il vettore che congiunge le due origini.
if ( IntersLineCylinder( ptC - vtMove, Z_AX, CylFrame, dHei, dRad, ptInt1, ptInt2, vtN1, vtN2, bCylSt, bCylEn)) {
if ( IntersLineCylinder( ptC - vtMove, Z_AX, CylFrame, dHei, dRad, bCylSt, bCylEn, ptInt1, ptInt2, vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z + vtMove.z ;
dMax = ptInt2.z + vtMove.z ;
@@ -4232,7 +4232,7 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
// Cilindro ellittico di punta
if ( IntersLineEllipticalCylinder( Z_AX, ptC, CylFrame, dSqRad,
dLongLen, dOrtLen, ptInt1, ptInt2, vtN1, vtN2, bElpsT, bElpsT)) {
dLongLen, dOrtLen, bElpsT, bElpsT, ptInt1, ptInt2, vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z ;
dMax = ptInt2.z ;
@@ -4253,7 +4253,7 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
// del sistema di riferimento, quindi usiamo lo stesso sistema sommando a ptC
// il vettore che congiunge le due origini.
if ( IntersLineEllipticalCylinder( Z_AX, ptC - dHei * vtV1, CylFrame, dSqRad,
dLongLen, dOrtLen, ptInt1, ptInt2, vtN1, vtN2, bElpsB, bElpsB)) {
dLongLen, dOrtLen, bElpsB, bElpsB, ptInt1, ptInt2, vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z + dHei * vtV1.z ;
dMax = ptInt2.z + dHei * vtV1.z ;
@@ -4391,7 +4391,7 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
Vector3d vtN1, vtN2 ;
// Cono iniziale
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, ptInt1, ptInt2, vtN1, vtN2, bConeT, bConeB)) {
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, bConeT, bConeB, ptInt1, ptInt2, vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z ;
@@ -4410,7 +4410,7 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
}
// Cono finale
if ( IntersLineConus( ptC - vtMove, Z_AX, ConusFrame, dTan, dl, dL, ptInt1, ptInt2, vtN1, vtN2, bConeT, bConeB)) {
if ( IntersLineConus( ptC - vtMove, Z_AX, ConusFrame, dTan, dl, dL, bConeT, bConeB, ptInt1, ptInt2, vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z + vtMove.z ;
@@ -4577,7 +4577,7 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
// Traslazione ellisse di punta
if ( IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dl, ConusFrame, dSqMinRad,
dLongLen, dOrtLen, ptInt1, ptInt2, vtN1, vtN2, bElpsT, bElpsT)) {
dLongLen, dOrtLen, bElpsT, bElpsT, ptInt1, ptInt2, vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z + vtV1.z * dl ;
dMax = ptInt2.z + vtV1.z * dl ;
@@ -4596,7 +4596,7 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
// Traslazione ellisse di base
if ( IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dL, ConusFrame, dSqMaxRad,
dLongLen, dOrtLen, ptInt1, ptInt2, vtN1, vtN2, bElpsB, bElpsB)) {
dLongLen, dOrtLen, bElpsB, bElpsB, ptInt1, ptInt2, vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z + vtV1.z * dL ;
dMax = ptInt2.z + vtV1.z * dL ;
@@ -4630,7 +4630,7 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
Vector3d vtN1, vtN2 ;
// Cono
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, ptInt1, ptInt2, vtN1, vtN2, bConeT, bConeB)) {
if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, bConeT, bConeB, ptInt1, ptInt2, vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z ;
dMax = ptInt2.z ;
@@ -4649,7 +4649,7 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
// Traslazione ellisse
if ( IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dL, ConusFrame, dSqMaxRad,
dLongLen, dOrtLen, ptInt1, ptInt2, vtN1, vtN2, bConeB, bConeB)) {
dLongLen, dOrtLen, bConeB, bConeB, ptInt1, ptInt2, vtN1, vtN2)) {
if( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z + vtV1.z * dL ;
dMax = ptInt2.z + vtV1.z * dL ;
@@ -4897,7 +4897,7 @@ VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d & ptLs, const Point
Vector3d vtN1, vtN2 ;
// Cilindro
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dLengthPath, dRad, ptInt1, ptInt2, vtN1, vtN2, false, false)) {
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dLengthPath, dRad, false, false, ptInt1, ptInt2, vtN1, vtN2)) {
if ( ptInt1.z < ptInt2.z) {
dMin = ptInt1.z ;
dMax = ptInt2.z ;