diff --git a/VolZmap.cpp b/VolZmap.cpp
index 52db129..53538c9 100644
--- a/VolZmap.cpp
+++ b/VolZmap.cpp
@@ -566,10 +566,16 @@ VolZmap::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
 int
 VolZmap::GetPartCount( void) const
 {
+  // Se mono-dexel la connessione è incalcolabile.
+   if ( m_nMapNum == 1)
+      return - 1 ;
+  // Se il numero delle componenti è indefinito 
+  // lo ricalcolo e restituisco il risultato.
    if ( m_nConnectedCompoCount == - 1) {
       const_cast<VolZmap*>(this)->CheckMapConnection() ;
       return m_nConnectedCompoCount ;
    }
+  // Altrimenti restituisco direttamente il numero di componenti.
    else 
       return m_nConnectedCompoCount ;
 }
@@ -893,138 +899,157 @@ VolZmap::ExpandFromZInterval( IntContaier& IntCont)
 VolZmap*
 VolZmap::ClonePart( int nPart) const
 {
-
+  // Se è usata una sola griglia, i risultati non 
+  // sarebbero attendibili; restituisco nullptr.
+   if ( m_nMapNum == 1)
    return nullptr ;
-
-#if 0
-  // Se il vettore non è vuoto lo pulisco
-   if ( vMap.size() > 0)
-      vMap.resize( 0) ;
-  // Se il numero di componenti è 
-  // indefinito, lo ricalcolo.
+  // Se è richiesta una componente fuori intervallo restituisco nullptr.
+   if ( nPart < 0 || nPart >= m_nConnectedCompoCount)
+      return nullptr ;
+  // Se il numero di componenti è indefinito, lo ricalcolo.
    if ( m_nConnectedCompoCount == - 1)
-      IsMapConnected() ;
+      const_cast<VolZmap*>(this)->CheckMapConnection() ;
+  // Se non vi sono componenti restituisco nullptr. 
+   if ( m_nConnectedCompoCount == 0)
+      return nullptr ;
 
-  // Se il numero di componenti è 
-  // superiore a 1, creo più Zmap.
-   if ( m_nConnectedCompoCount > 1) 
-      vMap.reserve( m_nConnectedCompoCount - 1) ;
-   else 
-      return true ;
+   PtrOwner<VolZmap> pVolume( CreateBasicVolZmap()) ;
+   if ( IsNull( pVolume))
+      return nullptr ;
+  // Setto per il nuovo Zmap le seguenti variabili 
+   pVolume->m_nConnectedCompoCount = 1 ;
+   pVolume->m_dStep = m_dStep ;
+   pVolume->m_nMapNum = m_nMapNum ;
 
-  // Ciclo sulle componenti connesse con indice superiore a uno
-   for ( int nC = 2 ; nC <= m_nConnectedCompoCount ; ++ nC) {
-   
-      VolZmap TempMap ;
-      TempMap.m_nConnectedCompoCount = 1 ;
-      TempMap.m_dStep = m_dStep ;
-      TempMap.m_nMapNum = m_nMapNum ;
-
-      int nMinIndI, nMaxIndI, nMinIndJ, nMaxIndJ ;
-
-      double dNewOx, dNewOy, dNewOz ;
-     // Ciclo sulle mappe
-      for ( int nMap = 0 ; nMap < m_nMapNum ; ++ nMap) {
+   int nMinIndI[3] ;
+   int nMaxIndI[3] ;
+   int nMinIndJ[3] ;
+   int nMaxIndJ[3] ;
+  // Coordinate dell'origine del sistema di riferimento 
+  // del nuovo Zmap
+   double dNewOx, dNewOy, dNewOz ;
+   // Ciclo sulle mappe
+   for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
       
-         nMinIndI = m_nNx[nMap] ;
-         nMinIndJ = m_nNy[nMap] ; 
-         nMaxIndI = 0 ;
-         nMaxIndJ = 0 ;
-        // Della componente connessa in questione calcolo  
-        // indici i e j massimi e minimi. 
-         for ( int nIndI = 0 ; nIndI < m_nNx[nMap] ; ++ nIndI) {
-            for ( int nIndJ = 0 ; nIndJ < m_nNy[nMap] ; ++ nIndJ) {
+      nMinIndI[nMap] = m_nNx[nMap] ;
+      nMinIndJ[nMap] = m_nNy[nMap] ; 
+      nMaxIndI[nMap] = 0 ;
+      nMaxIndJ[nMap] = 0 ;
+      // Della componente connessa in questione calcolo  
+      // indici i e j massimi e minimi. 
+      for ( int nIndI = 0 ; nIndI < int( m_nNx[nMap]) ; ++ nIndI) {
+         for ( int nIndJ = 0 ; nIndJ < int( m_nNy[nMap]) ; ++ nIndJ) {
             
-               int nDex = nIndJ * m_nNx[0] + nIndI ;
+            int nDex = nIndJ * m_nNx[nMap] + nIndI ;
 
-               for ( int nInt = 0 ; nInt < m_Values[nMap][nDex].size() ; ++ nInt) {
+            for ( int nInt = 0 ; nInt < int( m_Values[nMap][nDex].size()) ; ++ nInt) {
                
-                  if ( m_Values[nMap][nDex][nInt].nCompo == nC) {
+               if ( m_Values[nMap][nDex][nInt].nCompo == nPart + 1) {
                   
-                     if ( nIndI < nMinIndI)
-                        nMinIndI = nIndI ;
-                     if ( nIndJ < nMinIndJ)
-                        nMinIndJ = nIndJ ;
-                     if ( nIndI > nMaxIndI)
-                        nMaxIndI = nIndI ;
-                     if ( nIndJ > nMaxIndJ)
-                        nMaxIndJ = nIndJ ;
-                  }
+                  if ( nIndI < nMinIndI[nMap])
+                     nMinIndI[nMap] = nIndI ;
+                  if ( nIndJ < nMinIndJ[nMap])
+                     nMinIndJ[nMap] = nIndJ ;
+                  if ( nIndI > nMaxIndI[nMap])
+                     nMaxIndI[nMap] = nIndI ;
+                  if ( nIndJ > nMaxIndJ[nMap])
+                     nMaxIndJ[nMap] = nIndJ ;
                }
             }
          }
-
-         TempMap.m_nNx[nMap] = nMaxIndI - nMinIndI + 1 ;
-         TempMap.m_nNy[nMap] = nMaxIndJ - nMinIndJ + 1 ;
-         TempMap.m_nDim[nMap] = TempMap.m_nNx[nMap] * TempMap.m_nNy[nMap] ;
-         TempMap.m_Values[nMap].resize( TempMap.m_nDim[nMap]) ;
-         TempMap.m_dMinZ[nMap] = m_dMaxZ[nMap] ;
-         TempMap.m_dMaxZ[nMap] = m_dMinZ[nMap] ;
-
-        // Coordinate x,y dell'origine del sistema di riferimento
-         if ( nMap == 0) {
-            dNewOx = ( nMinIndI - 0.5) * m_dStep ;
-            dNewOy = ( nMinIndJ - 0.5) * m_dStep ;
-            dNewOz = TempMap.m_dMinZ[nMap] ;
-         }  
-         if ( nMap == 1) {
-         
-            dNewOz = ( nMinIndJ - 0.5) * m_dStep ;
-         }
       }
-     // Copio gli intervalli nella griglia del nuovo oggetto
-     // e li cancello da quella del vecchio.
-      for ( int nMap = 0 ; nMap < m_nMapNum ; ++ nMap) {
 
-         for ( int nIndJ = 0 ; nIndJ < TempMap.m_nNy[nMap] ; ++ nIndJ) {
-            for ( int nIndI = 0 ; nIndI < TempMap.m_nNx[nMap] ; ++ nIndI) {
+      pVolume->m_nNx[nMap] = nMaxIndI[nMap] - nMinIndI[nMap] + 1 ;
+      pVolume->m_nNy[nMap] = nMaxIndJ[nMap] - nMinIndJ[nMap] + 1 ;
+      pVolume->m_nDim[nMap] = pVolume->m_nNx[nMap] * pVolume->m_nNy[nMap] ;
+      pVolume->m_Values[nMap].resize( pVolume->m_nDim[nMap]) ;
+      pVolume->m_dMinZ[nMap] = m_dMaxZ[nMap] ;
+      pVolume->m_dMaxZ[nMap] = m_dMinZ[nMap] ;
+   }
+   
+  // Copio gli intervalli nella griglia del nuovo oggetto
+   for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
 
-               int nNewDex = nIndJ * TempMap.m_nNx[nMap] + nIndI ;
-               int nOldDex = ( nIndJ + nMinIndJ) * m_nNx[nMap] + nIndI + nMinIndI ;
+      for ( int nIndJ = 0 ; nIndJ < int( pVolume->m_nNy[nMap]) ; ++ nIndJ) {
+         for ( int nIndI = 0 ; nIndI < int( pVolume->m_nNx[nMap]) ; ++ nIndI) {
+
+            int nNewDex = nIndJ * pVolume->m_nNx[nMap] + nIndI ;
+            int nOldDex = ( nIndJ + nMinIndJ[nMap]) * m_nNx[nMap] + nIndI + nMinIndI[nMap] ;
                
-               for ( int nInt = 0 ; nInt < m_Values[nMap][nOldDex].size() ; ++ nInt) {
+            for ( int nInt = 0 ; nInt < int( m_Values[nMap][nOldDex].size()) ; ++ nInt) {
                
-                  if ( m_Values[nMap][nOldDex][nInt].nCompo == nC) {
+               if ( m_Values[nMap][nOldDex][nInt].nCompo == nPart + 1) {
 
-                     TempMap.m_Values[nMap][nNewDex].emplace_back( m_Values[nMap][nOldDex][nInt]) ;
-                     m_Values[nMap][nOldDex].erase( m_Values[nMap][nOldDex].begin() + nInt) ;
+                  pVolume->m_Values[nMap][nNewDex].emplace_back( m_Values[nMap][nOldDex][nInt]) ;
+                  pVolume->m_Values[nMap][nNewDex][pVolume->m_Values[nMap][nNewDex].size() - 1].nCompo = 1 ;
                      
-                     if ( m_Values[nMap][nOldDex][nInt].dMin < TempMap.m_dMinZ[nMap])
-                        TempMap.m_dMinZ[nMap] = m_Values[nMap][nOldDex][nInt].dMin ;
-                     if ( m_Values[nMap][nOldDex][nInt].dMax > TempMap.m_dMaxZ[nMap])
-                        TempMap.m_dMaxZ[nMap] = m_Values[nMap][nOldDex][nInt].dMax ;
-                  }
+                  if ( m_Values[nMap][nOldDex][nInt].dMin < pVolume->m_dMinZ[nMap])
+                     pVolume->m_dMinZ[nMap] = m_Values[nMap][nOldDex][nInt].dMin ;
+                  if ( m_Values[nMap][nOldDex][nInt].dMax > pVolume->m_dMaxZ[nMap])
+                     pVolume->m_dMaxZ[nMap] = m_Values[nMap][nOldDex][nInt].dMax ;
                }
             }
          }
       }
-
-     // Definisco il numero di blocchi lungo x e y
-      TempMap.m_nFracLin[0] = max( 1u,
-                           TempMap.m_nNx[0] / TempMap.m_nDexNumPBlock +
-                           ( TempMap.m_nNx[0] % TempMap.m_nDexNumPBlock >= TempMap.m_nDexNumPBlock / 2 ? 1 : 0)) ;
-      TempMap.m_nFracLin[1] = max( 1u,
-                           TempMap.m_nNy[0] / TempMap.m_nDexNumPBlock +
-                           ( TempMap.m_nNy[0] % TempMap.m_nDexNumPBlock >= TempMap.m_nDexNumPBlock / 2 ? 1 : 0)) ;
-
-     // Se vi sono tre griglie definisco il numero di blocchi lungo z
-      if ( TempMap.m_nMapNum > 1)
-         TempMap.m_nFracLin[2] = max( 1u,
-                              TempMap.m_nNy[1] / TempMap.m_nDexNumPBlock +
-                              ( TempMap.m_nNy[1] % TempMap.m_nDexNumPBlock >= TempMap.m_nDexNumPBlock / 2 ? 1 : 0)) ;
-
-     // Sistema di riferimento 
-      Point3d ptNewO( dNewOx, dNewOy, dNewOz) ;
-      TempMap.m_MapFrame[0].Set( ptNewO, X_AX, Y_AX, Z_AX) ;
-   
-      if ( TempMap.m_nMapNum > 1) {
-   
-         TempMap.m_MapFrame[1].Set( ptNewO, Y_AX, Z_AX, X_AX) ;
-         TempMap.m_MapFrame[2].Set( ptNewO, Z_AX, X_AX, Y_AX) ;
+   }
+  // Coordinate x,y dell'origine del sistema di riferimento
+   dNewOx = nMinIndI[0] * m_dStep ;
+   dNewOy = nMinIndJ[0] * m_dStep ;
+   dNewOz = nMinIndJ[1] * m_dStep ;
+   //dNewOz = pVolume->m_dMinZ[0] ;
+ 
+  // Porto i dexel nel nuovo sistema di riferimento
+   for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
+      for ( int nDex = 0 ; nDex < int( pVolume->m_nDim[nMap]) ; ++ nDex) {
+         for ( int nInt = 0 ; nInt < int( pVolume->m_Values[nMap][nDex].size()) ; ++ nInt) {
+         
+            switch ( nMap) {
+            case 0 :       
+               pVolume->m_Values[nMap][nDex][nInt].dMin -= dNewOz ;
+               pVolume->m_Values[nMap][nDex][nInt].dMax -= dNewOz ;
+               break ;
+            case 1 :
+               pVolume->m_Values[nMap][nDex][nInt].dMin -= dNewOx ;
+               pVolume->m_Values[nMap][nDex][nInt].dMax -= dNewOx ;
+               break ;
+            case 2 :
+               pVolume->m_Values[nMap][nDex][nInt].dMin -= dNewOy ;
+               pVolume->m_Values[nMap][nDex][nInt].dMax -= dNewOy ;
+                  break ;
+            }
+         }
       }
-  
-         vMap.emplace_back( TempMap) ;
-   } 
-   return true ;
-#endif
+   }
+
+  // Definisco il numero di blocchi lungo x,y e z
+   pVolume->m_nFracLin[0] = max( 1u,
+                        pVolume->m_nNx[0] / pVolume->m_nDexNumPBlock +
+                        ( pVolume->m_nNx[0] % pVolume->m_nDexNumPBlock >= pVolume->m_nDexNumPBlock / 2 ? 1 : 0)) ;
+   pVolume->m_nFracLin[1] = max( 1u,
+                        pVolume->m_nNy[0] / pVolume->m_nDexNumPBlock +
+                        ( pVolume->m_nNy[0] % pVolume->m_nDexNumPBlock >= pVolume->m_nDexNumPBlock / 2 ? 1 : 0)) ;
+   pVolume->m_nFracLin[2] = max( 1u,
+                        pVolume->m_nNy[1] / pVolume->m_nDexNumPBlock +
+                        ( pVolume->m_nNy[1] % pVolume->m_nDexNumPBlock >= pVolume->m_nDexNumPBlock / 2 ? 1 : 0)) ;
+
+  // Dimensiono il vettore dei blocchi 
+   pVolume->m_nNumBlock = pVolume->m_nFracLin[0] * pVolume->m_nFracLin[1] * pVolume->m_nFracLin[2] ;
+   pVolume->m_BlockToUpdate.resize( pVolume->m_nNumBlock) ;
+  // Setto tutti i blocchi come da ricalcolare (per quanto riguarda la grafica) 
+   for ( unsigned int nCount = 0 ; nCount < pVolume->m_nNumBlock ; ++ nCount)
+      pVolume->m_BlockToUpdate[nCount] = true ;
+
+  // Dimensiono raccolta triangoli di feature tra blocchi
+   pVolume->m_InterBlockTria.resize( pVolume->m_nNumBlock) ;
+
+  // Sistemi di riferimento delle griglie del nuovo solido 
+   Point3d ptNewO( dNewOx, dNewOy, dNewOz) ;
+   pVolume->m_MapFrame[0].Set( ptNewO, X_AX, Y_AX, Z_AX) ; 
+   pVolume->m_MapFrame[1].Set( ptNewO, Y_AX, Z_AX, X_AX) ;
+   pVolume->m_MapFrame[2].Set( ptNewO, Z_AX, X_AX, Y_AX) ;
+
+  // Setto lo stato del nuovo Solido
+   pVolume->m_nStatus = m_nStatus ;
+  // Restituisco il nuovo solido
+   return Release( pVolume) ;
 }