diff --git a/CurveArc.cpp b/CurveArc.cpp
index 4aa77c4..3a8fb19 100644
--- a/CurveArc.cpp
+++ b/CurveArc.cpp
@@ -86,6 +86,51 @@ CurveArc::Set( const Point3d& ptCen, const Vector3d& vtN, double dRad,
    return Validate() ;
 }
 
+//----------------------------------------------------------------------------
+// Set per arco di circonf. definito dagli estremi, versore normale e bulge
+//----------------------------------------------------------------------------
+bool
+CurveArc::Set( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& vtN, double dBulge)
+{
+  // versore normale
+   m_VtN = vtN ;
+   if ( ! m_VtN.Normalize())
+      return false ;
+  // vettore da inizio a fine
+   Vector3d vtDiff = ptFin - ptIni ;
+   if ( vtDiff.IsSmall())
+      return false ;
+  // deltaN eventuale ( è componente parallela a VtN)
+   m_dDeltaN = vtDiff * m_VtN ;
+   if ( fabs( m_dDeltaN) > EPS_SMALL)
+      vtDiff -= m_dDeltaN * m_VtN ;
+   else
+      m_dDeltaN = 0 ;
+  // verifico sia un arco (uso la lunghezza della saetta)
+   double dDist = vtDiff.Len() ;
+   if ( fabs( dBulge * 0.5 * dDist) < EPS_SMALL)
+      return false ;
+  // calcolo del centro
+   Vector3d vtOrtho = vtDiff ;
+   // ruoto di +90 deg attorno a vtN (la moltiplica successiva tiene conto del segno di bulge)
+   vtOrtho.Rotate( m_VtN, 0, 1) ;
+   vtOrtho *= ( 1 - dBulge * dBulge) / ( 4 * dBulge) ;
+   m_PtCen = ptIni + 0.5 * vtDiff + vtOrtho ; 
+  // calcolo il raggio
+   m_dRad = fabs( dDist * ( 1 + dBulge * dBulge) / ( 4 * dBulge)) ;
+  // calcolo il versore iniziale
+   m_VtS = ptIni - m_PtCen ;
+   m_VtS.Normalize() ;
+  // calcolo l'angolo al centro
+   m_dAngCenDeg = 4 * atan( dBulge) * RADTODEG ;
+
+  // imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+
+   m_nStatus = TO_VERIFY ;
+   return Validate() ;
+}
+
 //----------------------------------------------------------------------------
 // Set per arco di circonferenza nel piano XY
 //----------------------------------------------------------------------------
@@ -107,6 +152,30 @@ CurveArc::Set( const Point3d& ptCen, double dRad, double dAngIniDeg, double dAng
    return Validate() ;
 }
 
+//----------------------------------------------------------------------------
+// Set per circonferenza completa
+//----------------------------------------------------------------------------
+bool
+CurveArc::Set( const Point3d& ptCen, const Vector3d& vtN, double dRad)
+{
+  // assegno e calcolo i dati
+   m_PtCen = ptCen ;
+   m_VtN = vtN ;
+   Frame3d frF ;
+   if ( ! frF.Set( ORIG, vtN))
+      return false ;
+   m_VtS = frF.VersX() ;
+   m_dRad = dRad ;
+   m_dAngCenDeg = 360 ;
+   m_dDeltaN = 0 ;
+   m_nStatus = TO_VERIFY ;
+
+  // imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+
+   return Validate() ;
+}
+
 //----------------------------------------------------------------------------
 // Set per circonferenza completa nel piano XY
 //----------------------------------------------------------------------------
@@ -184,12 +253,12 @@ bool
 CurveArc::Dump( string& sOut, const char* szNewLine) const
 {
   // parametri : punti iniziale e finale
-   sOut += "C(" + ToString( m_PtCen) + ") " ;
-   sOut += "VN(" + ToString( m_VtN) + ") " ;
-   sOut += "R=" + ToString( m_dRad) + szNewLine ;
-   sOut += "VS(" + ToString( m_VtS) + ") " ;
-   sOut += "Ac=" + ToString( m_dAngCenDeg) + " " ;
-   sOut += "Dn=" + ToString( m_dDeltaN) + szNewLine ;
+   sOut += "C(" + ToString( m_PtCen, 3) + ") " ;
+   sOut += "VN(" + ToString( m_VtN, 6) + ") " ;
+   sOut += "R=" + ToString( m_dRad, 3) + szNewLine ;
+   sOut += "VS(" + ToString( m_VtS, 6) + ") " ;
+   sOut += "Ac=" + ToString( m_dAngCenDeg, 3) + " " ;
+   sOut += "Dn=" + ToString( m_dDeltaN, 3) + szNewLine ;
 
    return true ;
 }
