EgtGeomKernel :

- passaggio da mutex a shared_mutex nelle Bezier.

OffsetCurve.cpp

@@ -60,8 +60,6 @@ OffsetCurve::Reset( void)
       }
    }
    m_CrvLst.clear() ;
-   m_pt = P_INVALID ;
-   m_vt = V_INVALID ;
    return true ;
 }
 
@@ -706,18 +704,6 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
             double dCorr = ( dDist > 0 ? - VRONI_OFFS_TOL : VRONI_OFFS_TOL) ;
             voronoiObj->CalcOffset( vOffs, dDist + dCorr, nType) ;
          }
-        // se ancora vuoto calcolo i punti speciali di offset ( punti e direzioni sui bisettore alla distanza richiesta)      
-         if ( vOffs.empty()) {
-            PNTVECTVECTOR vPntOffs ;
-            voronoiObj->CalcSpecialPointOffset( vPntOffs, dDist) ;
-           // NB al momento vengono gestiti solo i casi in cui vi è un unico punto di offset. Se si ottengono più punti di offset 
-           // ( e.g. alcune curve aperte) non se ne restiusce nessuno. Da estendere, se necessario, individuando i punti dal lato 
-           // di offset richiesto
-            if ( vPntOffs.size() == 1) {
-               m_pt = vPntOffs[0].first ;
-               m_vt = vPntOffs[0].second ;            
-            }        
-         }
       }         
 
       for ( int i = 0 ; i < ( int)vOffs.size() ; i ++)
@@ -747,21 +733,10 @@ OffsetCurve::Make( const ICurve* pCrv, double dDist, int nType)
          pCrv->Scale( GLOB_FRM, 1 / dExtrOnN, 1, 1) ;
          pCrv->ToGlob( frCopy) ;
       }
-      if ( m_pt.IsValid()) {
-         m_pt.Scale( GLOB_FRM, 1 / dExtrOnN, 1, 1) ;
-         m_pt.ToGlob( frCopy) ;
-         m_vt.Scale( GLOB_FRM, 1 / dExtrOnN, 1, 1) ;
-         m_vt.ToGlob( frCopy) ;
-      }
-
    }
    else if ( bNeedRef) {
       for ( auto pCrv : m_CrvLst)
          pCrv->ToGlob( frCopy) ;
-      if ( m_pt.IsValid()) {       
-         m_pt.ToGlob( frCopy) ;
-         m_vt.ToGlob( frCopy) ;
-      }
    }
 
   // assegno estrusione e spessore come curva originale e unisco parti allineate
@@ -839,20 +814,6 @@ OffsetCurve::GetShorterCurve( void)
    return pCrv ;
 }
 
