EgtGeomKernel :

- piccoli aggiustamenti.

CurveAux.cpp

@@ -513,8 +513,13 @@ CurveToBezierCurve( const ICurve* pCrv, int nDeg, bool bMakeRatOrNot)
 
 //----------------------------------------------------------------------------
 ICurveBezier*
-LineToBezierCurve( const ICurveLine* pCrvLine, int nDeg, bool bMakeRatOrNot)
+LineToBezierCurve( const ICurve* pCrv, int nDeg, bool bMakeRatOrNot)
 {
+   // verifico sia una linea
+   const CurveLine* pCrvLine = GetBasicCurveLine( pCrv) ;
+   if ( pCrvLine == nullptr)
+      return nullptr ;
+
    PtrOwner<ICurveBezier> pCrvBezier( CreateCurveBezier()) ;
    // rendo tutte le curve di grado 2 e razionali così posso convertire anche archi e avere tutte curve dello stesso grado e razionali
    pCrvBezier->Init( nDeg, true) ;
@@ -560,7 +565,7 @@ ArcToBezierCurve( const ICurve* pCrv, int nDeg, bool bMakeRatOrNot)
       nParts = max( nParts, 2) ;
       for ( int i = 0 ; i < nParts ; ++ i) {
         // copio l'arco originale
-         CurveArc cArc = *pArc ;
+         CurveArc cArc = *GetBasicCurveArc(pArc->Clone()) ;
         // lo limito alla parte di interesse
          cArc.TrimStartEndAtParam( i / double( nParts), ( i + 1) / double( nParts)) ;
         // creo la curva di Bezier equivalente
@@ -584,8 +589,13 @@ ArcToBezierCurve( const ICurve* pCrv, int nDeg, bool bMakeRatOrNot)
 
 //----------------------------------------------------------------------------
 ICurve*
-CompositeToBezierCurve( const ICurveComposite* pCC, int nDeg, bool bMakeRatOrNot)
+CompositeToBezierCurve( const ICurve* pCrv, int nDeg, bool bMakeRatOrNot)
 {
+   // verifico sia una composita
+   const CurveComposite* pCC = GetBasicCurveComposite( pCrv) ;
+   if ( pCC == nullptr)
+      return nullptr ;
+
    // converto tutte le curve in bezier razionali di grado 2
    PtrOwner<ICurveComposite> pCCBezier( CreateCurveComposite()) ;
    for ( int i = 0 ; i < int( pCC->GetCurveCount()) ; ++i) {
@@ -620,10 +630,15 @@ CompositeToBezierCurve( const ICurveComposite* pCC, int nDeg, bool bMakeRatOrNot
 
 //----------------------------------------------------------------------------
 ICurve*
-EditBezierCurve( const ICurveBezier* pCrvBezier, int nDeg, bool bMakeRatOrNot, double dTol)
+EditBezierCurve( const ICurve* pCrv, int nDeg, bool bMakeRatOrNot, double dTol)
 { 
    // se nDeg == -1 allora viene mantenuto il grado della curva originale
 
+   // verifico sia una bezier
+   const CurveBezier* pCrvBezier = GetBasicCurveBezier( pCrv) ;
+   if ( pCrvBezier == nullptr)
+      return nullptr ;
+
    if( nDeg == 2 ||  nDeg == 1)
       return nullptr ;
 
@@ -889,8 +904,13 @@ BezierDecreaseDegree(const ICurveBezier* pCrvBezier, double dTol)
 
 //----------------------------------------------------------------------------
 ICurve*
-ApproxBezierWithCubics(const ICurveBezier* pCrvBezier, double dTol)
+ApproxBezierWithCubics(const ICurve* pCrv, double dTol)
 {
+   // verifico sia una bezier
+   const CurveBezier* pCrvBezier = GetBasicCurveBezier( pCrv) ;
+   if ( pCrvBezier == nullptr)
+      return nullptr ;
+
    // cerco di stimare quanti cambi di concavità ho
    // tiro una linea tra il primo punto di controllo e l'ultimo e poi scorro gli altri punti di controllo
    // controllando quante volte salto da un lato all'altro della linea
@@ -1012,8 +1032,13 @@ ApproxBezierWithCubics(const ICurveBezier* pCrvBezier, double dTol)
 
 //----------------------------------------------------------------------------
 ICurveBezier*
-ApproxCurveBezierWithSingleCubic( const ICurveBezier* pCrvBez)
+ApproxCurveBezierWithSingleCubic( const ICurve* pCrv)
 {
+   // verifico sia una bezier
+   const CurveBezier* pCrvBez = GetBasicCurveBezier( pCrv) ;
+   if ( pCrvBez == nullptr)
+      return nullptr ;
+
    Point3d ptStart, ptEnd ;
    pCrvBez->GetStartPoint( ptStart) ;
    pCrvBez->GetEndPoint( ptEnd) ;
@@ -1042,8 +1067,13 @@ ApproxCurveBezierWithSingleCubic( const ICurveBezier* pCrvBez)
 
 //----------------------------------------------------------------------------
 ICurveBezier*
-ApproxArcCurveBezierWithSingleCubic( const ICurveBezier* pCrvBez, const Point3d& ptCen)
+ApproxArcCurveBezierWithSingleCubic( const ICurve* pCrv, const Point3d& ptCen)
 {
+   // verifico sia una bezier
+   const CurveBezier* pCrvBez = GetBasicCurveBezier( pCrv) ;
+   if ( pCrvBez == nullptr)
+      return nullptr ;
+
    // converto una curva di bezier che definisce un arco perfetto di circonferenza
    // dato il centro( della circonferenza), inizio e fine
    // N.B. : per archi con angolo al centro < 90 
@@ -1086,7 +1116,9 @@ ApproxArcCurveBezierWithSingleCubic( const ICurveBezier* pCrvBez, const Point3d&
 ICurve*
 ApproxCurveWithBezier( const ICurve*, double dTol)
 {
-   // interpolazione di punti con una curva bezier
+   // campiono punti lungo la curva e poi li interpolo
+
+   // oppure faccio la fat curve e poi calcolo una bezier che stia all'interno di quella regione
 
    PtrOwner<ICurveComposite> pCC( CreateBasicCurveComposite()) ;
    return Release( pCC) ;
@@ -1262,7 +1294,7 @@ CurveToNoArcsCurve( const ICurve* pCrv)
       return nullptr ;
   // se arco, devo trasformarlo in curva di Bezier (semplice o composta)
    if ( pCrv->GetType() == CRV_ARC) {
-      return ArcToBezierCurve( pCrv) ;
+      return ArcToBezierCurve( GetCurveArc(pCrv)) ;
    }
   // se curva composita, devo trasformarla in composita senza archi
    else if ( pCrv->GetType() == CRV_COMPO) {

CurveAux.h

@@ -33,5 +33,5 @@ bool CurveGetArea( const ICurve& crvC, Plane3d& plPlane, double& dArea) ;
 bool CurveDump( const ICurve& crvC, std::string& sOut, bool bMM, const char* szNewLine) ;
 bool CopyExtrusion( const ICurve* pSouCrv, ICurve* pDestCrv) ;
 bool CopyThickness( const ICurve* pSouCrv, ICurve* pDestCrv) ;
-ICurveBezier* ApproxCurveBezierWithSingleCubic( const ICurveBezier* pCrvBez) ;
+ICurveBezier* ApproxCurveBezierWithSingleCubic( const ICurve* pCrv) ;
 Voronoi* GetCurveVoronoi( const ICurve& crvC) ;

CurveBezier.cpp

@@ -2383,3 +2383,11 @@ CurveBezier::IsALine( void) const
    }
    return true ;
 }
+
+//----------------------------------------------------------------------------
+PNTVECTOR
+CurveBezier::GetAllControlPoints( void) const
+{
+   PNTVECTOR vPntCtrl = m_vPtCtrl ;
+   return vPntCtrl ;
+}

CurveBezier.h

@@ -153,6 +153,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
       bool MakeRationalStandardForm( void) override ;
       bool MakeNonRational( double dTol) override ;
       bool IsALine( void) const override ;
+      PNTVECTOR GetAllControlPoints( void) const ;  // non aggiunta in interfaccia
 
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;

SurfBezier.cpp

@@ -5389,3 +5389,11 @@ SurfBezier::CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDe
    }
    return true ;
 }
+
+//----------------------------------------------------------------------------
+PNTVECTOR
+SurfBezier::GetAllControlPoints( void) const
+{
+   PNTVECTOR vPntCtrl = m_vPtCtrl ;
+   return vPntCtrl ;
+}

SurfBezier.h

@@ -22,7 +22,6 @@
 #include "/EgtDev/Include/EGkSurfBezier.h"
 #include "/EgtDev/Include/EGkGeoCollection.h"
 
-using namespace std ;
 class Tree ;
 
 struct PairHashIntInt {
@@ -157,6 +156,7 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool CreateByPointCurve( const Point3d& pt, const ICurve* pCurve) override ;
       bool CreateByTwoCurves( const ICurve* pCurve1, const ICurve* pCurve2, int nType) override ;
       bool CreateBySetOfCurves( const ICURVEPOVECTOR& vCrvBez, bool bReduceToDeg3) override ;
+      PNTVECTOR GetAllControlPoints( void) const ;
 
    public :                      // IGeoObjRW
       int  GetNgeId( void) const override ;
@@ -168,7 +168,7 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
 
    public :
       SurfBezier( void) ;
-      SurfBezier( const SurfBezier& sbSrc)
+      SurfBezier( const SurfBezier& sbSrc) : m_pSTM( nullptr), m_pSTMRefined( nullptr), m_pTrimReg(nullptr)
                   { if ( ! CopyFrom( sbSrc))
                        LOG_ERROR( GetEGkLogger(), "SurfBezier : copy constructor error") }
       SurfBezier& operator =( const SurfBezier& sbSrc)
@@ -238,7 +238,7 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       SurfFlatRegion* m_pTrimReg ;         // eventuale regione di trim
       int             m_nTempProp[2] ;     // vettore proprietà temporanee
       double          m_dTempParam[2] ;    // vettore parametri temporanei
-      mutable vector<ICRVCOMPOPOVECTOR> m_mCCEdge ; // vettore dei vettori che contengono le curve compo degli edge della superficie nello spazio 3D
+      mutable std::vector<ICRVCOMPOPOVECTOR> m_mCCEdge ; // vettore dei vettori che contengono le curve compo degli edge della superficie nello spazio 3D
       mutable ICRVCOMPOPOVECTOR m_vCCLoop ;         // vettore dei loop della superficie trimmata
       mutable int            m_nIsPlanar ;          // enum che indica se la superficie è piana ( -1, non è stato calcolato)
       mutable DBLVECTOR      m_vBernU ;

Tree.h

@@ -23,7 +23,7 @@
 #include <utility>
 
 struct PairHashInt64 {
-   size_t operator()(const pair<int64_t, int64_t>& key) const {
+   size_t operator()(const std::pair<int64_t, int64_t>& key) const {
       size_t h1 = std::hash<int64_t>{}(key.first) ;
       size_t h2 = std::hash<int64_t>{}(key.second) ;
       return h1 ^ (h2 << 1);  // Combine hashes
@@ -251,16 +251,14 @@ class Tree
       bool BuildTree( double dLinTol = LIN_TOL_STD,
                       double dSideMin = 1,                   // è la minima lunghezza del lato di una cella
                       double dSideMax = INFINITO) ;          // è la massima dimensione di un triangolo della trimesh
-      bool GetPolygons( POLYLINEMATRIX& vvPolygons, POLYLINEMATRIX& vvPolygons3d, vector<ICRVCOMPOPOVECTOR>& vCCEdges3D, ICRVCOMPOPOVECTOR& vCCLoops) ;
+      bool GetPolygons( POLYLINEMATRIX& vvPolygons, POLYLINEMATRIX& vvPolygons3d, std::vector<ICRVCOMPOPOVECTOR>& vCCEdges3D, ICRVCOMPOPOVECTOR& vCCLoops) ;
       bool GetPolygonsBasic( POLYLINEVECTOR& vPolygons, POLYLINEVECTOR& vPolygonsCorrected, POLYLINEVECTOR& vPolygons3d) ; // restituisce il poligono corrispondente ad ogni cella foglia dell'albero
                                                                                                                            // ad ogni poligono sono stati aggiunti tutti i vertici dei vicini posizionati sui suoi lati
                                                                                                                            // ad alcuni poligoni potrebbero venire tolti dei punti per evitare errori dovuti ad eventuali poli sui bordi del parametrico
-      bool GetLeaves( std::vector<Cell>& vLeaves) const ;         // restituisce gli indici delle foglie nell'albero
-      bool GetEdges3D ( vector<ICRVCOMPOPOVECTOR>& mCCEdge, POLYLINEVECTOR& vPolygons) ;  // restituisce gli edge 3D come polyline
-      bool GetSplitLoops( ICRVCOMPOPOVECTOR& vCCLoopSplit) const  // restituisce i loop splitatti ai confini delle celle
-             { for ( int i = 0 ; i < int( m_vCCLoop2D.size()); ++i)
-                  vCCLoopSplit.emplace_back( m_vCCLoop2D[i]->Clone()) ;
-               return true ; }
+      bool GetLeaves ( std::vector<Cell>& vLeaves) const ;  // restituisce gli indici delle foglie nell'albero
+      bool GetEdges3D ( std::vector<ICRVCOMPOPOVECTOR>& mCCEdge, POLYLINEVECTOR& vPolygons) ;  // restituisce gli edge 3D come polyline
+      bool GetSplitLoops( ICRVCOMPOPOVECTOR& vCCLoopSplit) const // funzione che restituisce i loop splitatti ai confini delle celle
+             { for ( int i = 0 ; i < int( m_vCCLoop2D.size()); ++i) vCCLoopSplit.emplace_back( m_vCCLoop2D[i]->Clone()) ; return true ; };
       // funzioni da usare per ricostruire tagli che vanno aggiunti allo spazio parametrico
       bool AddCutsToRoot( POLYLINEVECTOR& vCuts) ;          // aggiunge i tagli al tree
       bool CreateCellContour( POLYLINEMATRIX& vPolygons) ;  // crea il nuovo contorno esterno, tenendo conto dei tagli
@@ -312,8 +310,8 @@ class Tree
    private :
       const SurfBezier*           m_pSrfBz ;           // superficie di bezier
       bool                        m_bTrimmed ;         // superficie trimmata
-      unordered_map<int,int>      m_mChunk ;           // mappa in cui vengono salvati chunk di appartenza per ogni loop di trim
-      vector<tuple<PolyLine,bool>> m_vPlApprox ;       // vettore contenente le approssimazioni dei loop  // il bool indica se la curva è CCW
+      std::unordered_map<int,int>      m_mChunk ;           // mappa in cui vengono salvati chunk di appartenza per ogni loop di trim
+      std::vector<std::tuple<PolyLine,bool>> m_vPlApprox ;       // vettore contenente le approssimazioni dei loop  // il bool indica se la curva è CCW
       bool                        m_bBilinear ;        // superficie bilineare
       bool                        m_bMulti ;           // superficie multi-patch
       bool                        m_bClosedU ;         // superficie chiusa lungo il parametro U
@@ -323,10 +321,10 @@ class Tree
       int                         m_nDegV ;            // grado della superficie nel parametro V
       int                         m_nSpanU ;           // numero di span lungo il parametro U
       int                         m_nSpanV ;           // numero di span lungo il parametro V
-      unordered_map<int,Cell>     m_mTree ;            // mappa che contiene tutti i nodi e le foglie dell'albero. -2 è puntatore Null e -1 è root
-      mutable unordered_map<pair<int64_t,int64_t>,Point3d,PairHashInt64>     m_mPt3d ;    // mappa che contiene tutti i punti 3d della superficie calcolati (la chiave sono le coordinate, moltiplicate per 2^24 e trasformate in int)
+      std::unordered_map<int,Cell>     m_mTree ;            // mappa che contiene tutti i nodi e le foglie dell'albero. -2 è puntatore Null e -1 è root
+      mutable std::unordered_map<std::pair<int64_t, int64_t>,Point3d, PairHashInt64>     m_mPt3d ;    // mappa che contiene tutti i punti 3d della superficie calcolati (la chiave sono le coordinate, moltiplicate per 2^24 e trasformate in int)
       INTVECTOR                   m_vnLeaves ;         // vettore delle foglie
       INTVECTOR                   m_vnParents ;        // vettore delle celle ottenute dalla divisione preliminare in singole patch
       ICRVCOMPOPOVECTOR           m_vCCLoop2D ;        // vettore che contiene le CurveCompo che rappresentano i loop di trim tenendo conto della divisione in celle
-      vector<pair<BIPNTVECTOR, ChainCurves>>    m_vCEdge2D ;        // vettore che le chain che rappresentano ciò che resta degli edge originali, tenendo conto dei trim.
+      std::vector<std::pair<BIPNTVECTOR, ChainCurves>>    m_vCEdge2D ;        // vettore che le chain che rappresentano ciò che resta degli edge originali, tenendo conto dei trim.
 } ;

VolZmap.h

@@ -16,6 +16,7 @@
 #include "ObjGraphicsMgr.h"
 #include "GeoObjRW.h"
 #include "Tool.h"
+#include "SurfBezier.h"
 #include "/EgtDev/Include/EGkVolZmap.h"
 #include "/EgtDev/Include/EGkIntersLineVolZmap.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
@@ -23,9 +24,15 @@
 #include <stack>
 #include <mutex>
 #include <atomic>
+#include <tuple>
+
+typedef std::pair<Point3d, Vector3d>  PNTVEC3D ;
+typedef std::vector<PNTVEC3D>        PNTVEC3DVECTOR ;  // vettore di intersezioni punto, vettore, tipo superficie
 
 // ------------------------- FORWARD -------------------------------------------------------------
 class IntersParLinesSurfTm ;
+class BBox3d ;
+class Frame3d ;
 
 // ------------------------- STRUTTURE -----------------------------------------------------------
 struct AppliedVector {
@@ -34,6 +41,55 @@ struct AppliedVector {
    int nPropIndex ;
 } ;
 
+struct MachInfo {
+   int n5AxisType ;
+   int nSub ;
+   int nStepCnt ;
+   double dSide ;
+   Vector3d vtDirTipStartEx ;
+   Vector3d vtDirTipEndEx ;
+   Vector3d vtDirTopStartEx ;
+   Vector3d vtDirTopEndEx ;
+   VCT3DVECTOR vvtTipStartAux ;
+   VCT3DVECTOR vvtTipEndAux ;
+   VCT3DVECTOR vvtTopStartAux ;
+   VCT3DVECTOR vvtTopEndAux ;
+   Vector3d vtDirTip ;
+   Vector3d vtDirTop ;
+   MachInfo( int n5AxisType_, int nSub_, int nStepCnt_, double dSide_, Vector3d vtDirTipStartEx_, Vector3d vtDirTipEndEx_, Vector3d vtDirTopStartEx_, Vector3d vtDirTopEndEx_,
+             VCT3DVECTOR vvtTipStartAux_, VCT3DVECTOR vvtTipEndAux_, VCT3DVECTOR vvtTopStartAux_, VCT3DVECTOR vvtTopEndAux_, Vector3d vtDirTip_, Vector3d vtDirTop_) :
+             n5AxisType( n5AxisType_), nSub( nSub_), nStepCnt( nStepCnt_), dSide( dSide_), vtDirTipStartEx( vtDirTipStartEx_), vtDirTipEndEx( vtDirTipEndEx_), vtDirTopStartEx( vtDirTopStartEx_), vtDirTopEndEx( vtDirTopEndEx_),
+             vvtTipStartAux( vvtTipStartAux_), vvtTipEndAux( vvtTipEndAux_), vvtTopStartAux( vvtTopStartAux_), vvtTopEndAux( vvtTopEndAux_), vtDirTip( vtDirTip_), vtDirTop( vtDirTop_) {}
+};
+
+struct ToolInfo {
+   double dHeight ;
+   double dMaxRad ;
+   double dMinRad ;
+   double dTan ;
+   double dMaxH ;
+   double dMinH ;
+   double dMaxRadApprox ;
+   double dMinRadApprox ;
+   BBox3d bbStartCyl ;
+   BBox3d bbEndCyl ;
+   Frame3d frToolStart ;
+   Frame3d frToolEnd ;
+   //Vector3d vtDirTip ;
+   //Vector3d vtDirTop ;
+   ToolInfo( double dHeight_, double dMaxRad_, double dMinRad_, double dTan_, double dMaxH_, double dMinH_, double dMaxRadApprox_, double dMinRadApprox_,
+             BBox3d bbStartCyl_, BBox3d bbEndCyl_, Frame3d frToolStart_, Frame3d frToolEnd_) :
+             dHeight ( dHeight_), dMaxRad( dMaxRad_), dMinRad( dMinRad_), dTan( dTan_), dMaxH( dMaxH_), dMinH( dMinH_), dMaxRadApprox( dMaxRadApprox_), dMinRadApprox( dMinRadApprox_),
+             bbStartCyl( bbStartCyl_), bbEndCyl( bbEndCyl_), frToolStart( frToolStart_), frToolEnd( frToolEnd_) {}
+};
+
+struct SurfBezForInters {
+   SurfBezier sBez ;
+   BBox3d bbSurf ;
+   double A1, A2, B1, B2, C1, C2 ;
+   Vector3d d ;
+};
+
 //----------------------------------------------------------------------------
 class VolZmap : public IVolZmap, public IGeoObjRW
 {
@@ -97,7 +153,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
               { return m_nDexVoxRatio ; }   
       bool ChangeResolution( int nDexVoxRatio) override ;
       void SetShowEdges( bool bShow) override
-              { m_bShowEdges = bShow ;  // qui è necessario far ricreare la grafica
+              { m_bShowEdges = bShow ;  // qui � necessario far ricreare la grafica
                 m_OGrMgr.Clear() ; }
       bool GetShowEdges( void) const override
               { return m_bShowEdges ; }
@@ -263,9 +319,12 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool MillingTranslationStep( const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtD, const Vector3d& vtA) ;
       bool MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
                                      const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe) ;
+      bool SelectGeneralMotion( int nGrid, const PNTVECTOR& ptPs, const PNTVECTOR& ptPe, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int n5AxisType) ;
       bool SelectMotion( int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtL, const Vector3d& vtAL) ;
       bool 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]) ;
+      bool InitializeAuxPoints( Point3d ptTop1s[3], Point3d ptTop1e[3], Point3d ptTop2s[3], Point3d ptTop2e[3],
+                                Point3d ptBottom1s[3], Point3d ptBottom1e[3], Point3d ptBottom2s[3], Point3d ptBottom2e[3]) ;
     // SOTTRAZIONI 
     // UTENSILI
      // Asse di simmetria parallelo a Z
@@ -293,11 +352,16 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool Conus_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
       bool Conus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
       bool Mrt_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ;
-      bool Mrt_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ;  // E' in realtà un Perp
+      bool Mrt_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ;  // E' in realt� un Perp
       bool Chs_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ;
-      bool Chs_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ;  // E' in realtà un Perp
+      bool Chs_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, const Vector3d& vtAux) ;  // E' in realt� un Perp
       bool GenTool_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
       bool GenTool_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
+     // lavorazioni a 5 assi
+      bool GenTool_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, int n5AxisType = VolZmap::Move5Axis::ACROSS) ;
+      bool Cyl_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, double dHeightCorr = 0, int n5AxisType = VolZmap::Move5Axis::ACROSS) ;
+      bool CylBall_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, int n5AxisType = VolZmap::Move5Axis::ACROSS) ;
+      bool Conus_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe, int nToolNum, int n5AxisType = VolZmap::Move5Axis::ACROSS) ;
 
     // COMPONENTI
      // Asse di simmetria diretto come l'asse Z 
@@ -316,7 +380,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
                                const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR, int nToolNum) ;
       bool CompPar_ZMilling( int nGrid, double dLenX, double dLenY, double dLenZ,
                              const Point3d& ptS, const Point3d& ptE,
-                             const Vector3d& vtToolDir, const Vector3d& vtAux, int nToolNum) ;   //  E' in realtà  MillingPerp
+                             const Vector3d& vtToolDir, const Vector3d& vtAux, int nToolNum) ;   //  E' in realt�  MillingPerp
      // Asse di simmetria con orientazione generica
       bool CompCyl_Drilling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir,
                              double dHei, double dRad, bool bTapB, bool bTapT, int nToolNum) ;
@@ -332,7 +396,15 @@ class VolZmap : public IVolZmap, public IGeoObjRW
                               const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR, int nToolNum) ;
       bool CompPar_Milling( int nGrid, double dLenX, double dLenY, double dLenZ,
                             const Point3d& ptS, const Point3d& ptE,
-                            const Vector3d& vtToolDir, const Vector3d& vtAux, int nToolNum) ;   //  E' in realtà  MillingPerp
+                            const Vector3d& vtToolDir, const Vector3d& vtAux, int nToolNum) ;   //  E' in realtà  MillingPerp
+     // lavorazioni a 5 assi
+      bool Comp_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe,
+                              double dHeight, double dMaxRad, double dMinRad, int nToolNum, int n5AxisType) ;
+      bool CompCyl_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtLs, const VCT3DVECTOR& vtLe,
+                                 double dHeight, double dRadius, int nToolNum,int n5AxisType) ;
+      bool CompConus_5AxisMilling( int nGrid, const PNTVECTOR& ptS, const PNTVECTOR& ptE, const VCT3DVECTOR& vtToolDirS, const VCT3DVECTOR& vtToolDirE, double dHei, double dMaxRad, double dMinRad,
+                                   bool bTapB, bool bTapT,const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR, int nToolNum, int n5AxisType) ;
+
      // Generica traslazione sfera
       bool CompBall_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, double dRad, int nToolNum) ;
      // Additivi
