diff --git a/Tree.cpp b/Tree.cpp
index 20e7574..51fb1a0 100644
--- a/Tree.cpp
+++ b/Tree.cpp
@@ -21,6 +21,7 @@
 #include "SurfFlatRegion.h"
 #include "IntersLineLine.h"
 #include "AdjustLoops.h"
+#include "/EgtDev/Include/EGkDistLineLine.h"
 #include "/EgtDev/Include/EGkPolyLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkCurve.h"
@@ -750,6 +751,24 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax)
                Point3d ptU = ( 1 - dVLoc) * ptP10P11 + dVLoc * ptP01P00 ;
                dCurvV = Dist( ptV, ptPSrf) ;
                dCurvU = Dist( ptU, ptPSrf) ;
+
+               // devo calcolare anche il twist, in caso di bordi rettilinei ( superficie di grado maggiore di 1, ma che in realtà è una bilineare)
+               // NON posso guardare la distanza tra il punto medio delle diagonali e il punto centrale della cella ( uLoc = 0.5, vLoc = 0.5)
+               // posso guardare la distanza tra le due diagonali
+               Point3d ptP00, ptP10, ptP11, ptP01 ;
+               // distanza reale tra i vertici della cella
+               ptP00 = m_mVert[nCToSplit][0] ;
+               ptP10 = m_mVert[nCToSplit][1] ;
+               ptP11 = m_mVert[nCToSplit][2] ;
+               ptP01 = m_mVert[nCToSplit][3] ;
+               
+               // da implementare!!!!! serve una valutazione più fine, sennò approssimo la superficie in modo troppo grossolano!!!!
+               DistLineLine dll( ptP00, ptP11, ptP10, ptP01, true, true) ;
+               double dDist = 0 ; dll.GetDist( dDist) ;
+               if ( dDist > max(dCurvU, dCurvV) ) {
+                  // devo decidere in quale direzione splittare
+                  // dovrei capire in quale delle due direzioni è più torta la superficie
+               }
             }
             // faccio un'analisi più fine della curvatura se almeno il grado di una curva di uno dei due parametri è alto e 
             // se sto ancora guardando una cella abbastanza grande
@@ -802,7 +821,7 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax)
                bVert = true ;
             }
             m_mTree[nCToSplit].SetSplitDirVert( bVert) ;
-               Point3d ptP00, ptP10, ptP11, ptP01 ;
+            Point3d ptP00, ptP10, ptP11, ptP01 ;
             // distanza reale tra i vertici della cella
             ptP00 = m_mVert[nCToSplit][0] ;
             ptP10 = m_mVert[nCToSplit][1] ;
@@ -953,7 +972,7 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax)
             nCToSplit = m_mTree[nCToSplit].m_nChild1 ;
          }
       }
-      Balance() ; // da implementare quando dividerò ad un parametro a scelta e non a metà
+      Balance() ; // da implementare quando dividerò ad un parametro a scelta e non a metà  // probabilmente mi servirà salvare nella cella il livello di profondità
    }
    // bilineare
    else {
@@ -972,7 +991,7 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax)
             double dLen3 = Dist( ptP00, ptP01) ;
                
             bool bVert = false ;
-            // calcolo in quale direzione è meglio dividere in base allo stretch
+            // calcolo in quale direzione è meglio dividere in base allo stretch // in realtà visto che non parametro rispetto alla dimensione nel parametrico, così mi trovo a dividere con un quad-tree
             Point3d ptPSrfU, ptPSrfV ;
             double dU = 0, dV = 0 ;
             double dDistU = 0, dDistV = 0 ;
@@ -1035,6 +1054,7 @@ Tree::BuildTree( double dLinTol, double dSideMin, double dSideMax)
             }
             else {
                dErr = 1. / 4. * ( ( ptP00 - ptP01) + ( ptP11 - ptP10)).Len() ;
+               //int dErr2 = 1. / 4. * ( ( ptP10 - ptP01) + ( ptP11 - ptP00)).Len() ;  //correzione che mi verrebbe intuitiva, ma che fa dividere la superficie molto di più ( probabilmente troppo)!! quindi probabilmente sbagliata
             }
             // se la cella è abbastanza grande da poter essere divisa ancora e devo approssimare meglio, la divido
             if ( dSideMinVal / 2 >= dSideMin  &&  dSideMaxVal < dSideMax  &&  dErr > dLinTol) {