-//----------------------------------------------------------------------------
-bool
-OffsetCurve::GetPointOffset( Point3d& pt, Vector3d& vt)
-{
-  // verifico se valori validi da restituire
-   if ( ! m_pt.IsValid()  ||  ! m_vt.IsValid())
-      return false ;
-
-   pt = m_pt ;
-   vt = m_vt ;
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 PreviousIsLine( ICURVEPLIST::const_iterator iIter, const ICURVEPLIST& CrvLst, bool bClosed)

SfrCreate.cpp

@@ -577,8 +577,10 @@ SurfFlatRegionByContours::GetUnusedCurveTempProps( INTVECTOR& vId)
 bool
 CalcRegionPolyLines( const POLYLINEVECTOR& vPL, Vector3d& vtN, INTMATRIX& vnPLIndMat, BOOLVECTOR& vbInvert)
 {
-  // vnPLIndMat : ogni riga corrisponde ad un chunk, in posizione 0 c'è il loop esterno e nelle successive i loop interni
-  // vbInvert : riferito al vettore delle polyline, riporta true se la polyline è stata invertita
+   // 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 ;
+   // vettore di bool : riferito al vettore originale delle polyline, riporta true se la polyline è stata invertita
 
   // ricavo versore normale
    Plane3d plPlane ; double dArea ;

SurfBezier.h

@@ -25,6 +25,14 @@
 using namespace std ;
 class Tree ;
 
+struct PairHashIntInt {
+   std::size_t operator()(const std::pair<int, int>& key) const {
+      std::size_t h1 = std::hash<int>{}(key.first);
+      std::size_t h2 = std::hash<int>{}(key.second);
+      return h1 ^ (h2 << 1);  // Combine hashes
+   }
+};
+
 //----------------------------------------------------------------------------
 class SurfBezier : public ISurfBezier, public IGeoObjRW
 {
@@ -103,6 +111,7 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
                { return GetControlWeight( GetInd( nIndU, nIndV), pbOk) ; }
       double GetControlWeight( int nInd, bool* pbOk) const override ;
       bool IsAPoint( void) const override ;
+      bool GetPoint( double dU, double dV, Side nUs, Side nVs, Point3d& ptPos) const override ;
       bool GetPointD1D2( double dU, double dV, Side nUs, Side nVs,
                          Point3d& ptPos,
                          Vector3d* pvtDerU = nullptr, Vector3d* pvtDerV = nullptr,
@@ -113,7 +122,7 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
                             Vector3d* pvtDerUU = nullptr, Vector3d* pvtDerVV = nullptr, Vector3d* pvtDerUV = nullptr) const override ;
       CurveComposite* GetCurveOnU( double dV) const override ;
       CurveComposite* GetCurveOnV( double dU) const override ;
-      CurveComposite* GetLoop( int nLoop) const override ;                            // nLoop 0-based (1°esterno, successivi interni) 
+      CurveComposite* GetLoop( int nLoop) const override ;                            // nLoop 0-based (1°esterno, successivi interni) 
       bool GetControlCurveOnU( int nIndV, PolyLine& plCtrlU) const override ;
       bool GetControlCurveOnV( int nIndU, PolyLine& plCtrlV) const override ;
       const SurfTriMesh* GetAuxSurf( void) const override ;
@@ -122,14 +131,14 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool GetLeaves( std::vector<std::tuple<int, Point3d, Point3d>>& vLeaves) const override ;
       bool GetTriangles2D( std::vector<std::tuple<int,Point3d, Point3d, Point3d>>& vTria2D) const override ;
       // funzioni che servono per ricavare l'immagine nel parametrico di un punto appartenente alla trimesh ausiliaria della superficie di Bezier
-      // a nIL si può passare 5 come valore di default
+      // a nIL si può passare 5 come valore di default
       bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL = 5) const override ;
       bool UnprojectPointFromStm( int nT, const Point3d& ptI, Point3d& ptSP, int nIL, const Point3d& ptIPrev, bool* bTroughEdge = nullptr) const override ;
       // restituisce il corrispettivo parametrico di un punto qualunque della trimesh associata alla superficie
-      // ptIPrev è un punto addizionale che precede o segue il punto pt3D nel caso in cui il punto faccia parte di una curva 3d sulla superficie
-      // pPlCut è il piano di taglio su cui dovrebbe giacere il punto raffinato
+      // ptIPrev è un punto addizionale che precede o segue il punto pt3D nel caso in cui il punto faccia parte di una curva 3d sulla superficie
+      // pPlCut è il piano di taglio su cui dovrebbe giacere il punto raffinato
       bool UnprojectPoint( const Point3d& pt3D, Point3d& ptParam, const Point3d& ptIPrev, bool* bTroughEdge = nullptr, const Plane3d* plCut = nullptr) const override ;
-      // pPlCut è il piano di taglio su cui giace la curva
+      // pPlCut è il piano di taglio su cui giace la curva
       bool UnprojectCurveFromStm( const ICurveComposite* pCC, ICRVCOMPOPVECTOR& vpCC, const Plane3d* pPlCut) const override ;
       // funzione per tagliare una superficie di bezier con un piano ( cancello la parte dal lato positivo della normale del piano).
       // bSaveOnEq indica se tenere i triangoli (della trimesh associata) che sono sul piano
@@ -138,8 +147,8 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       bool IncreaseUV( double& dU, double dx, bool bUOrV, double* dUVCopy = nullptr, bool bModifyOrig = true) const override ;
       bool IncreaseUV( Point3d& ptUV, Vector3d vtH , Point3d* ptUVCopy, bool bModifyOrig) const override ;
       // funzione che restituisce gli edge della superficie o in forma di linea spezzata o in forma di curva di Bezier
-      // se la superficie è trimmata restituisce i loop dello spazio parametrico in forma di linee spezzate
-      bool GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge = -1) const override ;  // se la superficie non è trimmata restituisce un vettore di 4 elementi. Se la superficie è chiusa lungo un parametro i lati algi estremi di quel parametro saranno null.
+      // se la superficie è trimmata restituisce i loop dello spazio parametrico in forma di linee spezzate
+      bool GetLoops( ICRVCOMPOPOVECTOR& vCC, bool bLineOrBezier, int nEdge = -1) const override ;  // se la superficie non è trimmata restituisce un vettore di 4 elementi. Se la superficie è chiusa lungo un parametro i lati algi estremi di quel parametro saranno null.
       bool IsPlanar( void) const override ;
       bool CreateByFlatContour( const PolyLine& PL) override ;
       bool CreateByRegion( const POLYLINEVECTOR& vPL) override ;
@@ -203,12 +212,12 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       ISurfFlatRegion* CreateTrimRegionFromCuts( ICRVCOMPOPOVECTOR& vpCCOpen, ICRVCOMPOPOVECTOR& vpCCClosed) const ;
       // restituisce il singolo edge della superficie non trimmata
       ICurveComposite* GetSingleEdge3D( bool bLineOrBezier, int nEdge) const ;
-      bool UpdateEdgesFromTree( Tree& tr) const ;
       // funzione che calcola se gli edge sono collassati in poli
       bool CalcPoles( void) const ;
       bool FindMatchByParam( const PolyLine& pl0, const PolyLine& pl1, INTVECTOR& vMatch, int& nLong) const ;
       bool ReorderPntVector( const POLYLINEVECTOR& vPL, bool bTriangulatedIn3D, const PNTVECTOR& vPnt, const POLYLINEVECTOR& vPLToOrd, PNTVECTOR& vPntOrd) const ;
       bool ReorderPntEnhancedVector( const POLYLINEVECTOR& vPL, bool bTriangulatedIn3D, const PNTVECTOR& vPnt, const POLYLINEVECTOR& vPLToOrd, PNTVECTOR& vPntOrd) const ;
+      bool GetBernstein( double dU, int nDegU, DBLVECTOR& vBernU) const ;
 
    private :
       ObjGraphicsMgr  m_OGrMgr ;        // gestore grafica dell'oggetto
@@ -220,17 +229,24 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       int             m_nSpanV ;        // numero di pezze in V
       bool            m_bRat ;          // flag di razionale/polinomiale
       bool            m_bTrimmed ;      // flag per presenza regione di trim
-      mutable bool    m_bClosedU ;      // flag che indica se la superficie è chiusa lungo il parametro U
-      mutable bool    m_bClosedV ;      // flag che indica se la superficie è chiusa lungo il parametro V
+      mutable bool    m_bClosedU ;      // flag che indica se la superficie è chiusa lungo il parametro U
+      mutable bool    m_bClosedV ;      // flag che indica se la superficie è chiusa lungo il parametro V
       mutable BOOLVECTOR m_vbPole ;  // vettore di flag che indicano se i lati sono collassati in dei poli
       PNTVECTOR       m_vPtCtrl ;       // vettore dei punti di controllo
       DBLVECTOR       m_vWeCtrl ;       // vettore dei pesi di controllo
       SurfFlatRegion* m_pTrimReg ;      // eventuale regione di trim
-      int             m_nTempProp[2] ;  // vettore proprietà temporanee
+      int             m_nTempProp[2] ;  // vettore proprietà temporanee
       double          m_dTempParam[2] ; // vettore parametri temporanei
       mutable vector<ICRVCOMPOPOVECTOR> m_mCCEdge ;// vettore dei vettori che contengono le curve compo degli edge della superficie nello spazio 3D
       mutable ICRVCOMPOPOVECTOR m_vCCLoop ; // vettore dei loop della superficie trimmata
-      mutable int    m_nIsPlanar ;     // enum che indica se la superficie è piana ( -1, non è stato calcolato)
+      mutable int    m_nIsPlanar ;     // enum che indica se la superficie è piana ( -1, non è stato calcolato)
+      mutable DBLVECTOR      m_vBernU ;
+      mutable DBLVECTOR      m_vBernV ;
+      //mutable PNTVECTOR      m_ptTemp ;
+      //mutable PNTVECTOR      m_ptTempW ;
+      //mutable DBLVECTOR      m_dTempW ;
+      //mutable PNTVECTOR      m_vPtWCtrlLoc ;
+      //mutable DBLVECTOR      m_vWeCtrlLoc ;
 } ;
 
 //-----------------------------------------------------------------------------

