diff --git a/CDeBoxClosedSurfTm.cpp b/CDeBoxClosedSurfTm.cpp
index 6b29905..1c9df9e 100644
--- a/CDeBoxClosedSurfTm.cpp
+++ b/CDeBoxClosedSurfTm.cpp
@@ -19,10 +19,23 @@
 
 using namespace std ;
 
+//----------------------------------------------------------------------------
+// Il sistema di riferimento è allineato con il box e ha origine in un suo vertice.
+// La distanza di sicurezza ha effetto solo se maggiore di EPS_SMALL.
+// Il sistema di riferimento del box è riferito a quello della superficie.
+// La funzione restituisce :
+// - true in caso di collisione o inconsistenza dei parametri di input
+// - false in caso di assenza di collisione.
 //----------------------------------------------------------------------------
 bool
-CDeBoxClosedSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, const ISurfTriMesh& Stm)
+CDeBoxClosedSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, const ISurfTriMesh& Stm, double dSafeDist)
 {
+  // Se il box non è ben definito non ha senso proseguire
+   if ( vtDiag.IsSmall())
+      return true ;
+  // Se superficie non valida o aperta, non ha senso proseguire
+   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
+      return true ;
   // Recupero BBox del poliedro
    BBox3d b3Poly = Stm.GetAllTriaBox() ;
   // Calcolo il BBox del parallelepipedo
@@ -39,13 +52,10 @@ CDeBoxClosedSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDi
    for ( int nT : vT) {
       Triangle3d Tria ;
       if ( Stm.GetTriangle( nT, Tria)) {
-         if ( CDeBoxTria( frBox, vtDiag, dSafeDist, Tria))
+         if ( CDeBoxTria( frBox, vtDiag, Tria, dSafeDist))
             return true ;
       }
    }
-  // Se superficie aperta, non c'è collisione
-   if ( ! Stm.IsClosed())
-      return false ;
   // Se il BBox del parallelepipedo non è interno a quello del poliedro e viceversa, non c'è collisione
    if ( ! b3Poly.Encloses( b3Box)  &&  ! b3Box.Encloses( b3Poly))
       return false ;
diff --git a/CDeBoxTria.cpp b/CDeBoxTria.cpp
index 34ec61d..ad1ac33 100644
--- a/CDeBoxTria.cpp
+++ b/CDeBoxTria.cpp
@@ -171,7 +171,7 @@ CDeSimpleBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, const Triangle3d
 
 //----------------------------------------------------------------------------
 bool
-CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, const Triangle3d& trTria)
+CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, const Triangle3d& trTria, double dSafeDist)
 {
   // Porto il triangolo nel riferimento del box
    Triangle3d trTriaL = trTria ;
diff --git a/CDeBoxTria.h b/CDeBoxTria.h
index 560b3d6..ad39ada 100644
--- a/CDeBoxTria.h
+++ b/CDeBoxTria.h
@@ -17,4 +17,4 @@
 
 //----------------------------------------------------------------------------
 bool CDeSimpleBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, const Triangle3d& trTria) ;
-bool CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, const Triangle3d& trTria) ;
+bool CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, const Triangle3d& trTria, double dSafeDist) ;
diff --git a/CDeCapsTria.cpp b/CDeCapsTria.cpp
index 4212adc..85addb5 100644
--- a/CDeCapsTria.cpp
+++ b/CDeCapsTria.cpp
@@ -97,7 +97,7 @@ CDeSimpleCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Tr
 
 //----------------------------------------------------------------------------
 bool
-CDeCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, double dSafeDist, const Triangle3d& trTria)
+CDeCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Triangle3d& trTria, double dSafeDist)
 {
    return CDeSimpleCapsTria( ptP1, ptP2, dR + max( 0., dSafeDist), trTria) ;
 }
diff --git a/CDeCapsTria.h b/CDeCapsTria.h
index ef8c51d..ada6698 100644
--- a/CDeCapsTria.h
+++ b/CDeCapsTria.h
@@ -16,4 +16,4 @@
 
 //----------------------------------------------------------------------------
 bool CDeSimpleCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Triangle3d& trTria) ;
-bool CDeCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, double dSafeDist, const Triangle3d& trTria) ;
+bool CDeCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Triangle3d& trTria, double dSafeDist) ;
diff --git a/CDeClosedSurfTmClosedSurfTm.cpp b/CDeClosedSurfTmClosedSurfTm.cpp
index 8d1cfd1..b1d250c 100644
--- a/CDeClosedSurfTmClosedSurfTm.cpp
+++ b/CDeClosedSurfTmClosedSurfTm.cpp
@@ -22,24 +22,25 @@
 using namespace std ;
 
 //----------------------------------------------------------------------------
-// La funzione restituisce true in caso di collisone, false in caso di assenza
-// di collisione o inconsistenza dei parametri di input.
 // Le due superfici devono essere espresse nel medesimo sistema di riferimento.
 // La distanza di sicurezza ha effetto solo se maggiore di EPS_SMALL.
 // Se necessario cerco la collisione con un offset della superficie B costituito
