Tolto un commento

SurfTriMeshBooleans.cpp

@@ -26,11 +26,13 @@
 #include "/EgtDev/Include/EgkIntersLineTria.h"
 #include "/EgtDev/Include/EgkIntersLineBox.h"
 #include "/EgtDev/Include/EgkIntersPlanePlane.h"
+#include "/EgtDev/Include/EgkIntersLinePlane.h"
 #include "/EgtDev/Include/EgkIntersTriaTria.h"
 #include "/EgtDev/Include/EgkSfrCreate.h"
 #include "/EgtDev/Include/EGkChainCurves.h"
 #include "/EgtDev/Include/EGkGeoCollection.h"
 #include "/EgtDev/Include/EGkPolygon3d.h"
+#include "/EgtDev/Include/EGkIntersPlaneTria.h"
 #include "/EgtDev/Include/EgtPerfCounter.h"
 #include "/EgtDev/Include/EgnStringUtils.h"
 #include <algorithm>
@@ -45,96 +47,83 @@ static int
 IntersRectangleTriangle( const Point3d& ptP, const Vector3d& vtL1, const Vector3d& vtL2,
                          const Triangle3d& trTria, Point3d& ptStSeg, Point3d& ptEnSeg)
 {
-  // Definisco i due triangoli formanti il rettangolo
-   Triangle3d trTriaA ;
-   trTriaA.Set( ptP, ptP + vtL1, ptP + vtL2) ;
-   if ( ! trTriaA.Validate())
-      return -1 ;
-   Triangle3d trTriaB ;
-   trTriaB.Set( ptP + vtL1, ptP + vtL1 + vtL2, ptP + vtL2) ;
-   if ( ! trTriaB.Validate())
-      return -1 ;
-  // Interseco il triangolo con il primo dei due triangoli del rettangolo 
-   int nIntA = 0 ;
-   Point3d ptIntA1, ptIntA2 ;
-   TRIA3DVECTOR vTriaA ;
-   int nIntTypeA = IntersTriaTria( trTria, trTriaA, ptIntA1, ptIntA2, vTriaA) ;      
-   if ( nIntTypeA == ITTT_VERT_VERT  ||  nIntTypeA == ITTT_VERT_EDGE  ||  nIntTypeA == ITTT_VERT_INT  ||  nIntTypeA == ITTT_EDGE_VERT  ||  nIntTypeA == ITTT_EDGE_EDGE_PNT  ||  nIntTypeA == ITTT_INT_VERT)
-      nIntA = 1 ;   
-   else if ( /*nIntTypeA == ITTT_EDGE_EDGE_SEG  ||  nIntTypeA == ITTT_EDGE_INT  ||*/  nIntTypeA == ITTT_INT_EDGE  ||  nIntTypeA == ITTT_INT_INT_SEG) {
-      nIntA = 2 ;
-   }
-  // Interseco il triangolo con il secondo dei due triangoli del rettangolo 
-   int nIntB = 0 ;
-   Point3d ptIntB1, ptIntB2 ;
-   TRIA3DVECTOR vTriaB ;
-   int nIntTypeB = IntersTriaTria( trTria, trTriaB, ptIntB1, ptIntB2, vTriaB) ;
-   if ( nIntTypeB == ITTT_VERT_VERT  ||  nIntTypeB == ITTT_VERT_EDGE  ||  nIntTypeB == ITTT_VERT_INT  ||  nIntTypeB == ITTT_EDGE_VERT  ||  nIntTypeB == ITTT_EDGE_EDGE_PNT  ||  nIntTypeB == ITTT_INT_VERT)
-      nIntB = 1 ;     
-   else if ( /*nIntTypeB == ITTT_EDGE_EDGE_SEG  ||  nIntTypeB == ITTT_EDGE_INT  ||*/  nIntTypeB == ITTT_INT_EDGE  ||  nIntTypeB == ITTT_INT_INT_SEG) {
-      nIntB = 2 ;
-   }
-  // Unisco le due intersezioni
-   int nIntTot = nIntA + nIntB ;
-   if ( nIntTot == 4) {
-      if ( AreSamePointApprox( ptIntA2, ptIntB1)) {
-         ptStSeg = ptIntA1 ;
-         ptEnSeg = ptIntB2 ;
-      }
-      else {
-         ptStSeg = ptIntB1 ;
-         ptEnSeg = ptIntA2 ;
-      }
+   // Definisco il piano; se non definibile, segnalo un errore.
+   Plane3d plRectanglePlane ;
+   if ( ! plRectanglePlane.Set( ptP, vtL1 ^ vtL2))
+      return - 1 ;
+   // Interseco il triangolo con il piano: passo gli estremi del segmento al
+   // contrario per rispettare la regola che i loop hanno l'esterno a destra.
+   int nPlaneTriaIntersRes = IntersPlaneTria( plRectanglePlane, trTria, ptEnSeg, ptStSeg) ;
+   // Non trovo intersezione fra triangolo e piano; ho finito.
+   if ( nPlaneTriaIntersRes != IntPlaneTriaType::IPTT_YES)
+      return 0 ;
+   // Limito la linea col rettangolo.
+   Vector3d vtSegDir = ptEnSeg - ptStSeg ;
+   double dSegLen = vtSegDir.Len() ;
+   vtSegDir /= dSegLen ;
+   // Limito con un piano ortogonale al rettangolo.
+   Point3d ptLinePlaneInfInt ;
+   Plane3d plTrimPlaneInf ;
+   if ( vtSegDir * vtL1 > 0.)
+      plTrimPlaneInf.Set( ptP, - vtL1) ;
+   else
+      plTrimPlaneInf.Set( ptP + vtL1, vtL1) ;
+   int nLinePlaneInfInters = IntersLinePlane( ptStSeg, vtSegDir, dSegLen, plTrimPlaneInf, ptLinePlaneInfInt, false) ;
+   // Limito con l'altro piano ortogonale al rettangolo.
+   Point3d ptLinePlaneSupInt ;
+   Plane3d plTrimPlaneSup ;
+   if ( vtSegDir * vtL1 > 0.)
+      plTrimPlaneSup.Set( ptP + vtL1, vtL1) ;
+   else
+      plTrimPlaneSup.Set( ptP, - vtL1) ;
+   int nLinePlaneSupInters = IntersLinePlane( ptStSeg, vtSegDir, dSegLen, plTrimPlaneSup, ptLinePlaneSupInt, false) ;
+   // 
+   double dTol = EPS_SMALL/*EPS_ZERO*/ ;
+   if ( ( nLinePlaneInfInters == ILPT_NO  &&  nLinePlaneSupInters == ILPT_INPLANE)  ||
+        ( nLinePlaneSupInters == ILPT_NO  &&  nLinePlaneInfInters == ILPT_INPLANE)  ||
+        ( nLinePlaneInfInters == ILPT_NO  &&  nLinePlaneSupInters == ILPT_NO  &&
+          ( ptEnSeg - plTrimPlaneInf.GetPoint()) * plTrimPlaneInf.GetVersN() < 0.  &&
+          ( ptEnSeg - plTrimPlaneSup.GetPoint()) * plTrimPlaneSup.GetVersN() < 0.)) {
+      if ( AreSamePointEpsilon( ptStSeg, ptEnSeg, dTol))
+         return 1 ;
       return 2 ;
    }
-   else if ( nIntTot == 3) {
-      if ( nIntA == 2) {
-         ptStSeg = ptIntA1 ;
-         ptEnSeg = ptIntA2 ;
-      }
-      else {
-         ptStSeg = ptIntB1 ;
-         ptEnSeg = ptIntB2 ;
-      }
-      return 2 ;
+   //
+   double dInfU = ( ptLinePlaneInfInt - ptStSeg) * vtSegDir ;
+   double dSupU = ( ptLinePlaneSupInt - ptStSeg) * vtSegDir ;
+   if ( dInfU > dSegLen) {
+      return 0 ;
    }
-   else if ( nIntTot == 2) {
-      if ( nIntA == 2) {
-         ptStSeg = ptIntA1 ;
-         ptEnSeg = ptIntA2 ;
-      }
-      else if ( nIntA == 1) {
-         ptStSeg = ptIntA1 ;
-         ptEnSeg = ptIntB1 ;
-      }
-      else {
-         ptStSeg = ptIntB1 ;
-         ptEnSeg = ptIntB2 ;
-      }
-      return 2 ;
+   else if ( dInfU > 0.) {
+      ptStSeg += dInfU * vtSegDir ;
+      dSegLen -= dInfU ;
+      dSupU -= dInfU ;
    }
-   else if ( nIntTot == 1) {
-      if ( nIntA == 1)
-         ptStSeg = ptIntA1 ;
-      else
-         ptStSeg = ptIntB1 ;
-      return 1 ;
+   if ( dSupU < 0.)
+      return 0 ;
+   else if ( dSupU < dSegLen) {
+      dSegLen = dSupU ;
+      ptEnSeg = ptStSeg + dSegLen * vtSegDir ;
+   }
+
+   if ( dSegLen > dTol) {
+      return 2 ;
    }
    else
-      return 0 ;
+      return 1 ;
 }
 
 //----------------------------------------------------------------------------
 static bool
 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 ;
@@ -173,11 +162,11 @@ DistPointFacet( const Point3d& ptP, const POLYLINEVECTOR& vPolyVec, double& dPoi
       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 ;
@@ -191,7 +180,7 @@ DistPointFacet( const Point3d& ptP, const POLYLINEVECTOR& vPolyVec, double& dPoi
       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 ; 
@@ -204,7 +193,7 @@ DistPointFacet( const Point3d& ptP, const POLYLINEVECTOR& vPolyVec, double& dPoi
 static bool
 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) {
@@ -268,7 +257,7 @@ ChangeStart( const Point3d& ptNewStart, PNTVECTOR& Loop)
 static bool
 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) {
@@ -290,19 +279,20 @@ SplitAtPoint( const Point3d& ptStop, const PNTVECTOR& Loop, PNTVECTOR& Loop1, PN
   // 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)
-      Loop1.emplace_back( Loop[nPt]) ;
-  // Se il punto è interno al segmento, lo inglobo in entrambi i 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
    if ( ! ( bFirst  ||  bLast)) {
       Loop1.emplace_back( ptStop) ;
       Loop2.emplace_back( ptStop) ;
    }
    else {
-      Loop2.emplace_back( Loop[nMinSeg]) ;
+      if ( nMinSeg != int( Loop.size()) )
+         Loop2.emplace_back( Loop[nMinSeg]) ;
    }
   // Inglobo gli ultimi vertici in Loop2
    for ( int nPt = nMinSeg + 1 ; nPt < int( Loop.size()) ; ++ nPt)
@@ -357,7 +347,7 @@ SurfTriMesh::GeneralizedCut( const ICurve& cvCurve, bool bSaveOnEq)
    b3SurfBox.GetMinMax( ptMin, ptMax) ;
    Vector3d vtMax = ( ptMax.z + 10) * vtExtr ;
    Vector3d vtMin = ( ptMin.z - 10) * vtExtr ; 
-
+   
   // Ciclo sui triangoli
    bool bModif = false ;
    int nNumTria = GetTriangleSize() ;
@@ -372,7 +362,7 @@ SurfTriMesh::GeneralizedCut( const ICurve& cvCurve, bool bSaveOnEq)
       b3Tria.ToLoc( frCurve) ;
      // Se il box del triangolo non interseca quello locale della curva
       if ( ! b3Crv.OverlapsXY( b3Tria)) {
-        // Se la parte da conservare è quella all'interno della curva, elimino il triangolo 
+        // Se la parte da conservare � quella all'interno della curva, elimino il triangolo 
          if ( bCCW) {
             RemoveTriangle( nT) ;
             bModif = true ;
@@ -408,7 +398,7 @@ SurfTriMesh::GeneralizedCut( const ICurve& cvCurve, bool bSaveOnEq)
          Point3d ptSegSt, ptSegEn ;
          int nInt = IntersRectangleTriangle( ptSt + vtMin, ptEn - ptSt, vtMax - vtMin, trTria, ptSegSt, ptSegEn) ;
          if ( nInt == 2) {
-           // Creo nuova catena se non c'è già o se discontinuità
+           // Creo nuova catena se non c'� gi� o se discontinuit�
             if ( ! bChain  ||  ( ! AreSamePointApprox( ptSegSt, ptChEn)  &&  ! AreSamePointApprox( ptSegEn, ptChSt))) {
                ++ nChainCnt ;
                vChain.resize( nChainCnt) ;
@@ -439,11 +429,36 @@ SurfTriMesh::GeneralizedCut( const ICurve& cvCurve, bool bSaveOnEq)
          }
          pCrv = cvCompo.GetNextCurve() ;
       }
+
+      for ( auto itI = vChain.begin() ; itI != vChain.end() ; ) {
+         bool bErased = false ;
+         auto itJ = itI ;
+         ++ itJ ;
+         for ( ; itJ != vChain.end()  &&  ! bErased ; ) {
+            if ( int( itI->size()) == 1  &&  int( itJ->size()) == 1  &&
+                 AreSamePointEpsilon( itI->back().ptSt, itJ->back().ptEn, 2 * EPS_SMALL)  &&
+                 AreSamePointEpsilon( itI->back().ptEn, itJ->back().ptSt, 2 * EPS_SMALL)) {
+               itJ = vChain.erase( itJ) ;
+               bErased = true ;
+            }
+            else
+               ++ itJ ;
+         }
+         if ( bErased) {
+            itI = vChain.erase( itI) ;
+            bErased = false ;
+         }
+         else
+            ++ itI ;
+      }
+
+      nChainCnt = int( vChain.size()) ;
       if ( nChainCnt == 0  &&  nVertOutside > 0) {
          nVertInside = 0 ;
          vChain.clear() ;
          nChainCnt = 0 ;
       }
+
      // unisco eventuali catene estreme che sono parte di una stessa catena
       if ( nChainCnt > 1) {
          if ( AreSamePointApprox( vChain[0].front().ptSt, vChain[nChainCnt - 1].back().ptEn)) {
@@ -484,7 +499,7 @@ SurfTriMesh::GeneralizedCut( const ICurve& cvCurve, bool bSaveOnEq)
       CHAINVECTOR cvOpenChain ;
       for ( int nL = 0 ; nL < int( vChain.size()) ; ++ nL) {
          int nCurLoopLast = max( int(vChain[nL].size()) - 1, 0) ;
-         if ( AreSamePointApprox( vChain[nL][0].ptSt, vChain[nL][nCurLoopLast].ptEn))
+         if ( AreSamePointApprox( vChain[nL][0].ptSt, vChain[nL][nCurLoopLast].ptEn)  &&  nCurLoopLast > 0)
             cvClosedChain.emplace_back( vChain[nL]) ;
          else {
             cvOpenChain.emplace_back( vChain[nL]) ;
@@ -496,11 +511,11 @@ SurfTriMesh::GeneralizedCut( const ICurve& cvCurve, bool bSaveOnEq)
          else
             ++ it ;
       }
-     // Se più di una catena chiusa oppure catene chiuse e aperte, errore
+     // Se pi� di una catena chiusa oppure catene chiuse e aperte, errore
       if ( cvClosedChain.size() > 1  ||  ( cvClosedChain.size() > 0  &&  int( cvOpenChain.size()) > 0))
          return false ;
 
-     // Se c'è una catena chiusa
+     // Se c'� una catena chiusa
       if ( cvClosedChain.size() == 1) {
         // Ne ricavo una PolyLine
          PolyLine plInLoop ;
@@ -512,7 +527,7 @@ SurfTriMesh::GeneralizedCut( const ICurve& cvCurve, bool bSaveOnEq)
          if ( ! bCCW) {
            // Rimuovo il triangolo corrente
             RemoveTriangle( nT) ;
-           // Definisco il loop esterno (è il triangolo)
+           // Definisco il loop esterno (� il triangolo)
             PolyLine plExtLoop ;
             plExtLoop.AddUPoint( 0., trTria.GetP( 0)) ;
             plExtLoop.AddUPoint( 0., trTria.GetP( 1)) ;
@@ -562,7 +577,7 @@ SurfTriMesh::GeneralizedCut( const ICurve& cvCurve, bool bSaveOnEq)
         // Creo il loop chiuso padre di tutti, il perimetro del triangolo.
         // Questo viene diviso in sotto-loop chiusi mediante quelli aperti.
         // I loop chiusi trovati precedentemente sono interni a uno dei sotto-loop 
-        // chiusi di cui è formato il perimetro.
+        // chiusi di cui � formato il perimetro.
          PNTVECTOR cvFirstLoop ;
          cvFirstLoop.emplace_back( trTria.GetP( 0)) ;
          cvFirstLoop.emplace_back( trTria.GetP( 1)) ;
@@ -643,18 +658,20 @@ SurfTriMesh::GeneralizedCut( const ICurve& cvCurve, bool bSaveOnEq)
       }
 
      // da eliminare
-      else if ( nVertInside == 0)
+      else if ( nVertInside == 0) {
          RemoveTriangle( nT) ;
+         bModif = true ;
+      }
    }
-
-  // Se avvenuta modifica, aggiorno tutto
+   
+   // Se avvenuta modifica, aggiorno tutto
    if ( bModif) {
      // aggiorno tutto
       if ( ! AdjustVertices()  ||  ! DoCompacting())
          return false ;
    }
 
-  // se superficie originale a facce, cerco di semplificarle in ogni caso
+   // se superficie originale a facce, cerco di semplificarle in ogni caso
    if ( nFacetOriCnt < 200  ||  double( nTriaOriCnt) / nFacetOriCnt > 4) {
       if ( ! SimplifyFacets( 500.0))
          LOG_ERROR( GetEGkLogger(), "Error in SimplifyFacets of Stm::GeneralizedCut")
@@ -802,7 +819,7 @@ SurfTriMesh::DecomposeLoop( CHAINVECTOR& cvOpenChain, INTVECTOR& vnDegVec, PNTMA
                  // elimino i punti superflui prima
                   for ( int i = 0 ; i < nCvFirst ; ++ i)
                      cvBoundClosedLoopVec[nLoop].erase( cvBoundClosedLoopVec[nLoop].begin()) ;
-                 // verifico se questo punto è dalla parte valida o no
+                 // verifico se questo punto � dalla parte valida o no
                   bool bC12 = ( ( ptM12 - ptProva) * vtVecProva < 0) ;
                   vbInOut[nLoop] = bC12 ;
                }
@@ -813,7 +830,7 @@ SurfTriMesh::DecomposeLoop( CHAINVECTOR& cvOpenChain, INTVECTOR& vnDegVec, PNTMA
                  // elimino i punti superflui intermedi
                   for ( int i = nCvFirst + 2 ; i < nCvSecond ; ++ i)
                      cvBoundClosedLoopVec[nLoop].erase( cvBoundClosedLoopVec[nLoop].begin() + nCvFirst + 2) ;
-                 // verifico se questo punto è dalla parte valida o no
+                 // verifico se questo punto � dalla parte valida o no
                   bool bC21 = ( ( ptM21 - ptProva) * vtVecProva < 0) ;
                   vbInOut[nLoop] = bC21 ;
                }
@@ -872,7 +889,7 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
 
       if ( int( it->second.size()) == 0)
          continue ;
-     // Se il triangolo è stato sottoposto a ritriangolazione, le sue componenti sono classificabili come dentro-fuori.
+     // Se il triangolo � stato sottoposto a ritriangolazione, le sue componenti sono classificabili come dentro-fuori.
      // Lo tolgo dall'insieme dei triangoli ambigui (intersezione edge-edge)
       else {
          auto itS = Ambiguos.find( it->first) ;
@@ -1069,7 +1086,7 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
      // Creo il loop chiuso padre di tutti, il perimetro del triangolo.
      // Questo viene diviso in sotto-loop chiusi mediante quelli aperti.
      // I loop chiusi trovati precedentemente sono interni a uno dei sotto-loop 
-     // chiusi di cui è formato il perimetro.
+     // chiusi di cui � formato il perimetro.
       PNTVECTOR cvFirstLoop ;
       cvFirstLoop.emplace_back( trTria.GetP( 0)) ;
       cvFirstLoop.emplace_back( trTria.GetP( 1)) ;
@@ -1149,7 +1166,7 @@ SurfTriMesh::RetriangulationForBooleanOperation( CHAINMAP& LoopLines, TRIA3DVECT
         // Assegno ai loop trovati i rispettivi interni
         // Assumo che i loop interni a uno dei loop creati fino ad'ora siano tutti sullo stesso livello.
         // Il caso generale si risolve con una struttura ad albero in cui il nodi corrispondente a un  
-        // loop è figlio del nodo corrispondente al loop che lo contiene.
+        // loop � figlio del nodo corrispondente al loop che lo contiene.
          INTVECTOR vInnerLoop ;
          for ( int nCLI = 0 ; nCLI < int( cvClosedChain.size()) ; ++ nCLI) {
             for ( int nPtNum = 0 ; nPtNum < int( cvClosedChain[nCLI].size()) ; ++ nPtNum) {
@@ -1574,7 +1591,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.
+     // contatto edge-edge ha avuto dei contatti che lo hanno gi� classificato.
       if ( Surf.m_vTria[it->first].nTempPart != 0)
          continue ;
      // Recupero il triangolo corrente
@@ -1650,7 +1667,7 @@ SurfTriMesh::AmbiguosTriangleManager( TRIA3DVECTORMAP& Ambiguos, SurfTriMesh& Su
          if ( j < 3)
             break ;
       }
-     // Se la classificazione è coerente segno gli edge di contatto come invalicabili
+     // Se la classificazione � coerente segno gli edge di contatto come invalicabili
       Surf.m_vTria[it->first].nETempFlag[0] = int( vAdjSegToCurTria[0].size()) > 0 ? 1 : 0 ;
       Surf.m_vTria[it->first].nETempFlag[1] = int( vAdjSegToCurTria[1].size()) > 0 ? 1 : 0 ;
       Surf.m_vTria[it->first].nETempFlag[2] = int( vAdjSegToCurTria[2].size()) > 0 ? 1 : 0 ;
@@ -1676,7 +1693,7 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
   // Ciclo sui triangoli delle mesh
    int nTriaNumA = GetTriangleSize() ;
    int nTriaNumB = SurfB.GetTriangleSize() ;
-  // Setto il triangolo come né fuori né dentro
+  // Setto il triangolo come n� fuori n� dentro
    for ( int nTA = 0 ; nTA < nTriaNumA ; ++ nTA) {
       m_vTria[nTA].nTempPart = 0 ;
       m_vTria[nTA].nETempFlag[0] = 0 ;
@@ -1692,7 +1709,7 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
   // Resetto e ricalcolo la HashGrid della superficie B
    SurfB.ResetHashGrids3d() ;
    for ( int nTA = 0 ; nTA < nTriaNumA ; ++ nTA) {
-     // Se il triangolo A non è valido, continuo
+     // Se il triangolo A non � valido, continuo
       Triangle3d trTriaA ;
       if ( ! GetTriangle( nTA, trTriaA)  ||  ! trTriaA.Validate( true))
          continue ;
@@ -1703,7 +1720,7 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
       INTVECTOR vNearTria ;
       SurfB.GetAllTriaOverlapBox( b3dTriaA, vNearTria) ;
       for ( int nTB = 0 ; nTB < int( vNearTria.size()) ; ++ nTB) {
-        // Se il triangolo B non è valido, continuo
+        // Se il triangolo B non � valido, continuo
          Triangle3d trTriaB ;
          if ( ! SurfB.GetTriangle( vNearTria[nTB], trTriaB)  ||  ! trTriaB.Validate( true))
             continue ;
@@ -1779,7 +1796,7 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
                   }
                }
                if ( nSegMaxDist >= 0) {
-                 // Cerco qual'è il segmento di contatto per dichiararlo come invalicabile
+                 // Cerco qual'� il segmento di contatto per dichiararlo come invalicabile
                   int nVA ;
                   for ( nVA = 0 ; nVA < 3 ; ++ nVA) {
                      if ( abs( ( trTriaA.GetP( nVA) - trTriaB.GetP( 0)) * trTriaB.GetN()) < EPS_SMALL  &&
@@ -1803,7 +1820,7 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
                   }
                }
                if ( nSegMaxDist >= 0) {
-                 // Cerco qual'è il segmento di contatto per dichiararlo come invalicabile
+                 // Cerco qual'� il segmento di contatto per dichiararlo come invalicabile
                   int nVB ;
                   for ( nVB = 0 ; nVB < 3 ; ++ nVB) {
                      if ( abs( ( trTriaB.GetP( nVB) - trTriaA.GetP(0)) * trTriaA.GetN()) < EPS_SMALL  &&
@@ -1816,8 +1833,8 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
                }
             }
            // Intersezione edge-edge: salvo indice e vettore triangoli
-           // Uso i triangoli perché, se un triangolo fosse cancellato, non potrei accedervi poi usando l'indice.
-           // Salvando i triangoli risolvo il problema perché ai fini dello studio di questi contatti, triangolo
+           // Uso i triangoli perch�, se un triangolo fosse cancellato, non potrei accedervi poi usando l'indice.
+           // Salvando i triangoli risolvo il problema perch� ai fini dello studio di questi contatti, triangolo
            // e sua ritriangolazione portano al medesimo risultato.
             else if ( bIntOnEndgeA  &&  bIntOnEndgeB) {
                auto itA = AmbiguosA.find( nTA) ;
@@ -1847,7 +1864,7 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
    RetriangulationForBooleanOperation( LineMapA, AmbiguosA, *this, bModif) ;
    RetriangulationForBooleanOperation( LineMapB, AmbiguosB, SurfB, bModif) ;
   
-  // Se i triangoli delle superfici non si intersecano, una delle due è totalmente interna o esterna all'altra.
+  // Se i triangoli delle superfici non si intersecano, una delle due � totalmente interna o esterna all'altra.
    bool bRetriangulated = true ;
    if ( ! bModif  &&  ( int( AmbiguosA.size()) == 0  ||  int( AmbiguosB.size()) == 0)) {
       bRetriangulated = false ;
@@ -1859,7 +1876,7 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
          int nTriaNum = - 1 ;
          double dMinDist = DBL_MAX ;
          for ( int nTB = 0 ; nTB < nTriaNumB ; ++ nTB) {
-           // Se il triangolo B non è valido, continuo
+           // Se il triangolo B non � valido, continuo
             Triangle3d trTriaB ;
             if ( ! SurfB.GetTriangle( nTB, trTriaB)  ||  ! trTriaB.Validate( true))
                continue ;
@@ -1892,7 +1909,7 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
          int nTriaNum = - 1 ;
          double dMinDist = DBL_MAX ;
          for ( int nTA = 0 ; nTA < nTriaNumA ; ++ nTA) {
-            // Se il triangolo A non è valido, continuo
+            // Se il triangolo A non � valido, continuo
             Triangle3d trTriaA ;
             if ( ! ( GetTriangle( nTA, trTriaA)  &&  trTriaA.Validate( true)))
                continue ;
@@ -1924,7 +1941,7 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
       }
    }
 
-  // Se c'è stata una ritriangolazione di almeno un triangolo, NON siamo nel caso di tutto dentro o tutto fuori.
+  // Se c'� stata una ritriangolazione di almeno un triangolo, NON siamo nel caso di tutto dentro o tutto fuori.
   // Studio i triangoli ambigui.
    if ( bRetriangulated) {
       AmbiguosTriangleManager( AmbiguosA, *this) ;
@@ -1941,7 +1958,7 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
       // Resetto e ricalcolo la HashGrid della superficie B
       SurfB.ResetHashGrids3d() ;
       for ( int nTA = 0 ; nTA < nTriaNum2A ; ++ nTA) {
-        // Se il triangolo A non è valido, continuo
+        // Se il triangolo A non � valido, continuo
          Triangle3d trTriaA ;
          if ( ! GetTriangle( nTA, trTriaA)  ||  ! trTriaA.Validate( true))
             continue ;
@@ -1952,7 +1969,7 @@ SurfTriMesh::IntersectTriMeshTriangle( SurfTriMesh& Other)
          INTVECTOR vNearTria ;
          SurfB.GetAllTriaOverlapBox( b3dTriaA, vNearTria) ;
          for ( int nTB = 0 ; nTB < int( vNearTria.size()) ; ++ nTB) {
-            // Se il triangolo B non è valido, continuo
+            // Se il triangolo B non � valido, continuo
             Triangle3d trTriaB ;
             if ( ! SurfB.GetTriangle( vNearTria[nTB], trTriaB)  ||  ! trTriaB.Validate( true))
                continue ;
@@ -1978,7 +1995,7 @@ bool
 SurfTriMesh::IdentifyParts( void) const
 {
    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  ||
            abs( m_vTria[i].nTempPart) != 1)
          continue ;
@@ -2018,7 +2035,7 @@ SurfTriMesh::RemoveTJunctions(void)
    for ( int nT = 0 ; nT < int( m_vTria.size()) ; ++ nT) {
      // Riga di matrice per il triangolo 
       INTVECTOR& vIndexRow = vvIndexMatrix[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 ;
@@ -2042,7 +2059,7 @@ SurfTriMesh::RemoveTJunctions(void)
          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
@@ -2180,7 +2197,7 @@ SurfTriMesh::ScanForTripleTriangles( bool& bModified)
       bool bCirc ;
       INTVECTOR vTriaIndex ;
       int nTriaNum = GetAllTriaAroundVertex( nV, vTriaIndex, bCirc) ;
-     // Se il vertice è condiviso da tre triangoli tutti adiacenti fra loro a due a due
+     // Se il vertice � condiviso da tre triangoli tutti adiacenti fra loro a due a due
       if ( nTriaNum == 3  &&  bCirc) {
         // Valuto parallelismo fra le normali
          int nParallel = 0 ;
@@ -2193,7 +2210,7 @@ SurfTriMesh::ScanForTripleTriangles( bool& bModified)
          }
         // Se sono tutte parallele fra loro unisco i tre triangoli in uno
          if ( nParallel == 3) {
-           // Cerco gli altri triangoli adiacenti a quelli che sostituirò con il triangolo grande.
+           // Cerco gli altri triangoli adiacenti a quelli che sostituir� con il triangolo grande.
            // Cerco anche quali lati dei tre triangoli che saranno eliminati sono adiacenti a quelli esterni
             INTVECTOR vVertAndAdjTria ;
             for ( int nTria = 0 ; nTria < 3 ; ++ nTria) {
@@ -2205,7 +2222,7 @@ SurfTriMesh::ScanForTripleTriangles( bool& bModified)
                   }
                }
             }
-           // Cerco fra questi altri triangoli esterni sono adiacenti ai triangoli che eliminerò
+           // Cerco fra questi altri triangoli esterni sono adiacenti ai triangoli che eliminer�
             int nAdjTriaContactEdge[3] ;
             for ( int nAdjTria = 1 ; nAdjTria < 6 ; nAdjTria += 2) {
                for ( int nAdjEdge = 0 ; nAdjEdge < 3 ; ++ nAdjEdge) {
@@ -2268,19 +2285,19 @@ SurfTriMesh::FlipTriangles( int nTA, int nTB)
       if ( m_vTria[nTB].nIdAdjac[nEdgeB] == nTA)
          break ;
    }
-  // Se uno è adiacente all'altro ma non viceversa, c'è un errore
+  // Se uno � adiacente all'altro ma non viceversa, c'� un errore
    if ( ( nEdgeA == 3  &&  nEdgeB < 3)  ||  ( nEdgeA < 3  &&  nEdgeB == 3))
       return false ;
   // Se non sono adiacenti, ho finito
    else if ( nEdgeA == 3  &&  nEdgeB == 3)
       return true ;
-  // Se non trovo i vertici del triangolo A, c'è un errorre
+  // Se non trovo i vertici del triangolo A, c'� un errorre
    Point3d ptSegSt, ptSegEn, ptVertA ;  
    if ( ! GetVertex( m_vTria[nTA].nIdVert[nEdgeA], ptSegSt)  ||
         ! GetVertex( m_vTria[nTA].nIdVert[( nEdgeA + 1) % 3], ptSegEn)  ||
         ! GetVertex( m_vTria[nTA].nIdVert[( nEdgeA + 2) % 3], ptVertA))
       return false ;
-  // Se non trovo i vertici del triangolo B, c'è un errorre
+  // Se non trovo i vertici del triangolo B, c'� un errorre
    Point3d ptVertB ;
    if ( ! GetVertex( m_vTria[nTB].nIdVert[( nEdgeB + 2) % 3], ptVertB))
       return false ;
@@ -2563,7 +2580,7 @@ SurfTriMesh::IntersFacetPlane( const SurfFlatRegion& Region, const Plane3d& plCu
   // Intersezione tra i piani delle due facce
    Point3d ptL ; Vector3d vtL ;
    int nResPP = IntersPlanePlane( plFacetPlane, plCutPlane, ptL, vtL) ;
-  // Sono considerate non complanari, se c'è la retta d'intersezione è errore
+  // Sono considerate non complanari, se c'� la retta d'intersezione � errore
    if ( nResPP == IPPT_NO  ||  nResPP == IPPT_OVERLAPS)
       return FPI_ERROR ;
 
@@ -2585,7 +2602,7 @@ SurfTriMesh::IntersFacetPlane( const SurfFlatRegion& Region, const Plane3d& plCu
   // Classifico la linea di intersezione con la faccia
    CRVCVECTOR IntersectionResults ;
    bool bClassificationOk = Region.GetCurveClassification( cvPlaneIntersLine, 0.1 * EPS_SMALL, IntersectionResults) ;
-  // Se non trovo le intersezioni, c'è un errore.
+  // Se non trovo le intersezioni, c'� un errore.
    if ( ! bClassificationOk)
       return FPI_ERROR ;
 
@@ -2602,7 +2619,7 @@ SurfTriMesh::IntersFacetPlane( const SurfFlatRegion& Region, const Plane3d& plCu
    if ( ! IntersLinePart.empty())
       return FPI_CUT ;
 
-  // La linea si è ridotta ad un punto, la regione è tutta dentro o tutta fuori
+  // La linea si � ridotta ad un punto, la regione � tutta dentro o tutta fuori
    Point3d ptCen ;
    if ( ! Region.GetChunkCentroid( 0, ptCen))
       return FPI_ERROR ;
@@ -2847,7 +2864,7 @@ SurfTriMesh::SplitFacet( const INTERSCHAINMAP& IntersLineMap, PieceMap& NewFacet
       vNewPieces.back().nPiecePart = 1 ;
       GetFacetLoops( it->first, vNewPieces.back().vPieceLoop) ;
      // Divido la faccia in parti.
-     // Ciclo sulle catene finché non esauriscono.
+     // Ciclo sulle catene finch� non esauriscono.
       int nIterNumber = 0 ;
       int nPrevLastChainNum = int( cvOpenChain.size()) ;
       while ( int( cvOpenChain.size()) > 0) {
@@ -2973,7 +2990,7 @@ SurfTriMesh::SplitFacet( const INTERSCHAINMAP& IntersLineMap, PieceMap& NewFacet
                      NewLoopCCW = NewLoop2;
                      NewLoopCW = NewLoop1;
                   }
-                 // Creo il pezzo nuovo, il cui loop esterno è stato appena definito.
+                 // Creo il pezzo nuovo, il cui loop esterno � stato appena definito.
                   FacetPiece DetachedPiece;
                   DetachedPiece.vPieceLoop.emplace_back(NewLoopCCW);
                   DetachedPiece.nPiecePart = bFirstLoopIsCounter ? 1 : -1;
@@ -3151,7 +3168,7 @@ SurfTriMesh::SplitFacet( const INTERSCHAINMAP& IntersLineMap, PieceMap& NewFacet
                      NewLoopCCW = NewLoop2 ;
                      NewLoopCW = NewLoop1 ;
                   }
-                 // // Creo il pezzo nuovo, il cui loop esterno è stato appena definito.
+                 // // Creo il pezzo nuovo, il cui loop esterno � stato appena definito.
                   // FacetPiece PieceInn ;
                   // PieceInn.vPieceLoop.emplace_back( NewLoop1) ;
                   // PieceInn.nPiecePart = 1 ;
@@ -3178,7 +3195,7 @@ SurfTriMesh::SplitFacet( const INTERSCHAINMAP& IntersLineMap, PieceMap& NewFacet
                   // vNewPieces[nPart].vPieceLoop.emplace_back( NewLoop2) ;
                   // vNewPieces[nPart].nPiecePart = - 1 ;
                   // vNewPieces.emplace_back( PieceInn) ;
-                 // Creo il pezzo nuovo, il cui loop esterno è stato appena definito.
+                 // Creo il pezzo nuovo, il cui loop esterno � stato appena definito.
                   FacetPiece DetachedPiece ;
                   DetachedPiece.vPieceLoop.emplace_back( NewLoopCCW) ;
                   DetachedPiece.nPiecePart = bFirstLoopIsCounter ? 1 : - 1 ;
@@ -3390,7 +3407,7 @@ SurfTriMesh::EdgeInteriorContactManager( const SurfTriMesh& OthSurf,
       GetAllTriaInFacet( nFacet, vFacetTria) ;
       // Versore normale alla faccia.
       Vector3d vtN = m_vTria[m_vFacet[nFacet]].vtN ;
-      // Se la faccia è stata tagliata, salto alla prossima faccia.
+      // Se la faccia � stata tagliata, salto alla prossima faccia.
       if ( InterInterLineMap.find( nFacet) != InterInterLineMap.end())
          continue ;
       int nInOutPart = 0 ;
@@ -3487,7 +3504,7 @@ SurfTriMesh::EdgeEdgeContactManager( const SurfTriMesh& OthSurf,
       GetAllTriaInFacet( nFacet, vFacetTria) ;
       // Versore normale alla faccia.
       Vector3d vtN = m_vTria[m_vFacet[nFacet]].vtN ;
-      // Se la faccia è stata tagliata, salto alla prossima faccia.
+      // Se la faccia � stata tagliata, salto alla prossima faccia.
       if ( InterInterLineMap.find( nFacet) != InterInterLineMap.end())
          continue ;
       int nInOutPart = 0 ;
@@ -3548,7 +3565,7 @@ SurfTriMesh::EdgeEdgeContactManager( const SurfTriMesh& OthSurf,
             if ( nOthFacet2 != int( Edge.vOthFacetIndex.size()))
                break ;
          }
-         // Se l'indice interno/esterno non è stato assegnato
+         // Se l'indice interno/esterno non � stato assegnato
          if ( nInOutPart == 0) {
             // Se non ho trovato una coppia di facce, uso la prima.
             if ( ( nOthFacet1 == int( Edge.vOthFacetIndex.size()) - 1  &&  nOthFacet2 == int( Edge.vOthFacetIndex.size()))  ||  nOthFacet2 == - 1) {
@@ -3663,8 +3680,8 @@ SurfTriMesh::RetriangulateFacetPieces( const PieceMap& NewFacet,
                int nNewId[3] = { AddVertex( vPt[nNewTriaVertId[0]]),
                                  AddVertex( vPt[nNewTriaVertId[1]]),
                                  AddVertex( vPt[nNewTriaVertId[2]])} ;
-               // Il colore passato nel secondo parametro è definito perché il vettore delle facce ha ancora salvato l'indice di un suo triangolo e
-               // il triangolo è cancellato semplicente assegnadno la costante apposita VT_DEL (-2) a nIdVert[0]; ma il suo colore resta definito. 
+               // Il colore passato nel secondo parametro � definito perch� il vettore delle facce ha ancora salvato l'indice di un suo triangolo e
+               // il triangolo � cancellato semplicente assegnadno la costante apposita VT_DEL (-2) a nIdVert[0]; ma il suo colore resta definito. 
                int nNewTriaNum = AddTriangle( nNewId, m_vTria[m_vFacet[it->first]].nTFlag) ;
                if ( IsValidSvt( nNewTriaNum)) {
                   // Assegno l'indice della parte interno/esterno.
@@ -3762,7 +3779,7 @@ SurfTriMesh::IntersectTriMeshFacets( SurfTriMesh& Other)
    INTERSCHAINMAP IntersLineMapA, IntersLineMapB ;
    INTERSEDGEMAP EdgeInnLineMapA, EdgeInnLineMapB ;
    INTERSEDGEMAP EdgeEdgeLineMapA, EdgeEdgeLineMapB ;
-   // Setto il triangolo come né fuori né dentro
+   // Setto il triangolo come n� fuori n� dentro
    int nTriaNumA = GetTriangleSize();
    int nTriaNumB = SurfB.GetTriangleSize();
    for ( int nTA = 0 ; nTA < nTriaNumA ; ++ nTA) {
@@ -3961,7 +3978,7 @@ SurfTriMesh::IntersectTriMeshFacets( SurfTriMesh& Other)
    EdgeEdgeContactManager( SurfB, IntersLineMapA, EdgeEdgeLineMapA) ;
    SurfB.EdgeEdgeContactManager( *this, IntersLineMapB, EdgeEdgeLineMapB) ;
 
-   // Se non ci sono stati tagli, valuto se una è tutta interna all'altra.
+   // Se non ci sono stati tagli, valuto se una � tutta interna all'altra.
    if ( int( NewFacetA.size() + NewFacetB.size()) == 0) {
       int nVertNum = 0 ;
       Point3d ptVert ;
@@ -3994,7 +4011,7 @@ SurfTriMesh::IntersectTriMeshFacets( SurfTriMesh& Other)
             ++ nVertNum ;
          }
       }
-      // Se la superficie A non è interna valuto la posizione della superficie B.
+      // Se la superficie A non � interna valuto la posizione della superficie B.
       int nInOutNumB = nInOutNumA == 1 ? - 1 : 0 ;
       if ( nInOutNumB == 0) {
          nVertNum = 0 ;
@@ -4028,8 +4045,8 @@ SurfTriMesh::IntersectTriMeshFacets( SurfTriMesh& Other)
             }
          }
       }
-      // Se la posizione della superficie A rispetto alla B non è definita e
-      // B è esterna ad A, allora assumiamo che siano reciprocamente esterne.
+      // Se la posizione della superficie A rispetto alla B non � definita e
+      // B � esterna ad A, allora assumiamo che siano reciprocamente esterne.
       if ( nInOutNumA == 0  &&  nInOutNumB == - 1)
          nInOutNumA = - 1 ;
       // Assegno gli indici interni/esterni.
@@ -4257,7 +4274,7 @@ SurfTriMesh::IntersectTriMeshFacets( SurfTriMesh& Other)
       // Resetto e ricalcolo la HashGrid della superficie B
       SurfB.ResetHashGrids3d() ;
       for ( int nTA = 0 ; nTA < nTriaNum2A ; ++ nTA) {
-         // Se il triangolo A non è valido, continuo
+         // Se il triangolo A non � valido, continuo
          Triangle3d trTriaA ;
          if ( ! GetTriangle( nTA, trTriaA)  ||  ! trTriaA.Validate( true))
             continue ;
@@ -4268,7 +4285,7 @@ SurfTriMesh::IntersectTriMeshFacets( SurfTriMesh& Other)
          INTVECTOR vNearTria ;
          SurfB.GetAllTriaOverlapBox( b3dTriaA, vNearTria) ;
          for ( int nTB = 0 ; nTB < int( vNearTria.size()) ; ++ nTB) {
-            // Se il triangolo B non è valido, continuo
+            // Se il triangolo B non � valido, continuo
             Triangle3d trTriaB ;
             if ( ! SurfB.GetTriangle( vNearTria[nTB], trTriaB)  ||  ! trTriaB.Validate( true))
                continue ;
@@ -4283,7 +4300,7 @@ SurfTriMesh::IntersectTriMeshFacets( SurfTriMesh& Other)
                bSuccesfullInters = IsPointInsideTriangle( ptIntTriaCentroid, trTriaA, TriangleType::EXACT)  &&
                                    IsPointInsideTriangle( ptIntTriaCentroid, trTriaB, TriangleType::EXACT) ;
             }
-            // Se l'intersezeione è corretta e i triangoli sono sovrapposti aggiorno gli indici.
+            // Se l'intersezeione � corretta e i triangoli sono sovrapposti aggiorno gli indici.
             if ( nIntTypeAB == ITTT_OVERLAPS  &&  bSuccesfullInters) {
                bool bInvertB = trTriaA.GetN() * trTriaB.GetN() < 0. ;
                m_vTria[nTA].nTempPart = ( bInvertB ? -2 : 2) ;