diff --git a/CurveArc.h b/CurveArc.h
index a0b0736..b5dd953 100644
--- a/CurveArc.h
+++ b/CurveArc.h
@@ -75,7 +75,9 @@ class CurveArc : public ICurveArc, public IGeoObjRW
       virtual bool Copy( const IGeoObj* pGObjSrc) ;
       virtual bool Set( const Point3d& ptCen, const Vector3d& vtN, double dRad,
                         const Vector3d& vtS, double dAngCenDeg, double dDeltaN) ;
+      virtual bool Set( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& vtN, double dBulge) ;
       virtual bool Set( const Point3d& ptCen, double dRad, double dAngIniDeg, double dAngCenDeg, double dDeltaZ) ;
+      virtual bool Set( const Point3d& ptCen, const Vector3d& vtN, double dRad) ;
       virtual bool Set( const Point3d& ptCen, double dRad) ;
       virtual bool IsFlat( void) const
                         { return ( fabs( m_dDeltaN) < EPS_SMALL) ; }
diff --git a/CurveBezier.cpp b/CurveBezier.cpp
index 67b2368..1e00eff 100644
--- a/CurveBezier.cpp
+++ b/CurveBezier.cpp
@@ -330,9 +330,9 @@ CurveBezier::Dump( string& sOut, const char* szNewLine) const
    sOut += "Deg=" + ToString( m_nDeg) + szNewLine ;
   // ciclo sui punti di controllo ( con pesi se razionale)
    for ( int i = 0 ; i <= m_nDeg ; ++ i) {
-      sOut += "PC(" + ToString( m_aPtCtrl[i]) ;
+      sOut += "PC(" + ToString( m_aPtCtrl[i], 3) ;
       if ( m_bRat)
-         sOut += "," + ToString( m_aWeCtrl[i]) ;
+         sOut += "," + ToString( m_aWeCtrl[i], 3) ;
       sOut += string( ")") + szNewLine ;
    }
 
diff --git a/CurveComposite.cpp b/CurveComposite.cpp
index 75b3195..17dea4c 100644
--- a/CurveComposite.cpp
+++ b/CurveComposite.cpp
@@ -109,6 +109,43 @@ CurveComposite::AddCurve( const ICurve& cCrv)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+CurveComposite::AddCurve( ICurve* pCrv)
+{
+  // se curva semplice
+   if ( pCrv->IsSimple()) {
+     // inserisco la curva
+      if ( ! AddSimpleCurve( pCrv)) {
+         delete pCrv ;
+         return false ;
+      }
+   }
+  // altrimenti curva composta, devo aggiungere le singole curve semplici
+   else {
+     // puntatore alla curva composita originaria
+      CurveComposite* pCrvCompo = dynamic_cast<CurveComposite*>( pCrv) ;
+      if ( pCrvCompo == nullptr)
+         return false ;
+     // recupero le curve componenti e le inserisco nella lista
+      ICurve* pSmplCrv ;
+      while ( ( pSmplCrv = pCrvCompo->RemoveFirstCurve()) != nullptr) {
+        // inserisco la curva
+         if ( ! AddSimpleCurve( pSmplCrv)) {
+            delete pSmplCrv ;
+            return false ;
+         }
+      }
+     // cancello la curva composita originaria
+      delete pCrvCompo ;
+   }
+
+  // imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 CurveComposite::AddSimpleCurve( ICurve* pSmplCrv)
@@ -256,8 +293,10 @@ CurveComposite::GetTitle( void) const
 bool
 CurveComposite::Dump( string& sOut, const char* szNewLine) const
 {
+  // se curva aperta o chiusa
+   sOut += ( IsClosed() ? "Closed" : "Open") ;
   // numero di curve
-   sOut += "Num=" + ToString( m_nCounter) + szNewLine ;
+   sOut += " CrvNbr=" + ToString( m_nCounter) + szNewLine ;
   // ciclo sulle curve componenti
    int i = 0 ;
    const ICurve* pCrvSmpl = GetFirstCurve() ;
@@ -1016,6 +1055,24 @@ CurveComposite::GetNextCurve( void) const
       return nullptr ;
 }
 
+//----------------------------------------------------------------------------
+ICurve*
+CurveComposite::RemoveFirstCurve( void)
+{
+  // la curva composita deve essere validata
+   if ( m_nStatus != OK)
+      return nullptr ;
+
+  // recupero la curva semplice iniziale e la tolgo dalla lista
+   if ( ! m_CrvSmplS.empty()) {
+      ICurve* pCrv = *(m_CrvSmplS.begin()) ;
+      m_CrvSmplS.pop_front() ;
+      return pCrv ;
+   }
+   else
+      return nullptr ;
+}
+
 //----------------------------------------------------------------------------
 bool
 CurveComposite::IsParamAtJoint( double dU) const
diff --git a/CurveComposite.h b/CurveComposite.h
index 3931b94..6333f92 100644
--- a/CurveComposite.h
+++ b/CurveComposite.h
@@ -75,6 +75,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       virtual bool Copy( const IGeoObj* pGObjSrc) ;
       virtual bool Clear( void) ;
       virtual bool AddCurve( const ICurve& cCrv) ;
+      virtual bool AddCurve( ICurve* pCrv) ;
       virtual bool FromSplit( const ICurve& cCrv, int nParts) ;
       virtual int   GetCurveNumber( void) const { return m_nCounter ; }
       virtual const ICurve* GetFirstCurve( void) const ;
@@ -98,6 +99,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool Copy( const CurveComposite& ccSrc) ;
       bool Validate( void) ;
       bool AddSimpleCurve( ICurve* pSmplCrv) ;
+      ICurve* RemoveFirstCurve( void) ;
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
diff --git a/CurveLine.cpp b/CurveLine.cpp
index bd9e0a0..1779fb6 100644
--- a/CurveLine.cpp
+++ b/CurveLine.cpp
@@ -106,8 +106,8 @@ bool
 CurveLine::Dump( string& sOut, const char* szNewLine) const
 {
   // parametri : punti iniziale e finale
-   sOut += "P1(" + ToString( m_PtStart) + ")" + szNewLine ;
-   sOut += "P2(" + ToString( m_PtEnd) + ")" + szNewLine ;
+   sOut += "P1(" + ToString( m_PtStart, 3) + ")" + szNewLine ;
+   sOut += "P2(" + ToString( m_PtEnd, 3) + ")" + szNewLine ;
 
    return true ;
 }
diff --git a/Frame3d.cpp b/Frame3d.cpp
index b57978a..3d9c34a 100644
--- a/Frame3d.cpp
+++ b/Frame3d.cpp
@@ -96,7 +96,7 @@ Frame3d::Set( const Point3d& ptOrig, const Vector3d& vtDirZ)
    if ( ! m_vtVersZ.Normalize())
       return false ;
   // versore X (metodo OCS di DXF)
-   if ( fabs( m_vtVersZ.x) < 1/64  &&  fabs( m_vtVersZ.y) < 1/64)
+   if ( fabs( m_vtVersZ.x) < 1./64.  &&  fabs( m_vtVersZ.y) < 1./64.)
       m_vtVersX = Y_AX ^ m_vtVersZ ;
    else
       m_vtVersX = Z_AX ^ m_vtVersZ ;
diff --git a/GdbExecutor.cpp b/GdbExecutor.cpp
index 5a1dbc9..3e74b4d 100644
--- a/GdbExecutor.cpp
+++ b/GdbExecutor.cpp
@@ -956,16 +956,31 @@ GdbExecutor::GetVectorParam( const std::string& sParam, Vector3d& vtV)
       vtV = X_AX ;
       return true ;
    }
