EgtGeomKernel :

- Aggiunte funzioni per identificazione di Parts e Shells nelle TriMesh.

ArcPntDirTgCurve.cpp

@@ -16,9 +16,9 @@
 #include "CurveBezier.h"
 #include "CurveComposite.h"
 #include "CreateCurveAux.h"
-#include "DistPointLine.h"
 #include "GeoConst.h"
 #include "/EgtDev/Include/EGkArcPntDirTgCurve.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkArcSpecial.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"

CAvToolSurfTm.cpp

@@ -14,8 +14,8 @@
 #include "stdafx.h"
 #include "CAvToolTriangle.h"
 #include "CAvToolSurfTm.h"
-#include "DistPointLine.h"
 #include "DllMain.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGnStringUtils.h"
 #include <thread>
 #include <future>

CAvToolTriangle.cpp

@@ -17,8 +17,8 @@
 #include "CAvToolTriangle.h"
 #include "IntersLineSurfStd.h"
 #include "IntersLineTria.h"
-#include "DistPointLine.h"
 #include "CDeUtility.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/ENkPolynomialRoots.h"
 #include "/EgtDev/Include/EgtNumUtils.h"

CDeCylTria.cpp

@@ -13,9 +13,9 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "DistPointLine.h"
 #include "CDeCylTria.h"
 #include "CDeConvexTorusTria.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkPolygon3d.h"
 
 using namespace std ;

CDeUtility.cpp

@@ -1,6 +1,6 @@
 #include "stdafx.h"
 #include "CDeUtility.h"
-#include "DistPointLine.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/ENkPolynomialRoots.h"
 
 using namespace std ;

CircleCenTgCurve.cpp

@@ -16,8 +16,8 @@
 #include "CurveBezier.h"
 #include "CurveComposite.h"
 #include "CreateCurveAux.h"
-#include "DistPointLine.h"
 #include "GeoConst.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkCircleCenTgCurve.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"

CurveBezier.cpp

@@ -19,7 +19,6 @@
 #include "BiArcs.h"
 #include "GeoConst.h"
 #include "PolygonPlane.h"
-#include "DistPointLine.h"
 #include "GeoObjFactory.h"
 #include "NgeWriter.h"
 #include "NgeReader.h"
@@ -29,6 +28,7 @@
 #include "Voronoi.h"
 #include "IntersLineLine.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
 #include "/EgtDev/Include/ENkPolynomial.h"

CurveByApprox.cpp

@@ -16,8 +16,8 @@
 #include "CurveComposite.h"
 #include "CalcDerivate.h"
 #include "BiArcs.h"
-#include "DistPointLine.h"
 #include "RemoveCurveDefects.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkCurveByApprox.h"
 #include "/EgtDev/Include/EGkPolyLine.h"
 #include "/EgtDev/Include/EGkPolyArc.h"

CurveComposite.cpp

@@ -14,7 +14,6 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CurveComposite.h"
-#include "DistPointLine.h"
 #include "DistPointCrvComposite.h"
 #include "CurveLine.h"
 #include "CurveArc.h"
@@ -27,6 +26,7 @@
 #include "NgeWriter.h"
 #include "NgeReader.h"
 #include "Voronoi.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkCurveByApprox.h"
 #include "/EgtDev/Include/EGkArcSpecial.h"
 #include "/EgtDev/Include/EGkSfrCreate.h"