-// da sfere centrate nei vertici, cilindri con i segmenti per asse e il triangolo
-// originale traslato di una costante pari alla distanza di sicurezza lungo la
-// sua normale.
+// da sfere centrate nei vertici, cilindri con gli spigoli per asse e il triangolo
+// originale traslato della distanza di sicurezza lungo la sua normale.
+// La funzione restituisce :
+// - true in caso di collisione o inconsistenza dei parametri di input
+// - false in caso di assenza di collisione.
+//----------------------------------------------------------------------------
 bool
 CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist)
 {
   // Recupero le superfici base
    const SurfTriMesh* pSrfA = GetBasicSurfTriMesh( &SurfA) ;
    const SurfTriMesh* pSrfB = GetBasicSurfTriMesh( &SurfB) ;
-  // Se le superfici non sono valide o non sono chiuse, non ha senso proseguire.
+  // Se le superfici non sono valide o non sono chiuse, non ha senso proseguire
    if ( pSrfA == nullptr ||  ! pSrfA->IsValid()  ||  ! pSrfA->IsClosed()  ||
         pSrfB == nullptr ||  ! pSrfB->IsValid()  ||  ! pSrfB->IsClosed())
-      return false ;
+      return true ;
   // Se i box delle superfici non si intersecano, ho finito.
    BBox3d b3BoxA, b3BoxB ;
    pSrfA->GetLocalBBox( b3BoxA) ;
diff --git a/CDeConeFrustumClosedSurfTm.cpp b/CDeConeFrustumClosedSurfTm.cpp
index f425e18..26e38a6 100644
--- a/CDeConeFrustumClosedSurfTm.cpp
+++ b/CDeConeFrustumClosedSurfTm.cpp
@@ -21,15 +21,22 @@ using namespace std ;
 
 //----------------------------------------------------------------------------
 // Il sistema di riferimento deve avere l'asse di simmetria del cono come asse Z e origine nel centro della base.
-// La distanza di sicurezza ha effetto solo se maggiore di epsilon, altrimenti è ignorata ed è ininfluente.
-// Il sistema di riferimento del cono deve essere immerso in quello della superficie.
+// La distanza di sicurezza ha effetto solo se maggiore di EPS_SMALL, altrimenti è ignorata ed è ininfluente.
+// Il sistema di riferimento del cono è riferito a quello della superficie.
+// La funzione restituisce :
+// - true in caso di collisione o inconsistenza dei parametri di input
+// - false in caso di assenza di collisione.
+//----------------------------------------------------------------------------
 bool
 CDeConeFrustumClosedSurfTm( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
-                            double dSafeDist, const ISurfTriMesh& Stm)
+                            const ISurfTriMesh& Stm, double dSafeDist)
 {
   // Se il tronco di cono non è ben definito non ha senso proseguire
    if ( max( dBaseRad, dTopRad) < EPS_SMALL  ||  dHeight < EPS_SMALL)
-      return false ;
+      return true ;
+  // Se superficie non valida o aperta, non ha senso proseguire
+   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
+      return true ;
   // Recupero BBox della trimesh
    BBox3d b3Surf = Stm.GetAllTriaBox() ;
   // Calcolo il BBox del tronco di cono
@@ -49,13 +56,10 @@ CDeConeFrustumClosedSurfTm( const Frame3d& frCone, double dBaseRad, double dTopR
    for ( int nT : vT) {
       Triangle3d trTria ;
       if ( Stm.GetTriangle( nT, trTria)) {
-         if ( CDeConeFrustumTria( frCone, dBaseRad, dTopRad, dHeight, dSafeDist, trTria))
+         if ( CDeConeFrustumTria( frCone, dBaseRad, dTopRad, dHeight, trTria, dSafeDist))
             return true ;
       }
    }
-  // Se superficie aperta, non c'è collisione
-   if ( ! Stm.IsClosed())
-      return false ;
   // Se il BBox del tronco di cono non è interno a quello del poliedro e viceversa, non c'è collisione
    if ( ! b3Surf.Encloses( b3Cone)  &&  ! b3Cone.Encloses( b3Surf))
       return false ;
diff --git a/CDeConeFrustumTria.cpp b/CDeConeFrustumTria.cpp
index 7576b0b..c3faf19 100644
--- a/CDeConeFrustumTria.cpp
+++ b/CDeConeFrustumTria.cpp
@@ -134,7 +134,7 @@ CDeSimpleConeFrustumTria( const Frame3d& frCone, double dMinRad, double dMaxRad,
 // La distanza di sicurezza ha effetto solo se maggiore di epsilon, altrimenti è ignorata ed è ininfluente.
 bool
 CDeConeFrustumTria( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
-                    double dSafeDist, const Triangle3d& trTria)
+                    const Triangle3d& trTria, double dSafeDist)
 {
   // Se il tronco di cono o il triangolo non sono ben definiti non procedo
    if ( max( dBaseRad, dTopRad) < EPS_SMALL  ||  dHeight < EPS_SMALL  ||  ! trTria.IsValid())
@@ -142,7 +142,7 @@ CDeConeFrustumTria( const Frame3d& frCone, double dBaseRad, double dTopRad, doub
 
   // Se è un cilindro chiamo la routine apposita.
    if ( abs( dBaseRad - dTopRad) < EPS_SMALL)
-      return CDeCylTria( frCone, max( dBaseRad, dTopRad), dHeight, dSafeDist, trTria) ;
+      return CDeCylTria( frCone, max( dBaseRad, dTopRad), dHeight, trTria, dSafeDist) ;
 
   // Se il raggio di base è maggiore del raggio top cambio il sistema di riferimento.
    double dMinRad = dBaseRad ;
@@ -156,11 +156,11 @@ CDeConeFrustumTria( const Frame3d& frCone, double dBaseRad, double dTopRad, doub
 
   // Se è un cono, chiamo la routine apposita
    if ( dMinRad < EPS_SMALL)
-      return CDeConeTria( frMyCone, dMaxRad, dHeight, dSafeDist, trTria) ;
+      return CDeConeTria( frMyCone, dMaxRad, dHeight, trTria, dSafeDist) ;
 
   // Se distanza di sicurezza nulla
    if ( dSafeDist < EPS_SMALL)
-      return CDeSimpleConeFrustumTria( frMyCone, dBaseRad, dTopRad, dHeight, trTria ) ;
+      return CDeSimpleConeFrustumTria( frMyCone, dBaseRad, dTopRad, dHeight, trTria) ;
 
   // Verifica preliminare con tronco di cono esteso
    double dDiffRad = dMaxRad - dMinRad ;
diff --git a/CDeConeFrustumTria.h b/CDeConeFrustumTria.h
index d714e86..80384c4 100644
--- a/CDeConeFrustumTria.h
+++ b/CDeConeFrustumTria.h
@@ -20,6 +20,5 @@
 // Il sistema di riferimento deve avere l'origine nel centro della base minore e l'asse
 // di simmetria del cono, rivolto verso la direzione di apertura, come asse Z.
 bool CDeSimpleConeFrustumTria( const Frame3d& frCone, double dMinRad, double dMaxRad, double dHeight, const Triangle3d& trTria) ;
-// Il sistema di riferimento ha l'asse Z coincidente con l'asse di simmetria del cono e l'origine nel centro della base.
 bool CDeConeFrustumTria( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
-                         double dSafeDist, const Triangle3d& trTria) ;
+                         const Triangle3d& trTria, double dSafeDist) ;
diff --git a/CDeConeTria.cpp b/CDeConeTria.cpp
index d4fa5be..5cb5437 100644
--- a/CDeConeTria.cpp
+++ b/CDeConeTria.cpp
@@ -111,7 +111,7 @@ CDeSimpleConeTria( const Frame3d& frCone, double dRad, double dHeight, const Tri
 
 //----------------------------------------------------------------------------
 bool
-CDeConeTria( const Frame3d& frCone, double dRad, double dHeight, double dSafeDist, const Triangle3d& trTria)
+CDeConeTria( const Frame3d& frCone, double dRad, double dHeight, const Triangle3d& trTria, double dSafeDist)
 {
   // Verifico validità del cono
    if ( dRad < EPS_SMALL  ||  dHeight < EPS_SMALL)
diff --git a/CDeConeTria.h b/CDeConeTria.h
index 52fad35..70262f0 100644
--- a/CDeConeTria.h
+++ b/CDeConeTria.h
@@ -19,4 +19,4 @@
 //----------------------------------------------------------------------------
 // Il sistema di riferimento ha asse Z coincidente con l'asse del cono e origine nel vertice del cono (punto più basso).
 bool CDeSimpleConeTria( const Frame3d& frCone, double dRad, double dHeight, const Triangle3d& trTria) ;
-bool CDeConeTria( const Frame3d& frCone, double dRad, double dHeight, double dSafeDist, const Triangle3d& trTria) ;
+bool CDeConeTria( const Frame3d& frCone, double dRad, double dHeight, const Triangle3d& trTria, double dSafeDist) ;
diff --git a/CDeConvexTorusClosedSurfTm.cpp b/CDeConvexTorusClosedSurfTm.cpp
index 280cd13..84d7f14 100644
--- a/CDeConvexTorusClosedSurfTm.cpp
+++ b/CDeConvexTorusClosedSurfTm.cpp
@@ -18,17 +18,23 @@
 using namespace std ;
 
 //----------------------------------------------------------------------------
-// Il toro convesso è il disco limitato dalla sola parte esterna del toro.
+// Il toro convesso è il solido a disco limitato dalla sola parte esterna del toro.
 // Raggio principale R1, raggio secondario R2.
 // Il toro è posto nel piano XY del suo riferimento, centrato sull'origine.
-// La funzione restituisce true in caso di collisione.
+// La funzione restituisce :
+// - true in caso di collisione o inconsistenza dei parametri di input
+// - false in caso di assenza di collisione.
+//----------------------------------------------------------------------------
 bool
 CDeConvexTorusClosedSurfTm( const Frame3d& frTorus, double dRad1, double dRad2,
-                            double dSafeDist, const ISurfTriMesh& Stm)
+                            const ISurfTriMesh& Stm, double dSafeDist)
 {
-  // I raggi devono essere non nulli e la superficie ben definita.
-   if ( dRad1 < EPS_SMALL  ||  dRad2 < EPS_SMALL  ||  ! Stm.IsValid())
-      return false ;
+  // I raggi devono essere non nulli
+   if ( dRad1 < EPS_SMALL  ||  dRad2 < EPS_SMALL)
+      return true ;
+  // Se superficie non valida o aperta, non ha senso proseguire
+   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
+      return true ;
   // Box della superficie
    BBox3d b3Surf = Stm.GetAllTriaBox() ;
   // Box del toro (sempre completo)
@@ -47,13 +53,10 @@ CDeConvexTorusClosedSurfTm( const Frame3d& frTorus, double dRad1, double dRad2,
    for ( int nT : vT) {
       Triangle3d trTria ;
       if ( Stm.GetTriangle( nT, trTria)) {
-         if ( CDeConvexTorusTria( frTorus, dRad1, dRad2, CT_TOT, dSafeDist, trTria))
+         if ( CDeConvexTorusTria( frTorus, dRad1, dRad2, CT_TOT, trTria, dSafeDist))
             return true ;
       }
    }
-  // Se superficie aperta, non c'è collisione
-   if ( ! Stm.IsClosed())
-      return false ;
   // Se il BBox del toro non è interno a quello del poliedro e viceversa, non c'è collisione
    if ( ! b3Surf.Encloses( b3Torus)  &&  ! b3Torus.Encloses( b3Surf))
       return false ;
diff --git a/CDeConvexTorusTria.cpp b/CDeConvexTorusTria.cpp
index 48a6c37..b6fc56a 100644
--- a/CDeConvexTorusTria.cpp
+++ b/CDeConvexTorusTria.cpp
@@ -61,7 +61,7 @@ CDeSimpleConvexTorusTria( const Frame3d& frTorus, double dRad1, double dRad2, in
    bool bContinue = plyApprox.GetFirstPoint( ptSt)  &&  plyApprox.GetNextPoint( ptEn) ;
    while ( bContinue  &&  ! bCollision) {
       frConus.Set( Point3d( 0., 0., ptSt.z), Frame3d::TOP) ;
-      bCollision = CDeConeFrustumTria( frConus, ptSt.x, ptEn.x, ptEn.z - ptSt.z, 0., trMyTria) ;
+      bCollision = CDeSimpleConeFrustumTria( frConus, ptSt.x, ptEn.x, ptEn.z - ptSt.z, trMyTria) ;
       ptSt = ptEn ;
       bContinue = plyApprox.GetNextPoint( ptEn) ;
    }
@@ -71,7 +71,7 @@ CDeSimpleConvexTorusTria( const Frame3d& frTorus, double dRad1, double dRad2, in
 //----------------------------------------------------------------------------
 bool
 CDeConvexTorusTria( const Frame3d& frTorus, double dRad1, double dRad2, int nCtType,
-                    double dSafeDist, const Triangle3d& trTria)
+                    const Triangle3d& trTria, double dSafeDist)
 {
   // I raggi devono essere non nulli e il triangolo ben definito.
    if ( dRad1 < EPS_SMALL  ||  dRad2 < EPS_SMALL  ||  ! trTria.IsValid())
diff --git a/CDeConvexTorusTria.h b/CDeConvexTorusTria.h
index 72d6afb..b2584e2 100644
--- a/CDeConvexTorusTria.h
+++ b/CDeConvexTorusTria.h
@@ -28,4 +28,4 @@ enum ConvexTorusType { CT_INF = -1, CT_SUP = 1, CT_TOT = 0} ;
 bool CDeSimpleConvexTorusTria( const Frame3d& frTorus, double dRad1, double dRad2, int nCtType,
                                const Triangle3d& trTria) ;
 bool CDeConvexTorusTria( const Frame3d& frTorus, double dRad1, double dRad2, int nCtType,
-                         double dSafeDist, const Triangle3d& trTria) ;
\ No newline at end of file
+                         const Triangle3d& trTria, double dSafeDist) ;
\ No newline at end of file
diff --git a/CDeCylClosedSurfTm.cpp b/CDeCylClosedSurfTm.cpp
index f8feab3..e34e6d9 100644
--- a/CDeCylClosedSurfTm.cpp
+++ b/CDeCylClosedSurfTm.cpp
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : CDCylSurfTm.cpp      Data : 09.01.20        Versione : 2.2a2
+// File : CDCylSurfTm.cpp      Data : 15.02.24        Versione : 2.6b2
 // Contenuto : Implementazione della verifica di collisione tra
 //             Cylinder e Closed SurftriMesh.
 //
@@ -19,17 +19,30 @@
 
 using namespace std ;
 
+//----------------------------------------------------------------------------
+// Il sistema di riferimento deve avere l'asse di simmetria del cilindro come asse Z e origine nel centro della base o del top.
+// La distanza di sicurezza ha effetto solo se maggiore di EPS_SMALL, altrimenti è ignorata ed è ininfluente.
+// Il sistema di riferimento del cilindro è riferito a quello della superficie.
+// La funzione restituisce :
+// - true in caso di collisione o inconsistenza dei parametri di input
+// - false in caso di assenza di collisione.
 //----------------------------------------------------------------------------
 bool
-CDeCylClosedSurfTm( const Frame3d& frCyl, double dR, double dH, double dSafeDist, const ISurfTriMesh& Stm)
+CDeCylClosedSurfTm( const Frame3d& frCyl, double dR, double dH, const ISurfTriMesh& Stm, double dSafeDist)
 {
+  // Il cilindro deve essere ben definito
+   if ( dR < EPS_SMALL  ||  dH < EPS_SMALL)
+      return true ;
+  // Se superficie non valida o aperta, non ha senso proseguire
+   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
+      return true ;
   // Recupero BBox del poliedro
    BBox3d b3Poly = Stm.GetAllTriaBox() ;
   // Sistemazioni cilindro
    Frame3d frMyCyl = frCyl ;
    if ( dH < 0) {
       frMyCyl.Translate( dH * frMyCyl.VersZ()) ;
-      dH = - dH ;
+      dH = -dH ;
    }
   // Calcolo il BBox del cilindro
    BBox3d b3CylL( Point3d( -dR, -dR, 0),
@@ -46,13 +59,10 @@ CDeCylClosedSurfTm( const Frame3d& frCyl, double dR, double dH, double dSafeDist
    for ( int nT : vT) {
       Triangle3d Tria ;
       if ( Stm.GetTriangle( nT, Tria)) {
-         if ( CDeCylTria( frMyCyl, dR, dH, dSafeDist, Tria))
+         if ( CDeCylTria( frMyCyl, dR, dH, Tria, dSafeDist))
             return true ;
       }
    }
-  // Se superficie aperta, non c'è collisione
-   if ( ! Stm.IsClosed())
-      return false ;
   // Se il BBox del cilindro non è interno a quello del poliedro e viceversa, non c'è collisione
    if ( ! b3Poly.Encloses( b3Cyl)  &&  ! b3Cyl.Encloses( b3Poly))
       return false ;
diff --git a/CDeCylTria.cpp b/CDeCylTria.cpp
index ff9baf5..084a0e5 100644
--- a/CDeCylTria.cpp
+++ b/CDeCylTria.cpp
@@ -84,7 +84,7 @@ CDeSimpleCylTria( const Frame3d& frCyl, double dR, double dH, const Triangle3d&
 
 //----------------------------------------------------------------------------
 bool
-CDeCylTria( const Frame3d& frCyl, double dR, double dH, double dSafeDist, const Triangle3d& trTria)
+CDeCylTria( const Frame3d& frCyl, double dR, double dH, const Triangle3d& trTria, double dSafeDist)
 {
   // Se distanza di sicurezza nulla
    if ( dSafeDist < EPS_SMALL)
diff --git a/CDeCylTria.h b/CDeCylTria.h
index f1b5cf3..7e1ce6f 100644
--- a/CDeCylTria.h
+++ b/CDeCylTria.h
@@ -16,4 +16,4 @@
 
 //----------------------------------------------------------------------------
 bool CDeSimpleCylTria( const Frame3d& frCyl, double dR, double dH, const Triangle3d& trTria) ;
-bool CDeCylTria( const Frame3d& frCyl, double dR, double dH, double dSafeDist, const Triangle3d& trTria) ;
+bool CDeCylTria( const Frame3d& frCyl, double dR, double dH, const Triangle3d& trTria, double dSafeDist) ;
diff --git a/CDeRectPrismoidClosedSurfTm.cpp b/CDeRectPrismoidClosedSurfTm.cpp
index 0c1d1e0..05e9018 100644
--- a/CDeRectPrismoidClosedSurfTm.cpp
+++ b/CDeRectPrismoidClosedSurfTm.cpp
@@ -22,16 +22,23 @@ using namespace std ;
 // Il sistema di riferimento deve avere l'origine nel centro della Base, asse X lungo
 // un segmento della stessa e asse Z ortogonale alle basi e diretta verso la base Top.
 // Il sistema di riferimento della piramide deve essere immerso in quello della superficie.
+// La funzione restituisce :
+// - true in caso di collisione o inconsistenza dei parametri di input
+// - false in caso di assenza di collisione.
+//----------------------------------------------------------------------------
 bool
 CDeRectPrismoidClosedSurfTm( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
                              double dLenghtTopX, double dLenghtTopY, double dHeight,
-                             double dSafeDist, const ISurfTriMesh& Stm)
+                             const ISurfTriMesh& Stm, double dSafeDist)
 {
-  // Se il tronco di piramide non è definito o la superficie non ben definita non ha senso proseguire.
+  // Se il tronco di piramide non è definito non ha senso proseguire.
    if ( max( dLenghtBaseX, dLenghtTopX) < EPS_SMALL  ||
         max( dLenghtBaseY, dLenghtTopY) < EPS_SMALL  ||
-        dHeight < EPS_SMALL  ||  ! Stm.IsValid())
-      return false ;
+        dHeight < EPS_SMALL)
+      return true ;
+  // Se superficie non valida o aperta, non ha senso proseguire
+   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
+      return true ;
   // Recupero BBox della trimesh
    BBox3d b3Surf = Stm.GetAllTriaBox() ;
   // Calcolo il BBox del tronco di piramide
@@ -53,13 +60,10 @@ CDeRectPrismoidClosedSurfTm( const Frame3d& frPrismoid, double dLenghtBaseX, dou
       Triangle3d trTria ; 
       if ( Stm.GetTriangle( nT, trTria)) {
          if ( CDeRectPrismoidTria( frPrismoid, dLenghtBaseX, dLenghtBaseY, dLenghtTopX, dLenghtTopY, dHeight,
-                                   dSafeDist, trTria))
+                                    trTria, dSafeDist))
             return true ;
       }
    }
-  // Se superficie aperta, non c'è collisione
-   if ( ! Stm.IsClosed())
-      return false ;
   // Se il BBox del tronco di piramide non è interno a quello del poliedro e viceversa, non c'è collisione
    if ( ! b3Surf.Encloses( b3Pyr)  &&  ! b3Pyr.Encloses( b3Surf))
       return false ;
diff --git a/CDeRectPrismoidTria.cpp b/CDeRectPrismoidTria.cpp
index 1464549..5fe2a16 100644
--- a/CDeRectPrismoidTria.cpp
+++ b/CDeRectPrismoidTria.cpp
@@ -134,7 +134,7 @@ CDeSimpleRectPrismoidTria( const Frame3d& frPrismoid, double dLenghtBaseX, doubl
 bool
 CDeRectPrismoidTria( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
                      double dLenghtTopX, double dLenghtTopY, double dHeight,
-                     double dSafeDist, const Triangle3d& trTria)
+                     const Triangle3d& trTria, double dSafeDist)
 {
   // Se il tronco di piramide o il triangolo non sono ben definiti non procedo
    if ( max( dLenghtBaseX, dLenghtTopX) < EPS_SMALL  ||
diff --git a/CDeRectPrismoidTria.h b/CDeRectPrismoidTria.h
index d45ef1b..3b6bb2a 100644
--- a/CDeRectPrismoidTria.h
+++ b/CDeRectPrismoidTria.h
@@ -26,4 +26,4 @@ bool CDeSimpleRectPrismoidTria( const Frame3d& frPrismoid, double dLenghtBaseX,
 // asse X lungo un lato della stessa e asse Z ortogonale alle basi e diretta verso la base Top.
 bool CDeRectPrismoidTria( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
                           double dLenghtTopX, double dLenghtTopY, double dHeight,
-                          double dSafeDist, const Triangle3d& trTria) ;
+                          const Triangle3d& trTria, double dSafeDist) ;
diff --git a/CDeSpheClosedSurfTm.cpp b/CDeSpheClosedSurfTm.cpp
index e6ab0c8..ea4d103 100644
--- a/CDeSpheClosedSurfTm.cpp
+++ b/CDeSpheClosedSurfTm.cpp
@@ -19,10 +19,20 @@
 
 using namespace std ;
 
+//----------------------------------------------------------------------------
+// La funzione restituisce :
+// - true in caso di collisione o inconsistenza dei parametri di input
+// - false in caso di assenza di collisione.
 //----------------------------------------------------------------------------
 bool
-CDeSpheClosedSurfTm( const Point3d& ptCen, double dR, double dSafeDist, const ISurfTriMesh& Stm)
+CDeSpheClosedSurfTm( const Point3d& ptCen, double dR, const ISurfTriMesh& Stm, double dSafeDist)
 {
+  // Il raggio deve essere non nullo
+   if ( dR < EPS_SMALL)
+      return true ;
+  // Se superficie non valida o aperta, non ha senso proseguire
+   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
+      return true ;
   // Recupero BBox del poliedro
    BBox3d b3Poly = Stm.GetAllTriaBox() ;
   // Calcolo il BBox della sfera
@@ -38,13 +48,10 @@ CDeSpheClosedSurfTm( const Point3d& ptCen, double dR, double dSafeDist, const IS
    for ( int nT : vT) {
       Triangle3d Tria ;
       if ( Stm.GetTriangle( nT, Tria)) {
-         if ( CDeSpheTria( ptCen, dR, dSafeDist, Tria))
+         if ( CDeSpheTria( ptCen, dR, Tria, dSafeDist))
             return true ;
       }
    }
-  // Se superficie aperta, non c'è collisione
-   if ( ! Stm.IsClosed())
-      return false ;
   // Se il BBox della sfera non è interno a quello del poliedro e viceversa, non c'è collisione
    if ( ! b3Sphe.Encloses( b3Poly)  &&  ! b3Poly.Encloses( b3Sphe))
       return false ;
diff --git a/CDeSpheTria.cpp b/CDeSpheTria.cpp
index 2d6977a..991e42c 100644
--- a/CDeSpheTria.cpp
+++ b/CDeSpheTria.cpp
@@ -31,7 +31,7 @@ CDeSimpleSpheTria( const Point3d& ptCen, double dR, const Triangle3d& trTria)
 
 //----------------------------------------------------------------------------
 bool
-CDeSpheTria( const Point3d& ptCen, double dR, double dSafeDist, const Triangle3d& trTria)
+CDeSpheTria( const Point3d& ptCen, double dR, const Triangle3d& trTria, double dSafeDist)
 {
    return CDeSimpleSpheTria( ptCen, dR + max( 0., dSafeDist), trTria) ;
 }
diff --git a/CDeSpheTria.h b/CDeSpheTria.h
index 95080ee..13e52a6 100644
--- a/CDeSpheTria.h
+++ b/CDeSpheTria.h
@@ -16,4 +16,4 @@
 
 //----------------------------------------------------------------------------
 bool CDeSimpleSpheTria( const Point3d& ptCen, double dR, const Triangle3d& trTria) ;
-bool CDeSpheTria( const Point3d& ptCen, double dR, double dSafeDist, const Triangle3d& trTria) ;
+bool CDeSpheTria( const Point3d& ptCen, double dR, const Triangle3d& trTria, double dSafeDist) ;
diff --git a/CDeUtility.cpp b/CDeUtility.cpp
index 13b44e4..2c8f7da 100644
--- a/CDeUtility.cpp
+++ b/CDeUtility.cpp
@@ -368,4 +368,4 @@ ClampSegmentOutPlane( const Plane3d& plPlane, Point3d& ptSegP, const Vector3d& v
       dSegLen -= dIntersLen ;
    }
    return true ;
-}
\ No newline at end of file
+}
diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc
index 6e8fa5b..74c82b1 100644
Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ
diff --git a/GdbExecutor.cpp b/GdbExecutor.cpp
index 43fadf4..8cd2c19 100644
--- a/GdbExecutor.cpp
+++ b/GdbExecutor.cpp
@@ -3073,7 +3073,7 @@ GdbExecutor::VolZmapBBoxZmapIntersection( const STRVECTOR& vsParams)
       return false ;
    bool bInt ;
 
-   bInt = ! pZmap->AvoidBox( frBBoxFrame, ptEnd - ORIG) ; 
+   bInt = pZmap->CDeBox( frBBoxFrame, ptEnd - ORIG) ; 
 
    return true ;
 }*/
diff --git a/ProjectCurveSurfTm.cpp b/ProjectCurveSurfTm.cpp
index 647ef6d..0c3e660 100644
--- a/ProjectCurveSurfTm.cpp
+++ b/ProjectCurveSurfTm.cpp
@@ -18,6 +18,8 @@
 #include "/EgtDev/Include/EGkIntersLineSurfTm.h"
 #include "/EgtDev/Include/EGkProjectCurveSurfTm.h"
 
+using namespace std ;
+
 //----------------------------------------------------------------------------
 static bool
 PointsInTolerance( const PNT5AXVECTOR& vPt5ax, int nPrec, int nCurr, int nNext, double dSqTol)
@@ -32,14 +34,17 @@ PointsInTolerance( const PNT5AXVECTOR& vPt5ax, int nPrec, int nCurr, int nNext,
 
 //----------------------------------------------------------------------------
 bool
-ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vector3d& vtDir, double dLinTol,
+ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vector3d& vtDir, double dLinTol, double dMaxSegmLen,
                       PNT5AXVECTOR& vPt5ax)
 {
+  // controllo le tolleranze
+   dLinTol = max( dLinTol, LIN_TOL_MIN) ;
+   dMaxSegmLen = max( dMaxSegmLen, 10 * EPS_SMALL) ;
   // approssimo la curva con una polilinea entro la metà della tolleranza
    PolyLine PL ;
    if ( ! crCrv.ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
       return false ;
-   const double MAX_SEG_LEN = 1 ;
+   const double MAX_SEG_LEN = min( dMaxSegmLen, 1.) ;
    if ( ! PL.AdjustForMaxSegmentLen( MAX_SEG_LEN))
       return false ;
 
@@ -85,23 +90,29 @@ ProjectCurveOnSurfTm( const ICurve& crCrv, const ISurfTriMesh& tmSurf, const Vec
       bFound = PL.GetNextUPoint( &dU, &ptP) ;
    }
 
-  // rimuovo i punti allineati entro la tolleranza
+  // rimuovo i punti allineati entro la tolleranza e non più lontani tra loro del massimo
+   double dSqMaxLen = dMaxSegmLen * dMaxSegmLen ;
    double dSqTol = dLinTol * dLinTol ;
    int nPrec = 0 ;
    int nCurr = 1 ;
    int nNext = 2 ;
    while ( nNext < int( vMyPt5ax.size())) {
       bool bRemove = false ;
-     // distanza del punto corrente dal segmento che unisce gli adiacenti
-      DistPointLine dPL( vMyPt5ax[nCurr].ptP, vMyPt5ax[nPrec].ptP, vMyPt5ax[nNext].ptP) ;
-      double dSqDist ;
-     // se distanza inferiore a tolleranza lineare
-      if ( dPL.GetSqDist( dSqDist)  &&  dSqDist < dSqTol  &&  PointsInTolerance( vMyPt5ax, nPrec, nCurr, nNext, dSqTol)) {
-        // verifico se errore angolare inferiore a limite
-         double dPar ; dPL.GetParamAtMinDistPoint( dPar) ;
-         Vector3d vtNew = Media( vMyPt5ax[nPrec].vtDir, vMyPt5ax[nNext].vtDir, dPar) ;
-         if ( vtNew.Normalize()  &&  vtNew * vMyPt5ax[nCurr].vtDir > cos( 2 * DEGTORAD))
-            bRemove = true ;
+     // lunghezza del segmento che unisce gli adiacenti
+      double dSqLen = SqDist( vMyPt5ax[nPrec].ptP, vMyPt5ax[nNext].ptP) ;
+     // se lunghezza inferiore al massimo, passo agli altri controlli
+      if ( dSqLen <= dSqMaxLen) {
+        // distanza del punto corrente dal segmento che unisce gli adiacenti
+         DistPointLine dPL( vMyPt5ax[nCurr].ptP, vMyPt5ax[nPrec].ptP, vMyPt5ax[nNext].ptP) ;
+         double dSqDist ;
+        // se distanza inferiore a tolleranza lineare
+         if ( dPL.GetSqDist( dSqDist)  &&  dSqDist < dSqTol  &&  PointsInTolerance( vMyPt5ax, nPrec, nCurr, nNext, dSqTol)) {
+           // verifico se errore angolare inferiore a limite
+            double dPar ; dPL.GetParamAtMinDistPoint( dPar) ;
+            Vector3d vtNew = Media( vMyPt5ax[nPrec].vtDir, vMyPt5ax[nNext].vtDir, dPar) ;
+            if ( vtNew.Normalize()  &&  vtNew * vMyPt5ax[nCurr].vtDir > cos( 2 * DEGTORAD))
+               bRemove = true ;
+         }
       }
      // se da eliminare
       if ( bRemove) {   
diff --git a/SurfFlatRegionOffset.cpp b/SurfFlatRegionOffset.cpp
index cda1912..4d549a3 100644
--- a/SurfFlatRegionOffset.cpp
+++ b/SurfFlatRegionOffset.cpp
@@ -209,7 +209,7 @@ SurfFlatRegion::Offset( double dDist, int nType)
 
   // se offset nullo, non devo fare alcunchè
    if ( abs( dDist) < 10 * EPS_SMALL)
-      return this->Clone() ;
+      return true ;
   
   // calcolo la superficie di offset
    PtrOwner<SurfFlatRegion> pSfr( CreateOffsetSurf( dDist, nType)) ;
diff --git a/VolZmap.h b/VolZmap.h
index 7719ab7..fa0f843 100644
--- a/VolZmap.h
+++ b/VolZmap.h
@@ -114,17 +114,17 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool GetDepth( const Point3d& ptP, const Vector3d& vtD, double& dInLength, double& dOutLength, bool bExact) const override ;
       bool GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTOR& vIntersInfo) const override ;
       bool GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) const override ;
-      bool AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, bool bPrecise = false) const override ;
-      bool AvoidSphere( const Point3d& ptCenter, double dRad, double dSafeDist, bool bPrecise = false) const override ;
-      bool AvoidCylinder( const Frame3d& frCyl, double dR, double dH, double dSafeDist, bool bPrecise = false) const override ;
-      bool AvoidConeFrustum( const Frame3d& frCone, double dRadBot, double dRadTop, double dHeight,
-                             double dSafeDist, bool bPrecise = false) const override ;
-      bool AvoidRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
-                              double dLenghtTopX, double dLenghtTopY, double dHeight,
-                              double dSafeDist, bool bPrecise = false) const override ;
-      bool AvoidTorus( const Frame3d& frTorus, double dRadMax, double dRadMin,
-                       double dSafeDist, bool bPrecise = false) const override ;
-      bool AvoidSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecise = false) const override ;
+      bool CDeBox( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, bool bPrecise = false) const override ;
+      bool CDeSphere( const Point3d& ptCenter, double dRad, double dSafeDist, bool bPrecise = false) const override ;
+      bool CDeCylinder( const Frame3d& frCyl, double dR, double dH, double dSafeDist, bool bPrecise = false) const override ;
+      bool CDeConeFrustum( const Frame3d& frCone, double dRadBot, double dRadTop, double dHeight,
+                           double dSafeDist, bool bPrecise = false) const override ;
+      bool CDeRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
+                            double dLenghtTopX, double dLenghtTopY, double dHeight,
+                            double dSafeDist, bool bPrecise = false) const override ;
+      bool CDeTorus( const Frame3d& frTorus, double dRadMax, double dRadMin,
+                     double dSafeDist, bool bPrecise = false) const override ;
+      bool CDeSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecise = false) const override ;
       bool Cut( const Plane3d& plPlane) override ;
       bool Compact( void) override ;
       int  GetPartCount( void) const override ;
@@ -393,14 +393,14 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool ProcessIntervals( IntContainer& IntervalsToProcess) ;
       bool IsMapPartABox( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, double& dMinZ, double& dMaxZ) ;
       bool IsBox( void) ;
-     // Avoid semplici
-      bool AvoidSimpleBox( const Frame3d& frBox, const Vector3d& vtDiag, bool bPrecise = false) const ;
-      bool AvoidSimpleSphere( const Point3d& ptCenter, double dRad, bool bPrecise = false) const ;
-      bool AvoidSimpleCylinder( const Frame3d& frCyl, double dR, double dH, bool bPrecise = false) const ;
-      bool AvoidSimpleConeFrustum( const Frame3d& frCone, double dMinRad, double dMaxRad, double dHeight, bool bPrecise = false) const ;
-      bool AvoidSimpleRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
-                                    double dLenghtTopX, double dLenghtTopY, double dHeight, bool bPrecise = false) const ;
-      bool AvoidSimpleTorus( const Frame3d& frTorus, double dMaxRad, double dMinRad, bool bPrecise = false) const ;
+     // Collision Detection semplici
+      bool CDeSimpleBox( const Frame3d& frBox, const Vector3d& vtDiag, bool bPrecise = false) const ;
+      bool CDeSimpleSphere( const Point3d& ptCenter, double dRad, bool bPrecise = false) const ;
+      bool CDeSimpleCylinder( const Frame3d& frCyl, double dR, double dH, bool bPrecise = false) const ;
+      bool CDeSimpleConeFrustum( const Frame3d& frCone, double dMinRad, double dMaxRad, double dHeight, bool bPrecise = false) const ;
+      bool CDeSimpleRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
+                                  double dLenghtTopX, double dLenghtTopY, double dHeight, bool bPrecise = false) const ;
+      bool CDeSimpleTorus( const Frame3d& frTorus, double dMaxRad, double dMinRad, bool bPrecise = false) const ;
       // Funzione per crezione solido in parallelo
       bool CreateMapPart( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, const Vector3d& vtLen, const Point3d& ptMapOrig,
                           const ISurfTriMesh& Surf, IntersParLinesSurfTm& intPLSTM) ;
diff --git a/VolZmapCalculus.cpp b/VolZmapCalculus.cpp
index cadc688..4a7caf4 100644
--- a/VolZmapCalculus.cpp
+++ b/VolZmapCalculus.cpp
@@ -411,7 +411,7 @@ VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dIn
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AvoidSimpleBox( const Frame3d& frBox, const Vector3d& vtDiag, bool bPrecise) const
+VolZmap::CDeSimpleBox( const Frame3d& frBox, const Vector3d& vtDiag, bool bPrecise) const
 {
   // BBox
    BBox3d b3BoxL( ORIG, ORIG + vtDiag) ;
@@ -425,10 +425,10 @@ VolZmap::AvoidSimpleBox( const Frame3d& frBox, const Vector3d& vtDiag, bool bPre
 
   // Se non interferiscono, posso uscire
    if ( ! b3Zmap.Overlaps( b3Box)  ||  ! b3Zmap.Overlaps( frBoxInt, b3BoxL))
-      return true ;
+      return false ;
    BBox3d b3Int ;
    if ( ! b3Zmap.FindIntersection( b3Box, b3Int))
-      return true ;
+      return false ;
 
   // Se verifico solo prima mappa
    if ( ! bPrecise  ||  m_nMapNum == 1) {
@@ -470,7 +470,7 @@ VolZmap::AvoidSimpleBox( const Frame3d& frBox, const Vector3d& vtDiag, bool bPre
                   for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 1) {
                      if ( dZmax > m_Values[0][nPos][nIndex].dMin - EPS_SMALL  &&
                           dZmin < m_Values[0][nPos][nIndex].dMax + EPS_SMALL)
-                        return false ;
+                        return true ;
                   }
                }
             }
@@ -533,7 +533,7 @@ VolZmap::AvoidSimpleBox( const Frame3d& frBox, const Vector3d& vtDiag, bool bPre
                      // Se il segmento è interno all'intervallo d'intersezione, ho finito.
                      if ( dMaxU > m_Values[nMap][nPos][nIndex].dMin - EPS_SMALL  &&
                           dMinU < m_Values[nMap][nPos][nIndex].dMax + EPS_SMALL)
-                        return false ;
+                        return true ;
                   }
                }
             }
@@ -541,32 +541,36 @@ VolZmap::AvoidSimpleBox( const Frame3d& frBox, const Vector3d& vtDiag, bool bPre
       }
    }
 
-   return true ;
+   return false ;
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, bool bPrecise) const
+VolZmap::CDeBox( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, bool bPrecise) const
 {
+  // Se il box non è ben definito non ha senso proseguire
+   if ( vtDiag.IsSmall())
+      return true ;
+
   // Se distanza di sicurezza nulla
    if ( dSafeDist < EPS_SMALL)
-      return AvoidSimpleBox( frBox, vtDiag, bPrecise) ;
+      return CDeSimpleBox( frBox, vtDiag, bPrecise) ;
 
   // Verifica preliminare con box esteso
    Frame3d frEst = frBox ; frEst.Translate( -dSafeDist * ( frBox.VersX() + frBox.VersY() + frBox.VersZ())) ;
-   if ( AvoidSimpleBox( frEst, vtDiag + 2 * Vector3d( dSafeDist, dSafeDist, dSafeDist), bPrecise))
-      return true ;
+   if ( ! CDeSimpleBox( frEst, vtDiag + 2 * Vector3d( dSafeDist, dSafeDist, dSafeDist), bPrecise))
+      return false ;
 
   // Tre box aumentati con distanza di sicurezza in un sola dimensione
    Frame3d frTmp = frBox ; frTmp.Translate( -dSafeDist * frBox.VersX()) ;
-   if ( ! AvoidSimpleBox( frTmp, vtDiag + 2 * dSafeDist * X_AX, bPrecise))
-      return false ;
+   if ( CDeSimpleBox( frTmp, vtDiag + 2 * dSafeDist * X_AX, bPrecise))
+      return true ;
    frTmp = frBox ; frTmp.Translate( -dSafeDist * frBox.VersY()) ;
-   if ( ! AvoidSimpleBox( frTmp, vtDiag + 2 * dSafeDist * Y_AX, bPrecise))
-      return false ;
+   if ( CDeSimpleBox( frTmp, vtDiag + 2 * dSafeDist * Y_AX, bPrecise))
+      return true ;
    frTmp = frBox ; frTmp.Translate( -dSafeDist * frBox.VersZ()) ;
-   if ( ! AvoidSimpleBox( frTmp, vtDiag + 2 * dSafeDist * Z_AX, bPrecise))
-      return false ;
+   if ( CDeSimpleBox( frTmp, vtDiag + 2 * dSafeDist * Z_AX, bPrecise))
+      return true ;
 
   // Vertici del box
    Point3d ptVert0 = frBox.Orig() ;
@@ -579,67 +583,67 @@ VolZmap::AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDis
    Point3d ptVert7 = ptVert3 + vtDiag.z * frBox.VersZ() ;
 
   // Sfere centrate negli otto vertici
-   if ( ! AvoidSimpleSphere( ptVert0, dSafeDist, bPrecise))
-      return false ;
-   if ( ! AvoidSimpleSphere( ptVert1, dSafeDist, bPrecise))
-      return false ;
-   if ( ! AvoidSimpleSphere( ptVert2, dSafeDist, bPrecise))
-      return false ;
-   if ( ! AvoidSimpleSphere( ptVert3, dSafeDist, bPrecise))
-      return false ;
-   if ( ! AvoidSimpleSphere( ptVert4, dSafeDist, bPrecise))
-      return false ;
-   if ( ! AvoidSimpleSphere( ptVert5, dSafeDist, bPrecise))
-      return false ;
-   if ( ! AvoidSimpleSphere( ptVert6, dSafeDist, bPrecise))
-      return false ;
-   if ( ! AvoidSimpleSphere( ptVert7, dSafeDist, bPrecise))
-      return false ;
+   if ( CDeSimpleSphere( ptVert0, dSafeDist, bPrecise))
+      return true ;
+   if ( CDeSimpleSphere( ptVert1, dSafeDist, bPrecise))
+      return true ;
+   if ( CDeSimpleSphere( ptVert2, dSafeDist, bPrecise))
+      return true ;
+   if ( CDeSimpleSphere( ptVert3, dSafeDist, bPrecise))
+      return true ;
+   if ( CDeSimpleSphere( ptVert4, dSafeDist, bPrecise))
+      return true ;
+   if ( CDeSimpleSphere( ptVert5, dSafeDist, bPrecise))
+      return true ;
+   if ( CDeSimpleSphere( ptVert6, dSafeDist, bPrecise))
+      return true ;
+   if ( CDeSimpleSphere( ptVert7, dSafeDist, bPrecise))
+      return true ;
 
   // Cilindri centrati sui dodici spigoli
    frTmp.Set( ptVert0, frBox.VersX()) ;
-   if ( ! AvoidSimpleCylinder( frTmp, dSafeDist, vtDiag.x, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frTmp, dSafeDist, vtDiag.x, bPrecise))
+      return true ;
    frTmp.Set( ptVert2, frBox.VersX()) ;
-   if ( ! AvoidSimpleCylinder( frTmp, dSafeDist, vtDiag.x, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frTmp, dSafeDist, vtDiag.x, bPrecise))
+      return true ;
    frTmp.Set( ptVert0, frBox.VersY()) ;
-   if ( ! AvoidSimpleCylinder( frTmp, dSafeDist, vtDiag.y, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frTmp, dSafeDist, vtDiag.y, bPrecise))
+      return true ;
    frTmp.Set( ptVert1, frBox.VersY()) ;
-   if ( ! AvoidSimpleCylinder( frTmp, dSafeDist, vtDiag.y, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frTmp, dSafeDist, vtDiag.y, bPrecise))
+      return true ;
    frTmp.Set( ptVert4, frBox.VersX()) ;
-   if ( ! AvoidSimpleCylinder( frTmp, dSafeDist, vtDiag.x, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frTmp, dSafeDist, vtDiag.x, bPrecise))
+      return true ;
    frTmp.Set( ptVert6, frBox.VersX()) ;
-   if ( ! AvoidSimpleCylinder( frTmp, dSafeDist, vtDiag.x, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frTmp, dSafeDist, vtDiag.x, bPrecise))
+      return true ;
    frTmp.Set( ptVert4, frBox.VersY()) ;
-   if ( ! AvoidSimpleCylinder( frTmp, dSafeDist, vtDiag.y, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frTmp, dSafeDist, vtDiag.y, bPrecise))
+      return true ;
    frTmp.Set( ptVert5, frBox.VersY()) ;
-   if ( ! AvoidSimpleCylinder( frTmp, dSafeDist, vtDiag.y, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frTmp, dSafeDist, vtDiag.y, bPrecise))
+      return true ;
    frTmp.Set( ptVert0, frBox.VersZ()) ;
-   if ( ! AvoidSimpleCylinder( frTmp, dSafeDist, vtDiag.z, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frTmp, dSafeDist, vtDiag.z, bPrecise))
+      return true ;
    frTmp.Set( ptVert1, frBox.VersZ()) ;
-   if ( ! AvoidSimpleCylinder( frTmp, dSafeDist, vtDiag.z, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frTmp, dSafeDist, vtDiag.z, bPrecise))
+      return true ;
    frTmp.Set( ptVert2, frBox.VersZ()) ;
-   if ( ! AvoidSimpleCylinder( frTmp, dSafeDist, vtDiag.z, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frTmp, dSafeDist, vtDiag.z, bPrecise))
+      return true ;
    frTmp.Set( ptVert3, frBox.VersZ()) ;
-   if ( ! AvoidSimpleCylinder( frTmp, dSafeDist, vtDiag.z, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frTmp, dSafeDist, vtDiag.z, bPrecise))
+      return true ;
 
-   return true ;
+   return false ;
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AvoidSimpleSphere( const Point3d& ptCenter, double dRad, bool bPrecise) const
+VolZmap::CDeSimpleSphere( const Point3d& ptCenter, double dRad, bool bPrecise) const
 {
   // Porto la sfera nel riferimento intrinseco dello Zmap
    Point3d ptC = ptCenter ;
@@ -655,7 +659,7 @@ VolZmap::AvoidSimpleSphere( const Point3d& ptCenter, double dRad, bool bPrecise)
   // Se non interferiscono, posso uscire
    BBox3d b3Int ;
    if ( ! b3Zmap.FindIntersection( b3Box, b3Int))
-      return true ;
+      return false ;
 
   // Se verifico solo prima mappa
    if ( ! bPrecise  ||  m_nMapNum == 1) {
@@ -693,7 +697,7 @@ VolZmap::AvoidSimpleSphere( const Point3d& ptCenter, double dRad, bool bPrecise)
                   for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 1) {
                      if ( dZmax > m_Values[0][nPos][nIndex].dMin - EPS_SMALL  &&
                           dZmin < m_Values[0][nPos][nIndex].dMax + EPS_SMALL)
-                        return false ;
+                        return true ;
                   }
                }
             }
@@ -765,7 +769,7 @@ VolZmap::AvoidSimpleSphere( const Point3d& ptCenter, double dRad, bool bPrecise)
                     // Se il segmento è interno all'intervallo d'intersezione, ho finito.
                      if ( dMaxU > m_Values[nMap][nPos][nIndex].dMin - EPS_SMALL  &&
                           dMinU < m_Values[nMap][nPos][nIndex].dMax + EPS_SMALL)
-                        return false ;
+                        return true ;
                   }
                }
             }
@@ -773,19 +777,23 @@ VolZmap::AvoidSimpleSphere( const Point3d& ptCenter, double dRad, bool bPrecise)
       }
    }
 
