EgtGeomKernel :
- in Zmap aggiunta gestione movimenti utensili a 5 assi.
This commit is contained in:
Dario Sassi
+290
-243
@@ -1,7 +1,7 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2015-2019
|
||||
// EgalTech 2015-2020
|
||||
//----------------------------------------------------------------------------
|
||||
// File : VolZmap.cpp Data : 01.03.19 Versione : 2.1c1
|
||||
// File : VolZmap.cpp Data : 05.10.20 Versione : 2.2j1
|
||||
// Contenuto : Implementazione della classe Volume Zmap (tre griglie)
|
||||
//
|
||||
//
|
||||
@@ -480,14 +480,16 @@ VolZmap::AddIntervals( int nGrid, int nI, int nJ,
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Point3d& ptPe, const Vector3d& vtDe)
|
||||
VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs,
|
||||
const Point3d& ptPe, const Vector3d& vtDe)
|
||||
{
|
||||
return MillingStep( ptPs, vtDs, Vector3d(), ptPe, vtDe, Vector3d()) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs, const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe)
|
||||
VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
|
||||
const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe)
|
||||
{
|
||||
// Se non è definito l'utensile, non devo fare alcunchè
|
||||
if ( m_Tool.GetType() == Tool::UNDEF)
|
||||
@@ -503,278 +505,323 @@ VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d&
|
||||
if ( vtAs.IsSmall() || vtAe.IsSmall())
|
||||
return false ;
|
||||
}
|
||||
// Reset numero di parti
|
||||
m_nConnectedCompoCount = - 1 ;
|
||||
|
||||
// Punti nei sistemi di riferimento intrinseci dello Zmap
|
||||
// Punti e vettori descriventi il moto nel sistema intrinseco dello Zmap
|
||||
Point3d ptPLs = ptPs ;
|
||||
ptPLs.ToLoc( m_MapFrame) ;
|
||||
Point3d ptPLe = ptPe ;
|
||||
ptPLe.ToLoc( m_MapFrame) ;
|
||||
Vector3d vtDLs = vtDs ;
|
||||
vtDLs.ToLoc( m_MapFrame) ;
|
||||
vtDLs.Normalize() ;
|
||||
Vector3d vtDLe = vtDe ;
|
||||
vtDLe.ToLoc( m_MapFrame) ;
|
||||
vtDLe.Normalize() ;
|
||||
Vector3d vtALs = vtAs ;
|
||||
vtALs.ToLoc( m_MapFrame) ;
|
||||
vtALs.Normalize() ;
|
||||
Vector3d vtALe = vtAe ;
|
||||
vtALe.ToLoc( m_MapFrame) ;
|
||||
vtALe.Normalize() ;
|
||||
|
||||
// Se pura traslazione
|
||||
if ( AreSameVectorApprox( vtDLs, vtDLe))
|
||||
return MillingTranslationStep( ptPLs, ptPLe, vtDLs, vtALs) ;
|
||||
else
|
||||
return MillingGeneralMotionStep( ptPLs, vtDLs, vtALs, ptPLe, vtDLe, vtALe) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
|
||||
const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe)
|
||||
{
|
||||
// Ciclo sulle mappe
|
||||
double dAngDeg ;
|
||||
vtDs.GetAngle( vtDe, dAngDeg) ;
|
||||
int nNumSubStep = int( abs( dAngDeg) / 0.5) ;
|
||||
Vector3d vtMove = ptPe - ptPs ;
|
||||
double dLenPath = vtMove.Len() ;
|
||||
double dDeltaLen = dLenPath / nNumSubStep ;
|
||||
vtMove /= dLenPath ;
|
||||
bool bSuccessful = true ;
|
||||
for ( int n = 0 ; n < nNumSubStep + 1 && bSuccessful ; ++ n) {
|
||||
double dPathSt = 0 ;
|
||||
double dPathEn = 0.5 * dDeltaLen ;
|
||||
if ( n == nNumSubStep) {
|
||||
dPathSt = ( n - 0.5) * dDeltaLen ;
|
||||
dPathEn = n * dDeltaLen ;
|
||||
}
|
||||
else if ( n > 0) {
|
||||
dPathSt = ( n - 0.5) * dDeltaLen ;
|
||||
dPathEn = ( n + 0.5) * dDeltaLen ;
|
||||
}
|
||||
Point3d ptSt = ptPs + dPathSt * vtMove ;
|
||||
Point3d ptEn = ptPs + dPathEn * vtMove ;
|
||||
Vector3d vtD = ( dLenPath - dPathSt) * vtDs + dPathSt * vtDe ;
|
||||
vtD.Normalize() ;
|
||||
Vector3d vtA = ( dLenPath - dPathSt) * vtAs + dPathSt * vtAe ;
|
||||
vtA.Normalize() ;
|
||||
bSuccessful = bSuccessful && MillingTranslationStep( ptSt, ptEn, vtD, vtA) ;
|
||||
}
|
||||
return bSuccessful ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
VolZmap::MillingTranslationStep( const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtD, const Vector3d& vtA)
|
||||
{
|
||||
Point3d ptLs[3] ;
|
||||
Point3d ptLe[3] ;
|
||||
Vector3d vtLs[3] ;
|
||||
Vector3d vtALs[3] ;
|
||||
InitializePointsAndVectors( ptPs, ptPe, vtD, vtA, ptLs, ptLe, vtLs, vtALs) ;
|
||||
// Ciclo sulle mappe
|
||||
for ( int i = 0 ; i < m_nMapNum ; ++ i) {
|
||||
SelectMotion( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
VolZmap::InitializePointsAndVectors( const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtDs, const Vector3d& vtAs,
|
||||
Point3d ptLs[3], Point3d ptLe[3], Vector3d vtLs[3], Vector3d vtALs[3])
|
||||
{
|
||||
// Punti posizione
|
||||
ptLs[0] = ptPs ;
|
||||
ptLs[0].ToLoc( m_MapFrame) ;
|
||||
|
||||
ptLe[0] = ptPe ;
|
||||
ptLe[0].ToLoc( m_MapFrame) ;
|
||||
|
||||
if ( m_nMapNum > 1) {
|
||||
ptLs[1].x = ptLs[0].y ; ptLs[1].y = ptLs[0].z ; ptLs[1].z = ptLs[0].x ;
|
||||
ptLs[2].x = ptLs[0].z ; ptLs[2].y = ptLs[0].x ; ptLs[2].z = ptLs[0].y ;
|
||||
|
||||
ptLe[1].x = ptLe[0].y ; ptLe[1].y = ptLe[0].z ; ptLe[1].z = ptLe[0].x ;
|
||||
ptLe[2].x = ptLe[0].z ; ptLe[2].y = ptLe[0].x ; ptLe[2].z = ptLe[0].y ;
|
||||
}
|
||||
|
||||
// Vettori nei sistemi di riferimento intrinseci dello Zmap
|
||||
Vector3d vtLs[3] ;
|
||||
Vector3d vtLe[3] ;
|
||||
|
||||
vtLs[0] = vtDs ;
|
||||
vtLs[0].ToLoc( m_MapFrame) ;
|
||||
vtLs[0].Normalize() ;
|
||||
|
||||
vtLe[0] = vtDe ;
|
||||
vtLe[0].ToLoc( m_MapFrame) ;
|
||||
vtLe[0].Normalize() ;
|
||||
|
||||
// Vettori asse utensile
|
||||
vtLs[0] = vtDs ;
|
||||
if ( m_nMapNum > 1) {
|
||||
vtLs[1].x = vtLs[0].y ; vtLs[1].y = vtLs[0].z ; vtLs[1].z = vtLs[0].x ;
|
||||
vtLs[2].x = vtLs[0].z ; vtLs[2].y = vtLs[0].x ; vtLs[2].z = vtLs[0].y ;
|
||||
|
||||
vtLe[1].x = vtLe[0].y ; vtLe[1].y = vtLe[0].z ; vtLe[1].z = vtLe[0].x ;
|
||||
vtLe[2].x = vtLe[0].z ; vtLe[2].y = vtLe[0].x ; vtLe[2].z = vtLe[0].y ;
|
||||
}
|
||||
|
||||
// Vettori ausiliari nei sistemi di riferimento intrinseci dello Zmap
|
||||
Vector3d vtALs[3] ;
|
||||
Vector3d vtALe[3] ;
|
||||
|
||||
vtALs[0] = vtAs ;
|
||||
vtALs[0].ToLoc( m_MapFrame) ;
|
||||
vtALs[0].Normalize() ;
|
||||
|
||||
vtALe[0] = vtAe ;
|
||||
vtALe[0].ToLoc( m_MapFrame) ;
|
||||
vtALe[0].Normalize() ;
|
||||
|
||||
// Vettori ausiliari
|
||||
vtALs[0] = vtAs ;
|
||||
if ( m_nMapNum > 1) {
|
||||
vtALs[1].x = vtALs[0].y ; vtALs[1].y = vtALs[0].z ; vtALs[1].z = vtALs[0].x ;
|
||||
vtALs[2].x = vtALs[0].z ; vtALs[2].y = vtALs[0].x ; vtALs[2].z = vtALs[0].y ;
|
||||
|
||||
vtALe[1].x = vtALe[0].y ; vtALe[1].y = vtALe[0].z ; vtALe[1].z = vtALe[0].x ;
|
||||
vtALe[2].x = vtALe[0].z ; vtALe[2].y = vtALe[0].x ; vtALe[2].z = vtALe[0].y ;
|
||||
}
|
||||
|
||||
// Ciclo sulle mappe
|
||||
for ( int i = 0 ; i < m_nMapNum ; ++ i) {
|
||||
// Direzione utensile costante: pura traslazione
|
||||
if ( AreSameVectorApprox( vtLs[i], vtLe[i])) {
|
||||
return true ;
|
||||
}
|
||||
|
||||
// Versore utensile parallelo all'asse Z (coincide con spillone)
|
||||
if ( vtLs[i].SqLenXY() < EPS_ZERO * EPS_ZERO) {
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
VolZmap::SelectMotion( int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d vtL, const Vector3d vtAL)
|
||||
{
|
||||
// Versore utensile parallelo all'asse Z (coincide con spillone)
|
||||
if ( vtL.SqLenXY() < EPS_ZERO * EPS_ZERO) {
|
||||
|
||||
Vector3d vtMove = ptLe[i] - ptLs[i] ;
|
||||
Vector3d vtMove = ptLe - ptLs ;
|
||||
|
||||
// Foratura
|
||||
if ( vtMove.SqLenXY() < EPS_SMALL * EPS_SMALL) {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_ZDrilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_ZDrilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_ZDrilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_ZDrilling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
break ;
|
||||
case Tool::CHISEL :
|
||||
Chs_ZDrilling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
|
||||
// Fresatura con vettore movimento perpendicolare all'utensile
|
||||
else if ( abs( vtMove.z) < EPS_SMALL) {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_ZMilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_ZPerp( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_ZPerp( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Milling(i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]);
|
||||
break ;
|
||||
case Tool::CHISEL :
|
||||
Chs_Milling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
|
||||
// Fresatura con vettore movimento generico rispetto all'utensile
|
||||
else {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_ZMilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_ZMilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_ZMilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Milling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Versore utensile nel piano XY (perpendicolare allo spillone)
|
||||
else if ( abs( vtLs[i].z) < EPS_ZERO) {
|
||||
|
||||
Vector3d vtMove = ptLe[i] - ptLs[i] ;
|
||||
Vector3d vtMLong = ( vtMove * vtLs[i]) * vtLs[i] ;
|
||||
Vector3d vtMOrt = vtMove - vtMLong ;
|
||||
|
||||
double dSqLLong = vtMLong.SqLen() ;
|
||||
double dSqLOrt = vtMOrt.SqLen() ;
|
||||
|
||||
// Foratura
|
||||
if ( dSqLOrt < EPS_SMALL * EPS_SMALL) {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_Drilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_XYDrilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_XYDrilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Drilling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
break ;
|
||||
case Tool::CHISEL :
|
||||
Chs_Drilling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
// Fresatura con vettore movimento perpendicolare all'utensile
|
||||
else if ( dSqLLong < EPS_SMALL * EPS_SMALL) {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_Milling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_XYPerp( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
// Usiamo la generica per via dell'intsabilità di Conus_XYPerp
|
||||
//Conus_XYPerp( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
Conus_Milling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Milling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
break ;
|
||||
case Tool::CHISEL :
|
||||
Chs_Milling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
// Fresatura con vettore movimento generico rispetto all'utensile
|
||||
else {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_Milling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_XYMilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_XYMilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Milling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Versore utensile con direzione generica
|
||||
else {
|
||||
Vector3d vtMove = ptLe[i] - ptLs[i] ;
|
||||
Vector3d vtMLong = ( vtMove * vtLs[i]) * vtLs[i] ;
|
||||
Vector3d vtMOrt = vtMove - vtMLong ;
|
||||
|
||||
double dSqLLong = vtMLong.SqLen() ;
|
||||
double dSqLOrt = vtMOrt.SqLen() ;
|
||||
|
||||
// Foratura
|
||||
if ( dSqLOrt < EPS_SMALL * EPS_SMALL) {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_Drilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_Drilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_Drilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Drilling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
break ;
|
||||
case Tool::CHISEL :
|
||||
Chs_Drilling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
// Fresatura con vettore movimento generico rispetto all'utensile
|
||||
else {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_Milling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_Milling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_Milling( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Milling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
break ;
|
||||
case Tool::CHISEL :
|
||||
// ammesso solo movimento perpendicolare all'asse utensile
|
||||
if ( dSqLLong < EPS_SMALL * EPS_SMALL)
|
||||
Chs_Milling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
// Foratura
|
||||
if ( vtMove.SqLenXY() < EPS_SMALL * EPS_SMALL) {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_ZDrilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_ZDrilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_ZDrilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_ZDrilling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
case Tool::CHISEL :
|
||||
Chs_ZDrilling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
|
||||
else ;
|
||||
// Altri casi al momento non gestiti
|
||||
// return false ;
|
||||
// Fresatura con vettore movimento perpendicolare all'utensile
|
||||
else if ( abs( vtMove.z) < EPS_SMALL) {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_ZMilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_ZPerp( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_ZPerp( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
case Tool::CHISEL :
|
||||
Chs_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
|
||||
// Fresatura con vettore movimento generico rispetto all'utensile
|
||||
else {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_ZMilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_ZMilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_ZMilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Versore utensile nel piano XY (perpendicolare allo spillone)
|
||||
else if ( abs( vtL.z) < EPS_ZERO) {
|
||||
|
||||
Vector3d vtMove = ptLe - ptLs ;
|
||||
Vector3d vtMLong = ( vtMove * vtL) * vtL ;
|
||||
Vector3d vtMOrt = vtMove - vtMLong ;
|
||||
|
||||
double dSqLLong = vtMLong.SqLen() ;
|
||||
double dSqLOrt = vtMOrt.SqLen() ;
|
||||
|
||||
// Foratura
|
||||
if ( dSqLOrt < EPS_SMALL * EPS_SMALL) {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_Drilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_XYDrilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_XYDrilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Drilling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
case Tool::CHISEL :
|
||||
Chs_Drilling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
// Fresatura con vettore movimento perpendicolare all'utensile
|
||||
else if ( dSqLLong < EPS_SMALL * EPS_SMALL) {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_Milling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_XYPerp( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
// Usiamo la generica per via dell'intsabilità di Conus_XYPerp
|
||||
//Conus_XYPerp( i, ptLs[i], ptLe[i], vtLs[i]) ;
|
||||
Conus_Milling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
case Tool::CHISEL :
|
||||
Chs_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
// Fresatura con vettore movimento generico rispetto all'utensile
|
||||
else {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_Milling( nGrid, ptLs, ptLe, vtL);
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_XYMilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_XYMilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Versore utensile con direzione generica
|
||||
else {
|
||||
Vector3d vtMove = ptLe - ptLs ;
|
||||
Vector3d vtMLong = ( vtMove * vtL) * vtL ;
|
||||
Vector3d vtMOrt = vtMove - vtMLong ;
|
||||
|
||||
double dSqLLong = vtMLong.SqLen() ;
|
||||
double dSqLOrt = vtMOrt.SqLen() ;
|
||||
|
||||
// Foratura
|
||||
if ( dSqLOrt < EPS_SMALL * EPS_SMALL) {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_Drilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_Drilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_Drilling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Drilling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
case Tool::CHISEL :
|
||||
Chs_Drilling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
// Fresatura con vettore movimento generico rispetto all'utensile
|
||||
else {
|
||||
switch ( m_Tool.GetType()) {
|
||||
case Tool::GEN :
|
||||
GenTool_Milling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CYLMILL :
|
||||
case Tool::BALLMILL :
|
||||
CylBall_Milling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::CONEMILL :
|
||||
Conus_Milling( nGrid, ptLs, ptLe, vtL) ;
|
||||
break ;
|
||||
case Tool::MORTISER :
|
||||
Mrt_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
case Tool::CHISEL :
|
||||
// ammesso solo movimento perpendicolare all'asse utensile
|
||||
if ( dSqLLong < EPS_SMALL * EPS_SMALL)
|
||||
Chs_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
m_nConnectedCompoCount = - 1 ;
|
||||
return true ;
|
||||
}
|
||||
|
||||
|
||||
// ---------- VERSORE UTENSILE DERETTO COME Z --------------------------------
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user