SurfTriMesh.cpp

@@ -2091,17 +2091,6 @@ SurfTriMesh::CreateByFlatContour( const PolyLine& PL)
    return AdjustTopology() ;
 }
 
-//----------------------------------------------------------------------------
-bool
-SurfTriMesh::CreateByPolygonWithHoles( const POLYLINEVECTOR& vPL)
-{
-   INTMATRIX vnPLIndMat ;
-   vnPLIndMat.push_back( { 0}) ;
-   for ( int i = 1 ; i < int( vPL.size()) ; ++ i)
-      vnPLIndMat[0].push_back( i) ;
-   return CreateByRegion( vPL, vnPLIndMat) ;
-}
-
 //----------------------------------------------------------------------------
 bool
 SurfTriMesh::CreateByRegion( const POLYLINEVECTOR& vPL, const INTMATRIX& vnPLIndMat)

SurfTriMesh.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2025
+//  EgalTech 2014-2023
 //----------------------------------------------------------------------------
-// File : SurfTriMesh.h         Data : 28.03.25          Versione : 2.7c4
+// File : SurfTriMesh.h         Data : 09.12.23          Versione : 2.5l2
 // Contenuto : Dichiarazione della classe Superficie TriMesh.
 //
 //
@@ -251,7 +251,6 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       bool RemoveTriangle( int nId) override ;
       bool AdjustTopology( void) override ;
       bool CreateByFlatContour( const PolyLine& PL) override ;
