EgtGeomKernel 1.6h3 :

- migliorata approssimazione curve per riconoscimento di tratti rettilinei - aggiunta CopyMaterial a GeomDB - correzioni a IntersCurveCurve per le curve approssimate - aggiunte a Intervals Union, Intersection e Difference - correzioni a SelfIntersCurve per curve approssimate - aggiunte funzioni di creazione Regioni (Rectangle, Stadium, Disk e da zuppa di curve) - migliorie varie a Regioni e introduzione dei componenti connessi (chunk).
2015-08-18 07:30:08 +00:00
parent f4b88af3e1
commit bab45eb4f3
28 changed files with 1049 additions and 346 deletions
@@ -31,7 +31,7 @@ GEOOBJ_REGISTER( SRF_FLATRGN, NGE_S_FRG, SurfFlatRegion) ;

 //----------------------------------------------------------------------------
 SurfFlatRegion::SurfFlatRegion( void)
-   : m_pSTM( nullptr), m_nStatus( TO_VERIFY), m_pExtLoop( nullptr), m_nTempProp(), m_Iter( m_vpIntLoop.end())
+   : m_pSTM( nullptr), m_nStatus( TO_VERIFY), m_nTempProp()
 {
 }

@@ -45,32 +45,26 @@ SurfFlatRegion::~SurfFlatRegion( void)
 bool
 SurfFlatRegion::Clear( void)
 {
-   if ( m_pSTM != nullptr)
-      delete( m_pSTM) ;
-   m_pSTM = nullptr ;
   m_nStatus = TO_VERIFY ;
   m_frF.Reset() ;

-  // ciclo di pulizia
-   if ( m_pExtLoop != nullptr)
-      delete( m_pExtLoop) ;
-   m_pExtLoop = nullptr ;
-   for ( auto Iter = m_vpIntLoop.begin() ; Iter != m_vpIntLoop.end() ; ++Iter)
-      delete (*Iter) ;
-   m_vpIntLoop.clear() ;
+  // pulizia dei loop
+   for ( auto& pLoop : m_vpLoop)
+      delete pLoop ;
+   m_vpLoop.clear() ;

   m_nTempProp = 0 ;
-   m_Iter = m_vpIntLoop.end() ;

  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;
+   ResetAuxSurf() ;

   return true ;
 }

 //----------------------------------------------------------------------------
 bool
-SurfFlatRegion::SetExtLoop( const ICurve& cCrv)
+SurfFlatRegion::AddExtLoop( const ICurve& cCrv)
 {
  // verifico validità curva
   if ( &cCrv == nullptr)
@@ -80,15 +74,13 @@ SurfFlatRegion::SetExtLoop( const ICurve& cCrv)
   if ( pCrv == nullptr)
      return false ;
  // procedo
-   return SetExtLoop( pCrv) ;
+   return AddExtLoop( pCrv) ;
 }

 //----------------------------------------------------------------------------
 bool
-SurfFlatRegion::SetExtLoop( ICurve* pCrv)
+SurfFlatRegion::AddExtLoop( ICurve* pCrv)
 {
-  // resetto tutto
-   Clear() ;
  // acquisisco la curva
   PtrOwner<ICurve> pMyCrv( pCrv) ;
   if ( IsNull( pMyCrv))
@@ -97,28 +89,71 @@ SurfFlatRegion::SetExtLoop( ICurve* pCrv)
   if ( ! pMyCrv->IsClosed())
      return false ;
  // verifico sia piana
+   double dArea ;
   Plane3d plPlane ;
-   if ( ! pMyCrv->IsFlat( plPlane))
-      return false ;
-  // assegno il riferimento intrinseco
-   if ( ! m_frF.Set( ORIG + plPlane.vtN * plPlane.dDist, plPlane.vtN))
+   if ( ! pMyCrv->GetArea( plPlane, dArea))
      return false ;
+  // se sto costruendo il primo chunk
+   if ( m_vExtInd.size() == 0) {
+     // assegno il riferimento intrinseco
+      if ( ! m_frF.Set( ORIG + plPlane.vtN * plPlane.dDist, plPlane.vtN))
+         return false ;
+     // sistemo il senso di rotazione (deve essere CCW -> area > 0)
+      if ( dArea < 0)
+         pMyCrv->Invert() ;
+   }
+  // altrimenti
+   else {
+     // verifico che il piano della curva coincida con quello XY intrinseco
+      plPlane.ToLoc( m_frF) ;
+      if ( ! ( plPlane.vtN.IsZplus()  ||  plPlane.vtN.IsZminus())  ||  fabs( plPlane.dDist) > EPS_SMALL)
+         return false ;
+     // sistemo il senso di rotazione (deve essere CCW -> area > 0)
+      if ( ( plPlane.vtN.IsZplus()  &&  dArea < 0)  ||
+           ( plPlane.vtN.IsZminus()  &&  dArea > 0))
+         pMyCrv->Invert() ;
+   }
  // porto la curva nel riferimento intrinseco
   if ( ! pMyCrv->ToLoc( m_frF))
      return false ;
  // verifico non abbia auto-intersezioni
   SelfIntersCurve sInt( *pMyCrv) ;
-   if ( sInt.GetNumInters() > 0)
+   if ( sInt.GetIntersCount() > 0)
      return false ;
-  // sistemo il senso di rotazione (deve essere CCW -> area > 0)
-   double dArea ;
-   if ( ! pMyCrv->GetAreaXY( dArea)  ||  fabs( dArea) < 100 * EPS_SMALL * EPS_SMALL)
+  // verifico che sia esterna alle curve esterne degli altri chunk
+   bool bOk = true ;
+   CRVCVECTOR ccClass ;
+   for ( auto i : m_vExtInd) {
+      IntersCurveCurve ccInt( *pMyCrv, *m_vpLoop[i]) ;
+      if ( ccInt.GetNumInters() > 0  ||
+           ! ccInt.GetCurveClassification( 0, ccClass)  ||
+           ccClass.empty()  ||  ccClass[0].nClass != CRVC_OUT) {
+         bOk = false ;  
+         break ;  
+      }
+   }
+  // oppure esterna ad un loop interno degli altri chunk
+   for ( int i = 0 ; i < int( m_vpLoop.size()) ; ++ i) {
+      // se loop esterno, salto
+       if ( binary_search( m_vExtInd.begin(), m_vExtInd.end(), i))
+          continue ;
+      IntersCurveCurve ccInt( *pMyCrv, *m_vpLoop[i]) ;
+      if ( ccInt.GetNumInters() == 0  &&
+           ccInt.GetCurveClassification( 0, ccClass)  &&
+           ! ccClass.empty()  &&  ccClass[0].nClass == CRVC_OUT) {
+         bOk = true ;  
+         break ;  
+      }
+   }
+   if ( ! bOk)
      return false ;
-   if ( dArea < 0)
-      pMyCrv->Invert() ;
-  // assegno la curva al loop esterno
-   m_pExtLoop = Release( pMyCrv) ;
+  // assegno la curva come loop esterno
+   m_vpLoop.push_back( Release( pMyCrv)) ;
+   m_vExtInd.push_back( int( m_vpLoop.size()) - 1) ;
   m_nStatus = OK ;
+  // imposto ricalcolo della grafica
+   ResetAuxSurf() ;
+   m_OGrMgr.Reset() ;
   return true ;
 }