@@ -3225,61 +3225,64 @@ MergeTwoCurves( ICurve* pCrvP, ICurve* pCrvC, double& dCurrLinTol, double dCosAn
      // verifico di non superare l'angolo giro al centro
       if ( abs( pArcP->GetAngCenter() + pArcC->GetAngCenter()) > ANG_FULL + EPS_ANG_SMALL)
          return 0 ;
-     // se archi piatti
+     // verifico se archi piatti
-      if ( pArcP->IsPlane()  &&  pArcC->IsPlane()) {
+      bool bPlaneArcs = pArcP->IsPlane()  &&  pArcC->IsPlane() ;
-        // se calcolo nuovo arco ok, procedo con l'unione
+     // se archi non piatti verifico coincidenza pendenza sulla normale
-         Point3d ptP1 ;
+      if ( ! bPlaneArcs) {        
-         pArcP->GetStartPoint( ptP1) ;
+         double dN = pArcP->GetNormVersor() * pArcC->GetNormVersor() ;
-         Point3d ptP2 ;
+         if ( abs(( pArcC->GetDeltaN() * pArcP->GetAngCenter() - dN * pArcP->GetDeltaN() * pArcC->GetAngCenter()) /
-         pArcP->GetEndPoint( ptP2) ;
+            ( pArcP->GetAngCenter() + pArcC->GetAngCenter())) > dCurrLinTol)
-         Point3d ptP3 ;
-         pArcC->GetEndPoint( ptP3) ;
-         // verifico se circonferenza completa
-         bool bCirc = ( AreSamePointApprox( ptP1, ptP3)) ;
-         if ( bCirc)
-            pArcC->GetMidPoint( ptP3) ;
-         CurveArc NewArc ;
-         if ( NewArc.Set3P( ptP1, ptP2, ptP3, bCirc)) {
-           // verifico normale al piano dell'arco
-            if ( NewArc.GetNormVersor() * pArcC->GetNormVersor() < 0)
-               NewArc.InvertN() ;
-           // se curve originali con la stessa proprietà, la riporto
-            if ( nTpr0P == nTpr0C)
-               NewArc.SetTempProp( nTpr0C, 0) ;
-            if ( nTpr1P == nTpr1C)
-               NewArc.SetTempProp( nTpr1C, 1) ;
-           // aggiorno l'arco corrente e torno flag modifica
-            *pArcC = NewArc ;
-            return -1 ;
-         }
-         else
             return 0 ;
       }
-     // verifico coincidenza pendenza sulla normale
+
-      double dN = pArcP->GetNormVersor() * pArcC->GetNormVersor() ;
+     // se calcolo nuovo arco ok, procedo con l'unione
-      if ( abs(( pArcC->GetDeltaN() * pArcP->GetAngCenter() - dN * pArcP->GetDeltaN() * pArcC->GetAngCenter()) /
+      Point3d ptP1 ;
-                ( pArcP->GetAngCenter() + pArcC->GetAngCenter())) < dCurrLinTol) {
+      pArcP->GetStartPoint( ptP1) ;
-        // se calcolo nuovo arco ok, procedo con l'unione
+      Point3d ptP2 ;
-         Point3d ptP1 ;
+      pArcP->GetEndPoint( ptP2) ;
-         pArcP->GetStartPoint( ptP1) ;
+      Point3d ptP3 ;
-         Vector3d vtDir1 ;
+      pArcC->GetEndPoint( ptP3) ;
-         pArcP->GetStartDir( vtDir1) ;
+
-         Point3d ptP3 ;
+     // se archi non piani costruisco arco sul piano definito dalla normale e dal punto di partenza del primo arco
-         pArcC->GetEndPoint( ptP3) ;
+      Frame3d frRef ;
-         CurveArc NewArc ;
+      if ( ! frRef.Set( ptP1, pArcP->GetNormVersor()))
-         if ( NewArc.Set2PVN( ptP1, ptP3, vtDir1, pArcC->GetNormVersor())) {
+         return 0 ;
-           // se curve originali con la stessa proprietà, la riporto
+      if ( ! bPlaneArcs) {
-            if ( nTpr0P == nTpr0C)
+         ptP1.Scale( frRef, 1, 1, 0) ;
-               NewArc.SetTempProp( nTpr0C, 0) ;
+         ptP2.Scale( frRef, 1, 1, 0) ;
-            if ( nTpr1P == nTpr1C)
+         ptP3.Scale( frRef, 1, 1, 0) ;      
-               NewArc.SetTempProp( nTpr1C, 1) ;
-           // aggiorno l'arco corrente e torno flag modifica
-            *pArcC = NewArc ;
-            return -1 ;
-         }
-         else
-            return 0 ;
       }
+
+     // verifico se circonferenza completa
+      bool bCirc = ( AreSamePointApprox( ptP1, ptP3)) ;
+      if ( bCirc) {
+         pArcC->GetMidPoint( ptP3) ;
+         if ( ! bPlaneArcs)
+            ptP3.Scale( frRef, 1, 1, 0) ;
+      }
+         
+      CurveArc NewArc ;
+      if ( NewArc.Set3P( ptP1, ptP2, ptP3, bCirc)) {
+        // verifico normale al piano dell'arco
+         if ( NewArc.GetNormVersor() * pArcC->GetNormVersor() < 0)
+            NewArc.InvertN() ;
+        // se archi non piani ripristino il deltaN
+         if ( ! bPlaneArcs) {
+            double dDeltaN1 = pArcP->GetDeltaN() ;
+            double dDeltaN2 = pArcC->GetDeltaN() ;
+            NewArc.ChangeDeltaN( dDeltaN1 + dDeltaN2) ;
+         }
+        // se curve originali con la stessa proprietà, la riporto
+         if ( nTpr0P == nTpr0C)
+            NewArc.SetTempProp( nTpr0C, 0) ;
+         if ( nTpr1P == nTpr1C)
+            NewArc.SetTempProp( nTpr1C, 1) ;
+        // aggiorno l'arco corrente e torno flag modifica
+         *pArcC = NewArc ;
+         return -1 ;
+      }
+      else
+         return 0 ;
    }
 
   // nessuna fusione

CurveLine.cpp

@@ -14,11 +14,11 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CurveLine.h"
-#include "DistPointLine.h"
 #include "GeoObjFactory.h"
 #include "NgeWriter.h"
 #include "NgeReader.h"
 #include "Voronoi.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"

DistPointCrvAux.cpp

@@ -14,9 +14,9 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "DllMain.h"
-#include "DistPointCrvAux.h"
-#include "DistPointLine.h"
 #include "GeoConst.h"
+#include "DistPointCrvAux.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 
 
 //----------------------------------------------------------------------------

DistPointCurve.cpp

@@ -13,10 +13,10 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "DistPointLine.h"
 #include "DistPointArc.h"
 #include "DistPointCrvBezier.h"
 #include "DistPointCrvComposite.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 
 

DistPointLine.cpp

@@ -1,19 +1,19 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2013
+//  EgalTech 2013-2024
 //----------------------------------------------------------------------------
-// File : DistPointLine.cpp       Data : 17.12.13          Versione : 1.4l1
+// File : DistPointLine.cpp       Data : 20.05.24          Versione : 2.6e5
 // Contenuto : Implementazione della classe distanza punto da linea/segmento.
 //
 //
 //
 // Modifiche : 17.12.13 DS Creazione modulo.
-//
+//             20.05.24 DS Reso pubblico in Include.
 //
 //----------------------------------------------------------------------------
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "DistPointLine.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 
 
 //----------------------------------------------------------------------------

DistPointLine.h

@@ -1,58 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2013-2014
-//----------------------------------------------------------------------------
-// File : DistPointLine.h      Data : 02.01.14          Versione : 1.5a1
-// Contenuto : Dichiarazione della classe distanza punto da linea/segmento.
-//
-//
-//
-// Modifiche : 30.12.12 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkPoint3d.h"
-#include "/EgtDev/Include/EGkCurveLine.h"
-
-
-//-----------------------------------------------------------------------------
-class DistPointLine
-{
-   friend class DistPointCurve ;
-
-   public :
-      DistPointLine( const Point3d& ptP,
-                     const ICurveLine& crvLine, bool bIsSegment = true) ;
-      DistPointLine( const Point3d& ptP,
-                     const Point3d& ptIni, const Point3d& ptFin, bool bIsSegment = true) ;
-      DistPointLine( const Point3d& ptP,
-                     const Point3d& ptIni, const Vector3d& vtDir, double dLen, bool bIsSegment = true) ;
-
-   public :
-      bool GetSqDist( double& dSqDist) const ;
-      bool GetDist( double& dDist) const ;
-      bool IsEpsilon( double dTol) const
-              { double dSqDist ; return ( GetSqDist( dSqDist) && ( dSqDist < SQ_EPS_ZERO || dSqDist < dTol * dTol)) ; }
-      bool IsSmall( void) const
-              { return IsEpsilon( EPS_SMALL) ; }
-      bool IsZero( void) const
-              { return IsEpsilon( EPS_ZERO) ; }
-      int  GetNbrMinDist( void) const
-              { return (( m_dSqDist < 0) ? 0 : 1) ; }
-      bool GetMinDistPoint( Point3d& ptMinDist) const ;
-      bool GetParamAtMinDistPoint( double& dParam) const ;
-
-   private :
-      DistPointLine( void) ;
-      void Calculate( const Point3d& ptP,
-                      const Point3d& ptIni, const Vector3d& vtDir, double dLen, bool bIsSegment) ;
-
-   private :
-      double  m_dSqDist ;
-      mutable double  m_dDist ;
-      double  m_dParam ;
-      Point3d m_ptMinDist ;
-} ;
-

DistPointSurfTm.cpp

@@ -15,6 +15,7 @@
 #include "SurfTriMesh.h"
 #include "/EgtDev/Include/EGkDistPointTria.h"
 #include "/EgtDev/Include/EGkDistPointSurfTm.h"
+#include "/EgtDev/Include/EGkIntersLineTria.h"
 
 using namespace std ;
 
@@ -93,6 +94,8 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
 {
   // Inizializzo distanza non calcolata
    m_dDist = - 1. ;
+  // Controllo se la superficie è chiusa
+   m_bIsSurfClosed = tmSurf.IsClosed() ;
 
   // Lavoro con l'oggetto superficie trimesh di base
    const SurfTriMesh* pStm = GetBasicSurfTriMesh( &tmSurf) ;
@@ -121,6 +124,9 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
   // Finché non si verifica la condizione di terminazione ingrandisco il box.
    pStm->ResetTempInts() ;
    bool bContinue = true ;
+
+  // creazione del vettore dei triangoli più vicini a ptP
+   vector<pair<int, Triangle3d>> vTria ; // <indice triangolo, Triangolo>
    while ( bContinue) {
      // Calcolo il box differenza con il precedente per non esplorare parti già considerate
       BOXVECTOR vBox ;
@@ -134,8 +140,8 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
             continue ;
         // ricerca sui triangoli nel box
          bCollide = true ;
-         INTVECTOR vnIds ; 
+         INTVECTOR vnIds ;
-         if ( pStm->GetAllTriaOverlapBox( b3Int, vnIds)) { 
+         if ( pStm->GetAllTriaOverlapBox( b3Int, vnIds)) {
            // Ciclo sui triangoli del sotto-box corrente
             for ( auto nT : vnIds) {
                int nTriaTemp ;
@@ -144,18 +150,24 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
                   pStm->SetTempInt( nT, 1) ;
                   DistPointTriangle distPT( ptP, trCurTria) ;
                   double dCurSqDist ;
-                 // Se la distanza del triangolo č valida e minore di quella attuale aggiorno 
+                 // Se la distanza del triangolo è valida e minore di quella attuale aggiorno
-                  if ( distPT.GetSqDist( dCurSqDist)  &&  dCurSqDist < dMinSqDist) {
+                  if ( distPT.GetSqDist( dCurSqDist)) {
-                     dMinSqDist = dCurSqDist ;
+                     if ( abs( dCurSqDist - dMinSqDist) < EPS_SMALL) // se distanze uguali...
-                     nMinDistTriaIndex = nT ;
+                        vTria.emplace_back( make_pair( nT, trCurTria)) ; // aggiungo il triangolo
-                     distPT.GetMinDistPoint( ptMinDistPoint) ;
+                     else if ( dCurSqDist < dMinSqDist) { // se minore...
+                        vTria.clear() ; // pulisco il vettore
+                        dMinSqDist = dCurSqDist ;
+                        nMinDistTriaIndex = nT ;
+                        distPT.GetMinDistPoint( ptMinDistPoint) ;
+                        vTria.emplace_back( make_pair( nT, trCurTria)) ; // aggiungo il triangolo
+                     }
                   }
                }
             }
          }
       }
      // Se si verifica la condizione di terminazione arresto il ciclo altrimenti aggiorno i box 
-      if ( ! bCollide  ||  dMinSqDist < EPS_SMALL * EPS_SMALL)
+      if ( ! bCollide  ||  dMinSqDist < SQ_EPS_SMALL)
          bContinue = false ;
       else {
         boxPPrev = boxP ;
@@ -163,15 +175,70 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
       }
    }
 
-   if ( nMinDistTriaIndex != SVT_NULL) {
+  // se non ho trovato nessun triangolo, esco
-      m_dDist = sqrt( max( dMinSqDist, 0.)) ;
+   if ( nMinDistTriaIndex == SVT_NULL)
+      return ;
+
+  // salvo la distanza minima
+   m_dDist = sqrt( max( dMinSqDist, 0.)) ;
+  // salvo il punto a distanza minima
+   m_ptMinDistPoint = ptMinDistPoint ;
+  // se il punto è sulla TriMesh...
+   if ( m_dDist < EPS_SMALL) {
       m_nMinDistTriaIndex = nMinDistTriaIndex ;
-      m_ptMinDistPoint = ptMinDistPoint ;
+      m_bIsInside = false ;
-      Triangle3d trMinDistTria ;
+      return ;
-      pStm->GetTriangle( m_nMinDistTriaIndex, trMinDistTria) ;
-      trMinDistTria.Validate() ;
-      m_bIsInside = ( ( ptP - m_ptMinDistPoint) * trMinDistTria.GetN() < - EPS_SMALL)  &&  pStm->IsClosed() ;
    }
+  // se ho un solo triangolo, allora deduco le informazioni da lui
+   else if ( int( vTria.size()) == 1) {
+      m_nMinDistTriaIndex = vTria.back().first ;
+      m_bIsInside = ( ( ptP - m_ptMinDistPoint) * vTria.back().second.GetN() < - EPS_SMALL) ;
+      return ;
+   }
+  
+  // controllo se tutti i triangoli a minima distanza forniscono la stessa informazione
+  // ( il punto potrebbe essere esterno a tutti, interno a tutti o indefinito )
+   bool bInside = false ;
+   bool bOutside = false ;
+   for ( int i = 0 ; i < int( vTria.size()) ; ++ i) { // scorro i triangoli a minima distanza
+      if ( ( ptP - vTria[i].second.GetP( 0)) * vTria[i].second.GetN() < - EPS_SMALL)
+         bInside = true ;
+      else
+         bOutside = true ;
+   }
+
+  // inizializzo le variabili membro
+   m_nMinDistTriaIndex = nMinDistTriaIndex ;
+   m_bIsInside = false ;
+
+  // se le informazioni non sono coerenti, allora :
+  // 1) calcolo i centroidi dei triangoli in questione
+  // 2) ottengo il punto medio di questi centroidi
+  // 3) controllo quale triangolo interseca il segmento che parte da ptP e arriva a tale punto
+  // 4) userò questo triangolo per classificare ptP
+   if ( bOutside == bInside) {
+     // calcolo il baricentro complessivo
+      Point3d ptBar_tot ;
+      for ( auto& Tria : vTria)
+         ptBar_tot += Tria.second.GetCentroid() ;
+      ptBar_tot /= int( vTria.size()) ;
+     // per ogni triangolo, cerco quello che interseca il segmento
+      for ( auto& Tria : vTria) {
+         Point3d ptInters1, ptInters2 ;
+         int nType = IntersLineTria( ptP, ptBar_tot, Tria.second, ptInters1, ptInters2) ;
+         if ( nType == ILTT_IN) { // se intersezione ho finito
+            DistPointTriangle( ptP, Tria.second).GetMinDistPoint( m_ptMinDistPoint) ;
+            m_bIsInside = ( ( ptP - m_ptMinDistPoint) * Tria.second.GetN() < - EPS_SMALL) ;
+            m_nMinDistTriaIndex = Tria.first ;
+            break ;
+         }
+      }
+   }
+   else // se informazioni coerenti
+      m_bIsInside = bInside ;
+
+   return ;
+
 }
 
 //----------------------------------------------------------------------------

DistPointTria.cpp

@@ -14,7 +14,7 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "ProjPlane.h"
-#include "DistPointLine.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointTria.h"
 
 

EgtGeomKernel.vcxproj

@@ -329,6 +329,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="..\Include\EGkCDeConvexTorusClosedSurfTm.h" />
     <ClInclude Include="..\Include\EGkCDeRectPrismoidClosedSurfTm.h" />
     <ClInclude Include="..\Include\EGkDistLineLine.h" />
+    <ClInclude Include="..\Include\EGkDistPointLine.h" />
     <ClInclude Include="..\Include\EGkIntersCurveSurfTm.h" />
     <ClInclude Include="..\Include\EGkIntersLineBox.h" />
     <ClInclude Include="..\Include\EGkIntersLineVolZmap.h" />
@@ -600,7 +601,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="DistPointCrvAux.h" />
     <ClInclude Include="DistPointCrvBezier.h" />
     <ClInclude Include="DistPointCrvComposite.h" />
-    <ClInclude Include="DistPointLine.h" />
     <ClInclude Include="DllMain.h" />
     <ClInclude Include="earcut.hpp" />
     <ClInclude Include="ExtDimension.h" />

EgtGeomKernel.vcxproj.filters

@@ -593,9 +593,6 @@
     <ClInclude Include="DistPointArc.h">
       <Filter>File di intestazione</Filter>
     </ClInclude>
-    <ClInclude Include="DistPointLine.h">
-      <Filter>File di intestazione</Filter>
-    </ClInclude>
     <ClInclude Include="DistPointCrvBezier.h">
       <Filter>File di intestazione</Filter>
     </ClInclude>
@@ -1214,6 +1211,9 @@
     <ClInclude Include="..\Include\EGkDistLineLine.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
+    <ClInclude Include="..\Include\EGkDistPointLine.h">
+      <Filter>File di intestazione\Include</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtGeomKernel.rc">

IntersLineSurfBez.cpp

@@ -13,12 +13,12 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
+#include "CurveLine.h"
+#include "/EgtDev/Include/EGkDistPointLine.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 ;
 

IntersLineSurfTm.cpp

@@ -52,6 +52,8 @@ OrderInfoIntersLineSurfTm( ILSIVECTOR& vInfo)
             []( const IntLinStmInfo& a, const IntLinStmInfo& 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) ;
+                  if ( abs( dUa - dUb) < EPS_SMALL)
+                     return ( a.dCosDN < b.dCosDN) ;
                   return ( dUa < dUb) ; }) ;
 }
 

IntersLineTria.cpp

@@ -17,7 +17,7 @@
 #include "CurveLine.h"
 #include "IntersLineLine.h"
 #include "IntersLineTria.h"
-#include "DistPointLine.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistLineLine.h"
 #include "/EgtDev/Include/EGkIntersLinePlane.h"
 #include "/EgtDev/Include/EGkFrame3d.h"

IntersPlaneSurfTm.cpp

@@ -15,7 +15,7 @@
 #include "stdafx.h"
 #include "ProjPlane.h"
 #include "CurveLine.h"
-#include "DistPointLine.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkIntersPlaneSurfTm.h"
 #include "/EgtDev/Include/EGkIntersPlaneTria.h"
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"

IntersSurfTmSurfTm.cpp

@@ -13,9 +13,9 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "DistPointLine.h"
 #include "IntersLineTria.h"
 #include "DllMain.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkIntersSurfTmSurfTm.h"
 #include "/EgtDev/Include/EGkIntersTriaTria.h"
 #include "/EgtDev/Include/EGkPointGrid3d.h"

LineTgCurvePerpCurve.cpp

@@ -14,7 +14,7 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CreateCurveAux.h"
-#include "DistPointLine.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkLineTgCurvePerpCurve.h"
 #include "/EgtDev/Include/EGkLinePntTgCurve.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"

LineTgTwoCurves.cpp

@@ -14,7 +14,7 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CreateCurveAux.h"
-#include "DistPointLine.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkLineTgTwoCurves.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 

PolyArc.cpp

@@ -13,9 +13,9 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "DistPointLine.h"
 #include "GeoConst.h"
 #include "CurveArc.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkPolyArc.h"
 #include "/EgtDev/Include/EGkFrame3d.h"
 #include <algorithm>

PolyLine.cpp

@@ -14,13 +14,13 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CurveLine.h"
-#include "DistPointLine.h"
 #include "IntersLineLine.h"
 #include "PolygonPlane.h"
 #include "PointsPCA.h"
 #include "GeoConst.h"
 #include "/EgtDev/Include/EGkPolyLine.h"
 #include "/EgtDev/Include/EGkPlane3d.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGnStringUtils.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 

ProjectCurveSurfTm.cpp

@@ -13,8 +13,8 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "DistPointLine.h"
 #include "GeoConst.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkDistPointSurfTm.h"
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
@@ -22,6 +22,10 @@
 
 using namespace std ;
 