-      bool CreateByPolygonWithHoles( const POLYLINEVECTOR& vPL) override ;
       bool CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr) override ;
       bool CreateByPointCurve( const Point3d& ptP, const PolyLine& PL) override ;
       bool CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nRuledType) override ;

Tree.h

@@ -20,6 +20,18 @@
 #include "/EgtDev/Include/EGkPolyLine.h"
 #include "/EgtDev/Include/EGkChainCurves.h"
 #include <map>
+#include <utility>
+#include <queue>
+#include <functional>
+#include <condition_variable>
+
+struct PairHashInt64 {
+   size_t operator()(const pair<int64_t, int64_t>& key) const {
+      size_t h1 = std::hash<int64_t>{}(key.first) ;
+      size_t h2 = std::hash<int64_t>{}(key.second) ;
+      return h1 ^ (h2 << 1);  // Combine hashes
+   }
+};
 
 //----------------------------------------------------------------------------
 struct Inters {
@@ -194,9 +206,11 @@ class Cell
       void SetProcessed( bool bProcessed = true)
               { m_bProcessed = bProcessed ; }
       static bool minorX( const Cell& c1, const Cell& c2)
-                     { return c1.m_ptPbl.x < c2.m_ptPbl.x ; }
+              { return c1.m_ptPbl.x < c2.m_ptPbl.x ; }
       static bool minorY( const Cell& c1, const Cell& c2)
-                     { return c1.m_ptPbl.y < c2.m_ptPbl.y ; }
+              { return c1.m_ptPbl.y < c2.m_ptPbl.y ; }
+      void AddPoly( int nPolyId)
+              { m_vnPolyId.push_back( nPolyId) ;}
 
    public :
       int                  m_nId ;              // Id della cella
@@ -219,6 +233,7 @@ class Cell
                                                 // ogni elemento del vettore è l'insieme dei punti che caratterizza un attraversamento della cella
       int                  m_nVertToErase ;     // vertice da eliminare dal poligono della cella, in caso di lato sovrapposto ad un lato di polo
                                                 // contati in senso CCW a partire dal bottom left
+      INTVECTOR            m_vnPolyId ;         // indici dei poligoni associati a questa cella nel vettore m_vPolygons del Tree
 
    private :
       Point3d          m_ptPbl ;            // punto bottom left
@@ -237,21 +252,19 @@ class Tree
       Tree( const Point3d ptBl, const Point3d ptTr) ; // creatore da usare solo nel caso in cui si voglia aggiungere tagli ad un'unica cella e del risultato ottenere il contorno 
       bool SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches = true, const Point3d& ptMin = ORIG, const Point3d& ptMax = ORIG) ;
       bool GetIndependentTrees( BIPNTVECTOR& vTrees) ;                             // calcolo la suddivisione della superficie solo sulle singole bbox dei loop di trim ( unendo quelli vicini)
-      bool BuildTree( double dLinTol = LIN_TOL_STD, double dSideMin = 1, double dSideMax = INFINITO) ; // dSideMax è il massimo per la dimensione maggiore di un triangolo della trimesh
+      void BranchManager( queue<function<void()>>& tasks, condition_variable& cv, bool& done) ;
+      bool BuildTree( double dLinTol = LIN_TOL_STD, double dSideMin = 1, double dSideMax = INFINITO) ;
+      bool BuildBranch( int nFirstCell, unordered_map<int, Cell>& mBranch, double dLinTol = LIN_TOL_STD, double dSideMin = 1, double dSideMax = INFINITO) ; // dSideMax è il massimo per la dimensione maggiore di un triangolo della trimesh
                                                                                                        // dSideMin è lunghezza minima del lato di una cella nello spazio reale
       bool BuildTree_test( double dLinTol = LIN_TOL_STD, double dSideMin = 1, double dSideMax = INFINITO) ;