+  // se altrimenti vettore predefinito -X_AX
+   else if ( sParam == "-X_AX") {
+      vtV = - X_AX ;
+      return true ;
+   }
   // se altrimenti vettore predefinito Y_AX
    else if ( sParam == "Y_AX") {
       vtV = Y_AX ;
       return true ;
    }
+  // se altrimenti vettore predefinito -Y_AX
+   else if ( sParam == "-Y_AX") {
+      vtV = - Y_AX ;
+      return true ;
+   }
   // se altrimenti vettore predefinito Z_AX
    else if ( sParam == "Z_AX") {
       vtV = Z_AX ;
       return true ;
    }
+  // se altrimenti vettore predefinito -Z_AX
+   else if ( sParam == "-Z_AX") {
+      vtV = - Z_AX ;
+      return true ;
+   }
   // altrimenti nome di vettore già nel DB
    else {
       const IGeoVector3d* pV ;
diff --git a/SurfTriMesh.cpp b/SurfTriMesh.cpp
index 13e19ce..bf96213 100644
--- a/SurfTriMesh.cpp
+++ b/SurfTriMesh.cpp
@@ -71,7 +71,7 @@ SurfTriMesh::AddVertex( const Point3d& ptVert)
    m_OGrMgr.Reset() ;
   // inserisco il vertice
    try { m_vVert.push_back( StmVert( ptVert)) ;}
-   catch(...) { return VT_NULL ;}
+   catch(...) { return SVT_NULL ;}
   // ne determino l'indice
    return int( m_vVert.size() - 1) ;
 }
@@ -94,7 +94,7 @@ SurfTriMesh::SetVertex( int nInd, const StmVert& vV)
       catch (...) { return false ; }
      // inizializzo a cancellati gli eventuali vertici intermedi
       if ( ( nNewSize - nPrevSize) > 1) {
-         StmVert vEmpty( Point3d(), VT_DEL, 0) ;
+         StmVert vEmpty( Point3d(), SVT_DEL, 0) ;
          for ( int i = nPrevSize ; i < nNewSize ; ++ i)
             m_vVert[i] = vEmpty ;
       }