-   return true ;
+   return false ;
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AvoidSphere( const Point3d& ptCenter, double dRad, double dSafeDist, bool bPrecise) const
+VolZmap::CDeSphere( const Point3d& ptCenter, double dRad, double dSafeDist, bool bPrecise) const
 {
-   return AvoidSimpleSphere( ptCenter, dRad + max( 0., dSafeDist), bPrecise) ;
+  // Il raggio deve essere non nullo
+   if ( dRad < EPS_SMALL)
+      return true ;
+
+   return CDeSimpleSphere( ptCenter, dRad + max( 0., dSafeDist), bPrecise) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AvoidSimpleCylinder( const Frame3d& frCyl, double dR, double dH, bool bPrecise) const
+VolZmap::CDeSimpleCylinder( const Frame3d& frCyl, double dR, double dH, bool bPrecise) const
 {
   // BBox del cilindro in locale
    BBox3d b3CylL( Point3d( -dR, -dR, 0), Point3d( dR, dR, dH)) ;
@@ -799,7 +807,7 @@ VolZmap::AvoidSimpleCylinder( const Frame3d& frCyl, double dR, double dH, bool b
 
   // Se non interferiscono, posso uscire
    if ( ! b3Zmap.Overlaps( b3CylI)  ||  ! b3Zmap.Overlaps( frCylInt, b3CylL))
-      return true ;
+      return false ;
 
   // BBox del cilindro ottimizzato nel riferimento intrinseco dello Zmap
    Point3d ptMyCen = frCylInt.Orig() ;
@@ -822,7 +830,7 @@ VolZmap::AvoidSimpleCylinder( const Frame3d& frCyl, double dR, double dH, bool b
   // Se non interferiscono, posso uscire
    BBox3d b3Int ;
    if ( ! b3Zmap.FindIntersection( b3Cyl, b3Int))
-      return true ;
+      return false ;
 
   // Se verifico solo prima mappa
    if ( ! bPrecise  ||  m_nMapNum == 1) {
@@ -866,7 +874,7 @@ VolZmap::AvoidSimpleCylinder( const Frame3d& frCyl, double dR, double dH, bool b
                   for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 1) {
                      if ( dZmax > m_Values[0][nPos][nIndex].dMin - EPS_SMALL  &&
                           dZmin < m_Values[0][nPos][nIndex].dMax + EPS_SMALL)
-                        return false ;
+                        return true ;
                   }
                }
             }
@@ -931,7 +939,7 @@ VolZmap::AvoidSimpleCylinder( const Frame3d& frCyl, double dR, double dH, bool b
                      // Se il segmento è interno all'intervallo d'intersezione, ho finito.
                      if ( dMaxU > m_Values[nMap][nPos][nIndex].dMin - EPS_SMALL  &&
                           dMinU < m_Values[nMap][nPos][nIndex].dMax + EPS_SMALL)
-                        return false ;
+                        return true ;
                   }
                }
             }
@@ -939,13 +947,17 @@ VolZmap::AvoidSimpleCylinder( const Frame3d& frCyl, double dR, double dH, bool b
       }
    }
 