-      bool GetPolygons( POLYLINEMATRIX& vvPolygons) ;
-      bool GetPolygons( POLYLINEMATRIX& vvPolygons, POLYLINEMATRIX& vvPolygons3d) ;
-      bool GetPolygons( POLYLINEMATRIX& vPolygons, bool bForTriangulation, POLYLINEMATRIX& vvPolygons3d) ;
-      bool GetPolygonsBasic( POLYLINEVECTOR& vPolygons, POLYLINEVECTOR& vPolygonsCorrected,                 // restituisce il poligono corrispondente ad ogni cella foglia dell'albero
-                              bool bForTriangulation, POLYLINEVECTOR& vPolygons3d, INTVECTOR vCells = {}) ; // ad ogni poligono sono stati aggiunti tutti i vertici dei vicini posizionati sui suoi lati
-                                                                                                            // se richiesti per la triangolazione ad alcuni poligoni potrebbero venire tolti dei punti per evitare errori dovuti ad eventuali poli sui bordi del parametrico
-      bool GetPolygonsBasic( POLYLINEVECTOR& vPolygons, POLYLINEVECTOR& vPolygonsCorrected, POLYLINEVECTOR& vPolygons3d) ;
-      bool GetPolygonsBasic( POLYLINEVECTOR& vPolygons, INTVECTOR vCells = {}) ;
-      bool GetLeaves ( std::vector<Cell>& vLeaves) const ;  // restituisce gli indici delle foglie nell'albero
-      bool GetEdges3D ( POLYLINEMATRIX& mPLEdges) ;  // restituisce gli edge 3D come polyline
-      bool GetSplitLoops( POLYLINEVECTOR& vPl) const // funzione che restituisce i loop splitatti ai confini delle celle
-            { for ( int i = 0 ; i < int( m_vPlLoop2D.size()); ++i) vPl.emplace_back( m_vPlLoop2D[i]) ; return true ; };
+      bool GetPolygons( POLYLINEMATRIX& vvPolygons, POLYLINEMATRIX& vvPolygons3d, vector<ICRVCOMPOPOVECTOR>& vCCEdges3D, ICRVCOMPOPOVECTOR& vCCLoops) ;
+      bool GetPolygonsBasic( POLYLINEVECTOR& vPolygons, POLYLINEVECTOR& vPolygonsCorrected, POLYLINEVECTOR& vPolygons3d) ; // restituisce il poligono corrispondente ad ogni cella foglia dell'albero
+                                                                                                                           // ad ogni poligono sono stati aggiunti tutti i vertici dei vicini posizionati sui suoi lati
+                                                                                                                           // ad alcuni poligoni potrebbero venire tolti dei punti per evitare errori dovuti ad eventuali poli sui bordi del parametrico
+      bool GetLeaves ( vector<Cell>& vLeaves) const ;  // restituisce gli indici delle foglie nell'albero
+      bool GetEdges3D ( vector<ICRVCOMPOPOVECTOR>& mCCEdge, POLYLINEVECTOR& vPolygons) ;  // restituisce gli edge 3D come polyline
+      bool GetSplitLoops( ICRVCOMPOPOVECTOR& vCCLoopSplit) const // funzione che restituisce i loop splitatti ai confini delle celle
+             { for ( int i = 0 ; i < int( m_vCCLoop2D.size()); ++i) vCCLoopSplit.emplace_back( m_vCCLoop2D[i]->Clone()) ; return true ; };
       void SetTestMode( void) { m_bTestMode = true ;} ;        // attivando la test mode, per la costruzione dell'albero viene usata la funzione BuiltTree_test e viene corretta di conseguenza la FindCell
       // funzioni da usare per ricostruire tagli che vanno aggiunti allo spazio parametrico
       bool AddCutsToRoot( POLYLINEVECTOR& vCuts) ;          // aggiunge i tagli al tree
@@ -261,9 +274,8 @@ class Tree
       std::vector<bool> GetPoles( void) { return m_vbPole ;} ; // funzione che restituisce i flag che indicano se i lati sono collassati in dei poli
 
    private :