@@ -346,7 +418,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
      // BBox per utensili e solidi semplici con movimenti di traslazione
       inline bool TestToolBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV,
                                 int& nStI, int& nStJ, int& nEnI, int& nEnJ) ;
-      inline bool TestCompoBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV,
+      inline bool TestCompoBBox( int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV, const Vector3d& vtV2,
                                  double dRad, double dTipRad, double dHei,
                                  int& nStI, int& nStJ, int& nEnI, int& nEnJ) ;
       inline bool TestParaBBox( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtD, const Vector3d& vtA,
@@ -377,6 +449,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool IntersLineTruncatedPyramid( const Point3d& ptLineSt, const Vector3d& vtLineDir,
                                        const Frame3d& frTruncPyramFrame, double dSegMin, double dSegMax, double dHeight,
                                        Point3d& ptInt1, Vector3d& vtN1, Point3d& ptInt2, Vector3d& vtN2) const ;
+      bool IntersToolLine( const Point3d& ptLineStart, const Vector3d& vtLineDir, const MachInfo& mi, const ToolInfo& ti,
+                           const std::vector<SurfBezForInters>& vSurfBez,PNTVEC3DVECTOR& vInters, INTVECTOR& vSurfInters) const ;
       bool TestIntersPlaneZmapBBox( const Plane3d& plPlane) const ;
      // Voxel: esistenza e passaggio da N a ijk per i voxel
       bool IsValidVoxel( int nN) const ;
@@ -453,6 +527,28 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool AddIntervalsForOffset( int nGrid, int nI, int nJ,
                                   double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax,
                                   int nToolNum, bool bSkipSwap = false) ;
+   public :
+      // ------------------------- ENUM ----------------------------------------------------------------
+      enum MillingPhase {
+         COUNT_START_VOL = 0 ,
+         ONLY_LATERAL_SURF = 1 ,
+         COUNT_END_VOL = 2 ,
+         COUNT_START_END = 3
+      } ;
+
+      enum Move5Axis{
+         ALONG_CONVEX = 0 ,
+         ALONG_CONCAVE = 1 ,
+         ACROSS = 2 ,
+         NO_BASE_INTERS = 3
+      } ;
+
+      enum CuttingSurface {
+         NONE = -1,
+         TOOL = 0 ,
+         BZ = 1 ,
+         LATERAL = 2
+      } ;
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
@@ -463,7 +559,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
    private :
       ObjGraphicsMgr m_OGrMgr ;             // gestore grafica dell'oggetto
       Status         m_nStatus ;            // stato
-      int            m_nTempProp[2] ;       // vettore proprietà temporanee
+      int            m_nTempProp[2] ;       // vettore propriet� temporanee
       double         m_dTempParam[2] ;      // vettore parametri temporanei
       bool           m_bShowEdges ;         // flag di visualizzazione spigoli vivi
       Frame3d        m_MapFrame ;           // riferimento intrinseco dello Zmap
@@ -497,8 +593,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       mutable BOOLVECTOR m_BlockToUpdate ;
       mutable INTVECTOR  m_BlockUpdatingCounter ;
 
-      int m_nConnectedCompoCount ;          // Se == - 1 il numero di componenti non è noto
-                                            // Se >= 0 è il numero di componenti connesse
+      int m_nConnectedCompoCount ;          // Se == - 1 il numero di componenti non � noto
+                                            // Se >= 0 � il numero di componenti connesse
               
       mutable std::vector<VoxelContainer>  m_InterBlockVox ;
       mutable SharpTriaMatrix              m_InterBlockOriginalSharpTria ;