-   return true ;
+   return false ;
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AvoidCylinder( const Frame3d& frCyl, double dR, double dH, double dSafeDist, bool bPrecise) const
+VolZmap::CDeCylinder( const Frame3d& frCyl, double dR, double dH, double dSafeDist, bool bPrecise) const
 {
+  // Il cilindro deve essere ben definito
+   if ( dR < EPS_SMALL  ||  dH < EPS_SMALL)
+      return true ;
+
   // Se altezza negativa, sposto riferimento da faccia sopra a quella sotto
    Frame3d frMyCyl = frCyl ;
    if ( dH < 0) {
@@ -955,34 +967,34 @@ VolZmap::AvoidCylinder( const Frame3d& frCyl, double dR, double dH, double dSafe
 
   // Se distanza di sicurezza nulla
    if ( dSafeDist < EPS_SMALL)
-      return AvoidSimpleCylinder( frMyCyl, dR, dH, bPrecise) ;
+      return CDeSimpleCylinder( frMyCyl, dR, dH, bPrecise) ;
 
   // Verifica preliminare con cilindro esteso
    Frame3d frEst = frMyCyl ; frEst.Translate( -dSafeDist * frMyCyl.VersZ()) ;
-   if ( AvoidSimpleCylinder( frEst, dR + dSafeDist, dH + 2 * dSafeDist, bPrecise))
-      return true ;
+   if ( ! CDeSimpleCylinder( frEst, dR + dSafeDist, dH + 2 * dSafeDist, bPrecise))
+      return false ;
 
   // Cilindro allargato
-   if ( ! AvoidSimpleCylinder( frMyCyl, dR + dSafeDist, dH, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frMyCyl, dR + dSafeDist, dH, bPrecise))
+      return true ;
   // Cilindro allungato
    Frame3d frTmp = frMyCyl ; frTmp.Translate( - dSafeDist * frMyCyl.VersZ()) ;
-   if ( ! AvoidSimpleCylinder( frTmp, dR, dH + 2 * dSafeDist, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frTmp, dR, dH + 2 * dSafeDist, bPrecise))
+      return true ;
   // Toro inferiore
-   if ( ! AvoidSimpleTorus( frMyCyl, dR, dSafeDist, bPrecise))
-      return false ;
+   if ( CDeSimpleTorus( frMyCyl, dR, dSafeDist, bPrecise))
+      return true ;
   // Toro superiore
    frTmp = frMyCyl ; frTmp.Translate( dH * frMyCyl.VersZ()) ;
-   if ( ! AvoidSimpleTorus( frTmp, dR, dSafeDist, bPrecise))
-      return false ;
+   if ( CDeSimpleTorus( frTmp, dR, dSafeDist, bPrecise))
+      return true ;
 
-   return true ;
+   return false ;
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AvoidSimpleConeFrustum( const Frame3d& frCone, double dMinRad, double dMaxRad, double dHeight, bool bPrecise) const
+VolZmap::CDeSimpleConeFrustum( const Frame3d& frCone, double dMinRad, double dMaxRad, double dHeight, bool bPrecise) const
 {
   // BBox del tronco di cono in locale
    BBox3d b3ConeL( Point3d( -dMaxRad, -dMaxRad, 0), Point3d( dMaxRad, dMaxRad, dHeight)) ;
@@ -996,7 +1008,7 @@ VolZmap::AvoidSimpleConeFrustum( const Frame3d& frCone, double dMinRad, double d
 
   // Se non interferiscono, posso uscire
    if ( ! b3Zmap.Overlaps( b3ConeI)  ||  ! b3Zmap.Overlaps( frConeInt, b3ConeL))
-      return true ;
+      return false ;
 
   // BBox del tronco di cono ottimizzato nel riferimento intrinseco dello Zmap 
    Point3d ptRefPoint = frConeInt.Orig() ;
@@ -1025,7 +1037,7 @@ VolZmap::AvoidSimpleConeFrustum( const Frame3d& frCone, double dMinRad, double d
   // Se non interferiscono, posso uscire
    BBox3d b3Int ;
    if ( ! b3Zmap.FindIntersection( b3Cone, b3Int))
-      return true ;
+      return false ;
 
   // Uso solo la prima mappa
    if ( ! bPrecise  ||  m_nMapNum == 1) {
@@ -1068,7 +1080,7 @@ VolZmap::AvoidSimpleConeFrustum( const Frame3d& frCone, double dMinRad, double d
                   for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 1) {
                      if ( dZmax > m_Values[0][nPos][nIndex].dMin - EPS_SMALL  &&
                           dZmin < m_Values[0][nPos][nIndex].dMax + EPS_SMALL)
-                        return false ;
+                        return true ;
                   }
                }
             }
@@ -1133,14 +1145,14 @@ VolZmap::AvoidSimpleConeFrustum( const Frame3d& frCone, double dMinRad, double d
                      // Se il segmento è interno all'intervallo d'intersezione, ho finito.
                      if ( dMaxU > m_Values[nMap][nPos][nIndex].dMin - EPS_SMALL  &&
                           dMinU < m_Values[nMap][nPos][nIndex].dMax + EPS_SMALL)
-                        return false ;
+                        return true ;
                   }
                }
             }
          }
       }
    }