-      bool LimitLoop( PolyLine& pl, POLYLINEVECTOR& vPl, BOOLVECTOR& vbOrientation) const ;              // funzione che limita i loop di trim allo spazio parametrico
-      bool Split( int nId, double dSplitValue) ;                              // funzione di split di una cella al parametro indicato nella direzione data da bVert
-      bool Split( int nId) ;                                                  // funzione di split di una cella dell'albero a metà nella direzione data da bVert
+      bool Split( int nId, double dSplitValue, unordered_map<int, Cell>& mBranch) ;// funzione di split di una cella al parametro indicato nella direzione data da bVert
+      bool Split( int nId,unordered_map<int, Cell>& mBranch) ;                     // funzione di split di una cella dell'albero a metà nella direzione data da bVert
       void Balance( void) ;                                                       // creo rami in modo che tutte tutte le foglie abbiano come adiacenti foglie ad una profondità di +- 1
       int GetHeightLeaves( int nId, INTVECTOR& vnLeaves, int d = 0) const ;  // altezza del subtree a partire dal nodo nId
       int GetDepth( int nId, int nRef) const ;                               // livello del nodo nId
@@ -279,7 +291,7 @@ class Tree
       bool FindInters( int& nId, const CurveLine& clTrim, const PolyLine& plPolygon, PNTVECTOR& vptInters, bool bFirstInters = true) ;   // trova le intersezioni tra una cella e una linea di trim
                                                                               // resituisce l'id della cella verso cui la curva di trim esce e il vettore delle intersezioni per la cella successiva con il primo punto
       bool CreateCellPolygons( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX& vPolygons3d, INTVECTOR& vToCheck, int& nPoly, INTVECTOR& vnParentChunk, const PolyLine& plCell, const PolyLine& plCell3d) ;  // crea i poligoni della cella passata. richiede anche la funzione CreateIslandAndHoles per completare i poligoni.
-      bool CreateIslandAndHoles( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX& vvPolygons3d, int& nPoly, INTVECTOR& vnParentChunk, bool bForTriangulation, 
+      bool CreateIslandAndHoles( int nLeafId, POLYLINEMATRIX& vPolygons, POLYLINEMATRIX& vvPolygons3d, int& nPoly, INTVECTOR& vnParentChunk, 
                                  const PolyLine& plPolygonsBasic, const PolyLine& plPolygonsBasic3d) ;  // ai poligoni generati da CreatePolygonsCell aggiunge i loop che creano isole o buchi all'interno della singola cella
       bool CheckIfBefore( const PolyLine& pl, int nEdge) const ;  // controllo se ptEnd è prima di ptStart sul lato nEdge rispetto al senso antiorario
       bool CheckIfBefore( const Inters& inA) const ;  // controlla se l'ingresso è prima dell'uscita in senso antiorario a partire da ptTR.
@@ -294,21 +306,19 @@ class Tree
       bool CheckIfBetween( const Inters& inA, const Inters& inB) const ; // / controllo se inB è compreso tra l'end e lo start di inA (in senso CCW)
       bool OnWhichEdge( int nId, const Point3d& ptToAssign, int& nEdge) const ;  // indica a quale edge o vertice il punto è vicino entro EPS_SMALL
       bool AdjustCuts( void) ;
-      bool UpdateSplitLoop( PolyLine& pl, int& nCount, Point3d& pt) ;
-      bool CloseOpenCuts( void) ;
-      bool CloseOpenCuts( POLYLINEVECTOR& vPL, PolyLine& pl) const ;
+      bool UpdateSplitLoop( ICurveComposite* pCC, Point3d& pt) ;
       bool VerifyLoopOrientation( ICURVEPLIST& vpCrv, BOOLVECTOR& vbOrientation) const ;  // verifico l'orientazione ( CCW o CW) delle polyline in base a come sono contenute le une nelle altre
       bool AdjustLoop( PolyLine& pl, POLYLINEVECTOR& vPl, BOOLVECTOR& vbOrientation) const ;
+      bool GetPoint(double dU, double dV, Point3d& pt) const ;
+      bool SavePoint( double dU, double dV, Point3d& pt) ;
 
 
    private :
       const SurfBezier*           m_pSrfBz ;           // superficie di bezier
       DBLVECTOR                   m_vDim ;             // distanze tra i vertici della superficie di bezier in 3d in ordine antiorario a partire da ptP00
       bool                        m_bTrimmed ;         // superficie trimmata
-      //INTMATRIX                   m_vChunk ;           // elenco dei loop divisi per chunk
-      std::unordered_map<int,int>   m_mChunk ;           // mappa in cui vengono salvati chunk di appartenza per ogni loop di trim
-      //ICURVEPOVECTOR              m_vLoop ;            // curve di loop
-      std::vector<std::tuple<PolyLine,bool>> m_vPlApprox ;  // vettore contenente le approssimazioni dei loop  // il bool indica se la curva è CCW
+      unordered_map<int,int>      m_mChunk ;           // mappa in cui vengono salvati chunk di appartenza per ogni loop di trim
+      vector<tuple<PolyLine,bool>> m_vPlApprox ;       // vettore contenente le approssimazioni dei loop  // il bool indica se la curva è CCW
       bool                        m_bBilinear ;        // superficie bilineare
       bool                        m_bMulti ;           // superficie multi-patch
       bool                        m_bClosedU ;         // superficie chiusa lungo il parametro U
@@ -319,14 +329,11 @@ class Tree
       int                         m_nDegV ;            // grado della superficie nel parametro V
       int                         m_nSpanU ;           // numero di span lungo il parametro U
       int                         m_nSpanV ;           // numero di span lungo il parametro V
-      POLYLINEMATRIX              m_vPolygons ;        // matrice dei poligoni del tree
-      POLYLINEMATRIX              m_vPolygonsCorr ;    // matrice dei poligoni del tree, corretti per i punti che sono nei poli
-      POLYLINEMATRIX              m_vPolygons3d ;        // matrice dei poligoni3d del tree
-      std::unordered_map<int,Cell>          m_mTree ;            // mappa che contiene tutti i nodi e le foglie dell'albero. -2 è puntatore Null e -1 è root
-      std::unordered_map<int,PNTVECTOR>     m_mVert ;            // mappa che contiene tutti i vertici 3d delle celle del tree. L'Id è lo stesso che la cella ha in m_mTree. I punti sono nell'ordine P00, P10, P11, P01
+      unordered_map<int,Cell>     m_mTree ;            // mappa che contiene tutti i nodi e le foglie dell'albero. -2 è puntatore Null e -1 è root
+      mutable unordered_map<pair<int64_t, int64_t>,Point3d, PairHashInt64>     m_mPt3d ;    // mappa che contiene tutti i punti 3d della superficie calcolati (la chiave sono le coordinate, moltiplicate per 2^24 e trasformate in int)
       INTVECTOR                   m_vnLeaves ;         // vettore delle foglie
       INTVECTOR                   m_vnParents ;        // vettore delle celle ottenute dalla divisione preliminare in singole patch
       bool                        m_bTestMode ;        // bool che indica se la test mode è attiva
-      POLYLINEVECTOR              m_vPlLoop2D ;        // vettore che contiene le polyline che rappresentano i loop di trim tenendo conto della divisione in celle
-      std::vector<std::pair<BIPNTVECTOR, ChainCurves>>    m_vCEdge2D ;        // vettore che le chain che rappresentano ciò che resta degli edge originali, tenendo conto dei trim.
+      ICRVCOMPOPOVECTOR           m_vCCLoop2D ;        // vettore che contiene le CurveCompo che rappresentano i loop di trim tenendo conto della divisione in celle
+      vector<pair<BIPNTVECTOR, ChainCurves>>    m_vCEdge2D ;        // vettore che le chain che rappresentano ciò che resta degli edge originali, tenendo conto dei trim.
 } ;