@@ -108,12 +108,17 @@ SurfTriMesh::SetVertex( int nInd, const StmVert& vV)
 int
 SurfTriMesh::AddTriangle( const int nIdVert[3])
 {
+  // verifico che i tre indici diano diversi
+   if ( nIdVert[0] == nIdVert[1]  ||
+        nIdVert[1] == nIdVert[2]  ||
+        nIdVert[2] == nIdVert[0])
+      return SVT_DEL ;
   // imposto ricalcolo
    m_nStatus = TO_VERIFY ;
    m_OGrMgr.Reset() ;
   // inserisco il triangolo
    try { m_vTria.push_back( StmTria( nIdVert)) ;}
-   catch(...) { return VT_NULL ;}
+   catch(...) { return SVT_NULL ;}
   // ne determino l'indice
    return int( m_vTria.size() - 1) ;
 }
@@ -137,7 +142,7 @@ SurfTriMesh::SetTriangle( int nInd, const StmTria& tT)
      // inizializzo a cancellati gli eventuali triangoli intermedi
       if ( ( nNewSize - nPrevSize) > 1) {
          StmTria tEmpty ;
-         tEmpty.nIdVert[0] = VT_DEL ;
+         tEmpty.nIdVert[0] = SVT_DEL ;
          for ( int i = nPrevSize ; i < nNewSize ; ++ i)
             m_vTria[i] = tEmpty ;
       }
@@ -151,7 +156,7 @@ SurfTriMesh::SetTriangle( int nInd, const StmTria& tT)
 int
 SurfTriMesh::GetFirstVertex( Point3d& ptP) const 
 {
-   return GetNextVertex( VT_NULL, ptP) ;  
+   return GetNextVertex( SVT_NULL, ptP) ;  
 }
 
 //----------------------------------------------------------------------------
@@ -161,10 +166,10 @@ SurfTriMesh::GetNextVertex( int nId, Point3d& ptP) const
   // cerco il primo successivo valido
    do {
      nId ++ ;
-   } while ( nId < GetVertexNum()  &&  m_vVert[nId].nIdTria == VT_DEL) ;
+   } while ( nId < GetVertexNum()  &&  m_vVert[nId].nIdTria == SVT_DEL) ;
   // se oltrepassata fine
    if ( nId >= GetVertexNum())
-      return VT_NULL ;
+      return SVT_NULL ;
   // recupero i dati
    ptP = m_vVert[nId].ptP ;
   // ritorno indice triangolo corrente
@@ -175,7 +180,7 @@ SurfTriMesh::GetNextVertex( int nId, Point3d& ptP) const
 int
 SurfTriMesh::GetFirstTriangle( Triangle3d& Tria) const 
 {
-   return GetNextTriangle( VT_NULL, Tria) ;  
+   return GetNextTriangle( SVT_NULL, Tria) ;  
 }
 
 //----------------------------------------------------------------------------
@@ -185,10 +190,10 @@ SurfTriMesh::GetNextTriangle( int nId, Triangle3d& Tria) const
   // cerco il primo successivo valido
    do {
      nId ++ ;
-   } while ( nId < GetTriangleNum()  &&  m_vTria[nId].nIdVert[0] == VT_DEL) ;
+   } while ( nId < GetTriangleNum()  &&  m_vTria[nId].nIdVert[0] == SVT_DEL) ;
   // se oltrepassata fine
    if ( nId >= GetTriangleNum())