-   return true ;
+   return false ;
 }
 
 //----------------------------------------------------------------------------
@@ -1149,12 +1161,16 @@ VolZmap::AvoidSimpleConeFrustum( const Frame3d& frCone, double dMinRad, double d
 // Se è un tronco di cono l'origine è nel centro della base Bot e l'asse Z è diretto verso
 // la base Top, a prescindere da quale base abbia raggio maggiore.
 bool
-VolZmap::AvoidConeFrustum( const Frame3d& frCone, double dRadBot, double dRadTop, double dHeight,
+VolZmap::CDeConeFrustum( const Frame3d& frCone, double dRadBot, double dRadTop, double dHeight,
                            double dSafeDist, bool bPrecise) const
 {
+  // Se il tronco di cono non è ben definito non ha senso proseguire
+   if ( max( dRadBot, dRadTop) < EPS_SMALL  ||  dHeight < EPS_SMALL)
+      return true ;
+
   // Se cilindro
    if ( abs( dRadBot - dRadTop) < EPS_SMALL)
-      return AvoidCylinder( frCone, max( dRadBot, dRadTop), dHeight, dSafeDist, bPrecise) ;
+      return CDeCylinder( frCone, max( dRadBot, dRadTop), dHeight, dSafeDist, bPrecise) ;
 
   // Verifico che la base minore sia in basso nel suo riferimento
    Frame3d frMyCone = frCone ;
@@ -1167,7 +1183,7 @@ VolZmap::AvoidConeFrustum( const Frame3d& frCone, double dRadBot, double dRadTop
 
   // Se distanza di sicurezza nulla
    if ( dSafeDist < EPS_SMALL)
-      return AvoidSimpleConeFrustum( frMyCone, dMinRad, dMaxRad, dHeight, bPrecise) ;
+      return CDeSimpleConeFrustum( frMyCone, dMinRad, dMaxRad, dHeight, bPrecise) ;
 
   // Se vero e proprio cono
    if ( dMinRad < EPS_SMALL)  {
@@ -1177,28 +1193,28 @@ VolZmap::AvoidConeFrustum( const Frame3d& frCone, double dRadBot, double dRadTop
       double dRadExt = dMaxRad * dHeightExt / dHeight ;
       Frame3d frFrame = frMyCone ;
       frFrame.Translate( -dDeltaVert * frFrame.VersZ()) ;
-      if ( AvoidSimpleConeFrustum( frFrame, 0., dRadExt, dHeightExt, bPrecise))
-         return true ;
+      if ( ! CDeSimpleConeFrustum( frFrame, 0., dRadExt, dHeightExt, bPrecise))
+         return false ;
      // Sfera nel vertice in basso
       frFrame = frMyCone ;
-      if ( ! AvoidSimpleSphere( frMyCone.Orig(), dSafeDist, bPrecise))
-         return false ;
+      if ( CDeSimpleSphere( frMyCone.Orig(), dSafeDist, bPrecise))
+         return true ;
      // Tronco di cono intermedio
       double dHypo = sqrt( dMaxRad * dMaxRad + dHeight * dHeight ) ;
       double dDeltaH = dSafeDist * dMaxRad / dHypo ;
       double dDeltaR = dSafeDist * dHeight / dHypo ;
       frFrame = frMyCone ; frFrame.Translate( -dDeltaH * frFrame.VersZ()) ;
-      if ( ! AvoidSimpleConeFrustum( frFrame, dDeltaR, dMaxRad + dDeltaR, dHeight, bPrecise))
-         return false ;
+      if ( CDeSimpleConeFrustum( frFrame, dDeltaR, dMaxRad + dDeltaR, dHeight, bPrecise))
+         return true ;
      // Cilindro nel toro in alto
       frFrame = frMyCone ; frFrame.Translate( ( dHeight - dSafeDist) * frFrame.VersZ()) ;
-      if ( ! AvoidSimpleCylinder( frFrame, dMaxRad, 2 * dSafeDist, bPrecise))
-         return false ;
+      if ( CDeSimpleCylinder( frFrame, dMaxRad, 2 * dSafeDist, bPrecise))
+         return true ;
      // Toro in alto
       frFrame = frMyCone ; frFrame.Translate( dHeight * frFrame.VersZ()) ;
-      if ( ! AvoidSimpleTorus( frFrame, dMaxRad, dSafeDist, bPrecise))
-         return false ;
-      return true ;
+      if ( CDeSimpleTorus( frFrame, dMaxRad, dSafeDist, bPrecise))
+         return true ;
+      return false ;
    }
 
   // Tronco di cono
@@ -1210,33 +1226,33 @@ VolZmap::AvoidConeFrustum( const Frame3d& frCone, double dRadBot, double dRadTop
    double dDeltaMaxRad = ( dDeltaVert + dSafeDist) * dDiffRad / dHeight ;
    double dDeltaMinRad = ( dDeltaVert - dSafeDist) * dDiffRad / dHeight ;
    Frame3d frFrame = frMyCone ; frFrame.Translate( -dSafeDist * frFrame.VersZ()) ;
-   if ( AvoidSimpleConeFrustum( frFrame, dMinRad + dDeltaMinRad, dMaxRad + dDeltaMaxRad, dHeight + 2 * dSafeDist, bPrecise))
-      return true ;
+   if ( ! CDeSimpleConeFrustum( frFrame, dMinRad + dDeltaMinRad, dMaxRad + dDeltaMaxRad, dHeight + 2 * dSafeDist, bPrecise))
+      return false ;
   // Tronco di cono intermedio
    double dHypo = sqrt( dDiffRad * dDiffRad + dHeight * dHeight ) ;
    double dDeltaH = dSafeDist * dDiffRad / dHypo ;
    double dDeltaR = dSafeDist * dHeight / dHypo ;
    frFrame = frMyCone ; frFrame.Translate( -dDeltaH * frFrame.VersZ()) ;
-   if ( ! AvoidSimpleConeFrustum( frFrame, dMinRad + dDeltaR, dMaxRad + dDeltaR, dHeight, bPrecise))
-      return false ;
+   if ( CDeSimpleConeFrustum( frFrame, dMinRad + dDeltaR, dMaxRad + dDeltaR, dHeight, bPrecise))
+      return true ;
   // Cilindro sotto
    frFrame = frMyCone ; frFrame.Translate( - dSafeDist * frFrame.VersZ()) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dMinRad, 2 * dSafeDist, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dMinRad, 2 * dSafeDist, bPrecise))
+      return true ;
   // Cilindro sopra
    frFrame.Translate( dHeight * frFrame.VersZ()) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dMaxRad, 2 * dSafeDist, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dMaxRad, 2 * dSafeDist, bPrecise))
+      return true ;
   // Toro sotto
    frFrame = frMyCone ;
-   if ( ! AvoidSimpleTorus( frFrame, dMinRad, dSafeDist, bPrecise))
-      return false ;
+   if ( CDeSimpleTorus( frFrame, dMinRad, dSafeDist, bPrecise))
+      return true ;
   // Toro sopra
    frFrame.Translate( dHeight * frFrame.VersZ()) ;
-   if ( ! AvoidSimpleTorus( frFrame, dMaxRad, dSafeDist, bPrecise))
-      return false ;
+   if ( CDeSimpleTorus( frFrame, dMaxRad, dSafeDist, bPrecise))
+      return true ;
 
-   return true ;
+   return false ;
 }
 
 //----------------------------------------------------------------------------
@@ -1380,8 +1396,8 @@ RectPrismoidSegmentCollisionPlus( const Frame3d& frPrismoid, double dLenghtBaseX
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AvoidSimpleRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
-                                  double dLenghtTopX, double dLenghtTopY, double dHeight, bool bPrecise) const
+VolZmap::CDeSimpleRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
+                                double dLenghtTopX, double dLenghtTopY, double dHeight, bool bPrecise) const
 {
   // Box del tronco di prismoide nel suo sistema locale
    double dMaxLenX = max( dLenghtBaseX, dLenghtTopX) ;
@@ -1398,7 +1414,7 @@ VolZmap::AvoidSimpleRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX
 
    // Se i box non interferiscono, posso uscire
    if ( ! b3Zmap.Overlaps( b3PrismI)  ||  ! b3Zmap.Overlaps( frPrismInt, b3PrismL))
-      return true ;
+      return false ;
 
   // BBox del tronco di prismoide ottimizzato nel riferimento intrinseco dello Zmap
    Point3d ptMyCen = frPrismInt.Orig() ;
@@ -1418,7 +1434,7 @@ VolZmap::AvoidSimpleRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX
   // Se i box non interferiscono, posso uscire
    BBox3d b3Int ;
    if ( ! b3Zmap.FindIntersection( b3Prism, b3Int))
-      return true ;
+      return false ;
 
   // Se verifico solo prima mappa
    if ( ! bPrecise  ||  m_nMapNum == 1) {
@@ -1456,7 +1472,7 @@ VolZmap::AvoidSimpleRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX
                                                       dHeight, ptSegSt, ptSegEn, dStU, dEnU)) {       
                   for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 1) {
                      if ( m_Values[0][nPos][nIndex].dMax >= dStU  &&  m_Values[0][nPos][nIndex].dMin <= dEnU)
-                        return false ;
+                        return true ;
                   }
                }
             }
