diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc
index 1ab611f..1e89db4 100644
Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ
diff --git a/SurfTriMesh.h b/SurfTriMesh.h
index 5354b21..8b2f1aa 100644
--- a/SurfTriMesh.h
+++ b/SurfTriMesh.h
@@ -100,13 +100,13 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       virtual bool CopyFrom( const IGeoObj* pGObjSrc) ;
       virtual bool Init( int nNumVert, int nNumTria) ;
       virtual void SetLinearTolerance( double dLinTol)
-                      { m_dLinTol = std::max( dLinTol, EPS_SMALL) ; }
+                      { m_dLinTol = (std::max)( dLinTol, EPS_SMALL) ; }
       virtual void SetBoundaryAngle( double dBoundaryAngDeg)
-                      { m_dBoundaryAng = std::max( dBoundaryAngDeg, EPS_ANG_SMALL) ;
+                      { m_dBoundaryAng = (std::max)( dBoundaryAngDeg, EPS_ANG_SMALL) ;
                         m_dCosBndAng = cos( m_dBoundaryAng * DEGTORAD) ;
                         m_OGrMgr.Reset() ; }
       virtual void SetSmoothAngle( double dSmoothAngDeg)
-                      { m_dSmoothAng = std::max( dSmoothAngDeg, EPS_ANG_SMALL) ;
+                      { m_dSmoothAng = (std::max)( dSmoothAngDeg, EPS_ANG_SMALL) ;
                         m_dCosSmAng = cos( m_dSmoothAng * DEGTORAD) ;
                         m_OGrMgr.Reset() ; }
       virtual int  AddVertex( const Point3d& ptVert) ;
diff --git a/Triangulate.cpp b/Triangulate.cpp
index e60c70f..6173cb0 100644
--- a/Triangulate.cpp
+++ b/Triangulate.cpp
@@ -18,10 +18,6 @@
 #include "\EgtDev\Include\EGkPolyLine.h"
 #include "\EgtDev\Include\EGkPlane3d.h"
 
-#include "DllMain.h"
-#include "/EgtDev/Include/EGkStringUtils3d.h"
-#include "/EgtDev/Include/EgtLogger.h"
-
 using namespace std ;
 
 //----------------------------------------------------------------------------
@@ -602,7 +598,7 @@ Triangulate::CalcTriangleAspectRatio( const Point3d& ptPa, const Point3d& ptPb,
    if ( dTwoArea < EPS_SMALL * EPS_SMALL)
       return INFINITO ;
    else
-      return ( std::max( dSqDistA, std::max( dSqDistB, dSqDistC)) / dTwoArea) ;
+      return ( (std::max)( dSqDistA, (std::max)( dSqDistB, dSqDistC)) / dTwoArea) ;
 }
 
 //----------------------------------------------------------------------------
@@ -811,8 +807,14 @@ Triangulate::GetOuterPntToJoin( const PNTVECTOR& vPt, const Point3d& ptP, int& n
      // mi metto nel piano principale
       switch (m_nPlane) {
       default :  // PL_XY
+        // se i punti coincidono
+         if ( fabs( vPt[i].x - ptP.x) < EPS_SMALL  &&  fabs( vPt[i].y - ptP.y) < EPS_SMALL) {
+            dMinDist = 0 ;
+            nI = i ;
+            ptInt = vPt[i] ;
+         }
         // se punto esattamente sul raggio e raggio interno al settore
-         if ( vPt[i].x > ptP.x  &&  fabs( vPt[i].y - ptP.y) < EPS_SMALL  &&
+         else if ( vPt[i].x > ptP.x  &&  fabs( vPt[i].y - ptP.y) < EPS_SMALL  &&
               PointInSector( ptP, vPt[h], vPt[i], vPt[j])) {
            // se distanza minore della minima, nuovo minimo
             if ( ( vPt[i].x - ptP.x) < dMinDist) {
@@ -827,7 +829,7 @@ Triangulate::GetOuterPntToJoin( const PNTVECTOR& vPt, const Point3d& ptP, int& n
             double dCoeff = ( ptP.y - vPt[i].y) / ( vPt[j].y - vPt[i].y) ;
             double dX = vPt[i].x + ( vPt[j].x - vPt[i].x) * dCoeff ;
            // se sta sul raggio e distanza minore della minima
-            if ( dX > ptP.x  &&  ( dX - ptP.x) < dMinDist) {
+            if ( dX > ptP.x - EPS_SMALL  &&  ( dX - ptP.x) < dMinDist) {
                dMinDist = dX - ptP.x ;
                nI = ( vPt[i].x >= vPt[j].x) ? i : j ;
                double dZ = vPt[i].z + ( vPt[j].z - vPt[i].z) * dCoeff ;
@@ -836,8 +838,14 @@ Triangulate::GetOuterPntToJoin( const PNTVECTOR& vPt, const Point3d& ptP, int& n
          }
          break ;
       case PL_YZ :
+        // se i punti coincidono
+         if ( fabs( vPt[i].y - ptP.y) < EPS_SMALL  &&  fabs( vPt[i].z - ptP.z) < EPS_SMALL) {
+            dMinDist = 0 ;
+            nI = i ;
+            ptInt = vPt[i] ;
+         }
         // se punto esattamente sul raggio e raggio interno al settore
-         if ( vPt[i].y > ptP.y  &&  fabs( vPt[i].z - ptP.z) < EPS_SMALL  &&
+         else if ( vPt[i].y > ptP.y  &&  fabs( vPt[i].z - ptP.z) < EPS_SMALL  &&
               PointInSector( ptP, vPt[h], vPt[i], vPt[j])) {
            // se distanza minore della minima, nuovo minimo
             if ( ( vPt[i].y - ptP.y) < dMinDist) {
@@ -852,7 +860,7 @@ Triangulate::GetOuterPntToJoin( const PNTVECTOR& vPt, const Point3d& ptP, int& n
             double dCoeff = ( ptP.z - vPt[i].z) / ( vPt[j].z - vPt[i].z) ;
             double dY = vPt[i].y + ( vPt[j].y - vPt[i].y) * dCoeff ;
            // se sta sul raggio e distanza minore della minima
-            if ( dY > ptP.y  &&  ( dY - ptP.y) < dMinDist) {
+            if ( dY > ptP.y - EPS_SMALL  &&  ( dY - ptP.y) < dMinDist) {
                dMinDist = dY - ptP.y ;
                nI = ( vPt[i].y >= vPt[j].y) ? i : j ;
                double dX = vPt[i].x + ( vPt[j].x - vPt[i].x) * dCoeff ;
@@ -861,8 +869,14 @@ Triangulate::GetOuterPntToJoin( const PNTVECTOR& vPt, const Point3d& ptP, int& n
          }
          break ;
       case PL_ZX :
+        // se i punti coincidono
+         if ( fabs( vPt[i].z - ptP.z) < EPS_SMALL  &&  fabs( vPt[i].x - ptP.x) < EPS_SMALL) {
+            dMinDist = 0 ;
+            nI = i ;
+            ptInt = vPt[i] ;
+         }
         // se punto esattamente sul raggio e raggio interno al settore
-         if ( vPt[i].z > ptP.z  &&  fabs( vPt[i].x - ptP.x) < EPS_SMALL  &&
+         else if ( vPt[i].z > ptP.z  &&  fabs( vPt[i].x - ptP.x) < EPS_SMALL  &&
               PointInSector( ptP, vPt[h], vPt[i], vPt[j])) {
            // se distanza minore della minima, nuovo minimo
             if ( ( vPt[i].z - ptP.z) < dMinDist) {
@@ -877,7 +891,7 @@ Triangulate::GetOuterPntToJoin( const PNTVECTOR& vPt, const Point3d& ptP, int& n
             double dCoeff = ( ptP.x - vPt[i].x) / ( vPt[j].x - vPt[i].x) ;
             double dZ = vPt[i].z + ( vPt[j].z - vPt[i].z) * dCoeff ;
            // se sta sul raggio e distanza minore della minima
-            if ( dZ > ptP.z  &&  ( dZ - ptP.z) < dMinDist) {
+            if ( dZ > ptP.z - EPS_SMALL  &&  ( dZ - ptP.z) < dMinDist) {
                dMinDist = dZ - ptP.z ;
                nI = ( vPt[i].z >= vPt[j].z) ? i : j ;
                double dY = vPt[i].y + ( vPt[j].y - vPt[i].y) * dCoeff ;