-      return VT_NULL ;
+      return SVT_NULL ;
   // recupero i dati
    Tria.Set( m_vVert[m_vTria[nId].nIdVert[0]].ptP,
              m_vVert[m_vTria[nId].nIdVert[1]].ptP,
@@ -203,7 +208,7 @@ bool
 SurfTriMesh::GetTriangleSmoothNormals( int nId, TriNormals3d& TNrms) const 
 {
   // verifico esistenza del triangolo 
-   if ( nId >= GetTriangleNum()  ||  m_vTria[nId].nIdVert[0] == VT_DEL)
+   if ( nId >= GetTriangleNum()  ||  m_vTria[nId].nIdVert[0] == SVT_DEL)
       return false ;
 
   // recupero le normali di ciascun vertice
@@ -321,9 +326,9 @@ SurfTriMesh::Dump( string& sOut, const char* szNewLine) const
   // se superficie aperta o chiusa
    sOut += ( m_bClosed ? "Closed" : "Open") ;
   // numero di vertici
-   sOut += " NbrVert=" + ToString( GetVertexNum()) ;
+   sOut += " VertNbr=" + ToString( GetVertexNum()) ;
   // numero di triangoli
-   sOut += " NbrTria=" + ToString( GetTriangleNum()) ;
+   sOut += " TriaNbr=" + ToString( GetTriangleNum()) ;
 
    return true ;
 }
@@ -438,10 +443,11 @@ SurfTriMesh::Validate( void)
    m_nStatus = OK ;
    for ( int i = 0 ; i < GetTriangleNum() && m_nStatus == OK ; ++ i) {
      // se triangolo non cancellato
-      if ( m_vTria[i].nIdVert[0] != VT_DEL) {
+      if ( m_vTria[i].nIdVert[0] != SVT_DEL) {
          for ( int j = 0 ; j < 3 && m_nStatus == OK ; ++ j) {
-            if ( m_vTria[i].nIdVert[j] >= GetVertexNum()  ||
-                 m_vVert[ m_vTria[i].nIdVert[j]].nIdTria == VT_DEL)
+            if ( m_vTria[i].nIdVert[j] < 0  ||
+                 m_vTria[i].nIdVert[j] >= GetVertexNum()  ||
+                 m_vVert[ m_vTria[i].nIdVert[j]].nIdTria == SVT_DEL)
                m_nStatus = ERR ;   
          }
         // calcolo eventuali normale mancante
@@ -453,9 +459,10 @@ SurfTriMesh::Validate( void)
   // Verifico che i triangoli riferiti dai vertici esistano
    for ( int i = 0 ; i < GetVertexNum() && m_nStatus == OK ; ++ i) {
      // se vertice non cancellato e con riferimento assegnato
-      if ( m_vVert[i].nIdTria != VT_DEL  &&  m_vVert[i].nIdTria != VT_NULL) {
-         if ( m_vVert[i].nIdTria >= GetTriangleNum()  ||
-              m_vTria[ m_vVert[i].nIdTria].nIdVert[0] == VT_DEL)
+      if ( m_vVert[i].nIdTria != SVT_DEL  &&  m_vVert[i].nIdTria != SVT_NULL) {
+         if ( m_vVert[i].nIdTria < SVT_DEL  ||
+              m_vVert[i].nIdTria >= GetTriangleNum()  ||
+              m_vTria[ m_vVert[i].nIdTria].nIdVert[0] == SVT_DEL)
             m_nStatus = ERR ;   
       }
    }
@@ -488,7 +495,7 @@ SurfTriMesh::GetAllTriaAroundVertex( int nV, INTVECTOR& vT) const
 
   // recupero il triangolo puntato dal vertice
    int nT = m_vVert[nV].nIdTria ;
-   if ( nT == VT_NULL)
+   if ( nT == SVT_NULL)
       return 0 ;
    vT.push_back( nT) ;
 
@@ -499,14 +506,14 @@ SurfTriMesh::GetAllTriaAroundVertex( int nV, INTVECTOR& vT) const
       if ( FindVertexInTria( nV, nTa, k))
          nTa = m_vTria[nTa].nIdAdjac[Prev(k)] ;
       else
-         nTa = VT_NULL ;
+         nTa = SVT_NULL ;
      // per evitare cicli infiniti dovuti a triangoli invertiti
       if ( vT.size() >= 2  &&  nTa == vT[vT.size()-2])
          break ;
      // se valido
-      if ( nTa != nT  &&  nTa != VT_NULL)
+      if ( nTa != nT  &&  nTa != SVT_NULL)
          vT.push_back( nTa) ;
-   } while ( nTa != nT  &&  nTa != VT_NULL  &&  vT.size() < MAX_VT_SIZE) ;
+   } while ( nTa != nT  &&  nTa != SVT_NULL  &&  vT.size() < MAX_VT_SIZE) ;
 
   // se sono ritornato al triangolo di partenza ho fatto un giro e concluso la ricerca
    if ( nTa == nT)
@@ -518,14 +525,14 @@ SurfTriMesh::GetAllTriaAroundVertex( int nV, INTVECTOR& vT) const
       if ( FindVertexInTria( nV, nTa, k))
          nTa = m_vTria[nTa].nIdAdjac[k] ;
       else
-         nTa = VT_NULL ;
+         nTa = SVT_NULL ;
      // per evitare cicli infiniti dovuti a triangoli invertiti
       if ( vT.size() >= 2  &&  nTa == vT[vT.size()-2])
          break ;
      // se valido
-      if ( nTa != nT  &&  nTa != VT_NULL)
+      if ( nTa != nT  &&  nTa != SVT_NULL)
          vT.insert( vT.begin(), nTa) ;
-   } while ( nTa != nT  &&  nTa != VT_NULL  &&  vT.size() < MAX_VT_SIZE) ;
+   } while ( nTa != nT  &&  nTa != SVT_NULL  &&  vT.size() < MAX_VT_SIZE) ;
 
    return int( vT.size()) ;
 }