+//----------------------------------------------------------------------------
+// Angolo limite tra normale al triangolo e direzione di proiezione 89°
+const double COS_ANG_LIM = 0.0175 ;
+
 //----------------------------------------------------------------------------
 static bool
 PointsInTolerance( const PNT5AXVECTOR& vPt5ax, int nPrec, int nCurr, int nNext, double dSqTol)
@@ -89,9 +93,9 @@ ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vec
   // 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
+  // approssimo la curva con una polilinea alla massima risoluzione
    PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
+   if ( ! crCrv.ApproxWithLines( EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
       return false ;
    const double MAX_SEG_LEN = min( dMaxSegmLen, 1.) ;
    if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
@@ -112,12 +116,17 @@ ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vec
    Point3d ptP ;
    bool bFound = PL.GetFirstUPoint( &dPar, &ptP) ;
    while ( bFound) {
+     // intersezione retta di proiezione con superficie
       Point3d ptL = GetToLoc( ptP, frRefLine) ;
       ILSIVECTOR vIntRes ;
       intPLSTM.GetInters( ptL, 1, vIntRes, false) ;
-      if ( ! vIntRes.empty()) {
+     // cerco la prima intersezione valida a partire dall'ultima (è la più alta)
+      int nI = int( vIntRes.size()) - 1 ;
+      while ( nI >= 0  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
+         --nI ;
+     // se trovata
+      if ( nI >= 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 ;
@@ -187,9 +196,13 @@ ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const IGe
          vtLine /= dLineLen ;
          ILSIVECTOR vIntRes ;
          if ( IntersLineSurfTm( ptP, vtLine, dLineLen, tmSurf, vIntRes, false)) {
-            if ( vIntRes.size() > 0) {
+           // cerco la prima intersezione valida a partire dall'ultima (è la più alta)
+            int nI = int( vIntRes.size()) - 1 ;
+            while ( nI >= 0  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
+               --nI ;
+           // se trovata
+            if ( nI >= 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 ;
@@ -235,9 +248,9 @@ ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const ICu
    dLinTol = max( dLinTol, LIN_TOL_MIN) ;
    dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
 
-  // approssimo la curva con una polilinea entro la metà della tolleranza
+  // approssimo la curva con una polilinea alla massima risoluzione
    PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
+   if ( ! crCrv.ApproxWithLines( EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
       return false ;
    const double MAX_SEG_LEN = min( dMaxSegmLen, 1.) ;
    if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
@@ -264,9 +277,13 @@ ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const ICu
             vtLine /= dLineLen ;
             ILSIVECTOR vIntRes ;
             if ( IntersLineSurfTm( ptP, vtLine, dLineLen, tmSurf, vIntRes, false)) {
-               if ( vIntRes.size() > 0) {
+              // cerco la prima intersezione valida a partire dall'ultima (è la più alta)
+               int nI = int( vIntRes.size()) - 1 ;
+               while ( nI >= 0  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
+                  --nI ;
+              // se trovata
+               if ( nI >= 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 ;
@@ -342,9 +359,13 @@ ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const ISu
             vtLine /= dLineLen ;
             ILSIVECTOR vIntRes ;
             if ( IntersLineSurfTm( ptP, vtLine, dLineLen, tmSurf, vIntRes, false)) {
-               if ( vIntRes.size() > 0) {
+              // cerco la prima intersezione valida a partire dall'ultima (è la più alta)
+               int nI = int( vIntRes.size()) - 1 ;
+               while ( nI >= 0  &&  abs( vIntRes[nI].dCosDN) < COS_ANG_LIM)
+                  --nI ;
+              // se trovata
+               if ( nI >= 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 ;

RemoveCurveDefects.cpp

@@ -15,8 +15,8 @@
 #include "stdafx.h"
 #include "GeoConst.h"
 #include "CurveComposite.h"
-#include "DistPointLine.h"
 #include "RemoveCurveDefects.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include <algorithm>
 

SurfTriMesh.cpp

@@ -20,12 +20,14 @@
 #include "NgeWriter.h"
 #include "NgeReader.h"
 #include "SurfFlatRegion.h"
-#include "DistPointLine.h"
 #include "Triangulate.h"
 #include "GeoConst.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistLineLine.h"
+#include "/EgtDev/Include/EGkDistPointSurfTm.h"
 #include "/EgtDev/Include/EGkIntersLinePlane.h"
 #include "/EgtDev/Include/EGkPointGrid3d.h"
+#include "/EgtDev/Include/EGkPolygon3d.h"
 #include "/EgtDev/Include/EGkPolyLine.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
@@ -44,7 +46,7 @@ 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_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_nMaxTFlag( 0), m_nParts( -1), m_nShells( -1), m_pHGrd3d( nullptr)
 {
    m_dCosBndAng = cos( m_dBoundaryAng * DEGTORAD) ;
    m_dCosSmAng = cos( m_dSmoothAng * DEGTORAD) ;
@@ -84,6 +86,7 @@ SurfTriMesh::Init( int nNumVert, int nNumTria, int nNumFacet)
    m_bClosed = false ;
    m_nMaxTFlag = 0 ;
    m_nParts = -1 ;
+   m_nShells = -1 ;
 
    return true ;
 }
@@ -115,6 +118,7 @@ SurfTriMesh::Clear( void)
    m_dTempParam[1] = 0 ;
    m_nMaxTFlag = 0 ;
    m_nParts = -1 ;
+   m_nShells = -1 ;
    return true ;
 }
 
@@ -125,6 +129,7 @@ SurfTriMesh::AddVertex( const Point3d& ptVert, double dU, double dV)
    // imposto ricalcolo
    m_nStatus = TO_VERIFY ;
    m_nParts = - 1 ;
+   m_nShells = -1 ;
    m_OGrMgr.Reset() ;
    ResetHashGrids3d() ;
    // inserisco il vertice
@@ -156,6 +161,7 @@ SurfTriMesh::MoveVertex( int nInd, const Point3d& ptNewVert)
   // imposto ricalcolo
    m_nStatus = TO_VERIFY ;
    m_nParts = - 1 ;
+   m_nShells = - 1 ;
    m_bFaceted = false ;
    m_bFacEdged = false ;
    m_OGrMgr.Reset() ;
@@ -225,6 +231,7 @@ SurfTriMesh::AddTriangle( const int nIdVert[3], int nTFlag)
   // imposto ricalcolo
    m_nStatus = TO_VERIFY ;
    m_nParts = - 1 ;
+   m_nShells = -1 ;
    m_OGrMgr.Reset() ;
    ResetHashGrids3d() ;
   // inserisco il triangolo
@@ -316,6 +323,7 @@ SurfTriMesh::RemoveTriangle( int nId)
    m_bFacEdged = false ;
   // invalido calcolo connettività
    m_nParts = - 1 ;
+   m_nShells = -1 ;
    return true ;
 }
 
@@ -905,6 +913,7 @@ SurfTriMesh::CloneTriangle( int nT) const
    pSurfTM->m_dSmoothAng = m_dSmoothAng ;
    pSurfTM->m_dCosSmAng = m_dCosSmAng ;
    pSurfTM->m_nParts = 1 ;
+   pSurfTM->m_nShells = 1 ;
 
   // Copio il triangolo
    int nNewInd[3] = { pSurfTM->AddVertex( m_vVert[m_vTria[nT].nIdVert[0]].ptP),
@@ -1177,6 +1186,78 @@ SurfTriMesh::GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR&
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+SurfTriMesh::GetSilhouette( const Plane3d& plPlane, double dTol, POLYLINEVECTOR& vPL, bool bAllTria) const
+{
+  // Verifico lo stato
+   if ( m_nStatus != OK)
+      return false ;
+
+  // Verifico la direzione
+   Vector3d vtVers = plPlane.GetVersN() ;
+   if ( ! vtVers.Normalize())
+      return false ;
+
+  // Controlli su tolleranza
+   dTol = max( dTol, 100 * EPS_SMALL) ;
+
+  // Determino il riferimento di proiezione
+   Frame3d frOCS ; frOCS.Set( plPlane.GetPoint(), vtVers) ;
+
+  // Ottengo la Silhouette come unione delle regioni dei triangoli proiettati (solo parti sopra il piano)
+  // calcolo la regione dei triangoli proiettati
+   PtrOwner<SurfFlatRegion> pSfr ;
+   Triangle3d Tria ;
+   int nT = GetFirstTriangle( Tria) ;
+   while ( nT != SVT_NULL) {
+     // verifico la normale
+      if ( ( bAllTria  &&  abs( Tria.GetN() * vtVers) > EPS_ZERO)  ||
+           ( ! bAllTria  &&  Tria.GetN() * vtVers > EPS_ZERO)) {
+        // ricavo il poligono equivalente al triangolo
+         Polygon3d pgTria ;
+         pgTria.FromTriangle( Tria) ;
+        // taglio il poligono con il piano
+         pgTria.Trim( plPlane, false, true, bAllTria) ;
+        // se rimasto qualcosa
+         if ( pgTria.GetSideCount() > 0) {
+           // lo proietto sul piano e creo la regione
+            pgTria.Scale( frOCS, 1, 1, 0) ;
+            PtrOwner<SurfFlatRegion> pSfrTria( GetBasicSurfFlatRegion( GetSurfFlatRegionFromPolyLine( pgTria.GetPolyLine()))) ;
+            if ( ! IsNull( pSfrTria)) {
+               if ( bAllTria  &&  Tria.GetN() * vtVers < 0)
+                  pSfrTria->Invert() ;
+               pSfrTria->Offset( dTol, ICurve::OFF_FILLET) ;
+               if ( IsNull( pSfr))
+                  pSfr.Set( pSfrTria) ;
+               else
+                  pSfr->Add( *pSfrTria) ;
+            }
+         }
+      }
+     // passo al successivo
+      nT = GetNextTriangle( nT, Tria) ;
+   }
+
+  // Se non esiste la regione
+   if ( IsNull( pSfr))
+      return false ;
+
+  // Effettuo contro-offset
+   pSfr->Offset( -dTol, ICurve::OFF_EXTEND) ;
+
+  // Recupero i contorni della regione
+   for ( int i = 0 ; i < pSfr->GetChunkCount() ; ++ i) {
+      for ( int j = 0 ; j < pSfr->GetLoopCount( i) ; ++ j) {
+         PolyLine PL ;
+         if ( pSfr->ApproxLoopWithLines( i, j, LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
+            vPL.emplace_back( PL) ;
+      }
+   }
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 SurfTriMesh*
 SurfTriMesh::Clone( void) const
@@ -1231,6 +1312,7 @@ SurfTriMesh::CopyFrom( const SurfTriMesh& stmSrc)
    m_nTempProp[1] = stmSrc.m_nTempProp[1] ;
    m_nMaxTFlag = stmSrc.m_nMaxTFlag ;
    m_nParts = stmSrc.m_nParts ;
+   m_nShells = stmSrc.m_nShells ;
    m_dTempParam[0] = stmSrc.m_dTempParam[0] ;
    m_dTempParam[1] = stmSrc.m_dTempParam[1] ;
    return true ;
@@ -1268,10 +1350,12 @@ SurfTriMesh::Dump( string& sOut, bool bMM, const char* szNewLine) const
   // segnalo eventuale incongruenza di orientamento
    if ( ! m_bOriented)
       sOut += string( "Inconsistent Orientation") + szNewLine ;
-  // segnalo numero di parti se più di una
+  // segnalo numero di parti
    int nParts = GetPartCount() ;
-   if ( nParts > 1)
+   sOut += string( "Parts=") + ToString( nParts) + szNewLine ;
-      sOut += string( "Parts =") + ToString( nParts) + szNewLine ;
+  // segnalo numero di gusci
+   int nShells = GetShellCount() ;
+   sOut += string( "Shells=") + ToString( nShells) + szNewLine ;
   // numero di vertici
    sOut += "Vert : Nbr=" + ToString( GetVertexCount()) +
                 " Size=" + ToString( GetVertexSize()) + szNewLine ;
@@ -1382,6 +1466,7 @@ SurfTriMesh::Load( NgeReader& ngeIn)
    m_OGrMgr.Clear() ;
    m_nMaxTFlag = 0 ;
    m_nParts = -1 ;
+   m_nShells = -1 ;
    ResetHashGrids3d() ;
   // leggo la prossima linea ( 2 parametri : dLinTol e dSmoothAng)
   // tolleranza lineare di costruzione
@@ -1542,6 +1627,7 @@ SurfTriMesh::Validate( bool bCorrect)
 
   // invalido calcolo connessione
    m_nParts = - 1 ;
+   m_nShells = -1 ;
 
    return ( m_nStatus == OK) ;
 }
@@ -1817,6 +1903,7 @@ SurfTriMesh::AdjustTopology( void)
    m_bFacEdged = false ;
   // invalido calcolo connessione
    m_nParts = - 1 ;
+   m_nShells = - 1 ;
   // verifica indici
    if ( ! Validate( true))
       return false ;
@@ -3568,6 +3655,17 @@ SurfTriMesh::GetPartCount( void) const
    return m_nParts ;
 }
 
+//----------------------------------------------------------------------------
+int
+SurfTriMesh::GetShellCount( void) const
+{
+   if ( ! IsValid())
+      return 0 ;
+   if ( m_nShells == - 1  &&  ! VerifyConnection())
+      return 0 ;
+   return m_nShells ;
+}
+
 //----------------------------------------------------------------------------
 bool
 SurfTriMesh::VerifyConnection( void) const
@@ -3576,19 +3674,21 @@ SurfTriMesh::VerifyConnection( void) const
       return false ;
 
   // reset connessione
-   for ( auto Tria : m_vTria)
+   for ( auto& Tria : m_vTria) {
       Tria.nPart = SVT_NULL ;
+      Tria.nShell = SVT_NULL ;
+   }
 
-  // ciclo sui triangoli
+  // ciclo sui triangoli per determinare le shells
-   m_nParts = 0 ;
+   m_nShells = 0 ;
    for ( int i = 0 ; i < int( m_vTria.size()) ; ++ i) {
-     // salto triangoli cancellati o gi� assegnati
+     // salto triangoli cancellati o già assegnati
       if ( m_vTria[i].nIdVert[0] == SVT_DEL  ||
-           m_vTria[i].nPart != SVT_NULL)
+           m_vTria[i].nShell != SVT_NULL)
          continue ;
      // assegno indice di parte connessa al triangolo
-      m_vTria[i].nPart = m_nParts ;
+      m_vTria[i].nShell = m_nShells ;
-      ++ m_nParts ;
+      ++ m_nShells ;
      // set di triangoli da aggiornare
       set<int> stTria ;
       stTria.insert( i) ;
@@ -3600,13 +3700,137 @@ SurfTriMesh::VerifyConnection( void) const
         // aggiorno i triangoli adiacenti
          for ( int j = 0 ; j < 3 ; ++ j) {
             int nAdjT = m_vTria[nT].nIdAdjac[j] ;
-            if ( nAdjT != SVT_NULL  &&  m_vTria[nAdjT].nPart == SVT_NULL) {
+            if ( nAdjT != SVT_NULL  &&  m_vTria[nAdjT].nShell == SVT_NULL) {
-               m_vTria[nAdjT].nPart = m_vTria[nT].nPart ;
+               m_vTria[nAdjT].nShell = m_vTria[nT].nShell ;
                stTria.insert( nAdjT) ;
             }
          }
       }
    }
+
+  // identifico le parti
+   m_nParts = 0 ;
+   if ( m_nShells == 1) { // se ho solo una shell allora ho una sola parte
+      m_nParts = 1 ;
+      for ( auto& Tria : m_vTria)
+         Tria.nPart = Tria.nShell ;
+   }
+   else { // se ho più shells devo controllare la loro posizione
+     // salvo solo le Shells chiuse e per ognuna di esse il loro volume e l'indice della shell
+     // < stmShell, ( nShellInd, dVol) >
+     // NB. I Volumi sono sempre finiti, il segno del volume mi dice solo se sto considerando
+     // la parte interna o esterna della superficie
+      typedef pair<PtrOwner<ISurfTriMesh>, pair<int, double>> SHELLINFO ;
+      vector<SHELLINFO> vClosedShells ;
+      vClosedShells.reserve( m_nShells) ;
+      INTVECTOR vOpenShells ;    // vettore di indici di Shell aperte
+      for ( int s = 0 ; s < GetShellCount() ; ++ s) {
+        // recupero la Shell
+         PtrOwner<ISurfTriMesh> pStmShell( CloneShell( s)) ;
+         if ( IsNull( pStmShell)  ||  ! pStmShell->IsValid())
+            return false ;
+         double dVol = 0. ;
+        // se chiusa calcolo il suo volume con segno
+         if ( pStmShell->IsClosed()) {
+            pStmShell->GetVolume( dVol) ;
+            vClosedShells.emplace_back( make_pair( Release( pStmShell), make_pair( s, dVol))) ;
+         }
+        // se aperta, non rientra nella classficazione ( sarà coincidente ad una Part)
+         else
+            vOpenShells.push_back( s) ;
+      }
+
+     // ordino il vettore in senso decrescente per volume, in valore assoluto
+     // NB. tutte le shell con volume negativo sono state invertite !
+      sort( vClosedShells.begin(), vClosedShells.end(),
+            []( const SHELLINFO& a, const SHELLINFO& b) {
+               return abs( a.second.second) > abs( b.second.second) ;
+            }) ;
+
+     // se la superficie in prima posizione è negativa, allora le inverto tutte; il numero di
+     // Parts non cambia nel conto
+      if ( ! vClosedShells.empty()  &&  vClosedShells.front().second.second < - EPS_SMALL)
+         for ( auto& Shell : vClosedShells)
+            Shell.first->Invert() ;
+
+     // creo una matrice di interi ; ogni riga corrisponde ad una Parte, dove in posizione 0 c'è
+     // la shell esterna e nelle successive le rispettiva shells interne
+      INTMATRIX vnShellIndMat ;
+
+      bool bFirstShell ;         // flag per indicare se la shell corrente è esterna
+      int nIndExtShell = -1 ;    // indice del vettore di shell chiuse della shell esterna
+      INTVECTOR vIndIntShells ;  // vettore di indici di shell chiuse interne alla shell esterna corrente
+      do {
+         bFirstShell = true ;
+         for ( int i = 0 ; i < int( vClosedShells.size()) ; ++ i) {
+           // recupero l'indice della shell e verifico che sia valido
+            int j = vClosedShells[i].second.first ;
+            if ( j < 0)
+               continue ;
+           // lo inserisco come esterno...
+            if ( bFirstShell) {
+               vnShellIndMat.push_back({ j}) ;
+               vClosedShells[i].second.first = -1 ;
+               bFirstShell = false ;
+               nIndExtShell = i ;
+               vIndIntShells.clear() ;
+            }
+           // altrimento verifico se la shell è interna o no
+            else {
+              // la shell è interna se è sia interna alla shell esterna corrente ( della riga di
+              // vnShellIndMat ) e allo stesso tempo esterna a tutte le shell già inserite nella riga
+              // attuale.
+               Point3d ptCheck ;
+               vClosedShells[i].first->GetFirstVertex( ptCheck) ;
+
+              // 1) verifica rispetto alla shell esterna
+               DistPointSurfTm distCalculator( ptCheck, *vClosedShells[nIndExtShell].first) ;
+               if ( ! distCalculator.IsPointInside())
+                  continue ;
+
+              // 2) verifica rispetto a tutte la shell già trovate interne
+               bool bOk = true ;
+               for ( int k = 1 ; k < int( vIndIntShells.size()) ; ++ k) {
+                  DistPointSurfTm distCalculator( ptCheck, *vClosedShells[vIndIntShells[k]].first) ;
+                 // NB. tutte le shell hanno volume negativo !
+                  if ( ! distCalculator.IsPointInside()) {
+                     bOk = false ;
+                     break ;
+                  }
+               }
+               if ( bOk) {
+                 // inserisco nella matrice
+                  vnShellIndMat.back().push_back( j) ;
+                  vClosedShells[i].second.first = - 1 ;
+                  vIndIntShells.push_back( i) ;
+               }
+            }
+         }
+      } while ( ! bFirstShell) ;
+
+     // scorro le righe della matrice e assegno la Part ( ovvero la riga )
+      int nPart = 0 ;
+      for ( nPart = 0 ; nPart < int( vnShellIndMat.size()) ; ++ nPart) {
+         ++ m_nParts ;
+         for ( int j = 0 ; j < int( vnShellIndMat[nPart].size()) ; ++ j) {
+            for ( auto& Tria : m_vTria) {
+               if ( Tria.nShell == j)
+                  Tria.nPart = nPart ;
+            }
+         }
+      }
+
+     // per tutte le superfici aperte, assegno loro una Parte
+      for ( int i = 0 ; i < int( vOpenShells.size()) ; ++ i) {
+         ++ m_nParts ;
+         for ( auto& Tria : m_vTria) {
+            if ( Tria.nShell == i)
+               Tria.nPart = i + ( nPart ++ ) ;
+         }
+      }
+
+   }
+
    return true ;
 }
 
@@ -3642,6 +3866,38 @@ SurfTriMesh::RemovePart( int nPart)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+SurfTriMesh::RemoveShell( int nShell)
+{
+   if ( ! IsValid())
+      return false ;
+
+  // Il numero delle componenti deve essere maggiore di zero o calcolabile
+   if ( m_nShells == -1  &&  ! VerifyConnection())
+      return false ;
+
+  // Se la componente non esiste, errore
+   if ( m_nShells <= 0  ||  nShell < 0  ||  nShell >= m_nShells)
+      return false ;
+
+   int nShellsOld = m_nShells ;
+  // Rimuovo i triangoli della componente nPart
+   for ( int i = 0 ; i < int( m_vTria.size()) ; ++ i) {
+      if ( m_vTria[i].nShell == nShell)
+         RemoveTriangle( i) ;
+   }
+
+  // Aggiorno il numero di componenti
+   m_nShells = nShellsOld - 1 ;
+
+  // imposto ricalcolo della grafica e di hashgrids3d
+   m_OGrMgr.Reset() ;
+   ResetHashGrids3d() ;
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 SurfTriMesh*
 SurfTriMesh::ClonePart( int nPart) const
@@ -3669,6 +3925,7 @@ SurfTriMesh::ClonePart( int nPart) const
    pSurfTM->m_dSmoothAng = m_dSmoothAng ;
    pSurfTM->m_dCosSmAng = m_dCosSmAng ;
    pSurfTM->m_nParts = 1 ;
+   pSurfTM->m_nShells = 1 ;
 
   // Copio i triangoli
    for ( int i = 0 ; i < int( m_vTria.size()) ; ++ i) {
@@ -3688,6 +3945,53 @@ SurfTriMesh::ClonePart( int nPart) const
    return Release( pSurfTM) ;
 }
 
+//----------------------------------------------------------------------------
+SurfTriMesh* 
+SurfTriMesh::CloneShell( int nShell) const
+{
+   if ( ! IsValid())
+      return nullptr ;
+
+  // Il numero delle componenti deve essere maggiore di zero o calcolabile
+   if ( m_nShells == -1  &&  ! VerifyConnection())
+      return nullptr ;
+
+  // Se la componente non esiste, errore
+   if ( m_nShells <= 0  ||  nShell < 0  ||  nShell >= m_nShells)
+      return nullptr ;
+
+  // Creo nuovo oggetto SurfTriMesh
+   PtrOwner<SurfTriMesh> pSurfTM( new( nothrow) SurfTriMesh) ;
+   if ( IsNull( pSurfTM))
+      return nullptr ;
+
+  // Copio il valore dei membri
+   pSurfTM->m_dLinTol = m_dLinTol ;
+   pSurfTM->m_dBoundaryAng = m_dBoundaryAng ;
+   pSurfTM->m_dCosBndAng = m_dCosBndAng ;
+   pSurfTM->m_dSmoothAng = m_dSmoothAng ;
+   pSurfTM->m_dCosSmAng = m_dCosSmAng ;
+   pSurfTM->m_nParts = 1 ;
+   pSurfTM->m_nShells = 1 ;
+
+  // Copio i triangoli
+   for ( int i = 0 ; i < int( m_vTria.size()) ; ++ i) {
+      if ( m_vTria[i].nIdVert[0] != SVT_DEL  &&  m_vTria[i].nShell == nShell) {
+         int nNewInd[3] = { pSurfTM->AddVertex( m_vVert[m_vTria[i].nIdVert[0]].ptP),
+                            pSurfTM->AddVertex( m_vVert[m_vTria[i].nIdVert[1]].ptP),
+                            pSurfTM->AddVertex( m_vVert[m_vTria[i].nIdVert[2]].ptP)} ;
+         if ( pSurfTM->AddTriangle( nNewInd, m_vTria[i].nTFlag) == SVT_NULL)
+            return nullptr ;
+      }
+   }
+
+  // Aggiusto la superficie
+   pSurfTM->DoCompacting() ;
+
+  // Restituisco la nuova superficie
+   return Release( pSurfTM) ;
+}
+
 //----------------------------------------------------------------------------
 bool
 SurfTriMesh::ResetTFlags( void)

SurfTriMesh.h

@@ -52,16 +52,16 @@ class StmTria
    public :
       StmTria( void)
          : nIdVert{ SVT_NULL, SVT_NULL, SVT_NULL}, nIdAdjac{ SVT_NULL, SVT_NULL, SVT_NULL}, nETempFlag{ 0, 0, 0},
-           vtN(), nIdFacet( SVT_NULL), nTFlag( 0), nEFlag( 0), nPart( SVT_NULL), nTemp( 0), nTempPart{ 0} {}
+         vtN(), nIdFacet( SVT_NULL), nTFlag( 0), nEFlag( 0), nShell( SVT_NULL), nPart( SVT_NULL), nTemp( 0), nTempShell{ 0}, nTempPart{ 0} {}
       StmTria( const int nIdV[3])
          : nIdVert{ nIdV[0], nIdV[1], nIdV[2]}, nIdAdjac{ SVT_NULL, SVT_NULL, SVT_NULL}, nETempFlag{ 0, 0, 0},
-           vtN(), nIdFacet( SVT_NULL), nTFlag( 0), nEFlag( 0), nPart( SVT_NULL), nTemp( 0), nTempPart{ 0} {}
+           vtN(), nIdFacet( SVT_NULL), nTFlag( 0), nEFlag( 0), nShell( SVT_NULL), nPart( SVT_NULL), nTemp( 0), nTempShell{ 0}, nTempPart{ 0} {}
       StmTria( const int nIdV[3], int nTF)
          : nIdVert{ nIdV[0], nIdV[1], nIdV[2]}, nIdAdjac{ SVT_NULL, SVT_NULL, SVT_NULL}, nETempFlag{ 0, 0, 0},
-           vtN(), nIdFacet( SVT_NULL), nTFlag( nTF), nEFlag( 0), nPart( SVT_NULL), nTemp( 0), nTempPart{ 0} {}
+           vtN(), nIdFacet( SVT_NULL), nTFlag( nTF), nEFlag( 0), nShell( SVT_NULL), nPart( SVT_NULL), nTemp( 0), nTempShell{ 0}, nTempPart{ 0} {}
       StmTria( const int nIdV[3], const int nIdA[3], const Vector3d& vtV, int nTF, int nEF)
          : nIdVert{ nIdV[0], nIdV[1], nIdV[2]}, nIdAdjac{ nIdA[0], nIdA[1], nIdA[2]}, nETempFlag{ 0, 0, 0},
-           vtN( vtV), nIdFacet( SVT_NULL), nTFlag( nTF), nEFlag( nEF), nPart( SVT_NULL), nTemp( 0), nTempPart{ 0} {}
+           vtN( vtV), nIdFacet( SVT_NULL), nTFlag( nTF), nEFlag( nEF), nShell( SVT_NULL), nPart( SVT_NULL), nTemp( 0), nTempShell{ 0}, nTempPart{ 0} {}
    public :
       int nIdVert[3] ;
       int nIdAdjac[3] ;
@@ -70,9 +70,12 @@ class StmTria
       int nIdFacet ;
       int nTFlag ;
       int nEFlag ;
+      mutable int nShell ;
       mutable int nPart ;
       mutable int nTemp ;
+      mutable int nTempShell ;
       mutable int nTempPart ;
+
 } ;
 
 //----------------------------------------------------------------------------
@@ -279,6 +282,7 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       SurfTriMesh* CloneTriangle( int nT) const override ;
       bool GetLoops( POLYLINEVECTOR& vPL) const override ;
       bool GetSilhouette( const Vector3d& vtDir, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false) const override ;
+      bool GetSilhouette( const Plane3d& plPlane, double dTol, POLYLINEVECTOR& vPL, bool bAllTria = false) const override ;
       int  GetFacetCount( void) const override ;
       int  GetFacetSize( void) const override
               { return int( m_vFacet.size()) ; }
@@ -316,8 +320,11 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       bool GetAllTriaOverlapBox( const BBox3d& b3Box, INTVECTOR& vT) const override ;
       const BBox3d& GetAllTriaBox( void) const override ;
       int GetPartCount( void) const override ;
+      int GetShellCount( void) const override ;
       bool RemovePart( int nPart) override ;
+      bool RemoveShell( int nShell) override ;
       SurfTriMesh* ClonePart( int nPart) const override ;
+      SurfTriMesh* CloneShell( int nShell) const override ;
       bool SetTFlag( int nId, int nTFlag) override ;
       bool GetTFlag( int nId, int& nFlag) const override ;
       int  GetMaxTFlag( void) const override 
@@ -404,6 +411,7 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       bool AmbiguosTriangleManager( TRIA3DVECTORMAP& Ambiguos, SurfTriMesh& Surf) ;
       bool IntersectTriMeshTriangle( SurfTriMesh& Other) ;
       bool IdentifyParts( void) const ;
+      bool IdentifyShells( void) const ;
       bool RemoveDoubleTriangles( bool& bModified) ;
       bool RemoveTJunctions( bool& bModified) ;
       bool FlipTriangles( int nTA, int nTB) ;
@@ -434,9 +442,10 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       int            m_nTempProp[2] ;  // vettore proprietà temporanee
       double         m_dTempParam[2] ; // vettore parametri temporanei
       int            m_nMaxTFlag ;     // massimo valore dei TFlag dei triangoli
-      mutable int    m_nParts ;        // numero di parti connesse (-1 se da calcolare)
+      mutable int    m_nParts ;        // numero di parti intese come volumi (-1 se da calcolare)
+      mutable int    m_nShells ;       // numero di gusci connessi (-1 se da calcolare)
       mutable HashGrids3d* m_pHGrd3d ; // Hash Grid 3d nel suo riferimento
-      mutable BBox3d m_b3HGrd3d ;      // Box3d collegato a Hash Grid 3d 
+      mutable BBox3d m_b3HGrd3d ;      // Box3d collegato a Hash Grid 3d
 } ;
 
 //-----------------------------------------------------------------------------

SurfTriMeshBooleans.cpp

@@ -17,13 +17,14 @@
 #include "CurveLine.h"
 #include "CurveComposite.h"
 #include "SurfFlatRegion.h"
-#include "DistPointLine.h"
 #include "Triangulate.h"
 #include "GeoConst.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EGkCurve.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkDistPointTria.h"
+#include "/EgtDev/Include/EGkDistPointSurfTm.h"
 #include "/EgtDev/Include/EGkIntersLineTria.h"
 #include "/EgtDev/Include/EGkIntersLineBox.h"
 #include "/EgtDev/Include/EGkIntersPlanePlane.h"
@@ -477,7 +478,7 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
                   Surf.m_vTria[nNewAloneTriaNum].nETempFlag[0] = 0 ;
                   Surf.m_vTria[nNewAloneTriaNum].nETempFlag[1] = 0 ;
                   Surf.m_vTria[nNewAloneTriaNum].nETempFlag[2] = 0 ;
-                  Surf.m_vTria[nNewAloneTriaNum].nTempPart = nDist[nAloneVert] ;
+                  Surf.m_vTria[nNewAloneTriaNum].nTempShell = nDist[nAloneVert] ;
                   bModif = true ;
                }
                int nNewCoupleId1[3] = { Surf.AddVertex( ptIntSt), Surf.AddVertex( trTria.GetP( ( nAloneVert + 1) % 3)), Surf.AddVertex( trTria.GetP( ( nAloneVert + 2) % 3)) } ;
@@ -486,7 +487,7 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
                   Surf.m_vTria[nNewCoupleTriaNum1].nETempFlag[0] = 0 ;
                   Surf.m_vTria[nNewCoupleTriaNum1].nETempFlag[1] = 0 ;
                   Surf.m_vTria[nNewCoupleTriaNum1].nETempFlag[2] = 0 ;
-                  Surf.m_vTria[nNewCoupleTriaNum1].nTempPart = - nDist[nAloneVert] ;
+                  Surf.m_vTria[nNewCoupleTriaNum1].nTempShell = - nDist[nAloneVert] ;
                   bModif = true ;
                }
                int nNewCoupleId2[3] = { Surf.AddVertex( ptIntSt), Surf.AddVertex( trTria.GetP( ( nAloneVert + 2) % 3)), Surf.AddVertex( ptIntEn) } ;
@@ -495,7 +496,7 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
                   Surf.m_vTria[nNewCoupleTriaNum2].nETempFlag[0] = 0 ;
                   Surf.m_vTria[nNewCoupleTriaNum2].nETempFlag[1] = 0 ;
                   Surf.m_vTria[nNewCoupleTriaNum2].nETempFlag[2] = 0 ;
-                  Surf.m_vTria[nNewCoupleTriaNum2].nTempPart = - nDist[nAloneVert] ;
+                  Surf.m_vTria[nNewCoupleTriaNum2].nTempShell = - nDist[nAloneVert] ;
                   bModif = true ;
                }
                continue ;
@@ -561,18 +562,18 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
                vnDegVec.resize( 1) ;
             }
             else {
-               Surf.m_vTria[it->first].nTempPart = 0 ;
+               Surf.m_vTria[it->first].nTempShell = 0 ;
                continue ;
             }
             vbInOut.resize( 1) ;
             vbInOut[0] = true ;
             if ( ! DecomposeLoop( cvOpenChain, vnDegVec, cvBoundClosedLoopVec, vbInOut)) {
-               Surf.m_vTria[it->first].nTempPart = 0 ;
+               Surf.m_vTria[it->first].nTempShell = 0 ;
                continue ;
             }
          }
          else {
-            Surf.m_vTria[it->first].nTempPart = 0 ;
+            Surf.m_vTria[it->first].nTempShell = 0 ;
             continue ;
          }
       }
@@ -730,9 +731,9 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
                      Surf.m_vTria[nNewTriaNum].nETempFlag[1] = 0 ;
                      Surf.m_vTria[nNewTriaNum].nETempFlag[2] = 0 ;
                      if ( vbInOut[nLoop])
-                        Surf.m_vTria[nNewTriaNum].nTempPart = 1 ;
+                        Surf.m_vTria[nNewTriaNum].nTempShell = 1 ;
                      else
-                        Surf.m_vTria[nNewTriaNum].nTempPart = - 1 ;
+                        Surf.m_vTria[nNewTriaNum].nTempShell = - 1 ;
                      bModif = true ;
                   }
                }
@@ -827,9 +828,9 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
                      Surf.m_vTria[nNewTriaNum].nETempFlag[1] = 0 ;
                      Surf.m_vTria[nNewTriaNum].nETempFlag[2] = 0 ;
                      if ( bCodirectedNormals)
-                        Surf.m_vTria[nNewTriaNum].nTempPart = -1 ;
+                        Surf.m_vTria[nNewTriaNum].nTempShell = -1 ;
                      else
-                        Surf.m_vTria[nNewTriaNum].nTempPart = 1 ;
+                        Surf.m_vTria[nNewTriaNum].nTempShell = 1 ;
                      bModif = true ;
                   }
                }
@@ -982,9 +983,9 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
                      Surf.m_vTria[nNewTriaNum].nETempFlag[1] = 0 ;
                      Surf.m_vTria[nNewTriaNum].nETempFlag[2] = 0 ;
                      if ( bCordirectedNormals_intLoop)
-                        Surf.m_vTria[nNewTriaNum].nTempPart = 1 ;
+                        Surf.m_vTria[nNewTriaNum].nTempShell = 1 ;
                      else
-                        Surf.m_vTria[nNewTriaNum].nTempPart = -1 ;
+                        Surf.m_vTria[nNewTriaNum].nTempShell = -1 ;
                      bModif = true ;
                   }
                }
@@ -1037,7 +1038,7 @@ SurfTriMesh::AmbiguosTriangleManager( TRIA3DVECTORMAP& Ambiguos, SurfTriMesh& Su
    for ( auto it = Ambiguos.begin() ; it != Ambiguos.end() ; ++ it) {
      // Se il triangolo ha l'indice diverso da zero vuol dire che oltre a un
      // contatto edge-edge ha avuto dei contatti che lo hanno già classificato.
-      if ( Surf.m_vTria[it->first].nTempPart != 0)
+      if ( Surf.m_vTria[it->first].nTempShell != 0)
          continue ;
      // Recupero il triangolo corrente
       Triangle3d trTria ;
@@ -1101,11 +1102,11 @@ SurfTriMesh::AmbiguosTriangleManager( TRIA3DVECTORMAP& Ambiguos, SurfTriMesh& Su
       for ( int i = 0 ; i < 3 ; ++ i) {
          if ( nTriaClassificationByEdges[i] == 0)
             continue ;
-         Surf.m_vTria[it->first].nTempPart = nTriaClassificationByEdges[i] ;
+         Surf.m_vTria[it->first].nTempShell = nTriaClassificationByEdges[i] ;
          int j ;
          for ( j = i + 1 ; j < 3 ; ++ j) {
             if ( nTriaClassificationByEdges[j] != 0  &&  nTriaClassificationByEdges[i] != nTriaClassificationByEdges[j]) {
-               Surf.m_vTria[it->first].nTempPart = 0 ;
+               Surf.m_vTria[it->first].nTempShell = 0 ;
                break ;
             }
          }
@@ -1145,13 +1146,13 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
 
   // Setto il triangolo come né fuori né dentro
    for ( int nTA = 0 ; nTA < nTriaNumA ; ++ nTA) {
-      m_vTria[nTA].nTempPart = 0 ;
+      m_vTria[nTA].nTempShell = 0 ;
       m_vTria[nTA].nETempFlag[0] = 0 ;
       m_vTria[nTA].nETempFlag[1] = 0 ;
       m_vTria[nTA].nETempFlag[2] = 0 ;
    }
    for ( int nTB = 0 ; nTB < nTriaNumB ; ++ nTB) {
-      SurfB.m_vTria[nTB].nTempPart = 0 ;
+      SurfB.m_vTria[nTB].nTempShell = 0 ;
       SurfB.m_vTria[nTB].nETempFlag[0] = 0 ;
       SurfB.m_vTria[nTB].nETempFlag[1] = 0 ;
       SurfB.m_vTria[nTB].nETempFlag[2] = 0 ;
@@ -1259,9 +1260,9 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
                           abs( ( trTriaA.GetP( ( nVA + 1) % 3) - trTriaB.GetP( 0)) * trTriaB.GetN()) < EPS_SMALL)
                         break ;
                   }
-                  m_vTria[nTA].nTempPart = ( ( trTriaA.GetP( nSegMaxDist) - trTriaB.GetP( 0)) * trTriaB.GetN() < - EPS_SMALL ? 1 : - 1) ;
+                  m_vTria[nTA].nTempShell = ( ( trTriaA.GetP( nSegMaxDist) - trTriaB.GetP( 0)) * trTriaB.GetN() < - EPS_SMALL ? 1 : - 1) ;
                   if ( nVA >= 0  && nVA <= 2)
-                     m_vTria[nTA].nETempFlag[nVA] = m_vTria[nTA].nTempPart ;
+                     m_vTria[nTA].nETempFlag[nVA] = m_vTria[nTA].nTempShell ;
                }
             }
            // caso di Intersezione interno-edge ( per superficie A con B)
@@ -1284,9 +1285,9 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
                           abs( ( trTriaB.GetP( ( nVB + 1) % 3) - trTriaA.GetP( 0)) * trTriaA.GetN()) < EPS_SMALL)
                         break ;
                   }
-                  SurfB.m_vTria[vNearTria[nTB]].nTempPart = ( ( trTriaB.GetP( nSegMaxDist) - trTriaA.GetP( 0)) * trTriaA.GetN() < - EPS_SMALL ? 1 : - 1) ;
+                  SurfB.m_vTria[vNearTria[nTB]].nTempShell = ( ( trTriaB.GetP( nSegMaxDist) - trTriaA.GetP( 0)) * trTriaA.GetN() < - EPS_SMALL ? 1 : - 1) ;
                   if ( nVB >= 0  &&  nVB <= 2)
-                     SurfB.m_vTria[vNearTria[nTB]].nETempFlag[nVB] = SurfB.m_vTria[vNearTria[nTB]].nTempPart ;
+                     SurfB.m_vTria[vNearTria[nTB]].nETempFlag[nVB] = SurfB.m_vTria[vNearTria[nTB]].nTempShell ;
                }
             }
            // Intersezione edge-edge: salvo indice e vettore triangoli
@@ -1326,171 +1327,28 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
    bool bRetriangulated = true ;
    if ( ! bModif  &&  ( int( AmbiguosA.size()) == 0  ||  int( AmbiguosB.size()) == 0)) {
       bRetriangulated = false ;
-      int nVertNum = 0 ;
+     // devo assegnare a tutti i triangoli della superficie la medesima proprietà ( definita da nInOutNum)
-      Point3d ptFirstV ;
+     // ( -1 -> esterno | 0 -> indefinito | +1 -> interno )
-      int nCurVert = GetFirstVertex( ptFirstV) ;
+     // devo farlo sia per la SurfA( *this) che per la SurfB
       int nInOutNum = 0 ;
-      while ( nInOutNum == 0  &&  nCurVert != SVT_NULL) {
+      for ( int v = 0 ; v < int( m_vVert.size())  &&  nInOutNum == 0 ; ++ v) {
-         INTVECTOR vnTriaNum ;
+         double dDist = 0. ;
-         double dMinDist = DBL_MAX ;
+         DistPointSurfTm distCalculator( m_vVert[v].ptP, SurfB) ;
-         for ( int nTB = 0 ; nTB < nTriaNumB ; ++ nTB) {
+         if ( distCalculator.GetDist( dDist)  &&  dDist > EPS_SMALL)
-           // Se il triangolo B non è valido, continuo
+            nInOutNum = ( distCalculator.IsPointOnLeftSide() ? 1 : -1) ;
-            Triangle3d trTriaB ;
-            if ( ! SurfB.GetTriangle( nTB, trTriaB)  ||  ! trTriaB.Validate( true))
-               continue ;
-            double dDist ;
-            // potrei trovare più triangolo equidistanti, li salvo tutti
-            if ( DistPointTriangle( ptFirstV, trTriaB).GetDist( dDist)) {
-               if ( abs(dDist - dMinDist) < EPS_SMALL)
-                  vnTriaNum.push_back( nTB) ;
-               else if ( dDist < dMinDist){
-                  vnTriaNum.clear() ;
-                  vnTriaNum.push_back( nTB) ;
-                  dMinDist = dDist ;
-               }
-            }
-         }
-         if ( ! vnTriaNum.empty()) {
-            Triangle3d trTriaB ;
-            bool bSame = true ;
-            // controllo se rispetto a questi triangoli il punto risulta sempre fuori o sempre dentro
-            for ( int nTriaNum : vnTriaNum) {
-               SurfB.GetTriangle( nTriaNum, trTriaB) ;
-               if ( ( ptFirstV - trTriaB.GetP(0)) * trTriaB.GetN() < - EPS_SMALL) {
-                  if ( nInOutNum == 0)
-                     nInOutNum = 1 ;
-                  else if ( nInOutNum == -1) {
-                     bSame = false ;
-                     break ;
-                  }
-               }
-               else if ( ( ptFirstV - trTriaB.GetP(0)) * trTriaB.GetN() > EPS_SMALL) {
-                  if ( nInOutNum == 0)
-                     nInOutNum = -1 ;
-                  else if ( nInOutNum == 1) {
-                     bSame = false ;
-                     break ;
-                  }
-               }
-            }
-            // se le informazioni date dalle normali dei triangoli non sono concordi valuto il triangolo più vicino
-            // e ricalcolo l'informazione che mi dà la sua normale
-            if ( ! bSame) {
-               Point3d ptBar_tot ;
-               for (int nTriaNum : vnTriaNum) {
-                  SurfB.GetTriangle( nTriaNum, trTriaB) ;
-                  ptBar_tot += trTriaB.GetCentroid();
-               }
-               ptBar_tot /= int( vnTriaNum.size()) ;
-               for ( int nTriaNum : vnTriaNum) {
-                  SurfB.GetTriangle( nTriaNum, trTriaB) ;
-                  Point3d ptInters1, ptInters2 ;
-                  int nInters = IntersLineTria( ptFirstV, ptBar_tot, trTriaB, ptInters1, ptInters2, true) ;
-                  if ( nInters == ILTT_NO)
-                     continue ;
-                  else if ( nInters == ILTT_IN) {
-                     if ( ( ptFirstV - trTriaB.GetP( 0)) * trTriaB.GetN() < - EPS_SMALL)
-                        nInOutNum = 1 ;
-                     else if ( ( ptFirstV - trTriaB.GetP( 0)) * trTriaB.GetN() > EPS_SMALL)
-                        nInOutNum = -1 ;
-                     break ;
-                  }
-                  else
-                     nInOutNum = 0 ;
-               }
-            }
-         }
-         if ( nInOutNum == 0) {
-            nCurVert = GetNextVertex( nVertNum, ptFirstV) ;
-            ++ nVertNum ;
-         }
       }
-
       for ( int nTA = 0 ; nTA < nTriaNumA ; ++ nTA)
-         m_vTria[nTA].nTempPart = nInOutNum ;
+         m_vTria[nTA].nTempShell = nInOutNum ;
 
-      nVertNum = 0 ;
-      nCurVert = SurfB.GetFirstVertex( ptFirstV) ;
       nInOutNum = 0 ;
-      while ( nInOutNum == 0  &&  nCurVert != SVT_NULL) {
+      for ( int v = 0 ; v < int( SurfB.m_vVert.size())  &&  nInOutNum == 0 ; ++ v) {
-         INTVECTOR vnTriaNum ;
+         double dDist = 0. ;
-         double dMinDist = DBL_MAX ;
+         DistPointSurfTm distCalculator( SurfB.m_vVert[v].ptP, *this) ;
-         for ( int nTA = 0 ; nTA < nTriaNumA ; ++ nTA) {
+         if ( distCalculator.GetDist( dDist)  &&  dDist > EPS_SMALL)
-            // Se il triangolo A non è valido, continuo
+            nInOutNum = ( distCalculator.IsPointOnLeftSide() ? 1 : -1) ;
-            Triangle3d trTriaA ;
-            if ( ! ( GetTriangle( nTA, trTriaA)  &&  trTriaA.Validate( true)))
-               continue ;
-            DistPointTriangle DistCalculator( ptFirstV, trTriaA) ;
-            double dDist ;
-            DistCalculator.GetDist( dDist) ;
-            // potrei trovare più triangolo equidistanti, li salvo tutti
-            if ( DistPointTriangle( ptFirstV, trTriaA).GetDist( dDist)) {
-               if ( abs( dDist - dMinDist) < EPS_SMALL)
-                  vnTriaNum.push_back( nTA) ;
-               else if ( dDist < dMinDist){
-                  vnTriaNum.clear() ;
-                  vnTriaNum.push_back( nTA) ;
-                  dMinDist = dDist ;
-               }
-            }
-         }
-         if ( ! vnTriaNum.empty()) {
-            Triangle3d trTriaA ;
-            bool bSame = true ;
-            // controllo se rispetto a questi triangoli il punto risulta sempre fuori o sempre dentro
-            for ( int nTriaNum : vnTriaNum) {
-               GetTriangle( nTriaNum, trTriaA) ;
-               if ( ( ptFirstV - trTriaA.GetP(0)) * trTriaA.GetN() < - EPS_SMALL) {
-                  if ( nInOutNum == 0)
-                     nInOutNum = 1 ;
-                  else if ( nInOutNum == -1) {
-                     bSame = false ;
-                     break ;
-                  }
-               }
-               else if ( ( ptFirstV - trTriaA.GetP(0)) * trTriaA.GetN() > EPS_SMALL) {
-                  if ( nInOutNum == 0)
-                     nInOutNum = -1 ;
-                  else if ( nInOutNum == 1) {
-                     bSame = false ;
-                     break ;
-                  }
-               }
-            }
-            // se le informazioni date dalle normali dei triangoli non sono concordi valuto il triangolo più vicino
-            // e ricalcolo l'informazione che mi dà la sua normale
-            if ( ! bSame) {
-               Point3d ptBar_tot ;
-               for ( int nTriaNum : vnTriaNum) {
-                  GetTriangle( nTriaNum, trTriaA) ;
-                  ptBar_tot += trTriaA.GetCentroid();
-               }
-               ptBar_tot /= int( vnTriaNum.size()) ;
-               for ( int nTriaNum : vnTriaNum) {
-                  GetTriangle( nTriaNum, trTriaA) ;
-                  Point3d ptInters1, ptInters2 ;
-                  int nInters = IntersLineTria( ptFirstV, ptBar_tot, trTriaA, ptInters1, ptInters2, true) ;
-                  if ( nInters == ILTT_NO)
-                     continue ;
-                  else if ( nInters == ILTT_IN) {
-                     if ( ( ptFirstV - trTriaA.GetP( 0)) * trTriaA.GetN() < - EPS_SMALL)
-                        nInOutNum = 1 ;
-                     else if ( ( ptFirstV - trTriaA.GetP( 0)) * trTriaA.GetN() > EPS_SMALL)
-                        nInOutNum = -1 ;
-                     break ;
-                  }
-                  else
-                     nInOutNum = 0 ;
-               }
-            }
-         }
-         if ( nInOutNum == 0) {
-            nCurVert = SurfB.GetNextVertex( nVertNum, ptFirstV) ;
-            ++ nVertNum ;
-         }
       }
       for ( int nTB = 0 ; nTB < nTriaNumB ; ++ nTB)
-         SurfB.m_vTria[nTB].nTempPart = nInOutNum ;
+         SurfB.m_vTria[nTB].nTempShell = nInOutNum ;
    }
 
   // Se c'è stata una ritriangolazione di almeno un triangolo, NON siamo nel caso di tutto dentro o tutto fuori.
@@ -1531,12 +1389,12 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
             Point3d ptTempA, ptTempB ;
             int nIntTypeAB = IntersTriaTria( trTriaA, trTriaB, ptTempA, ptTempB, vTriaAB) ;
             if ( nIntTypeAB == ITTT_OVERLAPS) {
-               m_vTria[nTA].nTempPart = 2 ;
+               m_vTria[nTA].nTempShell = 2 ;
-               SurfB.m_vTria[vNearTria[nTB]].nTempPart = 2 ;
+               SurfB.m_vTria[vNearTria[nTB]].nTempShell = 2 ;
             }
             else if ( nIntTypeAB == ITTT_COUNTER_OVERLAPS) {
-               m_vTria[nTA].nTempPart = -2 ;
+               m_vTria[nTA].nTempShell = -2 ;
-               SurfB.m_vTria[vNearTria[nTB]].nTempPart = -2 ;  
+               SurfB.m_vTria[vNearTria[nTB]].nTempShell = -2 ;  
             }
          }
       }
@@ -1579,70 +1437,139 @@ SurfTriMesh::IdentifyParts( void) const
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+SurfTriMesh::IdentifyShells( void) const
+{
+   for ( int i = 0 ; i < int( m_vTria.size()) ; ++ i) {
+     // salto triangoli cancellati o già assegnati
+      if ( m_vTria[i].nIdVert[0] == SVT_DEL  ||
+           abs( m_vTria[i].nTempShell) != 1)
+         continue ;
+     // set di triangoli da aggiornare
+      set<int> stTria ;
+      stTria.insert( i) ;
+      while ( ! stTria.empty()) {
+        // tolgo un triangolo dal set
+         const auto iIt = stTria.begin() ;
+         int nT = *iIt ;
+         stTria.erase( iIt) ;
+        // aggiorno i triangoli adiacenti
+         for ( int j = 0 ; j < 3 ; ++ j) {
+            if ( m_vTria[nT].nETempFlag[j] != 0)
+               continue ;
+            int nAdjT = m_vTria[nT].nIdAdjac[j] ;
+            if ( nAdjT != SVT_NULL  &&  m_vTria[nAdjT].nTempShell == 0) {
+               m_vTria[nAdjT].nTempShell = m_vTria[nT].nTempShell ;
+               stTria.insert( nAdjT) ;
+            }
+         }
+      }
+   }
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 SurfTriMesh::Add( const ISurfTriMesh& Other)
 {
-  // Le superfici devono essere valide
+
+  // le superfici devono essere valide
    if ( ! IsValid()  ||  ! Other.IsValid())
       return false ;
 
-  // Se la seconda è vuota non devo fare alcunchè
+  // se la seconda è vuota non devo fare alcunchè
    if ( Other.IsEmpty())
       return true ;
 
    m_OGrMgr.Clear() ;
 
-  // Se la prima è vuota, copio la seconda nella prima
+  // se la prima è vuota, copio la seconda nella prima
    if ( IsEmpty()) {
       CopyFrom( &Other) ;
       return true ;
    }
 
+  // clono la superficie B
    SurfTriMesh SurfB ;
    SurfB.CopyFrom( &Other) ;
 
+  // creazione del frame per scalare A e B
    Frame3d frScalingRef ;
    frScalingRef.Set( m_vVert[0].ptP, X_AX, Y_AX, Z_AX) ;
+  // scalo A e B
    Scale( frScalingRef, BOOLEAN_SCALE, BOOLEAN_SCALE, BOOLEAN_SCALE) ;
    SurfB.Scale( frScalingRef, BOOLEAN_SCALE, BOOLEAN_SCALE, BOOLEAN_SCALE) ;
 
-   IntersectTriMeshTriangle( SurfB) ;
+  // tengo una copia di B ( la superficie B viene modificata durante la ritriangolazione )
-   IdentifyParts() ;
+   SurfTriMesh SurfB_cl ;
-   SurfB.IdentifyParts() ;
+   SurfB_cl.CopyFrom( &SurfB) ;
 
+  // tengo una copia di B ( la superficie B viene modificata durante la ritriangolazione )
+   SurfTriMesh SurfA_cl ;
+   SurfA_cl.CopyFrom( this) ;
+ 
+  // ritriangolo le due superfici mediante ogni intersezione Triangolo-Triangolo
+   IntersectTriMeshTriangle( SurfB) ;
+
+  // assegno un medesimo indice ai triangoli che non interferiscono con altri
+   IdentifyShells() ;
+   SurfB.IdentifyShells() ;
+
+  // rimozione dei triangoli di A con proprietà 1 e -2 ( e gestione dei triangoli ambigui, 0)
    int nTriaNumA = GetTriangleSize() ;
    for ( int nTA = 0 ; nTA < nTriaNumA ; ++ nTA) {
-      if ( m_vTria[nTA].nTempPart == 1  ||  m_vTria[nTA].nTempPart == - 2)
+      if ( m_vTria[nTA].nTempShell == 1  ||  m_vTria[nTA].nTempShell == - 2)
          RemoveTriangle( nTA) ;
+     // se triangolo ambiguo
+      if ( m_vTria[nTA].nTempShell == 0) {
+         Triangle3d TriaA ;
+         GetTriangle( nTA, TriaA) ;
+        // rimuovo il triangolo se interno a surfB ( basta controllare un solo vertice(?) )
+         DistPointSurfTm distCalculator( TriaA.GetP( 0), SurfB_cl) ;
+         if ( distCalculator.IsPointOnLeftSide())
+            RemoveTriangle( nTA) ;
+      }
    }
+
+  // aggiunta di tutti i triangoli di B con proprietà -1 ( e gestione dei triangoli ambigui, 0)
    int nPrevMaxTFlag = m_nMaxTFlag ;
    int nTriaNumB = SurfB.GetTriangleSize() ;
    for ( int nTB = 0 ; nTB < nTriaNumB ; ++ nTB) {
-      if ( SurfB.m_vTria[nTB].nTempPart == - 1) {
+      bool bAdd = ( SurfB.m_vTria[nTB].nTempShell == - 1) ;
-         int nNewVert[3] ;
+      if ( ! bAdd) {
-         for ( int nV = 0 ; nV < 3 ; ++ nV) {
+        // se ambiguo
-            nNewVert[nV] = AddVertex( SurfB.m_vVert[SurfB.m_vTria[nTB].nIdVert[nV]].ptP) ;
+         if ( SurfB.m_vTria[nTB].nTempShell == 0) {
+           // aggiungo se il triangolo è a surfA ( basta controllare un solo vertice(?) )
+            DistPointSurfTm distCalculator( SurfB.m_vVert[SurfB.m_vTria[nTB].nIdVert[0]].ptP, SurfA_cl) ;
+            bAdd = ! distCalculator.IsPointOnLeftSide() ;
          }
+      }
+      if ( bAdd) {
+         int nNewVert[3] ;
+         for ( int nV = 0 ; nV < 3 ; ++ nV)
+            nNewVert[nV] = AddVertex( SurfB.m_vVert[SurfB.m_vTria[nTB].nIdVert[nV]].ptP) ;
          if ( nPrevMaxTFlag == m_nMaxTFlag)
             ++ m_nMaxTFlag ;
          AddTriangle( nNewVert, m_nMaxTFlag) ;
       }
    }
 
+  // sistemazioni varie
    bool bOk = ( AdjustVertices()  &&  DoCompacting()) ;
-
    bool bModified = false ;
    bOk = bOk && RemoveDoubleTriangles( bModified) ;
    if ( bModified)
       bOk = bOk && ( AdjustVertices()  &&  DoCompacting()) ;
-
    bOk = bOk && RemoveTJunctions( bModified) ;
    if ( bModified)
       bOk = bOk && ( AdjustVertices()  &&  DoCompacting()) ;
 
+  // scalo alla dimensioni originali
    Scale( frScalingRef, 1. / BOOLEAN_SCALE, 1. / BOOLEAN_SCALE, 1. / BOOLEAN_SCALE) ;
 
+  // semplifico eventuale geometria delle facce
    if ( ! SimplifyFacets())
       LOG_ERROR( GetEGkLogger(), "Error in SimplifyFacets of Stm::Add")
 
@@ -1653,6 +1580,7 @@ SurfTriMesh::Add( const ISurfTriMesh& Other)
 bool
 SurfTriMesh::Intersect( const ISurfTriMesh& Other)
 {
+
   // Le superfici devono essere valide
    if ( ! IsValid()  ||  ! Other.IsValid())
       return false ;
@@ -1681,29 +1609,51 @@ SurfTriMesh::Intersect( const ISurfTriMesh& Other)
    Scale( frScalingRef, BOOLEAN_SCALE, BOOLEAN_SCALE, BOOLEAN_SCALE) ;
    SurfB.Scale( frScalingRef, BOOLEAN_SCALE, BOOLEAN_SCALE, BOOLEAN_SCALE) ;
 
+  // tengo una copia di B ( la superficie B viene modificata durante la ritriangolazione )
+   SurfTriMesh SurfB_cl ;
+   SurfB_cl.CopyFrom( &SurfB) ;
+
+  // tengo una copia di B ( la superficie B viene modificata durante la ritriangolazione )
+   SurfTriMesh SurfA_cl ;
+   SurfA_cl.CopyFrom( this) ;
+
   // ritriangolo le due superfici mediante ogni intersezione Triangolo-Triangolo
    IntersectTriMeshTriangle( SurfB) ;
 
   // assegno un medesimo indice ai triangoli che non interferiscono con altri
-   IdentifyParts() ;
+   IdentifyShells() ;
-   SurfB.IdentifyParts() ;
+   SurfB.IdentifyShells() ;
 
-  // rimozione dei triangoli di A con proprietà -1 e -2
+  // rimozione dei triangoli di A con proprietà -1 e -2 (e gestione dei triangoli ambigui, 0)
    int nTriaNumA = GetTriangleSize() ;
    for ( int nTA = 0 ; nTA < nTriaNumA ; ++ nTA) {
-      if ( m_vTria[nTA].nTempPart == - 1  ||  m_vTria[nTA].nTempPart == - 2)
+      if ( m_vTria[nTA].nTempShell == - 1  ||  m_vTria[nTA].nTempShell == - 2)
          RemoveTriangle( nTA) ;
+     // se triangolo ambiguo
+      else if ( m_vTria[nTA].nTempShell == 0) {
+         Triangle3d TriaA ;
+         GetTriangle( nTA, TriaA) ;
+        // rimuovo il triangolo se fuori a surfB ( basta controllare un solo vertice(?) )
+         DistPointSurfTm distCalculator( TriaA.GetP( 0), SurfB_cl) ;
+         if ( ! distCalculator.IsPointOnLeftSide())
+            RemoveTriangle( nTA) ;
+      }
    }
 
-  // aggiunta dei triangoli di B con proprietà +1
+  // aggiunta dei triangoli di B con proprietà +1 ( e gestione dei triangoli ambigui, 0)
    int nPrevMaxTFlag = m_nMaxTFlag ;
    int nTriaNumB = SurfB.GetTriangleSize() ;
    for ( int nTB = 0 ; nTB < nTriaNumB ; ++ nTB) {
-      if ( SurfB.m_vTria[nTB].nTempPart == 1) {
+      bool bAdd = ( SurfB.m_vTria[nTB].nTempShell == 1) ;
+      if ( ! bAdd  &&  SurfB.m_vTria[nTB].nTempShell == 0) {
+        // aggiungo se il triangolo è interno a surfA ( basta controllare un solo vertice(?) )
+         DistPointSurfTm distCalculator( SurfB.m_vVert[SurfB.m_vTria[nTB].nIdVert[0]].ptP, SurfA_cl) ;
+         bAdd = distCalculator.IsPointOnLeftSide() ;
+      }
+      if ( bAdd) {
          int nNewVert[3] ;
          for ( int nV = 0 ; nV < 3 ; ++ nV)
             nNewVert[nV] = AddVertex( SurfB.m_vVert[SurfB.m_vTria[nTB].nIdVert[nV]].ptP) ;
-
          if ( nPrevMaxTFlag == m_nMaxTFlag)
             ++ m_nMaxTFlag ;
          AddTriangle( nNewVert, m_nMaxTFlag) ;
@@ -1720,33 +1670,6 @@ SurfTriMesh::Intersect( const ISurfTriMesh& Other)
    if ( bModified)
       bOk = bOk && ( AdjustVertices()  &&  DoCompacting()) ;
 
-  // rimuovo tutte le parti esterne all'intersezione
-   int nParts = GetPartCount() ;
-   if ( nParts > 1) {
-      for ( int i = 0 ; i < nParts ; ++ i) {
-        // recupero i triangoli della stessa Part
-         INTVECTOR vTriaPart ;
-         for ( int j = 0 ; j < int( m_vTria.size()) ; ++ j)
-            if ( m_vTria[j].nPart == i)
-               vTriaPart.push_back( j) ;
-        // controllo se il loro box interferisce con il box della superficie B
-         bool bErasePart = true ;
-         for ( int j = 0 ; j < int( vTriaPart.size())  &&  bErasePart ; ++ j) {
-           // Se il triangolo A non è valido, continuo
-            Triangle3d Tria ;
-            if ( ! GetTriangle( j, Tria)  ||  ! Tria.Validate( true))
-               continue ;
-           // Box del triangolo A
-            BBox3d b3dTriaA ; Tria.GetLocalBBox( b3dTriaA) ;
-           // Recupero i triangoli di B che interferiscono col box del triangolo di A
-            INTVECTOR vNearTria ; SurfB.GetAllTriaOverlapBox( b3dTriaA, vNearTria) ;
-            bErasePart = int( vNearTria.size() == 0) ;
-         }
-         if ( bErasePart)
-            RemovePart( i) ;
-      }
-   }
-
   // scalo alle dimensioni originali
    Scale( frScalingRef, 1. / BOOLEAN_SCALE, 1. / BOOLEAN_SCALE, 1. / BOOLEAN_SCALE) ;
 
@@ -1760,42 +1683,77 @@ SurfTriMesh::Intersect( const ISurfTriMesh& Other)
 bool
 SurfTriMesh::Subtract( const ISurfTriMesh& Other)
 {
-  // Le superfici devono essere valide
+
+  // le superfici devono essere valide
    if ( ! IsValid()  ||  ! Other.IsValid())
       return false ;
 
-  // Se una delle due è vuota non devo fare alcunchè
+  // se una delle due è vuota non devo fare alcunchè
    if ( IsEmpty()  ||  Other.IsEmpty())
       return true ;
 
+  // pulisco grafica
    m_OGrMgr.Clear() ;
 
+  // clono superficie B
    SurfTriMesh SurfB ;
    SurfB.CopyFrom( &Other) ;
 
-   Frame3d frScalingRef;
+  // creazione del frame per scalare A e B
+   Frame3d frScalingRef ;
    frScalingRef.Set( m_vVert[0].ptP, X_AX, Y_AX, Z_AX) ;
+  // scalo A e B
    Scale( frScalingRef, BOOLEAN_SCALE, BOOLEAN_SCALE, BOOLEAN_SCALE) ;
    SurfB.Scale( frScalingRef, BOOLEAN_SCALE, BOOLEAN_SCALE, BOOLEAN_SCALE) ;
 
+  // tengo una copia di B ( la superficie B viene modificata durante la ritriangolazione )
+   SurfTriMesh SurfB_cl ;
+   SurfB_cl.CopyFrom( &SurfB) ;
+
+  // tengo una copia di B ( la superficie B viene modificata durante la ritriangolazione )
+   SurfTriMesh SurfA_cl ;
+   SurfA_cl.CopyFrom( this) ;
+ 
+  // ritriangolo le due superfici mediante ogni intersezione Triangolo-Triangolo
    IntersectTriMeshTriangle( SurfB) ;
 
-   IdentifyParts() ;
+  // assegno un medesimo indice ai triangoli che non interferiscono con altri
-   SurfB.IdentifyParts() ;
+   IdentifyShells() ;
+   SurfB.IdentifyShells() ;
 
+  // rimozione dei triangoli di A con proprietà 1 e 2 ( e gestione triangoli ambigui, 0)
    int nTriaNumA = GetTriangleSize() ;
    for ( int nTA = 0 ; nTA < nTriaNumA ; ++ nTA) { 
-      if  ( m_vTria[nTA].nTempPart == 1  ||  m_vTria[nTA].nTempPart == 2)
+      if  ( m_vTria[nTA].nTempShell == 1  ||  m_vTria[nTA].nTempShell == 2)
          RemoveTriangle( nTA) ;
+     // se triangolo ambiguo...
+      if ( m_vTria[nTA].nTempShell == 0) {
+         Triangle3d TriaA ;
+         GetTriangle( nTA, TriaA) ;
+        // rimuovo il triangolo se interno a SurfB ( basta controllare un solo vertice(?) )
+         DistPointSurfTm distCalculator( TriaA.GetP( 0), SurfB_cl) ;
+         if ( distCalculator.IsPointOnLeftSide())
+            RemoveTriangle( nTA) ;
+      }
    }
+
+  // aggiunta dei triangoli di B con proprietà +1 ( e gestione triangoli ambigui, 0)
    int nPrevMaxTFlag = m_nMaxTFlag ;
    int nTriaNumB = SurfB.GetTriangleSize() ;
    for ( int nTB = 0 ; nTB < nTriaNumB ; ++ nTB) {
-      if ( SurfB.m_vTria[nTB].nTempPart == 1) {
+      bool bAdd = SurfB.m_vTria[nTB].nTempShell == 1 ;
-         int nNewVert[3] ;
+      if ( ! bAdd) {
-         for ( int nV = 0 ; nV < 3 ; ++ nV) {
+        // se ambiguo
-            nNewVert[nV] = AddVertex( SurfB.m_vVert[SurfB.m_vTria[nTB].nIdVert[nV]].ptP) ;
+         if ( SurfB.m_vTria[nTB].nTempShell == 0) {
+           // aggiungo il triangolo se interno alla SurfA ( basta controllare un solo vertice(?) )
+            DistPointSurfTm distCalculator( SurfB.m_vVert[SurfB.m_vTria[nTB].nIdVert[0]].ptP, SurfA_cl) ;
+            bAdd = distCalculator.IsPointOnLeftSide() ;
          }
+      }
+      if ( bAdd) {
+         int nNewVert[3] ;
+         for ( int nV = 0 ; nV < 3 ; ++ nV)
+            nNewVert[nV] = AddVertex( SurfB.m_vVert[SurfB.m_vTria[nTB].nIdVert[nV]].ptP) ;
          swap( nNewVert[1], nNewVert[2]) ;
          if ( nPrevMaxTFlag == m_nMaxTFlag)
             ++ m_nMaxTFlag ;
@@ -1803,22 +1761,23 @@ SurfTriMesh::Subtract( const ISurfTriMesh& Other)
       }
    }
 
+  // sistemazioni varie
    bool bOk = ( AdjustVertices()  &&  DoCompacting()) ;
-
    bool bModified = false ;
    bOk = bOk && RemoveDoubleTriangles( bModified) ;
    if ( bModified)
       bOk = bOk && ( AdjustVertices()  &&  DoCompacting()) ;
-
    bOk = bOk && RemoveTJunctions( bModified) ;
    if ( bModified)
       bOk = bOk && ( AdjustVertices()  &&  DoCompacting()) ;
 
+  // scalo alle dimensioni originali
    Scale( frScalingRef, 1. / BOOLEAN_SCALE, 1. / BOOLEAN_SCALE, 1. / BOOLEAN_SCALE) ;
 
+  // semplifico le facce
    if ( ! SimplifyFacets())
       LOG_ERROR( GetEGkLogger(), "Error in SimplifyFacets of Stm::Subtract")
-   
+
    return bOk ;
 }
 
@@ -1842,14 +1801,14 @@ SurfTriMesh::GetSurfClassification( const ISurfTriMesh& ClassifierSurf,
    SurfC.Scale( frScalingRef, BOOLEAN_SCALE, BOOLEAN_SCALE, BOOLEAN_SCALE) ;
 
    IntersectTriMeshTriangle( SurfC) ;
-   IdentifyParts() ;
+   IdentifyShells() ;
    Scale( frScalingRef, 1. / BOOLEAN_SCALE, 1. / BOOLEAN_SCALE, 1. / BOOLEAN_SCALE) ;
   
    int nTriaNum = GetTriangleSize() ;
    for ( int nT = 0 ; nT < nTriaNum ; ++ nT) {
       if ( m_vTria[nT].nIdVert[0] == SVT_DEL)
          continue ;
-      switch ( m_vTria[nT].nTempPart) {
+      switch ( m_vTria[nT].nTempShell) {
       case -2 : 
          vTriaOnM.push_back( nT) ;
          break ;
@@ -1894,13 +1853,13 @@ SurfTriMesh::CutWithOtherSurf( const ISurfTriMesh& CutterSurf, bool bInVsOut, bo
    SurfC.Scale( frScalingRef, BOOLEAN_SCALE, BOOLEAN_SCALE, BOOLEAN_SCALE) ;
 
    IntersectTriMeshTriangle( SurfC) ;
-   IdentifyParts() ;
+   IdentifyShells() ;
 
    int nPartToRemove = ( bInVsOut ? -1 : 1) ;
    int nCoplanarPartToRemove = ( bSaveOnEq ? ( nPartToRemove ? -2 : 2) : 5) ;
    int nTriaNum = GetTriangleSize() ;
    for ( int nT = 0 ; nT < nTriaNum ; ++ nT) {
-      if ( m_vTria[nT].nTempPart == nPartToRemove  ||  m_vTria[nT].nTempPart == nCoplanarPartToRemove)
+      if ( m_vTria[nT].nTempShell == nPartToRemove  ||  m_vTria[nT].nTempShell == nCoplanarPartToRemove)
          RemoveTriangle( nT) ;
    }
 

SurfTriMeshCuts.cpp

@@ -15,10 +15,10 @@
 #include "CurveComposite.h"
 #include "SurfTriMesh.h"
 #include "SurfFlatRegion.h"
-#include "DistPointLine.h"
 #include "Triangulate.h"
 #include "GeoConst.h"
 #include "/EgtDev/Include/EGkSfrCreate.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkIntersLinePlane.h"
 #include "/EgtDev/Include/EGkIntersPlaneTria.h"

SurfTriMeshUtilities.cpp

@@ -15,7 +15,7 @@
 #include "SurfTriMesh.h"
 #include "CurveLine.h"
 #include "Triangulate.h"
-#include "DistPointLine.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistLineLine.h"
 #include <unordered_map>
 

VolZmap.cpp

@@ -18,8 +18,8 @@
 #include "GdbGeo.h"
 #include "NgeWriter.h"
 #include "NgeReader.h"
-#include "DistPointLine.h"
 #include "GeoConst.h"
+#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkIntersLinePlane.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
 #include "/EgtDev/Include/EGkIntervals.h"

VolZmapVolume.cpp

@@ -892,7 +892,7 @@ VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, co
                                    const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe)
 {
   // Divido il movimento in tratti con direzione utensile costante
-   const double ANG_STEP = 0.02 ;
+   const double ANG_STEP = 0.04 ;
    double dAngDeg ; vtDs.GetAngle( vtDe, dAngDeg) ;
    int nStepCnt = int( abs( dAngDeg) / ANG_STEP) + 1 ;
    bool bOk = true ;