@@ -143,10 +178,10 @@ SurfFlatRegion::AddIntLoop( ICurve* pCrv)
 {
  // acquisisco la curva
   PtrOwner<ICurve> pMyCrv( pCrv) ;
-   if ( IsNull( pMyCrv))
+   if ( IsNull( pMyCrv)  ||  ! pMyCrv->IsValid())
      return false ;
  // verifico lo stato
-   if ( m_nStatus != OK  ||  m_pExtLoop == nullptr)
+   if ( m_nStatus != OK  ||  m_vpLoop.empty())
      return false ;
  // verifico sia chiusa
   if ( ! pMyCrv->IsClosed())
@@ -155,36 +190,33 @@ SurfFlatRegion::AddIntLoop( ICurve* pCrv)
   if ( ! pMyCrv->ToLoc( m_frF))
      return false ;
  // verifico sia piana e il piano coincida con quello XY intrinseco
+   double dArea ;
   Plane3d plPlane ;
-   if ( ! pMyCrv->IsFlat( plPlane))
+   if ( ! pMyCrv->GetArea( plPlane, dArea))
      return false ;
-   if ( ! plPlane.vtN.IsZplus()  &&  ! plPlane.vtN.IsZminus()  &&  fabs( plPlane.dDist) > EPS_SMALL)
+   if ( ! ( plPlane.vtN.IsZplus()  ||  plPlane.vtN.IsZminus())  ||  fabs( plPlane.dDist) > EPS_SMALL)
      return false ;
+  // sistemo il senso di rotazione (deve essere CW -> se N==Z+ area < 0, se N==Z- area>0)
+   if ( ( plPlane.vtN.IsZplus()  &&  dArea > 0)  ||  ( plPlane.vtN.IsZminus()  &&  dArea < 0))
+      pMyCrv->Invert() ;
  // verifico non abbia auto-intersezioni
   SelfIntersCurve sInt( *pMyCrv) ;
-   if ( sInt.GetNumInters() > 0)
+   if ( sInt.GetIntersCount() > 0)
      return false ;
-  // verifico non abbia intersezioni e sia interna al loop esterno
-   IntersCurveCurve ccInt( *pMyCrv, *m_pExtLoop) ;
+  // verifico non abbia intersezioni e non sia esterna ai loop già definiti del medesimo chunk
   CRVCVECTOR ccClass ;
-   if ( ccInt.GetNumInters() > 0  ||
-        ! ccInt.GetCurveClassification( 0, ccClass)  ||
-        ccClass.empty()  ||  ccClass[0].nClass != CRVC_IN)
-      return false ;
-  // verifico non abbia intersezioni con eventuali altri loop interni
-   for ( auto& pIntLoop : m_vpIntLoop) {
-      IntersCurveCurve ccInt( *pMyCrv, *pIntLoop) ;
-      if ( ccInt.GetNumInters() > 0)
+   for ( int i = m_vExtInd.back() ; i < int( m_vpLoop.size()) ; ++ i) {
+      IntersCurveCurve ccInt( *pMyCrv, *m_vpLoop[i]) ;
+      if ( ccInt.GetNumInters() > 0  ||
+           ! ccInt.GetCurveClassification( 0, ccClass)  ||
+           ccClass.empty()  ||  ccClass[0].nClass != CRVC_IN)
         return false ;
   }
-  // sistemo il senso di rotazione (deve essere CW -> area < 0)
-   double dArea ;
-   if ( ! pMyCrv->GetAreaXY( dArea)  ||  fabs( dArea) < 100 * EPS_SMALL * EPS_SMALL)
-      return false ;
-   if ( dArea > 0)
-      pMyCrv->Invert() ;
-  // aggiungo la curva all'elenco dei loop interni
-   m_vpIntLoop.push_back( Release( pMyCrv)) ;
+  // aggiungo la curva all'elenco dei loop
+   m_vpLoop.push_back( Release( pMyCrv)) ;
+  // imposto ricalcolo della grafica
+   ResetAuxSurf() ;
+   m_OGrMgr.Reset() ;
   return true ;
 }

@@ -224,17 +256,16 @@ SurfFlatRegion::CopyFrom( const SurfFlatRegion& sfrSrc)
   if ( sfrSrc.m_pSTM != nullptr)
      m_pSTM = sfrSrc.m_pSTM->Clone() ;
   m_frF = sfrSrc.m_frF ;
-   if ( sfrSrc.m_pExtLoop != nullptr)
-      m_pExtLoop = sfrSrc.m_pExtLoop->Clone() ;
-   for ( auto& pIntLoop : sfrSrc.m_vpIntLoop) {
-      ICurve* pCrv = pIntLoop->Clone() ;
+   for ( auto& pLoop : sfrSrc.m_vpLoop) {
+      ICurve* pCrv = pLoop->Clone() ;
      if ( pCrv == nullptr)
         return false ;
-      m_vpIntLoop.push_back( pCrv) ;
+      m_vpLoop.push_back( pCrv) ;
   }
+   m_vExtInd = sfrSrc.m_vExtInd ;
   m_nTempProp = sfrSrc.m_nTempProp ;
   m_nStatus = sfrSrc.m_nStatus ;
-   return ( m_nStatus == OK  &&  m_pExtLoop != nullptr) ;
+   return ( m_nStatus == OK  &&  ! m_vpLoop.empty()) ;
 }

 //----------------------------------------------------------------------------
@@ -268,19 +299,27 @@ SurfFlatRegion::Dump( string& sOut, bool bMM, const char* szNewLine) const
   sOut += "VX(" + ToString( m_frF.VersX()) + ")" + szNewLine ;
   sOut += "VY(" + ToString( m_frF.VersY()) + ")" + szNewLine ;
   sOut += "VZ(" + ToString( m_frF.VersZ()) + ")" + szNewLine ;
-  // loop esterno
-   if ( m_pExtLoop != nullptr) {
-      sOut += string( "External Loop :") + szNewLine ; 
-      m_pExtLoop->Dump( sOut, bMM, szNewLine) ;
-   }
-   else
-      sOut += string( "External Loop Invalid") + szNewLine ; 
-  // loop interni
-   sOut += "Internal Loops=" + ToString( GetIntLoopNumber()) + szNewLine ;
-   int i = 0 ;
-   for ( auto& pIntLoop : m_vpIntLoop) {
-      sOut += "##" + ToString( ++i) + szNewLine ;
-      pIntLoop->Dump( sOut, bMM, szNewLine) ;
+  // ciclo sui chunk (parti connesse)
+   int nChunkCount = GetChunkCount() ;
+   sOut += string( "Chunks =") + ToString( nChunkCount) + szNewLine ;
+   for ( int i = 0 ; i < nChunkCount ; ++ i) {
+      int nLoopCount = GetLoopCount( i) ;
+     // ciclo sui loop del chunk
+      for ( int j = 0 ; j < nLoopCount ; ++ j) {
+         int k = GetIndFromChunkLoop( i, j) ;
+        // loop esterno
+         if ( j == 0) {
+            sOut += "Chunk # " + ToString( i) + szNewLine ;
+            sOut += string( "External Loop : ") + szNewLine ; 
+            m_vpLoop[k]->Dump( sOut, bMM, szNewLine) ;
+            sOut += "Internal Loops =" + ToString( GetLoopCount( i) - 1) + szNewLine ;
+         }
+        // loop interno
+         else {
+            sOut += "## " + ToString( j) + szNewLine ;
+            m_vpLoop[k]->Dump( sOut, bMM, szNewLine) ;
+         }
+      }
   }

   return true ;
@@ -301,29 +340,33 @@ SurfFlatRegion::Save( NgeWriter& ngeOut) const
   if ( ! ngeOut.WriteFrame( m_frF, ";", true))
      return false ;
  // numero di loops (esterno + interni)
-   if ( ! ngeOut.WriteInt( 1 + int( m_vpIntLoop.size()), nullptr, true))
+   if ( ! ngeOut.WriteInt( int( m_vpLoop.size()), nullptr, true))
      return false ;
  // ciclo sui loop
   int i = 0 ;
-   const ICurve* pCrv = GetMyLoop( i) ;
-   while ( pCrv != nullptr) {
+   for ( auto& pLoop : m_vpLoop) {
     // recupero il gestore di lettura/scrittura della curva
-      const IGeoObjRW* pCSmplRW = dynamic_cast<const IGeoObjRW*>( pCrv) ;
-      if ( pCSmplRW == nullptr)
+      const IGeoObjRW* pLoopRW = dynamic_cast<const IGeoObjRW*>( pLoop) ;
+      if ( pLoopRW == nullptr)
         return false ;
     // emetto il tipo della curva
-      if ( ! ngeOut.WriteKey( pCSmplRW->GetNgeId()))
+      if ( ! ngeOut.WriteKey( pLoopRW->GetNgeId()))
         return false ;
-     // assegno ed emetto il nome della curva
+     // assegno ed emetto il nome della curva, seguito da chunk e loop
      string sCrvName = "##" + ToString( i) ;
-      if ( ! ngeOut.WriteString( sCrvName, nullptr, true))
+      if ( ! ngeOut.WriteString( sCrvName, ";"))
+         return false ;
+      int nChunk, nLoop ;
+      if ( ! GetChunkLoopFromInd( i, nChunk, nLoop))
+         return false ;
+      if ( ! ngeOut.WriteInt( nChunk, ",")  ||
+           ! ngeOut.WriteInt( nLoop, ";", true))
         return false ;
     // salvo la curva
-      if ( ! pCSmplRW->Save( ngeOut))
+      if ( ! pLoopRW->Save( ngeOut))
         return false ;
     // passo alla successiva
      ++ i ;
-      pCrv = GetMyLoop( i) ;
   }
   return true ;
 }
@@ -352,11 +395,14 @@ SurfFlatRegion::Load( NgeReader& ngeIn)
      IGeoObj* pGeoO = GEOOBJ_CREATE( nType) ;
      if ( pGeoO == nullptr)
         return false ;
-     // recupero la linea con il nome
+     // recupero la linea con il nome, chunk e loop
      string sName ;
      int j ;
-      bool bOk = ngeIn.ReadString( sName, nullptr, true) && 
+      bool bOk = ngeIn.ReadString( sName, ";") && 
                 FromString( sName.substr(2), j)  &&  i == j ;
+      int nChunk, nLoop ;
+      bOk = ngeIn.ReadInt( nChunk, ",")  &&
+            ngeIn.ReadInt( nLoop, ";", true) ;
     // ne leggo i dati
      IGeoObjRW* pGObjRW = dynamic_cast<IGeoObjRW*>( pGeoO) ;
      bOk = bOk && ( pGObjRW != nullptr && pGObjRW->Load( ngeIn)) ;
@@ -365,10 +411,11 @@ SurfFlatRegion::Load( NgeReader& ngeIn)
      bOk = bOk && ( pCrv != nullptr) ;
     // aggiungo questa curva
      if ( bOk) {
-         if ( i == 0)
-            m_pExtLoop = pCrv ;
-         else
-            m_vpIntLoop.push_back( pCrv) ;
+         m_vpLoop.push_back( pCrv) ;
+         if ( nLoop == 0) {
+            m_vExtInd.push_back( i) ;
+            bOk = ( nChunk + 1 == int( m_vExtInd.size())) ;
+         }
      }
     // se errore 
      if ( ! bOk)
@@ -384,10 +431,10 @@ bool
 SurfFlatRegion::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
 {
  // verifico lo stato
-   if ( m_nStatus != OK  ||  m_pExtLoop == nullptr)
+   if ( m_nStatus != OK  ||  m_vpLoop.empty())
      return false ;
  // è il bounding box del loop esterno
-   return m_pExtLoop->GetBBox( m_frF, b3Loc, nFlag) ;
+   return m_vpLoop[0]->GetBBox( m_frF, b3Loc, nFlag) ;
 }

 //----------------------------------------------------------------------------
@@ -395,12 +442,12 @@ bool
 SurfFlatRegion::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
 {
  // verifico lo stato
-   if ( m_nStatus != OK  ||  m_pExtLoop == nullptr)
+   if ( m_nStatus != OK  ||  m_vpLoop.empty())
      return false ;
  // frame composito
   Frame3d frCompo = m_frF * frRef ;
  // è il bounding box del loop esterno
-   return m_pExtLoop->GetBBox( frCompo, b3Ref, nFlag) ;
+   return m_vpLoop[0]->GetBBox( frCompo, b3Ref, nFlag) ;
 }

 //----------------------------------------------------------------------------
@@ -437,7 +484,7 @@ bool
 SurfFlatRegion::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ)
 {
  // verifico lo stato
-   if ( m_nStatus != OK  ||  m_pExtLoop == nullptr)
+   if ( m_nStatus != OK  ||  m_vpLoop.empty())
      return false ;
  // imposto ricalcolo della grafica
   ResetAuxSurf() ;
@@ -455,18 +502,17 @@ SurfFlatRegion::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, dou

  // porto i loop nel nuovo riferimento, senza modificarne la geometria in globale
   frTrasf.ToLoc( m_frF) ;
-   m_pExtLoop->ToGlob( frTrasf) ;
-   for ( auto& pIntLoop : m_vpIntLoop)
-      pIntLoop->ToGlob( frTrasf) ;
+   for ( auto& pLoop : m_vpLoop)
+      pLoop->ToGlob( frTrasf) ;

  // porto il riferimento di scalatura nel nuovo riferimento del gruppo
   Frame3d frRefLoc = frRef ;
   frRefLoc.ToLoc( m_frF) ;

  // ciclo sui loop
-   bool bOk = m_pExtLoop->Scale( frRefLoc, dCoeffX, dCoeffY, dCoeffZ) ;
-   for ( auto& pIntLoop : m_vpIntLoop) {
-      if ( ! pIntLoop->Scale( frRefLoc, dCoeffX, dCoeffY, dCoeffZ))
+   bool bOk = true ;
+   for ( auto& pLoop : m_vpLoop) {
+      if ( ! pLoop->Scale( frRefLoc, dCoeffX, dCoeffY, dCoeffZ))
         bOk = false ;
   }

@@ -478,7 +524,7 @@ bool
 SurfFlatRegion::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
 {
  // verifico lo stato
-   if ( m_nStatus != OK  ||  m_pExtLoop == nullptr)
+   if ( m_nStatus != OK  ||  m_vpLoop.empty())
      return false ;
  // imposto ricalcolo della grafica
   ResetAuxSurf() ;
@@ -490,9 +536,8 @@ SurfFlatRegion::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)

  // porto i loop nel nuovo riferimento, senza modificarne la geometria in globale
   frTrasf.ToLoc( m_frF) ;
-   m_pExtLoop->ToGlob( frTrasf) ;
-   for ( auto& pIntLoop : m_vpIntLoop)
-      pIntLoop->ToGlob( frTrasf) ;
+   for ( auto& pLoop : m_vpLoop)
+      pLoop->ToGlob( frTrasf) ;

  // porto i dati del piano di mirror nel riferimento del gruppo 
   Point3d ptOnLoc = ptOn ;
@@ -501,9 +546,9 @@ SurfFlatRegion::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
   vtNormLoc.ToLoc( m_frF) ;

  // ciclo sui loop (mirror + invert)
-   bool bOk = m_pExtLoop->Mirror( ptOnLoc, vtNormLoc)  &&  m_pExtLoop->Invert() ;
-   for ( auto& pIntLoop : m_vpIntLoop) {
-      if ( ! pIntLoop->Mirror( ptOnLoc, vtNormLoc)  ||  ! pIntLoop->Invert())
+   bool bOk = true ;
+   for ( auto& pLoop : m_vpLoop) {
+      if ( ! pLoop->Mirror( ptOnLoc, vtNormLoc)  ||  ! pLoop->Invert())
         bOk = false ;
   }

@@ -523,7 +568,7 @@ bool
 SurfFlatRegion::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDir, double dCoeff)
 {
  // verifico lo stato
-   if ( m_nStatus != OK  ||  m_pExtLoop == nullptr)
+   if ( m_nStatus != OK  ||  m_vpLoop.empty())
      return false ;
  // imposto ricalcolo della grafica
   ResetAuxSurf() ;
@@ -541,9 +586,8 @@ SurfFlatRegion::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector

  // porto i loop nel nuovo riferimento, senza modificarne la geometria in globale
   frTrasf.ToLoc( m_frF) ;
-   m_pExtLoop->ToGlob( frTrasf) ;
-   for ( auto& pIntLoop : m_vpIntLoop)
-      pIntLoop->ToGlob( frTrasf) ;
+   for ( auto& pLoop : m_vpLoop)
+      pLoop->ToGlob( frTrasf) ;

  // porto i dati di scorrimento nel riferimento del gruppo 
   Point3d ptOnLoc = ptOn ;
@@ -554,9 +598,9 @@ SurfFlatRegion::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector
   vtDirLoc.ToLoc( m_frF) ;

  // ciclo sugli oggetti
-   bool bOk =  m_pExtLoop->Shear( ptOnLoc, vtNormLoc, vtDirLoc, dCoeff) ;
-   for ( auto& pIntLoop : m_vpIntLoop) {
-      if ( ! pIntLoop->Shear( ptOnLoc, vtNormLoc, vtDirLoc, dCoeff))
+   bool bOk = true ;
+   for ( auto& pLoop : m_vpLoop) {
+      if ( ! pLoop->Shear( ptOnLoc, vtNormLoc, vtDirLoc, dCoeff))
         bOk = false ;
   }

@@ -568,24 +612,16 @@ bool
 SurfFlatRegion::ConvertArcsToBezierCurves( void)
 {
  // verifico lo stato
-   if ( m_nStatus != OK  ||  m_pExtLoop == nullptr)
+   if ( m_nStatus != OK  ||  m_vpLoop.empty())
      return false ;
-  // loop esterno
-   if ( m_pExtLoop->GetType() == CRV_ARC) {
-      ICurve* pCrvNew = ArcToBezierCurve( m_pExtLoop) ;
-      if ( pCrvNew == nullptr)
-         return false ;
-      delete m_pExtLoop ;
-      m_pExtLoop = pCrvNew ;
-   }
-  // eventuali loop interni
-   for ( auto& pIntLoop : m_vpIntLoop) {
-      if ( pIntLoop->GetType() == CRV_ARC) {
-         ICurve* pCrvNew = ArcToBezierCurve( pIntLoop) ;
+  // ciclo sui loop
+   for ( auto& pLoop : m_vpLoop) {
+      if ( pLoop->GetType() == CRV_ARC) {
+         ICurve* pCrvNew = ArcToBezierCurve( pLoop) ;
         if ( pCrvNew == nullptr)
            return false ;
-         delete pIntLoop ;
-         pIntLoop = pCrvNew ;
+         delete pLoop ;
+         pLoop = pCrvNew ;
      }
   }
   return true ;
@@ -634,13 +670,13 @@ SurfFlatRegion::GetArea( double& dArea) const
  // inizio con area nulla
   dArea = 0 ;
  // la regione deve essere validata
-   if ( m_nStatus != OK  ||  m_pExtLoop == nullptr)
+   if ( m_nStatus != OK  ||  m_vpLoop.empty())
      return false ;
  // sommo l'area di tutti i loop (gli interni hanno area negativa)
-   bool bOk = m_pExtLoop->GetAreaXY( dArea) ;
-   for ( auto& pIntLoop : m_vpIntLoop) {
+   bool bOk = true ;
+   for ( auto& pLoop : m_vpLoop) {
      double dTemp ;
-      if ( pIntLoop->GetAreaXY( dTemp))
+      if ( pLoop->GetAreaXY( dTemp))
         dArea += dTemp ;
      else
         bOk = false ;
@@ -657,35 +693,111 @@ SurfFlatRegion::GetCentroid( Point3d& ptCen) const
   if ( &ptCen == nullptr)
      return false ;
  // la regione deve essere validata
-   if ( m_nStatus != OK  ||  m_pExtLoop == nullptr)
+   if ( m_nStatus != OK  ||  m_vpLoop.empty())
      return false ;
  // determino il centroide del solo loop esterno
-   return m_pExtLoop->GetCentroid( ptCen) ;
+   if ( ! m_vpLoop[0]->GetCentroid( ptCen))
+      return false ;
+  // lo porto dal riferimento intrinseco a quello in cui è immersa l'entità
+   ptCen.ToGlob( m_frF) ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+int
+SurfFlatRegion::GetChunkCount( void) const
+{
+  // la regione deve essere validata
+   if ( m_nStatus != OK)
+      return 0 ;
+   return int( m_vExtInd.size()) ;
+}
+
+//----------------------------------------------------------------------------
+int
+SurfFlatRegion::GetLoopCount( int nChunk) const
+{
+  // la regione deve essere validata
+   if ( m_nStatus != OK  ||  m_vpLoop.empty())
+      return 0 ;
+  // non deve superare l'indice massimo ( Count - 1)
+   int nChunkMax = int( m_vExtInd.size()) - 1 ;
+   if ( nChunk < 0  ||  nChunk > nChunkMax)
+      return 0 ;
+  // se non è l'ultimo Chunk
+   if ( nChunk < nChunkMax)
+      return ( m_vExtInd[nChunk+1] - m_vExtInd[nChunk]) ;
+  // altrimenti
+   else
+      return ( int( m_vpLoop.size()) - m_vExtInd[nChunk]) ;
+}
+
+//----------------------------------------------------------------------------
+int
+SurfFlatRegion::GetIndFromChunkLoop( int nChunk, int nLoop) const
+{
+  // recupero il numero di loop nel chunk
+   int nLoopCount = GetLoopCount( nChunk) ;
+   if ( nLoopCount <= 0)
+      return - 1 ;
+  // verifico che il loop esista
+   if ( nLoop < 0  ||  nLoop >= nLoopCount)
+      return - 1 ;
+  // ritorno il suo indice
+   return ( m_vExtInd[nChunk] + nLoop) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+SurfFlatRegion::GetChunkLoopFromInd( int nInd, int& nChunk, int& nLoop) const
+{
+  // valori non validi
+   nChunk = - 1 ;
+   nLoop = - 1 ;
+  // verifico validità di nInd
+   if ( nInd < 0  ||  nInd >= int( m_vpLoop.size()))
+      return false ;
+  // verifica esistenza array di chunks
+   if ( m_vExtInd.empty())
+      return false ;
+  // ricerca del chunk e del loop
+   nChunk = 0 ;
+   while ( ( nChunk + 1) < int( m_vExtInd.size())) {
+      if ( nInd < m_vExtInd[nChunk+1])
+         break ;
+      ++ nChunk ;
+   }
+   nLoop = nInd - m_vExtInd[nChunk] ;
+   return true ;
 }

 //----------------------------------------------------------------------------
 ICurve*
-SurfFlatRegion::GetMyLoop( int nLoop) const
+SurfFlatRegion::GetMyLoop( int nInd) const
 {
  // la regione deve essere validata
   if ( m_nStatus != OK)
      return nullptr ;
-  // se esterno
-   if ( nLoop == 0)
-      return m_pExtLoop ;
-  // altrimenti interno, verifico che l'indice sia nei limiti
-   if ( nLoop < 1  ||  nLoop > int( m_vpIntLoop.size()))
+  // verifico che l'indice sia nei limiti
+   if ( nInd < 0  ||  nInd >= int( m_vpLoop.size()))
      return nullptr ;
   else
-      return m_vpIntLoop[nLoop-1] ;
+      return m_vpLoop[nInd] ;
 }

 //----------------------------------------------------------------------------
 ICurve*
-SurfFlatRegion::GetLoop( int nLoop) const
+SurfFlatRegion::GetMyLoop( int nChunk, int nLoop) const
+{
+   return GetMyLoop( GetIndFromChunkLoop( nChunk, nLoop)) ;
+}
+
+//----------------------------------------------------------------------------
+ICurve*
+SurfFlatRegion::GetLoop( int nChunk, int nLoop) const
 {
  // recupero il loop nel riferimento intrinseco
-   const ICurve* pMyCrv = GetMyLoop( nLoop) ;
+   const ICurve* pMyCrv = GetMyLoop( nChunk, nLoop) ;
   if ( pMyCrv == nullptr)
      return nullptr ;
  // ne faccio una copia
@@ -702,29 +814,37 @@ const ISurfTriMesh*
 SurfFlatRegion::GetAuxSurf( void) const
 {
  // la superficie deve essere validata
-   if ( m_nStatus != OK  ||  m_pExtLoop == nullptr)
-      return false ;
+   if ( m_nStatus != OK  ||  m_vpLoop.empty())
+      return nullptr ;
  // se già calcolata, la restituisco
-   if ( m_pSTM != nullptr)
+   if ( m_pSTM  != nullptr)
      return m_pSTM ;
-  // la calcolo
-   // calcolo le polilinee che approssimano i loop
-   POLYLINEVECTOR vPL ;
-   vPL.resize( 1 + int( m_vpIntLoop.size())) ;
-   int i = - 1 ;
-   if ( ! m_pExtLoop->ApproxWithLines( LIN_TOL_SFR, ANG_TOL_STD_DEG, ICurve::APL_STD, vPL[++i]))
-      return nullptr ;
-   for ( auto& pIntLoop : m_vpIntLoop) {
-      if ( ! pIntLoop->ApproxWithLines( LIN_TOL_SFR, ANG_TOL_STD_DEG, ICurve::APL_STD, vPL[++i]))
-         return nullptr ;
-   }
-   // porto le polilinee in globale al riferimento intrinseco
-   for ( auto& PL : vPL)
-      PL.ToGlob( m_frF) ;
-   // creo, setto la superficie trimesh ed elimino punti ripetuti
+  // la creo
   PtrOwner<SurfTriMesh> pSTM( CreateBasicSurfTriMesh()) ;
-   if ( IsNull( pSTM)  ||  ! pSTM->CreateByRegion( vPL)  ||  ! pSTM->DoCompacting())
+   if ( IsNull( pSTM))
      return nullptr ;
+  // per ogni chunk (componente connesso)
+   for ( int i = 0 ; i < GetChunkCount() ; ++ i) {
+     // calcolo le polilinee che approssimano i loop
+      POLYLINEVECTOR vPL ;
+      vPL.resize( GetLoopCount( i)) ;
+      int j = 0 ;
+      ICurve* pLoop = GetMyLoop(  i, j) ;
+      while ( pLoop != nullptr) {
+         if ( ! pLoop->ApproxWithLines( LIN_TOL_SFR, ANG_TOL_STD_DEG, ICurve::APL_STD, vPL[j]))
+            return nullptr ;
+         pLoop = GetMyLoop( i, ++j) ;
+      }
+     // porto le polilinee in globale al riferimento intrinseco
+      for ( auto& PL : vPL)
+         PL.ToGlob( m_frF) ;
+     // creo, setto la superficie trimesh ed elimino punti ripetuti
+      PtrOwner<SurfTriMesh> pChSTM( CreateBasicSurfTriMesh()) ;
+      if ( IsNull( pChSTM)  ||  ! pChSTM->CreateByRegion( vPL)  ||  ! pChSTM->DoCompacting())
+         return nullptr ;
+     // inserisco questa trimesh in quella complessiva
+      pSTM->DoSewing( *Get( pChSTM)) ; 
+   }
   // la salvo
   m_pSTM = Release( pSTM) ;
   return m_pSTM ;
@@ -739,16 +859,47 @@ SurfFlatRegion::ResetAuxSurf( void) const
   m_pSTM = nullptr ;
 }

+//----------------------------------------------------------------------------
+SurfFlatRegion*
+SurfFlatRegion::CloneChunk( int nChunk) const
+{
+  // verifico esistenza del chunk (implicitamente anche lo stato)
+   int nLoop = GetLoopCount( nChunk) ;
+   if ( nLoop == 0)
+      return nullptr ;
+  // alloco la nuova regione
+   PtrOwner<SurfFlatRegion> pSfr( CreateBasicSurfFlatRegion()) ;
+   if ( IsNull( pSfr))
+      return nullptr ;
+  // copio il riferimento intrinseco
+   pSfr->m_frF = m_frF ;
+  // copio i loop del chunk indicato
+   for ( int i = 0 ; i < nLoop ; ++i) {
+      ICurve* pCrv = GetMyLoop( nChunk, i)->Clone() ;
+      if ( pCrv == nullptr)
+         return nullptr ;
+      pSfr->m_vpLoop.push_back( pCrv) ;
+   }
+  // sistemo indice dell'unico loop esterno
+   pSfr->m_vExtInd.push_back( 0) ;
+   pSfr->m_nStatus = OK ;
+   return Release( pSfr) ;
+}
+
 //----------------------------------------------------------------------------
 bool
 SurfFlatRegion::GetCurveClassification( const ICurve& Crv, CRVCVECTOR& ccClass) const
 {
  // verifico lo stato
-   if ( m_nStatus != OK  ||  m_pExtLoop == nullptr)
+   if ( m_nStatus != OK  ||  m_vpLoop.empty())
      return false ;
  // verifico la curva
   if ( &Crv == nullptr  ||  ! Crv.IsValid())
      return false ;
+  // dominio della curva
+   double dStart, dEnd ;
+   if ( ! Crv.GetDomain( dStart, dEnd))
+      return false ;
  // curva in locale nel riferimento intrinseco
   const ICurve* pCrvLoc = nullptr ;
   PtrOwner<ICurve> pCopyCrv ;
@@ -761,72 +912,77 @@ SurfFlatRegion::GetCurveClassification( const ICurve& Crv, CRVCVECTOR& ccClass)
      pCopyCrv->ToLoc( m_frF) ;
      pCrvLoc = Get( pCopyCrv) ;
   }
-  // intervalli delle diverse classi
-   Intervals inIn, inOut, inOnP, inOnM ;
-  // classifico la curva con tutti i loop presenti
-   int nLoop = 0 ;
-   const ICurve* pLoop = GetMyLoop( nLoop) ;
-   while ( pLoop != nullptr) {
-     // intersezione
-      IntersCurveCurve ccInt( *pCrvLoc, *pLoop) ;
-     // classificazione
-      CRVCVECTOR ccPart ;
-      if ( ! ccInt.GetCurveClassification( 0, ccPart))
-         return false ;
-      for ( auto& ccOne : ccPart) {
-         switch ( ccOne.nClass) {
-         case CRVC_IN :   inIn.Add( ccOne.dParS, ccOne.dParE) ; break ;
-         case CRVC_OUT :  inOut.Add( ccOne.dParS, ccOne.dParE) ; break ;
-         case CRVC_ON_P : inOnP.Add( ccOne.dParS, ccOne.dParE) ; break ;
-         case CRVC_ON_M : inOnM.Add( ccOne.dParS, ccOne.dParE) ; break ;
-         default : return false ;
+
+  // intervalli totali delle diverse classi
+   Intervals inTIn, inTOut, inTOnP, inTOnM ;
+   inTOut.Set( dStart, dEnd) ;   // inizializzo come tutta la linea per poi poter rimuovere parti
+  // ciclo sui chunk
+   for ( int nChunk = 0 ; nChunk < GetChunkCount() ; ++ nChunk) {
+     // intervalli di Chunk delle diverse classi
+      Intervals inCIn, inCOut, inCOnP, inCOnM ;
+      inCIn.Set( dStart, dEnd) ;   // inizializzo come tutta la linea per poi poter rimuovere parti
+     // classifico la curva con tutti i loop presenti nel chunk
+      for ( int nLoop = 0 ; nLoop < GetLoopCount( nChunk) ; ++ nLoop) {
+         const ICurve* pLoop = GetMyLoop( nChunk, nLoop) ;
+        // intersezione
+         IntersCurveCurve ccInt( *pCrvLoc, *pLoop) ;
+        // classificazione
+         CRVCVECTOR ccPart ;
+         if ( ! ccInt.GetCurveClassification( 0, ccPart))
+            return false ;
+         for ( auto& ccOne : ccPart) {
+            switch ( ccOne.nClass) {
+            case CRVC_IN :
+               // IN è Remove degli altri
+               break ;
+            case CRVC_OUT :
+               inCOut.Add( ccOne.dParS, ccOne.dParE) ;
+               inCIn.Remove( ccOne.dParS, ccOne.dParE) ;
+               break ;
+            case CRVC_ON_P :
+               inCOnP.Add( ccOne.dParS, ccOne.dParE) ;
+               inCIn.Remove( ccOne.dParS, ccOne.dParE) ;
+               break ;
+            case CRVC_ON_M :
+               inCOnM.Add( ccOne.dParS, ccOne.dParE) ;
+               inCIn.Remove( ccOne.dParS, ccOne.dParE) ;
+               break ;
+            default : return false ;
+            }
         }
      }
-     // passo al loop successivo
-      ++ nLoop ;
-      pLoop = GetMyLoop( nLoop) ;
-   }
-  // sistemo gli intervalli di classificazione
-   // Out prevale su tutto
-   double dMin, dMax ;
-   bool bFound = inOut.GetFirst( dMin, dMax) ;
-   while ( bFound) {
-      inIn.Remove( dMin, dMax) ;
-      inOnP.Remove( dMin, dMax) ;
-      inOnM.Remove( dMin, dMax) ;
-      bFound = inOut.GetNext( dMin, dMax) ;
-   }
-   // OnP e OnM prevalgono su In e sono sicuramente disgiunti tra loro
-   bFound = inOnP.GetFirst( dMin, dMax) ;
-   while ( bFound) {
-      inIn.Remove( dMin, dMax) ;
-      bFound = inOnP.GetNext( dMin, dMax) ;
-   }
-   bFound = inOnM.GetFirst( dMin, dMax) ;
-   while ( bFound) {
-      inIn.Remove( dMin, dMax) ;
-      bFound = inOnM.GetNext( dMin, dMax) ;
+     // aggiorno gli intervalli di classificazione totali
+      // In, OnP e OnM vengono aggiornati per somma
+      inTIn.Union( inCIn) ;
+      inTOnP.Union( inCOnP) ;
+      inTOnM.Union( inCOnM) ;
+      // Out viene ricavato per differenza degli altri
+      inTOut.Difference( inCIn) ;
+      inTOut.Difference( inCOnP) ;
+      inTOut.Difference( inCOnM) ;
   }
+
  // ricostruisco la classificazione completa e la ordino
-   bFound = inIn.GetFirst( dMin, dMax) ;
+   double dMin, dMax ;
+   bool bFound = inTIn.GetFirst( dMin, dMax) ;
   while ( bFound) {
      ccClass.emplace_back( dMin, dMax, CRVC_IN) ;
-      bFound = inIn.GetNext( dMin, dMax) ;
+      bFound = inTIn.GetNext( dMin, dMax) ;
   }
-   bFound = inOut.GetFirst( dMin, dMax) ;
+   bFound = inTOut.GetFirst( dMin, dMax) ;
   while ( bFound) {
      ccClass.emplace_back( dMin, dMax, CRVC_OUT) ;
-      bFound = inOut.GetNext( dMin, dMax) ;
+      bFound = inTOut.GetNext( dMin, dMax) ;
   }
-   bFound = inOnP.GetFirst( dMin, dMax) ;
+   bFound = inTOnP.GetFirst( dMin, dMax) ;
   while ( bFound) {
      ccClass.emplace_back( dMin, dMax, CRVC_ON_P) ;
-      bFound = inOnP.GetNext( dMin, dMax) ;
+      bFound = inTOnP.GetNext( dMin, dMax) ;
   }
-   bFound = inOnM.GetFirst( dMin, dMax) ;
+   bFound = inTOnM.GetFirst( dMin, dMax) ;
   while ( bFound) {
      ccClass.emplace_back( dMin, dMax, CRVC_ON_M) ;
-      bFound = inOnM.GetNext( dMin, dMax) ;
+      bFound = inTOnM.GetNext( dMin, dMax) ;
   }
   sort( ccClass.begin(), ccClass.end(), 
         []( const CrvClass& a, const CrvClass& b) { return a.dParS < b.dParS ; }) ;