@@ -537,9 +544,9 @@ SurfTriMesh::AdjustAdjacencies( void)
   // sistemo i puntatori dai vertici ai triangoli
    for ( int i = 0 ; i < GetTriangleNum() ; ++ i) {
      // se triangolo non cancellato
-      if ( m_vTria[i].nIdVert[0] != VT_DEL) {
+      if ( m_vTria[i].nIdVert[0] != SVT_DEL) {
          for ( int j = 0 ; j < 3 ; ++ j) {
-            if ( m_vVert[ m_vTria[i].nIdVert[j]].nIdTria == VT_NULL)
+            if ( m_vVert[ m_vTria[i].nIdVert[j]].nIdTria == SVT_NULL)
                m_vVert[ m_vTria[i].nIdVert[j]].nIdTria = i ;
          }
       }
@@ -551,10 +558,10 @@ SurfTriMesh::AdjustAdjacencies( void)
       bModif = false ;
       for ( int i = 0 ; i < GetTriangleNum() ; ++ i) {
         // se triangolo non cancellato
-         if ( m_vTria[i].nIdVert[0] != VT_DEL) {
+         if ( m_vTria[i].nIdVert[0] != SVT_DEL) {
             for ( int j = 0 ; j < 3 ; ++ j) {
               // se adiacenza non risolta
-               if ( m_vTria[i].nIdAdjac[j] == VT_NULL) {
+               if ( m_vTria[i].nIdAdjac[j] == SVT_NULL) {
                  // vertici all'estremo dello half-edge di indice j
                   int nVi = m_vTria[i].nIdVert[j] ;
                   int nVf = m_vTria[i].nIdVert[Next(j)] ;
@@ -623,7 +630,7 @@ SurfTriMesh::AdjustOrientations( int nLev, bool& bSomeWrong)
      // ciclo sui lati del triangolo
       for ( int j = 0 ; j < 3 ; ++ j) {
         // se non c'è adiacenza
-         if ( m_vTria[i].nIdAdjac[j] == VT_NULL)
+         if ( m_vTria[i].nIdAdjac[j] == SVT_NULL)
             ++ nNull ;
         // la verifico
          else {
@@ -658,9 +665,9 @@ SurfTriMesh::TestClosure( void)
   // ciclo sui triangoli
    bool bClosed = true ;
    for ( int i = 0 ; i < GetTriangleNum() ; ++ i) {
-      if ( m_vTria[i].nIdAdjac[0] == VT_NULL  ||
-           m_vTria[i].nIdAdjac[1] == VT_NULL  ||
-           m_vTria[i].nIdAdjac[2] == VT_NULL)
+      if ( m_vTria[i].nIdAdjac[0] == SVT_NULL  ||
+           m_vTria[i].nIdAdjac[1] == SVT_NULL  ||
+           m_vTria[i].nIdAdjac[2] == SVT_NULL)
          bClosed = false ;
    }
   // aggiorno la chiusura della superficie
@@ -712,7 +719,7 @@ SurfTriMesh::CreateByTriangulation( const PolyLine& PL)
 
   // inserisco i vertici nella superficie
    for ( int i = 0 ; i < int( vPnt.size()) ; ++ i) {
-      if ( AddVertex( vPnt[i]) == VT_NULL)
+      if ( AddVertex( vPnt[i]) == SVT_NULL)
          return false ;
    }
 
@@ -722,7 +729,7 @@ SurfTriMesh::CreateByTriangulation( const PolyLine& PL)
       vV[0] = vTria[3*i] ;
       vV[1] = vTria[3*i+1] ;
       vV[2] = vTria[3*i+2] ;
-      if ( AddTriangle( vV) == VT_NULL)
+      if ( AddTriangle( vV) == SVT_NULL)
          return false ;
    }
 
@@ -753,7 +760,7 @@ SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
    if ( ! PL.GetFirstPoint( ptP))
       return false ;
    ++ nP ;
-   if ( AddVertex( ptP) == VT_NULL  ||  AddVertex( ptP + vtExtr) == VT_NULL)
+   if ( AddVertex( ptP) == SVT_NULL  ||  AddVertex( ptP + vtExtr) == SVT_NULL)
       return false ;
    nV += 2 ;
   // ciclo sui punti della polilinea (per inserire vertice e suo estruso + 2 triangoli per ogni punto)
@@ -764,16 +771,16 @@ SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
      // se polilinea aperta o non è l'ultimo punto
       if ( ! bClosed  ||  nP < nPointNbr) {
         // aggiungo due nuovi vertici
-         if ( AddVertex( ptP) == VT_NULL  ||  AddVertex( ptP + vtExtr) == VT_NULL)
+         if ( AddVertex( ptP) == SVT_NULL  ||  AddVertex( ptP + vtExtr) == SVT_NULL)
             return false ;
          nV += 2 ;
         // aggiungo triangolo in basso a sinistra
          nIdV[0] = nV - 3 ; nIdV[1] = nV - 1 ; nIdV[2] = nV - 2 ;
-         if ( AddTriangle( nIdV) == VT_NULL)
+         if ( AddTriangle( nIdV) == SVT_NULL)
             return false ;
         // aggiungo triangolo in alto a destra
          nIdV[0] = nV - 2 ; nIdV[1] = nV - 1 ; nIdV[2] = nV ;
-         if ( AddTriangle( nIdV) == VT_NULL)
+         if ( AddTriangle( nIdV) == SVT_NULL)
             return false ;
       }
      // altrimenti ultimo punto di polilinea chiusa
@@ -781,11 +788,11 @@ SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
         // non devo aggiungere i vertici, perchè coincidono con quelli iniziali
         // aggiungo triangolo in basso a sinistra
          nIdV[0] = nV - 1 ; nIdV[1] = 0 ; nIdV[2] = nV ;
-         if ( AddTriangle( nIdV) == VT_NULL)
+         if ( AddTriangle( nIdV) == SVT_NULL)
             return false ;
         // aggiungo triangolo in alto a destra
          nIdV[0] = nV ; nIdV[1] = 0 ; nIdV[2] = 1 ;
-         if ( AddTriangle( nIdV) == VT_NULL)
+         if ( AddTriangle( nIdV) == SVT_NULL)
             return false ;
       }
    }
@@ -804,7 +811,7 @@ SurfTriMesh::GetLocalBBox( BBox3d& b3Loc) const
   // assegno il box in locale
    b3Loc.Reset() ;
    for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
-      if ( m_vVert[i].nIdTria != VT_DEL)
+      if ( m_vVert[i].nIdTria != SVT_DEL)
          b3Loc.Add( m_vVert[i].ptP) ;
    }
    return true ;
@@ -823,7 +830,7 @@ SurfTriMesh::GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const
   // assegno il box nel riferimento
    b3Ref.Reset() ;
    for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
-      if ( m_vVert[i].nIdTria != VT_DEL) {
+      if ( m_vVert[i].nIdTria != SVT_DEL) {
          Point3d ptTemp = m_vVert[i].ptP ;
          ptTemp.ToGlob( frRef) ;
          b3Ref.Add( ptTemp) ;
@@ -846,7 +853,7 @@ SurfTriMesh::Translate( const Vector3d& vtMove)
 
   // traslo i vertici
    for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
-      if ( m_vVert[i].nIdTria != VT_DEL)
+      if ( m_vVert[i].nIdTria != SVT_DEL)
          m_vVert[i].ptP.Translate( vtMove) ;
    }
 
@@ -870,13 +877,13 @@ SurfTriMesh::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng,
 
   // ruoto i vertici
    for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
-      if ( m_vVert[i].nIdTria != VT_DEL)
+      if ( m_vVert[i].nIdTria != SVT_DEL)
          m_vVert[i].ptP.Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
    }
 
   // ruoto le normali delle facce
    for ( int i = 0 ; i < GetTriangleNum() ; ++ i) {
-      if ( m_vTria[i].nIdVert[0] != VT_DEL)
+      if ( m_vTria[i].nIdVert[0] != SVT_DEL)
          m_vTria[i].vtN.Rotate( vtAx, dCosAng, dSinAng) ;
    }
 
@@ -905,13 +912,13 @@ SurfTriMesh::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double
 
   // scalo i vertici
    for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
-      if ( m_vVert[i].nIdTria != VT_DEL)
+      if ( m_vVert[i].nIdTria != SVT_DEL)
          m_vVert[i].ptP.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ;
    }
 
   // aggiorno le facce
    for ( int i = 0 ; i < GetTriangleNum() ; ++ i) {
-      if ( m_vTria[i].nIdVert[0] != VT_DEL) {
+      if ( m_vTria[i].nIdVert[0] != SVT_DEL) {
         // se c'è mirror, devo invertire la faccia
          if ( bMirror  &&  ! InvertTriangle( i))
             return false ;
@@ -929,7 +936,7 @@ bool
 SurfTriMesh::InvertTriangle( int nT)
 {
   // controllo validità triangolo
-   if ( m_vTria[nT].nIdVert[0] == VT_DEL)
+   if ( m_vTria[nT].nIdVert[0] == SVT_DEL)
       return false ;
   // scambio di due vertici
    swap( m_vTria[nT].nIdVert[1], m_vTria[nT].nIdVert[2]) ;
@@ -945,15 +952,15 @@ bool
 SurfTriMesh::CalcTriangleNormal( int nT)
 {
   // controllo validità triangolo
-   if ( m_vTria[nT].nIdVert[0] == VT_DEL)
+   if ( m_vTria[nT].nIdVert[0] == SVT_DEL)
       return false ;
   // controllo validità vertici riferiti dal triangolo
    if ( m_vTria[nT].nIdVert[0] >= GetVertexNum()  ||
-        m_vVert[m_vTria[nT].nIdVert[0]].nIdTria == VT_DEL  ||
+        m_vVert[m_vTria[nT].nIdVert[0]].nIdTria == SVT_DEL  ||
         m_vTria[nT].nIdVert[1] >= GetVertexNum()  ||
-        m_vVert[m_vTria[nT].nIdVert[1]].nIdTria == VT_DEL  ||
+        m_vVert[m_vTria[nT].nIdVert[1]].nIdTria == SVT_DEL  ||
         m_vTria[nT].nIdVert[2] >= GetVertexNum()  ||
-        m_vVert[m_vTria[nT].nIdVert[2]].nIdTria == VT_DEL)
+        m_vVert[m_vTria[nT].nIdVert[2]].nIdTria == SVT_DEL)
       return false ;
   // calcolo vettori come due lati consecutivi del triangolo
    Vector3d vtV1 = m_vVert[m_vTria[nT].nIdVert[1]].ptP - m_vVert[m_vTria[nT].nIdVert[0]].ptP ;
@@ -987,7 +994,7 @@ SurfTriMesh::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
 
   // inverto le facce
    for ( int i = 0 ; i < GetTriangleNum() ; ++ i) {
-      if ( m_vTria[i].nIdVert[0] != VT_DEL) {
+      if ( m_vTria[i].nIdVert[0] != SVT_DEL) {
         // inverto la faccia
          if ( ! InvertTriangle( i))
             return false ;
@@ -1014,7 +1021,7 @@ SurfTriMesh::ToGlob( const Frame3d& frRef)
 
   // trasformo i vertici
    for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
-      if ( m_vVert[i].nIdTria != VT_DEL)
+      if ( m_vVert[i].nIdTria != SVT_DEL)
          m_vVert[i].ptP.ToGlob( frRef) ;
    }
 
@@ -1038,7 +1045,7 @@ SurfTriMesh::ToLoc( const Frame3d& frRef)
 
   // trasformo i vertici
    for ( int i = 0 ; i < GetVertexNum() ; ++ i) {
-      if ( m_vVert[i].nIdTria != VT_DEL)
+      if ( m_vVert[i].nIdTria != SVT_DEL)
          m_vVert[i].ptP.ToLoc( frRef) ;
    }
 
diff --git a/SurfTriMesh.h b/SurfTriMesh.h
index b3af72f..fc2ac91 100644
--- a/SurfTriMesh.h
+++ b/SurfTriMesh.h
@@ -19,16 +19,12 @@
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
 #include "/EgtDev/Include/EgtNumCollection.h"
 
-//----------------------------------------------------------------------------
-const int VT_NULL = - 1 ;           // vertice o triangolo nullo
-const int VT_DEL = - 2 ;            // vertice o triangolo cancellato
-
 //----------------------------------------------------------------------------
 class StmVert
 {
    public :
-      StmVert( void) : ptP(), nIdTria( VT_NULL), nFlag( 0) {}
-      StmVert( const Point3d& ptQ) : ptP( ptQ), nIdTria( VT_NULL), nFlag( 0) {}
+      StmVert( void) : ptP(), nIdTria( SVT_NULL), nFlag( 0) {}
+      StmVert( const Point3d& ptQ) : ptP( ptQ), nIdTria( SVT_NULL), nFlag( 0) {}
       StmVert( const Point3d& ptQ, int nIdT, int nF) : ptP( ptQ), nIdTria( nIdT), nFlag( nF) {}
    public :
       Point3d ptP ;
@@ -41,11 +37,11 @@ class StmTria
 {
    public :
       StmTria( void) : vtN(), nTFlag( 0), nEFlag( 0)
-            { nIdVert[0] = VT_NULL ; nIdVert[1] = VT_NULL ; nIdVert[2] = VT_NULL ;
-              nIdAdjac[0] = VT_NULL ; nIdAdjac[1] = VT_NULL ; nIdAdjac[2] = VT_NULL ; }
+            { nIdVert[0] = SVT_NULL ; nIdVert[1] = SVT_NULL ; nIdVert[2] = SVT_NULL ;
+              nIdAdjac[0] = SVT_NULL ; nIdAdjac[1] = SVT_NULL ; nIdAdjac[2] = SVT_NULL ; }
       StmTria( const int nIdV[3]) : vtN(), nTFlag( 0), nEFlag( 0)
             { nIdVert[0] = nIdV[0] ; nIdVert[1] = nIdV[1] ; nIdVert[2] = nIdV[2] ;
-              nIdAdjac[0] = VT_NULL ; nIdAdjac[1] = VT_NULL ; nIdAdjac[2] = VT_NULL ; }
+              nIdAdjac[0] = SVT_NULL ; nIdAdjac[1] = SVT_NULL ; nIdAdjac[2] = SVT_NULL ; }
       StmTria( const int nIdV[3], const int nIdA[3], const Vector3d& vtV, int nTF, int nEF)
             : vtN( vtV), nTFlag( nTF), nEFlag( nEF)
             { nIdVert[0] = nIdV[0] ; nIdVert[1] = nIdV[1] ; nIdVert[2] = nIdV[2] ;