EgtGeomKernel :

- codice di test per Zmap.

CDeBoxClosedSurfTm.cpp

@@ -1,13 +1,14 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2016-2020
+//  EgalTech 2016-2024
 //----------------------------------------------------------------------------
-// File : CDBoxSurfTm.cpp      Data : 09.01.20        Versione : 2.2a2
+// File : CDeBoxClosedSurfTm.cpp      Data : 24.03.24        Versione : 2.6c2
 // Contenuto : Implementazione della verifica di collisione tra
 //             BoundingBox e Closed SurftriMesh.
 //
 //
 // Modifiche : 05.10.16 DS Creazione modulo.
 //             09.01.20 DS Cambio nome alla funzione.
+//             24.03.24 DS Aggiunta TestCylSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -66,3 +67,39 @@ CDeBoxClosedSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, const ISurfTri
   // Se il box è interno c'è collisione
    return DistBoxCenSurfCalc.IsPointInside() ;
 }
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra il box e la superficie : restituisce true in caso di interferenza.
+//----------------------------------------------------------------------------
+bool
+TestBoxSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, const ISurfTriMesh& Stm, double dSafeDist)
+{
+  // Se il box non è ben definito non ha senso proseguire
+   if ( vtDiag.IsSmall())
+      return true ;
+  // Se superficie non valida, non ha senso proseguire
+   if ( ! Stm.IsValid())
+      return true ;
+  // Recupero BBox del poliedro
+   BBox3d b3Poly = Stm.GetAllTriaBox() ;
+  // Calcolo il BBox del parallelepipedo
+   BBox3d b3BoxL( ORIG, ORIG + vtDiag) ;
+   if ( dSafeDist > EPS_SMALL)
+      b3BoxL.Expand( dSafeDist) ;
+   BBox3d b3Box = GetToGlob( b3BoxL, frBox) ;
+  // Se i BBox non interferiscono, non c'è collisione
+   if ( ! b3Poly.Overlaps( b3Box)  ||  ! b3Poly.Overlaps( frBox, b3BoxL))
+      return false ;
+  // Verifico se il parallelepipedo interferisce con i triangoli del poliedro presenti nel suo BBox
+   INTVECTOR vT ;
+   Stm.GetAllTriaOverlapBox( b3Box, vT) ;
+   for ( int nT : vT) {
+      Triangle3d Tria ;
+      if ( Stm.GetTriangle( nT, Tria)) {
+         if ( CDeBoxTria( frBox, vtDiag, Tria, dSafeDist))
+            return true ;
+      }
+   }
+  // Non c'è interferenza
+   return false ;
+}

CDeClosedSurfTmClosedSurfTm.cpp

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File :      CDeSurfTmSurfTm.h      Data : 14.06.23    Versione : 2.5f3 
+// File : CDeClosedSurfTmClosedSurfTm.h    Data : 24.03.24  Versione : 2.6c2 
 // Contenuto : Implementazione funzione verifica collisione tra
 //             SurfTm e SurfTm.
 //
 // Modifiche : 13.11.20 LM Creazione modulo.
-//
+//             24.03.24 DS Aggiunta TestSurfTmSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -122,3 +122,89 @@ CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& Surf
    DistPointSurfTm DistPoinBSrfA( ptPointB, *pSrfA) ;
    return ( DistPoinASrfB.IsPointInside()  ||  DistPoinBSrfA.IsPointInside()) ;
 }
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra le due superfici : restituisce true in caso di interferenza.
+//----------------------------------------------------------------------------
+bool
+TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist)
+{
+  // Recupero le superfici base
+   const SurfTriMesh* pSrfA = GetBasicSurfTriMesh( &SurfA) ;
+   const SurfTriMesh* pSrfB = GetBasicSurfTriMesh( &SurfB) ;
+  // Se le superfici non sono valide, non ha senso proseguire
+   if ( pSrfA == nullptr ||  ! pSrfA->IsValid()  ||
+        pSrfB == nullptr ||  ! pSrfB->IsValid())
+      return true ;
+  // Se i box delle superfici non si intersecano, ho finito.
+   BBox3d b3BoxA, b3BoxB ;
+   pSrfA->GetLocalBBox( b3BoxA) ;
+   pSrfB->GetLocalBBox( b3BoxB) ;
+  // Se è necessario, espando il box di B di una costante additiva pari alla distanza di sicurezza.
+   if ( dSafeDist > EPS_SMALL)
+      b3BoxB.Expand( dSafeDist) ;
+  // Se i box non si sovrappongono, non c'è collisione. Ho finito.
+   if ( ! b3BoxA.Overlaps( b3BoxB))
+      return false ;
+  // Recupero i triangoli di A che interferiscono col box di B
+   INTVECTOR vTriaIndex ;
+   pSrfA->GetAllTriaOverlapBox( b3BoxB, vTriaIndex) ;
+  // Ciclo sui triangoli della superficie A che interferiscono col box della superficie B.
+   for ( int nTA : vTriaIndex) {
+      Triangle3d trTriaA ;
+      if ( ! ( pSrfA->GetTriangle( nTA, trTriaA)  &&  trTriaA.Validate()))
+         continue ;
+      BBox3d b3BoxTriaA ;
+      trTriaA.GetLocalBBox( b3BoxTriaA) ;
+     // Se è necessario, espando il box di una costante additiva pari alla distanza di sicurezza.
+      if ( dSafeDist > EPS_SMALL)
+         b3BoxTriaA.Expand( dSafeDist) ;
+     // Recupero i triangoli di B che interferiscono col box del triangolo di A
+      INTVECTOR vNearTria ;
+      pSrfB->GetAllTriaOverlapBox( b3BoxTriaA, vNearTria) ;
+     // Settare tutti i triangoli come già processati.
+     // Al termine della chiamata i TempInt dei triangoli valgono 0.
+      pSrfB->ResetTempInts() ;
+     // Ciclo sui triangoli della superficie B che cadono nel box del triangolo corrente della Superficie A.
+      for ( int nTB : vNearTria) {
+        // Recupero il triangolo corrente della superficie B.
+        // Se triangolo non valido salto al successivo.
+         Triangle3d trTriaB ;
+         if ( ! ( pSrfB->GetTriangle( nTB, trTriaB)  &&  trTriaB.Validate()))
+            continue ;   
+        // Se necessario considero l'offset
+         if ( dSafeDist > EPS_SMALL) {
+            int nAdjTriaId[3] ;
+            pSrfB->GetTriangleAdjacencies( nTB, nAdjTriaId) ;
+           // Ciclo sui vertici del triangolo.
+            for ( int nVB = 0 ; nVB < 3 ; ++ nVB) {
+              // Se il triangolo adiacente al triangolo corrente su questo edge
+              // non è stato processato, processo il vertice e l'edge.
+               int nAdjTriaTempFlag ;
+               if ( ! ( pSrfB->GetTempInt( nAdjTriaId[nVB], nAdjTriaTempFlag)  ||  nAdjTriaTempFlag == 0))
+                  continue ;
+              // Processo il vertice: se c'è collisione fra triangolo A e sfera ho finito.
+               if ( CDeSimpleSpheTria( trTriaB.GetP( nVB), dSafeDist, trTriaA))
+                  return true ;
+              // Processo l'edge: se c'è collisione fra triangolo A e cilindro ho finito.
+               Vector3d vtEdgeV = trTriaB.GetP( ( nVB + 1) % 3) - trTriaB.GetP( nVB) ;
+               double dEdgeLen = vtEdgeV.Len() ;
+               vtEdgeV /= dEdgeLen ;
+               Frame3d frCyl ;
+               frCyl.Set( trTriaB.GetP( nVB), vtEdgeV) ;
+               if ( CDeSimpleCylTria( frCyl, dSafeDist, dEdgeLen, trTriaA))
+                  return true ;  
+            }
+           // Traslo il triangolo
+            trTriaB.Translate( dSafeDist * trTriaB.GetN()) ;
+         }
+        // Processo il triangolo: se i due triangoli collidono ho finito.
+         if ( CDeTriaTria( trTriaA, trTriaB))
+            return true ;
+        // Segno il triangolo come processato: nTemp = 1
+         pSrfB->SetTempInt( nTB, 1) ;
+      }
+   }
+  // Non c'è interferenza
+   return false ;
+}

CDeConeFrustumClosedSurfTm.cpp

@@ -1,12 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : CDCylSurfTm.cpp      Data : 09.11.20        Versione : 
+// File : CDeConeFrustumClosedSurfTm.cpp  Data : 24.031.24  Versione : 2.6c2 
 // Contenuto : Implementazione della verifica di collisione tra
 //             Cone e Closed SurftriMesh.
 //
 //
 // Modifiche : 09.11.20 LM Creazione modulo.
+//             24.03.24 DS Aggiunta TestConeFrustumSurfTm.
 //
 //
 //----------------------------------------------------------------------------
@@ -69,4 +70,44 @@ CDeConeFrustumClosedSurfTm( const Frame3d& frCone, double dBaseRad, double dTopR
    DistPointSurfTm DistConeCenSurfCalc( ptConeCen, Stm) ;
   // Se il tronco di cono è interno c'è collisione
    return DistConeCenSurfCalc.IsPointInside() ;
-}
+}
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra il tronco di cono e la superficie : restituisce true in caso di interferenza.
+//----------------------------------------------------------------------------
+bool
+TestConeFrustumSurfTm( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
+                       const ISurfTriMesh& Stm, double dSafeDist)
+{
+  // Se il tronco di cono non è ben definito non ha senso proseguire
+   if ( max( dBaseRad, dTopRad) < EPS_SMALL  ||  dHeight < EPS_SMALL)
+      return true ;
+  // Se superficie non valida, non ha senso proseguire
+   if ( ! Stm.IsValid())
+      return true ;
+  // Recupero BBox della trimesh
+   BBox3d b3Surf = Stm.GetAllTriaBox() ;
+  // Calcolo il BBox del tronco di cono
+   double dMaxRad = max( dBaseRad, dTopRad) ;
+   BBox3d b3ConeL( Point3d( -dMaxRad, -dMaxRad, 0),
+                   Point3d( dMaxRad, dMaxRad, dHeight)) ;
+   if ( dSafeDist > EPS_SMALL)
+      b3ConeL.Expand( dSafeDist) ;
+   BBox3d b3Cone = GetToGlob( b3ConeL, frCone) ;
+  // Se i BBox non interferiscono, non c'è collisione
+   if ( ! b3Surf.Overlaps( b3Cone)  ||  ! b3Surf.Overlaps( frCone, b3ConeL))
+      return false ;
+  // Recupero i triangoli che interferiscono con il box del cono
+   INTVECTOR vT ;
+   Stm.GetAllTriaOverlapBox( b3Cone, vT) ;
+  // Verifico se il tronco di cono interferisce con i triangoli del poliedro presenti nel suo BBox
+   for ( int nT : vT) {
+      Triangle3d trTria ;
+      if ( Stm.GetTriangle( nT, trTria)) {
+         if ( CDeConeFrustumTria( frCone, dBaseRad, dTopRad, dHeight, trTria, dSafeDist))
+            return true ;
+      }
+   }
+  // Non c'è interferenza
+   return false ;
+}

CDeConeFrustumTria.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : CDeConTria.cpp   Data : 28.10.20     Versione : 2.2k1
+// File : CDeConeFrustumTria.h   Data : 28.10.20     Versione : 2.2k1
 // Contenuto : Dichiarazione della verifica di collisione tra 
 //             Cone e Triangle3d.
 //

CDeConvexTorusClosedSurfTm.cpp

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : CDeConvexTorusTria.cpp      Data : 18.11.20    Versione : 
+// File : CDeConvexTorusTria.cpp      Data : 24.03.24    Versione : 2.6c2
 // Contenuto : Implementazione funzione verifica collisione tra
 //             toro convesso e SurfTriMesh.
 //
 // Modifiche : 18.11.20 LM Creazione modulo.
-//
+//             24.03.24 DS Aggiunta TestConvexTorusSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -66,3 +66,42 @@ CDeConvexTorusClosedSurfTm( const Frame3d& frTorus, double dRad1, double dRad2,
   // Se il toro è interno c'è collisione
    return ( DistConeOrigSurfCalc.IsPointInside()) ;
 }
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra il toro convesso e la superficie : restituisce true in caso di interferenza
+//----------------------------------------------------------------------------
+bool
+TestConvexTorusSurfTm( const Frame3d& frTorus, double dRad1, double dRad2,
+                       const ISurfTriMesh& Stm, double dSafeDist)
+{
+  // I raggi devono essere non nulli
+   if ( dRad1 < EPS_SMALL  ||  dRad2 < EPS_SMALL)
+      return true ;
+  // Se superficie non valida, non ha senso proseguire
+   if ( ! Stm.IsValid())
+      return true ;
+  // Box della superficie
+   BBox3d b3Surf = Stm.GetAllTriaBox() ;
+  // Box del toro (sempre completo)
+   BBox3d b3TorusL( Point3d( -dRad1 - dRad2, -dRad1 - dRad2, -dRad2),
+                    Point3d(  dRad1 + dRad2,  dRad1 + dRad2,  dRad2)) ;
+   if ( dSafeDist > EPS_SMALL)
+      b3TorusL.Expand( dSafeDist) ;
+   BBox3d b3Torus = GetToGlob( b3TorusL, frTorus) ;
+  // Se i BBox non interferiscono, non c'è collisione
+   if ( ! b3Surf.Overlaps( b3Torus)  ||  ! b3Surf.Overlaps( frTorus, b3TorusL))
+      return false ;
+  // Recupero i triangoli che interferiscono con il box del toro
+   INTVECTOR vT ;
+   Stm.GetAllTriaOverlapBox( b3Torus, vT) ;
+  // Verifico se il toro interferisce con i triangoli del poliedro presenti nel suo BBox
+   for ( int nT : vT) {
+      Triangle3d trTria ;
+      if ( Stm.GetTriangle( nT, trTria)) {
+         if ( CDeConvexTorusTria( frTorus, dRad1, dRad2, CT_TOT, trTria, dSafeDist))
+            return true ;
+      }
+   }
+  // Non c'è interferenza
+   return false ;
+}

CDeCylClosedSurfTm.cpp

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : CDCylSurfTm.cpp      Data : 15.02.24        Versione : 2.6b2
+// File : CDeCylClosedSurfTm.cpp      Data : 24.03.24        Versione : 2.6c2
 // Contenuto : Implementazione della verifica di collisione tra
 //             Cylinder e Closed SurftriMesh.
 //
 //
 // Modifiche : 09.01.20 DS Creazione modulo.
-//
+//             24.03.24 DS Aggiunta TestCylSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -73,3 +73,46 @@ CDeCylClosedSurfTm( const Frame3d& frCyl, double dR, double dH, const ISurfTriMe
   // Se il cilindro è interno c'è collisione
    return ( DistCylCenSurfCalc.IsPointInside()) ;
 }
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra il cilindro e la superficie : restituisce true in caso di interferenza
+//----------------------------------------------------------------------------
+bool
+TestCylSurfTm( const Frame3d& frCyl, double dR, double dH, const ISurfTriMesh& Stm, double dSafeDist)
+{
+  // Il cilindro deve essere ben definito
+   if ( dR < EPS_SMALL  ||  dH < EPS_SMALL)
+      return true ;
+  // Se superficie non valida, non ha senso proseguire
+   if ( ! Stm.IsValid())
+      return true ;
+  // Recupero BBox della superficie poligonale
+   BBox3d b3Poly = Stm.GetAllTriaBox() ;
+  // Sistemazioni cilindro
+   Frame3d frMyCyl = frCyl ;
+   if ( dH < 0) {
+      frMyCyl.Translate( dH * frMyCyl.VersZ()) ;
+      dH = -dH ;
+   }
+  // Calcolo il BBox del cilindro
+   BBox3d b3CylL( Point3d( -dR, -dR, 0),
+                  Point3d(  dR,  dR, dH)) ;
+   if ( dSafeDist > EPS_SMALL)
+      b3CylL.Expand( dSafeDist) ;
+   BBox3d b3Cyl = GetToGlob( b3CylL, frMyCyl) ;
+  // Se i BBox non interferiscono, non c'è interferenza
+   if ( ! b3Poly.Overlaps( b3Cyl)  ||  ! b3Poly.Overlaps( frMyCyl, b3CylL))
+      return false ;
+  // Verifico se il cilindro interferisce con i triangoli del poliedro presenti nel suo BBox
+   INTVECTOR vT ;
+   Stm.GetAllTriaOverlapBox( b3Cyl, vT) ;
+   for ( int nT : vT) {
+      Triangle3d Tria ;
+      if ( Stm.GetTriangle( nT, Tria)) {
+         if ( CDeCylTria( frMyCyl, dR, dH, Tria, dSafeDist))
+            return true ;
+      }
+   }
+  // Non c'è interferenza
+   return false ;
+}

CDeRectPrismoidClosedSurfTm.cpp

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : CDePyramidClosedSurfTm.h      Data : 09.11.20    Versione : 
+// File : CDeRectPrismoidClosedSurfTm.h    Data : 24.03.24  Versione : 2.6c2
 // Contenuto : Implementazione funzione verifica collisione tra
 //             Prismoide a basi rettangolari e Closed SurfTriMesh.
 //
 // Modifiche : 09.11.20 LM Creazione modulo.
-//
+//             24.03.24 DS Aggiunta TestRectPrismoidSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -74,3 +74,48 @@ CDeRectPrismoidClosedSurfTm( const Frame3d& frPrismoid, double dLenghtBaseX, dou
   // C'è collisione se il tronco di piramide è interno
    return ( DistPyrCenSurfCalc.IsPointInside()) ;
 }
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra il Prismoide a basi rettangolari e la superficie : restituisce true in caso di interferenza.
+//----------------------------------------------------------------------------
+bool
+TestRectPrismoidSurfTm( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
+                        double dLenghtTopX, double dLenghtTopY, double dHeight,
+                        const ISurfTriMesh& Stm, double dSafeDist)
+{
+  // Se il tronco di piramide non è definito non ha senso proseguire.
+   if ( max( dLenghtBaseX, dLenghtTopX) < EPS_SMALL  ||
+        max( dLenghtBaseY, dLenghtTopY) < EPS_SMALL  ||
+        dHeight < EPS_SMALL)
+      return true ;
+  // Se superficie non valida, non ha senso proseguire
+   if ( ! Stm.IsValid())
+      return true ;
+  // Recupero BBox della trimesh
+   BBox3d b3Surf = Stm.GetAllTriaBox() ;
+  // Calcolo il BBox del tronco di piramide
+   double dMaxLenX = max( dLenghtBaseX, dLenghtTopX) ;
+   double dMaxLenY = max( dLenghtBaseY, dLenghtTopY) ;
+   BBox3d b3PyrL( Point3d( -dMaxLenX / 2, -dMaxLenY / 2, 0.),
+                  Point3d(  dMaxLenX / 2,  dMaxLenY / 2, dHeight)) ;
+   if ( dSafeDist > EPS_SMALL)
+      b3PyrL.Expand( dSafeDist) ;
+   BBox3d b3Pyr = GetToGlob( b3PyrL, frPrismoid) ;
+  // Se i BBox non interferiscono, non c'è collisione
+   if ( ! b3Surf.Overlaps( b3Pyr)  ||  ! b3Surf.Overlaps( frPrismoid, b3PyrL))
+      return false ;
+  // Recupero i triangoli che interferiscono con il box del tronco di piramide.
+   INTVECTOR vT ;
+   Stm.GetAllTriaOverlapBox( b3Pyr, vT) ;
+  // Verifico se il tronco di piramide interferisce con i triangoli del poliedro presenti nel suo BBox
+   for ( int nT : vT) {
+      Triangle3d trTria ; 
+      if ( Stm.GetTriangle( nT, trTria)) {
+         if ( CDeRectPrismoidTria( frPrismoid, dLenghtBaseX, dLenghtBaseY, dLenghtTopX, dLenghtTopY, dHeight,
+                                    trTria, dSafeDist))
+            return true ;
+      }
+   }
+  // Non c'è interferenza
+   return false ;
+}

CDeSpheClosedSurfTm.cpp

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : CDCylSurfTm.cpp      Data : 09.01.20        Versione : 2.2a2
+// File : CDCylSurfTm.cpp      Data : 24.03.24        Versione : 2.6c2
 // Contenuto : Implementazione della verifica di collisione tra
 //             Sphere e Closed SurftriMesh.
 //
 //
 // Modifiche : 09.01.20 DS Creazione modulo.
-//
+//             24.03.24 DS Aggiunta TestSpheSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -60,3 +60,38 @@ CDeSpheClosedSurfTm( const Point3d& ptCen, double dR, const ISurfTriMesh& Stm, d
   // C'è collisione se la sfera è interna.
    return ( DistCenSurfCalc.IsPointInside()) ;
 }
+
+//----------------------------------------------------------------------------
+// Verifica l'interferenza tra la sfera e la superficie : restituisce true in caso di interferenza
+//----------------------------------------------------------------------------
+bool
+TestSpheSurfTm( const Point3d& ptCen, double dR, const ISurfTriMesh& Stm, double dSafeDist)
+{
+  // Il raggio deve essere non nullo
+   if ( dR < EPS_SMALL)
+      return true ;
+  // Se superficie non valida, non ha senso proseguire
+   if ( ! Stm.IsValid())
+      return true ;
+  // Recupero BBox del poliedro
+   BBox3d b3Poly = Stm.GetAllTriaBox() ;
+  // Calcolo il BBox della sfera
+   BBox3d b3Sphe( ptCen, dR) ;
+   if ( dSafeDist > EPS_SMALL)
+      b3Sphe.Expand( dSafeDist) ;
+  // Se i BBox non interferiscono, non c'è collisione
+   if ( ! b3Sphe.Overlaps( b3Poly))
+      return false ;
+  // Verifico se la sfera interferisce con i triangoli del poliedro presenti nel suo BBox
+   INTVECTOR vT ;
+   Stm.GetAllTriaOverlapBox( b3Sphe, vT) ;
+   for ( int nT : vT) {
+      Triangle3d Tria ;
+      if ( Stm.GetTriangle( nT, Tria)) {
+         if ( CDeSpheTria( ptCen, dR, Tria, dSafeDist))
+            return true ;
+      }
+   }
+  // Non c'è interferenza
+   return false ;
+}

CurveArc.cpp

@@ -189,7 +189,7 @@ CurveArc::Set3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d&
   // calcolo del versore normale
    m_VtN = vtA ^ vtB ;
    double dNSqLen = m_VtN.SqLen() ;
-   // se i punti sono praticamente allineati non si può calcolare la circonferenza
+   // se i punti sono praticamente allineati non si può calcolare la circonferenza
    if ( ! m_VtN.Normalize( EPS_ZERO))
       return false ;
   // calcolo del centro
@@ -216,17 +216,17 @@ CurveArc::Set3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d&
       if ( ! m_VtS.GetRotation( ( ptEnd - m_PtCen), m_VtN, dAng2Deg, bDet2)  ||  ! bDet2)
          return false ;
      // deduzione dell'angolo al centro
-      // se uno dei due angoli è nullo, errore
+      // se uno dei due angoli è nullo, errore
       if ( abs( dAng1Deg) < EPS_ANG_SMALL  ||  abs( dAng2Deg) < EPS_ANG_SMALL)
          return false ;
-      // se i due angoli hanno lo stesso segno e Ang1 è minore di Ang2 in modulo
+      // se i due angoli hanno lo stesso segno e Ang1 è minore di Ang2 in modulo
       else if ( dAng1Deg * dAng2Deg > 0  &&  abs( dAng1Deg) < abs( dAng2Deg))
          m_dAngCenDeg = dAng2Deg ;
-     // altrimenti hanno segno opposto oppure Ang1 è maggiore di Ang2 in modulo
+     // altrimenti hanno segno opposto oppure Ang1 è maggiore di Ang2 in modulo
       else
          m_dAngCenDeg = - _copysign( ANG_FULL, dAng2Deg) + dAng2Deg ;
    }
-  // non c'è DeltaN
+  // non c'è DeltaN
    m_dDeltaN = 0 ;
 
   // imposto ricalcolo di Voronoi
@@ -255,7 +255,7 @@ CurveArc::Set2PNB( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& v
    Vector3d vtDiff = ptFin - ptIni ;
    if ( vtDiff.IsSmall())
       return false ;
-  // deltaN eventuale ( è componente parallela a VtN)
+  // deltaN eventuale ( è componente parallela a VtN)
    m_dDeltaN = vtDiff * m_VtN ;
    vtDiff -= m_dDeltaN * m_VtN ;
    if ( abs( m_dDeltaN) < EPS_SMALL)
@@ -304,7 +304,7 @@ CurveArc::Set2PD( const Point3d& ptStart, const Point3d& ptEnd, double dDirStart
   // calcolo del versore normale
    m_VtN = vtA ^ vtB ;
    double dNSqLen = m_VtN.SqLen() ;
-   // se tangente e punti sono praticamente allineati non si può calcolare la circonferenza
+   // se tangente e punti sono praticamente allineati non si può calcolare la circonferenza
    if ( ! m_VtN.Normalize( EPS_ZERO))
       return false ;
   // calcolo del centro
@@ -321,7 +321,7 @@ CurveArc::Set2PD( const Point3d& ptStart, const Point3d& ptEnd, double dDirStart
    double dAng1Deg ;
    if ( ! m_VtS.GetRotation( ( ptEnd - m_PtCen), m_VtN, dAng1Deg, bDet1)  ||  ! bDet1)
       return false ;
-   // poichè il senso di rotazione è sempre CCW, se l'angolo è negativo prendo il suo complemento al giro
+   // poichè il senso di rotazione è sempre CCW, se l'angolo è negativo prendo il suo complemento al giro
     if ( dAng1Deg < 0)
        m_dAngCenDeg = ANG_FULL + dAng1Deg ;
     else
@@ -414,7 +414,7 @@ CurveArc::Set2PRS( const Point3d& ptStart, const Point3d& ptEnd, double dRad, bo
    bool bDet ;
    if ( ! m_VtS.GetRotation( ( ptEnd - m_PtCen), m_VtN, m_dAngCenDeg, bDet)  ||  ! bDet)
       return false ;
-   // quando è 180deg il segno è determinato solo dal senso
+   // quando è 180deg il segno è determinato solo dal senso
    if ( abs( m_dAngCenDeg - ANG_STRAIGHT) < 10 * EPS_ANG_SMALL  &&
         ( ( bCCW  &&  m_dAngCenDeg < 0)  ||
           ( ! bCCW  &&  m_dAngCenDeg > 0)))
@@ -529,7 +529,7 @@ CurveArc::SetC2P( const Point3d& ptCen, const Point3d& ptStart, const Point3d& p
    if ( m_dRad < EPS_ZERO)
       return false ;
    m_VtS /= m_dRad ;
-  // calcolo l'angolo al centro (la funzione trova sempre il più piccolo)
+  // calcolo l'angolo al centro (la funzione trova sempre il più piccolo)
    bool bDet ;
    if ( ! m_VtS.GetRotation( ( ptNearEnd - m_PtCen), m_VtN, m_dAngCenDeg, bDet)  ||  ! bDet)
       return false ;
@@ -733,7 +733,7 @@ CurveArc::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
   // assegno il box nel riferimento
@@ -820,7 +820,7 @@ CurveArc::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
       }
    }
    
-  // se c'è estrusione, devo tenerne conto
+  // se c'è estrusione, devo tenerne conto
    if ( ! m_VtExtr.IsSmall()  &&  abs( m_dThick) > EPS_SMALL) {
       Vector3d vtFrExtr = m_VtExtr ;
       vtFrExtr.ToGlob( frRef) ;
@@ -838,7 +838,7 @@ bool
 CurveArc::Validate( void)
 {
    if ( m_nStatus == TO_VERIFY) {
-     // limito l'angolo al centro a un giro se è piatto ( non è elica)
+     // limito l'angolo al centro a un giro se è piatto ( non è elica)
       if ( abs( m_dDeltaN) < EPS_SMALL) {
          if ( m_dAngCenDeg > ANG_FULL)
             m_dAngCenDeg = ANG_FULL ;
@@ -1167,7 +1167,7 @@ CurveArc::ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, PolyLin
          return false ;
    }
 
-  // se necessario, sistemo per convessità dalla parte ammessa
+  // se necessario, sistemo per convessità dalla parte ammessa
    if ( nType == APL_RIGHT_CONVEX  ||  nType == APL_LEFT_CONVEX) {
       if ( ! PL.MakeConvex( vtExtr, ( nType == APL_LEFT_CONVEX)))
          return false ;
@@ -1241,7 +1241,7 @@ CurveArc::CopyParamRange( double dUStart, double dUEnd) const
       return nullptr ;
   // se il parametro start supera quello di end
    if ( dUStart > dUEnd - EPS_PARAM) {
-     // se curva aperta, il trim la cancella completamente quindi non resta alcunchè
+     // se curva aperta, il trim la cancella completamente quindi non resta alcunchè
       if ( ! IsClosed())
          return nullptr ;
      // se curva chiusa, il trim si avvolge attorno al punto di giunzione
@@ -1331,7 +1331,7 @@ bool
 CurveArc::MyExtendedOffset( double dDist, bool bAll, int nType)
 {
   // bAll == true fa accettare raggi nulli ==> da usare solo internamente 
-  // quando si è sicuri di aumentare subito il raggio o di cancellare
+  // quando si è sicuri di aumentare subito il raggio o di cancellare
 
   // la curva deve essere validata
    if ( m_nStatus != OK)
@@ -1409,7 +1409,7 @@ CurveArc::ModifyEnd( const Point3d& ptNewEnd)
    ptOldEndIntr.ToLoc( frIntr) ;
    Point3d ptEndIntr = ptNewEnd ;
    ptEndIntr.ToLoc( frIntr) ;
-  // se coincidono nel piano XY, è cambiato solo il deltaN
+  // se coincidono nel piano XY, è cambiato solo il deltaN
    if ( AreSamePointXYExact( ptOldEndIntr, ptEndIntr)) {
       m_dDeltaN += ptEndIntr.z - ptOldEndIntr.z ;
    }
@@ -1615,8 +1615,10 @@ CurveArc::Translate( const Vector3d& vtMove)
    if ( m_nStatus != OK)
       return false ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
+  // traslo Voronoi
+   if ( m_pVoronoiObj != nullptr)      
+      m_pVoronoiObj->Translate( vtMove) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1634,12 +1636,14 @@ CurveArc::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, dou
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità dell'asse di rotazione
+  // verifico validità dell'asse di rotazione
    if ( vtAx.IsSmall())
       return false ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
+  // ruoto Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1787,7 +1791,7 @@ CurveArc::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità del piano di specchiatura
+  // verifico validità del piano di specchiatura
    if ( vtNorm.IsSmall())
       return false ;
 
@@ -1815,11 +1819,11 @@ CurveArc::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vt
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità dei parametri
+  // verifico validità dei parametri
    if ( vtNorm.IsSmall()  ||  vtDir.IsSmall())
       return false ;
 
-  // possibile solo se l'arco è piatto e il piano di scorrimento coincide con quello dell'arco
+  // possibile solo se l'arco è piatto e il piano di scorrimento coincide con quello dell'arco
    if ( ! ( abs( m_dDeltaN) < EPS_SMALL)  ||  
         ! AreSameOrOppositeVectorExact( m_VtN, vtNorm))
       return false ;
@@ -1849,16 +1853,18 @@ CurveArc::ToGlob( const Frame3d& frRef)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
+  // se frame identità, non devo fare alcunché
    if ( IsGlobFrame( frRef))
       return true ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->ToGlob( frRef) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1876,16 +1882,18 @@ CurveArc::ToLoc( const Frame3d& frRef)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
+  // se frame identità, non devo fare alcunché
    if ( IsGlobFrame( frRef))
       return true ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->ToLoc( frRef) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1903,16 +1911,18 @@ CurveArc::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dei frame
+  // verifico validità dei frame
    if ( frOri.GetType() == Frame3d::ERR  ||  frDest.GetType() == Frame3d::ERR)
       return false ;
 
-  // se i due riferimenti coincidono, non devo fare alcunché
+  // se i due riferimenti coincidono, non devo fare alcunché
    if ( AreSameFrame( frOri, frDest))
       return true ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->LocToLoc( frOri, frDest) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1989,12 +1999,12 @@ CurveArc::MyCalcPointParamPosiz( const Point3d& ptP, double& dU, int& nPos, doub
   // verifica posizione punto su arco
    nPos = PP_NULL ;         // fuori
    if ( abs( DiffAngle( dAngDeg, 0) * DEGTORAD * m_dRad) < dLinTol) {
-      nPos = ( IsACircle() ? PP_MID : PP_START) ;   // se cerchio è interno, altrimenti vicino a inizio
+      nPos = ( IsACircle() ? PP_MID : PP_START) ;   // se cerchio è interno, altrimenti vicino a inizio
       dU = AngleNearAngle( dAngDeg, 0) / m_dAngCenDeg ;
       dU = max( dU, 0.) ;
    }
    else if ( abs( DiffAngle( dAngDeg, m_dAngCenDeg) * DEGTORAD * m_dRad) < dLinTol) {
-      nPos = ( IsACircle() ? PP_MID : PP_END) ;     // se cerchio è interno, altrimenti vicino a fine
+      nPos = ( IsACircle() ? PP_MID : PP_END) ;     // se cerchio è interno, altrimenti vicino a fine
       dU = AngleNearAngle( dAngDeg, m_dAngCenDeg) / m_dAngCenDeg ;
       dU = min( dU, 1.) ;
    }
@@ -2011,7 +2021,7 @@ CurveArc::ChangeRadius( double dNewRadius)
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità del raggio
+  // verifico validità del raggio
    if ( ! ( dNewRadius > EPS_SMALL  &&  dNewRadius < MAX_ARC_RAD))
       return false ;
   
@@ -2057,7 +2067,7 @@ CurveArc::ChangeAngCenter( double dNewAngCenDeg)
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico accettabilità angolo
+  // verifico accettabilità angolo
    if ( ! ( abs( m_dAngCenDeg) > EPS_ANG_ZERO))
       return false ;
 
@@ -2153,11 +2163,11 @@ CurveArc::Flip( void)
 
 //----------------------------------------------------------------------------
 // Oggetto locale per approssimazione di archi
-// Approx interna è quella cordale standard.
-// Approx esterna è quella tangente a inizio e fine con metà tratto e un punto in più.
+// Approx interna è quella cordale standard.
+// Approx esterna è quella tangente a inizio e fine con metà tratto e un punto in più.
 // I punti si calcolano a partire dal triangolo tra due punti consecutivi interni e il centro,
 // usando il versore medio dal centro e moltiplicandolo per il coefficiente ( 2 / ( 1 + cosA)).
-// Il versore dell'ultimo punto è già stato calcolato per il penultimo.
+// Il versore dell'ultimo punto è già stato calcolato per il penultimo.
 //----------------------------------------------------------------------------
 ArcApproxer::ArcApproxer( double dLinTol, double dAngTolDeg, bool bInside, const CurveArc& arArc)
 {
@@ -2281,7 +2291,7 @@ CurveArc::GetVoronoiObject() const
    if ( m_nStatus != OK)
       return nullptr ;
 
-  // se non è stato calcolato, lo calcolo
+  // se non è stato calcolato, lo calcolo
    if ( m_pVoronoiObj == nullptr)
       CalcVoronoiObject() ;
 

CurveArc.h

@@ -186,7 +186,10 @@ class CurveArc : public ICurveArc, public IGeoObjRW
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
+      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
+      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
+      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       CurveArc( void) ;
@@ -200,13 +203,13 @@ class CurveArc : public ICurveArc, public IGeoObjRW
       bool MyExtendedOffset( double dDist, bool bAll, int nType = OFF_FILLET) ;
       bool MyCalcPointParamPosiz( const Point3d& ptP, double& dU, int& nPos, double dLinTol) const ;
       Voronoi* GetVoronoiObject( void) const ;
+      void ResetVoronoiObject( void) const ;
 
    private :
       bool CopyFrom( const CurveArc& caSrc) ;
       bool Validate( void) ;
       bool GetDir( double dU, Vector3d& vtDir) const ;      
       bool CalcVoronoiObject( void) const ;
-      void ResetVoronoiObject( void) const ;
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
@@ -222,7 +225,7 @@ class CurveArc : public ICurveArc, public IGeoObjRW
       double   m_dDeltaN ;             // variazione di quota lungo VtN della fine rispetto all'inizio
       Vector3d m_VtExtr ;              // vettore estrusione (normalmente coincide con m_VtN)
       double   m_dThick ;              // spessore
-      int      m_nTempProp[2] ;        // vettore proprietà temporanee 
+      int      m_nTempProp[2] ;        // vettore proprietà temporanee 
       double   m_dTempParam[2] ;       // vettore parametri temporanei
       mutable Voronoi* m_pVoronoiObj ; // Voronoi
 } ;

CurveAux.cpp

@@ -2,7 +2,7 @@
 //  EgalTech 2013-2013
 //----------------------------------------------------------------------------
 // File : CurveAux.cpp      Data : 22.11.13          Versione : 1.3a1
-// Contenuto : Implementazione di alcune funzioni di utilità per le curve.
+// Contenuto : Implementazione di alcune funzioni di utilità per le curve.
 //
 //
 //
@@ -39,7 +39,7 @@ IsClosed( const ICurve& crvC)
 bool
 IsValidParam( const ICurve& crvC, double dPar, ICurve::Side nSide)
 {
-  // recupero l'intervallo di validità del parametro
+  // recupero l'intervallo di validità del parametro
    double dStart, dEnd ;
    if ( ! crvC.GetDomain( dStart, dEnd))
       return false ;
@@ -60,11 +60,11 @@ IsValidParam( const ICurve& crvC, double dPar, ICurve::Side nSide)
 bool
 IsStartParam( const ICurve& crvC, double dPar)
 {
-  // recupero l'intervallo di validità del parametro
+  // recupero l'intervallo di validità del parametro
    double dStart, dEnd ;
    if ( ! crvC.GetDomain( dStart, dEnd))
       return false ;
-  // se il parametro  non è nell'intorno dell'inizio
+  // se il parametro  non è nell'intorno dell'inizio
    if ( abs( dPar - dStart) > EPS_PARAM)
       return false ;
    return true ;
@@ -74,11 +74,11 @@ IsStartParam( const ICurve& crvC, double dPar)
 bool
 IsEndParam( const ICurve& crvC, double dPar)
 {
-  // recupero l'intervallo di validità del parametro
+  // recupero l'intervallo di validità del parametro
    double dStart, dEnd ;
    if ( ! crvC.GetDomain( dStart, dEnd))
       return false ;
-  // se il parametro  non è nell'intorno della fine
+  // se il parametro  non è nell'intorno della fine
    if ( abs( dPar - dEnd) > EPS_PARAM)
       return false ;
    return true ;
@@ -98,7 +98,7 @@ GetNearestExtremityToPoint( const Point3d& ptP, const ICurve& Curve, bool& bStar
       return false ;
   // se curva aperta
    if ( ! AreSamePointApprox( ptStart, ptEnd)) {
-     // è il più vicino tra inizio e fine
+     // è il più vicino tra inizio e fine
       bStart = ( SqDist( ptP, ptStart) <= SqDist( ptP, ptEnd)) ;
       return true ;
    }
@@ -186,7 +186,7 @@ GetPointTang( const ICurve& crvC, double dU, ICurve::Side nS, Point3d& ptPos, Ve
       return false ;
    double dUmod = dU + ( nS == ICurve::FROM_MINUS ? -1 : +1) * 100 * EPS_PARAM ;
    Point3d ptDummy ;
-  // se anche la derivata seconda è nulla, provo a spostarmi di poco
+  // se anche la derivata seconda è nulla, provo a spostarmi di poco
    if ( ! vtTang.Normalize(  EPS_ZERO)) {
       if ( ! crvC.GetPointD1D2( dUmod, nS, ptDummy, &vtDummy, &vtTang))
          return false ;
@@ -263,14 +263,14 @@ GetPointDiffGeom( const ICurve& crvC, double dU, ICurve::Side nS, CrvPointDiffGe
 bool
 ImproveCurveParamAtPoint( double& dU, const Point3d& ptP, const ICurve* pCrv)
 {
-  // Da usare quando il parametro è già molto vicino a quello esatto
+  // Da usare quando il parametro è già molto vicino a quello esatto
 
   // calcolo il punto della curva in corrispondenza al parametro
    Point3d ptQ ;
    Vector3d vtD ;
    if ( ! pCrv->GetPointD1D2( dU, ICurve::FROM_MINUS, ptQ, &vtD))
       return false ;
-  // se sono uguali, è già tutto ok
+  // se sono uguali, è già tutto ok
    if ( AreSamePointExact( ptP, ptQ))
       return true ;
   // se derivata nulla, non posso migliorare
@@ -332,7 +332,7 @@ CurveGetArea( const ICurve& crvC, Plane3d& plPlane, double& dArea)
 bool
 CurveDump( const ICurve& crvC, string& sOut, bool bMM, const char* szNewLine)
 {
-  // verifico validità curva
+  // verifico validità curva
    if ( ! crvC.IsValid())
       return false ;
 
@@ -455,7 +455,7 @@ ArcToBezierCurve( const ICurve* pCrv)
 ICurve*
 CurveToNoArcsCurve( const ICurve* pCrv)
 {
-  // verifico validità curva
+  // verifico validità curva
    if ( pCrv == nullptr)
       return nullptr ;
   // se arco, devo trasformarlo in curva di Bezier (semplice o composta)
@@ -479,7 +479,7 @@ CurveToNoArcsCurve( const ICurve* pCrv)
 ICurve*
 CurveToArcsPerpExtrCurve( const ICurve* pCrv, double dLinTol, double dAngTolDeg)
 {
-  // verifico validità curva
+  // verifico validità curva
    if ( pCrv == nullptr)
       return nullptr ;
   // se arco in piano non perpendicolare ad estrusione, curva composita o curva di Bezier trasformo 
@@ -524,14 +524,47 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
 
   // se periodica
    if ( cnData.bPeriodic  ||  ! cnData.bClamped) {
+      // se la curva è peridica verifco che effettivamente ci sia un numero di punti ripetituti uguale al grado della curva
+      if ( cnData.bPeriodic ) {
+         bool bRepetead = true ;
+         for ( int i = 0 ; i < cnData.nDeg ; ++i) {
+            if ( ! AreSamePointApprox( cnData.vCP[i], cnData.vCP.end()[-cnData.nDeg + i]) ) {
+               bRepetead = false ;
+               break ;
+            }
+         }
+         if ( ! bRepetead){
+            // se il primo e l'ultimo punto non coincidono allora aggiungo il primo punto in fondo al vettore dei punti di controllo
+            if ( ! AreSamePointApprox( cnData.vCP[0], cnData.vCP.back()) ) {
+               cnData.vCP.push_back( cnData.vCP[0]) ;
+               if ( cnData.bRat)
+                  cnData.vW.push_back( cnData.vW[0]) ;
+            }
+            // se effettivamente ho dei nodi in più da togliere allora li tolgo
+            if ( int( cnData.vU.size()) !=  int(cnData.vCP.size()) + cnData.nDeg - 1) {
+               // devo poi anche togliere i nodi di troppo // presuppongo che la convenzione sia che i nodi di troppo sono alla fine del vettore dei nodi
+               cnData.vU = DBLVECTOR( cnData.vU.begin(), cnData.vU.end() - cnData.nDeg) ;
+               // controlloeventualmente anche i nodi extra
+               // se ne ho due in più ne tolgo uno in cima e uno in fondo
+               if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg + 1 )   // significa che ci sono due nodi extra, uno all'inizio e uno alla fine, da togliere
+                  cnData.vU = vector<double>( cnData.vU.begin() + 1, cnData.vU.end() - 1) ;
+               // se ne ho solo uno in più lo tolgo in cima
+               else if ( cnData.vU.size() == int( cnData.vCP.size()) + cnData.nDeg)
+                  cnData.vU = vector<double>( cnData.vU.begin() + 1, cnData.vU.end()) ;
+            }
+            cnData.bPeriodic = false ;
+            return true ;
+         }
+      }
+
      // va trasformata in non-periodica (clamped)
-     // bisogna aumentare la molteplicità dei nodi u_p-1 e u_(m-p+1) fino ad arrivare al grado della nurbs
+     // bisogna aumentare la molteplicità dei nodi u_p-1 e u_(m-p+1) fino ad arrivare al grado della nurbs
      // e poi scartare nodi e punti fuori dalla regione clamped ( al di fuori della regione u_p-1 -> u_(m-p+1))
 
       // l'agoritmo per l'inserimento dei nodi l' A5.1 del libro delle Nurbs ( Piegl e Tiller), con qualche modifica
-      // agli indici perché uso u_p-1 e u_(m-p+1), anziché u_p e u_m-p
+      // agli indici perché uso u_p-1 e u_(m-p+1), anziché u_p e u_m-p
 
-      // comincio ad aumentare la molteplictià del nodo u_m-p+1
+      // comincio ad aumentare la molteplictià del nodo u_m-p+1
       int nCP = int( cnData.vCP.size()) ;
       int nU = nCP + cnData.nDeg - 1 ;
       int nDeg = cnData.nDeg ;
@@ -540,12 +573,12 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
       DBLVECTOR vBW ;
       vBW.resize( nDeg + 1) ;
 
-     // trovo il nodo di cui aumentare la molteplicità e ne calcolo la molteplicità
+     // trovo il nodo di cui aumentare la molteplicità e ne calcolo la molteplicità
       int b = nU - nDeg - 1 + 1 ;
       int i = b ;
       while ( b > 0  &&  abs( cnData.vU[b] - cnData.vU[b - 1]) < EPS_ZERO)
          -- b ;
-      int mult = min( i - b + 1, nDeg) ; // mi aspetto che sia 1, ma comunque sarà < nDeg
+      int mult = min( i - b + 1, nDeg) ; // mi aspetto che sia 1, ma comunque sarà < nDeg
      // recupero i punti da modificare
       if ( ! cnData.bRat) {
          for ( int i = 0 ; i <= nDeg - mult ; ++ i)
@@ -559,7 +592,7 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
       }
 
      // salvo i punti inalterati
-      int r = nDeg - mult ;  // numero di volte che dovrò inserire il nodo
+      int r = nDeg - mult ;  // numero di volte che dovrò inserire il nodo
       cnData.vCP.resize( nCP + r) ;
       for ( int p = nCP - 1 ; p > b - mult  ; --p) {
          cnData.vCP[r + p] = cnData.vCP[p] ;
@@ -604,12 +637,12 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
       nU = nU + r ;
       nCP = nCP + r ;
 
-     // aumento la molteplicità del punto u_p-1
+     // aumento la molteplicità del punto u_p-1
       b = nDeg - 1 ;
       i = b ;
       while ( b > 0  &&  abs( cnData.vU[b] - cnData.vU[b - 1]) < EPS_ZERO)
          -- b ;
-      mult = min( i - b + 1, nDeg) ; // mi aspetto che sia 1, ma comunque sarà < cnData.nDeg
+      mult = min( i - b + 1, nDeg) ; // mi aspetto che sia 1, ma comunque sarà < cnData.nDeg
      // recupero i punti da modificare
       if ( ! cnData.bRat) {
          for ( int i = 0 ; i <= nDeg - mult  ; ++ i)
@@ -719,7 +752,7 @@ NurbsToBezierCurve( const CNurbsData& cnData)
    if ( ! bOk)
       return nullptr ;
   
-  // se 1 solo intervallo, la Nurbs è già una curva di Bezier
+  // se 1 solo intervallo, la Nurbs è già una curva di Bezier
    if ( nInt == 1) {
      // creo la curva di Bezier
       PtrOwner<CurveBezier> pCrvBez( CreateBasicCurveBezier()) ;
@@ -738,14 +771,14 @@ NurbsToBezierCurve( const CNurbsData& cnData)
                return nullptr ;
          }
       }
-     // se non è una curva ma un punto, la invalido
+     // se non è una curva ma un punto, la invalido
       if ( pCrvBez->IsAPoint())
          pCrvBez->Init( cnData.nDeg, cnData.bRat) ;
      // restituisco la curva
       return Release( pCrvBez) ;
    }
 
-  // altrimenti è equivalente ad una curva composita, la creo
+  // altrimenti è equivalente ad una curva composita, la creo
    PtrOwner<CurveComposite> pCrvCompo( CreateBasicCurveComposite()) ;
    if ( IsNull( pCrvCompo))
       return nullptr ;
@@ -813,7 +846,7 @@ NurbsToBezierCurve( const CNurbsData& cnData)
          return nullptr ;
      // se precedente saltata
       if ( bPrevRejected) {
-        // prendo l'ultimo punto della curva composita per garantire la continuità
+        // prendo l'ultimo punto della curva composita per garantire la continuità
          Point3d ptEnd ;
          if ( pCrvCompo->GetEndPoint( ptEnd))
             vBC[0] = ptEnd ;
@@ -833,13 +866,13 @@ NurbsToBezierCurve( const CNurbsData& cnData)
                return nullptr ;
          }
       }
-     // se è una vera curva, la aggiungo alla curva composita
+     // se è una vera curva, la aggiungo alla curva composita
       if ( ! pCrvBez->IsAPoint()) {
          if ( ! pCrvCompo->AddCurve( Release( pCrvBez)))
             return nullptr ;
          bPrevRejected = false ;
       }
-     // altrimenti è un punto, la cancello
+     // altrimenti è un punto, la cancello
       else {
          pCrvBez.Reset() ;
          bPrevRejected = true ;
@@ -911,7 +944,7 @@ FlattenCurve( const ICurve& crCrv, double dToler, double dAngToler, int nFlag)
    Point3d ptCen ;
    if ( ! crCrv.GetCentroid( ptCen))
       return nullptr ;
-  // Verifico se curva già piatta
+  // Verifico se curva già piatta
    PolyLine PL ;
    if ( ! crCrv.ApproxWithLines( LIN_TOL_FINE, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL_INT, PL))
       return nullptr ;
@@ -924,7 +957,7 @@ FlattenCurve( const ICurve& crCrv, double dToler, double dAngToler, int nFlag)
          bFlat = false ;
       bPoint = PL.GetNextPoint( ptP) ;
    }
-  // Se curva già piatta, la copio ed esco
+  // Se curva già piatta, la copio ed esco
    if ( bFlat) {
       PtrOwner<ICurve> pCrv( crCrv.Clone()) ;
       if ( IsNull( pCrv))
@@ -975,7 +1008,7 @@ ProjectCurveOnPlane( const ICurve& crCrv, const Plane3d& plPlane)
   // determino se curva piana e suo eventuale piano
    Plane3d plCrv ;
    if ( crCrv.IsFlat( plCrv, false, EPS_SMALL / 2)) {
-     // se il piano della curva è parallelo a quello di proiezione
+     // se il piano della curva è parallelo a quello di proiezione
       if ( AreSameOrOppositeVectorExact( plCrv.GetVersN(), plPlane.GetVersN())) {
         // copio la curva
          PtrOwner<ICurve> pCrv( crCrv.Clone()) ;
@@ -1087,3 +1120,22 @@ CalcCurveFatCurve( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, double dRadius, bo
    return pVoronoiObj->CalcFatCurve( vCrvs, dRadius, bSquareEnds, bSquareMids) ; 
 }
 
+//----------------------------------------------------------------------------
+void 
+ResetCurveVoronoi( const ICurve& crvC)
+{
+   switch ( crvC.GetType()) {
+   case CRV_LINE : 
+      GetBasicCurveLine( &crvC)->ResetVoronoiObject() ;
+      break ;
+   case CRV_ARC : 
+      GetBasicCurveArc( &crvC)->ResetVoronoiObject() ;
+      break ;
+   case CRV_BEZIER : 
+      GetBasicCurveBezier( &crvC)->ResetVoronoiObject() ;
+      break ;
+   case CRV_COMPO : 
+      GetBasicCurveComposite( &crvC)->ResetVoronoiObject() ;
+      break ;
+   }
+}

CurveBezier.cpp

@@ -1873,8 +1873,10 @@ CurveBezier::Translate( const Vector3d& vtMove)
    if ( m_nStatus != OK)
       return false ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+  // traslo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->Translate( vtMove) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1897,8 +1899,10 @@ CurveBezier::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng,
    if ( vtAx.IsSmall())
       return false ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+  // ruoto Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2032,8 +2036,10 @@ CurveBezier::ToGlob( const Frame3d& frRef)
    if ( IsGlobFrame( frRef))
       return true ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->ToGlob( frRef) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2061,8 +2067,10 @@ CurveBezier::ToLoc( const Frame3d& frRef)
    if ( IsGlobFrame( frRef))
       return true ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->ToLoc( frRef) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2090,8 +2098,10 @@ CurveBezier::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
    if ( AreSameFrame( frOri, frDest))
       return true ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->LocToLoc( frOri, frDest) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 

CurveBezier.h

@@ -117,7 +117,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
       ICurve* CopyParamRange( double dUStart, double dUEnd) const override ;
       bool Invert( void) override ;
       bool SimpleOffset( double dDist, int nType = OFF_FILLET) override
-              { return false ; }  // l'offset di crvBezier non è crvBezier tranne in casi molto particolari
+              { return false ; }  // l'offset di crvBezier non è crvBezier tranne in casi molto particolari
       bool ModifyStart( const Point3d& ptNewStart) override ;
       bool ModifyEnd( const Point3d& ptNewEnd) override ;
       bool SetExtrusion( const Vector3d& vtExtr) override
@@ -151,7 +151,10 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
+      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
+      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
+      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       CurveBezier( void) ;
@@ -165,6 +168,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
       bool ApproxWithLines( int nStep, PolyLine& PL) const ;
       bool GetApproxLength( double& dLen) const ;
       Voronoi* GetVoronoiObject( void) const ;
+      void ResetVoronoiObject( void) const ;
 
    private :
       bool CopyFrom( const CurveBezier& cbSrc) ;
@@ -183,7 +187,6 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
       bool ToPowerBase( PolynomialPoint3d& pol3P) const ;
       bool ToPowerBase( PolynomialPoint3d& pol3Num, Polynomial& polDen) const ;      
       bool CalcVoronoiObject( void) const ;
-      void ResetVoronoiObject( void) const ;
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
@@ -194,12 +197,12 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
       Status         m_nStatus ;        // stato
       int            m_nDeg ;           // grado
       bool           m_bRat ;           // flag di razionale/polinomiale
-      mutable double m_dParSing ;       // eventuale parametro della singolarità (-1=no, -2=da calcolare)
+      mutable double m_dParSing ;       // eventuale parametro della singolarità (-1=no, -2=da calcolare)
       PNTVECTOR      m_vPtCtrl ;        // vettore dei punti di controllo
       DBLVECTOR      m_vWeCtrl ;        // vettore dei pesi di controllo
       Vector3d       m_VtExtr ;         // vettore estrusione (normalmente coincide con m_VtN)
       double         m_dThick ;         // spessore
-      int            m_nTempProp[2] ;   // vettore proprietà temporanee
+      int            m_nTempProp[2] ;   // vettore proprietà temporanee
       double         m_dTempParam[2] ;  // vettore parametri temporanei
       mutable Voronoi* m_pVoronoiObj ;  // Voronoi
 } ;

CurveComposite.cpp

@@ -186,7 +186,7 @@ CurveComposite::AddCurveByRelocate( CurveComposite& ccSrc, bool bEndOrStart, dou
 bool
 CurveComposite::AddSimpleCurve( ICurve* pSmplCrv, bool bEndOrStart, double dLinTol)
 {
-  // prendo la proprietà del puntatore
+  // prendo la proprietà del puntatore
    PtrOwner<ICurve> pCrv( pSmplCrv) ;
    if ( IsNull( pCrv))
       return false ;
@@ -211,15 +211,15 @@ CurveComposite::AddSimpleCurve( ICurve* pSmplCrv, bool bEndOrStart, double dLinT
    if ( ! pCrv->GetStartPoint( ptCrvStart)  ||  ! pCrv->GetEndPoint( ptCrvEnd))
       return false ;
 
-  // se non è la prima
+  // se non è la prima
    if ( ! m_CrvSmplS.empty()) {
      // se inserita alla fine
       if ( bEndOrStart) {
-        // verifico sia in continuità con il finale attuale
+        // verifico sia in continuità con il finale attuale
          Point3d ptEnd ;
          GetEndPoint( ptEnd) ;
          if ( ! AreSamePointEpsilon( ptCrvStart, ptEnd, EPS_CONNECT)) {
-           // se in tolleranza, modifico l'inizio dell'entità
+           // se in tolleranza, modifico l'inizio dell'entità
             if ( SqDist( ptCrvStart, ptEnd) < ( dLinTol * dLinTol)) {
               // lunghezza della curva originale
                double dOldLen ; pCrv->GetLength( dOldLen) ;
@@ -237,11 +237,11 @@ CurveComposite::AddSimpleCurve( ICurve* pSmplCrv, bool bEndOrStart, double dLinT
       }
      // altrimenti inserita all'inizio
       else {
-        // verifico sia in continuità con l'iniziale attuale
+        // verifico sia in continuità con l'iniziale attuale
          Point3d ptStart ;
          GetStartPoint( ptStart) ;
          if ( ! AreSamePointEpsilon( ptCrvEnd, ptStart, EPS_CONNECT)) {
-           // se in tolleranza, modifico la fine dell'entità
+           // se in tolleranza, modifico la fine dell'entità
             if ( SqDist( ptCrvEnd, ptStart) < ( dLinTol * dLinTol)) {
               // lunghezza della curva originale
                double dOldLen ; pCrv->GetLength( dOldLen) ;
@@ -286,7 +286,7 @@ CurveComposite::Close( void)
    if ( ! GetStartPoint( ptStart)  ||
         ! GetEndPoint( ptEnd))
       return false ;
-  // se distanza inferiore al limite ridotto, non faccio alcunché
+  // se distanza inferiore al limite ridotto, non faccio alcunché
    if ( AreSamePointEpsilon( ptStart, ptEnd, EPS_CONNECT))
       return true ;
   // se molto vicini li modifico
@@ -324,7 +324,7 @@ CurveComposite::FromSplit( const ICurve& cCrv, int nParts)
    if ( ! cCrv.IsValid()  ||  ! cCrv.IsSimple())
       return false ;
 
-  // se 1 parte o meno, non fa alcunchè
+  // se 1 parte o meno, non fa alcunchè
    if ( nParts <= 1)
       return true ;
 
@@ -565,11 +565,11 @@ CurveComposite::Clone( void) const
 bool
 CurveComposite::CopyFrom( const IGeoObj* pGObjSrc)
 {
-  // se sorgente è una curva composita
+  // se sorgente è una curva composita
    const CurveComposite* pCC = GetBasicCurveComposite( pGObjSrc) ;
    if ( pCC != nullptr)
       return CopyFrom( *pCC) ;
-  // se sorgente è un'altro tipo di curva
+  // se sorgente è un'altro tipo di curva
    const ICurve* pCrv = ::GetCurve( pGObjSrc) ;
    if ( pCrv != nullptr) {
       Clear() ;
@@ -782,7 +782,7 @@ CurveComposite::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
      // passo alla curva successiva
       pCrvSmpl = GetNextCurve() ;
    }
-  // se c'è estrusione, devo tenerne conto (curve componenti sempre con vtExtr e dThick nulli)
+  // se c'è estrusione, devo tenerne conto (curve componenti sempre con vtExtr e dThick nulli)
    if ( ! m_VtExtr.IsSmall()  &&  abs( m_dThick) > EPS_SMALL) {
       Point3d ptMinExtr = b3Loc.GetMin() + m_VtExtr * m_dThick ;
       Point3d ptMaxExtr = b3Loc.GetMax() + m_VtExtr * m_dThick ;
@@ -799,7 +799,7 @@ CurveComposite::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
   // inizializzo il box
@@ -816,7 +816,7 @@ CurveComposite::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
      // passo alla curva successiva
       pCrvSmpl = GetNextCurve() ;
    }
-  // se c'è estrusione, devo tenerne conto (curve componenti sempre con vtExtr e dThick nulli)
+  // se c'è estrusione, devo tenerne conto (curve componenti sempre con vtExtr e dThick nulli)
    if ( ! m_VtExtr.IsSmall()  &&  abs( m_dThick) > EPS_SMALL) {
       Vector3d vtFrExtr = m_VtExtr ;
       vtFrExtr.ToGlob( frRef) ;
@@ -838,14 +838,14 @@ CurveComposite::Validate( void)
      // ciclo su tutte le curve
       int nCount = 0 ;
       for ( auto Iter = m_CrvSmplS.cbegin() ; Iter != m_CrvSmplS.cend() ; ++Iter) {
-        // verifico validità della curva e sua semplicità
+        // verifico validità della curva e sua semplicità
          if ( ! (*Iter)->IsValid()  ||  (*Iter)->GetType() == CRV_COMPO) {
             m_nStatus = ERR ;
             return false ;
          }
         // incremento contatore
          ++ nCount ;
-        // verifico continuità con la precedente (se non è la prima)
+        // verifico continuità con la precedente (se non è la prima)
          if ( nCount > 1) {
             (*Iter)->GetStartPoint( ptStart) ;
             if ( ! AreSamePointApprox( ptPrevEnd, ptStart)) {
@@ -870,7 +870,7 @@ CurveComposite::Validate( void)
 bool
 CurveComposite::TestClosure( void)
 {
-  // se non è chiusa, esco subito
+  // se non è chiusa, esco subito
    if ( ! IsClosed())
       return true ;
   // verifico ed eventualmente aggiusto coincidenza punti estremi
@@ -939,7 +939,7 @@ CurveComposite::IsFlat( Plane3d& plPlane, bool bUseExtrusion, double dToler) con
          } break ;
      }
    }
-  // recupero dati sulla planarità della polilinea
+  // recupero dati sulla planarità della polilinea
    int nRank ;
    Point3d ptCen ;
    Vector3d vtDir ;
@@ -1022,7 +1022,7 @@ CurveComposite::GetMidPoint( Point3d& ptMid) const
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // determino il valore del parametro a metà lunghezza
+  // determino il valore del parametro a metà lunghezza
    double dLen, dMid ;
    if ( ! GetLength( dLen)  ||  ! GetParamAtLength( 0.5 * dLen, dMid))
       return false ;      
@@ -1083,7 +1083,7 @@ CurveComposite::GetMidDir( Vector3d& vtDir) const
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // determino il valore del parametro a metà lunghezza
+  // determino il valore del parametro a metà lunghezza
    double dLen, dMid ;
    if ( ! GetLength( dLen)  ||  ! GetParamAtLength( 0.5 * dLen, dMid))
       return false ;
@@ -1363,7 +1363,7 @@ CurveComposite::ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, P
    dLinTol = max( dLinTol, LIN_TOL_MIN) ;
    dAngTolDeg = max( dAngTolDeg, ANG_TOL_MIN_DEG) ;
 
-  // se speciale, approssimo ogni singola entità e conservo le estremità interne (joint)
+  // se speciale, approssimo ogni singola entità e conservo le estremità interne (joint)
    if ( nType == APL_SPECIAL  ||  nType == APL_SPECIAL_INT) {
      // eseguo approssimazione
       double dStartPar = 0 ;
@@ -1409,7 +1409,7 @@ CurveComposite::ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, P
       Vector3d vtExtr = ( m_VtExtr.IsSmall() ? Z_AX : m_VtExtr) ;
       if ( ! PL.ApproxOnSide( vtExtr, ( nType == APL_LEFT  ||  nType == APL_LEFT_CONVEX), dLinTol))
          return false ;
-     // se necessario, sistemo per convessità dalla parte ammessa
+     // se necessario, sistemo per convessità dalla parte ammessa
       if ( nType == APL_RIGHT_CONVEX  ||  nType == APL_LEFT_CONVEX) {
          if ( ! PL.MakeConvex( vtExtr, ( nType == APL_LEFT_CONVEX)))
             return false ;
@@ -1418,7 +1418,7 @@ CurveComposite::ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, P
    }
 
   // altrimenti standard
-   // prima approssimazione lineare a 10 * Epsilon di ogni singola entità
+   // prima approssimazione lineare a 10 * Epsilon di ogni singola entità
    if ( ! ApproxWithLines( 10 * EPS_SMALL, dAngTolDeg, APL_SPECIAL, PL))
       return false ;
    // eliminazione dei punti in tolleranza
@@ -1436,7 +1436,7 @@ CurveComposite::ApproxWithArcs( double dLinTol, double dAngTolDeg, PolyArc& PA)
    if ( m_nStatus != OK)
       return false ;
 
-  // determino riferimento naturale della curva in base all'estrusione o al piano medio se questa è nulla
+  // determino riferimento naturale della curva in base all'estrusione o al piano medio se questa è nulla
    Frame3d frNat ;
    if ( ! m_VtExtr.IsSmall()) {
       frNat.Set( ORIG, m_VtExtr) ;
@@ -1500,7 +1500,7 @@ CurveComposite::ApproxWithArcsEx( double dLinTol, double dAngTolDeg, double dLin
    double dMlStartPar = 0 ;
    CurveByApprox crvByApprox ;
 
-  // determino riferimento naturale della curva in base all'estrusione o al piano medio se questa è nulla
+  // determino riferimento naturale della curva in base all'estrusione o al piano medio se questa è nulla
    Frame3d frNat ;
    if ( ! m_VtExtr.IsSmall()) {
       frNat.Set( ORIG, m_VtExtr) ;
@@ -1617,12 +1617,12 @@ CurveComposite::CopyParamRange( double dUStart, double dUEnd) const
    if ( dUStart < - EPS_PARAM  ||  dUStart > dMaxU + EPS_PARAM  ||
         dUEnd < - EPS_PARAM  ||  dUEnd > dMaxU + EPS_PARAM)
       return nullptr ;
-  // se i parametri coincidono, non resta alcunchè
+  // se i parametri coincidono, non resta alcunchè
    if ( abs( dUEnd - dUStart) < EPS_PARAM)
       return nullptr ;
   // se il parametro start supera quello di end
    if ( dUStart > dUEnd - EPS_PARAM) {
-     // se curva aperta, il trim la cancella completamente quindi non resta alcunchè
+     // se curva aperta, il trim la cancella completamente quindi non resta alcunchè
       if ( ! IsClosed())
          return nullptr ;
      // se curva chiusa, il trim si avvolge attorno al punto di giunzione
@@ -1681,7 +1681,7 @@ CurveComposite::Invert( void)
 bool
 CurveComposite::SimpleOffset( double dDist, int nType)
 {
-  // se distanza di offset nulla, non devo fare alcunché
+  // se distanza di offset nulla, non devo fare alcunché
    if ( abs( dDist) < EPS_SMALL)
       return true ;
 
@@ -1842,7 +1842,7 @@ CurveComposite::AddArcTg( const Point3d& ptNew, bool bEndOrStart)
       return false ;
   // recupero il versore normale al piano ( estrusione oppure se nulla asse Z locale)
    Vector3d vtN = ( m_VtExtr.IsSmall() ? Z_AX : m_VtExtr) ;
-  // costruisco l'arco (in casi articolari può essere una linea)
+  // costruisco l'arco (in casi articolari può essere una linea)
    PtrOwner<ICurve> pCrv ;
   // se da aggiungere alla fine
    if ( bEndOrStart) {
@@ -1875,7 +1875,7 @@ CurveComposite::AddArc2P( const Point3d& ptOther, const Point3d& ptNew, bool bEn
   // verifico lo stato
    if ( m_nStatus != OK  &&  m_nStatus != TO_VERIFY)
       return false ;
-  // costruisco l'arco (in casi articolari può essere una linea)
+  // costruisco l'arco (in casi articolari può essere una linea)
    PtrOwner<ICurve> pCrv ;
   // se da aggiungere alla fine
    if ( bEndOrStart) {
@@ -1917,7 +1917,7 @@ CurveComposite::AddJoint( double dU)
    if ( IsNull( pCrv1)  ||  IsNull( pCrv2))
       return false ;
   // della prima curva tengo la parte dall'inizio al parametro, della seconda la rimanente
-   // ( se non riesco a trimmare, la nuova giunzione coincide con una già esistente, esco con successo)
+   // ( se non riesco a trimmare, la nuova giunzione coincide con una già esistente, esco con successo)
    if ( ! pCrv1->TrimEndAtParam( dLocU)  ||  ! pCrv2->TrimStartAtParam( dLocU))
       return true ;
   // elimino la curva originale
@@ -1955,17 +1955,17 @@ CurveComposite::ModifyJoint( int nU, const Point3d& ptNewJoint)
    else if ( IsClosed())
       nNextCrv = 0 ;
    ICurve* pNextCrv = ( nNextCrv != -1 ? m_CrvSmplS[ nNextCrv] : nullptr) ;
-  // recupero punto iniziale dell'entità precedente (se esiste)
+  // recupero punto iniziale dell'entità precedente (se esiste)
    Point3d ptStart ;
    if ( pPrevCrv != nullptr  &&  ! pPrevCrv->GetStartPoint( ptStart))
       return false ;
-  // recupero punto finale dell'entità successiva (se esiste)
+  // recupero punto finale dell'entità successiva (se esiste)
    Point3d ptEnd ;
    if ( pNextCrv != nullptr  &&  ! pNextCrv->GetEndPoint( ptEnd))
       return false ;
-  // modifico il punto finale dell'eventuale entità precedente
+  // modifico il punto finale dell'eventuale entità precedente
    if ( pPrevCrv != nullptr  &&  ! pPrevCrv->ModifyEnd( ptNewJoint)) {
-     // se entità precedente si annulla, la elimino
+     // se entità precedente si annulla, la elimino
       if ( AreSamePointApprox( ptStart, ptNewJoint)) {
          delete pPrevCrv ;
          m_CrvSmplS.erase( m_CrvSmplS.begin() + nPrevCrv) ;
@@ -1982,9 +1982,9 @@ CurveComposite::ModifyJoint( int nU, const Point3d& ptNewJoint)
          delete( pPrevCrv) ;
       }  
    }
-  // modifico il punto iniziale dell'eventuale entità successiva
+  // modifico il punto iniziale dell'eventuale entità successiva
    if ( pNextCrv != nullptr  &&  ! pNextCrv->ModifyStart( ptNewJoint)) {
-     // se entità successiva si annulla, la elimino
+     // se entità successiva si annulla, la elimino
       if ( AreSamePointApprox( ptNewJoint, ptEnd)) {
          delete pNextCrv ;
          m_CrvSmplS.erase( m_CrvSmplS.begin() + nNextCrv) ;
@@ -2101,17 +2101,17 @@ CurveComposite::MoveCurve( int nCrv, const Vector3d& vtMove)
    else if ( IsClosed())
       nNextCrv = 0 ;
    ICurve* pNextCrv = ( nNextCrv != -1 ? m_CrvSmplS[ nNextCrv] : nullptr) ;
-  // recupero punti iniziale e finale dell'entità precedente (se esiste)
+  // recupero punti iniziale e finale dell'entità precedente (se esiste)
    Point3d ptPrevStart, ptPrevEnd ;
    if ( pPrevCrv != nullptr  &&  ( ! pPrevCrv->GetStartPoint( ptPrevStart)  ||  ! pPrevCrv->GetEndPoint( ptPrevEnd)))
       return false ;
-  // recupero punti iniziale e finale dell'entità successiva (se esiste)
+  // recupero punti iniziale e finale dell'entità successiva (se esiste)
    Point3d ptNextStart, ptNextEnd ;
    if ( pNextCrv != nullptr  &&  ( ! pNextCrv->GetStartPoint( ptNextStart)  ||  ! pNextCrv->GetEndPoint( ptNextEnd)))
       return false ;
-  // modifico il punto finale dell'eventuale entità precedente
+  // modifico il punto finale dell'eventuale entità precedente
    if ( pPrevCrv != nullptr  &&  ! pPrevCrv->ModifyEnd( ptPrevEnd + vtMove)) {
-     // se entità precedente si annulla, la elimino
+     // se entità precedente si annulla, la elimino
       if ( AreSamePointApprox( ptPrevStart, ptPrevEnd + vtMove)) {
          delete pPrevCrv ;
          m_CrvSmplS.erase( m_CrvSmplS.begin() + nPrevCrv) ;
@@ -2130,9 +2130,9 @@ CurveComposite::MoveCurve( int nCrv, const Vector3d& vtMove)
          delete( pPrevCrv) ;
       }  
    }
-  // modifico il punto iniziale dell'eventuale entità successiva
+  // modifico il punto iniziale dell'eventuale entità successiva
    if ( pNextCrv != nullptr  &&  ! pNextCrv->ModifyStart( ptNextStart + vtMove)) {
-     // se entità successiva si annulla, la elimino
+     // se entità successiva si annulla, la elimino
       if ( AreSamePointApprox( ptNextStart + vtMove, ptNextEnd)) {
          delete pNextCrv ;
          m_CrvSmplS.erase( m_CrvSmplS.begin() + nNextCrv) ;
@@ -2209,7 +2209,7 @@ CurveComposite::ModifyCurveToLine( int nCrv)
       return false ;
   // recupero la curva corrente 
    ICurve* pCrv = m_CrvSmplS[nCrv] ;
-  // se già linea non devo fare alcunchè
+  // se già linea non devo fare alcunchè
    if ( pCrv->GetType() == CRV_LINE)
       return true ;
   // recupero gli estremi
@@ -2237,7 +2237,7 @@ CurveComposite::ModifyCurveToLine( int nCrv)
 bool
 CurveComposite::TrimStartAtParam( double dUTrim)
 {
-  // verifico validità parametro
+  // verifico validità parametro
    double dMaxU = double( m_CrvSmplS.size()) ;
    if ( dUTrim < -EPS_PARAM  ||  dUTrim > dMaxU - EPS_PARAM)
       return false ;
@@ -2267,7 +2267,7 @@ CurveComposite::TrimStartAtParam( double dUTrim)
          Iter = m_CrvSmplS.erase( Iter) ;
          break ;
       }
-     // altrimenti superata lunghezza ancora da tagliare (taglio già fatto al test sopra)
+     // altrimenti superata lunghezza ancora da tagliare (taglio già fatto al test sopra)
       else {
          break ;
       }
@@ -2280,7 +2280,7 @@ CurveComposite::TrimStartAtParam( double dUTrim)
 bool
 CurveComposite::TrimEndAtParam( double dUTrim)
 {
-  // verifico validità parametro
+  // verifico validità parametro
    double dMaxU = double( m_CrvSmplS.size()) ;
    if ( dUTrim < EPS_PARAM  ||  dUTrim > dMaxU + EPS_PARAM)
       return false ;
@@ -2301,7 +2301,7 @@ CurveComposite::TrimEndAtParam( double dUTrim)
       dUToTrim -= ( dParEnd - dParStart) ;
      // se da cancellare
       if ( bToErase) {
-        // cancello l'entità, la tolgo dalla lista e passo alla successiva
+        // cancello l'entità, la tolgo dalla lista e passo alla successiva
          delete (*Iter) ;
          Iter = m_CrvSmplS.erase( Iter) ;
       }
@@ -2311,7 +2311,7 @@ CurveComposite::TrimEndAtParam( double dUTrim)
       }
      // se lunghezza parametrica ancora da tagliare nulla (entro la tolleranza)
       else if ( dUToTrim > - EPS_PARAM) {
-        // passo alla entità successiva
+        // passo alla entità successiva
          ++ Iter ;
         // dichiaro ingresso in zona da cancellare
          bToErase = true ;
@@ -2324,7 +2324,7 @@ CurveComposite::TrimEndAtParam( double dUTrim)
             bToErase = true ;
             continue ;
          }
-        // passo alla entità successiva
+        // passo alla entità successiva
          ++ Iter ;
         // dichiaro ingresso in zona da cancellare
          bToErase = true ;
@@ -2389,7 +2389,7 @@ CurveComposite::TrimStartEndAtParam( double dUStartTrim, double dUEndTrim)
 bool
 CurveComposite::TrimStartAtLen( double dLenTrim)
 {
-  // verifico validità lunghezza risultante
+  // verifico validità lunghezza risultante
    if ( dLenTrim < EPS_ZERO)
       return true ;
    double dLen ;
@@ -2443,7 +2443,7 @@ CurveComposite::TrimStartAtLen( double dLenTrim)
 bool
 CurveComposite::TrimEndAtLen( double dLenTrim)
 {
-  // verifico validità lunghezza risultante
+  // verifico validità lunghezza risultante
    if ( dLenTrim < EPS_SMALL)
       return false ;
    double dLen ;
@@ -2456,7 +2456,7 @@ CurveComposite::TrimEndAtLen( double dLenTrim)
    double dLenToTrim = dLenTrim ;
    for ( auto Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ;) {
       double dCrvLen = 0 ;
-     // se non sono già nella zona da cancellare, aggiorno lunghezze
+     // se non sono già nella zona da cancellare, aggiorno lunghezze
       if ( ! bToErase) {
         // lunghezza della curva
          if ( ! (*Iter)->GetLength( dCrvLen))
@@ -2466,18 +2466,18 @@ CurveComposite::TrimEndAtLen( double dLenTrim)
       }
      // se da cancellare
       if ( bToErase) {
-        // cancello l'entità, la tolgo dalla lista e passo alla successiva
+        // cancello l'entità, la tolgo dalla lista e passo alla successiva
          delete (*Iter) ;
          Iter = m_CrvSmplS.erase( Iter) ;
       }
      // se lunghezza ancora da tagliare non nulla
       else if ( dLenToTrim > EPS_SMALL) {
-        // passo alla entità successiva
+        // passo alla entità successiva
          ++ Iter ;
       }
      // se lunghezza ancora da tagliare nulla (entro la tolleranza)
       else if ( dLenToTrim > - EPS_SMALL) {
-        // passo alla entità successiva
+        // passo alla entità successiva
          ++ Iter ;
         // dichiaro ingresso in zona da cancellare
          bToErase = true ;
@@ -2489,7 +2489,7 @@ CurveComposite::TrimEndAtLen( double dLenTrim)
             m_nStatus = ERR ;
             return false ;
          }
-        // passo alla entità successiva
+        // passo alla entità successiva
          ++ Iter ;
         // dichiaro ingresso in zona da cancellare
          bToErase = true ;
@@ -2565,8 +2565,10 @@ CurveComposite::Translate( const Vector3d& vtMove)
    if ( m_nStatus != OK)
       return false ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+  // traslo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->Translate( vtMove) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2584,12 +2586,14 @@ CurveComposite::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAn
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dell'asse di rotazione
+  // verifico validità dell'asse di rotazione
    if ( vtAx.IsSmall())
       return false ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+  // ruoto Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2649,9 +2653,9 @@ CurveComposite::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, dou
      // se tutto bene, passo alla prossima
       if ( bOk)
          ++Iter ;
-     // altrimenti, l'entità si è annullata => devo toglierla dalla lista e cancellarla
+     // altrimenti, l'entità si è annullata => devo toglierla dalla lista e cancellarla
       else {
-        // si è annullata l'entità, la elimino e la tolgo dalla lista
+        // si è annullata l'entità, la elimino e la tolgo dalla lista
          delete (*Iter) ;
          Iter = m_CrvSmplS.erase( Iter)  ;
       }
@@ -2699,7 +2703,7 @@ CurveComposite::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del piano di specchiatura
+  // verifico validità del piano di specchiatura
    if ( vtNorm.IsSmall())
       return false ;
 
@@ -2725,7 +2729,7 @@ CurveComposite::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dei parametri
+  // verifico validità dei parametri
    if ( vtNorm.IsSmall()  ||  vtDir.IsSmall())
       return false ;
 
@@ -2760,16 +2764,18 @@ CurveComposite::ToGlob( const Frame3d& frRef)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
+  // se frame identità, non devo fare alcunché
    if ( IsGlobFrame( frRef))
       return true ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->ToGlob( frRef) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2790,16 +2796,18 @@ CurveComposite::ToLoc( const Frame3d& frRef)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
+  // se frame identità, non devo fare alcunché
    if ( IsGlobFrame( frRef))
       return true ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->ToLoc( frRef) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2820,16 +2828,18 @@ CurveComposite::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dei frame
+  // verifico validità dei frame
    if ( frOri.GetType() == Frame3d::ERR  ||  frDest.GetType() == Frame3d::ERR)
       return false ;
 
-  // se i due riferimenti coincidono, non devo fare alcunché
+  // se i due riferimenti coincidono, non devo fare alcunché
    if ( AreSameFrame( frOri, frDest))
-      return true ;
+      return true ;                                                                                                
+
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->LocToLoc( frOri, frDest) ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2976,7 +2986,7 @@ CurveComposite::RemoveFirstOrLastCurve( bool bLast)
 bool
 CurveComposite::IsParamAtJoint( double dU) const
 {
-  // se aperta e all'inizio o alla fine o lontano dagli interi non è giunzione
+  // se aperta e all'inizio o alla fine o lontano dagli interi non è giunzione
    bool bClosed = IsClosed() ;
    if ( ( ! bClosed  &&  abs( dU) < EPS_PARAM)  ||
         ( ! bClosed  &&  abs( dU - double( m_CrvSmplS.size())) < EPS_PARAM)  ||
@@ -2994,7 +3004,7 @@ CurveComposite::ChangeStartPoint( double dU)
    if ( ! IsClosed())
       return false ;
 
-  // questa funzione gestisce già anche il cambio di inizio su curve chiuse
+  // questa funzione gestisce già anche il cambio di inizio su curve chiuse
    return TrimStartEndAtParam( dU, dU) ;
 }
 
@@ -3004,19 +3014,19 @@ CurveComposite::ArcsToBezierCurves( void)
 {
   // verifico le singole curve
    for ( auto Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter) {
-     // se arco, devo trasformare in una o più curve di Bezier
+     // se arco, devo trasformare in una o più curve di Bezier
       if ( (*Iter)->GetType() == CRV_ARC) {
         // eseguo trasformazione
          PtrOwner<ICurve> pNewCrv( ArcToBezierCurve( (*Iter))) ;
          if ( IsNull( pNewCrv))
             return false ;
-        // se risultato è singola curva
+        // se risultato è singola curva
          if ( pNewCrv->IsSimple()) {
            // elimino l'arco e lo sostituisco con la curva di Bezier
             delete (*Iter) ;
             (*Iter) = Release( pNewCrv) ;
          }
-        // altrimenti è una curva composita
+        // altrimenti è una curva composita
          else {
             CurveComposite* pCC = GetBasicCurveComposite( pNewCrv) ;
             if ( pCC == nullptr)
@@ -3058,13 +3068,13 @@ CurveComposite::ArcsBezierCurvesToArcsPerpExtr( double dLinTol, double dAngTolDe
          (*Iter)->SetExtrusion( V_NULL) ;
          if ( IsNull( pNewCrv))
             return false ;
-        // se risultato è singola curva
+        // se risultato è singola curva
          if ( pNewCrv->IsSimple()) {
            // elimino la curva originale e la sostituisco con l'arco
             delete (*Iter) ;
             (*Iter) = Release( pNewCrv) ;
          }
-        // altrimenti è una curva composita
+        // altrimenti è una curva composita
          else {
             CurveComposite* pCC = GetBasicCurveComposite( pNewCrv) ;
             if ( pCC == nullptr)
@@ -3130,7 +3140,7 @@ CurveComposite::StraightArcsToLines( double dLinTol, double dAngTolDeg)
 static int
 MergeTwoCurves( ICurve* pCrvP, ICurve* pCrvC, double& dCurrLinTol, double dCosAngTol, bool bNeedSameProp)
 {
-  // verifico compatibilità delle proprietà
+  // verifico compatibilità delle proprietà
    int nTpr0P = pCrvP->GetTempProp( 0) ;
    int nTpr0C = pCrvC->GetTempProp( 0) ;
    int nTpr1P = pCrvP->GetTempProp( 1) ;
@@ -3177,7 +3187,7 @@ MergeTwoCurves( ICurve* pCrvP, ICurve* pCrvC, double& dCurrLinTol, double dCosAn
             if ( pLineC->ModifyStart( pLineP->GetStart())) {
               // diminuisco la tolleranza corrente dell'errore attuale
                dCurrLinTol -= COEFF_TOL * sqrt( dSqDist) ;
-              // se curve originali con proprietà diversa, la cancello
+              // se curve originali con proprietà diversa, la cancello
                if ( nTpr0P != nTpr0C)
                   pLineC->SetTempProp( 0, 0) ;
                if ( nTpr1P != nTpr1C)
@@ -3202,7 +3212,7 @@ MergeTwoCurves( ICurve* pCrvP, ICurve* pCrvC, double& dCurrLinTol, double dCosAn
      // verifico la coincidenza dei raggi
       if ( abs( pArcP->GetRadius() - pArcC->GetRadius()) > dCurrLinTol)
          return 0 ;
-     // verifico la collinearità delle normali (tenendo conto del raggio)
+     // verifico la collinearità delle normali (tenendo conto del raggio)
       if ( ! (( pArcP->GetNormVersor() - pArcC->GetNormVersor()) * pArcP->GetRadius()).IsSmall()  &&
            ! (( pArcP->GetNormVersor() + pArcC->GetNormVersor()) * pArcP->GetRadius()).IsSmall())
          return 0 ;
@@ -3230,7 +3240,7 @@ MergeTwoCurves( ICurve* pCrvP, ICurve* pCrvC, double& dCurrLinTol, double dCosAn
            // verifico normale al piano dell'arco
             if ( NewArc.GetNormVersor() * pArcC->GetNormVersor() < 0)
                NewArc.InvertN() ;
-           // se curve originali con la stessa proprietà, la riporto
+           // se curve originali con la stessa proprietà, la riporto
             if ( nTpr0P == nTpr0C)
                NewArc.SetTempProp( nTpr0C, 0) ;
             if ( nTpr1P == nTpr1C)
@@ -3255,7 +3265,7 @@ MergeTwoCurves( ICurve* pCrvP, ICurve* pCrvC, double& dCurrLinTol, double dCosAn
          pArcC->GetEndPoint( ptP3) ;
          CurveArc NewArc ;
          if ( NewArc.Set2PVN( ptP1, ptP3, vtDir1, pArcC->GetNormVersor())) {
-           // se curve originali con la stessa proprietà, la riporto
+           // se curve originali con la stessa proprietà, la riporto
             if ( nTpr0P == nTpr0C)
                NewArc.SetTempProp( nTpr0C, 0) ;
             if ( nTpr1P == nTpr1C)
@@ -3293,11 +3303,11 @@ CurveComposite::MergeCurves( double dLinTol, double dAngTolDeg, bool bStartEnd,
    while ( iterC != m_CrvSmplS.end()) {
      // se curve unite
       switch ( MergeTwoCurves( *iterP, *iterC, dCurrLinTol, dCosAngTol, bNeedSameProp)) {
-      case -1 :          // cancello l'entità precedente e la tolgo dalla lista
+      case -1 :          // cancello l'entità precedente e la tolgo dalla lista
          delete (*iterP) ;
          iterC = m_CrvSmplS.erase( iterP) ;
          break ;
-      case 1 :           // cancello l'entità corrente e la tolgo dalla lista
+      case 1 :           // cancello l'entità corrente e la tolgo dalla lista
          delete (*iterC) ;
          iterC = m_CrvSmplS.erase( iterC) ;
          iterC = prev( iterC) ;
@@ -3314,11 +3324,11 @@ CurveComposite::MergeCurves( double dLinTol, double dAngTolDeg, bool bStartEnd,
    if ( bStartEnd  &&  m_CrvSmplS.size() >= 2  &&  IsClosed()) {
       iterC = m_CrvSmplS.begin() ;
       switch ( MergeTwoCurves( *iterP, *iterC, dCurrLinTol, dCosAngTol, bNeedSameProp)) {
-      case -1 :          // cancello l'entità precedente e la tolgo dalla lista
+      case -1 :          // cancello l'entità precedente e la tolgo dalla lista
          delete (*iterP) ;
          m_CrvSmplS.erase( iterP) ;
          break ;
-      case 1 :           // cancello l'entità corrente e la tolgo dalla lista
+      case 1 :           // cancello l'entità corrente e la tolgo dalla lista
          delete (*iterC) ;
          m_CrvSmplS.erase( iterC) ;
          break ;
@@ -3377,7 +3387,7 @@ SplitTopBottomArcs( CurveComposite& cCompo)
         // le ordino in senso crescente di ampiezza assoluta
          if ( abs( dAng1) > abs( dAng2))
             swap( dAng1, dAng2) ;
-        // verifico se la prima di queste rotazioni è compresa nell'arco
+        // verifico se la prima di queste rotazioni è compresa nell'arco
          if ( abs( dAng1) > EPS_ANG_SMALL  &&  abs( dAng1) < abs( pArc->GetAngCenter()) - EPS_ANG_SMALL) {
             cCompo.AddJoint( i + dAng1 / pArc->GetAngCenter()) ;
          }
@@ -3427,7 +3437,7 @@ CurveComposite::RemoveUndercutOnY( double dLinTol, double dAngTolDeg)
       Point3d ptStart, ptEnd ;
       pCompo->GetStartPoint( ptStart) ;
       pCompo->GetEndPoint( ptEnd) ;
-     // se curva pressochè verticale non sottende alcunché, quindi la salto
+     // se curva pressochè verticale non sottende alcunché, quindi la salto
       if ( abs( ptStart.x - ptEnd.x) < EPS_SMALL)
          continue ;
      // ordino gli estremi
@@ -3533,7 +3543,7 @@ CurveComposite::IsALine( double dLinTol, Point3d& ptStart, Point3d& ptEnd) const
   // elimino i punti allineati entro la tolleranza
    if ( ! PL.RemoveAlignedPoints( dLinTol))
       return false ;
-  // se sono rimasti due punti è una retta
+  // se sono rimasti due punti è una retta
    return ( PL.GetPointNbr() == 2) ;
 }
 
@@ -3541,7 +3551,7 @@ CurveComposite::IsALine( double dLinTol, Point3d& ptStart, Point3d& ptEnd) const
 bool
 CurveComposite::IsOneCircle( Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW) const
 {
-  // deve essere una sola entità
+  // deve essere una sola entità
    if ( GetCurveCount() != 1)
       return false ;
   // deve essere un arco di circonferenza completo
@@ -3564,7 +3574,7 @@ CurveComposite::IsACircle( double dLinTol, Point3d& ptCen, Vector3d& vtN, double
    if ( ! IsClosed())
       return false ;
 
-  // se è formata da una sola entità arco che è una circonferenza
+  // se è formata da una sola entità arco che è una circonferenza
    if ( IsOneCircle( ptCen, vtN, dRad, bCCW))
       return true ;
 
@@ -3601,10 +3611,10 @@ CurveComposite::IsARectangle( double dLinTol, Point3d& ptP, Vector3d& vtL1, Vect
    Point3d ptV2 ; PL.GetNextPoint( ptV2) ;
    Point3d ptV3 ; PL.GetNextPoint( ptV3) ;
    Point3d ptV4 ; PL.GetNextPoint( ptV4) ;
-  // verifico che le diagonali si incontrino nel loro punto medio (-> è un parallelogramma)
+  // verifico che le diagonali si incontrino nel loro punto medio (-> è un parallelogramma)
    if ( ! AreSamePointEpsilon( Media( ptV1, ptV3), Media( ptV2, ptV4), dLinTol / 2))
       return false ;
-  // verifico che le diagonali abbiano la stessa lunghezza (-> è un rettangolo)
+  // verifico che le diagonali abbiano la stessa lunghezza (-> è un rettangolo)
    if ( abs( Dist( ptV1, ptV3) - Dist( ptV2, ptV4)) > dLinTol)
       return false ;
   // assegno i parametri del rettangolo
@@ -3637,7 +3647,7 @@ CurveComposite::IsATrapezoid( double dLinTol, Point3d& ptP, Vector3d& vtB1, Vect
    Point3d ptV2 ; PL.GetNextPoint( ptV2) ;
    Point3d ptV3 ; PL.GetNextPoint( ptV3) ;
    Point3d ptV4 ; PL.GetNextPoint( ptV4) ;
-  // verifico se V4->V3 è parallelo a V1->V2
+  // verifico se V4->V3 è parallelo a V1->V2
    double dV3B12, dV4B12 ;
    if ( ! DistPointLine( ptV3, ptV1, ptV2, false).GetDist( dV3B12)  ||
         ! DistPointLine( ptV4, ptV1, ptV2, false).GetDist( dV4B12))
@@ -3649,7 +3659,7 @@ CurveComposite::IsATrapezoid( double dLinTol, Point3d& ptP, Vector3d& vtB1, Vect
       vtB2 = ptV3 - ptV4 ;
       return true ;
    }
-  // verifico se V1->V4 è parallelo a V2->V3
+  // verifico se V1->V4 è parallelo a V2->V3
    double dV1B23, dV4B23 ;
    if ( ! DistPointLine( ptV1, ptV2, ptV3, false).GetDist( dV1B23)  ||
         ! DistPointLine( ptV4, ptV2, ptV3, false).GetDist( dV4B23))
@@ -3661,7 +3671,7 @@ CurveComposite::IsATrapezoid( double dLinTol, Point3d& ptP, Vector3d& vtB1, Vect
       vtB2 = ptV4 - ptV1 ;
       return true ;
    }
-  // non è un trapezio
+  // non è un trapezio
    return false ;
 }
 
@@ -3747,7 +3757,7 @@ CurveComposite::GetVoronoiObject() const
    if ( m_nStatus != OK)
       return nullptr ;
  
-  // se non è stato calcolato, lo calcolo
+  // se non è stato calcolato, lo calcolo
    if ( m_pVoronoiObj == nullptr)
       CalcVoronoiObject() ;
  
@@ -3763,3 +3773,28 @@ CurveComposite::ResetVoronoiObject() const
       delete m_pVoronoiObj ;
    m_pVoronoiObj = nullptr ;
 }
+
+//----------------------------------------------------------------------------
+bool
+CurveComposite::FromPoint(Point3d& ptStart)
+{
+  // verifico lo stato
+   if ( m_nStatus != TO_VERIFY)
+      return false ;
+  // assegno il punto e setto lo stato
+   m_ptStart = ptStart ;
+   m_nStatus = IS_A_POINT ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+CurveComposite::GetOnlyPoint(Point3d& ptStart) const 
+{
+  // verifico lo stato
+   if ( m_nStatus != IS_A_POINT)
+      return false ;
+  // restituisco il punto
+   ptStart = m_ptStart ;
+   return true ;
+}

CurveComposite.h

@@ -150,7 +150,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool IsParamAtJoint( double dU) const override ;
       ICurve* RemoveFirstOrLastCurve(  bool bLast = true) override ;
       bool ChangeStartPoint( double dU) override ;
-      bool AddPoint( const Point3d& ptStart) override ;
+      bool AddPoint( const Point3d& ptStart) override ;  // funzione per aggiungere il ptStart prima di usare la funzione AddLine
       bool AddLine( const Point3d& ptNew, bool bEndOrStart = true) override ;
       bool AddLineTg( double dLen, bool bEndOrStart = true) override ;
       bool AddArc2P( const Point3d& ptOther, const Point3d& ptNew, bool bEndOrStart = true) override ;
@@ -177,11 +177,16 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool GetCurveTempProp( int nCrv, int& nProp, int nPropInd = 0) const override ;
       bool SetCurveTempParam( int nCrv, double dParam, int nParamInd = 0) override ;
       bool GetCurveTempParam( int nCrv, double& dParam, int nParamInd = 0) const override ;
+      bool FromPoint( Point3d& ptStart) override ;        // funzione per settare la curva ad un unico punto
+      bool GetOnlyPoint( Point3d& ptStart) const override ;  // funzione per recuperare l'unico punto da cui è composta la curva ( degenere)
       
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
+      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
+      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
+      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       CurveComposite( void) ;
@@ -195,6 +200,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool RelocateFrom( CurveComposite& ccSrc) ;
       bool GetApproxLength( double& dLen) const ;
       Voronoi* GetVoronoiObject( void) const ;
+      void ResetVoronoiObject( void) const ;
 
    private :
       bool CopyFrom( const CurveComposite& ccSrc) ;
@@ -206,10 +212,9 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool SimpleOffsetXY( double dDist, int nType = OFF_FILLET) ;
       bool IsOneCircle( Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW) const ;      
       bool CalcVoronoiObject( void) const ;
-      void ResetVoronoiObject( void) const ;
 
    private :
-      enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
+      enum Status { ERR = 0, OK = 1, TO_VERIFY = 2, IS_A_POINT = 3} ;
 
    private :
       typedef std::deque<ICurve*>      PCRVSMPL_DEQUE ;
@@ -222,7 +227,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       Vector3d         m_VtExtr ;        // vettore estrusione (normalmente coincide con m_VtN)
       double           m_dThick ;        // spessore
       Point3d          m_ptStart ;       // punto iniziale per composita vuota per Add di linee o archi
-      int              m_nTempProp[2] ;  // vettore proprietà temporanee
+      int              m_nTempProp[2] ;  // vettore proprietà temporanee
       double           m_dTempParam[2] ; // vettore parametri temporanei 
       mutable Voronoi* m_pVoronoiObj ;   // Voronoi
       mutable PCSD_CONST_ITER m_Iter ;   // iteratore      

CurveLine.cpp

@@ -162,7 +162,7 @@ CurveLine::Dump( string& sOut, bool bMM, const char* szNewLine) const
   // dati generali di una curva
    if ( ! CurveDump( *this, sOut, bMM, szNewLine))
       return false ;
-  // parametri : sono già compresi nei dati generali (PS e PE)
+  // parametri : sono già compresi nei dati generali (PS e PE)
 
    return true ;
 }
@@ -223,7 +223,7 @@ CurveLine::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
       return false ;
   // assegno il box in locale
    b3Loc.Set( m_PtStart, m_PtEnd) ;
-  // se c'è estrusione, devo tenerne conto
+  // se c'è estrusione, devo tenerne conto
    if ( ! m_VtExtr.IsSmall()  &&  abs( m_dThick) > EPS_SMALL) {
       Point3d ptMinExtr = b3Loc.GetMin() + m_VtExtr * m_dThick ;
       Point3d ptMaxExtr = b3Loc.GetMax() + m_VtExtr * m_dThick ;
@@ -241,7 +241,7 @@ CurveLine::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
   // porto gli estremi nel riferimento passato
@@ -251,7 +251,7 @@ CurveLine::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
    ptFrEnd.ToGlob( frRef) ;
   // assegno il box nel riferimento
    b3Ref.Set( ptFrStart, ptFrEnd) ;
-  // se c'è estrusione, devo tenerne conto
+  // se c'è estrusione, devo tenerne conto
    if ( ! m_VtExtr.IsSmall()  &&  abs( m_dThick) > EPS_SMALL) {
       Vector3d vtFrExtr = m_VtExtr ;
       vtFrExtr.ToGlob( frRef) ;
@@ -390,7 +390,7 @@ CurveLine::GetLength( double& dLen) const
    if ( m_nStatus != OK)
       return false ;
 
-  // la lunghezza è la distanza tra gli estremi
+  // la lunghezza è la distanza tra gli estremi
    dLen = Dist( m_PtStart, m_PtEnd) ;
 
    return ( dLen > EPS_SMALL) ;
@@ -416,7 +416,7 @@ CurveLine::GetLengthAtParam( double dU, double& dLen) const
       return true ;
    }
 
-  // la lunghezza totale è la distanza tra gli estremi
+  // la lunghezza totale è la distanza tra gli estremi
    double dTotLen = Dist( m_PtStart, m_PtEnd) ;
 
   // fine
@@ -448,7 +448,7 @@ CurveLine::GetParamAtLength( double dLen, double& dU) const
       return true ;
    }
 
-  // la lunghezza totale è la distanza tra gli estremi
+  // la lunghezza totale è la distanza tra gli estremi
    double dTotLen = Dist( m_PtStart, m_PtEnd) ;
 
   // se dopo fine, errore
@@ -811,8 +811,10 @@ CurveLine::Translate( const Vector3d& vtMove)
    if ( m_nStatus != OK)
       return false ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
+  // traslo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->Translate( vtMove) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -830,12 +832,14 @@ CurveLine::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, do
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dell'asse di rotazione
+  // verifico validità dell'asse di rotazione
    if ( vtAx.IsSmall())
       return false ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
+  // ruoto Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -894,7 +898,7 @@ CurveLine::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del piano di specchiatura
+  // verifico validità del piano di specchiatura
    if ( vtNorm.IsSmall())
       return false ;
 
@@ -919,7 +923,7 @@ CurveLine::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& v
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dei parametri
+  // verifico validità dei parametri
    if ( vtNorm.IsSmall()  ||  vtDir.IsSmall())
       return false ;
 
@@ -949,16 +953,18 @@ CurveLine::ToGlob( const Frame3d& frRef)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
+  // se frame identità, non devo fare alcunché
    if ( IsGlobFrame( frRef))
       return true ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->ToGlob( frRef) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -973,16 +979,18 @@ CurveLine::ToLoc( const Frame3d& frRef)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
+  // se frame identità, non devo fare alcunché
    if ( IsGlobFrame( frRef))
       return true ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->ToLoc( frRef) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -997,16 +1005,18 @@ CurveLine::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dei frame
+  // verifico validità dei frame
    if ( frOri.GetType() == Frame3d::ERR  ||  frDest.GetType() == Frame3d::ERR)
       return false ;
 
-  // se i due riferimenti coincidono, non devo fare alcunché
+  // se i due riferimenti coincidono, non devo fare alcunché
    if ( AreSameFrame( frOri, frDest))
       return true ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->LocToLoc( frOri, frDest) ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1065,7 +1075,7 @@ CurveLine::GetVoronoiObject() const
    if ( m_nStatus != OK)
       return nullptr ;
 
-  // se non è stato calcolato, lo calcolo
+  // se non è stato calcolato, lo calcolo
    if ( m_pVoronoiObj == nullptr)
       CalcVoronoiObject() ;
 

CurveLine.h

@@ -146,7 +146,10 @@ class CurveLine : public ICurveLine, public IGeoObjRW
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
+      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
+      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
+      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       CurveLine( void) ;
@@ -158,12 +161,12 @@ class CurveLine : public ICurveLine, public IGeoObjRW
                        LOG_ERROR( GetEGkLogger(), "CurveLine : copy error")
                     return *this ; }
       Voronoi* GetVoronoiObject( void) const ;
+      void ResetVoronoiObject( void) const ;
 
    private :
       bool CopyFrom( const CurveLine& clSrc) ;
       bool Validate( void) ;      
-      bool CalcVoronoiObject( void) const ;
-      void ResetVoronoiObject( void) const ;
+      bool CalcVoronoiObject( void) const ;      
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
@@ -175,7 +178,7 @@ class CurveLine : public ICurveLine, public IGeoObjRW
       Point3d  m_PtEnd ;                // punto finale
       Vector3d m_VtExtr ;               // vettore estrusione
       double   m_dThick ;               // spessore
-      int      m_nTempProp[2] ;         // vettore proprietà temporanee
+      int      m_nTempProp[2] ;         // vettore proprietà temporanee
       double   m_dTempParam[2] ;        // vettore parametri temporanei
       mutable Voronoi* m_pVoronoiObj ;  // Voronoi
 } ;

EgtGeomKernel.vcxproj

@@ -309,15 +309,34 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="CurveByApprox.cpp" />
     <ClCompile Include="CurveByInterp.cpp" />
     <ClCompile Include="CurveCompositeOffset.cpp" />
+    <ClCompile Include="IntersCurveSurfTm.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="IntersLineVolZmap.cpp" />
+    <ClCompile Include="IntersPlaneVolZmap.cpp" />
+    <ClCompile Include="IntersLineSurfBez.cpp" />
     <ClCompile Include="PolygonElevation.cpp" />
+    <ClCompile Include="Quaternion.cpp" />
+    <ClCompile Include="RotationMinimizingFrame.cpp" />
+    <ClCompile Include="RotationXplaneFrame.cpp" />
+    <ClCompile Include="SbzStandard.cpp" />
     <ClCompile Include="Voronoi.cpp" />
     <ClInclude Include="..\Include\EGkCDeClosedSurfTmClosedSurfTm.h" />
     <ClInclude Include="..\Include\EGkCDeConeFrustumClosedSurfTm.h" />
     <ClInclude Include="..\Include\EGkCDeConvexTorusClosedSurfTm.h" />
     <ClInclude Include="..\Include\EGkCDeRectPrismoidClosedSurfTm.h" />
+    <ClInclude Include="..\Include\EGkIntersCurveSurfTm.h" />
     <ClInclude Include="..\Include\EGkIntersLineBox.h" />
+    <ClInclude Include="..\Include\EGkIntersLineVolZmap.h" />
     <ClInclude Include="..\Include\EGkIntersPlaneBox.h" />
+    <ClInclude Include="..\Include\EGkIntersPlaneVolZmap.h" />
     <ClInclude Include="..\Include\EGkPolygonElevation.h" />
+    <ClInclude Include="..\Include\EGkQuaternion.h" />
+    <ClInclude Include="..\Include\EGkRotationMinimizingFrame.h" />
+    <ClInclude Include="..\Include\EGkRotationXplaneFrame.h" />
     <ClInclude Include="..\Include\EGkSubtractProjectedFacesOnStmFace.h" />
     <ClInclude Include="CDeBoxTria.h" />
     <ClInclude Include="CDeCapsTria.h" />

EgtGeomKernel.vcxproj.filters

@@ -43,15 +43,18 @@
     <Filter Include="File di origine\GeoOffset">
       <UniqueIdentifier>{f07670fd-9429-4b7e-ac6d-1c0022e756fb}</UniqueIdentifier>
     </Filter>
-    <Filter Include="File di origine\GeoCollision">
-      <UniqueIdentifier>{865b76ee-b10d-41fc-861c-b48ce52fa277}</UniqueIdentifier>
-    </Filter>
     <Filter Include="File di origine\GeoProject">
       <UniqueIdentifier>{d96752da-1884-4a73-ba1b-5b20b606e469}</UniqueIdentifier>
     </Filter>
     <Filter Include="File di origine\GeoElevation">
       <UniqueIdentifier>{4c6a9dc5-8fac-4ecd-bde6-3e37e056712e}</UniqueIdentifier>
     </Filter>
+    <Filter Include="File di origine\GeoCollisionAvoid">
+      <UniqueIdentifier>{ae52e402-3063-45e3-b9f7-1710035a1f56}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="File di origine\GeoCollisionDetection">
+      <UniqueIdentifier>{865b76ee-b10d-41fc-861c-b48ce52fa277}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Vector3d.cpp">
@@ -273,6 +276,9 @@
     <ClCompile Include="IntersLineSurfTm.cpp">
       <Filter>File di origine\GeoInters</Filter>
     </ClCompile>
+    <ClCompile Include="IntersLineSurfBez.cpp">
+      <Filter>File di origine\GeoInters</Filter>
+    </ClCompile>
     <ClCompile Include="CircleCenTgCurve.cpp">
       <Filter>File di origine\GeoCreate</Filter>
     </ClCompile>
@@ -372,17 +378,8 @@
     <ClCompile Include="IntersLineSurfStd.cpp">
       <Filter>File di origine\GeoInters</Filter>
     </ClCompile>
-    <ClCompile Include="CAvToolTriangle.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
-    </ClCompile>
-    <ClCompile Include="CAvToolSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
-    </ClCompile>
     <ClCompile Include="CDeBoxTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
-    </ClCompile>
-    <ClCompile Include="CAvSimpleSurfFrMove.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="IntersSurfTmSurfTm.cpp">
       <Filter>File di origine\GeoInters</Filter>
@@ -400,19 +397,19 @@
       <Filter>File di origine\Geo</Filter>
     </ClCompile>
     <ClCompile Include="CDeCylTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeBoxClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeCylClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeSpheTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeSpheClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="SurfBezier.cpp">
       <Filter>File di origine\Geo</Filter>
@@ -430,34 +427,34 @@
       <Filter>File di origine\GeoDist</Filter>
     </ClCompile>
     <ClCompile Include="CDeTriaTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeConeTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeUtility.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeClosedSurfTmClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeConeFrustumClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeConeFrustumTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeConvexTorusClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeConvexTorusTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeRectPrismoidClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeRectPrismoidTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="SurfTriMeshUtilities.cpp">
       <Filter>File di origine\Geo</Filter>
@@ -469,7 +466,7 @@
       <Filter>File di origine\Base</Filter>
     </ClCompile>
     <ClCompile Include="CDeCapsTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="Circle2P.cpp">
       <Filter>File di origine\GeoCreate</Filter>
@@ -510,6 +507,36 @@
     <ClCompile Include="PolygonElevation.cpp">
       <Filter>File di origine\GeoElevation</Filter>
     </ClCompile>
+    <ClCompile Include="IntersCurveSurfTm.cpp">
+      <Filter>File di origine\GeoInters</Filter>
+    </ClCompile>
+    <ClCompile Include="CAvSimpleSurfFrMove.cpp">
+      <Filter>File di origine\GeoCollisionAvoid</Filter>
+    </ClCompile>
+    <ClCompile Include="CAvToolSurfTm.cpp">
+      <Filter>File di origine\GeoCollisionAvoid</Filter>
+    </ClCompile>
+    <ClCompile Include="CAvToolTriangle.cpp">
+      <Filter>File di origine\GeoCollisionAvoid</Filter>
+    </ClCompile>
+    <ClCompile Include="IntersLineVolZmap.cpp">
+      <Filter>File di origine\GeoInters</Filter>
+    </ClCompile>
+    <ClCompile Include="IntersPlaneVolZmap.cpp">
+      <Filter>File di origine\GeoInters</Filter>
+    </ClCompile>
+    <ClCompile Include="SbzStandard.cpp">
+      <Filter>File di origine\GeoCreate</Filter>
+    </ClCompile>
+    <ClCompile Include="RotationMinimizingFrame.cpp">
+      <Filter>File di origine\Base</Filter>
+    </ClCompile>
+    <ClCompile Include="RotationXplaneFrame.cpp">
+      <Filter>File di origine\Base</Filter>
+    </ClCompile>
+    <ClCompile Include="Quaternion.cpp">
+      <Filter>File di origine\Base</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="stdafx.h">
@@ -1169,6 +1196,24 @@
     <ClInclude Include="Voronoi.h">
       <Filter>File di intestazione</Filter>
     </ClInclude>
+    <ClInclude Include="..\Include\EGkIntersCurveSurfTm.h">
+      <Filter>File di intestazione\Include</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Include\EGkIntersPlaneVolZmap.h">
+      <Filter>File di intestazione\Include</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Include\EGkIntersLineVolZmap.h">
+      <Filter>File di intestazione\Include</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Include\EGkRotationMinimizingFrame.h">
+      <Filter>File di intestazione\Include</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Include\EGkRotationXplaneFrame.h">
+      <Filter>File di intestazione\Include</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Include\EGkQuaternion.h">
+      <Filter>File di intestazione\Include</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtGeomKernel.rc">

ExtDimension.cpp

@@ -21,12 +21,14 @@
 #include "FontManager.h"
 #include "FontAux.h"
 #include "CurveArc.h"
+#include "IntersLineLine.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkExtText.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include <new>
+#include <algorithm>
 
 using namespace std ;
 
@@ -63,7 +65,7 @@ ExtDimension::~ExtDimension( void)
 //----------------------------------------------------------------------------
 bool
 ExtDimension::SetStyle( double dExtLineLen, double dArrowLen, double dTextDist, bool bLenIsMM,
-   int nDecDigit, const string& sFont, double dTextHeight)
+                        int nDecDigit, const string& sFont, double dTextHeight)
 {
    m_dExtLineLen = max( dExtLineLen, MIN_EXTLINELEN) ;
    m_dArrowLen = max( dArrowLen, MIN_ARROWLEN) ;
@@ -200,7 +202,7 @@ ExtDimension::SetDiametral( const Point3d& ptCen, const Point3d& ptPos,
 
 //----------------------------------------------------------------------------
 bool
-ExtDimension::SetAngular( const Point3d& ptP1, const Point3d& ptV, const Point3d& ptP2, const Point3d& ptPos,
+ExtDimension::SetAngular( const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptPos,
                           const Vector3d& vtN, const string& sText)
 {
   // dichiaro quota non ancora determinata
@@ -209,17 +211,16 @@ ExtDimension::SetAngular( const Point3d& ptP1, const Point3d& ptV, const Point3d
    m_vtN = vtN ;
    if ( ! m_vtN.Normalize())
       return false ;
-  // porto i punti nel piano definito da P1 e N
-   m_ptP1 = ptP1 ;
-   m_ptP2 = ptP2 - ( ptP2 - m_ptP1) * m_vtN * m_vtN ;
-   m_ptP6 = ptV - ( ptV - m_ptP1) * m_vtN * m_vtN ;
-   m_ptPos = ptPos - ( ptPos - m_ptP1) * m_vtN * m_vtN ;
-  // verifico che i punti di misura non siano coincidenti
-   if ( AreSamePointApprox( m_ptP1, m_ptP2)  ||  AreSamePointApprox( m_ptP1, m_ptP6)  ||  AreSamePointApprox( m_ptP2, m_ptP5))
-      return false ;
-  // direzione di riferimento ( nel piano perpendicolare a vtN)
+  // porto i punti e le direzioni nel piano definito da V e N
+   m_ptP6 = ptV ;
+   m_ptPos = ptPos - ( ptPos - m_ptP6) * m_vtN * m_vtN ;
    m_vtDir = m_ptPos - m_ptP6 ;
    double dLenDir = m_vtDir.Len() ;
+   Vector3d vtLine1 = OrthoCompo( ptP1 - m_ptP6, m_vtN) ;
+   Vector3d vtLine2 = OrthoCompo( ptP2 - m_ptP6, m_vtN) ;
+  // verifico che i punti di misura non siano coincidenti
+   if ( ! vtLine1.Normalize()  ||  ! vtLine2.Normalize()  ||  dLenDir < EPS_SMALL)
+      return false ;
 
   // controllo se è testo o se è la misura
    double dFactor ;
@@ -243,20 +244,12 @@ ExtDimension::SetAngular( const Point3d& ptP1, const Point3d& ptV, const Point3d
       m_vtDir = m_ptPos - m_ptP6 ;
       dLenDir = m_vtDir.Len() ;
    }
-  // calcolo le direzioni su cui giacciono i due lati dell'angolo
-   Vector3d vtLine1 = m_ptP1 - m_ptP6 ;
-   Vector3d vtLine2 = m_ptP2 - m_ptP6 ;
-   double dLen1 = vtLine1.Len() ;
-   double dLen2 = vtLine2.Len() ;
-   if ( ! vtLine1.Normalize()  ||  ! vtLine2.Normalize())
-      return false ;
-  // segnalo se i punti che definiscono i lati sono più lontani dal centro di ptPos
-   bool bPt1Close = ( dLenDir < dLen1 ? true : false) ;
-   bool bPt2Close = ( dLenDir < dLen2 ? true : false) ;
-   m_ptP5 = m_ptP1 + ( dLenDir - dLen1) * vtLine1 ;
-   Point3d ptP5_bis = m_ptP2 + ( dLenDir - dLen2) * vtLine2 ;
-   m_ptP3 = m_ptP5 + ( bPt1Close ? - vtLine1 : vtLine1) * m_dExtLineLen ;
-   m_ptP4 = ptP5_bis + ( bPt2Close ? - vtLine2 : vtLine2) * m_dExtLineLen ;
+  // assegno gli altri punti notevoli della quotatura
+   m_ptP1 = m_ptP6 ;
+   m_ptP2 = m_ptP6 ;
+   m_ptP5 = m_ptP6 + vtLine1 * dLenDir ;
+   m_ptP3 = m_ptP6 + vtLine1 * ( dLenDir + m_dExtLineLen) ;
+   m_ptP4 = m_ptP6 + vtLine2 * ( dLenDir + m_dExtLineLen) ;
 
   // assegnazione del testo
    m_sText = sText ;
@@ -266,7 +259,99 @@ ExtDimension::SetAngular( const Point3d& ptP1, const Point3d& ptV, const Point3d
    m_bToCalc = true ;
    m_OGrMgr.Reset() ;
 
-   return true;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ExtDimension::SetAngularEx( const Point3d& ptV1, const Point3d& ptP1,
+                            const Point3d& ptV2, const Point3d& ptP2, const Point3d& ptPos,
+                            const Vector3d& vtN, const string& sText)
+{
+  // dichiaro quota non ancora determinata
+   m_nType = DT_NONE ;
+  // verifico la definizione del versore normale
+   m_vtN = vtN ;
+   if ( ! m_vtN.Normalize())
+      return false ;
+  // calcolo l'intersezione tra le due linee
+   CurveLine Line1 ;
+   if ( ! Line1.Set( ptV1, ptP1)  ||  ! Line1.SetExtrusion( m_vtN))
+      return false ;
+   CurveLine Line2 ;
+   if ( ! Line2.Set( ptV2, ptP2)  ||  ! Line2.SetExtrusion( m_vtN))
+      return false ;
+   IntersLineLine IntLL( Line1, Line2, false) ;
+   IntCrvCrvInfo Info ;
+   if ( ! IntLL.GetIntCrvCrvInfo( Info)  ||  Info.bOverlap)
+      return false ;
+   Point3d ptV = Media( Info.IciA[0].ptI, Info.IciB[0].ptI) ;
+  // porto i punti e le direzioni nel piano definito da V1 e N
+   m_ptP6 = ptV ;
+   m_ptPos = ptPos - ( ptPos - m_ptP6) * m_vtN * m_vtN ;
+   m_vtDir = m_ptPos - m_ptP6 ;
+   double dLenDir = m_vtDir.Len() ;
+   Vector3d vtLine1 = OrthoCompo( ptP1 - m_ptP6, m_vtN) ;
+   Vector3d vtLine2 = OrthoCompo( ptP2 - m_ptP6, m_vtN) ;
+  // verifico che i punti di misura non siano coincidenti
+   if ( ! vtLine1.Normalize()  ||  ! vtLine2.Normalize()  ||  dLenDir < EPS_SMALL)
+      return false ;
+
+  // controllo se è testo o se è la misura
+   double dFactor ;
+   if ( m_sCalcText.find( IS_MEASURE) != string::npos) {
+      m_sCalcText = "300.00" ;
+      double dHalfDist = GetTextHalfDist( m_ptPos) ;
+      dFactor = 2.5 * dHalfDist ;
+      m_sCalcText = "" ;
+   }
+   else {
+      double dHalfDist = GetTextHalfDist( m_ptPos) ;
+      dFactor = 2.5 * dHalfDist ;
+   }
+  // allungo m_vtDir se è troppo vicino al centro
+   if ( m_vtDir.Len() < dFactor) {
+      Vector3d vtDir_n = m_vtDir ;
+      if ( ! vtDir_n.Normalize())
+         return false ;
+      m_ptPos = m_ptP6 + dFactor * vtDir_n ;
+     // ricalcolo m_vtDir
+      m_vtDir = m_ptPos - m_ptP6 ;
+      dLenDir = m_vtDir.Len() ;
+   }
+  // assegno gli altri punti notevoli della quotatura
+  // se i ptV concidono con l'intersezione tra le linee le sposto leggermente verso l'altro punto di quel lato
+   Point3d ptV1New = ptV1 ;
+   Point3d ptV2New = ptV2 ;
+   if ( AreSamePointApprox( ptV1, ptV)) {
+      Vector3d vtDir1 ; Line1.GetStartDir( vtDir1) ;
+      double dLen ; Line1.GetLength( dLen) ;
+      dLen = max( min( 1., dLen/ 10), 0.01) ;
+      ptV1New = ptV1 + vtDir1 * dLen ;
+   }
+   if ( AreSamePointApprox( ptV2, ptV)) {
+      Vector3d vtDir2 ; Line2.GetStartDir( vtDir2) ;
+      double dLen ; Line2.GetLength( dLen) ;
+      dLen = max( min( 1., dLen/ 10), 0.01) ;
+      ptV2New = ptV2 + vtDir2 * dLen ;
+   }
+   m_ptP1 = ptV1New - ( ptV1New - m_ptP6) * m_vtN * m_vtN ;
+   m_ptP2 = ptV2New - ( ptV2New - m_ptP6) * m_vtN * m_vtN ;
+   m_ptP5 = m_ptP6 + vtLine1 * dLenDir ;
+   double dLen1 = Dist( m_ptP6, m_ptP1) ;
+   m_ptP3 = m_ptP6 + vtLine1 * ( dLenDir + m_dExtLineLen * ( dLen1 < dLenDir ? 1 : -1)) ;
+   double dLen2 = Dist( m_ptP6, m_ptP2) ;
+   m_ptP4 = m_ptP6 + vtLine2 * ( dLenDir + m_dExtLineLen * ( dLen2 < dLenDir ? 1 : -1)) ;
+
+  // assegnazione del testo
+   m_sText = sText ;
+  // assegno il tipo
+   m_nType = DT_ANGULAR ;
+  // imposto da calcolare
+   m_bToCalc = true ;
+   m_OGrMgr.Reset() ;
+
+   return true ;
 }
 
 //----------------------------------------------------------------------------
@@ -1012,6 +1097,7 @@ ExtDimension::Update( void) const
       if ( ! GetTextMyBBox( b3Text)  &&  ! b3Text.IsEmpty())
          return false ;
       double dHeight = b3Text.GetMax().y - b3Text.GetMin().y ;
+      double dLength = b3Text.GetMax().x - b3Text.GetMin().x ;
       Vector3d vtPerpDir = m_ptPos - m_ptP6 ;
       if ( ! vtPerpDir.Normalize())
          return false ;
@@ -1020,11 +1106,11 @@ ExtDimension::Update( void) const
       if ( ! frRef.Set( m_ptP6, m_vtN))
          return false ;
       double dAngDeg = 0 ;
-      if ( ! m_vtDir.GetAngle( frRef.VersX(), dAngDeg) || ! vtPerpDir.Rotate( m_vtN, ( dAngDeg < 90 ? 90 : -90)))
+      if ( ! m_vtDir.GetAngle( frRef.VersX(), dAngDeg)  ||  ! vtPerpDir.Rotate( m_vtN, ( dAngDeg < 90 ? 90 : -90)))
          return false ;
       m_ptCalcPos = m_ptCalcPos + 0.6 * dHeight * vtPerpDir ;
      // semidistanza di interruzione
-      double dHalfDist = GetTextHalfDist( m_ptCalcPos) ;
+      double dHalfDist = GetTextHalfDist( m_ptCalcPos, false) ;
      // lunghezza della linea di misura
       double dLen = Dist( m_ptP1, m_ptP2) ;
      // determino come orientare le frecce e dove mettere il testo
@@ -1049,7 +1135,16 @@ ExtDimension::Update( void) const
          Vector3d vtRad = m_ptPos - m_ptP5 ;
          if ( ! vtRad.Normalize())
             return false ;
-         m_ptCalcPos = m_ptPos + vtRad * ( dHalfDist + 2 * m_dArrowLen) ;
+         m_ptCalcPos = m_ptPos + vtRad * ( 2 * m_dArrowLen + m_dTextDist) ;
+         const double COMP_LIM = 0.1 ; // circa 5.7deg
+         if ( vtRad.x > COMP_LIM)
+            m_ptCalcPos += dLength / 2 * X_AX ;
+         else if ( vtRad.x < -COMP_LIM)
+            m_ptCalcPos -= dLength / 2 * X_AX ;
+         if ( vtRad.y > COMP_LIM)
+            m_ptCalcPos += dHeight / 2 * Y_AX ;
+         else if ( vtRad.y < -COMP_LIM)
+            m_ptCalcPos -= dHeight / 2 * Y_AX ;
       }
      // dichiaro ricalcolo eseguito
       m_bToCalc = false ;
@@ -1058,8 +1153,8 @@ ExtDimension::Update( void) const
    case DT_ANGULAR : {
      // angolo
       double dAngDeg, dAngDeg1, dAngDeg2 = 0 ;
-      Vector3d vtLine1 = m_ptP1 - m_ptP6 ;
-      Vector3d vtLine2 = m_ptP2 - m_ptP6 ;
+      Vector3d vtLine1 = m_ptP3 - m_ptP6 ;
+      Vector3d vtLine2 = m_ptP4 - m_ptP6 ;
       Vector3d vtLine3 = m_ptPos - m_ptP6 ;
      // calcolo gli angoli tra m_ptPos e i due punti che identificano i lati dell'angolo
      // per capire se sto calcolando l'angolo interno o esterno
@@ -1074,10 +1169,9 @@ ExtDimension::Update( void) const
          ReplaceString( m_sCalcText, IS_MEASURE, sAngDeg + "°") ;
       }
      // calcolo ptP5_bis
-      double dLen2 = vtLine2.Len() ;
       if ( ! vtLine2.Normalize())
          return false ;
-      Point3d ptP5_bis = m_ptP2 + ( m_vtDir.Len() - dLen2) * vtLine2 ;
+      Point3d ptP5_bis = m_ptP6 + m_vtDir.Len() * vtLine2 ;
      // calcolo l'arco su cui metterò la misura
       PtrOwner<CurveArc> pCrvPos( CreateBasicCurveArc()) ;
       if ( IsNull( pCrvPos)  ||  ! pCrvPos->Set3P( ptP5_bis, m_ptPos, m_ptP5, false))
@@ -1288,15 +1382,12 @@ ExtDimension::ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST&
       if ( IsNull( pCrvPos))
          return false ;
      // calcolo ptP5_bis
-      Vector3d vtLine2 = m_ptP2 - m_ptP6 ;
-      double dLen2 = vtLine2.Len() ;
+      Vector3d vtLine2 = m_ptP4 - m_ptP6 ;
       if ( ! vtLine2.Normalize())
          return false ;
-      Point3d ptP5_bis = m_ptP2 + ( m_vtDir.Len() - dLen2) * vtLine2 ;
+      Point3d ptP5_bis = m_ptP6 + m_vtDir.Len() * vtLine2 ;
      // approssimerò l'arco con una polyline
       PolyLine plApprox ;
-      double dLinTol = 0.01 ;
-      double dAngTolDeg = 0.01 ;
      // se non ho testo 
       if ( IsEmptyOrSpaces( m_sCalcText)  ||  ! m_bCalcTextOn) {
          if ( ! pCrvPos->SetC2PN( m_ptP6, ptP5_bis, m_ptP5, m_vtN)   ||  ! pCrvPos->ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, plApprox))
@@ -1337,7 +1428,7 @@ ExtDimension::ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST&
          dFactor = 0 ;
       }
       lstPL.emplace_back() ;
-      Vector3d vtLine1 = m_ptP1 - m_ptP6 ;
+      Vector3d vtLine1 = m_ptP3 - m_ptP6 ;
       if ( ! vtLine1.Normalize())
          return false ;
       GetArrowHead( m_ptP5, ( m_bCalcArrowIn ? vtEndDir : - vtEndDir) + vtLine1 * dFactor, lstPL.back()) ;
@@ -1356,23 +1447,25 @@ ExtDimension::ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST&
 
 //----------------------------------------------------------------------------
 double
-ExtDimension::GetTextHalfDist( const Point3d& ptText) const
+ExtDimension::GetTextHalfDist( const Point3d& ptText, bool bUseRot) const
 {
   // semi distanza di interruzione
    double dHalfDist = m_dTextHeight / 2 + m_dTextDist ;
   // recupero il box di ingombro del testo
    BBox3d b3Text ;
-   Vector3d vtDir = m_vtDir ;
-   if ( m_nType == DT_ANGULAR)
-      vtDir.Normalize() ;
    if ( GetTextMyBBox( ptText, b3Text)  &&  ! b3Text.IsEmpty()) {
       double dHalfL = ( b3Text.GetMax().x - b3Text.GetMin().x) / 2 ;
       double dHalfH = ( b3Text.GetMax().y - b3Text.GetMin().y) / 2 ;
       dHalfDist = sqrt( dHalfL * dHalfL + dHalfH * dHalfH) ;
-      if ( abs( vtDir.x) > EPS_ZERO)
-         dHalfDist = min( dHalfDist, dHalfL / abs( vtDir.x)) ;
-      if ( abs( vtDir.y) > EPS_ZERO)
-         dHalfDist = min( dHalfDist, dHalfH / abs( vtDir.y)) ;
+      if ( bUseRot) {
+         Vector3d vtDir = m_vtDir ;
+         vtDir.Normalize() ;
+         double dCoeff = ( dHalfH > 1 ? dHalfL / dHalfH : 0) ;
+         if ( abs( vtDir.x) > dCoeff * abs( vtDir.y))
+            dHalfDist = min( dHalfDist, dHalfL / abs( vtDir.x)) ;
+         else
+            dHalfDist = min( dHalfDist, dHalfH / abs( vtDir.y)) ;
+      }
       dHalfDist += m_dTextDist ;
    }
    return dHalfDist ;

ExtDimension.h

@@ -28,7 +28,7 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
       ExtDimension* Clone( void) const override ;
       GeoObjType GetType( void) const override ;
       bool IsValid( void) const override
-        { return ( m_nType != DT_NONE) ; }
+               { return ( m_nType != DT_NONE) ; }
       const std::string& GetTitle( void) const override ;
       bool Dump( std::string& sOut, bool bMM = true, const char* szNewLine = "\n") const override ;
       bool GetLocalBBox( BBox3d& b3Loc, int nFlag = BBF_STANDARD) const override ;
@@ -71,8 +71,11 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
                       const Vector3d& vtN, const std::string& sText) override ;
       bool SetDiametral( const Point3d& ptCen, const Point3d& ptPos,
                          const Vector3d& vtN, const std::string& sText) override ;
-      bool SetAngular( const Point3d& ptP1, const Point3d& ptV, const Point3d& ptP2, const Point3d& ptPos,
+      bool SetAngular( const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptPos,
                        const Vector3d& vtN, const std::string& sText) override ;
+      bool SetAngularEx( const Point3d& ptV1, const Point3d& ptP1,
+                         const Point3d& ptV2, const Point3d& ptP2, const Point3d& ptPos,
+                         const Vector3d& vtN, const std::string& sText) override ;
       const Vector3d& GetNormVersor( void) const override
                         { return m_vtN ; } 
       const Vector3d& GetDirVersor( void) const override
@@ -105,12 +108,16 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
                         { return m_dTextHeight ; }
       bool GetMidPoint( Point3d& ptMid) const override ;
       bool GetCenterPoint( Point3d& ptCen) const override ;
+      const std::string& GetSubType( void) const override ;
       bool ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST& lstPL) const override ;
 
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
+      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
+      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
+      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       ExtDimension( void) ;
@@ -124,9 +131,8 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
 
    private :
       bool CopyFrom( const ExtDimension& gpSrc) ;
-      const std::string& GetSubType( void) const ;
       bool Update( void) const ;
-      double GetTextHalfDist( const Point3d& ptText) const ;
+      double GetTextHalfDist( const Point3d& ptText, bool bUseRot = true) const ;
       bool GetArrowHead( const Point3d& ptTip, const Vector3d& vtDir, PolyLine& PL) const ;
       bool SetCurrFont( FontManager& fntMgr) const ;
       bool ApproxTextWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST& lstPL) const ;

ExtText.h

@@ -113,7 +113,10 @@ class ExtText : public IExtText, public IGeoObjRW
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
+      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
+      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
+      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       ExtText( void) ;

FilletChamfer.cpp

@@ -18,6 +18,7 @@
 #include "/EgtDev/Include/EGkFilletChamfer.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkIntersCurves.h"
+#include "/EgtDev/Include/EgkOffsetCurve.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 using namespace std ;
@@ -40,13 +41,21 @@ CalcForFillet( const ICurve& cCrv1, const Point3d& ptNear1,
    if ( ! dPC1.GetSideAtMinDistPoint( 0, vtNorm, nSide1))
       return false ;
    double dOffs1 = ( nSide1 == MDS_RIGHT ? dRadius : - dRadius) ;
-  // calcolo l'offset nel piano locale e dal lato opportuno di una copia della curva 1
+  // calcolo gli offset nel piano locale e dal lato opportuno di una copia della curva 1
    PtrOwner<ICurve> pCopy1( cCrv1.Clone()) ;
    if ( IsNull( pCopy1))
       return false ;
    pCopy1->ToLoc( frIntr) ;
    pCopy1->SetExtrusion( Z_AX) ;
-   if ( ! pCopy1->SimpleOffset( dOffs1, ICurve::OFF_FILLET))
+   OffsetCurve OffsCrv1 ;
+   OffsCrv1.Make( pCopy1, dOffs1, ICurve::OFF_FILLET) ;
+   ICURVEPOVECTOR vOffs1 ;  
+   ICurve* pCrv = OffsCrv1.GetLongerCurve() ;
+   while ( pCrv != nullptr) {
+      vOffs1.emplace_back( pCrv) ;
+      pCrv = OffsCrv1.GetLongerCurve() ;
+   }
+   if ( vOffs1.empty())
       return false ;
 
   // determino il lato di offset della curva 2
@@ -54,23 +63,50 @@ CalcForFillet( const ICurve& cCrv1, const Point3d& ptNear1,
    if ( ! dPC2.GetSideAtMinDistPoint( 0, vtNorm, nSide2))
       return false ;
    double dOffs2 = ( nSide2 == MDS_RIGHT ? dRadius : - dRadius) ;
-  // calcolo l'offset nel piano locale e dal lato opportuno di una copia della curva 2
+  // calcolo gli offset nel piano locale e dal lato opportuno di una copia della curva 2
    PtrOwner<ICurve> pCopy2( cCrv2.Clone()) ;
    if ( IsNull( pCopy2))
       return false ;
    pCopy2->ToLoc( frIntr) ;
    pCopy2->SetExtrusion( Z_AX) ;
-   if ( ! pCopy2->SimpleOffset( dOffs2, ICurve::OFF_FILLET))
+   OffsetCurve OffsCrv2 ;
+   OffsCrv2.Make( pCopy2, dOffs2, ICurve::OFF_FILLET) ;
+   ICURVEPOVECTOR vOffs2 ;
+   pCrv = OffsCrv2.GetLongerCurve() ;
+   while ( pCrv != nullptr) {
+      vOffs2.emplace_back( pCrv) ;
+      pCrv = OffsCrv2.GetLongerCurve() ;
+   }
+   if ( vOffs2.empty())
       return false ;
 
-  // calcolo l'intersezione tra le due curve
-   Point3d ptInt1, ptInt2 ;
+  // calcolo le intersezioni tra tutte le curve di offset e seleziono quella più vicina ai punti passati
+   Point3d ptInt1 = P_INVALID, ptInt2 = P_INVALID ;
    Point3d ptNearI = Media( ptNear1, ptNear2) ;
    ptNearI.ToLoc( frIntr) ;
-   IntersCurveCurve intCC( *pCopy1, *pCopy2) ;
-   if ( ! intCC.GetIntersPointNearTo( 0, ptNearI, ptInt1)  ||
-        ! intCC.GetIntersPointNearTo( 1, ptNearI, ptInt2))
-      return false ;
+   double dMinDist = INFINITO ;
+   for ( int i = 0 ; i < int( vOffs1.size()) ; i++) {
+      for ( int j = 0 ; j < int( vOffs2.size()) ; j ++) {
+         IntersCurveCurve intCC( *vOffs1[i], *vOffs2[j]) ;
+         if ( intCC.GetIntersCount() == 0)
+            continue ;
+         Point3d ptInt1Curr, ptInt2Curr ;
+         if ( ! intCC.GetIntersPointNearTo( 0, ptNearI, ptInt1Curr)  ||
+              ! intCC.GetIntersPointNearTo( 1, ptNearI, ptInt2Curr))
+            return false ;
+         Point3d ptCenCurr = Media( ptInt1Curr, ptInt2Curr) ;
+         double dDist = Dist( ptNearI, ptCenCurr) ;
+         if ( dDist < dMinDist - EPS_SMALL) {
+            dMinDist = dDist ;
+            ptInt1 = ptInt1Curr ;
+            ptInt2 = ptInt2Curr ;
+         }
+      }  
+   }
+  // se non sono state trovate intersezioni esco
+   if ( ! ptInt1.IsValid()  ||  ! ptInt2.IsValid())
+      return false ;   
+   
    ptInt1.ToGlob( frIntr) ;
    ptInt2.ToGlob( frIntr) ;
    ptCen = Media( ptInt1, ptInt2) ;
@@ -105,7 +141,7 @@ CreateFillet( const ICurve& cCrv1, const Point3d& ptNear1,
               const ICurve& cCrv2, const Point3d& ptNear2,
               const Vector3d& vtNorm, double dRadius, double& dPar1, double& dPar2)
 {
-  // verifico validità parametri ricevuti
+  // verifico validità parametri ricevuti
    if ( &cCrv1 == nullptr  ||  &ptNear1 == nullptr  ||
         &cCrv2 == nullptr  ||  &ptNear2 == nullptr  ||
         &vtNorm == nullptr  ||  &dPar1 == nullptr  ||  &dPar2 == nullptr)
@@ -119,7 +155,7 @@ CreateFillet( const ICurve& cCrv1, const Point3d& ptNear1,
                          ptCen, ptTg1, ptTg2, nSide1, nSide2, dSinA, dTgPar1, dTgPar2))
       return nullptr ;
 
-  // se tangenti parallele al contatto con fillet, ricalcolo con raggio più piccolo
+  // se tangenti parallele al contatto con fillet, ricalcolo con raggio più piccolo
    bool bParallel = ( abs( dSinA) < EPS_SMALL) ;
    if ( bParallel) {
       Point3d ptQQQ, ptQQ1, ptQQ2 ;
@@ -165,7 +201,7 @@ CreateChamfer( const ICurve& cCrv1, const Point3d& ptNear1,
                const ICurve& cCrv2, const Point3d& ptNear2,
                const Vector3d& vtNorm, double dDist, double& dPar1, double& dPar2)
 {
-  // verifico validità parametri ricevuti
+  // verifico validità parametri ricevuti
    if ( &cCrv1 == nullptr  ||  &ptNear1 == nullptr  ||
         &cCrv2 == nullptr  ||  &ptNear2 == nullptr  ||
         &vtNorm == nullptr  ||  &dPar1 == nullptr  ||  &dPar2 == nullptr)

GdbGeo.cpp

@@ -101,6 +101,10 @@ GdbGeo::Save( int nBaseId, NgeWriter& ngeOut, INTUNORDSET* pSavedIds) const
    if ( pGObjRW == nullptr)
       return false ;
 
+  // eventuali modifiche prima del salvataggio
+   if ( ! pGObjRW->PreSave( * const_cast<GdbGeo*>( this)))
+      return false ;
+
   // tipo entità e identificativi
    if ( ! ngeOut.WriteKey( pGObjRW->GetNgeId()))
       return false ;
@@ -124,7 +128,11 @@ GdbGeo::Save( int nBaseId, NgeWriter& ngeOut, INTUNORDSET* pSavedIds) const
   // parametri geometrici
    if ( ! ngeOut.WriteKey( NGE_G))
       return false ;
-   return pGObjRW->Save( ngeOut) ;
+   if ( ! pGObjRW->Save( ngeOut))
+      return false ;
+
+  // eventuali ripristini dopo il salvataggio
+   return pGObjRW->PostSave( * const_cast<GdbGeo*>( this)) ;
 }
 
 //----------------------------------------------------------------------------
@@ -181,7 +189,7 @@ GdbGeo::Load( int nNgeId, NgeReader& ngeIn, int nBaseGdbId, int& nParentId)
 
   // parametri geometrici
    IGeoObjRW* pGObjRW = dynamic_cast<IGeoObjRW*>( m_pGeoObj) ;
-   return ( pGObjRW != nullptr  &&  pGObjRW->Load( ngeIn)) ;
+   return ( pGObjRW != nullptr  &&  pGObjRW->Load( ngeIn)  &&  pGObjRW->PostLoad( *this)) ;
 }
 
 //----------------------------------------------------------------------------

GeoFrame3d.h

@@ -83,7 +83,10 @@ class GeoFrame3d : public IGeoFrame3d, public IGeoObjRW
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
+      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
+      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
+      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       GeoFrame3d( void) ;

GeoObjRW.h

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2014
+//  EgalTech 2014-2024
 //----------------------------------------------------------------------------
-// File : GeoObjRW.h           Data : 14.03.14          Versione : 1.5d5
+// File : GeoObjRW.h           Data : 08.03.24          Versione : 2.6c2
 // Contenuto : Dichiarazione della interfaccia IGeoObjRW.
 //
 //
 //
 // Modifiche : 20.11.13 DS Creazione modulo.
-//
+//             08.03.24 DS Aggiunte PreSave, PostSave, PreLoad e PostLoad.
 //
 //----------------------------------------------------------------------------
 
@@ -15,6 +15,7 @@
 
 class NgeWriter ;
 class NgeReader ;
+class GdbGeo ;
 
 //-----------------------------------------------------------------------------
 class __declspec( novtable) IGeoObjRW
@@ -22,5 +23,8 @@ class __declspec( novtable) IGeoObjRW
    public :
       virtual int GetNgeId( void) const = 0 ;
       virtual bool Save( NgeWriter& ngeOut) const = 0 ;
+      virtual bool PreSave( GdbGeo& Wrapper) const = 0 ;
+      virtual bool PostSave( GdbGeo& Wrapper) const = 0 ;
       virtual bool Load( NgeReader& ngeIn) = 0 ;
+      virtual bool PostLoad( GdbGeo& Wrapper) = 0 ;
 } ;

GeoPoint3d.h

@@ -77,7 +77,10 @@ class GeoPoint3d : public IGeoPoint3d, public IGeoObjRW
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
+      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
+      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
+      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       GeoPoint3d( void) ;

GeoVector3d.h

@@ -91,7 +91,10 @@ class GeoVector3d : public IGeoVector3d, public IGeoObjRW
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
+      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
+      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
+      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
    
    public :
       GeoVector3d( void) ;

IntersCurveSurfTm.cpp

@@ -0,0 +1,223 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : IntersCurveSurfTm.cpp      Data : 23.02.24        Versione : 2.6b4
+// Contenuto : Implementazione della intersezione curva/superficie trimesh.
+//
+//
+//
+// Modifiche : 23.02.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "GeoConst.h"
+#include "/EgtDev/Include/EGkIntersLineTria.h"
+#include "/EgtDev/Include/EGkIntersCurveSurfTm.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+static void
+UpdateInfoIntersCurveSurfTm( const Point3d& ptL, const Vector3d& vtDir, double dLen, double dUs, double dUe,
+                             int nT, const Triangle3d& Tria, ICSIVECTOR& vInfo)
+{
+   Point3d ptInt, ptInt2 ;
+   int nRes = IntersLineTria( ptL, vtDir, dLen, Tria, ptInt, ptInt2, true) ;
+   if ( nRes == ILTT_IN  ||  nRes == ILTT_EDGE  ||  nRes == ILTT_VERT) {
+      double dU = dUs + ( ptInt - ptL) * vtDir / dLen * ( dUe - dUs) ;
+      double dCosDN = vtDir * Tria.GetN() ;
+      vInfo.emplace_back( nRes, dU, nT, dCosDN, ptInt) ;
+   }
+   else if ( nRes == ILTT_SEGM  ||  nRes == ILTT_SEGM_ON_EDGE) {
+      double dU = dUs + ( ptInt - ptL) * vtDir / dLen * ( dUe - dUs) ;
+      double dU2 = dUs + ( ptInt2 - ptL) * vtDir / dLen * ( dUe - dUs) ;
+      double dCosDN = vtDir * Tria.GetN() ;
+      vInfo.emplace_back( nRes, dU, dU2, nT, dCosDN, ptInt, ptInt2) ;
+   }
+}
+
+//----------------------------------------------------------------------------
+static void
+OrderInfoIntersCurveSurfTm( ICSIVECTOR& vInfo)
+{
+  // se non trovati, esco 
+   if ( vInfo.size() == 0)
+      return ;
+  // ordino il vettore delle intersezioni secondo il senso crescente del parametro di linea
+   sort( vInfo.begin(), vInfo.end(), 
+            []( const IntCrvStmInfo& a, const IntCrvStmInfo& b)
+               {  double dUa = ( ( a.nILTT == ILTT_SEGM  ||  a.nILTT == ILTT_SEGM_ON_EDGE) ? ( a.dU + a.dU2) / 2 : a.dU) ;
+                  double dUb = ( ( b.nILTT == ILTT_SEGM  ||  b.nILTT == ILTT_SEGM_ON_EDGE) ? ( b.dU + b.dU2) / 2 : b.dU) ;
+                  return ( dUa < dUb) ; }) ;
+}
+
+//----------------------------------------------------------------------------
+//  Intersezione di una curva con una superficie TriMesh
+//----------------------------------------------------------------------------
+bool
+IntersCurveSurfTm( const ICurve& Curve, const ISurfTriMesh& Stm, double dLinTol, ICSIVECTOR& vInfo)
+{
+  // verifico i parametri ricevuti
+   if ( & Curve == nullptr  ||  &Stm == nullptr  ||  &vInfo == nullptr)
+      return false ;
+   dLinTol = max( dLinTol, EPS_SMALL) ;
+   vInfo.clear() ;
+
+  // approssimo la curva con una spezzata
+   PolyLine PL ;
+   if ( ! Curve.ApproxWithLines( dLinTol, ANG_TOL_APPROX_DEG, ICurve::APL_SPECIAL, PL))
+      return false ;
+
+  // per ogni segmento dell'approssimante cerco l'intersezione con la superficie
+   double dParS, dParE ;
+   Point3d ptStart, ptEnd ;
+   bool bFound = PL.GetFirstULine( &dParS, &ptStart, &dParE, &ptEnd) ;
+   while ( bFound) {
+      Vector3d vtDir = ptEnd - ptStart ;
+      double dLen = vtDir.Len() ;
+      if ( dLen > EPS_SMALL) {
+         vtDir /= dLen ;
+        // cerco i triangoli intersecati dal segmento
+         const double BOX_STEP = 10 ;
+         int nStep = int( ceil( dLen / BOX_STEP)) ;
+         Vector3d vtStep = dLen / nStep * vtDir ;
+         INTVECTOR vPrevT ;
+         for ( int i = 0 ; i < nStep ; ++ i) {
+            BBox3d b3Box( ptStart + i * vtStep, ptStart + ( i + 1) * vtStep) ;
+            INTVECTOR vT ;
+            if ( Stm.GetAllTriaOverlapBox( b3Box, vT)) {
+               for ( auto nT : vT) {
+                 // se triangolo non ancora intersecato
+                  if ( find( vPrevT.begin(), vPrevT.end(), nT) == vPrevT.end()) {
+                     vPrevT.emplace_back( nT) ;
+                     Triangle3d Tria ;
+                     Stm.GetTriangle( nT, Tria) ;
+                    // aggiorno info con intersezione
+                     UpdateInfoIntersCurveSurfTm( ptStart, vtDir, dLen, dParS, dParE, nT, Tria, vInfo) ;
+                  }
+               }
+            }
+         }
+      }
+     // passo al segmento successivo
+      bFound = PL.GetNextULine( &dParS, &ptStart, &dParE, &ptEnd) ;
+   }
+
+  // ordino il vettore delle eventuali intersezioni secondo il senso crescente del parametro di linea
+   OrderInfoIntersCurveSurfTm( vInfo) ;
+   
+   return true ;
+}
+//----------------------------------------------------------------------------
+bool
+IntersCurveSurfTmExt( const ICurve& Curve, const ISurfTriMesh& Stm, double dLinTol, INTDBLVECTOR& vInters)
+{
+   ICSIVECTOR vInfo ;
+   vInters.clear() ;
+   return ( IntersCurveSurfTm( Curve, Stm, dLinTol, vInfo)  &&  FilterCurveSurfTmInters( Curve, vInfo, vInters)) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FilterCurveSurfTmInters( const ICurve& Curve, const ICSIVECTOR& vInfo, INTDBLVECTOR& vInters)
+{
+  // verifico i parametri ricevuti
+   if ( & Curve == nullptr  ||  &vInfo == nullptr  ||  &vInters == nullptr)
+      return false ;
+   vInters.clear() ;
+  // info sulla curva
+   bool bClosedCrv = Curve.IsClosed() ;
+   double dParSCrv, dParECrv ;
+   Curve.GetDomain( dParSCrv, dParECrv) ;
+   // ciclo sulle intersezioni
+   for ( const auto& Info : vInfo) {
+     // se intersezione puntuale
+      if ( Info.nILTT == ILTT_VERT  ||  Info.nILTT == ILTT_EDGE  ||  Info.nILTT == ILTT_IN) {
+         int nFlag = CSIT_NONE ;
+         if ( Info.dCosDN > EPS_ZERO)
+            nFlag = CSIT_IN_OUT ;
+         else if ( Info.dCosDN < -EPS_ZERO)
+            nFlag = CSIT_OUT_IN ;
+         vInters.emplace_back( nFlag, Info.dU) ;
+      }
+     // se altrimenti intersezione con coincidenza
+      else if ( Info.nILTT == ILTT_SEGM  ||  Info.nILTT == ILTT_SEGM_ON_EDGE) {
+         vInters.emplace_back( CSIT_IN_ON, Info.dU) ;
+         vInters.emplace_back( CSIT_ON_IN, Info.dU2) ;
+      }
+   }
+  // elimino intersezioni ripetute
+   int nStart = ( bClosedCrv ? 0 : 1) ;
+   for ( int j = nStart ; j < int( vInters.size()) ; ) {
+     // intersezione precedente
+      int i = ( j > 0 ? j - 1 : int( vInters.size()) - 1) ;
+     // se hanno lo stesso parametro 
+      if ( abs( vInters[i].second - vInters[j].second) < EPS_PARAM  ||
+           ( bClosedCrv  &&  abs( vInters[i].second - dParECrv) < EPS_PARAM  &&  abs( vInters[j].second - dParSCrv) < EPS_PARAM)) {
+        // flag per eseguita cancellazione
+         bool bSomeErased = false ;
+        // se sono entrambe entranti o uscenti, elimino la seconda
+         if ( ( vInters[i].first == CSIT_OUT_IN  &&  vInters[j].first == CSIT_OUT_IN)  ||
+              ( vInters[i].first == CSIT_IN_OUT  &&  vInters[j].first == CSIT_IN_OUT)) {
+            vInters.erase( vInters.begin() + j) ;
+            bSomeErased = true ;
+         }
+        // se una entrante e l'altra uscente, cambio in touch da fuori ed elimino la seconda
+         else if ( vInters[i].first == CSIT_OUT_IN  &&  vInters[j].first == CSIT_IN_OUT) {
+            vInters[i].first = CSIT_OUT_OUT ;
+            vInters.erase( vInters.begin() + j) ;
+            bSomeErased = true ;
+         }
+        // se una uscente e l'altra entrante, cambio in touch da dentro ed elimino la seconda
+         else if ( vInters[i].first == CSIT_IN_OUT  &&  vInters[j].first == CSIT_OUT_IN) {
+            vInters[i].first = CSIT_IN_IN ;
+            vInters.erase( vInters.begin() + j) ;
+            bSomeErased = true ;
+         }
+        // se una touch da fuori o da dentro e l'altra entrante o uscente, elimino la prima
+         else if ( ( vInters[i].first == CSIT_OUT_OUT  ||  vInters[i].first == CSIT_IN_IN)  &&
+                   ( vInters[j].first == CSIT_OUT_IN  ||  vInters[j].first == CSIT_IN_OUT)) {
+            vInters.erase( vInters.begin() + i) ;
+            bSomeErased = true ;
+         }
+        // se una entrante o uscente e l'altra touch da fuori o da dentro, elimino la seconda
+         else if ( ( vInters[i].first == CSIT_OUT_IN  ||  vInters[i].first == CSIT_IN_OUT)  &&
+                   ( vInters[j].first == CSIT_OUT_OUT  ||  vInters[j].first == CSIT_IN_IN)) {
+            vInters.erase( vInters.begin() + j) ;
+            bSomeErased = true ;
+         }
+        // se una puntuale e l'altra inizio di coincidenza, elimino la prima
+         else if ( ( vInters[i].first == CSIT_OUT_IN  ||  vInters[i].first == CSIT_IN_OUT  ||  vInters[i].first == CSIT_NONE)  &&
+                   ( vInters[j].first == CSIT_IN_ON  ||  vInters[j].first == CSIT_OUT_ON)) {
+            vInters[j].first = ( vInters[i].first == CSIT_IN_OUT ? CSIT_IN_ON : CSIT_OUT_ON) ;
+            vInters.erase( vInters.begin() + i) ;
+            bSomeErased = true ;
+         }
+        // se una fine di coincidenza e l'altra puntuale, elimino la seconda
+         else if ( ( vInters[i].first == CSIT_ON_IN  ||  vInters[i].first == CSIT_ON_OUT)  &&
+                   ( vInters[j].first == CSIT_OUT_IN  ||  vInters[j].first == CSIT_IN_OUT  ||  vInters[j].first == CSIT_NONE)) {
+            vInters[i].first = ( vInters[j].first == CSIT_IN_OUT ? CSIT_ON_OUT : CSIT_ON_IN) ;
+            vInters.erase( vInters.begin() + j) ;
+            bSomeErased = true ;
+         }
+        // se una fine di coincidenza e l'altra inizio di coincidenza, elimino entrambe
+         else if ( ( vInters[i].first == CSIT_ON_IN  ||  vInters[i].first == CSIT_ON_OUT)  &&
+                   ( vInters[j].first == CSIT_IN_ON  ||  vInters[j].first == CSIT_OUT_ON)) {
+            vInters.erase( vInters.begin() + j) ;
+            vInters.erase( vInters.begin() + ( j > 0 ? i : i - 1)) ;
+            bSomeErased = true ;
+         }
+         if ( bSomeErased) {
+            if ( j > 0)
+               -- j ;
+            continue ;
+         }
+      }
+     // passo alla successiva
+      ++ j ;
+   }
+   return true ;
+}

IntersLineBox.cpp

@@ -22,7 +22,7 @@ using namespace std ;
 
 //----------------------------------------------------------------------------
 // Linea e box allineato assi devono essere nel medesimo sistema di riferimento.
-// In caso di intersezione viene restituito true e i parametri in dU1 e dU2.
+// In caso di intersezione viene restituito true e i parametri lunghezza in dU1 e dU2.
 //----------------------------------------------------------------------------
 bool
 IntersLineBox( const Point3d& ptL, const Vector3d& vtL,

IntersLineBox.h

@@ -17,7 +17,7 @@
 
 //----------------------------------------------------------------------------
 // Linea e box allineato agli assi sono nel medesimo riferimento.
-// Con intersezione viene restituito true e i parametri in dU1 e dU2.
+// Con intersezione viene restituito true e i parametri lunghezza in dU1 e dU2.
 //----------------------------------------------------------------------------
 bool
 IntersLineBox( const Point3d& ptL, const Vector3d& vtL,

IntersLineLine.cpp

@@ -57,7 +57,7 @@ IntersLineLine::IntersLineLine( const CurveLine& Line1, const CurveLine& Line2,
 
 //----------------------------------------------------------------------------
 void
-IntersLineLine::IntersInfiniteLines( const ICurveLine& Line1, const ICurveLine& Line2)
+IntersLineLine::IntersInfiniteLines( const CurveLine& Line1, const CurveLine& Line2)
 {
   // linea 1 : Start, End, Direzione e Lunghezza
    Point3d ptS1 = Line1.GetStart() ;
@@ -118,7 +118,7 @@ IntersLineLine::IntersInfiniteLines( const ICurveLine& Line1, const ICurveLine&
 
 //----------------------------------------------------------------------------
 void
-IntersLineLine::IntersFiniteLines( const ICurveLine& Line1, const ICurveLine& Line2)
+IntersLineLine::IntersFiniteLines( const CurveLine& Line1, const CurveLine& Line2)
 {
   // verifico sovrapposizione box
    BBox3d boxL1 ;

IntersLineLine.h

@@ -38,8 +38,8 @@ class IntersLineLine
 
    private :
       IntersLineLine( void) ;
-      void IntersInfiniteLines( const ICurveLine& Line1, const ICurveLine& Line2) ;
-      void IntersFiniteLines( const ICurveLine& Line1, const ICurveLine& Line2) ;
+      void IntersInfiniteLines( const CurveLine& Line1, const CurveLine& Line2) ;
+      void IntersFiniteLines( const CurveLine& Line1, const CurveLine& Line2) ;
 
    private :
       bool          m_bOverlaps ;

IntersLineSurfBez.cpp

@@ -0,0 +1,234 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024
+//----------------------------------------------------------------------------
+// File : IntersLineSurfBez.cpp      Data : 06.02.24         Versione : 2.6b1
+// Contenuto : Implementazione della intersezione linea/superficie bezier.
+//
+//
+//
+// Modifiche : 06.02.24 DB Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "/EgtDev/Include/EGkIntersLineTria.h"
+#include "/EgtDev/Include/EGkIntersLineSurfTm.h"
+#include "/EgtDev/Include/EGkIntersLineSurfBez.h"
+#include "/EgtDev/Include/EGkSurfBezier.h"
+#include "DistPointLine.h"
+#include "CurveLine.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+static bool
+RefineIntersNewton( const Point3d& ptL, const Vector3d& vtL, double dLen, bool bFinite,
+                    const ISurfBezier* pSurfBz, Point3d& ptSP, Point3d& ptIBz)
+{
+  // la funzione raffina la posisione del punto ptSP, minimizzando la distanza dalla retta e restituisce il punto di intersezione ptIBz
+   pSurfBz->GetPointD1D2( ptSP.x / SBZ_TREG_COEFF, ptSP.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz) ;
+  // usando un algoritmo di newton cerco di avvicinarmi il più possibile alla retta
+   DistPointLine dpl( ptIBz, ptL, vtL, dLen, bFinite) ;
+   double dDistNew = 0, dDistPre = 0 ;
+   dpl.GetDist(dDistNew) ;
+
+   int nCount = 0 ;
+   double dh = EPS_SMALL ;
+   pSurfBz->GetPointD1D2( ptSP.x, ptSP.y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz) ;
+  // metodo di newton in più dimensioni
+  // vario sia il parametro U che il parametro V e verifico se la distanza dalla retta diminuisce per scostamenti positivi o negativi.
+   while ( dDistNew > EPS_SMALL  &&  nCount < 100) {
+      dDistPre = dDistNew ;
+      Point3d ptIBzNew1 ;
+      pSurfBz->GetPointD1D2( ( ptSP.x + dh)  / SBZ_TREG_COEFF, ptSP.y  / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew1) ;
+      DistPointLine dplNewU( ptIBzNew1, ptL, vtL, dLen, bFinite) ;
+      dplNewU.GetDist( dDistNew) ;
+      double dfdU = ( dDistNew - dDistPre) / dh ;
+      Point3d ptIBzNew2 ;
+      pSurfBz->GetPointD1D2( ptSP.x  / SBZ_TREG_COEFF, ( ptSP.y + dh) / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBzNew2) ;
+      DistPointLine dplNewV( ptIBzNew2, ptL, vtL, dLen, bFinite) ;
+      dplNewV.GetDist( dDistNew) ;
+      double dfdV = ( dDistNew - dDistPre) / dh ;
+     // mi avvicino cercando di annullare la distanza in un colpo solo
+      double dr = - dDistPre / ( dfdU + dfdV) ;
+      pSurfBz->GetPointD1D2(( ptSP.x + dr * dfdU) / SBZ_TREG_COEFF, ( ptSP.y + dr * dfdV) / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz) ;
+      DistPointLine dplNew( ptIBz, ptL, vtL, dLen, bFinite) ;
+      dplNew.GetDist( dDistNew) ;
+      ++ nCount ;
+   }
+
+   return ( nCount != 99) ;
+}
+
+//----------------------------------------------------------------------------
+static void
+UpdateInfoIntersLineSurfBz( const Point3d& ptL, const Vector3d& vtDir, int nILT, int nT, const Point3d& ptSP, const Point3d& ptIBz, double dCos,
+                            const Point3d& ptSP2, const Point3d& ptIBz2, double dCos2, ILSBIVECTOR& vInfo)
+{
+   if ( nILT == ILTT_IN  ||  nILT == ILTT_EDGE  ||  nILT == ILTT_VERT) {
+      double dU = ( ptIBz - ptL) * vtDir ;
+      vInfo.emplace_back( nILT, dU, nT, dCos, ptIBz, ptSP) ;
+   }
+   else if ( nILT == ILTT_SEGM  ||  nILT == ILTT_SEGM_ON_EDGE) {
+      double dU = ( ptIBz - ptL) * vtDir ;
+      double dU2 = ( ptIBz2 - ptL) * vtDir ;
+      vInfo.emplace_back( nILT, dU, dU2, nT, dCos2, ptIBz, ptIBz2, ptSP, ptSP2) ;
+   }
+}
+
+//----------------------------------------------------------------------------
+static void
+OrderInfoIntersLineSurfBz( ILSBIVECTOR& vInfo)
+{
+   // se non trovati, esco 
+   if ( vInfo.size() == 0)
+      return ;
+   // ordino il vettore delle intersezioni secondo il senso crescente del parametro di linea
+   sort( vInfo.begin(), vInfo.end(), 
+      []( const IntLinSbzInfo& a, const IntLinSbzInfo& b)
+      {  double dUa = ( ( a.nILTT == ILTT_SEGM  ||  a.nILTT == ILTT_SEGM_ON_EDGE) ? ( a.dU + a.dU2) / 2 : a.dU) ;
+   double dUb = ( ( b.nILTT == ILTT_SEGM  ||  b.nILTT == ILTT_SEGM_ON_EDGE) ? ( b.dU + b.dU2) / 2 : b.dU) ;
+   return ( dUa < dUb) ; }) ;
+}
+
+//----------------------------------------------------------------------------
+//  Intersezione di una linea con una superficie di Bezier
+//----------------------------------------------------------------------------
+bool
+IntersLineSurfBz( const Point3d& ptL, const Vector3d& vtL, double dLen, const ISurfBezier* pSurfBz,
+                  ILSBIVECTOR& vInfo, bool bFinite)
+{
+   PtrOwner<ICurveLine> pCL( CreateCurveLine()) ;
+   if ( bFinite)
+      pCL->SetPVL(ptL, vtL, dLen) ;
+   else
+      pCL->SetPVL(ptL, vtL, 1e6) ;
+   // verifico linea
+   Vector3d vtDir = vtL ;
+   if ( ! vtDir.Normalize( EPS_ZERO))
+      return false ;
+   // verifico superficie
+   if ( pSurfBz == nullptr)
+      return false ;
+   // verifico parametro di ritorno
+   if ( &vInfo == nullptr)
+      return false ;
+   vInfo.clear() ;
+
+   // trovo le intersezioni con la trimesh ausiliaria
+   const ISurfTriMesh* pSurfTm = pSurfBz->GetAuxSurf() ;
+   ILSIVECTOR vInfoTm ;
+   if ( ! IntersLineSurfTm( ptL, vtL, dLen, *pSurfTm, vInfoTm, bFinite))
+      return false ;
+   // ricavo le intersezioni con la superficie di Bezier
+   for ( IntLinStmInfo InfoTm : vInfoTm ) {
+      // devo raffinare i parametri lungo la curva, l'angolo e i punti di intersezione
+      Point3d ptI, ptI2 ;
+      // devo trovare le intersezioni
+      Point3d ptSP, ptSP2 ; // coordinate parametriche delle soluzioni
+      pSurfBz->UnprojectPointFromStm( InfoTm.nT, InfoTm.ptI, ptSP, InfoTm.nILTT) ;
+      Point3d ptIBz, ptIBz2 ;
+      if ( ! RefineIntersNewton( ptL, vtL, dLen, bFinite, pSurfBz, ptSP, ptIBz)) {
+      /////// posso provare anche a rilanciare newton con un punto di partenza diverso oppure con una direzione di avvicinamento diversa///////////////////////////////////
+         // per restare nel triangolo mi sposto verso un vertice
+         int nVert[3] ;
+         pSurfTm->GetTriangle( InfoTm.nT, nVert) ;
+         double dU0, dV0 ;
+         pSurfTm->GetVertexParam( nVert[0], dU0, dV0) ;
+         ptSP = ptSP + Point3d(dU0, dV0, 0) ;
+         if ( ! RefineIntersNewton( ptL,vtL, dLen, bFinite, pSurfBz, ptSP, ptIBz))
+            return false ;
+      }
+      Vector3d vtN ;
+      pSurfBz->GetPointNrmD1D2(ptSP.x / SBZ_TREG_COEFF, ptSP.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz, vtN) ;
+      double dCos = vtN * vtL ;
+      double dCos2 = 0 ;
+      // eventualmente ripeto tutto per ptI2 ( se ho un'intersezione con sovrapposizione)
+      if ( InfoTm.nILTT == ILTT_SEGM || InfoTm.nILTT == ILTT_SEGM_ON_EDGE ) {
+         pSurfBz->UnprojectPointFromStm( InfoTm.nT, InfoTm.ptI2, ptSP2, InfoTm.nILTT) ;
+         if ( ! RefineIntersNewton(ptL, vtL, dLen, bFinite, pSurfBz, ptSP2, ptIBz2) ) {
+            int nVert[3] ;
+            pSurfTm->GetTriangle( InfoTm.nT, nVert) ;
+            double dU0, dV0 ;
+            pSurfTm->GetVertexParam( nVert[0], dU0, dV0) ;
+            ptSP = ptSP + Point3d(dU0, dV0, 0) ;
+            if ( ! RefineIntersNewton( ptL,vtL, dLen, bFinite, pSurfBz, ptSP, ptIBz))
+               return false ;
+         }
+         pSurfBz->GetPointNrmD1D2( ptSP2.x / SBZ_TREG_COEFF, ptSP2.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptIBz2, vtN) ;
+         dCos2 = vtN * vtL ;
+      }
+      UpdateInfoIntersLineSurfBz( ptL, vtL, InfoTm.nILTT, InfoTm.nT, ptSP, ptIBz, dCos, ptSP2, ptIBz2, dCos2, vInfo) ;
+   }
+   
+   OrderInfoIntersLineSurfBz( vInfo) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FilterLineSurfBzInters( const ILSBIVECTOR& vInfo, INTDBLVECTOR& vInters)
+{
+   // tengo per buone la classificazione delle intersezioni fatte sulla trimesh
+   // ciclo sulle intersezioni
+   for ( const auto& Info : vInfo) {
+      // se intersezione puntuale
+      if ( Info.nILTT == ILTT_VERT  ||  Info.nILTT == ILTT_EDGE  ||  Info.nILTT == ILTT_IN) {
+         int nFlag = LSBT_TOUCH ;
+         if ( Info.dCosDN > EPS_ZERO)
+            nFlag = LSBT_OUT ;
+         else if ( Info.dCosDN < -EPS_ZERO)
+            nFlag = LSBT_IN ;
+         vInters.emplace_back( nFlag, Info.dU) ;
+      }
+      // se altrimenti intersezione con coincidenza
+      else if ( Info.nILTT == ILTT_SEGM  ||  Info.nILTT == ILTT_SEGM_ON_EDGE) {
+         vInters.emplace_back( LSBT_TG_INI, Info.dU) ;
+         vInters.emplace_back( LSBT_TG_FIN, Info.dU2) ;
+      }
+   }
+   // elimino intersezioni ripetute
+   for ( size_t j = 1 ; j < vInters.size() ; ) {
+      // intersezione precedente
+      size_t i = j - 1 ;
+      // se hanno lo stesso parametro 
+      if ( abs( vInters[i].second - vInters[j].second) < EPS_SMALL) {
+         // se sono entrambe entranti o uscenti, elimino la seconda
+         if ( ( vInters[i].first == LSBT_IN  &&  vInters[j].first == LSBT_IN)  ||
+            ( vInters[i].first == LSBT_OUT  &&  vInters[j].first == LSBT_OUT)) {
+            vInters.erase( vInters.begin() + j) ;
+            continue ;
+         }
+         // se una entrante e l'altra uscente, cambio in touch ed elimino la seconda
+         else if ( ( vInters[i].first == LSBT_IN  &&  vInters[j].first == LSBT_OUT)  ||
+            ( vInters[i].first == LSBT_OUT  &&  vInters[j].first == LSBT_IN)) {
+            vInters[i].first = LSBT_TOUCH ;
+            vInters.erase( vInters.begin() + j) ;
+            continue ;
+         }
+         // se una puntuale e l'altra inizio di coincidenza, elimino la prima
+         else if ( ( vInters[i].first == LSBT_IN  ||  vInters[i].first == LSBT_OUT  ||  vInters[i].first == LSBT_TOUCH)  &&  vInters[j].first == LSBT_TG_INI) {
+            vInters.erase( vInters.begin() + i) ;
+            continue ;
+         }
+         // se una fine di coincidenza e l'altra puntuale, elimino la seconda
+         else if ( vInters[i].first == LSBT_TG_FIN  &&  ( vInters[j].first == LSBT_IN  ||  vInters[j].first == LSBT_OUT  ||  vInters[j].first == LSBT_TOUCH)) {
+            vInters.erase( vInters.begin() + j) ;
+            continue ;
+         }
+         // se una fine di coincidenza e l'altra inizio di coincidenza, elimino entrambe
+         else if ( i > 0  &&  vInters[i].first == LSBT_TG_FIN  &&  vInters[j].first == LSBT_TG_INI) {
+            vInters.erase( vInters.begin() + j) ;
+            vInters.erase( vInters.begin() + i) ;
+            -- j ;
+            continue ;
+         }
+      }
+      // passo alla successiva
+      ++ j ;
+   }
+   return true ;
+}

IntersLineSurfTm.cpp

@@ -21,7 +21,7 @@
 using namespace std ;
 
 //----------------------------------------------------------------------------
-void
+static void
 UpdateInfoIntersLineSurfTm( const Point3d& ptL, const Vector3d& vtDir, double dLen,
                             int nT, const Triangle3d& Tria, ILSIVECTOR& vInfo, bool bFinite)
 {
@@ -41,7 +41,7 @@ UpdateInfoIntersLineSurfTm( const Point3d& ptL, const Vector3d& vtDir, double dL
 }
 
 //----------------------------------------------------------------------------
-void
+static void
 OrderInfoIntersLineSurfTm( ILSIVECTOR& vInfo)
 {
   // se non trovati, esco 
@@ -81,7 +81,7 @@ IntersLineSurfTm( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
   // lo ingrandisco per non avere problemi con faccia piana su piani canonici
    b3Stm.Expand( 10 * EPS_SMALL) ;
    double dU1, dU2 ;
-   if ( ! IntersLineBox( ptL, vtL, b3Stm.GetMin() , b3Stm.GetMax(), dU1, dU2))
+   if ( ! IntersLineBox( ptL, vtDir, b3Stm.GetMin() , b3Stm.GetMax(), dU1, dU2))
       return true ;
    if ( bFinite) {
       dU1 = max( dU1, 0.) ;
@@ -89,12 +89,12 @@ IntersLineSurfTm( const Point3d& ptL, const Vector3d& vtL, double dLen, const IS
       if ( dU2 - dU1 < EPS_SMALL)
          return true ;
    }
-   Point3d ptStart = ptL + dU1 * vtL ;
+   Point3d ptStart = ptL + dU1 * vtDir ;
    double dLenEff = dU2 - dU1 ;
   // cerco i triangoli intersecati dalla linea
    const double BOX_STEP = 10 ;
    int nStep = int( ceil( dLenEff / BOX_STEP)) ;
-   Vector3d vtStep = dLenEff / nStep * vtL ;
+   Vector3d vtStep = dLenEff / nStep * vtDir ;
    INTVECTOR vPrevT ;
    for ( int i = 0 ; i < nStep ; ++ i) {
       BBox3d b3Box( ptStart + i * vtStep, ptStart + ( i + 1) * vtStep) ;
@@ -189,3 +189,68 @@ IntersParLinesSurfTm::GetInters( const Point3d& ptL, double dLen, ILSIVECTOR& vI
 
    return true ;
 }
+
+//----------------------------------------------------------------------------
+bool
+FilterLineSurfTmInters( const ILSIVECTOR& vInfo, INTDBLVECTOR& vInters)
+{
+  // ciclo sulle intersezioni
+   for ( const auto& Info : vInfo) {
+     // se intersezione puntuale
+      if ( Info.nILTT == ILTT_VERT  ||  Info.nILTT == ILTT_EDGE  ||  Info.nILTT == ILTT_IN) {
+         int nFlag = LST_TOUCH ;
+         if ( Info.dCosDN > EPS_ZERO)
+            nFlag = LST_OUT ;
+         else if ( Info.dCosDN < -EPS_ZERO)
+            nFlag = LST_IN ;
+         vInters.emplace_back( nFlag, Info.dU) ;
+      }
+     // se altrimenti intersezione con coincidenza
+      else if ( Info.nILTT == ILTT_SEGM  ||  Info.nILTT == ILTT_SEGM_ON_EDGE) {
+         vInters.emplace_back( LST_TG_INI, Info.dU) ;
+         vInters.emplace_back( LST_TG_FIN, Info.dU2) ;
+      }
+   }
+  // elimino intersezioni ripetute
+   for ( size_t j = 1 ; j < vInters.size() ; ) {
+     // intersezione precedente
+      size_t i = j - 1 ;
+     // se hanno lo stesso parametro 
+      if ( abs( vInters[i].second - vInters[j].second) < EPS_SMALL) {
+        // se sono entrambe entranti o uscenti, elimino la seconda
+         if ( ( vInters[i].first == LST_IN  &&  vInters[j].first == LST_IN)  ||
+              ( vInters[i].first == LST_OUT  &&  vInters[j].first == LST_OUT)) {
+            vInters.erase( vInters.begin() + j) ;
+            continue ;
+         }
+        // se una entrante e l'altra uscente, cambio in touch ed elimino la seconda
+         else if ( ( vInters[i].first == LST_IN  &&  vInters[j].first == LST_OUT)  ||
+                   ( vInters[i].first == LST_OUT  &&  vInters[j].first == LST_IN)) {
+            vInters[i].first = LST_TOUCH ;
+            vInters.erase( vInters.begin() + j) ;
+            continue ;
+         }
+        // se una puntuale e l'altra inizio di coincidenza, elimino la prima
+         else if ( ( vInters[i].first == LST_IN  ||  vInters[i].first == LST_OUT  ||  vInters[i].first == LST_TOUCH)  &&  vInters[j].first == LST_TG_INI) {
+            vInters.erase( vInters.begin() + i) ;
+            continue ;
+         }
+        // se una fine di coincidenza e l'altra puntuale, elimino la seconda
+         else if ( vInters[i].first == LST_TG_FIN  &&  ( vInters[j].first == LST_IN  ||  vInters[j].first == LST_OUT  ||  vInters[j].first == LST_TOUCH)) {
+            vInters.erase( vInters.begin() + j) ;
+            continue ;
+         }
+        // se una fine di coincidenza e l'altra inizio di coincidenza, elimino entrambe
+         else if ( i > 0  &&  vInters[i].first == LST_TG_FIN  &&  vInters[j].first == LST_TG_INI) {
+            vInters.erase( vInters.begin() + j) ;
+            vInters.erase( vInters.begin() + i) ;
+            -- j ;
+            continue ;
+         }
+      }
+     // passo alla successiva
+      ++ j ;
+   }
+
+   return true ;
+}

IntersLineVolZmap.cpp

@@ -0,0 +1,106 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : IntersLineVolZmap.cpp     Data : 22.02.24         Versione : 2.6b4
+// Contenuto : Implementazione della intersezione linea/VolZmap.
+//
+//
+//
+// Modifiche : 22.02.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "VolZmap.h"
+#include "/EgtDev/Include/EGkIntersLineVolZmap.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+//  Intersezione di una linea con la superficie di un solido VolZmap
+//----------------------------------------------------------------------------
+bool
+IntersLineVolZmap( const Point3d& ptL, const Vector3d& vtL, const IVolZmap& Vzm, ILZIVECTOR& vInfo)
+{
+  // verifico linea
+   Vector3d vtDir = vtL ;
+   if ( ! vtDir.Normalize( EPS_ZERO))
+      return false ;
+  // verifico volume
+   const VolZmap* pVzm = GetBasicVolZmap( &Vzm) ;
+   if ( pVzm == nullptr)
+      return false ;
+  // verifico parametro di ritorno
+   if ( &vInfo == nullptr)
+      return false ;
+
+  // eseguo intersezione
+   return pVzm->GetLineIntersection( ptL, vtL, vInfo) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FilterLineVolZmapInters( const ILZIVECTOR& vInfo, INTDBLVECTOR& vInters)
+{
+  // ciclo sulle intersezioni
+   for ( const auto& Info : vInfo) {
+     // se intersezione puntuale
+      if ( Info.nILTT == ILTT_VERT  ||  Info.nILTT == ILTT_EDGE  ||  Info.nILTT == ILTT_IN) {
+         int nFlag = LZT_TOUCH ;
+         if ( Info.dCosDN > EPS_ZERO)
+            nFlag = LZT_OUT ;
+         else if ( Info.dCosDN < -EPS_ZERO)
+            nFlag = LZT_IN ;
+         vInters.emplace_back( nFlag, Info.dU) ;
+      }
+     // se altrimenti intersezione con coincidenza
+      else if ( Info.nILTT == ILTT_SEGM  ||  Info.nILTT == ILTT_SEGM_ON_EDGE) {
+         vInters.emplace_back( LZT_TG_INI, Info.dU) ;
+         vInters.emplace_back( LZT_TG_FIN, Info.dU2) ;
+      }
+   }
+  // elimino intersezioni ripetute
+   for ( size_t j = 1 ; j < vInters.size() ; ) {
+     // intersezione precedente
+      size_t i = j - 1 ;
+     // se hanno lo stesso parametro 
+      if ( abs( vInters[i].second - vInters[j].second) < EPS_SMALL) {
+        // se sono entrambe entranti o uscenti, elimino la seconda
+         if ( ( vInters[i].first == LZT_IN  &&  vInters[j].first == LZT_IN)  ||
+              ( vInters[i].first == LZT_OUT  &&  vInters[j].first == LZT_OUT)) {
+            vInters.erase( vInters.begin() + j) ;
+            continue ;
+         }
+        // se una entrante e l'altra uscente, cambio in touch ed elimino la seconda
+         else if ( ( vInters[i].first == LZT_IN  &&  vInters[j].first == LZT_OUT)  ||
+                   ( vInters[i].first == LZT_OUT  &&  vInters[j].first == LZT_IN)) {
+            vInters[i].first = LZT_TOUCH ;
+            vInters.erase( vInters.begin() + j) ;
+            continue ;
+         }
+        // se una puntuale e l'altra inizio di coincidenza, elimino la prima
+         else if ( ( vInters[i].first == LZT_IN  ||  vInters[i].first == LZT_OUT  ||  vInters[i].first == LZT_TOUCH)  &&  vInters[j].first == LZT_TG_INI) {
+            vInters.erase( vInters.begin() + i) ;
+            continue ;
+         }
+        // se una fine di coincidenza e l'altra puntuale, elimino la seconda
+         else if ( vInters[i].first == LZT_TG_FIN  &&  ( vInters[j].first == LZT_IN  ||  vInters[j].first == LZT_OUT  ||  vInters[j].first == LZT_TOUCH)) {
+            vInters.erase( vInters.begin() + j) ;
+            continue ;
+         }
+        // se una fine di coincidenza e l'altra inizio di coincidenza, elimino entrambe
+         else if ( i > 0  &&  vInters[i].first == LZT_TG_FIN  &&  vInters[j].first == LZT_TG_INI) {
+            vInters.erase( vInters.begin() + j) ;
+            vInters.erase( vInters.begin() + i) ;
+            -- j ;
+            continue ;
+         }
+      }
+     // passo alla successiva
+      ++ j ;
+   }
+
+   return true ;
+}

IntersPlaneVolZmap.cpp

@@ -0,0 +1,37 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : IntersPlaneVolZmap.cpp     Data : 22.02.24         Versione : 2.6b4
+// Contenuto : Implementazione della intersezione piano/VolZmap.
+//
+//
+//
+// Modifiche : 22.02.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "VolZmap.h"
+#include "/EgtDev/Include/EGkIntersPlaneVolZmap.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+//  Intersezione di unpiano con la superficie di un solido VolZmap
+//----------------------------------------------------------------------------
+bool
+IntersPlaneVolZmap( const Plane3d& plPlane, const IVolZmap& Vzm, ICURVEPOVECTOR& vpLoop)
+{
+  // verifico volume
+   const VolZmap* pVzm = GetBasicVolZmap( &Vzm) ;
+   if ( pVzm == nullptr)
+      return false ;
+  // verifico parametro di ritorno
+   if ( &vpLoop == nullptr)
+      return false ;
+
+  // eseguo intersezione
+   return pVzm->GetPlaneIntersection( plPlane, vpLoop) ;
+}

PolyLine.cpp

@@ -721,15 +721,42 @@ PolyLine::AdjustForMaxSegmentLen( double dMaxLen)
    return true ;
 }
 
-//----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
 static bool
-PointsInTolerance( const PNTVECTOR& vRPT, const Point3d& ptP1, const Point3d& ptP2, double dSqTol)
+DouglasPeuckerSimplification( const PNTUVECTOR& vPtU, const double dSqTol, const int nIndStart,
+                              const int nIndEnd, INTVECTOR& vInd)
 {
-   for ( const auto& ptQ : vRPT) {
-      double dSqDist ;
-      if ( ! DistPointLine( ptQ, ptP1, ptP2).GetSqDist( dSqDist)  ||  dSqDist > dSqTol)
+  // se indici uguali, ritorno
+   if ( nIndStart == nIndEnd)
+      return true ;
+
+  // distanza massima e indice del punto associato
+   double dMaxSqDist = 0. ;
+   int nMaxInd = 0 ;
+
+  // scorro i punti intermedi tra nIndStart e nIndEnd
+   for ( int i = nIndStart + 1 ; i < nIndEnd ; ++ i) {
+      double dCurrSqDist = 0. ;
+     // distanza tra il punto attuale e la retta tra i punti di indici nIndStart ed nIndEnd
+      DistPointLine DPL( vPtU[i].first, vPtU[nIndStart].first, vPtU[nIndEnd].first) ;
+      if ( DPL.GetSqDist( dCurrSqDist)  &&  dCurrSqDist > dMaxSqDist) {
+        // aggiorno i parametri
+         dMaxSqDist = dCurrSqDist ;
+         nMaxInd = i ;
+      }
+   }
+
+  // se la distanza massima trovata è sopra la tolleranza, allora controllo la parte di PolyLine tra
+  // (nIndStart, nMaxInd) e quella tra (nMaxInd, nIndEnd)
+   if ( dMaxSqDist > dSqTol) {
+     // inserisco il punto
+      vInd.push_back( nMaxInd) ;
+     // split
+      if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, nIndStart, nMaxInd, vInd)  ||
+           ! DouglasPeuckerSimplification( vPtU, dSqTol, nMaxInd, nIndEnd, vInd))
          return false ;
    }
+
    return true ;
 }
 
@@ -743,59 +770,53 @@ PolyLine::RemoveAlignedPoints( double dToler)
   // controllo minimo valore di tolleranza
    dToler = max( dToler, LIN_TOL_MIN) ;
    double dSqTol = dToler * dToler ;
-  // si analizza la distanza di un punto dal segmento che unisce precedente e successivo
-  // punto precedente
-   auto precP = m_lUPoints.begin() ;
-  // punto corrente
-   auto currP = next( precP) ;
-  // punto successivo
-   auto nextP = next( currP) ;
-  // lista dei punti appena rimossi
-   PNTVECTOR vRPT ; vRPT.reserve( 20) ;
-  // mentre esiste un successivo
-   while ( nextP != m_lUPoints.end()) {
-     // distanza del punto corrente dal segmento che unisce gli adiacenti
-      DistPointLine dPL( currP->first, precP->first, nextP->first) ;
-      double dSqDist ;
-     // se da eliminare
-      if ( dPL.GetSqDist( dSqDist)  &&  dSqDist < dSqTol  &&  PointsInTolerance( vRPT, precP->first, nextP->first, dSqTol)) {
-        // aggiungo il punto nella lista dei rimossi
-         vRPT.emplace_back( currP->first) ;
-        // elimino il punto
-         m_lUPoints.erase( currP) ;
-        // avanzo con corrente e successivo
-         currP = nextP ;
-         ++ nextP ;
-      }
-     // altrimenti da tenere
-      else {
-        // cancello la lista dei rimossi
-         vRPT.clear() ;
-        // avanzo il terzetto di uno step
-         precP = currP ;
-         currP = nextP ;
-         ++ nextP ;
-      }
+
+  // vettore contenente i punti della polyline
+   PNTUVECTOR vPtU ; vPtU.reserve( m_lUPoints.size()) ;
+   for ( const auto& ptCurr : m_lUPoints)
+      vPtU.emplace_back( ptCurr) ;
+
+  // vettore indici dei punti rimanenti
+   INTVECTOR vInd ; vInd.reserve( vPtU.size()) ;
+
+  // se aperta
+   if ( ! IsClosed()) {
+     // considero tutti i punti della PolyLine
+      vInd.push_back( 0) ;
+      if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, 0, int( vPtU.size()) - 1, vInd))
+         return false ;
+      vInd.push_back( vPtU.size() - 1) ;
    }
-  // se curva chiusa con almeno 4 punti, devo analizzare il terzetto attorno alla chiusura
-   if ( IsClosed()  &&  m_lUPoints.size() >= 4) {
-     // precP e currP sono già corretti
-     // il primo punto ripete l'ultimo (geometricamente coincide con currP)
-      auto firstP = m_lUPoints.begin() ;
-     // questo è il vero successivo
-      nextP = next( firstP) ;
-     // distanza del punto corrente dal segmento che unisce gli adiacenti
-      DistPointLine dPL( currP->first, precP->first, nextP->first) ;
-      double dSqDist ;
-     // se da eliminare
-      if ( dPL.GetSqDist( dSqDist)  &&  dSqDist < dSqTol  &&  PointsInTolerance( vRPT, precP->first, nextP->first, dSqTol)) {
-        // faccio coincidere il primo punto con il precedente
-         firstP->first = precP->first ;
-        // elimino il punto corrente
-         m_lUPoints.erase( currP) ;
+  // altrimenti chiusa
+   else {
+     // cerco il punto più distante dal primo
+      double dMaxDist = 0. ;
+      int nMaxInd = 0 ;
+      for ( int i = 1 ; i < int( vPtU.size()) ; ++ i) {
+         double dCurrDist = Dist( vPtU[0].first, vPtU[i].first) ;
+         if ( dCurrDist > dMaxDist) {
+            dMaxDist = dCurrDist ;
+            nMaxInd = i ;
+         }
       }
+     // recupero due PolyLine di approssimazione
+      vInd.push_back( 0) ;
+      if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, 0, nMaxInd, vInd))
+         return false ;
+      vInd.push_back( nMaxInd) ;
+      if ( ! DouglasPeuckerSimplification( vPtU, dSqTol, nMaxInd, int( vPtU.size()) - 1, vInd))
+         return false ;
+      vInd.push_back( vPtU.size() - 1) ;
    }
-   
+
+  // ordino in senso crescente
+   sort( vInd.begin(), vInd.end()) ;
+
+  // rimetto in lista i soli punti rimasti
+   m_lUPoints.clear() ;
+   for ( auto Ind : vInd)
+      m_lUPoints.push_back( vPtU[Ind]) ;
+
    return true ;
 }
 

ProjectCurveSurfTm.cpp

@@ -15,6 +15,8 @@
 #include "stdafx.h"
 #include "DistPointLine.h"
 #include "GeoConst.h"
+#include "/EgtDev/Include/EGkDistPointCurve.h"
+#include "/EgtDev/Include/EGkDistPointSurfTm.h"
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
 #include "/EgtDev/Include/EGkProjectCurveSurfTm.h"
 
@@ -33,63 +35,9 @@ PointsInTolerance( const PNT5AXVECTOR& vPt5ax, int nPrec, int nCurr, int nNext,
 }
 
 //----------------------------------------------------------------------------
-bool
-ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vector3d& vtDir, double dLinTol, double dMaxSegmLen,
-                      PNT5AXVECTOR& vPt5ax)
+static bool
+RemovePointsInExcess( PNT5AXVECTOR& vMyPt5ax, double dLinTol, double dMaxSegmLen)
 {
-  // controllo le tolleranze
-   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
-   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
-  // approssimo la curva con una polilinea entro la metà della tolleranza
-   PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
-      return false ;
-   const double MAX_SEG_LEN = min( dMaxSegmLen, 1.) ;
-   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
-      return false ;
-
-  // Oggetto per calcolo massivo intersezioni tra linee di proiezione e superficie
-   Frame3d frRefLine ;
-   if ( ! frRefLine.Set( ORIG, vtDir))
-      return false ;
-   IntersParLinesSurfTm intPLSTM( frRefLine, tmSurf) ;
-
-  // Vettore locale dei punti risultanti
-   PNT5AXVECTOR vMyPt5ax ;
-   vMyPt5ax.reserve( PL.GetPointNbr()) ;
-
-  // proietto i punti della polilinea sulla superficie
-   double dU ;
-   Point3d ptP ;
-   bool bFound = PL.GetFirstUPoint( &dU, &ptP) ;
-   while ( bFound) {
-      Point3d ptL = GetToLoc( ptP, frRefLine) ;
-      ILSIVECTOR vIntRes ;
-      intPLSTM.GetInters( ptL, 1, vIntRes, false) ;
-      if ( vIntRes.size() > 0) {
-        // calcolo il punto
-         int nI = int( vIntRes.size()) - 1 ;
-         Point3d ptInt ;
-         if ( vIntRes[nI].nILTT == ILTT_SEGM  ||  vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE)
-            ptInt = vIntRes[nI].ptI2 ;
-         else
-            ptInt = vIntRes[nI].ptI ;
-        // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
-         Triangle3dEx trTria ;
-         if ( ! tmSurf.GetTriangle( vIntRes[nI].nT, trTria))
-            return false ;
-         Vector3d vtN ;
-         double dU, dV, dW ;
-         if ( BarycentricCoord( ptInt, trTria, dU, dV, dW)) 
-            vtN = dU * trTria.GetVertexNorm( 0) + dV * trTria.GetVertexNorm( 1) + dW * trTria.GetVertexNorm( 2) ;
-         if ( ! vtN.Normalize())
-            vtN = trTria.GetN() ;
-        // aggiungo al vettore dei proiettati
-         vMyPt5ax.emplace_back( ptInt, vtN, dU, 1) ;
-      }
-      bFound = PL.GetNextUPoint( &dU, &ptP) ;
-   }
-
   // rimuovo i punti allineati entro la tolleranza e non più lontani tra loro del massimo
    double dSqMaxLen = dMaxSegmLen * dMaxSegmLen ;
    double dSqTol = dLinTol * dLinTol ;
@@ -130,6 +78,309 @@ ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vec
          ++ nNext ;
       }
    }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vector3d& vtDir, double dLinTol, double dMaxSegmLen,
+                      PNT5AXVECTOR& vPt5ax)
+{
+  // controllo le tolleranze
+   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
+   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
+  // approssimo la curva con una polilinea entro la metà della tolleranza
+   PolyLine PL ;
+   if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
+      return false ;
+   const double MAX_SEG_LEN = min( dMaxSegmLen, 1.) ;
+   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
+      return false ;
+
+  // Oggetto per calcolo massivo intersezioni tra linee di proiezione e superficie
+   Frame3d frRefLine ;
+   if ( ! frRefLine.Set( ORIG, vtDir))
+      return false ;
+   IntersParLinesSurfTm intPLSTM( frRefLine, tmSurf) ;
+
+  // Vettore locale dei punti risultanti
+   PNT5AXVECTOR vMyPt5ax ;
+   vMyPt5ax.reserve( PL.GetPointNbr()) ;
+
+  // proietto i punti della polilinea sulla superficie
+   double dPar ;
+   Point3d ptP ;
+   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
+   while ( bFound) {
+      Point3d ptL = GetToLoc( ptP, frRefLine) ;
+      ILSIVECTOR vIntRes ;
+      intPLSTM.GetInters( ptL, 1, vIntRes, false) ;
+      if ( ! vIntRes.empty()) {
+        // calcolo il punto
+         int nI = int( vIntRes.size()) - 1 ;
+         Point3d ptInt ;
+         if ( vIntRes[nI].nILTT == ILTT_SEGM  ||  vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE)
+            ptInt = vIntRes[nI].ptI2 ;
+         else
+            ptInt = vIntRes[nI].ptI ;
+        // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
+         Triangle3dEx trTria ;
+         if ( ! tmSurf.GetTriangle( vIntRes[nI].nT, trTria))
+            return false ;
+         Vector3d vtN ;
+         double dU, dV, dW ;
+         if ( BarycentricCoord( ptInt, trTria, dU, dV, dW)) 
+            vtN = dU * trTria.GetVertexNorm( 0) + dV * trTria.GetVertexNorm( 1) + dW * trTria.GetVertexNorm( 2) ;
+         if ( ! vtN.Normalize())
+            vtN = trTria.GetN() ;
+        // aggiungo al vettore dei proiettati
+         vMyPt5ax.emplace_back( ptInt, vtN, dPar, 1) ;
+      }
+      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
+   }
+
+  // rimuovo i punti allineati entro la tolleranza e non più lontani tra loro del massimo
+   RemovePointsInExcess( vMyPt5ax, dLinTol, dMaxSegmLen) ;
+
+  // copio i punti rimasti nel vettore di ritorno
+   vPt5ax.clear() ;
+   for ( const auto& Pt5ax : vMyPt5ax) {
+      if ( Pt5ax.nFlag != -1)
+         vPt5ax.emplace_back( Pt5ax) ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const IGeoPoint3d& gpRef,
+                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax)
+{
+  // controllo le tolleranze
+   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
+   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
+
+  // approssimo la curva con una polilinea entro la metà della tolleranza
+   PolyLine PL ;
+   if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
+      return false ;
+   const double MAX_SEG_LEN = min( dMaxSegmLen, 1.) ;
+   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
+      return false ;
+
+  // Vettore locale dei punti risultanti
+   PNT5AXVECTOR vMyPt5ax ;
+   vMyPt5ax.reserve( PL.GetPointNbr()) ;
+
+  // proietto i punti della polilinea sulla superficie con direzione data dal punto di riferimento
+   double dPar ;
+   Point3d ptP ;
+   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
+   while ( bFound) {
+     // punto di riferimento
+      Point3d ptMin = gpRef.GetPoint() ;
+     // intersezione della retta di minima distanza con la superficie
+      Vector3d vtLine = ptP - ptMin ;
+      double dLineLen = vtLine.Len() ;
+      if ( dLineLen > EPS_SMALL) {        
+         vtLine /= dLineLen ;
+         ILSIVECTOR vIntRes ;
+         if ( IntersLineSurfTm( ptP, vtLine, dLineLen, tmSurf, vIntRes, false)) {
+            if ( vIntRes.size() > 0) {
+              // calcolo il punto
+               int nI = int( vIntRes.size()) - 1 ;
+               Point3d ptInt ;
+               if ( vIntRes[nI].nILTT == ILTT_SEGM  ||  vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE)
+                  ptInt = vIntRes[nI].ptI2 ;
+               else
+                  ptInt = vIntRes[nI].ptI ;
+              // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
+               Triangle3dEx trTria ;
+               if ( ! tmSurf.GetTriangle( vIntRes[nI].nT, trTria))
+                  return false ;
+               Vector3d vtN ;
+               double dU, dV, dW ;
+               if ( BarycentricCoord( ptInt, trTria, dU, dV, dW)) 
+                  vtN = dU * trTria.GetVertexNorm( 0) + dV * trTria.GetVertexNorm( 1) + dW * trTria.GetVertexNorm( 2) ;
+               if ( ! vtN.Normalize())
+                  vtN = trTria.GetN() ;
+              // aggiungo al vettore dei proiettati
+               vMyPt5ax.emplace_back( ptInt, vtN, vtLine, dPar, 1) ;
+            }
+         }
+      }
+      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
+   }
+
+  // rimuovo i punti allineati entro la tolleranza e non più lontani tra loro del massimo
+   RemovePointsInExcess( vMyPt5ax, dLinTol, dMaxSegmLen) ;
+
+  // copio i punti rimasti nel vettore di ritorno
+   vPt5ax.clear() ;
+   for ( const auto& Pt5ax : vMyPt5ax) {
+      if ( Pt5ax.nFlag != -1)
+         vPt5ax.emplace_back( Pt5ax) ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const ICurve& crRef,
+                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax)
+{
+  // controllo le tolleranze
+   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
+   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
+
+  // approssimo la curva con una polilinea entro la metà della tolleranza
+   PolyLine PL ;
+   if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
+      return false ;
+   const double MAX_SEG_LEN = min( dMaxSegmLen, 1.) ;
+   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
+      return false ;
+
+  // Vettore locale dei punti risultanti
+   PNT5AXVECTOR vMyPt5ax ;
+   vMyPt5ax.reserve( PL.GetPointNbr()) ;
+
+  // proietto i punti della polilinea sulla superficie con direzione normale alla curva di riferimento
+   double dPar ;
+   Point3d ptP ;
+   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
+   while ( bFound) {
+     // punto sulla curva a minima distanza
+      DistPointCurve dPC( ptP, crRef) ;
+      Point3d ptMin ;
+      int nFlag ;
+      if ( dPC.GetMinDistPoint( 0, ptMin, nFlag)) {
+        // intersezione della retta di minima distanza con la superficie
+         Vector3d vtLine = ptP - ptMin ;
+         double dLineLen = vtLine.Len() ;
+         if ( dLineLen > EPS_SMALL) {        
+            vtLine /= dLineLen ;
+            ILSIVECTOR vIntRes ;
+            if ( IntersLineSurfTm( ptP, vtLine, dLineLen, tmSurf, vIntRes, false)) {
+               if ( vIntRes.size() > 0) {
+                 // calcolo il punto
+                  int nI = int( vIntRes.size()) - 1 ;
+                  Point3d ptInt ;
+                  if ( vIntRes[nI].nILTT == ILTT_SEGM  ||  vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE)
+                     ptInt = vIntRes[nI].ptI2 ;
+                  else
+                     ptInt = vIntRes[nI].ptI ;
+                 // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
+                  Triangle3dEx trTria ;
+                  if ( ! tmSurf.GetTriangle( vIntRes[nI].nT, trTria))
+                     return false ;
+                  Vector3d vtN ;
+                  double dU, dV, dW ;
+                  if ( BarycentricCoord( ptInt, trTria, dU, dV, dW)) 
+                     vtN = dU * trTria.GetVertexNorm( 0) + dV * trTria.GetVertexNorm( 1) + dW * trTria.GetVertexNorm( 2) ;
+                  if ( ! vtN.Normalize())
+                     vtN = trTria.GetN() ;
+                 // aggiungo al vettore dei proiettati
+                  vMyPt5ax.emplace_back( ptInt, vtN, vtLine, dPar, 1) ;
+               }
+            }
+         }
+      }
+      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
+   }
+
+  // rimuovo i punti allineati entro la tolleranza e non più lontani tra loro del massimo
+   RemovePointsInExcess( vMyPt5ax, dLinTol, dMaxSegmLen) ;
+
+  // copio i punti rimasti nel vettore di ritorno
+   vPt5ax.clear() ;
+   for ( const auto& Pt5ax : vMyPt5ax) {
+      if ( Pt5ax.nFlag != -1)
+         vPt5ax.emplace_back( Pt5ax) ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const ISurfTriMesh& tmRef,
+                      double dLinTol, double dMaxSegmLen, PNT5AXVECTOR& vPt5ax)
+{
+  // controllo le tolleranze
+   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
+   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
+
+  // approssimo la curva con una polilinea entro la metà della tolleranza
+   PolyLine PL ;
+   if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
+      return false ;
+   const double MAX_SEG_LEN = min( dMaxSegmLen, 1.) ;
+   if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
+      return false ;
+
+  // Vettore locale dei punti risultanti
+   PNT5AXVECTOR vMyPt5ax ;
+   vMyPt5ax.reserve( PL.GetPointNbr()) ;
+
+  // proietto i punti della polilinea sulla superficie con direzione normale alla curva di riferimento
+   double dPar ;
+   Point3d ptP ;
+   bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
+   while ( bFound) {
+     // punto sulla superficie guida a minima distanza
+      DistPointSurfTm dPS( ptP, tmRef) ;
+      Point3d ptMin ;
+      int nTriaMin ;
+      if ( dPS.GetMinDistPoint( ptMin)  &&  dPS.GetMinDistTriaIndex ( nTriaMin)) {
+        // intersezione della retta di minima distanza con la superficie
+         Vector3d vtLine = ptP - ptMin ;
+         double dLineLen = vtLine.Len() ;
+         if ( dLineLen > EPS_SMALL) {        
+            vtLine /= dLineLen ;
+            ILSIVECTOR vIntRes ;
+            if ( IntersLineSurfTm( ptP, vtLine, dLineLen, tmSurf, vIntRes, false)) {
+               if ( vIntRes.size() > 0) {
+                 // calcolo il punto
+                  int nI = int( vIntRes.size()) - 1 ;
+                  Point3d ptInt ;
+                  if ( vIntRes[nI].nILTT == ILTT_SEGM  ||  vIntRes[nI].nILTT == ILTT_SEGM_ON_EDGE)
+                     ptInt = vIntRes[nI].ptI2 ;
+                  else
+                     ptInt = vIntRes[nI].ptI ;
+                 // calcolo la normale (si calcola smooth, in caso di errore si prende quella del triangolo)
+                  Triangle3dEx trTria ;
+                  if ( ! tmSurf.GetTriangle( vIntRes[nI].nT, trTria))
+                     return false ;
+                  Vector3d vtN ;
+                  double dU, dV, dW ;
+                  if ( BarycentricCoord( ptInt, trTria, dU, dV, dW)) 
+                     vtN = dU * trTria.GetVertexNorm( 0) + dV * trTria.GetVertexNorm( 1) + dW * trTria.GetVertexNorm( 2) ;
+                  if ( ! vtN.Normalize())
+                     vtN = trTria.GetN() ;
+                 // calcolo la normale della superficie guida
+                  Triangle3dEx trGuide ;
+                  if ( ! tmRef.GetTriangle( nTriaMin, trGuide))
+                     return false ;
+                  Vector3d vtN2 ;
+                  double dU2, dV2, dW2 ;
+                  if ( BarycentricCoord( ptMin, trGuide, dU2, dV2, dW2)) 
+                     vtN2 = dU2 * trGuide.GetVertexNorm( 0) + dV2 * trGuide.GetVertexNorm( 1) + dW2 * trGuide.GetVertexNorm( 2) ;
+                  if ( ! vtN2.Normalize())
+                     vtN2 = trGuide.GetN() ;
+                 // aggiungo al vettore dei proiettati
+                  vMyPt5ax.emplace_back( ptInt, vtN, vtN2, dPar, 1) ;
+               }
+            }
+         }
+      }
+      bFound = PL.GetNextUPoint( &dPar, &ptP) ;
+   }
+
+  // rimuovo i punti allineati entro la tolleranza e non più lontani tra loro del massimo
+   RemovePointsInExcess( vMyPt5ax, dLinTol, dMaxSegmLen) ;
 
   // copio i punti rimasti nel vettore di ritorno
    vPt5ax.clear() ;

Quaternion.cpp

@@ -0,0 +1,158 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : Quaternion.cpp          Data : 13.04.24          Versione : 2.6d4
+// Contenuto : Funzioni della classe Quaternion.
+//
+//
+//
+// Modifiche : 13.04.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "\EgtDev\Include\EGkQuaternion.h"
+
+//----------------------------------------------------------------------------
+// Lunghezza o Modulo
+//----------------------------------------------------------------------------
+double 
+Quaternion::Len( void) const
+{
+   if ( abs( x) < EPS_ZERO  &&  abs( y) < EPS_ZERO  &&  abs( z) < EPS_ZERO)
+      return abs( w) ;
+   if ( abs( w) < EPS_ZERO  &&  abs( y) < EPS_ZERO  &&  abs( z) < EPS_ZERO)
+      return abs( x) ;
+   if ( abs( w) < EPS_ZERO  &&  abs( z) < EPS_ZERO  &&  abs( x) < EPS_ZERO)
+      return abs( y) ;
+   if ( abs( w) < EPS_ZERO  &&  abs( x) < EPS_ZERO  &&  abs( y) < EPS_ZERO)
+      return abs( z) ;
+
+   return sqrt( w * w + x * x + y * y + z * z) ; 
+}
+
+//----------------------------------------------------------------------------
+// Normalizzazione
+//----------------------------------------------------------------------------
+bool
+Quaternion::Normalize( double dEps)
+{
+  // se già normalizzato, ok
+   double dSqLen = w * w + x * x + y * y + z * z ;
+   if ( abs( 1.0 - dSqLen) < ( 2 * 1000 * DBL_EPSILON))
+      return true ;
+
+  // se troppo piccolo, errore
+   if ( dSqLen < ( dEps * dEps))
+      return false ;
+
+  // eseguo la normalizzazione
+   double dLen = sqrt( dSqLen) ;
+   *this /= dLen ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+Quaternion
+FromAxisAngle( const Vector3d& vtAx, double dAngDeg)
+{
+   if ( abs( dAngDeg) < EPS_ANG_ZERO)
+      return Q_UNIT ;
+   double dLen = vtAx.Len() ;
+   if ( dLen < EPS_ZERO)
+      return Q_NULL ;
+   double dDenom = 1 / dLen ;
+   double dHCos = cos( dAngDeg / 2 * DEGTORAD) ;
+   double dHSin = sin( dAngDeg / 2 * DEGTORAD) ;
+   return Quaternion( dHCos, dHSin * vtAx.x * dDenom, dHSin * vtAx.y * dDenom, dHSin * vtAx.z * dDenom) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ToAxisAngle( const Quaternion& qtQ, Vector3d& vtAx, double& dAngDeg)
+{
+   if ( ! qtQ.IsNormalized())
+      return false ;
+   if ( qtQ.IsUnit()  ||  (-qtQ).IsUnit()) {
+      dAngDeg = 0 ;
+      vtAx = Z_AX ;
+   }
+   else {
+      dAngDeg = 2 * acos( qtQ.w) * RADTODEG ;
+      double dDenom = 1 / sqrt( 1 - qtQ.w * qtQ.w) ;
+      vtAx.x = qtQ.x * dDenom ;
+      vtAx.y = qtQ.y * dDenom ;
+      vtAx.z = qtQ.z * dDenom ;
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+Quaternion
+FromFrame( const Frame3d& frRef)
+{
+  // verifico il riferimento
+   if ( ! frRef.IsValid())
+      return Q_NULL ;
+  // eseguo il calcolo
+   Quaternion qtQ ;
+  // traccia della matrice di rotazione
+   double dTr = frRef.VersX().x + frRef.VersY().y + frRef.VersZ().z ;
+  // se traccia positiva o nulla
+   if ( dTr > - 10 * EPS_ZERO) {
+      double dS = sqrt( 1 + dTr) ;
+      qtQ.w = dS / 2 ;
+      dS = 1 / ( 2 * dS) ;
+      qtQ.x = ( frRef.VersY().z - frRef.VersZ().y) * dS ;
+      qtQ.y = ( frRef.VersZ().x - frRef.VersX().z) * dS ;
+      qtQ.z = ( frRef.VersX().y - frRef.VersY().x) * dS ;
+   }
+  // altrimenti traccia negativa
+   else {
+      if ( frRef.VersX().x > frRef.VersY().y - 10 * EPS_ZERO  &&  frRef.VersX().x > frRef.VersZ().z - 10 * EPS_ZERO) {
+         double dS = sqrt( 1 + frRef.VersX().x - ( frRef.VersY().y + frRef.VersZ().z)) ;
+         qtQ.x = dS / 2 ;
+         dS = 1 / ( 2 * dS) ;
+         qtQ.y = ( frRef.VersY().x + frRef.VersX().y) * dS ;
+         qtQ.z = ( frRef.VersX().z + frRef.VersZ().x) * dS ;
+         qtQ.w = ( frRef.VersY().z - frRef.VersZ().y) * dS ;
+      }
+      else if ( frRef.VersY().y > frRef.VersZ().z - 10 * EPS_ZERO  &&  frRef.VersY().y > frRef.VersX().x - 10 * EPS_ZERO) {
+         double dS = sqrt( 1 + frRef.VersY().y - ( frRef.VersZ().z + frRef.VersX().x)) ;
+         qtQ.y = dS / 2 ;
+         dS = 1 / ( 2 * dS) ;
+         qtQ.z = ( frRef.VersZ().y + frRef.VersY().z) * dS ;
+         qtQ.x = ( frRef.VersY().x + frRef.VersX().y) * dS ;
+         qtQ.w = ( frRef.VersZ().x - frRef.VersX().z) * dS ;
+      }
+      else {
+         double dS = sqrt( 1 + frRef.VersZ().z - ( frRef.VersX().x + frRef.VersY().y)) ;
+         qtQ.z = dS / 2 ;
+         dS = 1 / ( 2 * dS) ;
+         qtQ.x = ( frRef.VersX().z + frRef.VersZ().x) * dS ;
+         qtQ.y = ( frRef.VersZ().y + frRef.VersY().z) * dS ;
+         qtQ.w = ( frRef.VersX().y - frRef.VersY().x) * dS ;
+      }
+   }
+
+   return qtQ ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ToFrame( const Quaternion& qtQ, Frame3d& frRef)
+{
+   double dNrm = qtQ.Len() ;
+   double dS = ( dNrm > EPS_ZERO ? 2 / dNrm : 0) ;
+   double dXs = qtQ.x * dS, dYs = qtQ.y * dS, dZs = qtQ.z * dS ;
+   double dWx = qtQ.w * dXs, dWy = qtQ.w * dYs, dWz = qtQ.w * dZs ;
+   double dXx = qtQ.x * dXs, dXy = qtQ.x * dYs, dXz = qtQ.x * dZs ;
+   double dYy = qtQ.y * dYs, dYz = qtQ.y * dZs, dZz = qtQ.z * dZs ;
+   Vector3d vtX( 1 - ( dYy + dZz), dXy + dWz, dXz - dWy) ;
+   Vector3d vtY( dXy - dWz, 1 - ( dXx + dZz), dYz + dWx) ;
+   Vector3d vtZ( dXz + dWy, dYz - dWx, 1 - ( dXx + dYy)) ;
+   return frRef.Set( ORIG, vtX, vtY, vtZ) ;
+}

RotationMinimizingFrame.cpp

@@ -0,0 +1,231 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : RotationMinimizingFrame.cpp   Data : 05.03.24      Versione : 2.6d1
+// Contenuto : Classe per RotationMinimizeFrame
+//
+//
+//
+// Modifiche : 05.03.24 RE Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "GeoConst.h"
+#include "/EgtDev/Include/EGkRotationMinimizingFrame.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+bool
+RotationMinimizingFrame::Set( const ICurve* pCrv, const Frame3d& fr_Start)
+{
+  // pulisco
+   Clear() ;
+  // verifico i parametri
+   if ( pCrv == nullptr  ||  ! pCrv->IsValid()  ||
+        ! fr_Start.IsValid())
+      return false ;
+  // assegno i parametri
+   m_pCrv = pCrv->Clone() ;
+   m_Frame0 = fr_Start ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+RotationMinimizingFrame::Clear( void)
+{
+  // pulizia della curva
+   if ( m_pCrv != nullptr)
+      delete m_pCrv ;
+   m_pCrv = nullptr ;
+  // reset del frame di partenza
+   m_Frame0.Reset() ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+RotationMinimizingFrame::IsValid( void)
+{
+  // controllo validità della curva
+   if ( m_pCrv == nullptr  ||  ! m_pCrv->IsValid())
+      return false ;
+
+  // controllo del frame iniziale
+   if ( ! m_Frame0.IsValid())
+      return false ;
+
+  // controllo che l'origine del frame sia sulla curva e che l'asse Z sia tangente alla curva
+   Point3d ptS ;
+   Vector3d vtZ ;
+   if ( ! m_pCrv->GetPointD1D2( 0., ICurve::FROM_MINUS, ptS, &vtZ) ||
+        ! vtZ.Normalize()  ||
+        ! AreSamePointApprox( ptS, m_Frame0.Orig())  ||
+        ! AreSameVectorEpsilon( vtZ, m_Frame0.VersZ(), 5 * EPS_SMALL))
+      return false ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+RotationMinimizingFrame::GetFrameAtParam( const Frame3d& frAct, const double dParNext, Frame3d& frNext)
+{
+  /*
+                                 Double Reflection
+            Computation of Rotation Minimizing Frame in Computer Graphics
+                  Wenping Wang Bert Juttler Dayue Zheng Yang Liu
+  */
+
+  // ricavo i parametri dal frame
+   if ( ! frAct.IsValid())
+      return false ;
+
+  // origine del frame e versori ( ptCurr, [ vtCurrR, vtCurrS, vtCurrT])
+   Point3d ptCurr = frAct.Orig() ;
+   Vector3d vtCurrR = frAct.VersX() ;
+   Vector3d vtCurrT = frAct.VersZ() ;
+
+  // punto i-esimo sulla curva e suo vettore tangente
+   Point3d ptNext ;
+   Vector3d vtNextT ;
+   if ( ! m_pCrv->GetPointD1D2( dParNext, ICurve::FROM_MINUS, ptNext, &vtNextT)  ||
+        ! vtNextT.Normalize())
+      return false ;
+
+  // controllo per casi degeneri
+   if ( AreSamePointEpsilon( ptCurr, ptNext, EPS_ZERO)  ||               // non esiste il piano R1
+        abs( ( ptNext - ptCurr) * ( vtNextT + vtCurrT)) < EPS_ZERO)      // non esiste il piano R2
+      return false ;
+
+  // ricavo il vettore di riflessione rispetto al piano R1
+   Vector3d vR1_norm = ptNext - ptCurr ;
+   if ( ! vR1_norm.IsValid())
+      return false ;
+
+  // parametro di riflessione per R1
+   double dPar1 = vR1_norm * vR1_norm ;
+
+  // riflessione rispetto al piano R1 ( sistema sinistrorso L )
+   Vector3d vt_r_L = vtCurrR - ( 2 / dPar1) * ( vR1_norm * vtCurrR) * vR1_norm ;
+   Vector3d vt_t_L = vtCurrT - ( 2 / dPar1) * ( vR1_norm * vtCurrT) * vR1_norm ;
+
+  // ricavo il vettore di riflessione rispetto al piano R1
+   Vector3d vR2_norm = vtNextT - vt_t_L ;
+   if ( ! vR2_norm.IsValid())
+      return false ;
+
+  // parametro di riflessione per R2
+   double dPar2 = vR2_norm * vR2_norm ;
+  // versore r del nuovo frame
+   Vector3d vt_r_next = vt_r_L - ( 2 / dPar2) * ( vR2_norm * vt_r_L) * vR2_norm ;
+
+  // imposto il nuovo frame
+   return frNext.Set( ptNext, vtNextT, vt_r_next) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+RotationMinimizingFrame::GetFramesByStep( double dStep, bool bUniform, FRAME3DVECTOR& vRMFrames)
+{
+  // controllo validità
+   if ( ! IsValid())
+      return false ;
+
+  // controllo sullo step
+   dStep = max( 10 * EPS_SMALL, dStep) ;
+
+  // lunghezza della curva
+   double dCrvLen = 0. ;
+   if ( ! m_pCrv->GetLength( dCrvLen)  ||  dCrvLen < 10 * EPS_SMALL)
+      return false ;
+
+  // ricavo il numero degli step
+   int nStep = int( ceil( dCrvLen / dStep)) ;
+   double dMyStep = ( bUniform ? dCrvLen / nStep : dStep) ;
+
+  // inserisco il frame iniziale nel vettore dei riferimenti
+   vRMFrames.clear() ;
+   vRMFrames.reserve( nStep + 1) ;
+   vRMFrames.push_back( m_Frame0) ;
+
+  // ciclo sugli step in cui la curva è suddivisa
+   for ( int i = 1 ; i <= nStep ; ++ i) {
+     // ricavo il parametro della curva allo step i-esimo
+      double dParNext ;
+      if ( ! m_pCrv->GetParamAtLength( min( i * dMyStep, dCrvLen - EPS_SMALL), dParNext))
+         return false ;
+     // ricavo il frame alla posizione calcolata
+      Frame3d frNext ;
+      if ( ! GetFrameAtParam( vRMFrames[i-1], dParNext, frNext))
+         return false ;
+     // inserisco nuovo frame nel vettore dei riferimenti
+      vRMFrames.push_back( frNext) ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+RotationMinimizingFrame::GetFramesBySplit( int nIntervals, FRAME3DVECTOR& vRMFrames)
+{
+  // controllo validità
+   if ( ! IsValid())
+      return false ;
+
+  // controllo sul numero di intervalli
+   nIntervals = max( 1, nIntervals) ;
+
+  // ricavo lo step
+   double dLen = 0 ;
+   if ( ! m_pCrv->GetLength( dLen))
+      return false ;
+   double dStep = dLen / nIntervals ;
+
+   return GetFramesByStep( dStep, true, vRMFrames) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+RotationMinimizingFrame::GetFramesByTolerance( double dTol, FRAME3DVECTOR& vRMFrames)
+{
+  // controllo validità
+   if ( ! IsValid())
+      return false ;
+
+  // controllo sulla tolleranza
+   dTol = max( EPS_SMALL, dTol) ;
+
+  // ricavo la PolyLine associata alla curva mediante tale tolleranza
+   PolyLine PL ;
+   if ( ! m_pCrv->ApproxWithLines( dTol, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
+      return false ;
+   int nStep = PL.GetLineNbr() ;
+
+  // inserisco il frame iniziale nel vettore dei riferimenti
+   vRMFrames.clear() ;
+   vRMFrames.reserve( nStep + 1) ;
+   vRMFrames.push_back( m_Frame0) ;
+
+  // eseguo il calcolo dei frame su ogni punto ricavato dall'approssimazione
+   Point3d ptCurr ;
+   PL.GetFirstPoint( ptCurr) ;
+   double dParNext ;
+   Point3d ptNext ;
+   while ( PL.GetNextUPoint( &dParNext, &ptNext)) {
+     // ricavo il Frame associato a questa posizione
+      Frame3d frNext ;
+      if ( ! GetFrameAtParam( vRMFrames.back(), dParNext, frNext))
+         return false ;
+      vRMFrames.emplace_back( frNext) ;
+   }
+
+   return true ;
+}

RotationXplaneFrame.cpp

@@ -0,0 +1,223 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : RotationXplaneFrame.cpp      Data : 05.04.24      Versione : 2.6d1
+// Contenuto : Classe per RotationXplaneFrame.
+//
+//
+//
+// Modifiche : 05.04.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "GeoConst.h"
+#include "/EgtDev/Include/EGkRotationXplaneFrame.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+bool
+RotationXplaneFrame::Set( const ICurve* pCrv, const Vector3d& vtNorm, const Vector3d& vtNearX)
+{
+  // pulisco
+   Clear() ;
+  // verifico i parametri
+   if ( pCrv == nullptr  ||  ! pCrv->IsValid()  ||
+        ! vtNorm.IsValid()  ||  vtNorm.IsSmall()  ||  ! vtNearX.IsValid())
+      return false ;
+  // assegno i parametri
+   m_pCrv = pCrv->Clone() ;
+   m_vtNorm = vtNorm ;
+   m_vtNearX = vtNearX ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+RotationXplaneFrame::Clear( void)
+{
+  // pulizia della curva
+   if ( m_pCrv != nullptr)
+      delete m_pCrv ;
+   m_pCrv = nullptr ;
+  // reset dei vettori
+   m_vtNorm = V_NULL ;
+   m_vtNearX = V_NULL ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+RotationXplaneFrame::IsValid( void)
+{
+  // controllo validità della curva
+   if ( m_pCrv == nullptr  ||  ! m_pCrv->IsValid())
+      return false ;
+
+  // controllo della normale al piano
+   if ( m_vtNorm.IsSmall())
+      return false ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+RotationXplaneFrame::GetFrameAtParam( const Frame3d& frAct, const double dParNext, Frame3d& frNext)
+{
+  // verifico il riferimento corrente
+   if ( ! frAct.IsValid())
+      return false ;
+
+  // recupero punto e tangente nel nuovo punto
+   Point3d ptNext ;
+   Vector3d vtNext ;
+   if ( ! m_pCrv->GetPointD1D2( dParNext, ICurve::FROM_MINUS, ptNext, &vtNext)  ||
+        ! vtNext.Normalize())
+      return false ;
+
+  // calcolo il nuovo riferimento
+   Vector3d vtAxX = m_vtNorm ^ vtNext ;
+   if ( vtAxX.IsSmall())
+      vtAxX = frAct.VersX() ;
+   else if ( vtAxX * frAct.VersX() < 0)
+      vtAxX.Invert() ;
+  
+  // lo imposto
+   return frNext.Set( ptNext, vtNext, vtAxX) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+RotationXplaneFrame::GetFramesByStep( double dStep, bool bUniform, FRAME3DVECTOR& vRXFrames)
+{
+  // controllo validità
+   if ( ! IsValid())
+      return false ;
+
+  // controllo sullo step
+   dStep = max( 10 * EPS_SMALL, dStep) ;
+
+  // lunghezza della curva
+   double dCrvLen = 0. ;
+   if ( ! m_pCrv->GetLength( dCrvLen)  ||  dCrvLen < 10 * EPS_SMALL)
+      return false ;
+
+  // numero e lunghezza effettiva di ogni step
+   int nStep = int( ceil( dCrvLen / dStep)) ;
+   double dMyStep = ( bUniform ? dCrvLen / nStep : dStep) ;
+
+  // calcolo il riferimento iniziale
+   Point3d ptStart ; m_pCrv->GetStartPoint( ptStart) ;
+   Vector3d vtStart ; m_pCrv->GetStartDir( vtStart) ;
+   Vector3d vtAxX = m_vtNorm ^ vtStart ;
+   if ( vtAxX.IsSmall()) {
+      vtAxX = OrthoCompo( m_vtNearX, m_vtNorm) ;
+      if ( vtAxX.IsSmall()) {
+         vtAxX = FromUprightOrtho( m_vtNorm) ;
+         vtAxX.Rotate( m_vtNorm, 0, 1) ;
+      }
+   }
+   Frame3d frStart ;
+   if ( ! frStart.Set( ptStart, vtStart, vtAxX))
+      return false ;
+
+  // inserisco questo frame nel vettore dei riferimenti
+   vRXFrames.clear() ;
+   vRXFrames.reserve( nStep + 1) ;
+   vRXFrames.push_back( frStart) ;
+
+  // ciclo sugli step in cui la curva è suddivisa
+   for ( int i = 1 ; i <= nStep ; ++ i) {
+     // ricavo il parametro della curva allo step i-esimo
+      double dParNext ;
+      if ( ! m_pCrv->GetParamAtLength( min( i * dMyStep, dCrvLen - EPS_SMALL), dParNext))
+         return false ;
+     // ricavo il frame alla posizione calcolata
+      Frame3d frNext ;
+      if ( ! GetFrameAtParam( vRXFrames[i-1], dParNext, frNext))
+         return false ;
+     // inserisco nuovo frame nel vettore dei riferimenti
+      vRXFrames.push_back( frNext) ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+RotationXplaneFrame::GetFramesBySplit( int nIntervals, FRAME3DVECTOR& vRXFrames)
+{
+  // controllo validità
+   if ( ! IsValid())
+      return false ;
+
+  // controllo sul numero di intervalli
+   nIntervals = max( 1, nIntervals) ;
+
+  // ricavo lo step
+   double dLen = 0 ;
+   if ( ! m_pCrv->GetLength( dLen))
+      return false ;
+   double dStep = dLen / nIntervals ;
+
+   return GetFramesByStep( dStep, true, vRXFrames) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+RotationXplaneFrame::GetFramesByTolerance( double dTol, FRAME3DVECTOR& vRXFrames)
+{
+  // controllo validità
+   if ( ! IsValid())
+      return false ;
+
+  // controllo sulla tolleranza
+   dTol = max( EPS_SMALL, dTol) ;
+
+  // ricavo la PolyLine associata alla curva mediante tale tolleranza
+   PolyLine PL ;
+   if ( ! m_pCrv->ApproxWithLines( dTol, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
+      return false ;
+   int nStep = PL.GetLineNbr() ;
+
+  // calcolo il riferimento iniziale
+   Point3d ptStart ; m_pCrv->GetStartPoint( ptStart) ;
+   Vector3d vtStart ; m_pCrv->GetStartDir( vtStart) ;
+   Vector3d vtAxX = m_vtNorm ^ vtStart ;
+   if ( vtAxX.IsSmall()) {
+      vtAxX = OrthoCompo( m_vtNearX, m_vtNorm) ;
+      if ( vtAxX.IsSmall()) {
+         vtAxX = FromUprightOrtho( m_vtNorm) ;
+         vtAxX.Rotate( m_vtNorm, 0, 1) ;
+      }
+   }
+   Frame3d frStart ;
+   if ( ! frStart.Set( ptStart, vtStart, vtAxX))
+      return false ;
+
+  // inserisco questo frame nel vettore dei riferimenti
+   vRXFrames.clear() ;
+   vRXFrames.reserve( nStep + 1) ;
+   vRXFrames.push_back( frStart) ;
+
+  // eseguo il calcolo dei frame sui punti della polyline approssimante
+   Point3d ptCurr ;
+   PL.GetFirstPoint( ptCurr) ;
+   double dParNext ;
+   Point3d ptNext ;
+   while ( PL.GetNextUPoint( &dParNext, &ptNext)) {
+     // ricavo il Frame associato a questa posizione
+      Frame3d frNext ;
+      if ( ! GetFrameAtParam( vRXFrames.back(), dParNext, frNext))
+         return false ;
+      vRXFrames.emplace_back( frNext) ;
+   }
+
+   return true ;
+}

SbzStandard.cpp

@@ -0,0 +1,80 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024
+//----------------------------------------------------------------------------
+// File : SbzSphere.cpp    Data : 14.02.2024       Versione : 2.6b2
+// Contenuto : Implementazione di funzioni per creazione di superfici Sbz
+//             standard : Box, Pyramid, Cylinder, Sphere, Cone.
+//
+//
+// Modifiche : 14.02.2024 DB Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "CurveArc.h"
+#include "SurfTriMesh.h"
+#include "SurfBezier.h"
+#include "/EgtDev/Include/EGkSbzStandard.h"
+
+using namespace std ;
+
+//-------------------------------------------------------------------------------
+ISurfBezier*
+CreateBezierSphere( const Point3d& ptCenter, double dR)
+{
+   // creo una superficie di Bezier di grado 2 con 45 punti di controllo
+   PtrOwner<ISurfBezier> pSrfBez( CreateSurfBezier()) ;
+   int nDegU = 2 ;
+   int nDegV = 2 ;
+   int nSpanU = 4 ; // i poli della sfera sono a coordinate ( 0,0,-R) e ( 0,0,R)
+   int nSpanV = 2 ;
+   bool bRat = true ;
+   double dW = SQRT2 ;
+   pSrfBez->Init(nDegU, nDegV, nSpanU, nSpanV, bRat) ;
+   // polo inferiore // dW = 1, dW = SQRT2 / 2
+   for ( int i = 0 ; i < 9; ++i) {
+      if ( i % 2 == 0)
+         dW = 1 ;
+      else
+         dW = SQRT2 / 2 ;
+      pSrfBez->SetControlPoint( i, 0, ptCenter + Point3d( 0, 0, -dR), dW) ;
+   }
+   // definisco la gabbia esterna // dW = SQRT2 / 2, dW = 1 / 2
+   // parto dal punto ( 0,-dR, -dR) e completo riga per riga
+   double dH = -dR ;
+   for ( int j = 1 ; j < 4 ; ++j ) {
+      Vector3d vtDir ( 0, -dR, 0) ;
+      Point3d pt(-dR,-dR,dH) ;
+      for ( int i = 0; i < 9 ; ++i ) {
+         // ogni due punti ruoto di 90 gradi a sinistra
+         if ( i%2 == 0) {
+            vtDir.Rotate( Z_AX, 90) ;
+            if ( j%2 == 1)
+               dW = SQRT2 / 2 ;
+            else
+               dW = 1 ;
+         }
+         else {
+            if ( j%2 == 1)
+               dW = 1. / 2. ;
+            else
+               dW = SQRT2 / 2 ;
+         }
+         pt += vtDir ;
+         pSrfBez->SetControlPoint( i, j, ptCenter + pt, dW) ;
+      }
+      dH += dR ;
+   }
+   // polo superiore  // dW = 1, dW = SQRT2 / 2
+   for ( int i = 0 ; i < 9; ++i) {
+      if ( i % 2 == 0)
+         dW = 1 ;
+      else
+         dW = SQRT2 / 2 ;
+      pSrfBez->SetControlPoint( i, 4, ptCenter + Point3d( 0, 0, dR), dW) ;
+   }
+
+   return Release( pSrfBez) ;
+}

StmFromCurves.cpp

@@ -1,4 +1,4 @@
-//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 //  EgalTech 2015-2015
 //----------------------------------------------------------------------------
 // File : StmFromCurves.cpp    Data : 01.02.15       Versione : 1.6b1
@@ -19,14 +19,15 @@
 #include "CurveComposite.h"
 #include "SurfTriMesh.h"
 #include "Voronoi.h"
+#include "/EgtDev/Include/EGkSfrCreate.h"
 #include "/EgtDev/Include/EGkOffsetCurve.h"
 #include "/EgtDev/Include/EGkStmFromCurves.h"
 #include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
+#include "/EgtDev/Include/EGkRotationMinimizingFrame.h"
+#include "/EgtDev/Include/EGkRotationXplaneFrame.h"
+#include "/EgtDev/Include/EGkIntersCurves.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
-#include <algorithm>
-#include <thread>
 #include <future>
-#include <EgtDev/Include/EGkIntersCurves.h>
 
 using namespace std ;
 
@@ -110,9 +111,9 @@ GetSurfTriMeshByExtrusion( const ICurve* pCurve, const Vector3d& vtExtr,
    PtrOwner<SurfTriMesh> pSTM( CreateBasicSurfTriMesh()) ;
    if ( IsNull( pSTM)  ||  ! pSTM->CreateByExtrusion( PL, vtExtr))
       return nullptr ;
-  // se da fare, metto i tappi sulle estremità
+  // se da fare, metto i tappi sulle estremità
    if ( bDoCapEnds) {
-     // creo la prima superficie di estremità
+     // creo la prima superficie di estremità
       SurfTriMesh STM1 ;
       if ( ! STM1.CreateByFlatContour( PL))
          return nullptr ;
@@ -156,7 +157,7 @@ GetSurfTriMeshByRegionExtrusion( const CICURVEPVECTOR& vpCurve, const Vector3d&
       for ( int i = 0 ; i < int( vPL.size()) ; ++ i)
          vPL[i].Invert() ;
    }
-  // creo la prima superficie di estremità
+  // creo la prima superficie di estremità
    PtrOwner<SurfTriMesh> pSTM( CreateBasicSurfTriMesh()) ;
    if ( IsNull( pSTM)  ||  ! pSTM->CreateByRegion( vPL))
       return nullptr ;
@@ -288,7 +289,7 @@ GetSurfTriMeshByScrewing( const ICurve* pCurve, const Point3d& ptAx, const Vecto
       return nullptr ;
   // se richiesti caps
    if ( bCapEnds) {
-     // determino se la sezione è chiusa e piatta
+     // determino se la sezione è chiusa e piatta
       Plane3d plPlane ; double dArea ;
       bool bSectClosedFlat = PL.IsClosedAndFlat( plPlane, dArea, 10 * EPS_SMALL) ;
      // determino non sia una semplice rivoluzione
@@ -332,7 +333,7 @@ GetSurfTriMeshSharpRectSwept( double dDimH, double dDimV, const ICurve* pGuide,
    if ( ! pGuide->IsFlat( plGuide, false, 10 * EPS_SMALL))
       return nullptr ;
    Vector3d vtNorm = plGuide.GetVersN() ;
-  // determino se la guida è chiusa
+  // determino se la guida è chiusa
    bool bGuideClosed = pGuide->IsClosed() ;
   // curve di offset
    OffsetCurve OffsCrvR ;
@@ -373,7 +374,7 @@ GetSurfTriMeshSharpRectSwept( double dDimH, double dDimV, const ICurve* pGuide,
    pSTM->SetSmoothAngle( 20) ;
   // se guida aperta e tappi piatti
    if ( ! bGuideClosed  &&  nCapType == RSCAP_FLAT) {
-     // verifico che le due estremità siano chiuse e piatte
+     // verifico che le due estremità siano chiuse e piatte
       POLYLINEVECTOR vPL ;
       if ( ! pSTM->GetLoops( vPL)  ||  vPL.size() != 2)
          return nullptr ;
@@ -452,7 +453,7 @@ GetSurfTriMeshBeveledRectSwept( double dDimH, double dDimV, double dBevelH, doub
    Point3d ptCen ;
    pGuide->GetStartPoint( ptCen) ;
    ptCen -= dDimV / 2 * vtNorm ;
-  // determino se la guida è chiusa
+  // determino se la guida è chiusa
    bool bGuideClosed = pGuide->IsClosed() ;
   // curve di offset
    const int NUM_OFFS = 4 ;
@@ -475,7 +476,7 @@ GetSurfTriMeshBeveledRectSwept( double dDimH, double dDimV, double dBevelH, doub
       }   
    }
    else {
-     // se Voronoi non è possibile calcolare gli offset di una stessa curva in parallelo 
+     // se Voronoi non è possibile calcolare gli offset di una stessa curva in parallelo 
       for ( int i = 0 ; i < NUM_OFFS && bOk ; ++ i)
          bOk = vOffsCrv[i].Make( pGuide, vDist[i], ICurve::OFF_FILLET) ;
    }
@@ -552,7 +553,7 @@ GetSurfTriMeshBeveledRectSwept( double dDimH, double dDimV, double dBevelH, doub
       StmFromTriangleSoup stmCapSoup ;
       if ( ! stmCapSoup.Start( nBuckets))
          return nullptr ;
-     // verifico che le due estremità siano chiuse e piatte
+     // verifico che le due estremità siano chiuse e piatte
       POLYLINEVECTOR vPL ;
       if ( ! pSTM->GetLoops( vPL)  ||  vPL.size() != 2)
          return nullptr ;
@@ -650,47 +651,42 @@ GetSurfTriMeshRectSwept( double dDimH, double dDimV, double dBevelH, double dBev
 }
 
 //-------------------------------------------------------------------------------
-ISurfTriMesh*
-GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, double dLinTol)
+static ISurfTriMesh*
+GetSurfTriMeshSweptInPlane( const ICurve* pSect, const ICurve* pGuide, const Vector3d& vtNorm, bool bCapEnds, double dLinTol)
 {
-  // verifica parametri
-   if ( pSect == nullptr  ||  pGuide == nullptr)
-      return nullptr ;
-  // calcolo la polilinea che approssima la sezione
-   PolyLine PL ;
-   if ( ! pSect->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
-      return nullptr ;
-  // determino se la sezione è chiusa
-   bool bSectClosed = PL.IsClosed() ;
-  // verifico che la linea guida sia piana
-   Plane3d plGuide ;
-   if ( ! pGuide->IsFlat( plGuide, false, 10 * EPS_SMALL))
-      return nullptr ;
-  // determino se la guida è chiusa
+  // determino se la sezione è chiusa
+   bool bSectClosed = pSect->IsClosed() ;
+  // determino se la guida è chiusa
    bool bGuideClosed = pGuide->IsClosed() ;
+
   // riferimento all'inizio della linea guida
    Frame3d frStart ;
    Point3d ptStart ;
    pGuide->GetStartPoint( ptStart) ;
    Vector3d vtStart ;
    pGuide->GetStartDir( vtStart) ;
-   Vector3d vtNorm = plGuide.GetVersN() ;
    frStart.Set( ptStart, -vtStart, vtStart ^ vtNorm) ;
-  // porto la sezione in questo riferimento e ve la appiattisco
+
+   // calcolo la polilinea che approssima la sezione
+   PolyLine PL ;
+   if ( ! pSect->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
+      return nullptr ;
+
+   // porto la sezione in questo riferimento e ve la appiattisco
    if ( ! PL.ToLoc( frStart)  ||  ! PL.Flatten())
       return nullptr ;
-  // calcolo la superficie
-   PtrOwner<SurfTriMesh> pSTM( CreateBasicSurfTriMesh()) ;
-   if ( IsNull( pSTM))
+
+  // preparo collettore delle superfici componenti
+   StmFromTriangleSoup StmFts ;
+   if ( ! StmFts.Start())
       return nullptr ;
-  // salvo tolleranza lineare usata
-   pSTM->SetLinearTolerance( dLinTol) ;
+
   // superficie swept
    PtrOwner<ICurve> pPrevCrv ;
    Point3d ptP ;
    bool bPoint = PL.GetFirstPoint( ptP) ;
    while ( bPoint) {
-     // nuova curva
+     // nuova curva ( definita dall'Offset )
       OffsetCurve OffsCrv ;
       if ( ! OffsCrv.Make( pGuide, ptP.x, ICurve::OFF_FILLET)  ||  OffsCrv.GetCurveCount() == 0)
          return nullptr ;
@@ -698,21 +694,32 @@ GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, d
       if ( IsNull( pCurrCrv))
          return nullptr ;
       pCurrCrv->Translate( ptP.y * frStart.VersY()) ;
-     // se esiste la curva precedente, costruisco la rigata (di tipo minima distanza)
+     // se esiste la curva precedente, costruisco la rigata ( di tipo minima distanza)
       if ( ! IsNull( pPrevCrv)) {
          PtrOwner<ISurfTriMesh> pSr( GetSurfTriMeshRuled( pPrevCrv, pCurrCrv, ISurfTriMesh::RLT_MINDIST, dLinTol)) ;
          if ( IsNull( pSr))
             return nullptr ;
-         pSTM->DoSewing( *pSr) ;
+        // inserisco nel collettore
+         StmFts.AddSurfTriMesh( *pSr) ;
       }
      // salvo la curva come prossima precedente
       pPrevCrv.Set( pCurrCrv) ;
      // prossimo punto
       bPoint = PL.GetNextPoint( ptP) ;
    }
+
+  // recupero la supeficie risultante
+   if ( ! StmFts.End())
+      return nullptr ;
+   PtrOwner<SurfTriMesh> pSTM( GetBasicSurfTriMesh( StmFts.GetSurf())) ;
+   if ( IsNull( pSTM))
+      return nullptr ;
+  // salvo tolleranza lineare usata
+   pSTM->SetLinearTolerance( dLinTol) ;
+
   // se richiesti caps e sezione chiusa e guida aperta
    if ( bCapEnds  &&  bSectClosed  &&  ! bGuideClosed) {
-     // verifico che le due estremità siano chiuse e piatte
+     // verifico che le due estremità siano chiuse e piatte
       POLYLINEVECTOR vPL ;
       if ( ! pSTM->GetLoops( vPL)  ||  vPL.size() != 2)
          return nullptr ;
@@ -726,6 +733,7 @@ GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, d
       if ( IsNull( pSci)  ||  ! pSci->CreateByFlatContour( PL))
          return nullptr ;
       pSci->ToGlob( frStart) ;
+     // unisco
       pSTM->DoSewing( *pSci) ;
      // riferimento alla fine della linea guida
       Frame3d frEnd ;
@@ -740,6 +748,7 @@ GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, d
          return nullptr ;
       pSce->Invert() ;
       pSce->ToGlob( frEnd) ;
+     // unisco
       pSTM->DoSewing( *pSce) ;
    }
   // se superficie risultante chiusa, verifico che la normale sia verso l'esterno
@@ -750,6 +759,329 @@ GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, d
    return Release( pSTM) ;
 }
 
+//-------------------------------------------------------------------------------
+static ISurfTriMesh*
+GetSurfTriMeshSwept3d( const ICurve* pSect, const ICurve* pGuide, const Vector3d& vtAx, bool bCapEnds, double dLinTol)
+{
+  // determino se la sezione è chiusa
+   bool bSectClosed = pSect->IsClosed() ;
+  // determino se la guida è chiusa
+   bool bGuideClosed = pGuide->IsClosed() ;
+  // determino algoritmo da usare per calcolare i riferimenti lungo la curva
+   bool bRMF = vtAx.IsSmall() ;
+
+  // riferimento all'inizio della linea guida
+   Point3d ptStart ;
+   pGuide->GetStartPoint( ptStart) ;
+   Vector3d vtStart ;
+   pGuide->GetStartDir( vtStart) ;
+   Frame3d frStart ;
+   if ( bRMF) {
+      if ( ! frStart.Set( ptStart, vtStart))
+         return nullptr ;
+   }
+   else {
+      Vector3d vtAxX = vtAx ^ vtStart ;
+      if ( vtAxX.IsSmall()) {
+         vtAxX = FromUprightOrtho( vtAx) ;
+         vtAxX.Rotate( vtAx, 0, 1) ;
+      }
+      if ( ! frStart.Set( ptStart, vtStart, vtAxX))
+         return nullptr ;
+   }
+
+  // calcolo la polilinea che approssima la sezione
+   PolyLine PL ;
+   if ( ! pSect->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
+      return nullptr ;
+
+  // recupero la sezione dalla PolyLine approssimata come Curva
+   PtrOwner<CurveComposite> pSecLocApprox( CreateBasicCurveComposite()) ;
+   if ( IsNull( pSecLocApprox)  ||
+        ! pSecLocApprox->FromPolyLine( PL)  ||
+        ! pSecLocApprox->IsValid())
+      return nullptr ;
+
+  // porto la PolyLine e la curva della sezione nel riferimento nel punto iniziale della guida
+   PL.ToLoc( frStart) ;
+   pSecLocApprox->ToLoc( frStart) ;
+
+  // calcolo il vettore di Frames campionati lungo la guida mediante la tolleranza definita
+   FRAME3DVECTOR vFrames ;
+   if ( bRMF) {
+      RotationMinimizingFrame RMF ;
+      if ( ! RMF.Set( pGuide, frStart)  ||
+           ! RMF.GetFramesByTolerance( dLinTol, vFrames)  ||  vFrames.empty())
+         return nullptr ;
+   }
+   else {
+      RotationXplaneFrame RXF ;
+      if ( ! RXF.Set( pGuide, vtAx, frStart.VersX())  ||
+           ! RXF.GetFramesByTolerance( dLinTol, vFrames)  ||  vFrames.empty())
+         return nullptr ;
+   }
+
+  // preparo collettore delle superfici componenti
+   StmFromTriangleSoup StmFts ;
+   if ( ! StmFts.Start())
+      return nullptr ;
+
+  // per ogni Frame calcolato, la sezione va roto-traslata lungo la guida
+   for ( int i = 0 ; i < int( vFrames.size()) - 1 ; ++ i) {
+
+     // definisco la sezione allo step corrente
+      PtrOwner<ICurve> pSecCurr( pSecLocApprox->Clone()) ;
+      if ( IsNull( pSecCurr)  ||  ! pSecCurr->IsValid())
+         return nullptr ;
+
+     // considero la sezione ( in locale ) come vista dal globale
+      if ( ! pSecCurr->ToGlob( vFrames[i]))
+         return nullptr ;
+
+     // definisco la sezione allo step successivo
+      PtrOwner<ICurve> pSecSucc( pSecLocApprox->Clone()) ;
+      if ( IsNull( pSecSucc)  ||  ! pSecSucc->IsValid())
+         return nullptr ;
+
+     // considero la sezione ( in locale ) come vista dal globale
+      if ( ! pSecSucc->ToGlob( vFrames[i+1]))
+         return nullptr ;
+
+     // creo la rigata tra queste due sezioni
+      PtrOwner<ISurfTriMesh> pSr( GetSurfTriMeshRuled( pSecCurr, pSecSucc, ISurfTriMesh::RLT_ISOPAR_SMOOTH, dLinTol)) ;
+      if ( IsNull( pSr)  ||  ! pSr->IsValid())
+         return nullptr ;
+     // la inverto
+      pSr->Invert() ;
+     // inserisco la superficie nel collettore
+      StmFts.AddSurfTriMesh( *pSr) ;
+   }
+
+  // se richiesti caps e sezione chiusa e guida aperta
+   if ( bCapEnds  &&  bSectClosed  &&  ! bGuideClosed) {
+
+     // aggiungo il cap sull'inizio ( portandolo nel frame del punto iniziale della guida )
+      PtrOwner<SurfTriMesh> pSci( CreateBasicSurfTriMesh()) ;
+      if ( IsNull( pSci)  ||  ! pSci->CreateByFlatContour( PL))
+         return nullptr ;
+      pSci->ToGlob( vFrames.front()) ;
+     // aggiungo
+      StmFts.AddSurfTriMesh( *pSci) ;
+
+     // aggiungo il cap sulla fine ( portandolo nel frame del punto finale della guida )
+      PtrOwner<SurfTriMesh> pSce( CreateBasicSurfTriMesh()) ;
+      if ( IsNull( pSce)  ||  ! pSce->CreateByFlatContour( PL))
+         return nullptr ;
+      pSce->ToGlob( vFrames.back()) ;
+     // inverto
+      pSce->Invert() ;
+     // aggiungo
+      StmFts.AddSurfTriMesh( *pSce) ;
+   }
+
+  // recupero la supeficie risultante
+   if ( ! StmFts.End())
+      return nullptr ;
+   PtrOwner<SurfTriMesh> pSTM( GetBasicSurfTriMesh( StmFts.GetSurf())) ;
+   if ( IsNull( pSTM))
+      return nullptr ;
+  // salvo tolleranza lineare usata
+   pSTM->SetLinearTolerance( dLinTol) ;
+
+  // se superficie risultante chiusa, verifico che la normale sia verso l'esterno
+   double dVol ;
+   if ( pSTM->GetVolume( dVol)  &&  dVol < 0)
+      pSTM->Invert() ;
+
+  // restituisco la superficie
+   return Release( pSTM) ;
+}
+
+//-------------------------------------------------------------------------------
+ISurfTriMesh*
+GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, const Vector3d& vtAx,
+                     bool bCapEnds, double dLinTol)
+{
+  // verifica parametri
+   if ( pSect == nullptr  ||  pGuide == nullptr)
+      return nullptr ;
+     
+   bool bIsLine = false ;
+   if ( pGuide->GetType() == CRV_LINE)
+      bIsLine = true ;
+   else {
+      const CurveComposite* pCompo = GetBasicCurveComposite( pGuide) ;
+      Point3d ptStart, ptEnd ;
+      if ( pCompo != nullptr  &&  pCompo->IsALine( 10 * EPS_SMALL, ptStart, ptEnd))
+         bIsLine = true ;
+   }
+  // se la guida è piana
+   Plane3d plGuide ;
+   if ( pGuide->IsFlat( plGuide, bIsLine, 10 * EPS_SMALL))
+      return GetSurfTriMeshSweptInPlane( pSect, pGuide, plGuide.GetVersN(), bCapEnds, dLinTol) ;
+
+  // altrimenti swept 3d
+   return GetSurfTriMeshSwept3d( pSect, pGuide, vtAx, bCapEnds, dLinTol) ;
+}
+
+//-------------------------------------------------------------------------------
+ISurfTriMesh*
+GetSurfTriMeshSwept( const ISurfFlatRegion* pSfrSect, const ICurve* pGuide, const Vector3d& vtAx,
+                     bool bCapEnds, double dLinTol)
+{
+  // verifica dei parametri
+   if ( pSfrSect == nullptr  ||  pGuide == nullptr)
+      return nullptr ;
+
+  // predispongo collettore superfici componenti
+   StmFromTriangleSoup StmSoup ;
+   StmSoup.Start() ;
+
+  // per ogni loop della superficie, creo una Swept
+   for ( int nC = 0 ; nC < pSfrSect->GetChunkCount() ; ++ nC) {
+      for ( int nL = 0 ; nL < pSfrSect->GetLoopCount( nC) ; ++ nL) {
+        // recupero il loop
+         PtrOwner<ICurve> pCrvLoop( pSfrSect->GetLoop( nC, nL)) ;
+         if ( IsNull( pCrvLoop)  ||  ! pCrvLoop->IsValid())
+            return nullptr ;
+        // creo la Trimesh Swept
+         PtrOwner<ISurfTriMesh> pStmLoopSwept( GetSurfTriMeshSwept( pCrvLoop, pGuide, vtAx, false, dLinTol)) ;
+         if ( IsNull( pStmLoopSwept)  ||  ! pStmLoopSwept->IsValid())
+            return nullptr ;
+        // aggiungo la Swept ricavata al risultato finale ( come triangoli )
+         StmSoup.AddSurfTriMesh( *pStmLoopSwept) ;
+      }
+   }
+
+  // Recupero la superficie
+   if ( ! StmSoup.End())
+      return nullptr ;
+   PtrOwner<ISurfTriMesh> pStmSwept( StmSoup.GetSurf()) ;
+   if ( IsNull( pStmSwept))
+      return nullptr ;
+
+  // se rischiesta chiusura...
+  // Controllo solo che la guida non sia chiusa, la sezione derivando da una Flatregion è sempre chiusa
+   if ( bCapEnds  &&  ! pGuide->IsClosed()) {
+     // recupero i loop all'inizio (dalla regione e apportunamente approssimati)
+      POLYLINEVECTOR vPLi ;
+      for ( int nC = 0 ; nC < pSfrSect->GetChunkCount() ; ++ nC) {
+         for ( int nL = 0 ; nL < pSfrSect->GetLoopCount( nC) ; ++ nL) {
+            vPLi.emplace_back() ;
+            if ( ! pSfrSect->ApproxLoopWithLines( nC, nL, dLinTol, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, vPLi.back()))
+               return nullptr ;
+         }
+      }
+     // creo il cap sull'inizio e lo attacco alla swept ( è già in posizione giusta)
+      PtrOwner<ISurfTriMesh> pSci( CreateSurfTriMesh()) ;
+      if ( ! pSci->CreateByRegion( vPLi))
+         return nullptr ;
+      pStmSwept->DoSewing( *pSci) ;
+     // recupero i loops alla fine
+      POLYLINEVECTOR vPLe ;
+      if ( ! pStmSwept->GetLoops( vPLe))
+         return nullptr ;
+     // creo la superficie alla fine e la attacco
+      PtrOwner<ISurfTriMesh> pSce( CreateSurfTriMesh()) ;
+      if ( ! pSce->CreateByRegion( vPLe))
+         return nullptr ;
+     // attacco la superficie finale alla swept
+      pSce->Invert() ;
+      pStmSwept->DoSewing( *pSce) ;
+   }
+  // se superficie risultante chiusa, verifico che la normale sia verso l'esterno
+   double dVol ;
+   if ( pStmSwept->GetVolume( dVol)  &&  dVol < 0)
+      pStmSwept->Invert() ;
+
+   return Release( pStmSwept) ;
+}
+
+//-------------------------------------------------------------------------------
+ISurfTriMesh*
+GetSurfTriMeshTransSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, double dLinTol)
+{
+  // verifica parametri
+   if ( pSect == nullptr  ||  pGuide == nullptr)
+      return nullptr ;
+  // determino se la sezione è chiusa
+   bool bSectClosed = pSect->IsClosed() ;
+  // punto iniziale della sezione e vettore a inizio guida
+   Point3d ptStart ;
+   if ( ! pSect->GetStartPoint( ptStart))
+      return nullptr ;
+   Point3d ptGuide ;
+   if ( ! pGuide->GetStartPoint( ptGuide))
+      return nullptr ;
+   Vector3d vtDelta = ptStart - ptGuide ;
+  // calcolo la polilinea che approssima la guida
+   PolyLine PLG ;
+   if ( ! pGuide->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PLG))
+      return nullptr ;
+  // determino se la guida è chiusa
+   bool bGuideClosed = PLG.IsClosed() ;
+  // calcolo la superficie
+   PtrOwner<SurfTriMesh> pSTM( CreateBasicSurfTriMesh()) ;
+   if ( IsNull( pSTM))
+      return nullptr ;
+  // salvo tolleranza lineare usata
+   pSTM->SetLinearTolerance( dLinTol) ;
+  // superficie swept
+   PtrOwner<ICurve> pPrevCrv ;
+   Point3d ptP ;
+   bool bPoint = PLG.GetFirstPoint( ptP) ;
+   while ( bPoint) {
+     // nuova curva
+      PtrOwner<ICurve> pCurrCrv( pSect->Clone()) ;
+      if ( IsNull( pCurrCrv))
+         return nullptr ;
+      pCurrCrv->Translate( ptP - ptStart + vtDelta) ;
+     // se esiste la curva precedente, costruisco la rigata (di tipo minima distanza)
+      if ( ! IsNull( pPrevCrv)) {
+         PtrOwner<ISurfTriMesh> pSr( GetSurfTriMeshRuled( pPrevCrv, pCurrCrv, ISurfTriMesh::RLT_ISOPAR, dLinTol)) ;
+         if ( IsNull( pSr))
+            return nullptr ;
+         pSTM->DoSewing( *pSr) ;
+      }
+     // salvo la curva come prossima precedente
+      pPrevCrv.Set( pCurrCrv) ;
+     // prossimo punto
+      bPoint = PLG.GetNextPoint( ptP) ;
+   }
+  // se richiesti caps e sezione chiusa e guida aperta
+   if ( bCapEnds  &&  bSectClosed  &&  ! bGuideClosed) {
+     // calcolo la polilinea che approssima la sezione
+      PolyLine PLS ;
+      if ( ! pSect->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PLS))
+         return nullptr ;
+     // verifico che la sezione sia chiusa e piatta
+      Plane3d plSect ; double dArea ;
+      if ( PLS.IsClosedAndFlat( plSect, dArea, 100 * EPS_SMALL)) {
+        // aggiungo il cap sull'inizio
+         PtrOwner<SurfTriMesh> pSci( CreateBasicSurfTriMesh()) ;
+         if ( IsNull( pSci)  ||  ! pSci->CreateByFlatContour( PLS))
+            return nullptr ;
+         pSci->Invert() ;
+         Point3d ptGi ; PLG.GetFirstPoint( ptGi) ;
+         pSci->Translate( ptGi - ptStart + vtDelta) ;
+         pSTM->DoSewing( *pSci) ;
+        // aggiungo il cap sulla fine
+         PtrOwner<SurfTriMesh> pSce( CreateBasicSurfTriMesh()) ;
+         if ( IsNull( pSce)  ||  ! pSce->CreateByFlatContour( PLS))
+            return nullptr ;
+         Point3d ptGe ; PLG.GetLastPoint( ptGe) ;
+         pSce->Translate( ptGe - ptStart + vtDelta) ;
+         pSTM->DoSewing( *pSce) ;
+      }
+   }
+  // se superficie risultante chiusa, verifico che la normale sia verso l'esterno
+   double dVol ;
+   if ( pSTM->GetVolume( dVol)  &&  dVol < 0)
+      pSTM->Invert() ;
+  // restituisco la superficie
+   return Release( pSTM) ;
+}
+
 //-------------------------------------------------------------------------------
 ISurfTriMesh*
 GetSurfTriMeshRuled( const Point3d& ptP, const ICurve* pCurve, double dLinTol)
@@ -852,7 +1184,7 @@ CalcRegionPolyLines( const CICURVEPVECTOR& vpCurve, double dLinTol,
       vCrvCompo[i]->ToLoc( frRef) ;
    }
 
-  // creo una matrice di interi ; ogni riga corrisponde ad un chunk, dove in posizione 0 c'è il loop esterno e nelle
+  // creo una matrice di interi ; ogni riga corrisponde ad un chunk, dove in posizione 0 c'è il loop esterno e nelle
   // successive i loop interni
    INTMATRIX vnPLIndMat ;
 
@@ -885,10 +1217,10 @@ CalcRegionPolyLines( const CICURVEPVECTOR& vpCurve, double dLinTol,
             }
             bFirstCrv = false ;
          }
-        // ... altrimenti verifico se il loop è interno o no
+        // ... altrimenti verifico se il loop è interno o no
          else {
-           // il loop è interno se è sia interno al loop esterno della riga di vnPLIndMat e allo stesso tempo
-           // esterno a tutti i loop già inseriti nella riga attuale.
+           // il loop è interno se è sia interno al loop esterno della riga di vnPLIndMat e allo stesso tempo
+           // esterno a tutti i loop già inseriti nella riga attuale.
            // verifica rispetto loop esterno
             IntersCurveCurve ccInt( *vCrvCompo[vnPLIndMat.back().front()], *vCrvCompo[j]) ;
             CRVCVECTOR ccClass ;

SurfAux.cpp

@@ -20,12 +20,14 @@
 #include "CurveBezier.h"
 #include "CurveComposite.h"
 #include "SurfBezier.h"
-#include "/EgtDev/Include/EgtPointerOwner.h"
 #include "/EgtDev/Include/EGkSurf.h"
 #include "/EgtDev/Include/EGkSurfAux.h"
+#include "/EgtDev/Include/EGkSfrCreate.h"
+#include "/EgtDev/Include/EgtPointerOwner.h"
 
 using namespace std ;
 
+//----------------------------------------------------------------------------
 bool
 NurbsSurfaceCanonicalize( SNurbsSurfData& snData)
 {
@@ -108,26 +110,24 @@ NurbsSurfaceCanonicalize( SNurbsSurfData& snData)
    return true;
 }
 
-
 //----------------------------------------------------------------------------
 ISurf*
 NurbsToBezierSurface(const SNurbsSurfData& snData)
 {
-   // la superficie Nurbs deve essere in forma canonica
+  // la superficie Nurbs deve essere in forma canonica
    if ( snData.bPeriodicU || snData.bPeriodicV || snData.bExtraKnotes )
       return nullptr ;
-   // controllo sul numero dei nodi
+  // controllo sul numero dei nodi
    int nU = snData.nCPU + snData.nDegU - 1 ;
    int nV = snData.nCPV + snData.nDegV - 1 ;
-   // controllo nodi e punti di controllo
-   //if ( nU != int( snData.vU.size())  ||  nV != int( snData.vV.size())  ||  snData.nCPU * snData.nCPV != int( snData.vCP.size()))
+  // controllo nodi e punti di controllo
    if ( nU != int(snData.vU.size()) || nV != int(snData.vV.size())) {
       return nullptr ;
    }
 
-   // verifico le condizioni agli estremi sui nodi (i primi nDeg nodi e gli ultimi nDeg nodi devono essere uguali tra loro)
+  // verifico le condizioni agli estremi sui nodi (i primi nDeg nodi e gli ultimi nDeg nodi devono essere uguali tra loro)
    bool bOk = true ;
-   // direzione U
+  // direzione U
    for ( int i = 1 ; i < snData.nDegU ; ++ i) {
       if ( abs( snData.vU[i] - snData.vU[0]) >= EPS_ZERO)
          bOk = false ;
@@ -136,7 +136,7 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
       if ( abs( snData.vU[nU - 1 - i] - snData.vU[nU - 1]) >= EPS_ZERO)
          bOk = false ;
    }
-   // direzione V
+  // direzione V
    for ( int i = 1 ; i < snData.nDegV ; ++ i) {
       if ( abs( snData.vV[i] - snData.vV[0]) >= EPS_ZERO)
          bOk = false ;
@@ -148,8 +148,8 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
    if ( ! bOk)
       return nullptr ;
 
-   // algoritmo 5.7 del libro "The NURBS book"//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-   // creazione delle strips nella direzione U ( trasformo le curve iso con U costante in bezier)
+  // algoritmo 5.7 del libro "The NURBS book"
+  // creazione delle strips nella direzione U ( trasformo le curve iso con U costante in bezier)
    int a = snData.nDegU - 1 ;
    int b = snData.nDegU ;
    int nb = 0 ;  // numero di strisce in U ( lunghezza con U costante)
@@ -164,14 +164,14 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
    DBLVECTOR vAlpha ;
    vAlpha.resize( snData.nDegU - 1) ;
    if ( ! snData.bRat ) {
-      for ( int i = 0 ; i <= snData.nDegU ; ++i ) {
+      for ( int i = 0 ; i <= snData.nDegU ; ++i) {
          for ( int row = 0 ; row < snData.nCPV ; ++row ) {
             mBC[i][row] = snData.mCP[i][row] ;
          }
       }
    }
    else {
-      for ( int i = 0 ; i <= snData.nDegU ; ++i ) {
+      for ( int i = 0 ; i <= snData.nDegU ; ++i) {
          for (int row = 0 ; row < snData.nCPV ; ++ row) {
             mW[i][row] = snData.mW[i][row] ;
             mBC[i][row] = snData.mCP[i][row] * snData.mW[i][row] ;
@@ -185,25 +185,25 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
       while ( b < nU - 1  &&  abs( snData.vU[b+1] - snData.vU[b]) < EPS_ZERO)
          ++ b ;
       int mult = b - i + 1 ;
-      if ( mult < snData.nDegU ) {
+      if ( mult < snData.nDegU) {
          bRef = true ;
          // calcolo numeratore e alpha
          double numer = snData.vU[b] - snData.vU[a] ;
          for ( int j = snData.nDegU ; j > mult ; -- j)
             vAlpha[j-mult-1] = numer / ( snData.vU[a+j] - snData.vU[a]) ;
          int r = snData.nDegU - mult ;
-         for ( int j = 1 ; j <= snData.nDegU - mult ; ++j ) {
+         for ( int j = 1 ; j <= snData.nDegU - mult ; ++j) {
             int save = r - j ;
             int s = mult + j ;
             if ( ! snData.bRat ) {
-               for ( int k = snData.nDegU ; k >= s ; --k ) {
+               for ( int k = snData.nDegU ; k >= s ; --k) {
                   for ( int row = 0 ; row < snData.nCPV ; ++row) {
                      mBC[k][row] = vAlpha[k-s] * mBC[k][row] + ( 1 -  vAlpha[k-s]) * mBC[k-1][row] ;
                   }
                }
             }
             else {
-               for ( int k = snData.nDegU ; k >= s ; --k ) {
+               for ( int k = snData.nDegU ; k >= s ; --k) {
                   for ( int row = 0 ; row < snData.nCPV ; ++row) {
                      mBC[k][row] = vAlpha[k-s] * mBC[k][row] + ( 1 -  vAlpha[k-s]) * mBC[k-1][row] ;
                      mW[k][row] = vAlpha[k-s] * mW[k][row] + ( 1 - vAlpha[k-s]) * mW[k-1][row] ;
@@ -222,26 +222,26 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
             }
          }
       }
-      mPC_strip.resize( snData.nDegU * ( nb  + 1) + 1 , vCPV) ;
+      mPC_strip.resize( snData.nDegU * ( nb  + 1) + 1, vCPV) ;
       mW_strip.resize( snData.nDegU * ( nb  + 1) + 1, vV_W) ;
       if ( ! snData.bRat)
          for ( int i = 0 ; i <= snData.nDegU ; ++i) {
-            for ( int row = 0 ; row < snData.nCPV ; ++row ) {
+            for ( int row = 0 ; row < snData.nCPV ; ++row) {
                mPC_strip[i+ nb * snData.nDegU][row] = mBC[i][row] ;
             }
          }
       else {
          for ( int i = 0 ; i <= snData.nDegU ; ++i) {
-            for ( int row = 0 ; row < snData.nCPV ; ++row ) {
+            for ( int row = 0 ; row < snData.nCPV ; ++row) {
                mPC_strip[i+ nb * snData.nDegU][row] = mBC[i][row]/mW[i][row] ;
                mW_strip[i+ nb * snData.nDegU][row] = mW[i][row] ;
             }
          }
       }
+     // ho finito di definire la patch di Bezier attuale e passo alla successiva
       ++ nb ;
-      // ho finito di definire la patch di Bezier attuale e passo alla successiva
 
-      // aggiorno mBC con i valori della prossima pezza di Bezier // corrisponde a nb = nb + 1 
+     // aggiorno mBC con i valori della prossima pezza di Bezier // corrisponde a nb = nb + 1 
       if ( ! snData.bRat){
          for (int i = 0 ; i < snData.nDegU - 1 ; ++ i) {
             for ( int row = 0 ; row < snData.nCPV ; ++row) {
@@ -283,7 +283,7 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
       }
    }
 
-   // se non ho raffinato allora tutti i nodi avevano gi? molteplicit? massima. Converto direttamente in Bezier la dir U
+  // se non ho raffinato allora tutti i nodi avevano gi? molteplicit? massima. Converto direttamente in Bezier la dir U
    int nCPU_ref ; // numero dei punti di controllo in U dopo il raffinamento
    if ( ! bRef ) {
       nCPU_ref = snData.nCPU ;
@@ -308,8 +308,8 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
    else
       nCPU_ref = snData.nDegU * nb + 1 ; // numero dei punti di controllo in U dopo il raffinamento
 
-   // ora ho ottenuto le strisce nDegU x nCPV
-   // devo ripetere la procedura, sulla dir V, per ottenere le patch nDegU x nDegV
+  // ora ho ottenuto le strisce nDegU x nCPV
+  // devo ripetere la procedura, sulla dir V, per ottenere le patch nDegU x nDegV
    a = snData.nDegV - 1 ;
    b = snData.nDegV ;
    int nc = 0 ;  // numero di strisce in V ( lunghezza con V costante)
@@ -325,14 +325,14 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
    vector<vector<Point3d>> mPC_tot( nCPU_ref, vDegV) ;
    vector<DBLVECTOR> mW_tot( nCPU_ref, vV1_W) ;
    if ( ! snData.bRat ) {
-      for ( int i = 0 ; i < nCPU_ref ; ++i ) {
+      for ( int i = 0 ; i < nCPU_ref ; ++i) {
          for ( int row = 0 ; row <= snData.nDegV ; ++row ) {
             m_BC1[i][row] = mPC_strip[i][row] ;
          }
       }
    }
    else {
-      for ( int i = 0 ; i < nCPU_ref ; ++i ) {
+      for ( int i = 0 ; i < nCPU_ref ; ++i) {
          for (int row = 0 ; row <= snData.nDegV ; ++ row) {
             mW1[i][row] = mW_strip[i][row] ;
             m_BC1[i][row] = mPC_strip[i][row] * mW_strip[i][row] ;
@@ -348,24 +348,24 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
       int mult = b - i + 1 ;
       if ( mult < snData.nDegV ) {
          bRef = true ;
-         // calcolo numeratore e alpha
+        // calcolo numeratore e alpha
          double numer = snData.vV[b] - snData.vV[a] ;
          for ( int j = snData.nDegV ; j > mult ; -- j)
             vAlpha1[j-mult-1] = numer / ( snData.vV[a+j] - snData.vV[a]) ;
          int r = snData.nDegV - mult ;
-         for ( int j = 1 ; j <= snData.nDegV - mult ; ++j ) {
+         for ( int j = 1 ; j <= snData.nDegV - mult ; ++j) {
             int save = r - j ;
             int s = mult + j ;
             if ( ! snData.bRat) {
                for ( int k = 0 ; k < nCPU_ref ; ++k) {
-                  for ( int row = snData.nDegV ; row >= s ; --row ) {
+                  for ( int row = snData.nDegV ; row >= s ; --row) {
                      m_BC1[k][row] = vAlpha1[row-s] * m_BC1[k][row] + ( 1 -  vAlpha1[row-s]) * m_BC1[k][row-1] ;
                   }
                }
             }
             else {
                for ( int k = 0 ; k < nCPU_ref ; ++k) {
-                  for ( int row = snData.nDegV ; row >= s ; --row ) {
+                  for ( int row = snData.nDegV ; row >= s ; --row) {
                      m_BC1[k][row] = vAlpha1[row-s] * m_BC1[k][row] + ( 1 -  vAlpha1[row-s]) * m_BC1[k][row-1] ;
                      mW1[k][row] = vAlpha1[row-s] * mW1[k][row] + ( 1 -  vAlpha1[row-s]) * mW1[k][row-1] ;
                   }
@@ -388,28 +388,28 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
          }
       }
       int nRef = snData.nDegV * ( nc + 1) + 1 ;
-      for ( int k = 0 ; k < nCPU_ref; ++k){
+      for ( int k = 0 ; k < nCPU_ref; ++k) {
          mPC_tot[k].resize( nRef) ;
          mW_tot[k].resize( nRef) ;
       }
       if ( ! snData.bRat)
          for ( int i = 0 ; i < nCPU_ref ; ++i) {
-            for ( int row = 0 ; row <= snData.nDegV ; ++row ) {
+            for ( int row = 0 ; row <= snData.nDegV ; ++row) {
                mPC_tot[i][row + nc * snData.nDegV] = m_BC1[i][row] ;
             }
          }
       else {
          for ( int i = 0 ; i < nCPU_ref ; ++i) {
-            for ( int row = 0 ; row <= snData.nDegV ; ++row ) {
-               mPC_tot[i][row + nc * snData.nDegV] = m_BC1[i][row]/mW1[i][row] ;
+            for ( int row = 0 ; row <= snData.nDegV ; ++row) {
+               mPC_tot[i][row + nc * snData.nDegV] = m_BC1[i][row] / mW1[i][row] ;
                mW_tot[i][row + nc * snData.nDegV] = mW1[i][row] ;
             }
          }
       }
+     // ho finito di definire la patch di Bezier attuale e passo alla successiva
       ++ nc ;
-      // ho finito di definire la patch di Bezier attuale e passo alla successiva
 
-      // aggiorno mBC con i valori della prossima pezza di Bezier // corrisponde a nc = nc + 1 
+     // aggiorno mBC con i valori della prossima pezza di Bezier // corrisponde a nc = nc + 1 
       if ( ! snData.bRat){
          for (int i = 0 ; i < nCPU_ref ; ++ i) {
             for ( int row = 0 ; row < snData.nDegV - 1 ; ++row) {
@@ -450,7 +450,7 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
          ++b ;
       }
    }
-   // se non ho raffinato allora aggiungo direttamente alle matrici della superficie totale
+  // se non ho raffinato allora aggiungo direttamente alle matrici della superficie totale
    int nCPV_ref ; // numero dei punti di controllo in V dopo il raffinamento
    if ( ! bRef) {
       nCPV_ref = snData.nCPV ;
@@ -477,7 +477,7 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
    else
       nCPV_ref = snData.nDegV * nc + 1 ;
 
-   // finalmente setto la superficie di bezier totale divisa in nb patch in U e nc patch in V
+  // finalmente setto la superficie di bezier totale divisa in nb patch in U e nc patch in V
    PtrOwner<SurfBezier> pSrfBz( CreateBasicSurfBezier()) ;
    if ( IsNull( pSrfBz))
       return nullptr ;
@@ -498,3 +498,178 @@ NurbsToBezierSurface(const SNurbsSurfData& snData)
    }
    return Release( pSrfBz) ;
 }
+
+//----------------------------------------------------------------------------
+bool
+MakeUniform( ISurfFlatRegion*& pSfr, bool& bRescaled, const DBLVECTOR& vU0, const DBLVECTOR& vV0,
+             int nDegU, int nDegV, double dScaleU, double dScaleV, bool bRetry) 
+{
+  // la superficie in input arriva già scalata
+   bool bRescaledU = false ;
+   bool bRescaledV = false ;
+   int nSpanU = 1, nSpanV = 1 ;
+   PtrOwner<ISurfFlatRegion> pRescaledSfr( CreateSurfFlatRegion()) ;
+   for ( int nDir = 0 ; nDir <= 1 ; ++ nDir) {
+     // vettore dei nodi
+      DBLVECTOR vU ;
+      int nExtraKnots = 0 ;
+     // controllo in U
+      if ( nDir == 0) {
+         if ( nDegU > 1) {
+            nExtraKnots = nDegU - 1 ;
+         }
+         for ( int i = nExtraKnots ; i < int( vU0.size()) - nExtraKnots ; ++i ) {
+            double dKnot = vU0[i] * SBZ_TREG_COEFF ;
+            // lo aggiungo solo se è diverso dal precedente
+            if ( i == nExtraKnots  ||  dKnot > vU.back() + EPS_SMALL  ||  dKnot < vU.back() - EPS_SMALL)
+               vU.push_back( dKnot) ;
+         }
+         nSpanU = (int)vU.size() - 1 ;
+      }
+     // controllo in V
+      else if ( nDir == 1 ) {
+         if ( nDegV > 1) {
+            nExtraKnots = nDegV - 1 ;
+         }
+         for ( int i = nExtraKnots ; i < int( vV0.size()) - nExtraKnots ; ++i ) {
+            double dKnot = vV0[i] * SBZ_TREG_COEFF ;
+            // lo aggiungo solo se è diverso dal precedente
+            if ( i == nExtraKnots  ||  dKnot > vU.back() + EPS_SMALL  ||  dKnot < vU.back() - EPS_SMALL)
+               vU.push_back( dKnot) ;
+         }
+         nSpanV = (int)vU.size() - 1 ;
+      }
+
+     // controllo se il vettore dei nodi è uniforme
+      int a = 0, b = 1 ;
+      double d0 = abs( vU[b] - vU[a]), d1 = d0 ;
+      // il vettore è uniforme quando la distanza tra nodi consecutivi è sempre zero o un valore costante
+      while ( b < (int)vU.size()  &&  ( ( d1 < d0 + EPS_SMALL  &&  d1 > d0 - EPS_SMALL)  ||  d1 < EPS_SMALL)) {
+         a = b ;
+         ++b ;
+         if ( b < (int)vU.size())
+            d1 = abs( vU[b] - vU[a]) ;
+      }
+      if ( b != (int)vU.size()) {
+         nDir == 0 ? bRescaledU = true : bRescaledV = true ;
+         pRescaledSfr.Set( CreateSurfFlatRegion()) ;
+         if ( IsNull( pRescaledSfr))
+            return false ;
+         for ( int p = 0 ; p < (int)vU.size() - 1 ; ++p) {
+            PtrOwner<ISurfFlatRegion> pSfr_copy( pSfr->Clone()) ;
+            if ( IsNull( pSfr_copy))
+               return false ;
+            double dLenStrip = abs( vU[p+1] - vU[p]) ;
+            if ( dLenStrip < EPS_SMALL)
+               continue ;
+            // creo la maschera per tagliare la superficie originale e ottenere una striscia
+            PtrOwner<ISurfFlatRegion> pSfrTrim( CreateSurfFlatRegion()) ;
+
+            // ricavo la maschera del trim, con cui poi farò l'intersezione con la sfr iniziale
+            Vector3d vtTrim ;
+            if ( nDir == 0) {
+               pSfrTrim.Set( GetSurfFlatRegionRectangle( dLenStrip, dScaleV + 2)) ;
+               vtTrim.Set( abs(vU[p] - vU.front()), - 1, 0) ;
+            }
+            else{
+               pSfrTrim.Set( GetSurfFlatRegionRectangle( dScaleU + 2, dLenStrip)) ;
+               vtTrim.Set( - 1, abs(vU[p] - vU.front()), 0) ;
+            }
+            pSfrTrim->Translate( vtTrim) ;
+
+            if ( ! pSfr_copy->Intersect( *pSfrTrim))
+               return false ;
+
+            // aggiungo la nuova striscia solo se è valida
+            if ( pSfr_copy->IsValid() ) {
+               if ( nDir == 0)
+                  pSfr_copy->Scale( GLOB_FRM, SBZ_TREG_COEFF / dLenStrip, 1, 1) ;
+               else
+                  pSfr_copy->Scale( GLOB_FRM, 1, SBZ_TREG_COEFF / dLenStrip, 1) ;
+
+               // prima di riunire la striscia al resto devo traslarla sul bordo destro della superificie che sto ricostruendo
+
+               Point3d pt ;
+               nDir == 0 ? pt.Set( abs(vU[p] - vU.front()), 0, 0) : pt.Set( 0,abs(vU[p] - vU.front()), 0) ;
+               if ( nDir == 0)
+                  pt.Scale( GLOB_FRM, SBZ_TREG_COEFF / dLenStrip, 1, 1) ;
+               else
+                  pt.Scale( GLOB_FRM, 1, SBZ_TREG_COEFF / dLenStrip, 1) ;
+
+               Vector3d vtJoin ;
+               if ( nDir == 0)
+                  vtJoin.Set( p * SBZ_TREG_COEFF - pt.x, 0, 0) ;
+               else
+                  vtJoin.Set( 0, p  * SBZ_TREG_COEFF - pt.y, 0) ;
+               pSfr_copy->Translate( vtJoin) ;
+               // se sto ritentando MakeUniform, allora faccio anche OFFSET e controOFFSET
+               if ( bRetry)
+                  pSfr_copy->Offset( 10 * EPS_SMALL, ICurve::OFF_FILLET) ; // OFFSET
+               if ( pRescaledSfr->IsValid()) {
+                  if ( ! pRescaledSfr->Add( *pSfr_copy))
+                     return false ;
+               }
+               else
+                  pRescaledSfr.Set( pSfr_copy) ;
+            }
+         }
+         if ( nDir == 0) {
+            dScaleU = ((int)vU.size() - 1) * SBZ_TREG_COEFF ;
+            if ( pRescaledSfr->IsValid()) {
+               if ( bRetry)
+                  pRescaledSfr->Offset( -10 * EPS_SMALL, ICurve::OFF_FILLET) ;  //contro OFFSET
+               pSfr = Release( pRescaledSfr) ;
+            }
+         }
+         else
+            dScaleV = ((int)vU.size() - 1) * SBZ_TREG_COEFF ;
+      }
+   }
+
+   if ( ! IsNull( pRescaledSfr)  &&  pRescaledSfr->IsValid()) {
+      if ( bRetry)
+         pRescaledSfr->Offset( -10 * EPS_SMALL, ICurve::OFF_FILLET) ;  // contro OFFSET
+      pSfr = Release( pRescaledSfr) ;
+   }
+
+   if ( ! bRescaledU  &&  ! bRescaledV)
+      pSfr->Scale( GLOB_FRM, nSpanU / dScaleU * SBZ_TREG_COEFF, nSpanV / dScaleV * SBZ_TREG_COEFF, 1) ;
+   else if ( bRescaledU  &&  ! bRescaledV)
+      pSfr->Scale( GLOB_FRM, 1, nSpanV / dScaleV * SBZ_TREG_COEFF, 1) ;
+   else if ( ! bRescaledU  &&  bRescaledV)
+      pSfr->Scale( GLOB_FRM, nSpanU / dScaleU * SBZ_TREG_COEFF, 1, 1) ;
+
+   bRescaled = ( bRescaledU || bRescaledV) ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OnWhichEdge( double u0, double u1, double v0, double v1, const Point3d& ptToAssign, int& nEdge)
+{
+   Point3d ptTR( u1, v1) ;
+   Point3d ptTl( u0, v1) ;
+   Point3d ptBL( u0, v0) ;
+   Point3d ptBr( u1, v0) ;
+
+   double dEps = 0.1 ;
+   if ( AreSamePointEpsilon( ptToAssign, ptTR, dEps))
+      nEdge = 7 ;
+   else if ( AreSamePointEpsilon( ptToAssign, ptTl, dEps))
+      nEdge = 4 ;
+   else if ( AreSamePointEpsilon( ptToAssign, ptBL, dEps))
+      nEdge = 5 ;
+   else if ( AreSamePointEpsilon( ptToAssign, ptBr, dEps))
+      nEdge = 6 ;
+   else if ( ptToAssign.x > ptBL.x - dEps  &&  ptToAssign.x < ptTR.x + dEps  &&  abs( ptToAssign.y - ptTR.y) < dEps)
+      nEdge = 0 ;
+   else if ( ptToAssign.y > ptBL.y - dEps  &&  ptToAssign.y < ptTR.y + dEps  &&  abs( ptToAssign.x - ptBL.x) < dEps)
+      nEdge = 1 ;
+   else if ( ptToAssign.x > ptBL.x - dEps  &&  ptToAssign.x < ptTR.x + dEps  &&  abs( ptToAssign.y - ptBL.y) < dEps)
+      nEdge = 2 ;
+   else if ( ptToAssign.y > ptBL.y - dEps  &&  ptToAssign.y < ptTR.y + dEps  &&  abs( ptToAssign.x - ptTR.x) < dEps)
+      nEdge = 3 ;
+   else
+      return false ;
+   return true ;
+}

SurfBezier.h

@@ -22,6 +22,8 @@
 #include "/EgtDev/Include/EGkSurfBezier.h"
 #include "/EgtDev/Include/EGkGeoCollection.h"
 
+using namespace std ;
+class Tree ;
 
 //----------------------------------------------------------------------------
 class SurfBezier : public ISurfBezier, public IGeoObjRW
@@ -87,7 +89,7 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool SetControlPoint( int nIndU, int nIndV, const Point3d& ptCtrl, double dW) override
                { return SetControlPoint( GetInd( nIndU, nIndV), ptCtrl, dW) ; }
       bool SetControlPoint( int nInd, const Point3d& ptCtrl, double dW) override ;
-      bool SetTrimRegion( const ISurfFlatRegion& sfrTrimReg) override ;
+      bool SetTrimRegion( ISurfFlatRegion& sfrTrimReg, bool bIntersectOrSubtract = true) override ;
       SurfFlatRegion* GetTrimRegion( void) const override ;
       bool GetInfo( int& nDegU, int& nDegV, int& nSpanU, int& nSpanV, bool& bIsRat, bool& bTrimmed) const override ;
       const Point3d& GetControlPoint( int nIndU, int nIndV, bool* pbOk) const override
@@ -111,12 +113,39 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool GetControlCurveOnU( int nIndV, PolyLine& plCtrlU) const override ;
       bool GetControlCurveOnV( int nIndU, PolyLine& plCtrlV) const override ;
       const SurfTriMesh* GetAuxSurf( void) const override ;
+      SurfTriMesh* GetApproxSurf( double dTol, double dSideMin = 100 * EPS_SMALL) const override ;
+      // funzione per ottenere la suddivisione dello spazio parametrico nelle celle utilizzate per la triangolazione.
       bool GetLeaves( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves) const override ;
+      bool GetTriangles2D( std::vector<std::tuple<int,Point3d, Point3d, Point3d>>& vTria2D) const override ;
+      // funzioni che servono per ricavare l'immagine nel parametrico di un punto appartenente alla trimesh ausiliaria della superficie di Bezier
+      // a nIL si può passare 5 come valore di default
+      bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL = 5) const override ;
+      bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL, const Point3d& ptIPrev, bool* bTroughEdge = nullptr) const override ;
+      // restituisce il corrispettivo parametrico di un punto qualunque della trimesh associata alla superficie
+      // ptIPrev è un punto addizionale che precede o segue il punto pt3D nel caso in cui il punto faccia parte di una curva 3d sulla superficie
+      // pPlCut è il piano di taglio su cui dovrebbe giacere il punto raffinato
+      bool UnprojectPoint( const Point3d& pt3D, Point3d& ptParam, const Point3d& ptIPrev, bool* bTroughEdge = nullptr, const Plane3d* plCut = nullptr) const override ;
+      // pPlCut è il piano di taglio su cui giace la curva
+      bool UnprojectCurveFromStm( const ICurveComposite* pCC, ICRVCOMPOPVECTOR& vpCC, const Plane3d* pPlCut) const override ;
+      // funzione per tagliare una superficie di bezier con un piano ( cancello la parte dal lato positivo della normale del piano).
+      // bSaveOnEq indica se tenere i triangoli (della trimesh associata) che sono sul piano
+      bool Cut( const Plane3d& plPlane, bool bSaveOnEq = false) override ;
+      // funzione che calcola se gli edge sono collassati in poli. DEVE ESSERE STATA CHIAMATA PRIMA DI UN CUT
+      bool CalcPoles( void) override ;
+      // funzioni per incrementare le coordinate restando dentro lo spazio parametrico
+      bool IncreaseUV( double& dU, double dx, bool bUOrV, double* dUVCopy = nullptr, bool bModifyOrig = true) const override ;
+      bool IncreaseUV( Point3d& ptUV, Vector3d vtH , Point3d* ptUVCopy, bool bModifyOrig) const override ;
+      // funzione che restituisce gli edge della superficie o in forma di linea spezzata o in forma di curva di Bezier
+      // se la superficie è trimmata restituisce i loop dello spazio parametrico in forma di linee spezzate
+      bool GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge = -1) const override ;
 
    public :                      // IGeoObjRW
       int  GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
+      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
+      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
+      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       SurfBezier( void) ;
@@ -159,6 +188,11 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool GetCurveOnV( double dU, int nStep, PolyLine& plCrvV) const ;
       double GetCurveOnUApproxLen( double dV) const ;
       double GetCurveOnVApproxLen( double dU) const ;
+      // funzione che proietta nello spazio parametrico un trim derivante da un taglio con un piano, categorizzandolo come aperto o chiuso ( nel parametrico)
+      bool AddCurveCompoToCuts( ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVECTOR& vpCCClosed, double dToler = EPS_SMALL, const Plane3d* pPlCut = nullptr) const ;
+      // restituisce il singolo edge della superficie non trimmata
+      ICurveComposite* GetSingleEdge3D( bool bLineOrBezier, int nEdge) const ;
+      bool UpdateEdgesFromTree( Tree& tr) const ;
 
    private :
       ObjGraphicsMgr  m_OGrMgr ;        // gestore grafica dell'oggetto
@@ -170,11 +204,16 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       int             m_nSpanV ;        // numero di pezze in V
       bool            m_bRat ;          // flag di razionale/polinomiale
       bool            m_bTrimmed ;      // flag per presenza regione di trim
+      mutable bool    m_bClosedU ;      // flag che indica se la superficie è chiusa lungo il parametro U
+      mutable bool    m_bClosedV ;      // flag che indica se la superficie è chiusa lungo il parametro V
+      mutable BOOLVECTOR m_vbPole ;  // vettore di flag che indicano se i lati sono collassati in dei poli
       PNTVECTOR       m_vPtCtrl ;       // vettore dei punti di controllo
       DBLVECTOR       m_vWeCtrl ;       // vettore dei pesi di controllo
       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 ICRVCOMPOPOVECTOR m_vCCLoop ; // vettore dei loop della superficie trimmata
 } ;
 
 //-----------------------------------------------------------------------------

SurfFlatRegion.cpp

@@ -75,7 +75,7 @@ SurfFlatRegion::Clear( void)
 bool
 SurfFlatRegion::AddExtLoop( const ICurve& cCrv)
 {
-  // verifico validità curva
+  // verifico validità curva
    if ( &cCrv == nullptr)
       return false ;
   // creo una copia della curva
@@ -146,7 +146,7 @@ SurfFlatRegion::AddSimpleExtLoop( ICurve* pCrv)
    else {
      // verifico che il piano della curva coincida con quello XY intrinseco
       plPlane.ToLoc( m_frF) ;
-      if ( ! plPlane.GetVersN().IsZ()  ||  abs( plPlane.GetDist()) > EPS_SMALL)
+      if ( ! plPlane.GetVersN().IsZEpsilon( 2 * EPS_ZERO)  ||  abs( plPlane.GetDist()) > EPS_SMALL)
          return false ;
      // sistemo il senso di rotazione (deve essere CCW -> area > 0)
       if ( ( plPlane.GetVersN().z > 0  &&  dArea < 0)  ||
@@ -221,7 +221,7 @@ SurfFlatRegion::MyAddExtLoop( ICurve* pCrv)
 bool
 SurfFlatRegion::AddIntLoop( const ICurve& cCrv)
 {
-  // verifico validità curva
+  // verifico validità curva
    if ( &cCrv == nullptr)
       return false ;
   // creo una copia della curva
@@ -288,7 +288,7 @@ SurfFlatRegion::AddSimpleIntLoop( ICurve* pCrv)
    Plane3d plPlane ;
    if ( ! pMyCrv->GetArea( plPlane, dArea))
       return false ;
-   if ( ! plPlane.GetVersN().IsZ()  ||  abs( plPlane.GetDist()) > EPS_SMALL)
+   if ( ! plPlane.GetVersN().IsZEpsilon( 2 * EPS_ZERO)  ||  abs( plPlane.GetDist()) > EPS_SMALL)
       return false ;
   // sistemo il senso di rotazione (deve essere CW -> se N==Z+ area < 0, se N==Z- area > 0)
    if ( ( plPlane.GetVersN().z > 0  &&  dArea > 0)  ||  ( plPlane.GetVersN().z < 0  &&  dArea < 0))
@@ -435,7 +435,7 @@ SurfFlatRegion::GetTitle( void) const
 bool
 SurfFlatRegion::Dump( string& sOut, bool bMM, const char* szNewLine) const
 {
-  // verifico validità regione
+  // verifico validità regione
    if ( m_nStatus != OK)
       sOut += string( "Status=Invalid") + szNewLine ;
   // area
@@ -583,7 +583,7 @@ SurfFlatRegion::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
       return false ;
   // reset del bbox
    b3Loc.Reset() ;
-  // è il bounding box dei loop esterni
+  // è il bounding box dei loop esterni
    for ( auto i : m_vExtInd) {
       BBox3d b3Tmp ;
       if ( m_vpLoop[i]->GetBBox( m_frF, b3Tmp, nFlag))
@@ -603,7 +603,7 @@ SurfFlatRegion::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
    Frame3d frCompo = m_frF * frRef ;
   // reset del bbox
    b3Ref.Reset() ;
-  // è il bounding box dei loop esterni
+  // è il bounding box dei loop esterni
    for ( auto i : m_vExtInd) {
       BBox3d b3Tmp ;
       if ( m_vpLoop[i]->GetBBox( frCompo, b3Tmp, nFlag))
@@ -622,8 +622,9 @@ SurfFlatRegion::Translate( const Vector3d& vtMove)
   // imposto ricalcolo della grafica
    ResetAuxSurf() ;
    m_OGrMgr.Reset() ;
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+  // traslo Voronoi
+   if ( m_pVoronoiObj != nullptr) 
+      m_pVoronoiObj->Translate( vtMove) ;
   // traslo il riferimento
    m_frF.Translate( vtMove) ;
    return true ;
@@ -636,15 +637,16 @@ SurfFlatRegion::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAn
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dell'asse di rotazione
+  // verifico validità dell'asse di rotazione
    if ( vtAx.IsSmall())
       return false ;
 
   // imposto ricalcolo della grafica
    ResetAuxSurf() ;
    m_OGrMgr.Reset() ;
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+  // ruoto Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
 
   // ruoto il riferimento
    return m_frF.Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
@@ -673,7 +675,7 @@ SurfFlatRegion::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, dou
          return false ;
    }
 
-  // parziale scalatura del riferimento (non può essere completa)
+  // parziale scalatura del riferimento (non può essere completa)
    Frame3d frTrasf = m_frF ;
    m_frF.PseudoScale( frRef, dCoeffX, dCoeffY, dCoeffZ) ;
 
@@ -712,7 +714,7 @@ SurfFlatRegion::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
   // verifico lo stato
    if ( m_nStatus != OK  ||  m_vpLoop.empty())
       return false ;
-  // verifico validità del piano di specchiatura
+  // verifico validità del piano di specchiatura
    if ( vtNorm.IsSmall())
       return false ;
 
@@ -722,7 +724,7 @@ SurfFlatRegion::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
   // imposto ricalcolo Voronoi
    ResetVoronoiObject() ;
 
-  // parziale mirror del riferimento (non può essere completa)
+  // parziale mirror del riferimento (non può essere completa)
    Frame3d frTrasf = m_frF ;
    m_frF.PseudoMirror( ptOn, vtNorm) ;
 
@@ -762,7 +764,7 @@ SurfFlatRegion::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector
   // verifico lo stato
    if ( m_nStatus != OK  ||  m_vpLoop.empty())
       return false ;
-  // verifico validità dei parametri
+  // verifico validità dei parametri
    if ( vtNorm.IsSmall()  ||  vtDir.IsSmall())
       return false ;
 
@@ -778,7 +780,7 @@ SurfFlatRegion::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector
          return false ;
    }
 
-  // parziale scorrimento del riferimento (non può essere completa)
+  // parziale scorrimento del riferimento (non può essere completa)
    Frame3d frTrasf = m_frF ;
    m_frF.PseudoShear( ptOn, vtNorm, vtDir, dCoeff) ;
 
@@ -832,19 +834,21 @@ SurfFlatRegion::ToGlob( const Frame3d& frRef)
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
+  // se frame identità, non devo fare alcunché
    if ( IsGlobFrame( frRef))
       return true ;
 
   // imposto ricalcolo della grafica
    ResetAuxSurf() ;
    m_OGrMgr.Reset() ;
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->ToGlob( frRef) ;
 
   // trasformo il riferimento
    return m_frF.ToGlob( frRef) ; ;
@@ -857,19 +861,21 @@ SurfFlatRegion::ToLoc( const Frame3d& frRef)
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
+  // se frame identità, non devo fare alcunché
    if ( IsGlobFrame( frRef))
       return true ;
 
   // imposto ricalcolo della grafica
    ResetAuxSurf() ;
    m_OGrMgr.Reset() ;
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->ToLoc( frRef) ;
 
   // trasformo il riferimento
    return m_frF.ToLoc( frRef) ; ;
@@ -882,19 +888,21 @@ SurfFlatRegion::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dei frame
+  // verifico validità dei frame
    if ( frOri.GetType() == Frame3d::ERR  ||  frDest.GetType() == Frame3d::ERR)
       return false ;
 
-  // se i due riferimenti coincidono, non devo fare alcunché
+  // se i due riferimenti coincidono, non devo fare alcunché
    if ( AreSameFrame( frOri, frDest))
       return true ;
 
   // imposto ricalcolo della grafica
    ResetAuxSurf() ;
    m_OGrMgr.Reset() ;
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
+
+  // trasformo Voronoi
+   if ( m_pVoronoiObj != nullptr)
+      m_pVoronoiObj->LocToLoc( frOri, frDest) ;
 
   // trasformo il riferimento
    return m_frF.LocToLoc( frOri, frDest) ; ;
@@ -978,7 +986,7 @@ SurfFlatRegion::GetCentroid( Point3d& ptCen) const
       return false ;
   // medio il centro
    ptCen /= dArea ;
-  // lo porto dal riferimento intrinseco a quello in cui è immersa l'entità
+  // lo porto dal riferimento intrinseco a quello in cui è immersa l'entità
    ptCen.ToGlob( m_frF) ;
    return true ;
 }
@@ -997,7 +1005,7 @@ SurfFlatRegion::GetChunkCentroid( int nChunk, Point3d& ptCen) const
    const ICurve* pCrv = GetMyLoop( nChunk, 0) ;
    if ( pCrv == nullptr  ||  ! pCrv->GetCentroid( ptCen))
       return false ;
-  // lo porto dal riferimento intrinseco a quello in cui è immersa l'entità
+  // lo porto dal riferimento intrinseco a quello in cui è immersa l'entità
    ptCen.ToGlob( m_frF) ;
    return true ;
 }
@@ -1023,7 +1031,7 @@ SurfFlatRegion::GetLoopCount( int nChunk) const
    int nChunkMax = int( m_vExtInd.size()) - 1 ;
    if ( nChunk < 0  ||  nChunk > nChunkMax)
       return 0 ;
-  // se non è l'ultimo Chunk
+  // se non è l'ultimo Chunk
    if ( nChunk < nChunkMax)
       return ( m_vExtInd[nChunk+1] - m_vExtInd[nChunk]) ;
   // altrimenti
@@ -1053,7 +1061,7 @@ SurfFlatRegion::GetChunkLoopFromInd( int nInd, int& nChunk, int& nLoop) const
   // valori non validi
    nChunk = - 1 ;
    nLoop = - 1 ;
-  // verifico validità di nInd
+  // verifico validità di nInd
    if ( nInd < 0  ||  nInd >= int( m_vpLoop.size()))
       return false ;
   // verifica esistenza array di chunks
@@ -1105,7 +1113,7 @@ SurfFlatRegion::GetLoop( int nChunk, int nLoop) const
       return nullptr ;
   // assegno la normale alla regione come estrusione
    pCrv->SetExtrusion( Z_AX) ;
-  // la porto nel riferimento in cui è inserito l'oggetto
+  // la porto nel riferimento in cui è inserito l'oggetto
    pCrv->ToGlob( m_frF) ;
    return pCrv ;
 }
@@ -1121,7 +1129,7 @@ SurfFlatRegion::ApproxLoopWithLines( int nChunk, int nLoop, double dLinTol, doub
   // ne creo una approssimazione
    if ( ! pMyCrv->ApproxWithLines( dLinTol, dAngTolDeg, nType, PL))
       return false ;
-  // la porto nel riferimento in cui è inserito l'oggetto
+  // la porto nel riferimento in cui è inserito l'oggetto
    PL.ToGlob( m_frF) ;
    return true ;
 }
@@ -1174,7 +1182,7 @@ SurfFlatRegion::GetAuxSurf( void) const
   // la superficie deve essere validata
    if ( m_nStatus != OK  ||  m_vpLoop.empty())
       return nullptr ;
-  // se già calcolata, la restituisco
+  // se già calcolata, la restituisco
    if ( m_pSTM != nullptr)
       return m_pSTM ;
   // la creo e la salvo
@@ -1222,7 +1230,7 @@ SurfFlatRegion::CloneChunk( int nChunk) const
 bool
 SurfFlatRegion::MyGetCurveClassification( const ICurve& Crv, double dLenMin, CRVCVECTOR& ccClass) const
 {
-  // la curva deve già essere nel riferimento intrinseco della regione
+  // la curva deve già essere nel riferimento intrinseco della regione
   // verifico lo stato
    if ( m_nStatus != OK  ||  m_vpLoop.empty())
       return false ;
@@ -1254,7 +1262,7 @@ SurfFlatRegion::MyGetCurveClassification( const ICurve& Crv, double dLenMin, CRV
          for ( auto& ccOne : ccPart) {
             switch ( ccOne.nClass) {
             case CRVC_IN :
-               // IN è Remove degli altri
+               // IN è Remove degli altri
                break ;
             case CRVC_OUT :
               // intervallo standard
@@ -1383,7 +1391,7 @@ SurfFlatRegion::GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion&
    if ( ! AreSameVectorApprox( m_frF.VersZ(), Reg2.m_frF.VersZ()))
       return REGC_NULL ;
 
-  // curva esterna del chunk della prima regione (ovviamente già in locale al riferimento intrinseco)
+  // curva esterna del chunk della prima regione (ovviamente già in locale al riferimento intrinseco)
    const ICurve* pCrv1Loc = GetMyLoop( nChunk, 0) ;
 
   // curva esterna del chunk della seconda regione in locale nel riferimento intrinseco della prima
@@ -1453,7 +1461,7 @@ SurfFlatRegion::ResetVoronoiObject() const
 bool 
 SurfFlatRegion::CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound) const
 {
-  // verifico se è stato calcolato 
+  // verifico se è stato calcolato 
    if ( m_pVoronoiObj == nullptr)
       if ( ! CalcVoronoiObject())
          return false ;
@@ -1465,7 +1473,7 @@ SurfFlatRegion::CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound) const
 bool 
 SurfFlatRegion::CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide) const
 {
-  // verifico se è stato calcolato 
+  // verifico se è stato calcolato 
    if ( m_pVoronoiObj == nullptr)
       if ( ! CalcVoronoiObject())
          return false ;

SurfFlatRegion.h

@@ -96,7 +96,7 @@ class SurfFlatRegion : public ISurfFlatRegion, public IGeoObjRW
               { return m_frF.VersZ() ; }
       int  GetChunkCount( void) const override ;
       int  GetLoopCount( int nChunk) const override ;
-      ICurve* GetLoop( int nChunk, int nLoop) const override ;   // nChunk 0-based, nLoop 0-based (1°esterno, successivi interni) 
+      ICurve* GetLoop( int nChunk, int nLoop) const override ;   // nChunk 0-based, nLoop 0-based (1°esterno, successivi interni) 
       bool ApproxLoopWithLines( int nChunk, int nLoop, double dLinTol, double dAngTolDeg, int nType, PolyLine& PL) const override ;
       const SurfTriMesh* GetAuxSurf( void) const override ;
       SurfFlatRegion* CloneChunk( int nChunk) const override ;
@@ -104,12 +104,16 @@ class SurfFlatRegion : public ISurfFlatRegion, public IGeoObjRW
       bool GetCurveClassification( const ICurve& Crv, double dLenMin, CRVCVECTOR& ccClass) const override ;
       int  GetChunkSimpleClassification( int nChunk, const ISurfFlatRegion& Other, int nOthChunk) const override ;   // compare only outsides
       bool CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound = 3) const override ;
-      bool CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide) const override ;      
+      bool CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide) const override ;
+      void ResetVoronoiObject( void) const override ;
 
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
+      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
+      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
+      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       SurfFlatRegion( void) ;
@@ -139,7 +143,7 @@ class SurfFlatRegion : public ISurfFlatRegion, public IGeoObjRW
       int  GetIndFromChunkLoop( int nChunk, int nLoop) const ;
       bool GetChunkLoopFromInd( int nInd, int& nChunk, int& nLoop) const ;
       ICurve* GetMyLoop( int nInd) const ;               // indice nel vettore di tutti i loop
-      ICurve* GetMyLoop( int nChunk, int nLoop) const ;  // nChunk 0-based, nLoop 0-based (1°esterno, successivi interni) 
+      ICurve* GetMyLoop( int nChunk, int nLoop) const ;  // nChunk 0-based, nLoop 0-based (1°esterno, successivi interni) 
       void ResetAuxSurf( void) const ;
       bool ConvertArcsToBezierCurves( void) ;
       bool MyGetCurveClassification( const ICurve& Crv, double dLenMin, CRVCVECTOR& ccClass) const ;
@@ -149,7 +153,6 @@ class SurfFlatRegion : public ISurfFlatRegion, public IGeoObjRW
       static SurfFlatRegion* MyNewSurfFromLoops( PCRV_DEQUE& vpLoop) ;
       static bool MyTestAndDelete( PCRV_DEQUE& vpCrv) ;    
       bool CalcVoronoiObject( void) const ;
-      void ResetVoronoiObject( void) const ;
 
    private :
       ObjGraphicsMgr m_OGrMgr ;        // gestore grafica dell'oggetto
@@ -158,7 +161,7 @@ class SurfFlatRegion : public ISurfFlatRegion, public IGeoObjRW
       Frame3d        m_frF ;           // riferimento intrinseco
       PCRV_DEQUE     m_vpLoop ;        // deque delle curve che formano i loop
       INTVECTOR      m_vExtInd ;       // indice dei loop esterni nel precedente vettore
-      int            m_nTempProp[2] ;  // vettore proprietà temporanee
+      int            m_nTempProp[2] ;  // vettore proprietà temporanee
       double         m_dTempParam[2] ; // vettore parametri temporanei
       mutable Voronoi* m_pVoronoiObj ; // Voronoi
 

SurfFlatRegionOffset.cpp

@@ -16,6 +16,7 @@
 #include "GeoConst.h"
 #include "CurveComposite.h"
 #include "SurfFlatRegion.h"
+#include "AdjustLoops.h"
 #include "Voronoi.h"
 #include "/EgtDev/Include/EGkOffsetCurve.h"
 #include "/EgtDev/Include/EGkSfrCreate.h"
@@ -36,7 +37,7 @@ SurfFlatRegion::CreateOffsetSurf( double dDist, int nType) const
    if ( nChunk == 0)
       return nullptr ;
 
-  // se offset nullo, la nuova regione è la copia di quella attuale
+  // se offset nullo, la nuova regione è la copia di quella attuale
    if ( abs( dDist) < 10 * EPS_SMALL)
       return this->Clone() ;
 
@@ -70,7 +71,7 @@ SurfFlatRegion::CreateOffsetSurf( double dDist, int nType) const
             while ( bOk  &&  ! IsNull( pOffs)) {
                if ( pOffs->GetType() == CRV_COMPO) {
                   CurveComposite* pOffsCompo = GetBasicCurveComposite( pOffs) ;
-                 // assegno proprietà
+                 // assegno proprietà
                   pOffsCompo->SetTempProp( j, 1) ;
                   for ( int k = 0 ; k < pOffsCompo->GetCurveCount() ; ++k)
                      pOffsCompo->SetCurveTempProp( k, j, 1) ;
@@ -80,7 +81,7 @@ SurfFlatRegion::CreateOffsetSurf( double dDist, int nType) const
                }
                else
                   pOffs->SetTempProp( j, 1) ;
-              // se prima curva esterna, è il primo contorno esterno della nuova regione
+              // se prima curva esterna, è il primo contorno esterno della nuova regione
                if ( j == 0  &&  bFirstCurve) {
                   if ( ! pSfrChk->AddExtLoop( Release( pOffs)))
                      return nullptr ;
@@ -137,7 +138,7 @@ SurfFlatRegion::CreateOffsetSurf( double dDist, int nType) const
 
   // -------------------- OFFSET CON VORONOI -------------------------------------
    else {
-     // verifico se oggetto Voronoi della superficie è definito
+     // verifico se oggetto Voronoi della superficie è definito
       if ( m_pVoronoiObj == nullptr)
          CalcVoronoiObject() ;
 
@@ -146,51 +147,28 @@ SurfFlatRegion::CreateOffsetSurf( double dDist, int nType) const
       if ( ! m_pVoronoiObj->CalcOffset( vOffs, dDist, nType))
          return nullptr ;
 
+     // costruisco la superficie
       if ( vOffs.size() > 0) {
-         BOOLVECTOR vbAddOrSub( vOffs.size(), true) ;
-         int nFirstId = -1 ;
-         for ( int i = 0 ; i < ( int)vOffs.size() ; i ++) {
-           // porto nel frame della flat region
+         PCRV_DEQUE vLoops ;
+         for ( int i = 0 ; i < int( vOffs.size()) ; i ++) {
             vOffs[i]->ToLoc( m_frF) ;
-           // calcolo orientamento della curva
-            double dAreaXY ;
-            if ( ! vOffs[i]->GetAreaXY( dAreaXY))
-               return nullptr ;
-            vbAddOrSub[i] = ( dAreaXY > SQ_EPS_SMALL) ;
-           // verifico se è il primo loop esterno
-            if ( nFirstId == -1  &&  vbAddOrSub[i])
-               nFirstId = i ;
-         }
-
-        // inizializzo la superficie
-         if ( nFirstId != -1  &&  ! pSfr->AddExtLoop( Release( vOffs[nFirstId])))
-            return nullptr ;
-         if ( pSfr->IsValid()) {
-
-            for ( int i = 0 ; i < ( int)vOffs.size() ; i ++) {
-              // verifico non sia il primo loop esterno
-               if ( i == nFirstId)
-                  continue ;
-              // costruisco la superficie associata
-               PtrOwner<SurfFlatRegion> pSrfCrv( CreateBasicSurfFlatRegion()) ;
-               if ( IsNull( pSrfCrv)  ||  ! pSrfCrv->AddExtLoop( Release( vOffs[i])))
-                  return nullptr ;
-               if ( ! pSrfCrv->IsValid())
-                  continue ;
-
-              // aggiungo o sottraggo
-               if ( vbAddOrSub[i]) {
-                  if ( ! pSfr->Add( *pSrfCrv))
-                     return nullptr ;
-               }
-               else {
-                  pSrfCrv->Invert() ;
-                  if ( ! pSfr->Subtract( *pSrfCrv))
-                     return nullptr ;
-               }
+           // rimuovo eventuali sovrapposizioni
+            ICURVEPLIST CrvLst ;
+            AdjustLoops( Release( vOffs[i]), CrvLst, true) ;
+            for ( auto pCrv : CrvLst) {
+               pCrv->SetExtrusion( Z_AX) ;
+               vLoops.emplace_back( pCrv) ;
             }
-
          }
+
+        // verifico di avere ancora dei loops
+         if ( vLoops.size() > 0) {
+            pSfr.Set( MyNewSurfFromLoops( vLoops)) ;
+            if ( IsNull( pSfr)) {
+               MyTestAndDelete( vLoops) ;
+               return nullptr ; 
+            }        
+         }                     
       }
    }
 
@@ -207,7 +185,7 @@ SurfFlatRegion::Offset( double dDist, int nType)
    if ( nChunk == 0)
       return false ;
 
-  // se offset nullo, non devo fare alcunchè
+  // se offset nullo, non devo fare alcunchè
    if ( abs( dDist) < 10 * EPS_SMALL)
       return true ;
   

SurfTriMesh.cpp

@@ -16,6 +16,7 @@
 #include "stdafx.h"
 #include "SurfTriMesh.h"
 #include "GeoObjFactory.h"
+#include "GdbGeo.h"
 #include "NgeWriter.h"
 #include "NgeReader.h"
 #include "SurfFlatRegion.h"
@@ -41,8 +42,9 @@ GEOOBJ_REGISTER( SRF_TRIMESH, NGE_S_TRM, SurfTriMesh) ;
 //----------------------------------------------------------------------------
 SurfTriMesh::SurfTriMesh( void)
    : m_nStatus( TO_VERIFY), m_dLinTol( STM_STD_LIN_TOL), m_dBoundaryAng( STM_STD_BOUNDARY_ANG),
-     m_dSmoothAng( STM_STD_SMOOTH_ANG), m_bOriented( false), m_bClosed( false), m_bFaceted( false), m_bFacEdged( false),
-     m_nTimeStamp( 0), m_nTempProp{0,0}, m_dTempParam{0.0,0.0}, m_nMaxTFlag( 0), m_nParts( -1), m_pHGrd3d( nullptr)
+     m_dSmoothAng( STM_STD_SMOOTH_ANG), m_bShowEdges( false), m_bOriented( false), m_bClosed( false),
+     m_bFaceted( false), m_bFacEdged( false), m_nTimeStamp( 0), m_nTempProp{0,0}, m_dTempParam{0,0},
+     m_nMaxTFlag( 0), m_nParts( -1), m_pHGrd3d( nullptr)
 {
    m_dCosBndAng = cos( m_dBoundaryAng * DEGTORAD) ;
    m_dCosSmAng = cos( m_dSmoothAng * DEGTORAD) ;
@@ -59,7 +61,7 @@ bool
 SurfTriMesh::Init( int nNumVert, int nNumTria, int nNumFacet)
 {
   // imposto ricalcolo della grafica e di hashgrids3d
-   m_OGrMgr.Reset() ;
+   m_OGrMgr.Clear() ;
    ResetHashGrids3d() ;
   // se superficie vuota
    if ( nNumVert == 0  &&  nNumTria == 0  &&  nNumFacet == 0)
@@ -91,6 +93,12 @@ bool
 SurfTriMesh::Clear( void)
 {
    m_nStatus = OK ;
+   m_dLinTol = STM_STD_LIN_TOL ;
+   m_dBoundaryAng = STM_STD_BOUNDARY_ANG ;
+   m_dCosBndAng = cos( m_dBoundaryAng * DEGTORAD) ;
+   m_dSmoothAng = STM_STD_SMOOTH_ANG ;
+   m_dCosSmAng = cos( m_dSmoothAng * DEGTORAD) ;
+   m_bShowEdges = false ;
    m_bOriented = false ;
    m_bClosed = false ;
    m_bFaceted = false ;
@@ -98,7 +106,13 @@ SurfTriMesh::Clear( void)
    m_vVert.clear() ;
    m_vTria.clear() ;
    m_vFacet.clear() ;
+   m_OGrMgr.Clear() ;
    ResetHashGrids3d() ;
+   m_nTimeStamp =  0 ;
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
+   m_dTempParam[0] = 0 ;
+   m_dTempParam[1] = 0 ;
    m_nMaxTFlag = 0 ;
    m_nParts = -1 ;
    return true ;
@@ -875,7 +889,7 @@ SurfTriMesh::GetTriangleSmoothNormal( int nT, int nV, Vector3d& vtN) const
 SurfTriMesh*
 SurfTriMesh::CloneTriangle( int nT) const
 {
-  // verifico validit� superficie ed esistenza del triangolo 
+  // verifico validità superficie ed esistenza del triangolo 
    if ( ! IsValid()  ||  nT < 0  ||  nT >= GetTriangleSize()  ||  m_vTria[nT].nIdVert[0] == SVT_DEL)
       return nullptr ;
 
@@ -982,7 +996,7 @@ SurfTriMesh::GetLoops( POLYLINEVECTOR& vPL) const
             if ( ! MarchAlongLoop( nT, 1, m_nTimeStamp, vPL.back()))
                return false ;
          }
-        // se il lato 0 � di contorno
+        // se il lato 0 è di contorno
          else if ( nAdjT[0] == SVT_NULL) {
            // ho trovato l'inizio di un loop
             vPL.emplace_back() ;
@@ -994,7 +1008,7 @@ SurfTriMesh::GetLoops( POLYLINEVECTOR& vPL) const
             if ( ! MarchAlongLoop( nT, 1, m_nTimeStamp, vPL.back()))
                return false ;
          }
-        // se il lato 1 � di contorno
+        // se il lato 1 è di contorno
          else if ( nAdjT[1] == SVT_NULL) {
            // ho trovato l'inizio di un loop
             vPL.emplace_back() ;
@@ -1006,7 +1020,7 @@ SurfTriMesh::GetLoops( POLYLINEVECTOR& vPL) const
             if ( ! MarchAlongLoop( nT, 2, m_nTimeStamp, vPL.back()))
                return false ;
          }
-        // se il lato 2 � di contorno
+        // se il lato 2 è di contorno
          else if ( nAdjT[2] == SVT_NULL) {
            // ho trovato l'inizio di un loop
             vPL.emplace_back() ;
@@ -1018,7 +1032,7 @@ SurfTriMesh::GetLoops( POLYLINEVECTOR& vPL) const
             if ( ! MarchAlongLoop( nT, 0, m_nTimeStamp, vPL.back()))
                return false ;
          }
-        // altrimenti non c'� contorno
+        // altrimenti non c'è contorno
          else {
            // marco il triangolo come verificato
             m_vTria[nT].nTemp = m_nTimeStamp ;
@@ -1063,10 +1077,10 @@ SurfTriMesh::MarchOneTria( int& nT, int& nV, int nTimeStamp,
       return false ;
   // vertice di fine adiacenza e indice del successivo lato
    int nAdjV = Next( nAdjS) ;
-  // verifico se il lato successivo � un bordo
+  // verifico se il lato successivo è un bordo
    int nNextT = m_vTria[nAdjT].nIdAdjac[nAdjV] ;
    if ( nNextT == SVT_NULL) {
-     // se gi� recuperato
+     // se già recuperato
       if ( m_vTria[nAdjT].nTemp == nTimeStamp) {
          bEnd = true ;
          return true ;
@@ -1197,6 +1211,7 @@ SurfTriMesh::CopyFrom( const SurfTriMesh& stmSrc)
    m_dCosBndAng = stmSrc.m_dCosBndAng ;
    m_dSmoothAng = stmSrc.m_dSmoothAng ;
    m_dCosSmAng = stmSrc.m_dCosSmAng ;
+   m_bShowEdges = stmSrc.m_bShowEdges ;
    m_bOriented = stmSrc.m_bOriented ;
    m_bClosed = stmSrc.m_bClosed ;
    m_bFaceted = stmSrc.m_bFaceted ;
@@ -1332,12 +1347,33 @@ SurfTriMesh::Save( NgeWriter& ngeOut) const
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+SurfTriMesh::PreSave( GdbGeo& Wrapper) const
+{
+  // salvo il flag di visualizzazione spigoli vivi anche in shading (default false)
+   if ( m_bShowEdges)
+      Wrapper.SetInfo( GDB_SI_SHOWEDGES, true) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+SurfTriMesh::PostSave( GdbGeo& Wrapper) const
+{
+  // elimino eventuali info aggiunte nella PreSave
+   Wrapper.RemoveInfo( GDB_SI_SHOWEDGES) ;
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 SurfTriMesh::Load( NgeReader& ngeIn)
 {
   // imposto ricalcolo della grafica, della connessione e di hashgrids3d
-   m_OGrMgr.Reset() ;
+   m_OGrMgr.Clear() ;
    m_nMaxTFlag = 0 ;
    m_nParts = -1 ;
    ResetHashGrids3d() ;
@@ -1434,6 +1470,20 @@ SurfTriMesh::Load( NgeReader& ngeIn)
    return Validate() ;
 }
 
+//----------------------------------------------------------------------------
+bool
+SurfTriMesh::PostLoad( GdbGeo& Wrapper)
+{
+  // recupero eventuale flag di visualizzazione spigoli vivi anche in shading
+   bool bVal ;
+   if ( Wrapper.GetInfo( GDB_SI_SHOWEDGES, bVal)) {
+      m_bShowEdges = bVal ;
+      Wrapper.RemoveInfo( GDB_SI_SHOWEDGES) ;
+   }
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 SurfTriMesh::Validate( bool bCorrect)
@@ -3194,7 +3244,6 @@ SurfTriMesh::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double
    bMirror = ( bMirror ? ( dCoeffZ > 0) : ( dCoeffZ < 0)) ; 
 
   // aggiorno le facce
-   bool bRecalc = ( abs( dCoeffX) < EPS_ZERO  ||  abs( dCoeffY) < EPS_ZERO  ||  abs( dCoeffZ) < EPS_ZERO) ;
    for ( int i = 0 ; i < GetTriangleSize() ; ++ i) {
       if ( m_vTria[i].nIdVert[0] != SVT_DEL) {
         // se c'è mirror, devo invertire la faccia
@@ -3204,15 +3253,12 @@ SurfTriMesh::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double
          if ( ! CalcTriangleNormal( i)) {
            // elimino il triangolo
             RemoveTriangle( i) ;
-           // richiedo ricalcolo vertici e topologia
-            bRecalc = true ;
          }
       }
    }
-   if ( bRecalc)
-      return DoCompacting() ;
 
-   return true ;
+   return DoCompacting() ;
+
 }
 
 //----------------------------------------------------------------------------
@@ -3643,6 +3689,7 @@ SurfTriMesh::ResetTFlags( void)
    for ( int i = 0 ; i < int( m_vTria.size()) ; ++ i)
       m_vTria[i].nTFlag = 0 ;
    m_nMaxTFlag = 0 ;
+   m_OGrMgr.Clear() ;
    return true ;
 }
 

SurfTriMesh.h

@@ -226,6 +226,9 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
               { m_dSmoothAng = std::max( dSmoothAngDeg, EPS_ANG_SMALL) ;
                 m_dCosSmAng = cos( m_dSmoothAng * DEGTORAD) ;
                 m_OGrMgr.Reset() ; }
+      void SetShowEdges( bool bShow) override
+              { m_bShowEdges = bShow ;  // qui è necessario far ricreare la grafica
+                m_OGrMgr.Clear() ; }
       int  AddVertex( const Point3d& ptVert, double dU = -1, double dV = -1) override ;
       bool MoveVertex( int nInd, const Point3d& ptNewVert) override ;
       int  AddTriangle( const int nIdVert[3], int nTFlag = 0) override ; 
@@ -254,6 +257,8 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
               { return m_dLinTol ; }
       double GetSmoothAngle( void) const override
               { return m_dSmoothAng ; }
+      bool GetShowEdges( void) const override
+              { return m_bShowEdges ; }
       bool GetVertex( int nId, Point3d& ptP) const override ;
       bool GetVertexParam( int nId, double& dU, double& dV) const override ;
       int  GetFirstVertex( Point3d& ptP) const override ;
@@ -320,7 +325,10 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
+      bool PreSave( GdbGeo& Wrapper) const override ;
+      bool PostSave( GdbGeo& Wrapper) const override ;
       bool Load( NgeReader& ngeIn) override ;
+      bool PostLoad( GdbGeo& Wrapper) override ;
 
    public :
       SurfTriMesh( void) ;
@@ -413,6 +421,7 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       double         m_dCosBndAng ;    // coseno dell'angolo limite per considerare un lato un contorno  
       double         m_dSmoothAng ;    // angolo limite per mediare le normali (in gradi)
       double         m_dCosSmAng ;     // coseno dell'angolo limite per mediare le normali
+      bool           m_bShowEdges ;    // flag di visualizzazione spigoli vivi
       bool           m_bOriented ;     // la superficie è orientata consistentemente in tutte le sue parti
       bool           m_bClosed ;       // la superficie racchiude un volume
       bool           m_bFaceted ;      // flag di validità della sfaccettatura

SurfTriMeshBooleans.cpp

@@ -35,7 +35,6 @@
 #include "/EgtDev/Include/EGkPolygon3d.h"
 #include "/EgtDev/Include/EgtPerfCounter.h"
 #include "/EgtDev/Include/EGnStringUtils.h"
-#include "/EgtDev/Include/EGkGeoObjSave.h"
 #include <algorithm>
 
 using namespace std ;
@@ -862,7 +861,7 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
                         double dDist ;
                         DistCalculator.GetDist( dDist) ;
                         double dLongPos = ( ptP - ptSt) * vtSeg ;
-                        if ( dDist < EPS_SMALL  &&  dLongPos > 0.  &&  dLongPos < dSegLen) {
+                        if ( dDist < EPS_SMALL  &&  dLongPos > EPS_SMALL  &&  dLongPos < dSegLen - EPS_SMALL) {
                            POINTU NewPointU ;
                            NewPointU.first = ptP ;
                            NewPointU.second = dLongPos ;
@@ -932,24 +931,32 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
                }
                bool bReplaced = false ;
                for ( int nl = 0 ; nl < int( vAuxPolygons.size()) ; ++ nl) {
-                  if ( true) {
-                     if ( ! bReplaced) {
-                        vPolygons[nL].Clear() ;
-                        Point3d ptP ;
-                        bool bContinue = vAuxPolygons[nl].GetFirstPoint( ptP) ;
-                        while ( bContinue) {
-                           vPolygons[nL].AddUPoint( 0., ptP) ;
-                           bContinue = vAuxPolygons[nl].GetNextPoint( ptP) ;
-                        }
-                        bReplaced = true ;
-                     }
-                     else {
-                        vPolygons.emplace_back( vAuxPolygons[nl]) ;
+                  if ( ! bReplaced) {
+                     vPolygons[nL].Clear() ;
+                     Point3d ptP ;
+                     bool bContinue = vAuxPolygons[nl].GetFirstPoint( ptP) ;
+                     while ( bContinue) {
+                        vPolygons[nL].AddUPoint( 0., ptP) ;
+                        bContinue = vAuxPolygons[nl].GetNextPoint( ptP) ;
                      }
+                     bReplaced = true ;
+                  }
+                  else {
+                     vPolygons.emplace_back( vAuxPolygons[nl]) ;
                   }
                }
             }
+
+           // tolgo il loop esterno per triangolare solo i loop interni
             vPolygons.erase( vPolygons.begin()) ;
+           // tolgo le PolyLine non valide ( rejected )
+            for ( int i = 0 ; i < int( vPolygons.size()) ; ) {
+               if ( ! vPolygons[i].IsClosed())
+                  vPolygons.erase( vPolygons.begin() + i) ;
+               else
+                  ++ i ;
+            }
+
             if ( Triangulate().MakeAdvanced( vPolygons, vPt, vTr)) {
                // Inserisco i nuovi triangoli
                for  (int n = 0 ; n < int( vTr.size()) - 2 ; n += 3) {
@@ -1486,9 +1493,6 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
    if ( bModif)
       bContinue = ( AdjustVertices()  &&  DoCompacting()  &&  SurfB.AdjustVertices()  &&  SurfB.DoCompacting()) ;
 
-   SaveGeoObj( this, "C:\\Users\\riccardo.elitropi\\Desktop\\SurfA.nge") ;
-   SaveGeoObj( SurfB.Clone(), "C:\\Users\\riccardo.elitropi\\Desktop\\SurfB.nge") ;
-
   // Triangoli sovrapposti
    if ( bContinue) {
       int nTriaNum2A = GetTriangleSize() ;

SurfTriMeshFaceting.cpp

@@ -901,7 +901,7 @@ SurfTriMesh::UpdateFacetEdging( void)
          int nTAdj = Tria.nIdAdjac[nE] ;
          if ( Tria.nETempFlag[nE] == 0) {
             if ( nTAdj == SVT_NULL) {
-               m_vFacEdge.emplace_back( Tria.nIdVert[nE], Tria.nIdVert[nE2], Tria.nIdFacet, SVT_NULL, 0.) ;        
+               m_vFacEdge.emplace_back( Tria.nIdVert[nE], Tria.nIdVert[nE2], Tria.nIdFacet, SVT_NULL, 180.) ;        
             }
             else if ( Tria.nIdFacet != m_vTria[nTAdj].nIdFacet) {
               // calcolo l'angolo tra le facce ( 0 = allineate, > 0 convesse, < 0 concave)

SurfTriMeshUtilities.cpp

@@ -2,7 +2,7 @@
 //  EgalTech 2021-2021
 //----------------------------------------------------------------------------
 // File : SurfTriMeshUtilities.cpp     Data : 01.11.21       Versione : 2.3k1
-// Contenuto : Implementazione funzioni di utilità di Superfici TriMesh.
+// Contenuto : Implementazione funzioni di utilità di Superfici TriMesh.
 //
 //
 //
@@ -123,7 +123,7 @@ SurfTriMesh::RemoveTJunctions( bool& bModified)
 
   // Ciclo sui triangoli della superficie per determinare gli altri vertici sul loro perimetro
    for ( int nT = 0 ; nT < int( m_vTria.size()) ; ++ nT) {
-     // Se il triangolo non è valido, passo al successivo
+     // Se il triangolo non è valido, passo al successivo
       Triangle3d trTria ;
       if ( ! GetTriangle( nT, trTria)  ||  ! trTria.Validate( true))
          continue ;
@@ -138,7 +138,7 @@ SurfTriMesh::RemoveTJunctions( bool& bModified)
       for ( int nSeg = 0 ; nSeg < 3 ; ++ nSeg) {
         // aggiungo al vettore il vertice iniziale del lato
          vVertOtl.emplace_back( m_vTria[nT].nIdVert[nSeg]) ;
-        // Se in questo lato il triangolo è adiacente a un altro, lo salto.
+        // Se in questo lato il triangolo è adiacente a un altro, lo salto.
          if ( m_vTria[nT].nIdAdjac[nSeg] != SVT_DEL  &&  m_vTria[nT].nIdAdjac[nSeg] != SVT_NULL)
             continue ;
          int nPrevSize = int( vVertOtl.size()) ;
@@ -152,7 +152,7 @@ SurfTriMesh::RemoveTJunctions( bool& bModified)
          vtSeg /= dSegLen ;
         // Ciclo sui triangoli vicini
          for ( int nI = 0 ; nI < int( vNearTria.size()) ; ++ nI) {
-           // Salto il triangolo se è quello di riferimento
+           // Salto il triangolo se è quello di riferimento
             if ( vNearTria[nI] == nT)
                continue ;
            // Cerco i vertici che stanno sul lato del triangolo
@@ -175,11 +175,11 @@ SurfTriMesh::RemoveTJunctions( bool& bModified)
                                  } ;
          sort( vVertOtl.begin() + nPrevSize, vVertOtl.end(), SortVertices) ;
       }
-     // Se ci sono più di 3 vertici
+     // Se ci sono più di 3 vertici
       if ( vVertOtl.size() > 3) {
         // Elimino i vertici ripetuti
          vVertOtl.erase( unique( vVertOtl.begin(), vVertOtl.end()), vVertOtl.end()) ;
-        // Se ci sono ancora più di 3 vertici, inserisco nel Map
+        // Se ci sono ancora più di 3 vertici, inserisco nel Map
          if ( vVertOtl.size() > 3)
             TriaMap.emplace( nT, vVertOtl) ;
       }
@@ -191,7 +191,7 @@ SurfTriMesh::RemoveTJunctions( bool& bModified)
       int nT = itT->first ;
      // Vettore degli altri vertici sul perimetro
       const INTVECTOR& vVertOtl = itT->second ;
-     // Se il triangolo non è valido, passo al successivo
+     // Se il triangolo non è valido, passo al successivo
       Triangle3d trTria ;
       if ( ! GetTriangle( nT, trTria)  ||  ! trTria.Validate( true))
          continue ;
@@ -207,7 +207,7 @@ SurfTriMesh::RemoveTJunctions( bool& bModified)
       int nLastNewTria = SVT_NULL ;
      // Se ci sono 4 vertici, inserisco due triangoli
       if ( vVertOtl.size() == 4) {
-        // se 1-2-3 è triangolo (e quindi 0-1-3)
+        // se 1-2-3 è triangolo (e quindi 0-1-3)
          int nNew1Id[3] = { vVertOtl[1], vVertOtl[2], vVertOtl[3]} ;
          int nNew1Tria = AddTriangle( nNew1Id, nTFlag) ;
          if ( nNew1Tria != SVT_NULL  &&  nNew1Tria != SVT_DEL) {
@@ -285,13 +285,13 @@ IsVertex( PNTULIST& PointList, PNTULIST::const_iterator itCurr)
 static bool
 ChooseGoodStartPoint( PNTULIST& PointList)
 {
-  // se il punto iniziale è un vertice, non devo fare alcunché
+  // se il punto iniziale è un vertice, non devo fare alcunché
    if ( IsVertex( PointList, PointList.begin()))
       return true ;
-  // altrimenti cerco il vertice più vicino
+  // altrimenti cerco il vertice più vicino
    for ( auto it = next( PointList.begin()) ; it != PointList.end() ; ++it) {
       if ( IsVertex( PointList, it)) {
-        // se ultimo punto non devo fare alcunché
+        // se ultimo punto non devo fare alcunché
          if ( next( it) == PointList.end())
             return false ;
         // cancello ultimo punto ( coincide con primo)
@@ -317,11 +317,32 @@ AdjustLoop( PNTULIST& PointList, double dMaxEdgeLen, bool& bModif)
    
      // Se dal punto corrente inizia un segmento adiacente a un'altra faccia
       if ( itLast->second != it->second) {
-        // Elimino i punti interni
-         auto itNextToLast = next( itLast) ;
-         for ( auto itInn = itNextToLast ; itInn != it ; ) {
-            itInn = PointList.erase( itInn) ;
-            bModif = true ;
+        // Raccolgo i punti in una polyline
+         PolyLine PL ;
+         int nPar = -1 ;
+         for ( auto itInn = itLast ; itInn != it ; ) {
+            PL.AddUPoint( ++nPar, itInn->first) ;
+            itInn = next( itInn) ;
+         }
+         PL.AddUPoint( ++nPar, it->first) ;
+        // Provo ad eliminare i punti allineati
+         PL.RemoveAlignedPoints( 50 * EPS_SMALL) ;
+         if ( PL.GetPointNbr() < nPar + 1) {
+           // rimuovo dalla lista dei punti gli eliminati (salto gli estremi)
+            int nUCurr = 1 ; 
+            for ( auto itInn = next( itLast) ; itInn != it ; ) {
+               bool bFound = false ;
+               double dU ;
+               for ( bool bOk = PL.GetFirstU( dU) ; bOk && ! bFound ; bOk = PL.GetNextU( dU))
+                  bFound = abs( dU - nUCurr) < EPS_SMALL ;
+               if ( ! bFound) {
+                  itInn = PointList.erase( itInn) ;
+                  bModif = true ;
+               }
+               else
+                  itInn = next( itInn) ;
+               ++ nUCurr ;
+            }
          }
         // Se la lunghezza del segmento supera il limite imposto
          double dSegLen = Dist( it->first, itLast->first) ;
@@ -354,7 +375,7 @@ AdjustLoop( PNTULIST& PointList, double dMaxEdgeLen, bool& bModif)
          }
         // Se i punti sono allineati
          if ( bAreAligned) {
-           // Verifico se il successivo punto non è più allineato
+           // Verifico se il successivo punto non è più allineato
             auto itNextToCurr = next( it) ;
             if ( itNextToCurr != PointList.end()) {
                for ( auto itInn = itNextToLast ; itInn != itNextToCurr  &&  bAreAligned ; ++ itInn) {
@@ -402,7 +423,7 @@ SurfTriMesh::SimplifyFacets( double dMaxEdgeLen, bool bForced)
   // La trimesh deve essere valida
    if ( ! IsValid())
       return false ;
-  // Se la lunghezza massima del lato del triangolo sul bordo della faccia è nulla e non forzata, non devo fare alcunché
+  // Se la lunghezza massima del lato del triangolo sul bordo della faccia è nulla e non forzata, non devo fare alcunché
    if ( dMaxEdgeLen < EPS_SMALL  &&  ! bForced)
       return true ;
 
@@ -505,7 +526,7 @@ SurfTriMesh::SimplifyFacets( double dMaxEdgeLen, bool bForced)
       }
    }
    
-  // dichiaro necessità ricalcolo della grafica e di hashgrids3d
+  // dichiaro necessità ricalcolo della grafica e di hashgrids3d
    m_OGrMgr.Reset() ;
    ResetHashGrids3d() ;
 
@@ -517,13 +538,13 @@ SurfTriMesh::SimplifyFacets( double dMaxEdgeLen, bool bForced)
 bool
 SurfTriMesh::AddChainToChain( const Chain& ChainToAdd, PNTVECTOR& OrigChain)
 {
-  // Se la catena da aggiungere è vuota, non devo fare alcunchè
+  // Se la catena da aggiungere è vuota, non devo fare alcunchè
    if ( ChainToAdd.size() == 0)
       return true ;
-  // Se la catena originale è vuota, non è possibile aggiungere nulla
+  // Se la catena originale è vuota, non è possibile aggiungere nulla
    if ( OrigChain.size() == 0)
       return false ;
-  // Se la catena originale è chiusa non posso aggiungere nulla
+  // Se la catena originale è chiusa non posso aggiungere nulla
    int nLastOrig = max( int( OrigChain.size()) - 1, 0) ;
    if ( AreSamePointApprox( OrigChain[0], OrigChain[nLastOrig]))
       return false ;
@@ -562,11 +583,11 @@ SurfTriMesh::DistPointFacet( const Point3d& ptP, const POLYLINEVECTOR& vPolyVec,
       return false ;
    double dDistPtPl = DistPointPlane( ptP, plPlane) ;
    Point3d ptProjP = ptP + dDistPtPl * plPlane.GetVersN() ;
-  // Verifico se il punto proiettato è esterno al loop esterno
+  // Verifico se il punto proiettato è esterno al loop esterno
    int nPtOut = -1 ;
    if ( ! IsPointInsidePolyLine( ptProjP, vPolyVec[0], EPS_SMALL))
       nPtOut = 0 ;
-  // Verifico se il punto proiettato è interno ai loop interni (quindi esterno alla faccia)
+  // Verifico se il punto proiettato è interno ai loop interni (quindi esterno alla faccia)
    for ( int nLoop = 1 ; nLoop < int( vPolyVec.size()) && nPtOut < 0 ; ++ nLoop) {
       Plane3d plPlane ;
       double dArea ;
@@ -580,7 +601,7 @@ SurfTriMesh::DistPointFacet( const Point3d& ptP, const POLYLINEVECTOR& vPolyVec,
       dPointFacetDist = abs( dDistPtPl) ;
       return true ;
    }
-  // Altrimenti calcolo la minima distanza del punto dalla polilinea del contorno a cui è esterno
+  // Altrimenti calcolo la minima distanza del punto dalla polilinea del contorno a cui è esterno
    double dDist ;
    if ( DistPointPolyLine( ptP, vPolyVec[nPtOut], dDist)) {
       dPointFacetDist = dDist ; 
@@ -593,7 +614,7 @@ SurfTriMesh::DistPointFacet( const Point3d& ptP, const POLYLINEVECTOR& vPolyVec,
 bool
 SurfTriMesh::ChangeStart( const Point3d& ptNewStart, PNTVECTOR& Loop)
 {
-  // Cerco il tratto del loop chiuso più vicino al punto
+  // Cerco il tratto del loop chiuso più vicino al punto
    int nMinSeg = - 1 ;  
    double dMinSqDinst = DBL_MAX ;
    for ( int nPt = 0 ; nPt < int( Loop.size()) ; ++ nPt) {
@@ -657,7 +678,7 @@ SurfTriMesh::ChangeStart( const Point3d& ptNewStart, PNTVECTOR& Loop)
 bool
 SurfTriMesh::SplitAtPoint( const Point3d& ptStop, const PNTVECTOR& Loop, PNTVECTOR& Loop1, PNTVECTOR& Loop2)
 {
-  // Cerco il tratto del loop chiuso più vicino al punto
+  // Cerco il tratto del loop chiuso più vicino al punto
    int nMinSeg = -1 ;
    double dMinSqDinst = DBL_MAX ;
    for ( int nPt = 0 ; nPt < int( Loop.size()) ; ++ nPt) {
@@ -679,13 +700,13 @@ SurfTriMesh::SplitAtPoint( const Point3d& ptStop, const PNTVECTOR& Loop, PNTVECT
   // Verifico che il punto stia su un vertice, in tal caso non devo aggiungerlo
    bool bFirst = AreSamePointApprox( Loop[nMinSeg], ptStop) ;
    bool bLast = AreSamePointApprox( Loop[( nMinSeg + 1) % int( Loop.size())], ptStop) ;
-  // Se il punto è sul vertice finale del segmento, aggiungo il vertice alla lista da inglobare al primo loop
+  // Se il punto è sul vertice finale del segmento, aggiungo il vertice alla lista da inglobare al primo loop
    if ( bLast)
       ++ nMinSeg ;
   // Inglobo fino a nSeg nel primo loop
    for ( int nPt = 0 ; nPt <= nMinSeg  &&  nPt < int( Loop.size()) ; ++ nPt)
       Loop1.emplace_back( Loop[nPt]) ;
-  // Se il punto è interno al segmento, lo inglobo in entrambi i loop
+  // Se il punto è interno al segmento, lo inglobo in entrambi i loop
    if ( ! ( bFirst  ||  bLast)) {
       Loop1.emplace_back( ptStop) ;
       Loop2.emplace_back( ptStop) ;

Tree.cpp

@@ -24,13 +24,15 @@
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "DistPointCrvComposite.h"
+#include "/EgtDev/Include/EGkSfrCreate.h"
 #include <algorithm>
 
 using namespace std ;
 
 //----------------------------------------------------------------------------
 Tree::Tree( void)
-   : m_pSrfBz( nullptr), m_bTrimmed( false), m_bBilinear( false), m_bMulti( false), m_bClosedU( false), m_bClosedV( false), m_bSplitPatches( true), m_bTestMode( false)
+   : m_pSrfBz( nullptr), m_bTrimmed( false), m_bBilinear( false), m_bMulti( false), m_bClosedU( false), m_bClosedV( false), m_vbPole( { false, false, false, false}),
+     m_bSplitPatches( true), m_bTestMode( false)
 {
    Point3d ptBl( 0, 0), ptTr ( 1 * SBZ_TREG_COEFF, 1 * SBZ_TREG_COEFF) ;
    Cell cRoot( ptBl, ptTr) ;
@@ -39,7 +41,8 @@ Tree::Tree( void)
 
 //----------------------------------------------------------------------------
 Tree::Tree( const SurfBezier* pSrfBz, const bool bSplitPatches, const Point3d& ptMin, const Point3d& ptMax)
-   : m_pSrfBz( nullptr), m_bTrimmed( false), m_bBilinear( false), m_bMulti( false), m_bClosedU( false), m_bClosedV( false), m_bSplitPatches( true), m_bTestMode( false)
+   : m_pSrfBz( nullptr), m_bTrimmed( false), m_bBilinear( false), m_bMulti( false), m_bClosedU( false), m_bClosedV( false), m_vbPole( { false, false, false, false}), 
+     m_bSplitPatches( true), m_bTestMode( false)
 {
    SetSurf( pSrfBz, bSplitPatches, ptMin, ptMax) ;
 }
@@ -49,6 +52,47 @@ Tree::~Tree( void)
 {
 }
 
+//----------------------------------------------------------------------------
+Tree::Tree( const Point3d ptBl, const Point3d ptTr)
+   : m_pSrfBz( nullptr), m_bTrimmed( false), m_bBilinear( false), m_bMulti( false), m_bClosedU( false), m_bClosedV( false), m_vbPole( { false, false, false, false}),
+     m_bSplitPatches( true), m_bTestMode( false)
+{
+   Cell cRoot( ptBl, ptTr) ;
+   m_mTree.insert( pair< int, Cell>( -1, cRoot)) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Tree::LimitLoop( PolyLine& pl, POLYLINEVECTOR& vPl) const
+{
+   // creo la flat region di trim, quella del parametrico e li interseco
+   PtrOwner<ISurfFlatRegion> pSfrTrim( GetSurfFlatRegionFromPolyLine( pl)) ;
+   bool bInverted = false ;
+   if ( ! pSfrTrim->GetNormVersor().IsZplus()) {
+      pSfrTrim->Invert() ;
+      bInverted = true ;
+   }
+   PtrOwner<ISurfFlatRegion> pParamTrim( GetSurfFlatRegionRectangle( SBZ_TREG_COEFF * m_nSpanU, SBZ_TREG_COEFF * m_nSpanV)) ;
+   if ( ! pParamTrim->Intersect( *pSfrTrim)  ||  ! pParamTrim->IsValid())
+      return false ;
+
+   // ricostruisco la curva tenendo solo le parti dentro lo spazio parametrico
+   // devo recuperare la polyline dei bordi dei vari chunk creati
+   for ( int c = 0 ; c < int( pParamTrim->GetChunkCount()) ; ++c) {
+      PtrOwner<ICurve> pCrv ( pParamTrim->GetLoop( c, 0)) ;
+      if ( bInverted)
+         pCrv->Invert() ;
+      PolyLine plApprox ;
+      double dLinTol = 10 * EPS_SMALL, dAngTolDeg = 5 ;
+      int nType = 0 ;
+      pCrv->ApproxWithLines( dLinTol, dAngTolDeg, nType, plApprox) ;
+      // aggiungo la polyline del chunk
+      vPl.push_back( plApprox) ;
+   }
+   
+   return false ;
+}
+
 //----------------------------------------------------------------------------
 void
 Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMin, const Point3d& ptMax)
@@ -60,8 +104,8 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi
    m_vLoop.clear() ;
    m_mChunk.clear() ;
    m_vPlApprox.clear() ;
-   m_vChunk.clear() ;
    m_vPolygons.clear() ;
+   m_vPlLoop2D.clear() ;
 
    m_pSrfBz = pSrfBz ;
    m_bSplitPatches = bSplitPatches ;
@@ -81,8 +125,6 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi
   // recupero i loop di trim e li divido per chunk
    if ( m_bTrimmed) {
       int nLoop = 0 ;
-      INTVECTOR vChunk ;
-
      // recupero la superficie di trim per avere accesso diretto ai loop e mantenendo le informazioni sui chunk
       PtrOwner<SurfFlatRegion> pTrimReg( m_pSrfBz->GetTrimRegion()->Clone()) ;
       double dLinTol = 0.01 ; // questo è riferito allo spazio parametrico
@@ -90,7 +132,7 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi
       for ( int i = 0 ; i < pTrimReg->GetChunkCount() ; ++ i) {
          PtrOwner<SurfFlatRegion> pChunk( pTrimReg->CloneChunk( i)) ;
          for ( int j = 0 ; j < pChunk->GetLoopCount( 0) ; ++ j) {
-            vChunk.push_back( nLoop) ;
+            //vChunk.push_back( nLoop) ;
            // i chunk della falt region sono ancora flat region composte da 1 chunk
             PtrOwner<ICurve> pLoop ( pChunk->GetLoop( 0, j)) ;
             // rimuovo i difetti dei loop prima di salvarli
@@ -115,21 +157,13 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi
                bCCW = true ;
             else
                bCCW = false ;
-            m_vPlApprox.push_back( tuple<PolyLine,bool>(plApprox,bCCW)) ;
+            // limito il loop allo spazio parametrico  // potrei ottenere più loop a partire da quello originale
+            POLYLINEVECTOR vPlLimited ;
+            LimitLoop( plApprox, vPlLimited) ;
+            for ( int k = 0 ; k < int( vPlLimited.size()) ; ++k)
+               m_vPlApprox.push_back( tuple<PolyLine,bool>(vPlLimited[k], bCCW)) ;
          }
-        // li riordino dal più grande al più piccolo
-         sort(vChunk.begin(), vChunk.end(), [this]( const int& a, const int& b) { double dArea1, dArea2 ;
-                                                                                  m_vLoop[a]->GetAreaXY( dArea1) ;
-                                                                                  m_vLoop[b]->GetAreaXY( dArea2) ;
-                                                                                  return dArea1 > dArea2 ; }) ;
-         m_vChunk.push_back( vChunk) ;
-         vChunk.clear() ;
       }
-     // li riordino dal più grande al più piccolo
-      sort(m_vChunk.begin(), m_vChunk.end(), [this]( const INTVECTOR& a, const INTVECTOR& b) { double dArea1, dArea2 ;
-                                                                               m_vLoop[a[0]]->GetAreaXY( dArea1) ;
-                                                                               m_vLoop[b[0]]->GetAreaXY( dArea2) ;
-                                                                               return dArea1 > dArea2 ;}) ;
    }
   // salvo i vertici 3d della cella root
    Point3d ptTop( nSpanU * SBZ_TREG_COEFF, nSpanV * SBZ_TREG_COEFF) ;
@@ -219,16 +253,18 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi
         // devo controllare se i punti ai parametri U=0 e U=1 sono tutti coincidenti
         // in caso devo fare uno split nell'altra direzione
          bool bOk = false ;
-         bool bCapped0 = true, bCapped1 = true ;
-         Point3d ptV0, ptV1 ;
-        // controllo se tutti i punti sull'isoparametrica sono uguali
+         bool bPole0 = true, bPole1 = true ;
+         Point3d ptU0, ptU1 ;
+        // controllo se tutti i punti di controllo sull'isoparametrica sono uguali
          for ( int i = 1 ; i < nDegV * nSpanV + 1 ; ++ i) {
-            ptV0 = m_pSrfBz->GetControlPoint( i * ( nDegU * nSpanU + 1), &bOk) ;
-            bCapped0 = bCapped0  &&  AreSamePointApprox( ptP00, ptV0) ;
-            ptV1 = m_pSrfBz->GetControlPoint( ( i + 1) * ( nDegU * nSpanU + 1) - 1, &bOk) ;
-            bCapped1 = bCapped1  &&  AreSamePointApprox( ptP10, ptV1) ;
+            ptU0 = m_pSrfBz->GetControlPoint( i * ( nDegU * nSpanU + 1), &bOk) ;
+            bPole0 = bPole0  &&  AreSamePointApprox( ptP00, ptU0) ;
+            ptU1 = m_pSrfBz->GetControlPoint( ( i + 1) * ( nDegU * nSpanU + 1) - 1, &bOk) ;
+            bPole1 = bPole1  &&  AreSamePointApprox( ptP10, ptU1) ;
          }
-         if ( bCapped0  &&  bCapped1) {
+         m_vbPole[1] = bPole0 ;
+         m_vbPole[3] = bPole1 ;
+         if ( bPole0  &&  bPole1) {
             m_mTree[0].SetSplitDirVert( true) ;
             Split( 0) ;
             m_mTree[1].SetSplitDirVert( true) ;
@@ -248,16 +284,18 @@ Tree::SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches, const Point3d& ptMi
            // devo controllare se i punti ai parametri V=0 e V=1 sono tutti coincidenti
            // in caso devo fare uno split nell'altra direzione
             bool bOk = false ;
-            bool bCapped0 = true, bCapped1 = true ;
-            Point3d ptU0, ptU1 ;
+            bool bPole0 = true, bPole1 = true ;
+            Point3d ptV0, ptV1 ;
            // controllo se tutti i punti sull'isoparametrica sono uguali
             for ( int i = 1 ; i < nDegU * nSpanU + 1 ; ++ i) {
-               ptU0 = m_pSrfBz->GetControlPoint( i, &bOk) ;
-               bCapped0 = bCapped0  &&  AreSamePointApprox( ptP00, ptU0) ;
-               ptU1 = m_pSrfBz->GetControlPoint( i + ( nDegU * nSpanU + 1) * ( nDegV * nSpanV), &bOk) ;
-               bCapped1 = bCapped1  &&  AreSamePointApprox( ptP01, ptU1) ;
+               ptV0 = m_pSrfBz->GetControlPoint( i, &bOk) ;
+               bPole0 = bPole0  &&  AreSamePointApprox( ptP00, ptV0) ;
+               ptV1 = m_pSrfBz->GetControlPoint( i + ( nDegU * nSpanU + 1) * ( nDegV * nSpanV), &bOk) ;
+               bPole1 = bPole1  &&  AreSamePointApprox( ptP01, ptV1) ;
             }
-            if ( bCapped0  &&  bCapped1) {
+            m_vbPole[0] = bPole0 ;
+            m_vbPole[2] = bPole1 ;
+            if ( bPole0  &&  bPole1) {
                m_mTree[0].SetSplitDirVert( false) ;
                Split( 0) ;
                m_mTree[1].SetSplitDirVert( false) ;
@@ -931,6 +969,7 @@ Tree::Balance()
 void
 Tree::GetTopNeigh( int nId, INTVECTOR& vTopNeighs) const
 {
+   // le celle restituite sono ordinate per x crescente
    if ( vTopNeighs.empty()) {
       if ( m_mTree.at( nId).m_nTop == -2)
          return ;
@@ -1000,6 +1039,7 @@ Tree::GetTopNeigh( int nId, INTVECTOR& vTopNeighs) const
    vector<Cell> vCells ;
    for ( int k : vTopNeighs)
       vCells.push_back( m_mTree.at( k)) ;
+   // le celle restituite sono ordinate per x crescente
    sort( vCells.begin(), vCells.end(), Cell::minorX) ;
    vTopNeighs.clear() ;
    for ( Cell c : vCells)
@@ -1011,6 +1051,7 @@ Tree::GetTopNeigh( int nId, INTVECTOR& vTopNeighs) const
 void
 Tree::GetBottomNeigh( int nId, INTVECTOR& vBottomNeighs) const
 {
+   // le celle restituite sono ordinate per x crescente
    if ( vBottomNeighs.empty()) {
       if ( m_mTree.at( nId).m_nBottom == -2)
          return ;
@@ -1080,6 +1121,7 @@ Tree::GetBottomNeigh( int nId, INTVECTOR& vBottomNeighs) const
    vector<Cell> vCells ;
    for ( int k : vBottomNeighs)
       vCells.push_back( m_mTree.at( k)) ;
+   // le celle restituite sono ordinate per x crescente
    sort( vCells.begin(), vCells.end(), Cell::minorX) ;
    vBottomNeighs.clear() ;
    for ( Cell c : vCells)
@@ -1090,6 +1132,7 @@ Tree::GetBottomNeigh( int nId, INTVECTOR& vBottomNeighs) const
 void
 Tree::GetLeftNeigh( int nId, INTVECTOR& vLeftNeighs) const
 {
+   // le celle restituite sono ordinate per y crescente
    if ( vLeftNeighs.empty()) {
       if ( m_mTree.at( nId).m_nLeft == -2)
          return ;
@@ -1159,6 +1202,7 @@ Tree::GetLeftNeigh( int nId, INTVECTOR& vLeftNeighs) const
    vector<Cell> vCells ;
    for ( int k : vLeftNeighs)
       vCells.push_back( m_mTree.at( k)) ;
+   // le celle restituite sono ordinate per y crescente
    sort( vCells.begin(), vCells.end(), Cell::minorY) ;
    vLeftNeighs.clear() ;
    for ( Cell c : vCells)
@@ -1169,6 +1213,7 @@ Tree::GetLeftNeigh( int nId, INTVECTOR& vLeftNeighs) const
 void
 Tree::GetRightNeigh( int nId, INTVECTOR& vRightNeighs) const
 {
+   // le celle restituite sono ordinate per y crescente
    if ( vRightNeighs.empty()) {
       if ( m_mTree.at( nId).m_nRight == -2)
          return ;
@@ -1238,6 +1283,7 @@ Tree::GetRightNeigh( int nId, INTVECTOR& vRightNeighs) const
    vector<Cell> vCells ;
    for ( int k : vRightNeighs)
       vCells.push_back( m_mTree.at( k)) ;
+   // le celle restituite sono ordinate per y crescente
    sort( vCells.begin(), vCells.end(), Cell::minorY) ;
    vRightNeighs.clear() ;
    for ( Cell c : vCells)
@@ -1372,6 +1418,12 @@ Tree::GetPolygons( POLYLINEMATRIX& vPolygons)
       else {
          POLYLINEVECTOR vPolygonsBasic ;
          GetPolygonsBasic( vPolygonsBasic) ;
+         // aggiungo 4 elementi al vettore che contiene ciò che resta degli edge dopo il trim
+         for ( int i = 0 ; i < 4  ; ++i) {
+            m_vCEdge2D.emplace_back() ;
+            m_vCEdge2D.back().second.Init( false, EPS_SMALL, 1) ;
+         }
+         // percorro i loop, trovo le intersezioni con le celle e le categorizzo
          if ( ! TraceLoopLabelCell( vPolygonsBasic))
             return false ;
          // scorro sulle celle e costruisco i poligoni
@@ -1418,9 +1470,17 @@ Tree::GetPolygons( POLYLINEMATRIX& vPolygons)
 
 //----------------------------------------------------------------------------
 bool
-Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygons)
+Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygons, INTVECTOR vCells)
 {
-   if ( m_vPolygons.empty()) {
+   // condizioni per il calcolo dei poligoni di base
+   if ( m_vPolygons.empty()  ||  // se non li ho mai calcolati
+      ( ! m_vPolygons.empty()  &&  ! vCells.empty())  ||  // se ho già calcolato dei poligoni ma ne sto chiedendo di un altro gruppo di celle
+      ( vCells.empty()  &&  m_vPolygons.size() != m_vnLeaves.size())) { // se sto chiedendo i poligoni di tutte le celle, ma i poligoni già calcolati sono meno delle celle
+      m_vPolygons.clear() ;
+      // se non ho dato un elenco di celle in input do per scontato che la chiamata sia per calcolare i poligoni di tutte le foglie
+      if ( vCells.empty())
+         vCells = m_vnLeaves ;
+
       PNTVECTOR vVertices ;
       INTVECTOR vNeigh ;
       // setto le celle che sono sul LeftEdge e sul TopEdge
@@ -1440,7 +1500,8 @@ Tree::GetPolygonsBasic( POLYLINEVECTOR& vPolygons)
       bool bBottomRight , bTopLeft ;
       // scorro lungo tutte le celle leaves e oltre agli angoli della cella aggiungo alla polyline della cella anche i vertici, delle celle adiacenti, 
       // che sono sui lati della cella corrente
-      for ( int nId : m_vnLeaves) {
+      // N.B. :i poligoni sono costruiti a partire dal ptBL !!!
+      for ( int nId : vCells) {
          vVertices.clear() ;
          vNeigh.clear() ;
          vVertices.push_back( m_mTree.at( nId).GetBottomLeft()) ;
@@ -1776,6 +1837,40 @@ Tree::FindCell( const Point3d& ptToAssign, const CurveLine& cl, INTVECTOR vCells
    return nCells ;
 }
 
+//----------------------------------------------------------------------------
+bool
+Tree::UpdateSplitLoop( PolyLine& pl, int& nCount, Point3d& pt)
+{
+   Point3d ptLast ;
+   pl.GetLastPoint( ptLast) ;
+   if ( pl.AddUPoint( nCount, pt))
+      ++ nCount ;
+   if ( pl.GetPointNbr() != 1 ) {
+      Vector3d vtDir = pt - ptLast ;
+      if ( ! vtDir.Normalize())
+         return false ;
+      // se sono allineato con gli edge della cella ROOT
+      int nEdge = -1 ;
+      if ( abs( vtDir.x) > 1 - EPS_SMALL) {
+         if ( pt.y < EPS_SMALL)
+            nEdge = 2 ;
+         else if ( m_nSpanV * SBZ_TREG_COEFF - pt.y < EPS_SMALL)
+            nEdge = 0 ;
+      }
+      else if ( abs( vtDir.y) > 1 - EPS_SMALL) {
+         if ( pt.x < EPS_SMALL )
+            nEdge = 1 ;
+         else if ( m_nSpanU * SBZ_TREG_COEFF - pt.x < EPS_SMALL )
+            nEdge = 3 ;
+      }
+      if ( nEdge != -1) {
+         m_vCEdge2D[nEdge].second.AddCurve( m_vCEdge2D[nEdge].first.size() + 1, ptLast, vtDir, pt, vtDir) ;
+         m_vCEdge2D[nEdge].first.emplace_back( BIPOINT( ptLast, pt)) ;
+      }
+   }
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 Tree::TraceLoopLabelCell( const POLYLINEVECTOR& vplPolygons)
@@ -1788,6 +1883,9 @@ Tree::TraceLoopLabelCell( const POLYLINEVECTOR& vplPolygons)
    // percorro i loop trovando le interezioni con le celle e riempiendo i vettori m_vInters delle varie celle
    for ( int i = 0 ; i < (int) m_vPlApprox.size() ; ++ i) {
       PolyLine plLoop = get<0>( m_vPlApprox[i]) ;
+      // creo la polyline che aggiunge alla polyline originale degli split dove interseca le celle ( serve per ricostruire gli edge aperti della superficie)
+      PolyLine plLoopSplit ;
+      int nPtLoopSplit = 0 ;
       // controllo se il loop è CCW o CW
       bool bCCW = get<1>( m_vPlApprox[i]) ;
       // trovo in quale cella è il ptStart
@@ -1799,6 +1897,8 @@ Tree::TraceLoopLabelCell( const POLYLINEVECTOR& vplPolygons)
       advance( ptSecond, 1) ;
       CurveLine clFirst ;
       clFirst.Set( ptFirst->first, ptSecond->first) ;
+      // aggiorno la polyline splittata
+      UpdateSplitLoop( plLoopSplit, nPtLoopSplit, ptFirst->first) ;
       // individuo la cella da cui parte il loop
       INTVECTOR nCells = FindCell( ptStart, clFirst) ;
       int nId ;
@@ -1863,9 +1963,13 @@ Tree::TraceLoopLabelCell( const POLYLINEVECTOR& vplPolygons)
             m_mTree[nId].m_vInters.back().bCCW = bCCW ;
             // salvo il chunk del loop
             m_mTree[nId].m_vInters.back().nChunk = m_mChunk[i] ;
+            // aggiorno la polyline splittata
+            UpdateSplitLoop( plLoopSplit, nPtLoopSplit, vptInters.back()) ;
          }
          // aggiungo la fine del segmento nel vettore delle intersezioni
          vptInters.push_back( ptCurr) ;
+         // aggiorno la polyline splittata
+         UpdateSplitLoop( plLoopSplit, nPtLoopSplit, ptCurr) ;
       }
       if ( nId == nFirstCell)
          vptInters.pop_back() ;
@@ -1914,6 +2018,8 @@ Tree::TraceLoopLabelCell( const POLYLINEVECTOR& vplPolygons)
             m_mTree[nId].m_vInters[nPass].nOut = nOut ;
          }
       }
+      // salvo la polyline splittata
+      m_vPlLoop2D.emplace_back( plLoopSplit) ;
    }
 
    // riordino i vettori di intersezione per ogni cella e setto il flag RightEdgeIn
@@ -3425,6 +3531,8 @@ Tree::CheckIfBetween( const Inters& inA, const Inters& inB) const
    }
    else if ( nEdge  == 7)
       nEdge = 0 ;
+   if ( AreSameEdge( inA.nIn, inA.nOut)  &&  ! CheckIfBefore( inA.nIn, inA.vpt[0], inA.vpt.back()))
+      vEdges.push_back( nEdge) ;
    // creo la sequenza di Edges da scorrere per trovare i possibili validNextStart
    while ( ! AreSameEdge( nEdge, inA.nIn) || (int) vEdges.size() == 0) {
       vEdges.push_back( nEdge) ;
@@ -3521,3 +3629,275 @@ Tree::OnWhichEdge( int nId, const Point3d& ptToAssign, int& nEdge) const
       return false ;
    return true ;
 }
+
+//----------------------------------------------------------------------------
+bool
+Tree::GetEdges3D( POLYLINEMATRIX& mPLEdges)
+{  
+   // se la superficie non è trimmata ricostruisco dalle celle al bordo
+   if ( ! m_bTrimmed) {
+      INTMATRIX vEdges ; // le righe sono gli edge a partire dallo 0, le colonne sono le celle che compongono quell'edge
+      // recupero le celle sui quattro bordi
+      vEdges.emplace_back() ;
+      GetRootNeigh( 0, vEdges[0]) ;
+      // le celle sui bordi orizzontali sono ordinate per x o y crescente, ma i io voglio costruire gli edge in senso antiorario a partire dal ptTR,
+      // quindi devo invertire gli Edge 0 e 1
+      reverse( vEdges[0].begin(), vEdges[0].end()) ;
+      vEdges.emplace_back() ;
+      GetRootNeigh( 1, vEdges[1]) ;
+      reverse( vEdges[1].begin(), vEdges[1].end()) ;
+      vEdges.emplace_back() ;
+      GetRootNeigh( 2, vEdges[2]) ;
+      vEdges.emplace_back() ;
+      GetRootNeigh( 3, vEdges[3]) ;
+
+      // recupero i poligoni base delle celle sui bordi
+      POLYLINEMATRIX mPL ;
+      mPL.emplace_back() ;
+      GetPolygonsBasic( mPL[0], vEdges[0]) ;
+      mPL.emplace_back() ;
+      GetPolygonsBasic( mPL[1], vEdges[1]) ;
+      mPL.emplace_back() ;
+      GetPolygonsBasic( mPL[2], vEdges[2]) ;
+      mPL.emplace_back() ;
+      GetPolygonsBasic( mPL[3], vEdges[3]) ;
+   
+      // scorro sui gruppi di polyline che rappresentano i poligoni delle celle lungo un lato
+      for ( int i = 0 ; i < int( mPL.size()) ; ++i) {
+         mPLEdges.emplace_back() ;
+         mPLEdges.back().emplace_back() ;
+         int nPtCount = 0 ;
+         // scorro sui poligoni delle celle di un lato
+         for ( int c = 0 ; c < int( mPL[i].size()) ; ++c) {
+            Point3d pt ; mPL[i][c].GetFirstPoint( pt) ;
+            Point3d pt3d ;
+            // a seconda del lato controllo di stare scorrendo il poligono prendendo solo i punti su quel lato
+            if ( i == 0) {
+               while ( ! AreSamePointApprox(pt, m_mTree.at(vEdges[0][c]).GetTopRight())  &&  mPL[i][c].GetNextPoint( pt)) {
+                  continue ;
+               }
+               mPLEdges.back().back().AddUPoint( nPtCount, m_mVert.at(vEdges[0][c])[2]) ;
+               ++ nPtCount ;
+               // scorro fino alla fine di quel lato
+               while ( mPL[i][c].GetNextPoint( pt)  &&  ! AreSamePointApprox(pt, m_mTree.at(vEdges[0][c]).GetTopLeft())) {
+                  m_pSrfBz->GetPointD1D2( pt.x / SBZ_TREG_COEFF, pt.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
+                  mPLEdges.back().back().AddUPoint( nPtCount, pt3d) ;
+                  ++ nPtCount ;
+               }
+               mPLEdges.back().back().AddUPoint( nPtCount, m_mVert.at(vEdges[0][c])[3]) ;
+               ++ nPtCount ;
+            }
+            else if ( i == 1 ) {
+               while ( ! AreSamePointApprox(pt, m_mTree.at(vEdges[1][c]).GetTopLeft())  &&  mPL[i][c].GetNextPoint( pt)) {
+                  continue ;
+               }
+               mPLEdges.back().back().AddUPoint( nPtCount, m_mVert.at(vEdges[1][c])[3]) ;
+               ++ nPtCount ;
+               // scorro fino alla fine di quel lato
+               while ( mPL[i][c].GetNextPoint( pt)  &&  ! AreSamePointApprox(pt, m_mTree.at(vEdges[1][c]).GetBottomLeft())) {
+                  m_pSrfBz->GetPointD1D2( pt.x / SBZ_TREG_COEFF, pt.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
+                  mPLEdges.back().back().AddUPoint( nPtCount, pt3d) ;
+                  ++ nPtCount ;
+               }
+               mPLEdges.back().back().AddUPoint( nPtCount, m_mVert.at(vEdges[1][c])[0]) ;
+               ++ nPtCount ;
+            }
+            else if ( i == 2) {
+               while ( ! AreSamePointApprox(pt, m_mTree.at(vEdges[2][c]).GetBottomLeft())  &&  mPL[i][c].GetNextPoint( pt)) {
+                  continue ;
+               }
+               mPLEdges.back().back().AddUPoint( nPtCount, m_mVert.at(vEdges[2][c])[0]) ;
+               ++ nPtCount ;
+               // scorro fino alla fine di quel lato
+               while ( mPL[i][c].GetNextPoint( pt)  &&  ! AreSamePointApprox(pt, m_mTree.at(vEdges[2][c]).GetBottomRight())) {
+                  m_pSrfBz->GetPointD1D2( pt.x / SBZ_TREG_COEFF, pt.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
+                  mPLEdges.back().back().AddUPoint( nPtCount, pt3d) ;
+                  ++ nPtCount ;
+               }
+               mPLEdges.back().back().AddUPoint( nPtCount, m_mVert.at(vEdges[2][c])[1]) ;
+               ++ nPtCount ;
+            }
+            else if ( i == 3) {
+               while ( ! AreSamePointApprox(pt, m_mTree.at(vEdges[3][c]).GetBottomRight())  &&  mPL[i][c].GetNextPoint( pt)) {
+                  continue ;
+               }
+               mPLEdges.back().back().AddUPoint( nPtCount, m_mVert.at(vEdges[3][c])[1]) ;
+               ++ nPtCount ;
+               // scorro fino alla fine di quel lato
+               while ( mPL[i][c].GetNextPoint( pt)  &&  ! AreSamePointApprox(pt, m_mTree.at(vEdges[3][c]).GetTopRight())) {
+                  m_pSrfBz->GetPointD1D2( pt.x / SBZ_TREG_COEFF, pt.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3d) ;
+                  mPLEdges.back().back().AddUPoint( nPtCount, pt3d) ;
+                  ++ nPtCount ;
+               }
+               mPLEdges.back().back().AddUPoint( nPtCount, m_mVert.at(vEdges[3][c])[2]) ;
+               ++ nPtCount ;
+            }
+         }
+      }
+   }
+   // se la superficie è trimmata ricostruisco dai loop splittati ricostruiti durante il TraceLoop
+   else {
+      // per ogni edge creo le compo che compongono l'edge dopo i trim ( possono essere più compo separate tra loro)
+      for ( int i = 0 ; i < 4 ; ++i) {
+         mPLEdges.emplace_back() ;
+         INTVECTOR vId ;
+         Point3d ptNear = m_mTree.at(-1).GetBottomLeft() ;
+         while( m_vCEdge2D[i].second.GetChainFromNear(ptNear, false, vId) ) {
+            PolyLine pl3D ;
+            int nInd = abs( vId[0]) - 1 ;
+            Point3d pt2D = m_vCEdge2D[i].first[nInd].first ;
+            Point3d pt3D ; m_pSrfBz->GetPointD1D2( pt2D.x / SBZ_TREG_COEFF, pt2D.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3D) ;
+            pl3D.AddUPoint( 0, pt3D) ;
+            int nCount = 1 ;
+            for ( int j = 1 ; j < int( vId.size()) ; ++j) {
+               nInd = abs( vId[j]) - 1 ;
+               pt2D = m_vCEdge2D[i].first[nInd].second ;
+               m_pSrfBz->GetPointD1D2( pt2D.x / SBZ_TREG_COEFF, pt2D.y / SBZ_TREG_COEFF, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, pt3D) ;
+               if ( pl3D.AddUPoint( nCount, pt3D))
+                  ++ nCount ;
+            }
+            // qui devo fare dei controlli prima di aggiungere questa polyline?
+            mPLEdges[i].emplace_back( pl3D) ; 
+         }
+      }
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Tree::AddCutsToRoot( POLYLINEVECTOR& vCuts)
+{
+   // questa funzione dà per scontato di stare lavorando sulla root di uno spazio parametrico di cui si sta solamente calcolando 
+   // il Contour. La funzione da chiamare dopo questa è la CreateCellContour.
+   // i tagli sono sempre delle linee che tagliano da parte a parte la cella, quindi sono curve aperte
+   if ( m_mTree.size() > 1)
+      return false ;
+   int nRoot = -1 ;
+   for ( int i = 0 ; i < int( vCuts.size()); ++i) {
+      PolyLine pl = vCuts.at( i) ;
+      m_mTree.at( nRoot).m_vInters.emplace_back() ;
+      Point3d pt ; pl.GetFirstPoint( pt) ; 
+      int nEdgeIn ;
+      // se non trovo il primo punto esattamente su un lato, estendo il primo tratto della polyline all'inditro finchè trovo un'intersezione con un lato
+      // questa intersezione diventa il nuovo primo punto del vettore intersezione
+      if ( ! OnWhichEdge(nRoot, pt, nEdgeIn) ) {
+         Point3d ptSecond ; pl.GetNextPoint( ptSecond) ;
+         PtrOwner<ICurveLine> pCL( CreateCurveLine()) ; pCL->SetPVL( ptSecond, pt - ptSecond, 1e6) ;
+         PtrOwner<ICurveLine> pCL0( CreateCurveLine()) ; pCL0->Set( m_mTree.at(-1).GetTopRight(), m_mTree.at(-1).GetTopLeft()) ;
+         PtrOwner<ICurveLine> pCL1( CreateCurveLine()) ; pCL1->Set( m_mTree.at(-1).GetTopLeft(), m_mTree.at(-1).GetBottomLeft()) ;
+         PtrOwner<ICurveLine> pCL2( CreateCurveLine()) ; pCL2->Set( m_mTree.at(-1).GetBottomLeft(), m_mTree.at(-1).GetBottomRight()) ;
+         PtrOwner<ICurveLine> pCL3( CreateCurveLine()) ; pCL3->Set( m_mTree.at(-1).GetBottomRight(), m_mTree.at(-1).GetTopRight()) ;
+         IntersCurveCurve icc0( *pCL, *pCL0) ;
+         IntersCurveCurve icc1( *pCL, *pCL1) ;
+         IntersCurveCurve icc2( *pCL, *pCL2) ;
+         IntersCurveCurve icc3( *pCL, *pCL3) ;
+         IntCrvCrvInfo iccInfo ;
+         if (icc0.GetIntersCount() != 0)
+            icc0.GetIntCrvCrvInfo( 0, iccInfo) ;
+         else if (icc1.GetIntersCount() != 0)
+            icc1.GetIntCrvCrvInfo( 0, iccInfo) ;
+         else if (icc2.GetIntersCount() != 0)
+            icc2.GetIntCrvCrvInfo( 0, iccInfo) ;
+         else if (icc3.GetIntersCount() != 0)
+            icc3.GetIntCrvCrvInfo( 0, iccInfo) ;
+         pt = iccInfo.IciA[0].ptI ;
+         if ( ! OnWhichEdge(nRoot, pt, nEdgeIn))
+            return false ;
+      }
+      m_mTree.at( nRoot).m_vInters.back().nIn = nEdgeIn ;
+      PNTVECTOR vInters ;
+      vInters.emplace_back( pt) ;
+      while ( pl.GetNextPoint( pt))
+         vInters.emplace_back( pt) ;
+      pl.GetLastPoint( pt) ;
+      int nEdgeOut ;
+      // se non trovo l'ultimo punto esattamente su un lato, estendo l'ultimo tratto della polyline in avnti finchè trovo un'intersezione con un lato
+      // questa intersezione diventa il nuovo ultimo punto del vettore intersezione
+      if ( ! OnWhichEdge(nRoot, pt, nEdgeOut) ) {
+         Point3d ptSecondToLast ; pl.GetNextPoint( ptSecondToLast) ;
+         PtrOwner<ICurveLine> pCL( CreateCurveLine()) ; pCL->SetPVL( ptSecondToLast, pt - ptSecondToLast, 1e6) ;
+         PtrOwner<ICurveLine> pCL0( CreateCurveLine()) ; pCL0->Set( m_mTree.at(-1).GetTopRight(), m_mTree.at(-1).GetTopLeft()) ;
+         PtrOwner<ICurveLine> pCL1( CreateCurveLine()) ; pCL1->Set( m_mTree.at(-1).GetTopLeft(), m_mTree.at(-1).GetBottomLeft()) ;
+         PtrOwner<ICurveLine> pCL2( CreateCurveLine()) ; pCL2->Set( m_mTree.at(-1).GetBottomLeft(), m_mTree.at(-1).GetBottomRight()) ;
+         PtrOwner<ICurveLine> pCL3( CreateCurveLine()) ; pCL3->Set( m_mTree.at(-1).GetBottomRight(), m_mTree.at(-1).GetTopRight()) ;
+         IntersCurveCurve icc0( *pCL, *pCL0) ;
+         IntersCurveCurve icc1( *pCL, *pCL1) ;
+         IntersCurveCurve icc2( *pCL, *pCL2) ;
+         IntersCurveCurve icc3( *pCL, *pCL3) ;
+         IntCrvCrvInfo iccInfo ;
+         if (icc0.GetIntersCount() != 0)
+            icc0.GetIntCrvCrvInfo( 0, iccInfo) ;
+         else if (icc1.GetIntersCount() != 0)
+            icc1.GetIntCrvCrvInfo( 0, iccInfo) ;
+         else if (icc2.GetIntersCount() != 0)
+            icc2.GetIntCrvCrvInfo( 0, iccInfo) ;
+         else if (icc3.GetIntersCount() != 0)
+            icc3.GetIntCrvCrvInfo( 0, iccInfo) ;
+         pt = iccInfo.IciA[0].ptI ;
+         vInters.pop_back() ;
+         vInters.emplace_back( pt) ;
+         if ( ! OnWhichEdge(nRoot, pt, nEdgeOut))
+            return false ;
+      }
+      m_mTree.at( nRoot).m_vInters.back().vpt = vInters ;
+      m_mTree.at( nRoot).m_vInters.back().nOut = nEdgeOut ;
+   }
+   // chiamo una funzione per renderli coerenti
+   AdjustCuts() ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Tree::AdjustCuts( void)
+{
+   if ( int( m_mTree.at( -1).m_vInters.size()) == 1)
+      return true ;
+   // li riordino per ordine di quali taglio incontrerei percorrendo il bordo della cella a partire da ptTR
+   sort( m_mTree.at( -1).m_vInters.begin(), m_mTree.at( -1).m_vInters.end(), [](Inters& a, Inters& b){ return Inters::FirstEncounter(a,b) ;}) ;
+   // ora controllo che le intersezioni che trovo siano ingressi alternati ad uscite, sennò inverto l'intersezione
+   bool bPreviousWasStart =  m_mTree.at( -1).m_vInters.at(0).bSortedbyStart ;
+   for ( int i = 0 ; i < int(  m_mTree.at( -1).m_vInters.size()); ++i) {
+      if ( m_mTree.at( -1).m_vInters.at(i).bSortedbyStart == bPreviousWasStart) {
+         reverse( m_mTree.at( -1).m_vInters.at(i).vpt.begin(), m_mTree.at( -1).m_vInters.at(i).vpt.end()) ;
+         int nEdgeOutNew = m_mTree.at( -1).m_vInters.at(i).nIn ;
+         m_mTree.at( -1).m_vInters.at(i).nIn = m_mTree.at( -1).m_vInters.at(i).nOut ;
+         m_mTree.at( -1).m_vInters.at(i).nOut = nEdgeOutNew ;
+         bPreviousWasStart = m_mTree.at( -1).m_vInters.at(i).bSortedbyStart ;
+      }
+      else
+         bPreviousWasStart = ! m_mTree.at( -1).m_vInters.at(i).bSortedbyStart ;
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Tree::CreateCellContour( POLYLINEMATRIX& vPolygons)
+{
+   // questa funzione è pensata per essere chiamata dopo la AddCutsToRoot, per creare il poligono di un'unica cella a cui sono stati aggiunti dei tagli
+   if ( m_mTree.size() > 1)
+      return false ;
+   int nRoot = -1 ;
+   // preparo tutto per poter chiamare la createCellPolygon
+   m_vnLeaves.push_back( nRoot) ;
+   INTVECTOR vToCheck( (int) m_mTree.at(nRoot).m_vInters.size()) ;
+   generate_n( vToCheck.begin(), (int) m_mTree.at(nRoot).m_vInters.size(), generator()) ;
+   int nPoly = 0 ;
+   INTVECTOR vnParentChunk ;
+   PolyLine pl ;
+   pl.AddUPoint(0, m_mTree.at(nRoot).GetTopRight()) ;
+   pl.AddUPoint(1, m_mTree.at(nRoot).GetTopLeft()) ;
+   pl.AddUPoint(2, m_mTree.at(nRoot).GetBottomLeft()) ;
+   pl.AddUPoint(3, m_mTree.at(nRoot).GetBottomRight()) ;
+   pl.Close() ;
+   // ora posso creare il poligono della cella con i tagli
+   while( (int)vToCheck.size() != 0) {
+      int nPolyBefore = nPoly ;
+      CreateCellPolygons( 0, vPolygons, vToCheck, nPoly, vnParentChunk, pl) ;
+      if ( nPolyBefore == nPoly)
+         break ;
+   }
+   return true ;
+}

Tree.h

@@ -18,6 +18,7 @@
 #include "GeoConst.h"
 #include "CurveLine.h"
 #include "/EgtDev/Include/EGkPolyLine.h"
+#include "/EgtDev/Include/EGkChainCurves.h"
 #include <map>
 
 //----------------------------------------------------------------------------
@@ -27,11 +28,12 @@ struct Inters {
    int nOut ;
    bool bCCW ;
    int nChunk ;
+   bool bSortedbyStart ;
    // riordino le intersezioni per lato in senso antiorario dal top
-   // se ho pi� intersezioni che entrano in un lato le riordino considerando che percorro i lati in senso antiorario a partire da ptTR
+   // se ho più intersezioni che entrano in un lato le riordino considerando che percorro i lati in senso antiorario a partire da ptTR
    bool operator < ( Inters& b)
    {
-      // trovo in che ordine stanno i due strat, tenendo conto anche della possibilit� che siano vertici
+      // trovo in che ordine stanno i due start, tenendo conto anche della possibilità che siano vertici
       INTVECTOR vEdges = { 7, 0, 4, 1, 5, 2, 6, 3} ;
       const auto iter1 = find( vEdges.begin(), vEdges.end(), nIn) ;
       int nPos1 = std::distance( vEdges.begin(), iter1) ;
@@ -52,7 +54,7 @@ struct Inters {
          pl.Close() ;
          pl.GetAreaXY( dAreaB) ;
       }
-      // se nIn � un vertice sistemo il valore
+      // se nIn è un vertice sistemo il valore
       int nEdgeIn = nIn ;
       if ( nIn > 3)
          nEdgeIn = nIn - 4 ;
@@ -63,6 +65,67 @@ struct Inters {
                ( bEqIn  &&  nEdgeIn == 2  &&  vpt[0].x < b.vpt[0].x)  ||
                ( bEqIn  &&  nEdgeIn == 3  &&  vpt[0].y < b.vpt[0].y)) ;
    }
+
+   static bool FirstEncounter ( Inters& a, Inters& b)
+   {
+      // riordino in base al lato toccato, o dall'uscita o  dall'ingresso, che viene prima.
+      // ottengo l'ordine che avrei percorrendo il bordo da ptTR e considerando i loop che incontro, indipendentemente se li incontro nel punto di uscita o ingresso
+      // nell'intersezione salvo se il taglio è stato ordinato guardando l'ingresso o l'uscita
+      INTVECTOR vEdges = { 7, 0, 4, 1, 5, 2, 6, 3} ;
+      // trovo i lati di ingresso e uscita
+      const auto iter1 = find( vEdges.begin(), vEdges.end(), a.nIn) ;
+      int nPos1 = std::distance( vEdges.begin(), iter1) ;
+      const auto iter2 = find( vEdges.begin(), vEdges.end(), a.nOut) ;
+      int nPos2 = std::distance( vEdges.begin(), iter2) ;
+      const auto iter3 = find( vEdges.begin(), vEdges.end(), b.nIn) ;
+      int nPos3 = std::distance( vEdges.begin(), iter3) ;
+      const auto iter4 = find( vEdges.begin(), vEdges.end(), b.nOut) ;
+      int nPos4 = std::distance( vEdges.begin(), iter4) ;
+      int nFirstA = 0 ;
+      int nFirstB = 0 ;
+      // salvo l'indice del primo punto dell'intersezione che ho incontrato scorrendo il bordo da ptTR
+      // salvo il lato che viene prima confrontando ingresso e uscita
+      if ( nPos2 < nPos1) {
+         nPos1 = nPos2 ;
+         nFirstA = int( a.vpt.size()) - 1 ;
+      }
+      // se ingresso e uscita sono sullo stesso lato allora confronto le coordinate per capire se viene prima l'ingresso o l'uscita
+      else if ( nPos2 == nPos1 ) {
+         if ( nPos1 == 0 )
+            nFirstA = a.vpt[0].x > a.vpt.back().x ? 0 : ( int( a.vpt.size()) - 1) ;
+         else if ( nPos1 == 1 )
+            nFirstA = a.vpt[0].y > a.vpt.back().y ? 0 : ( int( a.vpt.size()) - 1) ;
+         else if ( nPos1 == 2 )
+            nFirstA = a.vpt[0].x < a.vpt.back().x ? 0 : ( int( a.vpt.size()) - 1) ;
+         else if ( nPos1 == 3 )
+            nFirstA = a.vpt[0].y < a.vpt.back().y ? 0 : ( int( a.vpt.size()) - 1) ;
+      }
+      if ( nPos4 < nPos3) {
+         nPos3 = nPos4 ;
+         nFirstB = int( b.vpt.size()) - 1 ;
+      }
+      else if ( nPos4 == nPos3 ) {
+         if ( nPos3 == 0 )
+            nFirstB = b.vpt[0].x > b.vpt.back().x ? 0 : ( int( b.vpt.size()) - 1) ;
+         else if ( nPos3 == 1 )
+            nFirstB = b.vpt[0].y > b.vpt.back().y ? 0 : ( int( b.vpt.size()) - 1) ;
+         else if ( nPos3 == 2 )
+            nFirstB = b.vpt[0].x < b.vpt.back().x ? 0 : ( int( b.vpt.size()) - 1) ;
+         else if ( nPos3 == 3 )
+            nFirstB = b.vpt[0].y < b.vpt.back().y ? 0 : ( int( b.vpt.size()) - 1) ;
+      }
+      a.bSortedbyStart = nFirstA == 0 ;
+      b.bSortedbyStart = nFirstB == 0 ;
+      // se sono diversi ritorno il confronto
+      if ( nPos1 != nPos3)
+         return nPos1 < nPos3 ;
+      // se sono uguali devo valutare il punto di intersezione
+       return ( nPos1 == 0  &&  a.vpt[nFirstA].x > b.vpt[nFirstB].x)  ||
+              ( nPos1 == 1  &&  a.vpt[nFirstA].y > b.vpt[nFirstB].y)  ||
+              ( nPos1 == 2  &&  a.vpt[nFirstA].x < b.vpt[nFirstB].x)  ||
+              ( nPos1 == 3  &&  a.vpt[nFirstA].y < b.vpt[nFirstB].y) ;
+   }
+
    bool operator == ( Inters& b)
    {
       return AreSamePointExact( vpt[0], b.vpt[0]) ;
@@ -73,8 +136,8 @@ struct Inters {
    }
 } ;
 // nIn e nOut sono flag che indicano da quale lato ho l'ingresso e l'uscita a partire dal lato top in senso antiorario
-// oltre il 3 sono le celle adiacenti in diagonale al vertice-> 4 corrisponde al ptTl e da l� in senso antiorario
-// -1 se la curva � sempre dentro la cella
+// oltre il 3 sono le celle adiacenti in diagonale al vertice-> 4 corrisponde al ptTl e da lì in senso antiorario
+// -1 se la curva è sempre dentro la cella
 
 //----------------------------------------------------------------------------
 class Cell
@@ -116,6 +179,10 @@ class Cell
               { return m_ptPbl ; }
       Point3d GetTopRight( void) const
               { return m_ptPtr ; }
+      Point3d GetTopLeft( void) const
+              { return Point3d( m_ptPbl.x, m_ptPtr.y) ; }
+      Point3d GetBottomRight( void) const
+              { return Point3d( m_ptPtr.x, m_ptPbl.y); }
       double GetSplitValue( void) const
               { return m_dSplit ; }
       bool IsSplitVert( void) const                 // se true la cella verrebbe splittata verticalmente, senn� orizzontalmente
@@ -138,24 +205,24 @@ class Cell
       int                  m_nLeft ;            // cella adiacente al lato left
       int                  m_nRight ;           // cella adiacente al lato right
       int                  m_nParent ;          // cella genitore
-      int                  m_nDepth ;           // profondit� della cella rispetto a root
-      double               m_dSplit ;           // parametro a cui � stata splittata la cella
+      int                  m_nDepth ;           // profondità della cella rispetto a root
+      double               m_dSplit ;           // parametro a cui è stata splittata la cella
       int                  m_nChild1 ;          // prima cella figlio
       int                  m_nChild2 ;          // seconda cella figlio
       int                  m_nFlag ;            // falg che indica la caratterizzazione della cella rispetto ai loop di trim
                                                 // 0 esterna, 1 intersecata, 2 contiene un loop, 3 intersecata e contenente un loop, 4 contenuta in un loop
-      int                  m_nFlag2 ;           // falg che indica se la cella � stata attraversata durante l'ultima fase del labelling
-      int                  m_nRightEdgeIn ;     // 0 right edge fuori, 1 right edge dentro, 2 met� e met�
-      bool                 m_bOnLeftEdge ;      // flag che indica se la cella � sul lato sinistro ( per superfici chiuse sul parametro U)
-      bool                 m_bOnTopEdge ;       // flag che indica se la cella � sul lato top ( per superfici chiuse sul parametro V)
+      int                  m_nFlag2 ;           // falg che indica se la cella è stata attraversata durante l'ultima fase del labelling
+      int                  m_nRightEdgeIn ;     // 0 right edge fuori, 1 right edge dentro, 2 metà e metà
+      bool                 m_bOnLeftEdge ;      // flag che indica se la cella è sul lato sinistro ( per superfici chiuse sul parametro U)
+      bool                 m_bOnTopEdge ;       // flag che indica se la cella è sul lato top ( per superfici chiuse sul parametro V)
       std::vector<Inters>  m_vInters ;          // vettore delle intersezioni della cella con i loop di trim
-                                                // ogni elemento del vettore � l'insieme dei punti che caratterizza un atrtaversamento della cella
+                                                // ogni elemento del vettore è l'insieme dei punti che caratterizza un attraversamento della cella
 
    private :
       Point3d          m_ptPbl ;            // punto bottom left
       Point3d          m_ptPtr ;            // punto top right
-      bool             m_bProcessed ;       // flag che indica se la cella � stata processata
-      bool             m_bSplitVert ;       // flag che indica in quale direzione � stata divisa la cella
+      bool             m_bProcessed ;       // flag che indica se la cella è stata processata
+      bool             m_bSplitVert ;       // flag che indica in quale direzione è stata divisa la cella
 } ;
 
 //----------------------------------------------------------------------------
@@ -165,18 +232,29 @@ class Tree
       ~Tree( void) ;
       Tree( void) ;
       Tree ( const SurfBezier* pSrfBz, bool bSplitPatches = true, const Point3d& ptMin = ORIG, const Point3d& ptMax = ORIG) ;
+      Tree( const Point3d ptBl, const Point3d ptTr) ; // creatore da usare solo nel caso in cui si voglia aggiungere tagli ad un'unica cella e del risultato ottenere il contorno 
       void SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches = true, const Point3d& ptMin = ORIG, const Point3d& ptMax = ORIG) ;
       bool GetIndependentTrees( BIPNTVECTOR& vTrees) ;                             // calcolo la suddivisione della superficie solo sulle singole bbox dei loop di trim ( unendo quelli vicini)
       bool BuildTree( double dLinTol = LIN_TOL_STD, double dSideMin = 1, double dSideMax = INFINITO) ; // dSideMax � il massimo per la dimensione maggiore di un triangolo della trimesh
                                                                                                        // dSideMin � lunghezza minima del lato di una cella nello spazio reale
       bool BuildTree_test( double dLinTol = LIN_TOL_STD, double dSideMin = 1, double dSideMax = INFINITO) ;
       bool GetPolygons( POLYLINEMATRIX& vPolygons) ;
-      bool GetPolygonsBasic( POLYLINEVECTOR& vPolygons) ;                                              // restituisce il poligono corrispondente ad ogni cella foglia dell'albero
+      bool GetPolygonsBasic( POLYLINEVECTOR& vPolygons, INTVECTOR vCells = {}) ;                           // 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
       bool GetLeaves ( std::vector<Cell>& vLeaves) const ;  // restituisce gli indici delle foglie nell'albero
+      bool GetEdges3D ( POLYLINEMATRIX& mPLEdges) ;  // restituisce gli edge 3D come polyline
+      bool GetSplitLoops( POLYLINEVECTOR& vPl) const // funzione che restituisce i loop splitatti ai confini delle celle
+            { for ( int i = 0 ; i < int( m_vPlLoop2D.size()); ++i) vPl.emplace_back( m_vPlLoop2D[i]) ; return true ; };
       void SetTestMode( void) { m_bTestMode = true ;} ;        // attivando la test mode, per la costruzione dell'albero viene usata la funzione BuiltTree_test e viene corretta di conseguenza la FindCell
+      // 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
+      bool IsClosedU( void) const { return m_bClosedU ;} ;        // funzione che riferisce se la superficie è chiusa lungo il parametro U
+      bool IsClosedV( void) const { return m_bClosedV ;} ;        // funzione che riferisce se la superficie è chiusa lungo il parametro V
+      std::vector<bool> GetPoles( void) { return m_vbPole ;} ; // funzione che restituisce i flag che indicano se i lati sono collassati in dei poli
 
    private :
+      bool LimitLoop( PolyLine& pl, POLYLINEVECTOR& vPl) const ;              // funzione che limita i loop di trim allo spazio parametrico
       bool Split( int nId, double dSplitValue) ;                              // funzione di split di una cella al parametro indicato nella direzione data da bVert
       bool Split( int nId) ;                                                  // funzione di split di una cella dell'albero a met� nella direzione data da bVert
       void Balance( void) ;                                                       // creo rami in modo che tutte tutte le foglie abbiano come adiacenti foglie ad una profondit� di +- 1
@@ -205,19 +283,23 @@ class Tree
       bool CategorizeCell( int nId) ;  // categorizza la cella in base al flag m_nFlag (dentro, fuori, intersecata)
       bool CheckIfBetween( const Inters& inA, const Inters& inB) const ; // / controllo se inB è compreso tra l'end e lo start di inA (in senso CCW)
       bool OnWhichEdge( int nId, const Point3d& ptToAssign, int& nEdge) const ;  // indica a quale edge o vertice il punto è vicino entro EPS_SMALL
+      bool AdjustCuts( void) ;
+      bool UpdateSplitLoop( PolyLine& pl, int& nCount, Point3d& pt) ;
+
 
    private :
       const SurfBezier*           m_pSrfBz ;           // superficie di bezier
       DBLVECTOR                   m_vDim ;             // distanze tra i vertici della superficie di bezier in 3d in ordine antiorario a partire da ptP00
       bool                        m_bTrimmed ;         // superficie trimmata
-      INTMATRIX                   m_vChunk ;           // elenco dei loop divisi per chunk
+      //INTMATRIX                   m_vChunk ;           // elenco dei loop divisi per chunk
       std::map<int,int>           m_mChunk ;           // mappa in cui vengono salvati chunk di appartenza per ogni loop di trim
       ICURVEPOVECTOR              m_vLoop ;            // curve di loop
-      std::vector<std::tuple<PolyLine,bool>> m_vPlApprox ;  // vettore contenente le approssimazioni dei loop
+      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
       bool                        m_bClosedV ;         // superficie chiusa lungo il parametro V
+      BOOLVECTOR                  m_vbPole ;           // vettore che indica se i vari lati sono collassati in poli ( indici riferiti all'ordine degli edge)
       bool                        m_bSplitPatches ;    // flag che indica se le patches sono state divise prima della creazione dell'albero
       int                         m_nDegU ;            // grado della superficie nel parametro U
       int                         m_nDegV ;            // grado della superficie nel parametro V
@@ -229,4 +311,6 @@ class Tree
       INTVECTOR                   m_vnLeaves ;         // vettore delle foglie
       INTVECTOR                   m_vnParents ;        // vettore delle celle ottenute dalla divisione preliminare in singole patch
       bool                        m_bTestMode ;        // bool che indica se la test mode è attiva
+      POLYLINEVECTOR              m_vPlLoop2D ;        // vettore che contiene le polyline che rappresentano i loop di trim tenendo conto della divisione in celle
+      std::vector<std::pair<BIPNTVECTOR, ChainCurves>>    m_vCEdge2D ;        // vettore che le chain che rappresentano ciò che resta degli edge originali, tenendo conto dei trim.
 } ;

Triangulate.cpp

@@ -1225,7 +1225,7 @@ Triangulate::GetOuterPntToJoin( const PNTVECTOR& vPt, const Point3d& ptP, int& n
                dMinDist = dZ - ptP.z ;
                nI = ( vPt[i].z >= vPt[j].z) ? i : j ;
                double dY = vPt[i].y + ( vPt[j].y - vPt[i].y) * dCoeff ;
-               ptInt.Set( ptP.y, dY, dZ) ;
+               ptInt.Set( ptP.x, dY, dZ) ;
             }
          }
          break ;

Vector3d.cpp

@@ -169,6 +169,10 @@ Vector3d::ToSpherical( double* pdLen, double* pdAngVertDeg, double* pdAngOrizzDe
 bool
 Vector3d::Normalize( double dEps)
 {
+  // verifico validità
+   if ( ! IsValid())
+      return false ;
+
   // se già normalizzato, ok
    double dSqLen = x * x + y * y + z * z ;
    if ( abs( 1.0 - dSqLen) < ( 2 * 1000 * DBL_EPSILON))

VolZmap.cpp

@@ -14,18 +14,21 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "VolZmap.h"
-#include "DistPointLine.h"
 #include "GeoObjFactory.h"
+#include "GdbGeo.h"
 #include "NgeWriter.h"
 #include "NgeReader.h"
+#include "DistPointLine.h"
 #include "GeoConst.h"
 #include "/EgtDev/Include/EGkIntersLinePlane.h"
+#include "/EgtDev/Include/EGkIntersLineSurfTm.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
 #include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include <thread>
 #include <future>
+#include "IntersLineBox.h"
 
 using namespace std ;
 
@@ -34,7 +37,8 @@ GEOOBJ_REGISTER( VOL_ZMAP, NGE_V_ZMP, VolZmap) ;
 
 //----------------------------------------------------------------------------
 VolZmap::VolZmap(void)
-   : m_nStatus( TO_VERIFY), m_nTempProp{0,0}, m_dTempParam{0.0,0.0}, m_dStep( 10.0), m_nMapNum( 0), m_nShape( GENERIC), m_nVoxNumPerBlock( N_VOXBLOCK),
+   : m_nStatus( TO_VERIFY), m_nTempProp{0,0}, m_dTempParam{0.0,0.0}, m_bShowEdges( false),
+     m_dStep( 10.0), m_nMapNum( 0), m_nShape( GENERIC), m_nVoxNumPerBlock( N_VOXBLOCK),
      m_nDexVoxRatio( 1), m_nNumBlock( 0), m_nConnectedCompoCount( 0), m_nCurrTool( -1),
      m_dToolLinTol( LIN_TOL_STD), m_dToolAngTolDeg( ANG_TOL_APPROX_DEG)
 {
@@ -60,8 +64,16 @@ bool
 VolZmap::Clear( void)
 {
    m_nStatus = TO_VERIFY ;
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
+   m_dTempParam[0] = 0.0 ;
+   m_dTempParam[1] = 0.0 ;
+   m_bShowEdges = false ;
+   m_dStep = 10.0 ;
    m_nMapNum = 0 ;
    m_nShape = GENERIC ;
+   m_nVoxNumPerBlock = N_VOXBLOCK ;
+   m_nDexVoxRatio = 1 ;
    m_nNumBlock = 0 ;
    m_nConnectedCompoCount = 0 ;
    m_MapFrame.Reset() ;
@@ -73,21 +85,64 @@ VolZmap::Clear( void)
       m_dMaxZ[i] = 0 ;
       m_Values[i].clear() ;
    }
-   m_dStep = EPS_SMALL ;
-   m_nTempProp[0] = 0 ;
-   m_nTempProp[1] = 0 ;
-   m_dTempParam[0] = 0.0 ;
-   m_dTempParam[1] = 0.0 ;
    m_vTool.resize( 1) ;
    m_nCurrTool = 0 ;
    m_dToolLinTol = LIN_TOL_STD ;
    m_dToolAngTolDeg = ANG_TOL_APPROX_DEG ;
-  // imposto ricalcolo della grafica
-   m_OGrMgr.Reset() ;
+  // imposto ri-creazione della grafica
+   m_OGrMgr.Clear() ;
 
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+VolZmap::IsEmpty( void)
+{
+  // controllo validità
+   if ( ! IsValid())
+      return false ;
+
+   bool bIsEmpty = true ; // flag
+
+  // ciclo sul numero di mappe
+   for ( int i = 0 ; bIsEmpty  &&   i < m_nMapNum ; ++ i) {
+     // ciclo sulle dimensioni di ogni mappa
+      for ( int j = 0 ; bIsEmpty  &&  j < m_nDim[i] ; ++ j) {
+        // controllo se esiste un tratto di dexel non vuoto
+         bIsEmpty = ( int( m_Values[i][j].size()) == 1  &&
+                    abs( m_Values[i][j][0].dMin) < EPS_ZERO  &&
+                    m_Values[i][j][0].nToolMin == 0  &&
+                    m_Values[i][j][0].nCompo == 1) ;
+
+         if ( bIsEmpty) {
+            switch ( i) {
+               case 0 :
+                  bIsEmpty = ( m_Values[i][j][0].vtMinN.IsZminus()  &&
+                             abs( m_Values[i][j][0].dMax) < EPS_ZERO  &&
+                             m_Values[i][j][0].vtMaxN.IsZplus()  &&
+                             m_Values[i][j][0].nToolMax == 0) ;
+                  break ;
+               case 1 :
+                  bIsEmpty = ( m_Values[i][j][0].vtMinN.IsZminus()  &&
+                             abs( m_Values[i][j][0].dMax) < EPS_ZERO  &&
+                             m_Values[i][j][0].vtMaxN.IsXplus()  &&
+                             m_Values[i][j][0].nToolMax == 0 ) ;
+                  break ;
+               case 2 :
+                  bIsEmpty = ( m_Values[i][j][0].vtMinN.IsYminus()  &&
+                             abs( m_Values[i][j][0].dMax) < EPS_ZERO  &&
+                             m_Values[i][j][0].vtMaxN.IsYplus()  &&
+                             m_Values[i][j][0].nToolMax == 0 ) ;
+                  break ;
+            }
+         }
+      }
+   }
+
+   return bIsEmpty ;
+}
+
 //----------------------------------------------------------------------------
 VolZmap*
 VolZmap::Clone( void) const
@@ -150,6 +205,7 @@ VolZmap::CopyFrom( const VolZmap& vzmSrc)
    m_nTempProp[1] = vzmSrc.m_nTempProp[1] ;
    m_dTempParam[0] = vzmSrc.m_dTempParam[0] ;
    m_dTempParam[1] = vzmSrc.m_dTempParam[1] ;
+   m_bShowEdges = vzmSrc.m_bShowEdges ;
 
   // dimensiono membri legati ai blocchi
    m_BlockToUpdate = vzmSrc.m_BlockToUpdate ;
@@ -175,7 +231,7 @@ VolZmap::CopyFrom( const VolZmap& vzmSrc)
 bool
 VolZmap::ResetGraphics( void)
 {
-   m_OGrMgr.Reset() ;
+   m_OGrMgr.Clear() ;
    for ( int nCount = 0 ; nCount < m_nNumBlock ; ++ nCount)
       m_BlockToUpdate[nCount] = true ;
    return true ;
@@ -318,6 +374,27 @@ VolZmap::Save( NgeWriter& ngeOut) const
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+VolZmap::PreSave( GdbGeo& Wrapper) const
+{
+  // salvo il flag di visualizzazione spigoli vivi anche in shading (default false)
+   if ( m_bShowEdges)
+      Wrapper.SetInfo( GDB_SI_SHOWEDGES, true) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+VolZmap::PostSave( GdbGeo& Wrapper) const
+{
+  // elimino eventuali info aggiunte nella PreSave
+   Wrapper.RemoveInfo( GDB_SI_SHOWEDGES) ;
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------       
 bool
 VolZmap::Load( NgeReader& ngeIn)
@@ -430,6 +507,20 @@ VolZmap::Load( NgeReader& ngeIn)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+VolZmap::PostLoad( GdbGeo& Wrapper)
+{
+  // recupero eventuale flag di visualizzazione spigoli vivi anche in shading
+   bool bVal ;
+   if ( Wrapper.GetInfo( GDB_SI_SHOWEDGES, bVal)) {
+      m_bShowEdges = bVal ;
+      Wrapper.RemoveInfo( GDB_SI_SHOWEDGES) ;
+   }
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 VolZmap::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
@@ -1616,16 +1707,144 @@ VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+VolZmap::AddSrfTm( const ISurfTriMesh* pStm)
+{
+  // controllo sulla superficie
+   double dVol ;
+   if ( pStm == nullptr  ||  ! pStm->IsValid()  ||  ! pStm->IsClosed()  ||
+      ! pStm->GetVolume( dVol)  ||  dVol < 0)
+      return false ;
+
+  // controllo se il Box3d della superficie si interseca con il Box3d dello Zmap corrente
+   BBox3d BBox_stm ;
+   if ( ! pStm->GetLocalBBox( BBox_stm))
+      return false ;
+   BBox3d BBox_curr ;
+   if ( ! GetLocalBBox( BBox_curr))
+      return false ;
+   BBox3d BBox_inters ;
+   if ( BBox_stm.FindIntersection( BBox_curr, BBox_inters)  &&  BBox_inters.IsEmpty())
+      return true ; // se non ci sono intersezioni, la superficie non influenza lo Zmap
+
+  // determino i punti estremi del bounding box corrente
+   BBox3d BBoxCurr ;
+   if ( ! GetLocalBBox( BBoxCurr))
+      return false ;
+   Point3d ptMapOrig, ptMapEnd ;
+   BBoxCurr.GetMinMax( ptMapOrig, ptMapEnd) ;
+  // determino le dimensioni lineari del BBox
+   Vector3d vtLen = ptMapEnd - ptMapOrig ;
+
+  // creo uno Zmap vuoto per la TriMesh
+   PtrOwner<VolZmap> pZmapStm( CreateBasicVolZmap()) ;
+   if ( IsNull( pZmapStm)  ||
+        ! pZmapStm->CreateEmptyMap( ptMapOrig, BBoxCurr.GetDimX() + 10 * EPS_SMALL,
+                                               BBoxCurr.GetDimY() + 10 * EPS_SMALL,
+                                               BBoxCurr.GetDimZ() + 10 * EPS_SMALL,
+                                    m_dStep, IsTriDexel()))
+      return false ;
+
+
+  // ciclo sulle griglie
+   bool bCompleted = true ;
+   for ( int g = 0 ; g < pZmapStm->m_nMapNum ; ++ g) {
+     // definisco dei sistemi di riferimento ausiliari
+      Frame3d frMapFrame ;
+      if ( g == 0)
+         frMapFrame = m_MapFrame ;
+      else if ( g == 1)
+         frMapFrame.Set( ptMapOrig, Y_AX, Z_AX, X_AX) ;
+      else if ( g == 2)
+         frMapFrame.Set( ptMapOrig, Z_AX, X_AX, Y_AX) ;
+
+     // oggetto per calcolo massivo intersezioni
+      IntersParLinesSurfTm intPLSTM( frMapFrame, *pStm) ;
+
+     // numero massimo di thread
+      int nThreadMax = max( 1, int( thread::hardware_concurrency()) - 1) ;
+      vector<future<bool>> vRes ;
+      vRes.resize( nThreadMax) ;
+      if ( pZmapStm->m_nNx[g] > pZmapStm->m_nNy[g]) {
+         int nDexNum = pZmapStm->m_nNx[g] / nThreadMax ;
+         int nRemainder = pZmapStm->m_nNx[g] % nThreadMax ;
+         int nInfI = 0 ;
+         int nSupI = 0 ;
+         for ( int nThread = 0 ; nThread < nThreadMax ; ++ nThread) {
+            nInfI = nSupI ;
+            nSupI = nInfI + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
+            vRes[nThread] =  async( launch::async, &VolZmap::CreateMapPart, this, g,
+                                    nInfI, nSupI, 0, pZmapStm->m_nNy[g], ref( vtLen), ref( ptMapOrig), ref( *pStm), ref( intPLSTM)) ;
+         }
+      }
+      else {
+         int nDexNum = pZmapStm->m_nNy[g] / nThreadMax ;
+         int nRemainder = pZmapStm->m_nNy[g] % nThreadMax ;
+         int nInfJ = 0 ;
+         int nSupJ = 0 ;
+         for ( int nThread = 0 ; nThread < nThreadMax ; ++ nThread) {
+            nInfJ = nSupJ ;
+            nSupJ = nInfJ + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
+            vRes[nThread] =  async( launch::async, &VolZmap::CreateMapPart, this, g,
+                                    0, pZmapStm->m_nNx[g], nInfJ, nSupJ, ref( vtLen), ref( ptMapOrig), ref( *pStm), ref( intPLSTM)) ;
+         }
+      }
+
+     // ciclo per attendere che tutti gli async abbiano terminato.
+      int nTerminated = 0 ;
+      while ( nTerminated < nThreadMax) {
+         for ( int nL = 0 ; nL < nThreadMax ; ++ nL) {
+            // Async terminato
+            if ( vRes[nL].valid()  &&  vRes[nL].wait_for( chrono::microseconds{ 1}) == future_status::ready) {
+               ++ nTerminated ;
+               bCompleted = bCompleted  &&  vRes[nL].get() ;
+            }
+         }
+      }
+
+     // bho ( ???????? )
+      if ( ! bCompleted)
+         return false ;
+
+     // aggiungo ora gli intervalli ricavati allo Zmap corrente ( *this)
+     // ciclo sui dexel della mappa
+      for ( int nD = 0 ; nD < int( pZmapStm->m_Values[g].size()) ; ++ nD) {
+        // se spillone vuoto, passo al successivo
+         if ( pZmapStm->m_Values[g][nD].empty())
+            continue ;
+        // indici di spillone
+         int nI = nD % pZmapStm->m_nNx[g] ;
+         int nJ = nD / pZmapStm->m_nNx[g] ;
+        // ciclo sui voxel associati
+         for ( int nV = 0 ; nV < int( pZmapStm->m_Values[g][nD].size()) ; ++ nV) {
+           // estremi del voxel
+            double dMin = pZmapStm->m_Values[g][nD][nV].dMin ;
+            double dMax = pZmapStm->m_Values[g][nD][nV].dMax ;
+           // vettori associati agli estremi
+            Vector3d vtMaxN = pZmapStm->m_Values[g][nD][nV].vtMaxN ;
+            Vector3d vtMinN = pZmapStm->m_Values[g][nD][nV].vtMinN ;
+           // aggiungo l'intervallo                           // per ora... (???)
+            AddIntervals( g, nI, nJ, dMin, dMax, vtMinN, vtMaxN, 0) ;
+         }
+      }
+
+   }
+
+   return true ;
+}
+
+
 //----------------------------------------------------------------------------
 bool
 VolZmap::IsMapPartABox( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, double& dMinZ, double& dMaxZ)
 {
+   if ( ! m_bIsBox)
+      return true ;
    dMinZ = m_dMaxZ[nMap] ;
    dMaxZ = m_dMinZ[nMap] ;
    for ( int i = nInfI ; i < nSupI ; ++ i) {
       for ( int j = nInfJ ; j < nSupJ ; ++ j) {
-         if ( ! m_bIsBox)
-            return true ;
          int n = j * m_nNx[nMap] + i ;
          int nSize = int( m_Values[nMap][n].size()) ;
          if ( nSize > 1)

VolZmap.h

@@ -17,12 +17,15 @@
 #include "GeoObjRW.h"
 #include "Tool.h"
 #include "/EgtDev/Include/EGkVolZmap.h"
-#include "/EgtDev/Include/EGkIntersLineSurfTm.h"
+#include "/EgtDev/Include/EGkIntersLineVolZmap.h"
 #include <unordered_map>
 #include <stack>
 #include <mutex>
 #include <atomic>
 
+// ------------------------- FORWARD -------------------------------------------------------------
+class IntersParLinesSurfTm ;
+
 // ------------------------- STRUTTURE -----------------------------------------------------------
 struct AppliedVector {
    Point3d ptPApp ;
@@ -74,7 +77,9 @@ class VolZmap : public IVolZmap, public IGeoObjRW
    public :                      // IVolZmap
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
       bool Clear( void) override ;
+      bool IsEmpty( void) override ;
       bool Create( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dStep, bool bTriDex) override ;
+      bool CreateEmptyMap( const Point3d& ptO, double dLengthX, double dLengthY, double dLengthZ, double dStep, bool bTriDex) override ;
       bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dStep, bool bTriDex) override ;
       bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex) override ;
       int  GetBlockCount( void) const override ;
@@ -86,8 +91,13 @@ class VolZmap : public IVolZmap, public IGeoObjRW
               { return m_nMapNum == 3 ; }
       bool GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) const override ;
       int  GetResolution( void) const override
-              { return m_nDexVoxRatio ; }   
+              { return m_nDexVoxRatio ; }
       bool ChangeResolution( int nDexVoxRatio) override ;
+      void SetShowEdges( bool bShow) override
+              { m_bShowEdges = bShow ;  // qui è necessario far ricreare la grafica
+                m_OGrMgr.Clear() ; }
+      bool GetShowEdges( void) const override
+              { return m_bShowEdges ; }
       bool SetToolTolerances( double dLinTol, double dAngTolDeg = 90) override ;
       bool SetStdTool( const std::string& sToolName,
                        double dH, double dR, double dCornR, double dCutterH, int nFlag, bool bFirst) override ;
@@ -112,8 +122,6 @@ class VolZmap : public IVolZmap, public IGeoObjRW
                         const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
                         const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe) override ;
       bool GetDepth( const Point3d& ptP, const Vector3d& vtD, double& dInLength, double& dOutLength, bool bExact) const override ;
-      bool GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTOR& vIntersInfo) const override ;
-      bool GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) const override ;
       bool CDeBox( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, bool bPrecise = false) const override ;
       bool CDeSphere( const Point3d& ptCenter, double dRad, double dSafeDist, bool bPrecise = false) const override ;
       bool CDeCylinder( const Frame3d& frCyl, double dR, double dH, double dSafeDist, bool bPrecise = false) const override ;
@@ -134,11 +142,15 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       VolZmap* ClonePart( int nPart) const override ;
       bool RemovePart( int nPart) override ;
       int  GetPartMinDistFromPoint( const Point3d& ptP) const override ;
+      bool AddSrfTm( const ISurfTriMesh* pStm) override ;
 
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
+      bool PreSave( GdbGeo& Wrapper) const override ;
+      bool PostSave( GdbGeo& Wrapper) const override ;
       bool Load( NgeReader& ngeIn) override ;
+      bool PostLoad( GdbGeo& Wrapper) override ;
 
    public :
       VolZmap( void) ;
@@ -149,6 +161,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW
                   { if ( ! CopyFrom( stSrc))
                        LOG_ERROR( GetEGkLogger(), "VolZmap : copy error")
                     return *this ; }
+      bool GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTOR& vIntersInfo) const ;
+      bool GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) const ;
 
    private :
       enum CubeType { VOX_EXTERN = 1,
@@ -189,22 +203,18 @@ class VolZmap : public IVolZmap, public IGeoObjRW
          std::vector<BOOLVECTOR> vbFlipped ;
       } ;
      // Triangoli smooth
-     struct SmoothTriaStruct {
+      struct SmoothTriaStruct {
          int i, j, k ;
          TRIA3DEXVECTOR vTria ;
-     };
-     // Vettore di SharpTriaStruct con sharp feature
-      typedef std::vector<SharpTriaStruct> SharpTriHolder ;
-     // Vettore di SmoothTriaStruct con triangoli smooth
-      typedef std::vector<SmoothTriaStruct> SmoothTriHolder ;
-     // Vettore di SharpTriHolder con sharp feature: il primo indice individua il blocco, il secondo il voxel
-      typedef std::vector<SharpTriHolder> SharpTriaMatrix ;
-     // Vettore di SmoothTriHolder smooth: il primo indice individua il blocco, il secondo il voxel
-      typedef std::vector<SmoothTriHolder> SmoothTriaMatrix ;
+      } ;
+     // Matrice di SharpTriaStruct con sharp feature: il primo indice individua il blocco, il secondo il voxel
+      typedef std::vector<std::vector<SharpTriaStruct>> SharpTriaMatrix ;
+     // Matrice di SmoothTriaStruct con triangoli smooth: il primo indice individua il blocco, il secondo il voxel
+      typedef std::vector<std::vector<SmoothTriaStruct>> SmoothTriaMatrix ;
      // Tavola hash di Voxel
-      typedef std::unordered_map <int, Voxel> VoxelContainer ;
+      typedef std::unordered_map<int, Voxel> VoxelContainer ;
      // Unordered map per la coerenza topologica
-      typedef std::unordered_map <int, bool> InterVoxMatter ;
+      typedef std::unordered_map<int, bool> InterVoxMatter ;
       
    private :
       bool CopyFrom( const VolZmap& clSrc) ;
@@ -404,6 +414,9 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       // Funzione per crezione solido in parallelo
       bool CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, const Vector3d& vtLen, const Point3d& ptMapOrig,
                           const ISurfTriMesh& Surf, IntersParLinesSurfTm& intPLSTM) ;
+      // Funzione per aggiornamento solido in parallelo
+      bool UpdateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, const Vector3d& vtLen, const Point3d& ptMapOrig,
+                          const ISurfTriMesh& Surf, IntersParLinesSurfTm& intPLSTM) ;
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
@@ -416,9 +429,10 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       Status         m_nStatus ;            // stato
       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
       double         m_dStep ;              // passo delle griglie
       int            m_nMapNum ;            // numero di griglie ( 1 o 3)
-      Frame3d        m_MapFrame ;           // riferimento intrinseco dello Zmap
       int            m_nNx[N_MAPS] ;        // dimensione di ciascuna griglia in X
       int            m_nNy[N_MAPS] ;        // dimensione di ciascuna griglia in Y
       int            m_nDim[N_MAPS] ;       // dimensione di ciascuna griglia ( X * Y)
@@ -436,7 +450,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       } ;
       std::vector<std::vector<Data>> m_Values[N_MAPS] ;  // dexel delle 3 griglie
 
-      int m_nShape ;                        // Forma : 0 generica, 1 box, 2 estrusione
+      int m_nShape ;               // Forma : 0 generica, 1 box, 2 estrusione
 
       int m_nVoxNumPerBlock ;      // Numero di voxel per blocco
       int m_nDexVoxRatio ;         // Rapporto dexel voxel
@@ -462,7 +476,6 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       mutable std::vector<InterVoxMatter> m_SliceYZ ;
       mutable std::mutex                  m_SliceMutex ;
 
-      mutable std::atomic<bool>           m_bBreak ;
       std::atomic<bool>                   m_bIsBox ;
 
       int                                 m_nCurrTool ;

VolZmapCalculus.cpp

@@ -2912,8 +2912,9 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
                else if ( nIntType == ILTT_VERT  ||  nIntType == ILTT_EDGE  ||  nIntType == ILTT_IN) {
                   int nNumVox ;  
                   GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
+                  double dCosDN = vtDir * trTria.GetN() ;
                   vIntersInfo.emplace_back( nIntType, ( ptLineTria1 - ptP) * vtDir,
-                                            nNumVox, nB, ptLineTria1, trTria) ;
+                                            nNumVox, nB, trTria, dCosDN, ptLineTria1) ;
                }
               // altrimenti ci sono due intersezioni
                else {
@@ -2921,8 +2922,9 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
                   GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
                   double dP1 = ( ptLineTria1 - ptP) * vtDir ;
                   double dP2 = ( ptLineTria2 - ptP) * vtDir ;
+                  double dCosDN = vtDir * trTria.GetN() ;
                   vIntersInfo.emplace_back( nIntType, ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1),
-                                            nNumVox, nB, ptLineTria1, ptLineTria2, trTria) ;
+                                            nNumVox, nB, trTria, dCosDN, ptLineTria1, ptLineTria2) ;
                }
             }
          }
@@ -2948,8 +2950,9 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
                   else if ( nIntType == ILTT_VERT  ||  nIntType == ILTT_EDGE  ||  nIntType == ILTT_IN) {
                      int nNumVox ;
                      GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
+                     double dCosDN = vtDir * trTria.GetN() ;
                      vIntersInfo.emplace_back( nIntType, ( ptLineTria1 - ptP) * vtDir,
-                                               nNumVox, nB, ptLineTria1, trTria) ;
+                                               nNumVox, nB, trTria, dCosDN, ptLineTria1) ;
                   }
                   // altrimenti ci sono due intersezioni
                   else {
@@ -2957,8 +2960,9 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
                      GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
                      double dP1 = ( ptLineTria1 - ptP) * vtDir ;
                      double dP2 = ( ptLineTria2 - ptP) * vtDir ;
+                     double dCosDN = vtDir * trTria.GetN() ;
                      vIntersInfo.emplace_back( nIntType, ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1),
-                                               nNumVox, nB, ptLineTria1, ptLineTria2, trTria) ;
+                                               nNumVox, nB, trTria, dCosDN, ptLineTria1, ptLineTria2) ;
                   }
                }
             }
@@ -2974,15 +2978,17 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
                continue ;
            // se altrimenti c'è una sola intersezione
             else if ( nIntType == ILTT_VERT  ||  nIntType == ILTT_EDGE  ||  nIntType == ILTT_IN) {
+               double dCosDN = vtDir * trTria.GetN() ;
                vIntersInfo.emplace_back( nIntType, ( ptLineTria1 - ptP) * vtDir,
-                                         -1, nB, ptLineTria1, trTria) ;
+                                         -1, nB, trTria, dCosDN, ptLineTria1) ;
             }
            // altrimenti ci sono due intersezioni
             else {
                double dP1 = ( ptLineTria1 - ptP) * vtDir ;
                double dP2 = ( ptLineTria2 - ptP) * vtDir ;
+               double dCosDN = vtDir * trTria.GetN() ;
                vIntersInfo.emplace_back( nIntType, ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1),
-                                         -1, nB, ptLineTria1, ptLineTria2, trTria) ;
+                                         -1, nB, trTria, dCosDN, ptLineTria1, ptLineTria2) ;
             }
          }
       }
@@ -3007,8 +3013,9 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
                else if ( nIntType == ILTT_VERT  ||  nIntType == ILTT_EDGE  ||  nIntType == ILTT_IN) {
                   int nNumVox ;
                   GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
+                  double dCosDN = vtDir * trTria.GetN() ;
                   vIntersInfo.emplace_back( nIntType, ( ptLineTria1 - ptP) * vtDir,
-                                            nNumVox, nB, ptLineTria1, trTria) ;
+                                            nNumVox, nB, trTria, dCosDN, ptLineTria1) ;
                }
                // altrimenti ci sono due intersezioni
                else {
@@ -3016,8 +3023,9 @@ VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTO
                   GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
                   double dP1 = ( ptLineTria1 - ptP) * vtDir ;
                   double dP2 = ( ptLineTria2 - ptP) * vtDir ;
+                  double dCosDN = vtDir * trTria.GetN() ;
                   vIntersInfo.emplace_back( nIntType, ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1),
-                                            nNumVox, nB, ptLineTria1, ptLineTria2, trTria) ;
+                                            nNumVox, nB, trTria, dCosDN, ptLineTria1, ptLineTria2) ;
                }
             }
          }

VolZmapCreation.cpp

@@ -1,4 +1,4 @@
-//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 //  EgalTech 2015-2016
 //----------------------------------------------------------------------------
 // File : VolZmap.cpp         Data : 22.01.15           Versione : 1.6a4
@@ -17,6 +17,7 @@
 #include "CurveLine.h"
 #include "VolZmap.h"
 #include "GeoConst.h"
+#include "/EgtDev/Include/EGkIntersLineSurfTm.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include <future>
 
@@ -25,14 +26,124 @@ using namespace std ;
 // ------------------------- CREAZIONE MAPPA --------------------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
-bool 
+bool
 VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dLengthZ, double dStep, bool bTriDex)
 {
-  // Controlli sull'ammissibilità delle dimensioni lineari del grezzo e del passo
+
+  // Controlli sull'ammissibilità delle dimensioni lineari del grezzo e del passo
    if ( dStep < EPS_SMALL  ||  dLengthX < EPS_SMALL  ||  dLengthY < EPS_SMALL  ||  dLengthZ < EPS_SMALL)
       return false ;
 
-  // Il passo di discretizzazione non può essere inferiore a 100 * EPS_SMALL
+  // Il passo di discretizzazione non può essere inferiore a 100 * EPS_SMALL
+   m_dStep = max( dStep, 100 * EPS_SMALL) ;
+
+  // Aggiorno la dimensione della mappa 1 o 3
+   m_nMapNum = ( bTriDex ? 3 : 1) ;
+
+  // Disponendo i sistemi di riferimento in una successione, le coordinate x,y,z
+  // di uno si ottengono da una permutazione ciclica di quelle del precedente sistema.
+  // es: X(n) = Z(n-1), Y(n) = X(n-1), Z(n) = Y(n-1)
+
+  // Definisco il sistema di riferimento intrinseco
+   m_MapFrame.Set( ptO, X_AX, Y_AX, Z_AX) ;
+
+  // Definisco i vettori dei limiti su indici
+   m_nNx[0] = max( int( ( dLengthX + EPS_SMALL) / m_dStep + 0.5), 1) ;
+   m_nNy[0] = max( int( ( dLengthY + EPS_SMALL) / m_dStep + 0.5), 1) ;
+
+  // Numero di componenti connesse 
+   m_nConnectedCompoCount = 1 ;
+
+  // Se tridexel
+   if ( bTriDex) {
+      m_nNx[1] = m_nNy[0] ;
+      m_nNy[1] = max( int( ( dLengthZ + EPS_SMALL) / m_dStep + 0.5), 1) ;
+      m_nNx[2] = m_nNy[1] ;
+      m_nNy[2] = m_nNx[0] ;
+   }
+
+  // altrimenti mono dexel
+   else {
+      m_nNx[1] = 0 ;
+      m_nNy[1] = 0 ;
+      m_nNx[2] = 0 ;
+      m_nNy[2] = 0 ; 
+   }
+
+  // Definisco il numero di blocchi lungo x,y e z
+   if ( ! CalcBlockNum())
+      return false ;
+
+  // Definizione della mappa
+
+  // Creazione delle mappe
+  // Calcolo del numero di celle per ogni mappa
+   for ( int i = 0 ; i < m_nMapNum ; ++ i)
+      m_nDim[i] = m_nNx[i] * m_nNy[i] ;
+
+  // Creazione delle celle per ogni mappa
+   for ( int i = 0 ; i < m_nMapNum ; ++ i)
+      m_Values[i].resize( m_nDim[i]) ;
+
+  // Riempimento delle celle
+   for ( int i = 0 ; i < m_nMapNum ; ++ i) {
+      for ( int j = 0 ; j < m_nDim[i] ; ++ j) {
+
+        // Aggiungo il tratto al dexel vuoto
+         m_Values[i][j].resize( 1) ;
+         m_Values[i][j][0].dMin = 0 ;
+         m_Values[i][j][0].nToolMin = 0 ;
+         m_Values[i][j][0].nCompo = 1 ;
+
+         switch ( i) {
+         case 0 :
+            m_Values[i][j][0].vtMinN = - Z_AX ;
+            m_Values[i][j][0].dMax = dLengthZ ; 
+            m_Values[i][j][0].vtMaxN = Z_AX ;
+            m_Values[i][j][0].nToolMax = 0 ;
+            break ;
+         case 1 :
+            m_Values[i][j][0].vtMinN = - X_AX ;
+            m_Values[i][j][0].dMax = dLengthX ;
+            m_Values[i][j][0].vtMaxN = X_AX ;
+            m_Values[i][j][0].nToolMax = 0 ;
+            break ;
+         case 2 :
+            m_Values[i][j][0].vtMinN = - Y_AX ;
+            m_Values[i][j][0].dMax = dLengthY ;
+            m_Values[i][j][0].vtMaxN = Y_AX ;
+            m_Values[i][j][0].nToolMax = 0 ;
+            break ; 
+         }
+      }
+   }
+
+  // Definizione delle limitazioni iniziali in Z per ogni mappa
+   m_dMinZ[0] = 0 ;
+   m_dMaxZ[0] = dLengthZ ;
+   m_dMinZ[1] = 0 ;
+   m_dMaxZ[1] = ( bTriDex ? dLengthX : 0) ;
+   m_dMinZ[2] = 0 ;  
+   m_dMaxZ[2] = ( bTriDex ? dLengthY : 0) ;
+
+  // Tipologia
+   m_nShape = BOX ;
+
+  // Aggiornamento dello stato
+   m_nStatus = OK ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool 
+VolZmap::CreateEmptyMap( const Point3d& ptO, double dLengthX, double dLengthY, double dLengthZ, double dStep, bool bTriDex)
+{
+  // Controlli sull'ammissibilità delle dimensioni lineari del grezzo e del passo
+   if ( dStep < EPS_SMALL  ||  dLengthX < EPS_SMALL  ||  dLengthY < EPS_SMALL  ||  dLengthZ < EPS_SMALL)
+      return false ;
+
+  // Il passo di discretizzazione non può essere inferiore a 100 * EPS_SMALL
    m_dStep = max( dStep, 100 * EPS_SMALL) ;
 
   // Aggiorno la dimensione della mappa 1 o 3
@@ -72,8 +183,6 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL
    if ( ! CalcBlockNum())
       return false ;
 
-  // Definizione della mappa
-
   // Creazione delle mappe
   // Calcolo del numero di celle per ogni mappa
    for ( int i = 0 ; i < m_nMapNum ; ++ i)
@@ -83,38 +192,6 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL
    for ( int i = 0 ; i < m_nMapNum ; ++ i)
       m_Values[i].resize( m_nDim[i]) ;
 
-  // Riempimento delle celle
-   for ( int i = 0 ; i < m_nMapNum ; ++ i)
-      for ( int j = 0 ; j < m_nDim[i] ; ++ j) {
-
-        // Aggiungo il tratto al dexel vuoto
-         m_Values[i][j].resize( 1) ;
-         m_Values[i][j][0].dMin = 0 ;
-         m_Values[i][j][0].nToolMin = 0 ;
-         m_Values[i][j][0].nCompo = 1 ;
-
-         switch ( i) {
-         case 0 :
-            m_Values[i][j][0].vtMinN = - Z_AX ;
-            m_Values[i][j][0].dMax = dLengthZ ; 
-            m_Values[i][j][0].vtMaxN = Z_AX ;
-            m_Values[i][j][0].nToolMax = 0 ;
-            break ;
-         case 1 :
-            m_Values[i][j][0].vtMinN = - X_AX ;
-            m_Values[i][j][0].dMax = dLengthX ;
-            m_Values[i][j][0].vtMaxN = X_AX ;
-            m_Values[i][j][0].nToolMax = 0 ;
-            break ;
-         case 2 :
-            m_Values[i][j][0].vtMinN = - Y_AX ;
-            m_Values[i][j][0].dMax = dLengthY ;
-            m_Values[i][j][0].vtMaxN = Y_AX ;
-            m_Values[i][j][0].nToolMax = 0 ;
-            break ; 
-         }
-      }
-
   // Definizione delle limitazioni iniziali in Z per ogni mappa
    m_dMinZ[0] = 0 ;
    m_dMaxZ[0] = dLengthZ ;
@@ -123,8 +200,8 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL
    m_dMinZ[2] = 0 ;  
    m_dMaxZ[2] = ( bTriDex ? dLengthY : 0) ;
 
-   // Tipologia
-   m_nShape = BOX ;
+  // Tipologia
+   m_nShape = GENERIC ;
 
   // Aggiornamento dello stato
    m_nStatus = OK ;
@@ -139,7 +216,7 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
   // Aggiorno la dimensione della mappa 1 o 3
    m_nMapNum = ( bTriDex ? 3 : 1) ;
 
-  // Il passo di discretizzazione non può essere inferiore a 100 * EPS_SMALL
+  // Il passo di discretizzazione non può essere inferiore a 100 * EPS_SMALL
    m_dStep = max( dStep, 100 * EPS_SMALL) ;
  
   // Determino il bounding box della flat region
@@ -222,11 +299,11 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
       CRVCVECTOR IntersectionResults ;
       Surf.GetCurveClassification( GridLine, EPS_SMALL, IntersectionResults) ;
 
-     // Analizzo le parti in cui la retta è stata divisa
+     // Analizzo le parti in cui la retta è stata divisa
       int nPart = int( IntersectionResults.size()) ;
       for ( int k = 0 ; k < nPart ; ++ k) {
 
-        // Se la retta è interna alla regione o coincidente con parte della sua frontiera
+        // Se la retta è interna alla regione o coincidente con parte della sua frontiera
          int nType = IntersectionResults[k].nClass ;
          if ( nType == CRVC_IN  ||  nType == CRVC_ON_P  ||  nType == CRVC_ON_M) {
 
@@ -333,7 +410,7 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
          int nPart = int( IntersectionResults.size()) ; 
          for ( int k = 0 ; k < nPart ; ++ k) {
 
-           // Se la retta è interna alla regione o coincidente con parte della sua frontiera
+           // Se la retta è interna alla regione o coincidente con parte della sua frontiera
             int nType = IntersectionResults[k].nClass ;
             if ( nType == CRVC_IN  ||  nType == CRVC_ON_P  ||  nType == CRVC_ON_M) {
 
@@ -470,7 +547,7 @@ VolZmap::CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, co
 
             int nIntType = IntersectionResults[k].nILTT ;
 
-            // Se c'è intersezione
+            // Se c'è intersezione
             if ( nIntType != ILTT_NO) {
 
                double dCos = IntersectionResults[k].dCosDN ;
@@ -522,11 +599,115 @@ VolZmap::CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, co
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+VolZmap::UpdateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, const Vector3d& vtLen, const Point3d& ptMapOrig,
+                          const ISurfTriMesh& Surf, IntersParLinesSurfTm& intPLSTM)
+{
+      if ( nMap < 0  ||  nMap > 2  ||
+        nInfI < 0  ||  nInfI > m_nNx[nMap]  ||
+        nSupI < 0  ||  nSupI > m_nNx[nMap]  ||
+        nInfJ < 0  ||  nInfJ > m_nNy[nMap]  ||
+        nSupJ < 0  ||  nSupJ > m_nNy[nMap])
+      return false ;
+
+   // Determinazione e ridimensionamento dei dexel interni alla trimesh
+   for ( int i = nInfI ; i < nSupI ; ++ i) {
+      for ( int j = nInfJ ; j < nSupJ ; ++ j) {
+
+         // Definisco la retta da intersecare con la trimesh
+         double dX = ( i + 0.5) * m_dStep ;
+         double dY = ( j + 0.5) * m_dStep ;
+         Point3d ptP0( dX, dY, 0) ;
+
+         // Determino le intersezioni della retta con la TriMesh
+         ILSIVECTOR IntersectionResults ;
+         intPLSTM.GetInters( ptP0, vtLen.v[(nMap+2)%3], IntersectionResults) ;
+
+         for ( int nI = 0 ; nI < int( IntersectionResults.size()) - 3 ; ++ nI) {
+            int nJ = nI + 1 ;  
+            int nK = nJ + 1 ;
+            int nT = nK + 1 ;
+            int nSgnI = IntersectionResults[nI].dCosDN > EPS_SMALL ? 1 : IntersectionResults[nI].dCosDN > -EPS_SMALL ? 0 : - 1 ;
+            int nSgnJ = IntersectionResults[nJ].dCosDN > EPS_SMALL ? 1 : IntersectionResults[nJ].dCosDN > -EPS_SMALL ? 0 : - 1 ;
+            int nSgnK = IntersectionResults[nK].dCosDN > EPS_SMALL ? 1 : IntersectionResults[nK].dCosDN > -EPS_SMALL ? 0 : - 1 ;
+            int nSgnT = IntersectionResults[nT].dCosDN > EPS_SMALL ? 1 : IntersectionResults[nT].dCosDN > -EPS_SMALL ? 0 : - 1 ;
+            double dUJ = IntersectionResults[nJ].dU ;
+            double dUK = IntersectionResults[nK].dU ;
+            if ( nSgnI != 0  &&  nSgnI == nSgnJ  &&  nSgnK != 0  &&  nSgnK == nSgnT  &&  nSgnI == - nSgnT  &&  abs( dUJ - dUK) < EPS_SMALL) {
+               IntersectionResults.erase( IntersectionResults.begin() + nK) ;
+               IntersectionResults.erase( IntersectionResults.begin() + nJ) ;
+            }
+         }
+
+         int nInt = int( IntersectionResults.size()) ;
+
+         int nPos = j * m_nNx[nMap] + i ;
+
+         bool bInside = false ;
+         Point3d ptIn ;
+         Vector3d vtInN ;
+
+         for ( int k = 0 ; k < nInt ; ++ k) {
+
+            int nIntType = IntersectionResults[k].nILTT ;
+
+            // Se c'è intersezione
+            if ( nIntType != ILTT_NO) {
+
+               double dCos = IntersectionResults[k].dCosDN ;
+
+               // entro nella superficie trimesh
+               if ( dCos < - EPS_SMALL) {
+
+                  ptIn = IntersectionResults[k].ptI ;
+
+                  int nT = IntersectionResults[k].nT ;
+                  int nF = Surf.GetFacetFromTria( nT) ;
+
+                  Surf.GetFacetNormal( nF, vtInN) ;
+
+                  bInside = true ;
+               }
+
+               // esco dalla superficie trimesh
+               else if ( dCos > EPS_SMALL  &&  bInside) {
+
+                  Point3d ptOut = IntersectionResults[k].ptI ;
+
+                  int nT = IntersectionResults[k].nT ;
+                  int nF = Surf.GetFacetFromTria( nT) ;
+
+                  Vector3d vtOutN ;
+                  Surf.GetFacetNormal( nF, vtOutN) ; 
+
+                  int nCurrentSize = int( m_Values[nMap][nPos].size()) ;
+
+                  // Aggiungo un tratto al dexel
+                  m_Values[nMap][nPos].resize( nCurrentSize + 1) ;
+
+                  // Aggiorno dati del tratto di dexel 
+                  // Aggiungo un tratto al dexel attuale ( allo spillone )
+                   AddIntervals( nMap, nInfI, nInfJ,
+                                 ptIn.v[(nMap+2)%3] - ptMapOrig.v[(nMap+2)%3],
+                                 ptOut.v[(nMap+2)%3] - ptMapOrig.v[(nMap+2)%3],
+                                 vtInN, vtOutN, 0) ;
+
+                  bInside = false ;
+               }
+            }   
+         }
+      }
+   }
+   return true ;
+
+}
+
 //----------------------------------------------------------------------------
 bool
 VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex)
 {
-  // Se la superficie non è chiusa oppure orientata al contrario non ha senso continuare
+  // Se la superficie non è chiusa oppure orientata al contrario non ha senso continuare
    double dVol ;
    if ( ! Surf.IsClosed()  ||  ! Surf.GetVolume( dVol)  ||  dVol < 0)
       return false ;
@@ -542,14 +723,14 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dStep, bool bTriDex
    Point3d ptMapOrig, ptMapEnd ; 
    SurfBBox.GetMinMax( ptMapOrig, ptMapEnd) ;
 
-  // Il dexel se parte da un triangolo della trimesh può non trovare l'intersezione,
+  // Il dexel se parte da un triangolo della trimesh può non trovare l'intersezione,
   // quindi espandiamo il bounding box per ovviare al problema.
    SurfBBox.Expand( 100 * EPS_SMALL, 100 * EPS_SMALL, 100 * EPS_SMALL) ;
 
   // Sistema di riferimento intrinseco dello Zmap
    m_MapFrame.Set( ptMapOrig, Frame3d::TOP) ;
 
-  // Il passo di discretizzazione non può essere inferiore a 100 * EPS_SMALL
+  // Il passo di discretizzazione non può essere inferiore a 100 * EPS_SMALL
    m_dStep = max( dStep, 100 * EPS_SMALL) ;
 
   // Determino le dimensioni lineari del BBox

VolZmapGraphics.cpp

@@ -4673,23 +4673,19 @@ VolZmap::GetEdges( ICURVEPOVECTOR& vpCurve) const
       PtrOwner<CurveComposite> pCrvCompo( CreateBasicCurveComposite()) ;
       if ( IsNull( pCrvCompo))
          return false ;
-     // recupero gli estremi dei segmenti, creo le linee e le inserisco nella composita
+     // recupero gli estremi dei segmenti e li inserisco nella composita
       for ( int i = 0 ; i < int( vId.size()) ; ++ i) {
-        // creo un segmento di retta
+        // recupero indice e flag di inversione
          int nInd = abs( vId[i]) - 1 ;
          bool bInvert = ( vId[i] < 0) ;
-         PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
-         if ( IsNull( pLine)  ||  ! pLine->Set( vBpt[nInd].first, vBpt[nInd].second))
-            continue ;
-         if ( bInvert)
-            pLine->Invert() ;
-        // lo accodo alla composita
-         if ( ! pCrvCompo->AddCurve( Release( pLine), true, 1.1 * dToler)  &&
-              ! AreSamePointApprox( ptNear, ( bInvert ? vBpt[nInd].first : vBpt[nInd].second)))
-            return false ;
-        // aggiorno il prossimo near
-         ptNear = ( bInvert ? vBpt[nInd].first : vBpt[nInd].second) ;
+        // se primo segmento, inserisco il punto iniziale
+         if ( i == 0)
+            pCrvCompo->AddPoint( ! bInvert ? vBpt[nInd].first : vBpt[nInd].second) ;
+        // aggiungo il punto finale
+         pCrvCompo->AddLine( ! bInvert ? vBpt[nInd].second : vBpt[nInd].first) ;
       }
+     // aggiorno il prossimo near
+      pCrvCompo->GetEndPoint( ptNear) ;
      // se lunghezza curva inferiore a 5 volte la tolleranza, la salto
       double dCrvLen ;
       if ( ! pCrvCompo->GetLength( dCrvLen)  ||  dCrvLen < 5 * dToler)

VolZmapVolume.cpp

@@ -132,10 +132,10 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
 
   // Imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
-  // Imposto forma generica 
-   m_nShape = GENERIC ;    
+  // Imposto forma generica
+   m_nShape = GENERIC ;
   // Imposto ricalcolo numero di componenti connesse
-   m_nConnectedCompoCount = - 1 ; 
+   m_nConnectedCompoCount = - 1 ;
 
   // Passo da indici di dexel a indici di voxel
    nI /= m_nDexVoxRatio ;
@@ -160,7 +160,7 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
          ++ nYStop ;
       }
      // Voxel lungo Z
-      int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;  
+      int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
       int nMinK = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) - EPS_SMALL))), 0, nVoxNumZ - 2) ;
       int nMaxK = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) + EPS_SMALL))), 0, nVoxNumZ - 2) ;
       int nMinZBlock = ( m_nMapNum == 1 ? 0 : Clamp( nMinK / int( m_nVoxNumPerBlock), 0, int( m_nFracLin[2] - 1))) ;
@@ -227,8 +227,8 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
          nZBlock[1] = nZBlock[0] - 1 ;
          ++ nZStop ;
       }
-     // Voxel lungo Y 
-      int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ; 
+     // Voxel lungo Y
+      int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
       int nMinJ = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) - EPS_SMALL))), 0, nVoxNumY - 2) ; 
       int nMaxJ = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) + EPS_SMALL))), 0, nVoxNumY - 2) ; 
       int nMinYBlock = Clamp( nMinJ / int( m_nVoxNumPerBlock), 0, int( m_nFracLin[1] - 1)) ;
@@ -249,232 +249,355 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AddIntervals( int nGrid, int nI, int nJ,
-                       double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax, int nToolNum)
+VolZmap::AddIntervals( int nGrid, int nI, int nJ, double dMin, double dMax, const Vector3d& vtNMin,
+                       const Vector3d& vtNMax, int nToolNum)
 {
-//   // Controllo che dMin e dMax non siano quasi coincidenti
-//   if ( abs( dMax - dMin) < EPS_SMALL)
-//      return true ;
-//
-//   // Controllo che il numero di griglia sia entro i limiti
-//   if ( nGrid < 0 || nGrid > 2)
-//      return false ;
-//
-//   // Controllo che dMin < dMax
-//   if ( dMin > dMax)
-//      swap( dMin, dMax) ; 
-//   
-//   // Controllo che indici nI, nJ siano entro i limiti
-//   if ( nI < 0 && nI >= m_nNx[nGrid] && 
-//        nJ < 0 && nJ >= m_nNy[nGrid])
-//      return false ;
-//
-//  // Riporto le coordinate cicliche nell'ordine di partenza
-//   Vector3d vtNmi = vtNMin ;
-//   Vector3d vtNma = vtNMax ;
-//   if ( nGrid == 1) {
-//      swap( vtNmi.x, vtNmi.z) ;
-//      swap( vtNmi.y, vtNmi.z) ;
-//      swap( vtNma.x, vtNma.z) ;
-//      swap( vtNma.y, vtNma.z) ;
-//   }
-//   else if ( nGrid == 2) {
-//      swap( vtNmi.y, vtNmi.z) ;
-//      swap( vtNmi.x, vtNmi.z) ;
-//      swap( vtNma.y, vtNma.z) ;
-//      swap( vtNma.x, vtNma.z) ;
-//   }
-//
-//   // Calcolo nPos
-//   unsigned int nPos = nJ * m_nNx[nGrid] + nI ;
-//
-//   
-//   // Se spillone vuoto
-//   if ( m_Values[nGrid][nPos].size() == 0) {
-//   
-//      m_Values[nGrid][nPos].resize( 1) ;
-//   
-//      m_Values[nGrid][nPos][0].dMin = dMin ;
-//      m_Values[nGrid][nPos][0].dMax = dMax ;
-//
-//      m_Values[nGrid][nPos][0].vtMinN = vtNmi ;
-//      m_Values[nGrid][nPos][0].vtMaxN = vtNma ;
-//
-//      if ( dMax > m_dMaxZ[nGrid])
-//         m_dMinZ[nGrid] = dMax ;
-//
-//      if ( dMin < m_dMinZ[nGrid])
-//         m_dMinZ[nGrid] = dMin ;
-//
-//      m_OGrMgr.Reset() ;
-//
-//      return true ;
-//   }
-//
-//   // Ciclo sugli intervalli dello spillone
-//   bool bModified = false ;
-//   unsigned int i = 0 ;
-//   while ( i < m_Values[nGrid][nPos].size()) {
-//
-//      // Eventuale aggiustamento di intervalli sovrapposti
-//      if ( i < m_Values[nGrid][nPos].size() - 1) {
-//         if ( m_Values[nGrid][nPos][i].dMax > m_Values[nGrid][nPos][i + 1].dMin - EPS_SMALL) {
-//
-//            // Se l'intervallo corrente non è contenuto totalmente si esegue l'istruzione successiva
-//            if ( m_Values[nGrid][nPos][i].dMin < m_Values[nGrid][nPos][i + 1].dMin + EPS_SMALL) {
-//         
-//               m_Values[nGrid][nPos][i].dMax = m_Values[nGrid][nPos][i + 1].dMax ;
-//               m_Values[nGrid][nPos][i].vtMaxN = m_Values[nGrid][nPos][i + 1].vtMaxN ;
-//            }
-//            // altrimenti
-//            else {
-//            
-//               m_Values[nGrid][nPos][i].dMin = m_Values[nGrid][nPos][i].dMin ;
-//               m_Values[nGrid][nPos][i].vtMinN = m_Values[nGrid][nPos][i].vtMinN ;
-//
-//               m_Values[nGrid][nPos][i].dMax = m_Values[nGrid][nPos][i].dMax ;
-//               m_Values[nGrid][nPos][i].vtMaxN = m_Values[nGrid][nPos][i].vtMaxN ;
-//            }
-//         
-//            for ( unsigned int j = i + 1 ; j < m_Values[nGrid][nPos].size() - 1 ; ++ j) {
-//
-//               m_Values[nGrid][nPos][j].dMin = m_Values[nGrid][nPos][j + 1].dMin ;
-//               m_Values[nGrid][nPos][j].vtMinN = m_Values[nGrid][nPos][j + 1].vtMinN ;
-//
-//               m_Values[nGrid][nPos][j].dMax = m_Values[nGrid][nPos][j + 1].dMax ;
-//               m_Values[nGrid][nPos][j].vtMaxN = m_Values[nGrid][nPos][j + 1].vtMaxN ;
-//            }
-//         
-//            m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() - 1) ; 
-//            
-//            i = i - 1 ; 
-//         }
-//      }
-//     
-//
-//      // Caso in cui devo aggiungere un intervallo a sinistra dell'intervallo corrente
-//      if ( m_Values[nGrid][nPos][i].dZVal > dMax + EPS_SMALL) {
-//
-//         bModified = true ;   
-//                  
-//         m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() + 2) ;
-//         
-//         for ( size_t j = m_Values[nGrid][nPos].size() - 1 ; j >= i + 2 ; -- j) {
-//         
-//            m_Values[nGrid][nPos][j].dZVal = m_Values[nGrid][nPos][j - 2].dZVal ;
-//            m_Values[nGrid][nPos][j].vtN = m_Values[nGrid][nPos][j - 2].vtN ;
-//         }
-//            
-//         
-//         m_Values[nGrid][nPos][i].dZVal = dMin ;
-//         m_Values[nGrid][nPos][i + 1].dZVal = dMax ;
-//
-//         m_Values[nGrid][nPos][i].vtN = vtNMin ;
-//         m_Values[nGrid][nPos][i + 1].vtN = vtNMax ;
-//
-//         i = i + 2 ;
-//      } 
-//
-//      // Casi d'intersezione:
-//      else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMax - EPS_SMALL) {
-//
-//         // Se l'intervallo da aggiungere sconfina a sinistra modifico il minimo dell'intervalo corrente
-//         if ( m_Values[nGrid][nPos][i].dZVal > dMin - EPS_SMALL) { 
-//
-//            bModified = true ;         
-//            m_Values[nGrid][nPos][i].dZVal = dMin ;
-//            m_Values[nGrid][nPos][i].vtN = vtNmi ;
-//         }
-//      }
-//
-//      else {
-//         // Se l'intervallo corrente è tutto contenuto nell'intervallo da aggungere modifico gli estremi    
-//         if ( m_Values[nGrid][nPos][i].dZVal > dMin + EPS_SMALL) {
-//
-//               bModified = true ;         
-//               m_Values[nGrid][nPos][i].dZVal = dMin ;
-//               m_Values[nGrid][nPos][i + 1].dZVal = dMax ;
-//               m_Values[nGrid][nPos][i].vtN = vtNMin ;
-//               m_Values[nGrid][nPos][i + 1].vtN = vtNma ;
-//         }
-//         // Se l'intervallo da aggiungere sconfina a destra modifico il massimo dell'intervallo corrente 
-//         else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMin - EPS_SMALL) {
-//
-//            bModified = true ;         
-//            m_Values[nGrid][nPos][i + 1].dZVal = dMax ;
-//            m_Values[nGrid][nPos][i + 1].vtN = vtNma ;
-//         }
-//         else {
-//            // Aggiungo intervallo a destra dell'ultimo intervallo
-//            if ( i == m_Values[nGrid][nPos].size() - 2) {
-//
-//               bModified = true ;         
-//               m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() + 2) ;
-//               
-//               m_Values[nGrid][nPos][i + 2].dZVal = dMin ;
-//               m_Values[nGrid][nPos][i + 3].dZVal = dMax ;
-//               m_Values[nGrid][nPos][i + 2].vtN = vtNmi ;
-//               m_Values[nGrid][nPos][i + 3].vtN = vtNma ;
-//
-//               i = i + 2 ;
-//            }
-//         }
-//      }
-//
-//      i = i + 2 ;
-//   }
-//
-//   // se eseguita modifica, imposto ricalcolo della grafica
-//   if ( bModified) {
-//
-//      // Determino quali blocchi sono stati modificati
-//      int nLayerBlock = m_nFracLin[0] * m_nFracLin[1] ;
-//  
-//      if ( nGrid == 0) {
-//
-//         int nXBlock = min( nI / m_nDexNumPBlock, m_nFracLin[0] - 1) ;
-//         int nYBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[1] - 1) ;
-//         int nMinZBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ;
-//         int nMaxZBlock = min( int( m_nFracLin[2] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ;
-//         
-//         for ( int k = nMinZBlock ; k <= nMaxZBlock ; ++ k) 
-//
-//            m_BlockToUpdate[k * nLayerBlock + nYBlock * m_nFracLin[0] + nXBlock] = true ;
-//      }
-//      else if ( nGrid == 1) {
-//
-//         int nYBlock = min( nI / m_nDexNumPBlock, m_nFracLin[1] - 1) ;
-//         int nZBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[2] - 1) ;
-//         int nMinXBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ;
-//         int nMaxXBlock = min( int( m_nFracLin[0] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ;
-//         
-//         for ( int k = nMinXBlock ; k <= nMaxXBlock ; ++ k) 
-//
-//            m_BlockToUpdate[nZBlock * nLayerBlock + nYBlock * m_nFracLin[0] + k] = true ;
-//      }
-//      else if ( nGrid == 2) {
-//
-//         int nXBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[0] - 1) ;
-//         int nZBlock = min( nI / m_nDexNumPBlock, m_nFracLin[2] - 1) ;
-//         int nMinYBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ;
-//         int nMaxYBlock = min( int( m_nFracLin[1] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ;
-//         
-//         for ( int k = nMinYBlock ; k <= nMaxYBlock ; ++ k) 
-//
-//            m_BlockToUpdate[nZBlock * nLayerBlock + k * m_nFracLin[0] + nXBlock] = true ;
-//      }
-//
-//      m_OGrMgr.Reset() ;
-//
-//      // Aggiorno massima e minima Z
-//      // sullo Zmap
-//      if ( dMax > m_dMaxZ[nGrid])
-//         m_dMinZ[nGrid] = dMax ;
-//
-//      if ( dMin < m_dMinZ[nGrid])
-//         m_dMinZ[nGrid] = dMin ;
-//   }
-//
+  // Controllo che il numero di griglia sia entro i limiti
+   if ( nGrid < 0 || nGrid > 2)
+      return false ;
+
+   // Controllo che indici nI, nJ siano entro i limiti
+   if ( nI < 0 && nI >= m_nNx[nGrid]  &&  nJ < 0 && nJ >= m_nNy[nGrid])
+      return false ;
+
+  // Controllo che dMin < dMax ( nel caso swap parametri e vettori )
+   Vector3d vtNmi = vtNMin ;
+   Vector3d vtNma = vtNMax ;
+   if ( dMin > dMax) {
+      swap( dMin, dMax) ;
+      swap( vtNmi, vtNma) ;
+   }
+
+  // Restringo minimo e massimo entro i limiti della mappa
+   if ( dMin < m_dMinZ[nGrid]) {
+      dMin = m_dMinZ[nGrid] ;
+      vtNmi = - Z_AX ;
+   }
+   else if ( dMin > m_dMaxZ[nGrid]) {
+      dMin = m_dMaxZ[nGrid] ;
+      vtNmi = - Z_AX ;
+   }
+   if ( dMax < m_dMinZ[nGrid]) {
+      dMax = m_dMinZ[nGrid] ;
+      vtNma = Z_AX ;
+   }
+   else if ( dMax > m_dMaxZ[nGrid]) {
+      dMax = m_dMaxZ[nGrid] ;
+      vtNma = Z_AX ;
+   }
+
+  // Controllo che dMin e dMax non siano quasi coincidenti ( la limitazione dei range può
+  // far collassare gli intervalli )
+   if ( abs( dMax - dMin) < EPS_SMALL)
+      return true ;
+
+  // Riporto le coordinate cicliche nell'ordine di partenza
+   if ( nGrid == 1) {
+      swap( vtNmi.x, vtNmi.z) ;
+      swap( vtNmi.y, vtNmi.z) ;
+      swap( vtNma.x, vtNma.z) ;
+      swap( vtNma.y, vtNma.z) ;
+   }
+   else if ( nGrid == 2) {
+      swap( vtNmi.y, vtNmi.z) ;
+      swap( vtNmi.x, vtNmi.z) ;
+      swap( vtNma.y, vtNma.z) ;
+      swap( vtNma.x, vtNma.z) ;
+   }
+
+   // Calcolo nPos
+   unsigned int nPos = nJ * m_nNx[nGrid] + nI ;
+   vector<Data>& vDexel = m_Values[nGrid][nPos] ;
+
+   bool bModified = false ;
+
+  // se non esistono segmenti...
+   if ( int( vDexel.size()) == 0) { // ... definisco il primo
+      vDexel.emplace_back() ;
+      vDexel.back().dMin = dMin ;
+      vDexel.back().vtMinN = vtNmi ;
+      vDexel.back().nToolMin = nToolNum ;
+      vDexel.back().dMax = dMax ;
+      vDexel.back().vtMaxN = vtNma ;
+      vDexel.back().nToolMax = nToolNum ;
+      m_OGrMgr.Reset() ;
+      bModified = true ; // modifica effettuata
+   }
+  // se ne esiste almeno uno, devo controllare possibili overlaps
+   else {
+     // Cerco l'ultimo intervallo a sinistra e l'ultimo intervallo a destra di quello da aggiungere,
+     // che non interferiscono con quest'ultimo
+      auto itLastLeft = vDexel.end() ;
+      auto itFirstRight = vDexel.end() ; // per bloccare la prima iterazione...
+      for ( auto it = vDexel.begin() ; it != vDexel.end() ; ++ it) {
+        // se il minimo attuale è maggiore del massimo it-esimo, l'intervallo it-esimo è a sinistra
+         if ( dMin > it->dMax + EPS_SMALL)
+            itLastLeft = it ; // aggiorno
+        // se il massimo attuale è minore del minimo it-esimo, l'interallo it-esimo è a destra
+         if ( dMax < it->dMin - EPS_SMALL  &&  itFirstRight == vDexel.end())
+            itFirstRight = it ; // aggiorno
+      }
+
+     // se esistono intervalli a sinistra... ( inizialmente l'iteratore è inizializzato su end())
+      if ( itLastLeft != vDexel.end()) {
+        // prendo il successivo dell'ultimo più vicino
+         auto itNextToLastLeft = itLastLeft ;
+         ++ itNextToLastLeft ;
+
+        // e se il successivo a sinistra non esiste...
+         if ( itNextToLastLeft == vDexel.end()) {
+           // aggiorno l'ultimo intervallo
+            vDexel.emplace_back() ;
+            vDexel.back().dMin = dMin ;
+            vDexel.back().dMax = dMax ;
+            vDexel.back().vtMinN = vtNmi ;
+            vDexel.back().vtMaxN = vtNma;
+            vDexel.back().nToolMin = nToolNum ;
+            vDexel.back().nToolMax = nToolNum ;
+            bModified = true ;
+         }
+        // se esiste...
+         else {
+           // controllo se coincide con il primo trovato a destra...
+            if ( itNextToLastLeft == itFirstRight) {
+              // in questo caso definisco il nuovo intervallo
+               Data NewSegment ;
+               NewSegment.dMin = dMin ;
+               NewSegment.dMax = dMax ;
+               NewSegment.vtMinN = vtNmi ;
+               NewSegment.vtMaxN = vtNma ;
+               NewSegment.nToolMin = nToolNum ;
+               NewSegment.nToolMax = nToolNum ;
+               vDexel.insert( itFirstRight, NewSegment) ; // inserimento intervallo
+               bModified = true ;
+            }
+            else {
+              // se il successivo non esce a sinistra da quello da aggiungere
+               if ( itNextToLastLeft->dMin > dMin + EPS_SMALL) {
+                  itNextToLastLeft->dMin = dMin ;
+                  itNextToLastLeft->vtMinN = vtNmi ;
+                  itNextToLastLeft->nToolMin = nToolNum ;
+               }
+              // cerco poi l'ultimo segmento che interferisce con quello da aggiungere
+               auto itPrevToFirstRight = vDexel.end() ;
+               for ( auto it = itNextToLastLeft ; it != itFirstRight ; ++ it)
+                  itPrevToFirstRight = it ;
+              // anche in qesto caso, se l'ultimo che interferisce non esce a destra da quello da aggiungere
+               if ( itPrevToFirstRight->dMax < dMax - EPS_SMALL) {
+                  itNextToLastLeft->dMax = dMax ;
+                  itNextToLastLeft->vtMaxN = vtNma ;
+                  itNextToLastLeft->nToolMax = nToolNum ;
+                  bModified = true ;
+               }
+               else {
+                  itNextToLastLeft->dMax = itPrevToFirstRight->dMax ;
+                  itNextToLastLeft->vtMaxN = itPrevToFirstRight->vtMaxN ;
+                  itNextToLastLeft->nToolMax = nToolNum ;
+                  bModified = true ;
+               }
+              // cancello il successivo...
+               auto itFirstToCancel = itNextToLastLeft ;
+               ++ itFirstToCancel ;
+               vDexel.erase( itFirstToCancel, itFirstRight) ;
+            }
+         }
+      }
+     // se non esiste da destra ...
+      else if ( itFirstRight == m_Values[nGrid][nPos].end()) {
+         // e il primo intervallo non sporge a sinistra ...
+         if ( vDexel.begin()->dMin > dMin + EPS_SMALL) {
+            vDexel.begin()->dMin = dMin ;
+            vDexel.begin()->vtMinN = vtNmi ;
+            vDexel.begin()->nToolMin = nToolNum ;
+            bModified = true ;
+         }
+        // se sporge da destra
+         if ( m_Values[nGrid][nPos].back().dMax > dMax + EPS_SMALL) {
+           // allora ci sono più segmenti, inglobo tutti nel primo
+            if ( vDexel.back().dMax > vDexel.begin()->dMax + EPS_SMALL) {
+               vDexel.begin()->dMax = vDexel.back().dMax ;
+               vDexel.begin()->vtMaxN = vDexel.back().vtMaxN ;
+               vDexel.begin()->nToolMax = nToolNum ;
+               bModified = true ;
+            }
+         }
+        // se l'ultimo intervallo non sporge a destra.
+         else {
+            vDexel.begin()->dMax = dMax ;
+            vDexel.begin()->vtMaxN = vtNma ;
+            vDexel.begin()->nToolMax = nToolNum ;
+            bModified = true ;
+         }
+        // cancello quelli inglobati
+         vDexel.erase( vDexel.begin() + 1, vDexel.end()) ;
+      }
+     // Casi Estremi...
+      else {
+        // 1) Tutti i segmenti sono a destra da quello da aggiungere...
+         if ( itFirstRight == vDexel.begin()) {
+           // -> inserisco il nuovo intervallo
+            Data NewSegment ;
+            NewSegment.dMin = dMin ;
+            NewSegment.dMax = dMax ;
+            NewSegment.vtMinN = vtNmi ;
+            NewSegment.vtMaxN = vtNma ;
+            NewSegment.nToolMin = nToolNum ;
+            NewSegment.nToolMax = nToolNum ;
+            vDexel.insert( vDexel.begin(), NewSegment) ; // posizione iniziale
+            bModified = true ;
+         }
+         else {
+           // se il primo segmento non esce a sinistra da quello da aggiungere, cambio l'inizio
+            if ( vDexel.begin()->dMin > dMin + EPS_SMALL) {
+               vDexel.begin()->dMin = dMin ;
+               vDexel.begin()->vtMinN = vtNmi ;
+               vDexel.begin()->nToolMin = nToolNum ;
+               bModified = true ;
+            }
+           // cerco l'ultimo segmento che interferisce con quello da aggiungere
+            auto itPrevToFirstRight = vDexel.begin() ;
+            for ( auto it = m_Values[nGrid][nPos].begin() ; it != itFirstRight ; ++ it)
+               itPrevToFirstRight = it ;
+           // se l'ultimo che interferisce non esce a destra da quello da aggiungere...
+            if ( itPrevToFirstRight->dMax < dMax - EPS_SMALL) {
+               vDexel.begin()->dMax = dMax ;
+               vDexel.begin()->vtMaxN = vtNma ;
+               vDexel.begin()->nToolMax = nToolNum ;
+               bModified = true ;
+            }
+           // ... altrimenti
+            else {
+               vDexel.begin()->dMax = itPrevToFirstRight->dMax ;
+               vDexel.begin()->vtMaxN = itPrevToFirstRight->vtMaxN ;
+               vDexel.begin()->nToolMax = nToolNum ;
+               bModified = true ;
+            }
+           // cancello gli inglobati ( come prima )
+            auto itFirstToCancel = vDexel.begin() ;
+            ++ itFirstToCancel ;
+            vDexel.erase( itFirstToCancel, itFirstRight) ;
+         }
+      }
+   }
+
+  // Se nessuna modifica, esco
+   if ( ! bModified)
+      return true ;
+
+  // Imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+  // Imposto forma generica
+   m_nShape = GENERIC ;
+  // Imposto ricalcolo numero di componenti connesse
+   m_nConnectedCompoCount = - 1 ;
+
+  // Passo da indici di dexel a indici di voxel
+   nI /= m_nDexVoxRatio ;
+   nJ /= m_nDexVoxRatio ;
+
+  // Determino quali blocchi sono stati modificati a seconda della griglia
+   if ( nGrid == 0) {
+      // Voxel lungo X
+      int nXStop = 1 ;
+      int nXBlock[2] ;
+      nXBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[0] - 1) ;
+      if ( nI % N_VOXBLOCK == 0  &&  nXBlock[0] > 0) {
+         nXBlock[1] = nXBlock[0] - 1 ;
+         ++ nXStop ;
+      }
+     // Voxel lungo Y
+      int nYStop = 1 ;
+      int nYBlock[2] ;
+      nYBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[1] - 1) ;
+      if ( nJ % N_VOXBLOCK == 0  &&  nYBlock[0] > 0) {
+         nYBlock[1] = nYBlock[0] - 1 ;
+         ++ nYStop ;
+      }
+     // Voxel lungo Z
+      int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
+      int nMinK = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) - EPS_SMALL))), 0, nVoxNumZ - 2) ;
+      int nMaxK = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) + EPS_SMALL))), 0, nVoxNumZ - 2) ;
+      int nMinZBlock = ( m_nMapNum == 1 ? 0 : Clamp( nMinK / int( m_nVoxNumPerBlock), 0, int( m_nFracLin[2] - 1))) ;
+      int nMaxZBlock = min( int( m_nFracLin[2] - 1), nMaxK / int( m_nVoxNumPerBlock)) ;
+     // Assegno flag ai voxel
+      for ( int tI = 0 ; tI < nXStop ; ++ tI) {
+         for ( int tJ = 0 ; tJ < nYStop ; ++ tJ) {
+            for ( int k = nMinZBlock ; k <= nMaxZBlock ; ++ k) {
+               int nBlockNum = k * m_nFracLin[0] * m_nFracLin[1] + nYBlock[tJ] * m_nFracLin[0] + nXBlock[tI] ;
+               m_BlockToUpdate[nBlockNum] = true ;
+            }
+         }
+      }
+   }
+
+   else if ( nGrid == 1) {
+     // Voxel lungo Y
+      int nYStop = 1 ;
+      int nYBlock[2] ;
+      nYBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[1] - 1) ;
+      if ( nI % N_VOXBLOCK == 0  &&  nYBlock[0] > 0) {
+         nYBlock[1] = nYBlock[0] - 1 ;
+         ++ nYStop ;
+      }
+     // Voxel lungo Z
+      int nZStop = 1 ;
+      int nZBlock[2] ;
+      nZBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[2] - 1) ;
+      if ( nJ % N_VOXBLOCK == 0  &&  nZBlock[0] > 0) {
+         nZBlock[1] = nZBlock[0] - 1 ;
+         ++ nZStop ;
+      }
+      // Voxel lungo X
+      int nVoxNumX = int( m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
+      int nMinI = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) - EPS_SMALL))), 0, nVoxNumX - 2) ;
+      int nMaxI = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) + EPS_SMALL))), 0, nVoxNumX - 2) ;
+      int nMinXBlock = Clamp( nMinI / int( m_nVoxNumPerBlock), 0, int( m_nFracLin[0] - 1)) ;
+      int nMaxXBlock = min( int( m_nFracLin[0] - 1), nMaxI / int( m_nVoxNumPerBlock)) ;
+      // Assegno flag ai voxel
+      for ( int tI = 0 ; tI < nYStop ; ++ tI) {
+         for ( int tJ = 0 ; tJ < nZStop ; ++ tJ) {
+            for ( int k = nMinXBlock ; k <= nMaxXBlock ; ++ k) {
+               int nBlockNum = nZBlock[tJ] * m_nFracLin[0] * m_nFracLin[1] + nYBlock[tI] * m_nFracLin[0] + k ;
+               m_BlockToUpdate[nBlockNum] = true ;
+            }
+         }
+      }
+   }
+
+   else if ( nGrid == 2) {
+      // Voxel lungo X
+      int nXStop = 1 ;
+      int nXBlock[2] ;
+      nXBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[0] - 1) ;
+      if ( nJ % N_VOXBLOCK == 0  &&  nXBlock[0] > 0) {
+         nXBlock[1] = nXBlock[0] - 1 ;
+         ++ nXStop ;
+      }
+      // Voxel lungo Z
+      int nZStop = 1 ;
+      int nZBlock[2] ;
+      nZBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[2] - 1) ;
+      if ( nI % N_VOXBLOCK == 0  &&  nZBlock[0] > 0) {
+         nZBlock[1] = nZBlock[0] - 1 ;
+         ++ nZStop ;
+      }
+      // Voxel lungo Y 
+      int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ; 
+      int nMinJ = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) - EPS_SMALL))), 0, nVoxNumY - 2) ; 
+      int nMaxJ = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) + EPS_SMALL))), 0, nVoxNumY - 2) ; 
+      int nMinYBlock = Clamp( nMinJ / int( m_nVoxNumPerBlock), 0, int( m_nFracLin[1] - 1)) ;
+      int nMaxYBlock = min( int( m_nFracLin[1] - 1), nMaxJ / int( m_nVoxNumPerBlock)) ;
+      // Assegno flag ai voxel
+      for ( int tI = 0 ; tI < nZStop ; ++ tI) {
+         for ( int tJ = 0 ; tJ < nXStop ; ++ tJ) {
+            for ( int k = nMinYBlock ; k <= nMaxYBlock ; ++ k) {
+               int nBlockNum = nZBlock[tI] * m_nFracLin[0] * m_nFracLin[1] + k * m_nFracLin[0] + nXBlock[tJ] ;
+               m_BlockToUpdate[nBlockNum] = true ;
+            }
+         }
+      }
+   }
+
    return true ;
 }
 

Voronoi.cpp

@@ -79,7 +79,7 @@ Voronoi::AddCurve( const ICurve* pCrv)
    if ( pCrv == nullptr)
       return false ;
   
-  // verifico se è una linea
+  // verifico se è una linea
    int nType = pCrv->GetType() ;
    bool bIsLine = ( nType == CRV_LINE) ;
    if ( nType == CRV_COMPO) {
@@ -92,7 +92,7 @@ Voronoi::AddCurve( const ICurve* pCrv)
   // verifico sia piana e trovo piano su cui giace
    Plane3d plPlane ;
    if ( bIsLine) {
-     // linea è sicuramente piana. Scelgo piano definito dall'estrusione ( se definita)
+     // linea è sicuramente piana. Scelgo piano definito dall'estrusione ( se definita)
       Point3d ptS ; pCrv->GetStartPoint( ptS) ;
       Vector3d vtExtr ; pCrv->GetExtrusion( vtExtr) ;
       if ( ! vtExtr.IsSmall())
@@ -110,7 +110,7 @@ Voronoi::AddCurve( const ICurve* pCrv)
       m_Frame.Set( plPlane.GetPoint(), plPlane.GetVersN()) ; 
    }
    else {
-     // altrimenti verifico sia complanare ad eventuali curve già presenti
+     // altrimenti verifico sia complanare ad eventuali curve già presenti
       if ( ! AreSameOrOppositeVectorApprox( m_Frame.VersZ(), plPlane.GetVersN())  ||  ! PointInPlaneApprox( m_Frame.Orig(), plPlane))
          return false ;  
    }
@@ -122,7 +122,7 @@ Voronoi::AddCurve( const ICurve* pCrv)
    pCrvLoc->ToLoc( m_Frame) ;
 
    try {
-     // verifico se oggetto vroni è stato inizializzato
+     // verifico se oggetto vroni è stato inizializzato
       if ( m_vroni == nullptr) {
          m_vroni = new( nothrow) vroniObject() ;
          if ( m_vroni == nullptr)
@@ -165,7 +165,7 @@ Voronoi::AddSurfFlatRegion( const ISurfFlatRegion* pSfr)
       m_Frame.Set( ptCen, vtN) ;   
    }
    else {
-     // verifico sia complanare ad eventuali curve già presenti
+     // verifico sia complanare ad eventuali curve già presenti
       Plane3d plPlane ;
       plPlane.Set( ptCen, pSfr->GetNormVersor()) ;
       if ( ! AreSameOrOppositeVectorApprox( m_Frame.VersZ(), pSfr->GetNormVersor())  ||  ! PointInPlaneApprox( m_Frame.Orig(), plPlane))
@@ -173,7 +173,7 @@ Voronoi::AddSurfFlatRegion( const ISurfFlatRegion* pSfr)
    }
  
    try {
-     // verifico se oggetto vroni è stato inizializzato
+     // verifico se oggetto vroni è stato inizializzato
       if ( m_vroni == nullptr) {
          m_vroni = new( nothrow) vroniObject() ;
          if ( m_vroni == nullptr)
@@ -315,7 +315,7 @@ Voronoi::AddCompoToVroni( const ICurveComposite* pCompo, int& nVroniCrv, int nLo
    for ( int i = 0 ; i < pCopy->GetCurveCount() ; i++) {
       Point3d ptForcedEnd = P_INVALID ;
    
-     // se curva è chiusa, forzo l'end point a coincidere con lo start ( per le tolleranze di vroni)
+     // se curva è chiusa, forzo l'end point a coincidere con lo start ( per le tolleranze di vroni)
       if ( i == pCopy->GetCurveCount() - 1  &&  bClosed)
          pCompo->GetStartPoint( ptForcedEnd) ;
    
@@ -359,7 +359,7 @@ Voronoi::AddBezierToVroni( const ICurveBezier* pBezier, int& nVroniCrv, int nLoo
 ICurve* 
 Voronoi::GetCurve( int nId) const
 {
-  // verifico validità indice
+  // verifico validità indice
    if ( nId < 0  ||  nId > ( int)m_vpCrvs.size() - 1)
       return nullptr ; 
   // ne faccio una copia
@@ -375,11 +375,11 @@ Voronoi::GetCurve( int nId) const
 bool 
 Voronoi::CalcVoronoi( int nBound)
 { 
-  // se già stato calcolato con lo stesso bound non devo fare nulla
+  // se già stato calcolato con lo stesso bound non devo fare nulla
    if ( m_bVDComputed  &&  nBound == m_nBound)
       return true ;
  
-  // se già stato calcolato reset dei dati
+  // se già stato calcolato reset dei dati
    if ( m_bVDComputed)
       m_vroni->ResetVoronoiDiagram() ;
 
@@ -389,8 +389,8 @@ Voronoi::CalcVoronoi( int nBound)
   // calcolo
    m_bVDComputed = true ; 
    string sTmp = "" ;
-   m_vroni->apiComputeVD( false, true, false, m_nBound, 0, 0, &sTmp[0], false, false, false, &sTmp[0], true) ;   
- 
+   m_vroni->apiComputeVD( false, true, false, m_nBound, 0, 0, &sTmp[0], false, false, false, &sTmp[0], true) ;  
+
    return true ;
 }
 
@@ -414,6 +414,11 @@ Voronoi::GetBisectorCurve( int i)
       CurveLine* pLine = CreateBasicCurveLine() ;
       if ( pLine == nullptr)
          return nullptr ;
+     // costruisco il bisettore orientato dal parametro minore al maggiore 
+      if ( dParS > dParE) {
+         swap( ptS, ptE) ;
+         swap( dParS, dParE) ;
+      }
       pLine->Set( ptS, ptE) ;
       pLine->SetTempParam( dParS, 0) ;
       pLine->SetTempParam( dParE, 1) ;
@@ -433,7 +438,7 @@ Voronoi::GetBisectorCurve( int i)
          return nullptr ;
       pArc->SetC2P( ptC, ptS, ptE) ;
       pArc->SetTempParam( dParS, 0) ;
-      pArc->SetTempParam( dParS, 1) ;
+      pArc->SetTempParam( dParS, 1) ; // dParE = dParS
       pArc->ToGlob( m_Frame) ;
       return pArc ;   
    }
@@ -449,15 +454,23 @@ Voronoi::GetBisectorCurve( int i)
       if ( pCompo == nullptr)
          return nullptr ;
    
+     // verifico se devo leggere i punti del bisettore al contrario per averlo orientato dal parametro minore al maggiore
+      bool bInvert = false ;
+      double dPar1, dPar2 ;
+      m_vroni->GetApproxedBisectorParams( i, dPar1, dPar2) ;
+      if ( dPar1 > dPar2 + EPS_SMALL)
+         bInvert = true ;
+
      // punto iniziale
       Point3d pt ;
       double dParS ;
-      m_vroni->GetApproxedBisectorPoint( i, 0, pt.v, dParS) ;
+      m_vroni->GetApproxedBisectorPoint( i, bInvert ? nPoints - 1 : 0, pt.v, dParS) ;
       pCompo->AddPoint( pt) ;
       int nCrvCount = 0 ;
    
       double dParPrev = dParS ;
-      for ( int j = 1 ; j < nPoints ; j ++) {
+      int j = bInvert ? nPoints - 2 : 1 ;
+      while ( ( bInvert  &&  j >= 0)  ||  ( ! bInvert  &&  j < nPoints)) {
          double dPar ;
          m_vroni->GetApproxedBisectorPoint( i, j, pt.v, dPar) ;
          if ( pCompo->AddLine( pt)) {           
@@ -467,7 +480,12 @@ Voronoi::GetBisectorCurve( int i)
            // aggiorno parametro precedente
             dParPrev = dPar ;
             nCrvCount ++ ;
-         }     
+         }
+        // aggiorno per punto successivo
+         if ( bInvert)
+            j -- ;
+         else
+            j ++ ;
       }
    
      // setto parametri sulla curva
@@ -501,6 +519,9 @@ Voronoi::CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound)
          if ( ! IsNull( pCrv) && pCrv->IsValid())
             vCrvs.emplace_back( Release( pCrv)) ;        
       }
+
+     // libero la memoria di vroni utilizzata per calcolare bisettore
+      m_vroni->apiFreeBisectorBuffer() ;
    }
    catch (...) {
       LOG_ERROR( GetEGkLogger(), m_vroni->GetExceptionMessage()) ;
@@ -542,6 +563,9 @@ Voronoi::CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide)
                vCrvs.emplace_back( Release( pCrv)) ;          
          }         
       }
+
+     // libero la memoria di vroni utilizzata per calcolare bisettore
+      m_vroni->apiFreeBisectorBuffer() ;
    }
    catch (...) {
       LOG_ERROR( GetEGkLogger(), m_vroni->GetExceptionMessage()) ;
@@ -651,12 +675,12 @@ Voronoi::CalcFatCurve( ICURVEPOVECTOR& vCrvs, double dOffs, bool bSquareEnds, bo
 
      // sistemo i raccordi
       if ( bClosed  &&  bSquareMids) {
-        // se curva è chiusa tutti i raccordi rispondono a bSquareMids
+        // se curva è chiusa tutti i raccordi rispondono a bSquareMids
          IdentifyFillets( pCrvOffs, dOffs) ;
          AdjustCurveFillets( pCrvOffs, dOffs, ICurve::OFF_EXTEND) ;      
       }
       else if ( ! bClosed  &&  (  bSquareMids  ||  bSquareEnds)) {
-        // se curva è aperta devo distinguere i raccordi interni da quelli relativi agli estremi e 
+        // se curva è aperta devo distinguere i raccordi interni da quelli relativi agli estremi e 
         // modificare solo quelli richiesti
          for ( int j = 0 ; j < pCrvOffs->GetCurveCount() ; j ++) {
             int nOrigCrv ; pCrvOffs->GetCurveTempProp( j, nOrigCrv) ;
@@ -738,13 +762,13 @@ Voronoi::CalcVroniOffset( ICRVCOMPOPLIST& OffsList, double dOffs, bool bRightOff
                bOk = pCrvOffs->AddCurve( Release( pArc)) ;
             }
 
-           // se la curva è stata aggiunta
+           // se la curva è stata aggiunta
             if ( bOk) {
-              // setto come info la sottocurva da cui si è generata
+              // setto come info la sottocurva da cui si è generata
                int nCurrCrvId = pCrvOffs->GetCurveCount() - 1 ;
                pCrvOffs->SetCurveTempProp( nCurrCrvId, nOrigCrv + 1, 0) ;
                pCrvOffs->SetCurveTempProp( nCurrCrvId, nOrigLoop, 1) ;
-              // verifico se è raccordo relativo agli estremi della curva
+              // verifico se è raccordo relativo agli estremi della curva
                if ( nOrigCrv == -1  &&  ( nOrigPnt == 0  ||  nOrigPnt == nOrigCrvCnt))
                   pCrvOffs->SetCurveTempParam( nCurrCrvId, 1.0, 0) ;     
             }
@@ -757,6 +781,9 @@ Voronoi::CalcVroniOffset( ICRVCOMPOPLIST& OffsList, double dOffs, bool bRightOff
          if ( ! IsNull( pCrvOffs) &&  pCrvOffs->IsValid())
             OffsList.push_back( Release( pCrvOffs)) ;        
       } 
+
+     // libero la memoria di vroni dedicata agli offset
+      m_vroni->apiFreeOffsetData() ;
    }
    catch (...) {
       LOG_ERROR( GetEGkLogger(), m_vroni->GetExceptionMessage()) ;
@@ -789,7 +816,7 @@ Voronoi::VerifyCurvesValidityForOffset()
    if ( m_vpCrvs.size() == 1)
       return true ;
 
-  // se ho più curve, devono essere tutte chiuse    
+  // se ho più curve, devono essere tutte chiuse    
    for ( auto pCrv : m_vpCrvs) {
       if ( ! pCrv->IsClosed())
          return false ;
@@ -809,12 +836,29 @@ Voronoi::VerifyCurvesValidityForOffset()
 
      // se curva con orientamento principale verifico sia esterna a tutte le altre curve con orientamento principale 
       if ( vArea[i] * dRefArea > EPS_SMALL) {
-         for ( int j = i + 1 ; j < ( int)vArea.size() ; j++) {
-            if ( vArea[i] * vArea[j] > EPS_SMALL) {
+         for ( int j = 0 ; j < ( int)vArea.size() ; j++) {
+            if ( j != i  &&  vArea[i] * vArea[j] > EPS_SMALL) {
                IntersCurveCurve ccInt( *m_vpCrvs[i], *m_vpCrvs[j]) ;
                int nRes = ccInt.GetRegionCurveClassification() ;
-               if ( ( bRefCCW  &&  nRes != CCREGC_OUT)  ||  ( ! bRefCCW  &&  nRes != CCREGC_IN1))
+               if ( nRes == CCREGC_NULL  ||  nRes == CCREGC_SAME  ||  nRes == CCREGC_INTERS)
                   return false ;
+               if ( ( bRefCCW  &&  nRes == CCREGC_IN1)  ||  ( ! bRefCCW  &&  nRes == CCREGC_IN2)) {
+                  // se è interna ad una curva con orientamento principale, verifico sia esterna ad almeno una curva con orientamento
+                  // diverso dal principale
+                   bool bFound = false ;
+                   for ( int k = 0 ; k < ( int)vArea.size() ; k++) {
+                      if ( k != i  &&  vArea[i] * vArea[k] < EPS_SMALL) {
+                         IntersCurveCurve ccInt( *m_vpCrvs[i], *m_vpCrvs[k]) ;
+                         int nRes = ccInt.GetRegionCurveClassification() ;
+                         if ( ( bRefCCW  &&  nRes ==  CCREGC_OUT)  ||  ( ! bRefCCW  &&  nRes == CCREGC_IN1)) {
+                            bFound = true ;
+                            break ;
+                         }                            
+                      }                   
+                   }
+                   if ( ! bFound)
+                      return false ;               
+               }
             }            
          }     
       }
@@ -884,7 +928,7 @@ Voronoi::AdjustOpenOffsetCurve( ICurveComposite& pCompo, double dOffs)
      // mi posiziono dopo la junction
       pCompo.ChangeStartPoint( vJunctions[0] + 1) ;
       delete( pCompo.RemoveFirstOrLastCurve()) ;
-     // verifico validità della curva
+     // verifico validità della curva
       int nSide = GetOffsetCurveSide( pCompo, 0) ;
       if ( nSide == nSideRef) {
         // scorro fino alla prima curva non valida ed elimino la curva da quel punto fino alla fine
@@ -895,7 +939,7 @@ Voronoi::AdjustOpenOffsetCurve( ICurveComposite& pCompo, double dOffs)
          }     
       }
       else {
-        // elimino finchè non trovo una curva valida
+        // elimino finchè non trovo una curva valida
          while( nSide != nSideRef  &&  pCompo.IsValid()) {
             delete( pCompo.RemoveFirstOrLastCurve( false)) ;
             if ( pCompo.IsValid())
@@ -948,3 +992,52 @@ Voronoi::AdjustOffsetStart( ICurveComposite& pCrv)
    }
    return true ;
 }
+
+//---------------------------------------------------------------------------
+bool
+Voronoi::Translate( const Vector3d & vtMove) 
+{  
+   if ( ! IsValid())
+      return false ;
+   return m_Frame.Translate( vtMove) ;
+}
+
+//---------------------------------------------------------------------------
+bool Voronoi::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg)
+{
+   if ( ! IsValid())
+      return false ;
+   return m_Frame.Rotate( ptAx, vtAx, dAngDeg) ;
+}
+
+//---------------------------------------------------------------------------
+bool Voronoi::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
+{
+   if ( ! IsValid())
+      return false ;
+   return m_Frame.Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
+}
+
+//---------------------------------------------------------------------------
+bool Voronoi::ToGlob( const Frame3d& frRef)
+{
+   if ( ! IsValid())
+      return false ;
+   return m_Frame.ToGlob( frRef) ;
+}
+
+//---------------------------------------------------------------------------
+bool Voronoi::ToLoc( const Frame3d& frRef)
+{
+   if ( ! IsValid())
+      return false ;
+   return m_Frame.ToLoc( frRef) ;
+}
+
+//---------------------------------------------------------------------------
+bool Voronoi::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
+{
+   if ( ! IsValid())
+      return false ;
+   return m_Frame.LocToLoc( frOri, frDest) ;
+}

Voronoi.h

@@ -55,6 +55,13 @@ class Voronoi
       bool CalcFatCurve( ICURVEPOVECTOR& vOffs, double dOffs, bool bSquareEnds, bool bSquareMids) ;
       bool CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide) ;
 
+      bool Translate( const Vector3d& vtMove) ;
+      bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg) ;
+      bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) ;
+      bool ToGlob( const Frame3d& frRef) ;
+      bool ToLoc( const Frame3d& frRef) ;
+      bool LocToLoc( const Frame3d& frOri, const Frame3d& frDest) ;
+
    private :
       bool Clear( void) ;
       bool IsValid( void) const
@@ -76,10 +83,10 @@ class Voronoi
 
    private :
       vroniObject*   m_vroni ;        // oggetto base della libreria vroni
-      Frame3d        m_Frame ;        // frame in cui è espresso l'oggetto vroni
+      Frame3d        m_Frame ;        // frame in cui è espresso l'oggetto vroni
       int            m_nBound ;       // bound associato al diagramma di Voronoi corrente
       CICURVEPVECTOR m_vpCrvs ;       // curve associate al Voronoi ( espresse rispetto a m_Frame)
       BBox3d         m_bBox ;         // box degli oggetti associati al Voronoi
-      bool           m_bVDComputed ;  // indica se il diagramma di Voronoi è stato calcolato
+      bool           m_bVDComputed ;  // indica se il diagramma di Voronoi è stato calcolato
       bool           m_bAllowAdd ;    // indica se possibile aggiungere altre curve/superifici dopo aver creato l'oggetto Voronoi
 } ;