@@ -1523,30 +1539,30 @@ VolZmap::AvoidSimpleRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX
                                                    dHeight, ptSegSt, ptSegEn, dStU, dEnU)) {
                for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 1) {
                   if ( m_Values[nMap][nDex][nIndex].dMax >= dStU  &&  m_Values[nMap][nDex][nIndex].dMin <= dEnU)
-                     return false ;
+                     return true ;
                }
             }
          }
       }
    }
-   return true ;
+   return false ;
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AvoidRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
-                            double dLenghtTopX, double dLenghtTopY, double dHeight,
-                            double dSafeDist, bool bPrecise) const
+VolZmap::CDeRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
+                          double dLenghtTopX, double dLenghtTopY, double dHeight,
+                          double dSafeDist, bool bPrecise) const
 {
   // Se il tronco di piramide non è ben definito non procedo
    if ( max( dLenghtBaseX, dLenghtTopX) < EPS_SMALL  ||
         max( dLenghtBaseY, dLenghtTopY) < EPS_SMALL  ||
         dHeight < EPS_SMALL)
-      return false ;
+      return true ;
 
   // Se distanza di sicurezza nulla
    if ( dSafeDist < EPS_SMALL)
-      return AvoidSimpleRectPrismoid( frPrismoid, dLenghtBaseX, dLenghtBaseY, dLenghtTopX, dLenghtTopY, dHeight, bPrecise) ;
+      return CDeSimpleRectPrismoid( frPrismoid, dLenghtBaseX, dLenghtBaseY, dLenghtTopX, dLenghtTopY, dHeight, bPrecise) ;
 
   // Verifica preliminare con offset esteso
    double dHDiffX = ( dLenghtBaseX - dLenghtTopX) / 2 ;
@@ -1560,9 +1576,9 @@ VolZmap::AvoidRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, doub
    double dOffsBaseY = dSafeDist * ( dSecAy + dTgAy) ;
    double dOffsTopY = dSafeDist * ( dSecAy - dTgAy) ;
    Frame3d frFrame = frPrismoid ; frFrame.Translate( -dSafeDist * frFrame.VersZ()) ;
-   if ( AvoidSimpleRectPrismoid( frFrame, dLenghtBaseX + 2 * dOffsBaseX, dLenghtBaseY + 2 * dOffsBaseY,
+   if ( ! CDeSimpleRectPrismoid( frFrame, dLenghtBaseX + 2 * dOffsBaseX, dLenghtBaseY + 2 * dOffsBaseY,
                                  dLenghtTopX + 2 * dOffsTopX, dLenghtTopY + 2 * dOffsTopY, dHeight + 2 * dSafeDist, bPrecise))
-      return true ;
+      return false ;
 
   // Offset fine
   // Sfere centrate nei vertici
@@ -1580,85 +1596,85 @@ VolZmap::AvoidRectPrismoid( const Frame3d& frPrismoid, double dLenghtBaseX, doub
                        Point3d( -dHalfTopX, dHalfTopY, dHeight)} ;
    for ( auto& ptV : vVert) {
       ptV.ToGlob( frPrismoid) ;
-      if ( ! AvoidSimpleSphere( ptV, dSafeDist, bPrecise))
-         return false ;
+      if ( CDeSimpleSphere( ptV, dSafeDist, bPrecise))
+         return true ;
    }
    // Cilindri con i segmenti come asse
    frFrame.Set( vVert[0], frPrismoid.VersX()) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dSafeDist, dLenghtBaseX, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dSafeDist, dLenghtBaseX, bPrecise))
+      return true ;
    frFrame.Set( vVert[1], frPrismoid.VersY()) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dSafeDist, dLenghtBaseY, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dSafeDist, dLenghtBaseY, bPrecise))