Voronoi.cpp

@@ -574,7 +574,7 @@ Voronoi::CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide)
          if ( m_vroni->IsWMATEdge( i)) {
             PtrOwner<ICurve> pCrv( GetBisectorCurve( i)) ;
             if ( ! IsNull( pCrv) && pCrv->IsValid()) 
-               vCrvs.emplace_back( Release( pCrv)) ; 
+               vCrvs.emplace_back( Release( pCrv)) ;          
          }         
       }
 
@@ -594,7 +594,7 @@ bool
 Voronoi::CalcOffset( ICURVEPOVECTOR& vOffs, double dOffs, int nType)
 {
    vOffs.clear() ;
-
+ 
    if ( ! IsValid())
       return false ;
 
@@ -767,76 +767,6 @@ Voronoi::CalcSingleCurvesOffset( ICURVEPOVECTOR& vOffs, double dOffs)
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool 
-Voronoi::CalcSpecialPointOffset( PNTVECTVECTOR& vResult, double dOffs)
-{
-  // calcola i punti e le tangenti sui bisettori del medial axis in corrispondenza del valore di offset richiesto
- 
-   vResult.clear() ;
-
-   if ( abs( dOffs) < EPS_SMALL)
-      return true ;
-
-   if ( ! IsValid())
-      return false ;
-
-   try {
-     // verifico se necessario ricalcolo Voronoi
-      UpdateVoronoi( dOffs) ;
-
-     // indivudio lato medial axis per curve chiuse ( suppongo di chiamare la funzione dalla singola curva, quindi vale controllare 
-     // la chiusura solo sulla prima curva. Eventualmente da estendere)
-      bool bLeft = true, bRight = true ;
-      if ( m_vpCrvs[0]->IsClosed()) {
-         bLeft = dOffs < 0 ;
-         bRight = ! bLeft ;      
-      }
-
-     // calcolo medial axis
-      m_vroni->apiComputeWMAT( false, 0.0, 0.0, false, bLeft, bRight) ;
-
-      for ( int i = 4 ; i < m_vroni->GetNumberOfEdges() ; i ++) {
-        // verifico se il lato appartiene al medial axis
-         if ( m_vroni->IsWMATEdge( i)) {
-           // verifico se coinvolto dall'offset
-            double dParS, dParE ;
-            m_vroni->GetBisectorParams( i, dParS, dParE) ;
-            if ( dParS > dParE)
-               swap( dParS, dParE) ;
-            if ( abs( dOffs) < dParS  ||  abs( dOffs) > dParE)
-               continue ;
-
-           // calcolo il punto sul bisettore in corrispondenza dell'offset
-            Point3d pt ;
-            m_vroni->GetBisectorPointAtParam( i, abs( dOffs), pt.v) ;
-
-           // calcolo il vettore tangente
-            PtrOwner<ICurve> pCrv( GetBisectorCurve( i)) ;
-            if ( IsNull( pCrv))
-               return false ;
-            double dPar ;
-            Point3d ptTemp ;
-            Vector3d vtDir ;
-            if ( ! pCrv->GetParamAtPoint( pt, dPar, 100 * EPS_SMALL)  ||  ! pCrv->GetPointD1D2( dPar, ICurve::FROM_MINUS, ptTemp, &vtDir))  
-               return false ;             
-            vtDir.Normalize() ;
-
-            vResult.emplace_back( pt, vtDir) ;
-         }         
-      }
-
-     // libero la memoria di vroni utilizzata per calcolare bisettori
-      m_vroni->apiFreeBisectorBuffer() ;
-   }
-   catch (...) {
-      LOG_ERROR( GetEGkLogger(), m_vroni->GetExceptionMessage()) ;
-      return false ;
-   }
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool 
 Voronoi::CalcFatCurve( ICURVEPOVECTOR& vCrvs, double dOffs, bool bSquareEnds, bool bSquareMids)
@@ -956,24 +886,14 @@ Voronoi::CalcVroniOffset( ICRVCOMPOPLIST& OffsList, double dOffs)
             }
             else {              
                PtrOwner<CurveArc> pArc( CreateBasicCurveArc()) ;
-               if ( ! pArc->SetC2P( ptC, ptS, ptE)) {
-                 // se raggio minore di EPS_SMALL approssimo con linea
-                  if ( AreSamePointApprox( ptC, ptS)) {
-                     if ( ! pCrvOffs->AddLine( ptE))
-                        return false ;                  
-                  }
-                  else
-                     return false ;               
-               }
-               else {
-                 // verifico orientamento
-                  double dAng = pArc->GetAngCenter() ;
-                  if ( ( nType == CCW  &&  dAng < - EPS_ANG_SMALL)  ||  ( nType == CW  &&  dAng > EPS_ANG_SMALL))
-                     pArc->ToExplementary() ;
-                 // aggiungo alla composita
-                  if ( ! pCrvOffs->AddCurve( Release( pArc)))
-                     return false ;              
-               }              
+               pArc->SetC2P( ptC, ptS, ptE) ;
+              // verifico orientamento
+               double dAng = pArc->GetAngCenter() ;
+               if ( ( nType == CCW  &&  dAng < - EPS_ANG_SMALL)  ||  ( nType == CW  &&  dAng > EPS_ANG_SMALL))
+                  pArc->ToExplementary() ;
+              // aggiungo alla composita
+               if ( ! pCrvOffs->AddCurve( Release( pArc)))
+                  return false ;
             }
 
            // setto come info la sottocurva da cui si è generata

Voronoi.h

@@ -56,7 +56,6 @@ class Voronoi
       bool CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound = VORONOI_STD_BOUND) ;
       bool CalcOffset( ICURVEPOVECTOR& vOffs, double dOffs, int nType) ;
       bool CalcSingleCurvesOffset( ICURVEPOVECTOR& vOffs, double dOffs) ;
-      bool CalcSpecialPointOffset( PNTVECTVECTOR& vResult, double dOffs) ;
       bool CalcFatCurve( ICURVEPOVECTOR& vOffs, double dOffs, bool bSquareEnds, bool bSquareMids) ;
       bool CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide) ;
       bool CalcLimitOffset( int nCrv, bool bLeft, double& dOffs) ;