EgtGeomKernel :

- gestiti più chunk per la triangolaziome ( MakeAdvanced)
- piccole modifiche a Intersezione e creazione di Stm da curve.

Triangulate.cpp

@@ -21,8 +21,11 @@
 #include "/EgtDev/Include/EGkPlane3d.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
+#include "CurveComposite.h"
+#include "IntersCrvCompoCrvCompo.h"
 #include <algorithm>
 
+
 using namespace std ;
 
 //----------------------------------------------------------------------------
@@ -218,6 +221,140 @@ Triangulate::Make( const POLYLINEVECTOR& vPL, PNTVECTOR& vPt, INTVECTOR& vTr)
    return true ;
 }
 
+//---------------------------------------------------------------------------
+bool
+Triangulate::MakeAdvanced( const POLYLINEVECTOR& vPLORIG, PNTVECTOR& vPt, INTVECTOR& vTr)
+{
+   vPt.clear() ;
+   vTr.clear() ;
+  // se non ho PolyLine, allora non faccio nulla
+   if ( int( vPLORIG.size()) == 0)
+      return true ;
+
+  // copio il vettore di PolyLine
+   POLYLINEVECTOR vPL ;
+   for ( int i = 0 ; i < int( vPLORIG.size()) ; ++ i)
+      vPL.push_back( vPLORIG[i]) ;
+
+   typedef std::pair<int,double> INDAREA ;
+   std::vector<INDAREA> m_vArea ;
+  // calcolo piano medio e area delle curve
+   m_vArea.reserve( vPL.size()) ;
+   Vector3d vtN0 ;
+   for ( int i = 0 ; i < int( vPL.size()) ; ++ i) {
+     // calcolo piano medio e area
+      Plane3d plPlane ;
+      double dArea ;
+      if ( ! vPL[i].IsClosedAndFlat( plPlane, dArea))
+         return false ;
+     // imposto la normale del primo contorno come riferimento
+      if ( i == 0)
+         vtN0 = plPlane.GetVersN() ;
+     // verifico che le normali siano molto vicine
+      if ( ! AreSameOrOppositeVectorApprox( plPlane.GetVersN(), vtN0))
+         return false ;
+     // assegno il segno all'area secondo il verso della normale
+      if ( ( plPlane.GetVersN() * vtN0) > 0)
+         m_vArea.emplace_back( i, dArea) ;
+      else
+         m_vArea.emplace_back( i, - dArea) ;
+   }
+  // ordino in senso decrescente sull'area
+   sort( m_vArea.begin(), m_vArea.end(), 
+         []( const INDAREA& a, const INDAREA& b) { return ( abs( a.second) > abs( b.second)) ; }) ;
+
+  // dalle PolyLine passo alle curve nel piano XY ( prendo la prima come riferimento, trascuro le Z delle successive)
+   Frame3d frRef ; frRef.Set( ORIG, vtN0) ;
+   if ( ! frRef.IsValid())
+      return false ;
+   ICRVCOMPOPOVECTOR vCrvCompo( int( vPL.size())) ;
+   for ( int i = 0 ; i < int( vPL.size()) ; ++ i) {
+      vCrvCompo[i].Set( CreateCurveComposite()) ;
+      vCrvCompo[i]->FromPolyLine( vPL[i]) ;
+      vCrvCompo[i]->ToLoc( frRef) ;
+   }
+
+  // creo una matrice di interi ; ogni riga corrisponde ad un chunk, dove in posizione 0 c'è il loop esterno e nelle
+  // successive i loop interni
+   INTMATRIX vnPLIndMat ;
+
+  // aggiungo le diverse curve
+   bool bExtLoop = false ;
+   bool bFirstCrv ;
+   Plane3d plExtLoop ;
+   do {
+      bFirstCrv = true ;
+      for ( int i = 0 ; i < int( m_vArea.size()) ; ++ i) {
+        // recupero indice di percorso e verifico sia valido
+         int j = m_vArea[i].first ;
+         if ( j < 0)
+            continue ;
+        // lo inserisco come esterno...
+         if ( bFirstCrv) {
+            vnPLIndMat.push_back({ j}) ;
+            m_vArea[i].first = -1 ;
+           // inverto se necessario
+            if ( m_vArea[i].second < EPS_SMALL) {
+               vPL[j].Invert() ;
+               vCrvCompo[j]->Invert() ;
+            }
+            bFirstCrv = false ;
+         }
+        // ... altrimenti verifico se il loop è interno o no
+         else {
+           // il loop è interno se è sia interno al loop esterno della riga di vnPLIndMat e allo stesso tempo
+           // esterno a tutti i loop già inseriti nella riga attuale.
+           // verifica rispetto loop esterno
+            IntersCurveCurve ccInt( *vCrvCompo[vnPLIndMat.back().front()], *vCrvCompo[j]) ;
+            CRVCVECTOR ccClass ;
+            if ( ccInt.GetCrossOrOverlapIntersCount() > 0  ||
+                 ! ccInt.GetCurveClassification( 1, EPS_SMALL, ccClass)  ||
+                 ccClass.empty()  ||  ccClass[0].nClass != CRVC_IN)
+               continue ;
+            // verifica rispetto ai loop interni
+            bool bOk = true ;
+            for ( int k = 1 ; k < int( vnPLIndMat.back().size()) ; ++ k) {
+               IntersCurveCurve ccInt2( *vCrvCompo[vnPLIndMat.back()[k]], *vCrvCompo[j]) ;
+               CRVCVECTOR ccClass2 ;
+               if ( ccInt2.GetCrossOrOverlapIntersCount() > 0  ||
+                    ! ccInt2.GetCurveClassification( 1, EPS_SMALL, ccClass2)  ||
+                    ccClass2.empty()  ||  ccClass2[0].nClass != CRVC_IN) {
+                  bOk = false ;
+                  break ;
+               }
+            }
+            if ( bOk) {
+              // inserisco nella matrice
+               vnPLIndMat.back().push_back( j) ;
+               m_vArea[i].first = -1 ;
+              // inverto se necessario
+               if ( m_vArea[i].second > - EPS_SMALL) {
+                  vPL[j].Invert() ;
+                  vCrvCompo[j]->Invert() ;
+               }
+            }
+         }
+      }
+   } while ( ! bFirstCrv) ;
+
+  // chiamo la Triangolazione per ogni riga della matrice ( quindi su ogni "Chunk")
+   for ( int i = 0 ; i < int( vnPLIndMat.size()) ; ++ i) {
+      PNTVECTOR vPt_tmp ; INTVECTOR vTr_tmp ;
+      POLYLINEVECTOR vPL_tmp ;
+      for ( int j = 0 ; j < int( vnPLIndMat[i].size()) ; ++ j)
+         vPL_tmp.push_back( vPL[vnPLIndMat[i][j]]) ;
+      if ( ! Make( vPL_tmp, vPt_tmp, vTr_tmp))
+         return false ;
+      int nSize = int( vPt.size()) ;
+      for ( int p = 0 ; p < int( vPt_tmp.size()) ; ++ p)
+         vPt.push_back( vPt_tmp[p]) ;
+      for ( int t = 0 ; t < int( vTr_tmp.size()) ; ++ t)
+         vTr.push_back( nSize + vTr_tmp[t]) ;
+   }
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 // Triangulate the CCW n-gon specified by the vertices vPt (Pt[n] != Pt[0])
 // Ear Clipping algorithm from mapbox