+      return true ;
    frFrame.Set( vVert[2], -frPrismoid.VersX()) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dSafeDist, dLenghtBaseX, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dSafeDist, dLenghtBaseX, bPrecise))
+      return true ;
    frFrame.Set( vVert[3], -frPrismoid.VersY()) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dSafeDist, dLenghtBaseY, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dSafeDist, dLenghtBaseY, bPrecise))
+      return true ;
    frFrame.Set( vVert[4], frPrismoid.VersX()) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dSafeDist, dLenghtTopX, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dSafeDist, dLenghtTopX, bPrecise))
+      return true ;
    frFrame.Set( vVert[5], frPrismoid.VersY()) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dSafeDist, dLenghtTopY, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dSafeDist, dLenghtTopY, bPrecise))
+      return true ;
    frFrame.Set( vVert[6], -frPrismoid.VersX()) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dSafeDist, dLenghtTopX, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dSafeDist, dLenghtTopX, bPrecise))
+      return true ;
    frFrame.Set( vVert[7], -frPrismoid.VersY()) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dSafeDist, dLenghtTopY, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dSafeDist, dLenghtTopY, bPrecise))
+      return true ;
    Vector3d vtSeg04 = vVert[4] - vVert[0] ;
    double dLenSeg04 = vtSeg04.Len() ;
    frFrame.Set( vVert[0], vtSeg04) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dSafeDist, dLenSeg04, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dSafeDist, dLenSeg04, bPrecise))
+      return true ;
    Vector3d vtSeg15 = vVert[5] - vVert[1] ;
    double dLenSeg15 = vtSeg15.Len() ;
    frFrame.Set( vVert[1], vtSeg15) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dSafeDist, dLenSeg15, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dSafeDist, dLenSeg15, bPrecise))
+      return true ;
    Vector3d vtSeg26 = vVert[6] - vVert[2] ;
    double dLenSeg26 = vtSeg26.Len() ;
    frFrame.Set( vVert[2], vtSeg26) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dSafeDist, dLenSeg26, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dSafeDist, dLenSeg26, bPrecise))
+      return true ;
    Vector3d vtSeg37 = vVert[7] - vVert[3] ;
    double dLenSeg37 = vtSeg37.Len();
    frFrame.Set( vVert[3], vtSeg37) ;
-   if ( ! AvoidSimpleCylinder( frFrame, dSafeDist, dLenSeg37, bPrecise))
-      return false ;
+   if ( CDeSimpleCylinder( frFrame, dSafeDist, dLenSeg37, bPrecise))
+      return true ;
   // Box sotto
    frFrame = frPrismoid ; frFrame.Translate( -dSafeDist * frFrame.VersZ()) ;
-   if ( ! AvoidSimpleBox( frFrame, Vector3d( dLenghtBaseX, dLenghtBaseY, dSafeDist), bPrecise))
-      return false ;
+   if ( CDeSimpleBox( frFrame, Vector3d( dLenghtBaseX, dLenghtBaseY, dSafeDist), bPrecise))
+      return true ;
   // Box sopra
    frFrame = frPrismoid ; frFrame.Translate( dHeight * frFrame.VersZ()) ;
-   if ( ! AvoidSimpleBox( frFrame, Vector3d( dLenghtBaseX, dLenghtBaseY, dSafeDist), bPrecise))
-      return false ;
+   if ( CDeSimpleBox( frFrame, Vector3d( dLenghtBaseX, dLenghtBaseY, dSafeDist), bPrecise))
+      return true ;
   // Prismoide allungato in X
    double dHypoX = sqrt( dHDiffX * dHDiffX + dHeight * dHeight) ;
    double dOffsX = dSafeDist * dHeight / dHypoX ;
    double dMoveXZ = dSafeDist * dHDiffX / dHypoX ;
    frFrame = frPrismoid ; frFrame.Translate( dMoveXZ * frFrame.VersZ()) ;
-   if ( ! AvoidSimpleRectPrismoid( frFrame, dLenghtBaseX + 2 * dOffsX, dLenghtBaseY,
+   if ( CDeSimpleRectPrismoid( frFrame, dLenghtBaseX + 2 * dOffsX, dLenghtBaseY,
                                    dLenghtTopX + 2 * dOffsX, dLenghtTopY, dHeight, bPrecise))
-      return false ;
+      return true ;
   // Prismoide allungato in Y
    double dHypoY = sqrt( dHDiffY * dHDiffY + dHeight * dHeight) ;
    double dOffsY = dSafeDist * dHeight / dHypoY ;
    double dMoveYZ = dSafeDist * dHDiffY / dHypoY ;
    frFrame = frPrismoid ; frFrame.Translate( dMoveYZ * frFrame.VersZ()) ;
-   if ( ! AvoidSimpleRectPrismoid( frFrame, dLenghtBaseX, dLenghtBaseY + 2 * dOffsY,
+   if ( CDeSimpleRectPrismoid( frFrame, dLenghtBaseX, dLenghtBaseY + 2 * dOffsY,
                                    dLenghtTopX, dLenghtTopY + 2 * dOffsY, dHeight, bPrecise))
-      return false ;
+      return true ;
 
-   return true ;
+   return false ;
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AvoidSimpleTorus( const Frame3d& frTorus, double dMaxRad, double dMinRad, bool bPrecise) const
+VolZmap::CDeSimpleTorus( const Frame3d& frTorus, double dMaxRad, double dMinRad, bool bPrecise) const
 {
   // BBox del toro in locale
    BBox3d b3TorusL( Point3d( -dMaxRad - dMinRad, -dMaxRad - dMinRad, -dMinRad),
@@ -1673,7 +1689,7 @@ VolZmap::AvoidSimpleTorus( const Frame3d& frTorus, double dMaxRad, double dMinRa
 
   // Se non interferiscono, posso uscire
    if ( ! b3Zmap.Overlaps( b3TorusI)  ||  ! b3Zmap.Overlaps( frTorusInt, b3TorusL))
-      return true ;
+      return false ;
 
   // BBox del toro ottimizzato nel riferimento intrinseco dello Zmap
    Point3d ptMyCen = frTorusInt.Orig() ;
@@ -1698,7 +1714,7 @@ VolZmap::AvoidSimpleTorus( const Frame3d& frTorus, double dMaxRad, double dMinRa
   // Se non interferiscono, posso uscire
    BBox3d b3Int ;
    if ( ! b3Zmap.FindIntersection( b3Torus, b3Int))
-      return true ;
+      return false ;
 
   // Se verifico solo prima mappa
    if ( ! bPrecise  ||  m_nMapNum == 1) {
@@ -1736,13 +1752,13 @@ VolZmap::AvoidSimpleTorus( const Frame3d& frTorus, double dMaxRad, double dMinRa
                int nIntType = SegmentTorus( ptSegSt, Z_AX, dParMax - dParMin, ptMyCen, vtMyAx, dMinRad, dMaxRad,
                                             vbType, vdPar) ;
                if ( nIntType == LinCompTorusIntersType::T_ERROR)
-                  return false ;
+                  return true ;
                else if ( nIntType != LinCompTorusIntersType::T_NO_INT) {
                   double dUmin = vdPar.front() ;
                   double dUmax = vdPar.back() ;
                   for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 1) {
                      if ( m_Values[0][nPos][nIndex].dMax >= dUmin  &&  m_Values[0][nPos][nIndex].dMin <= dUmax)
-                        return false ;
+                        return true ;
                   }
                }
             }
@@ -1810,31 +1826,31 @@ VolZmap::AvoidSimpleTorus( const Frame3d& frTorus, double dMaxRad, double dMinRa
             int nIntType = SegmentTorus( ptSegSt, vtLineDir, dParMax - dParMin, ptMyCen, vtMyAx, dMinRad, dMaxRad,
                                          vbType, vdPar) ;
             if ( nIntType == LinCompTorusIntersType::T_ERROR)
-               return false ;
+               return true ;
             else if ( nIntType != LinCompTorusIntersType::T_NO_INT) {
                double dUmin = vdPar.front() ;
                double dUmax = vdPar.back() ;
                for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 1) {
                   if ( m_Values[nMap][nDex][nIndex].dMax >= dUmin  &&  m_Values[nMap][nDex][nIndex].dMin <= dUmax)
-                     return false ;
+                     return true ;
                }
             }
          }
       }
    }
-   return true ;
+   return false ;
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AvoidTorus( const Frame3d& frTorus, double dMaxRad, double dMinRad,
+VolZmap::CDeTorus( const Frame3d& frTorus, double dMaxRad, double dMinRad,
                      double dSafeDist, bool bPrecise) const
 {
   // I raggi devono essere non nulli
    if ( dMaxRad < EPS_SMALL  ||  dMinRad < EPS_SMALL)
       return true ;
 
-   return AvoidSimpleTorus( frTorus, dMaxRad, dMinRad + max( 0., dSafeDist), bPrecise) ;
+   return CDeSimpleTorus( frTorus, dMaxRad, dMinRad + max( 0., dSafeDist), bPrecise) ;
 }
 
 //----------------------------------------------------------------------------
@@ -1844,12 +1860,13 @@ VolZmap::AvoidTorus( const Frame3d& frTorus, double dMaxRad, double dMinRad,
 // quelli di intersezione segmento triangolo vengono eseguiti nel sistema locale. Questo perché
 // è più veloce trasformare le coordinate degli estremi del segmento piuttosto che quelle del
 // triangolo.
+//----------------------------------------------------------------------------
 bool
-VolZmap::AvoidSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecise) const
+VolZmap::CDeSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecise) const
 {
-  // Controllo sulla validità della superficie ed eventualmente sulla sua chiusura
-   if ( ! ( tmSurf.IsValid()  &&  tmSurf.IsClosed()))
-      return false ;
+  // Controllo sulla validità della superficie e sulla sua chiusura
+   if ( ! tmSurf.IsValid()  ||  ! tmSurf.IsClosed())
+      return true ;
   // Bounding box della superficie espresso nel sistema locale
    BBox3d b3SurfBox ;
    tmSurf.GetLocalBBox( b3SurfBox) ;
@@ -1862,7 +1879,7 @@ VolZmap::AvoidSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecis
   // Box intersezione: se non c'è intersezione ho finito.
    BBox3d b3IntBox ;
    if ( ! b3ZmapBox.FindIntersection( b3SurfBox, b3IntBox))
-      return true ;
+      return false ;
   // Recupero i triangoli della superficie che cadono nel box intersezione.
    INTVECTOR vTriaIndex ;
    tmSurf.GetAllTriaOverlapBox( b3IntBox, vTriaIndex) ;
@@ -1923,7 +1940,7 @@ VolZmap::AvoidSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecis
                            for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 1) {
                               if ( dZmax > m_Values[0][nPos][nIndex].dMin - EPS_SMALL  &&
                                    dZmin < m_Values[0][nPos][nIndex].dMax + EPS_SMALL)
-                                 return false ;
+                                 return true ;
                            }
                         }
                      }
@@ -1939,7 +1956,7 @@ VolZmap::AvoidSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecis
                      for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 1) {
                         if ( dZmax > m_Values[0][nPos][nIndex].dMin - EPS_SMALL  &&
                              dZmin < m_Values[0][nPos][nIndex].dMax + EPS_SMALL)
-                           return false ;
+                           return true ;
                      }
                   }
                }
@@ -2030,11 +2047,11 @@ VolZmap::AvoidSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecis
                         double dU1, dU2 ;
                         int nIntersType = SegmentSphere( ptSegSt, vtLineDir, dSegLen, ptVertP, dSafeDist, dU1, dU2) ;
                         if ( nIntersType != LinCompSphereIntersType::S_NO_INTERS)
-                           return false ;
+                           return true ;
                         nIntersType = IntersSegmentCylinder( ptSegSt, vtLineDir, dSegLen, ptVertP, vtEdgeV,
                            dSafeDist, dEdgeLen, dU1, dU2) ;
                         if ( nIntersType != LinCompCCIntersType::CC_NO_INTERS)
-                           return false ;
+                           return true ;
                      }
                     // Traslo il triangolo.
                      trNewTria.Translate( dSafeDist * trTria.GetN()) ;
@@ -2044,14 +2061,14 @@ VolZmap::AvoidSurfTm( const ISurfTriMesh& tmSurf, double dSafeDist, bool bPrecis
                   int nIntersType = IntersLineTria( ptSegSt, vtLineDir, dSegLen, trNewTria, ptInt, ptInt2) ;
                  // Collisione
                   if ( nIntersType != IntLineTriaType::ILTT_NO)
-                     return false ;
+                     return true ;
                }
             }
          }
       }
    }
 
-   return true ;
+   return false ;
 }
 
 //----------------------------------------------------------------------------