diff --git a/CDeCylTria.cpp b/CDeCylTria.cpp
index 5849c43..1557e4f 100644
--- a/CDeCylTria.cpp
+++ b/CDeCylTria.cpp
@@ -32,10 +32,10 @@ CDeCylTria( const Frame3d& frCyl, double dH, double dR, double dSafeDist, const
   // Lo taglio come il cilindro (ingrossato della sicurezza)
    Plane3d plTrimB ;
    plTrimB.Set( dSafeDist, -Z_AX) ;
-   plyTria.Trim( plTrimB, true, false) ;
+   plyTria.Trim( plTrimB, true, false, false) ;
    Plane3d plTrimT ;
    plTrimT.Set( dH + dSafeDist, Z_AX) ;
-   plyTria.Trim( plTrimB, true, false) ;
+   plyTria.Trim( plTrimB, true, false, false) ;
   // Se non è rimasto alcunchè, allora non c'è collisione
    if ( plyTria.GetSideCount() == 0)
       return false ;
diff --git a/CurveArc.cpp b/CurveArc.cpp
index f3ee2bb..b355fe8 100644
--- a/CurveArc.cpp
+++ b/CurveArc.cpp
@@ -781,16 +781,16 @@ CurveArc::Validate( void)
 
 //----------------------------------------------------------------------------
 bool
-CurveArc::IsFlat( Plane3d& plPlane, double dToler) const
+CurveArc::IsFlat( Plane3d& plPlane, bool bUseExtrusion, double dToler) const
 {
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
 
   // assegno dati possibile piano
-   bool bFlat = IsFlat( dToler) ;
+   bool bFlat = IsPlane( dToler) ;
    Vector3d vtN ;
-   if ( m_VtExtr.IsSmall()) {
+   if ( ! bUseExtrusion  ||  m_VtExtr.IsSmall()) {
       vtN = m_VtN ;
    }
    else {
@@ -1516,7 +1516,7 @@ CurveArc::ExtendEndByLen( double dLenExt)
   // eseguo l'estensione
    double dCoeff = ( dLen + dLenExt) / dLen ;
    m_dAngCenDeg *= dCoeff ;
-   if ( ! IsFlat())
+   if ( ! IsPlane())
       m_dDeltaN *= dCoeff ;
    else if ( abs( m_dAngCenDeg) > ANG_FULL)
       m_dAngCenDeg = _copysign( ANG_FULL, m_dAngCenDeg) ;
diff --git a/CurveArc.h b/CurveArc.h
index a0aa520..46d0858 100644
--- a/CurveArc.h
+++ b/CurveArc.h
@@ -59,7 +59,7 @@ class CurveArc : public ICurveArc, public IGeoObjRW
               { return true ; }
       bool IsClosed( void) const override
               { return ::IsClosed( *this) ; }
-      bool IsFlat( Plane3d& plPlane, double dToler = EPS_SMALL) const override ; 
+      bool IsFlat( Plane3d& plPlane, bool bUseExtrusion = true, double dToler = EPS_SMALL) const override ; 
       bool GetStartPoint( Point3d& ptStart) const override ;
       bool GetEndPoint( Point3d& ptEnd) const override ;
       bool GetMidPoint( Point3d& ptMid) const override ;
@@ -140,10 +140,10 @@ class CurveArc : public ICurveArc, public IGeoObjRW
       bool SetCPAN( const Point3d& ptCen, const Point3d& ptStart, double dAngCenDeg, double dDeltaZ, const Vector3d& vtN) override ;
       bool SetC2P( const Point3d& ptCen, const Point3d& ptStart, const Point3d& ptNearEnd) override ;
       bool SetC2PN( const Point3d& ptCen, const Point3d& ptStart, const Point3d& ptNearEnd, const Vector3d& vtN) override ;
-      bool IsFlat( double dToler = EPS_SMALL) const override
+      bool IsPlane( double dToler = EPS_SMALL) const override
                 { return ( abs( m_dDeltaN) < dToler) ; }
       bool IsACircle( void) const override
-                { return ( IsFlat()  &&  IsClosed()) ; }
+                { return ( IsPlane()  &&  IsClosed()) ; }
       bool IsInPlaneXY( void) const override
                 { return ( m_VtN.IsZplus()) ; }
       bool IsInPlanePerpExtr( void) const override
diff --git a/CurveAux.cpp b/CurveAux.cpp
index 08cb8d2..7512a58 100644
--- a/CurveAux.cpp
+++ b/CurveAux.cpp
@@ -705,17 +705,10 @@ FlattenCurve( const ICurve& crCrv, double dToler, double dAngToler)
 {
   // Determino il piano medio della curva e verifico se scostamento accettabile
    Plane3d plMid ;
-   if ( ! crCrv.IsFlat( plMid, dToler))
+   if ( ! crCrv.IsFlat( plMid, false, dToler))
       return nullptr ;
-  // Verifico estrusione rispetto alla normale al piano medio
+  // Recupero estrusione rispetto alla normale al piano medio
    Vector3d vtExtr ; crCrv.GetExtrusion( vtExtr) ;
-   if ( vtExtr.IsSmall()) {
-      vtExtr = plMid.GetVersN() ;
-   }
-   else {
-      if ( ! AreSameOrOppositeVectorEpsilon( vtExtr, plMid.GetVersN(), sin( dAngToler * DEGTORAD)))
-         return nullptr ;
-   }
   // Determino il suo centro geometrico
    Point3d ptCen ;
    if ( ! crCrv.GetCentroid( ptCen))
@@ -725,7 +718,7 @@ FlattenCurve( const ICurve& crCrv, double dToler, double dAngToler)
    if ( ! crCrv.ApproxWithLines( LIN_TOL_FINE, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
       return nullptr ;
    bool bFlat = true ;
-   Plane3d plFlat ; plFlat.Set( ptCen, vtExtr) ;
+   Plane3d plFlat ; plFlat.Set( ptCen, plMid.GetVersN()) ;
    Point3d ptP ;
    bool bPoint = PL.GetFirstPoint( ptP) ;
    while ( bPoint  &&  bFlat) {
@@ -751,7 +744,7 @@ FlattenCurve( const ICurve& crCrv, double dToler, double dAngToler)
          return nullptr ;
      // calcolo un riferimento con piano XY coincidente con il piano di proiezione
       Frame3d frRef ;
-      if ( ! frRef.Set( ptCen, vtExtr))
+      if ( ! frRef.Set( ptCen, plMid.GetVersN()))
          return nullptr ;
      // eseguo scalatura con fattori X e Y unitari e fattore Z nullo
       if ( ! pCrv->Scale( frRef, 1, 1, 0))
diff --git a/CurveBezier.cpp b/CurveBezier.cpp
index e3537bf..9101725 100644
--- a/CurveBezier.cpp
+++ b/CurveBezier.cpp
@@ -512,7 +512,7 @@ CurveBezier::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
 
 //----------------------------------------------------------------------------
 bool
-CurveBezier::IsFlat( Plane3d& plPlane, double dToler) const
+CurveBezier::IsFlat( Plane3d& plPlane, bool bUseExtrusion, double dToler) const
 {
   // verifico lo stato
    if ( m_nStatus != OK)
@@ -543,11 +543,11 @@ CurveBezier::IsFlat( Plane3d& plPlane, double dToler) const
       if ( m_VtExtr.IsSmall())
          plPlane.Set( ptCen, FromUprightOrtho( vtDir)) ;
       else {
-         Vector3d vtN = m_VtExtr - ( m_VtExtr * vtDir) * vtDir ;
+         Vector3d vtN = OrthoCompo( m_VtExtr, vtDir) ;
          if ( ! vtN.Normalize())
             vtN = FromUprightOrtho( vtDir) ;
          plPlane.Set( ptCen, vtN) ;
-         bFlat = bFlat && ( AreSameOrOppositeVectorApprox( m_VtExtr, vtN)) ;
+         bFlat = bFlat && ( ! bUseExtrusion  ||  AreSameOrOppositeVectorApprox( m_VtExtr, vtN)) ;
       }
       break ;
    default :     // piana o 3d
@@ -555,7 +555,7 @@ CurveBezier::IsFlat( Plane3d& plPlane, double dToler) const
          plPlane.Set( ptCen, vtDir) ;
       else {
          plPlane.Set( ptCen, (( m_VtExtr * vtDir) > 0 ? vtDir : - vtDir)) ;
-         bFlat = bFlat && ( AreSameOrOppositeVectorApprox( m_VtExtr, vtDir)) ;
+         bFlat = bFlat && ( ! bUseExtrusion  ||  AreSameOrOppositeVectorApprox( m_VtExtr, vtDir)) ;
       }
       break ;
    }
diff --git a/CurveBezier.h b/CurveBezier.h
index 325b5e6..3710ca7 100644
--- a/CurveBezier.h
+++ b/CurveBezier.h
@@ -60,7 +60,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
       bool IsSimple( void) const override { return true ; }
       bool IsClosed( void) const override
               { return ::IsClosed( *this) ; }
-      bool IsFlat( Plane3d& plPlane, double dToler) const override ;
+      bool IsFlat( Plane3d& plPlane, bool bUseExtrusion = true, double dToler = EPS_SMALL) const override ;
       bool GetStartPoint( Point3d& ptStart) const override ;
       bool GetEndPoint( Point3d& ptEnd) const override ;
       bool GetMidPoint( Point3d& ptMid) const override ;
diff --git a/CurveComposite.cpp b/CurveComposite.cpp
index 1e2ee94..f044ea9 100644
--- a/CurveComposite.cpp
+++ b/CurveComposite.cpp
@@ -808,7 +808,7 @@ CurveComposite::Validate( void)
 
 //----------------------------------------------------------------------------
 bool
-CurveComposite::IsFlat( Plane3d& plPlane, double dToler) const
+CurveComposite::IsFlat( Plane3d& plPlane, bool bUseExtrusion, double dToler) const
 {
   // verifico lo stato
    if ( m_nStatus != OK)
@@ -876,11 +876,11 @@ CurveComposite::IsFlat( Plane3d& plPlane, double dToler) const
       if ( m_VtExtr.IsSmall())
          plPlane.Set( ptCen, FromUprightOrtho( vtDir)) ;
       else {
-         Vector3d vtN = m_VtExtr - ( m_VtExtr * vtDir) * vtDir ;
+         Vector3d vtN = OrthoCompo( m_VtExtr, vtDir) ;
          if ( ! vtN.Normalize())
             vtN = FromUprightOrtho( vtDir) ;
          plPlane.Set( ptCen, vtN) ;
-         bFlat = bFlat && ( AreSameOrOppositeVectorApprox( m_VtExtr, vtN)) ;
+         bFlat = bFlat && ( ! bUseExtrusion  ||  AreSameOrOppositeVectorApprox( m_VtExtr, vtN)) ;
       }
       break ;
    default :     // piana o 3d
@@ -888,7 +888,7 @@ CurveComposite::IsFlat( Plane3d& plPlane, double dToler) const
          plPlane.Set( ptCen, vtDir) ;
       else {
          plPlane.Set( ptCen, (( m_VtExtr * vtDir) > 0 ? vtDir : - vtDir)) ;
-         bFlat = bFlat && ( AreSameOrOppositeVectorApprox( m_VtExtr, vtDir)) ;
+         bFlat = bFlat && ( ! bUseExtrusion  ||  AreSameOrOppositeVectorApprox( m_VtExtr, vtDir)) ;
       }
       break ;
    }
@@ -2656,7 +2656,7 @@ CurveComposite::MergeTwoCurves( ICurve* pCrvP, ICurve* pCrvC, double& dCurrLinTo
       if ( abs( pArcP->GetAngCenter() + pArcC->GetAngCenter()) > ANG_FULL + EPS_ANG_SMALL)
          return false ;
      // se archi piatti
-      if ( pArcP->IsFlat()  &&  pArcC->IsFlat()) {
+      if ( pArcP->IsPlane()  &&  pArcC->IsPlane()) {
         // se calcolo nuovo arco ok, procedo con l'unione
          Point3d ptP1 ;
          pArcP->GetStartPoint( ptP1) ;
diff --git a/CurveComposite.h b/CurveComposite.h
index ea567f4..73d9132 100644
--- a/CurveComposite.h
+++ b/CurveComposite.h
@@ -59,7 +59,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool IsSimple( void) const override
               { return false ; }
       bool IsClosed( void) const override ;
-      bool IsFlat( Plane3d& plPlane, double dToler = EPS_SMALL) const override ; 
+      bool IsFlat( Plane3d& plPlane, bool bUseExtrusion = true, double dToler = EPS_SMALL) const override ; 
       bool GetStartPoint( Point3d& ptStart) const override ;
       bool GetEndPoint( Point3d& ptEnd) const override ;
       bool GetMidPoint( Point3d& ptMid) const override ;
diff --git a/CurveLine.cpp b/CurveLine.cpp
index f4ac2aa..f5e2527 100644
--- a/CurveLine.cpp
+++ b/CurveLine.cpp
@@ -263,7 +263,7 @@ CurveLine::Validate( void)
 
 //----------------------------------------------------------------------------
 bool
-CurveLine::IsFlat( Plane3d& plPlane, double dToler) const
+CurveLine::IsFlat( Plane3d& plPlane, bool bUseExtrusion, double dToler) const
 {
   // verifico lo stato
    if ( m_nStatus != OK)
@@ -272,7 +272,7 @@ CurveLine::IsFlat( Plane3d& plPlane, double dToler) const
   // assegno dati piano
    bool bFlat ;
    Vector3d vtN ;
-   if ( m_VtExtr.IsSmall()) {
+   if ( ! bUseExtrusion  ||  m_VtExtr.IsSmall()) {
       vtN = FromUprightOrtho( m_PtEnd - m_PtStart) ;
       bFlat = true ;
    }
diff --git a/CurveLine.h b/CurveLine.h
index 759b837..6f5431c 100644
--- a/CurveLine.h
+++ b/CurveLine.h
@@ -59,7 +59,7 @@ class CurveLine : public ICurveLine, public IGeoObjRW
               { return true ; }
       bool IsClosed( void) const override
               { return ::IsClosed( *this) ; }
-      bool IsFlat( Plane3d& plPlane, double dToler) const override ;
+      bool IsFlat( Plane3d& plPlane, bool bUseExtrusion = true, double dToler = EPS_SMALL) const override ;
       bool GetStartPoint( Point3d& ptStart) const override ;
       bool GetEndPoint( Point3d& ptEnd) const override ;
       bool GetMidPoint( Point3d& ptMid) const override ;
diff --git a/DistPointArc.cpp b/DistPointArc.cpp
index 485008a..0b78be8 100644
--- a/DistPointArc.cpp
+++ b/DistPointArc.cpp
@@ -32,7 +32,7 @@ DistPointArc::DistPointArc( const Point3d& ptP, const ICurveArc& arArc)
       DistPointCircle( ptP, arArc) ; 
 
   // se arco in un piano
-   else if ( arArc.IsFlat())
+   else if ( arArc.IsPlane())
       DistPointFlatArc( ptP, arArc) ; 
 
   // altrimenti caso generico
diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc
index bf01683..8e9fbc1 100644
Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ
diff --git a/GdbGeo.cpp b/GdbGeo.cpp
index 34b2b47..e8df030 100644
--- a/GdbGeo.cpp
+++ b/GdbGeo.cpp
@@ -374,7 +374,7 @@ GdbGeo::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDi
      // ricavo puntatore ad arco
       ICurveArc* pArc = GetCurveArc( m_pGeoObj) ; 
      // se l'arco non è piatto o il piano di scorrimento non coincide con quello dell'arco
-      if ( ! pArc->IsFlat()  ||
+      if ( ! pArc->IsPlane()  ||
            ! AreSameOrOppositeVectorExact( pArc->GetNormVersor(), vtNorm)) {
         // trasformo in curva di Bezier (semplice o composta)
          ICurve* pCrvNew = ArcToBezierCurve( GetCurve( m_pGeoObj)) ;
diff --git a/LinePerpTwoCurves.cpp b/LinePerpTwoCurves.cpp
index 307947d..326dc95 100644
--- a/LinePerpTwoCurves.cpp
+++ b/LinePerpTwoCurves.cpp
@@ -142,7 +142,7 @@ GetLinePerpLineArc( const CurveLine& crvLine1, const Point3d& ptNear1,
                     const CurveArc& crvArc2, const Point3d& ptNear2)
 {
   // l'arco deve essere piatto (no elica)
-   if ( ! crvArc2.IsFlat())
+   if ( ! crvArc2.IsPlane())
       return nullptr ;
   // versore della linea
    Vector3d vtDir1 ;
@@ -190,7 +190,7 @@ GetLinePerpTwoArcs( const CurveArc& crvArc1, const Point3d& ptNear1,
 {
   // i due archi devono giacere nello stesso piano o in piani paralleli ed essere piatti
    if ( ! AreSameOrOppositeVectorApprox( crvArc1.GetNormVersor(), crvArc2.GetNormVersor())  ||
-        ! crvArc1.IsFlat()  ||  ! crvArc2.IsFlat())
+        ! crvArc1.IsPlane()  ||  ! crvArc2.IsPlane())
       return nullptr ;
   // la linea cercata deve passare per i due centri
    Vector3d vtDirP = crvArc2.GetCenter() - crvArc1.GetCenter() ;
diff --git a/LinePntPerpCurve.cpp b/LinePntPerpCurve.cpp
index 038e268..84b9df3 100644
--- a/LinePntPerpCurve.cpp
+++ b/LinePntPerpCurve.cpp
@@ -90,7 +90,7 @@ CurveLine*
 GetLinePointPerpArc( const Point3d& ptP, const CurveArc& crvArc, const Point3d& ptNear)
 {
   // l'arco deve essere piatto (no elica)
-   if ( ! crvArc.IsFlat())
+   if ( ! crvArc.IsPlane())
       return nullptr ;
   // punti sull'arco su direzione della linea dal punto al centro dell'arco
    Point3d ptP2 ;
diff --git a/LineTgCurvePerpCurve.cpp b/LineTgCurvePerpCurve.cpp
index dcbc8dc..8a5b7e0 100644
--- a/LineTgCurvePerpCurve.cpp
+++ b/LineTgCurvePerpCurve.cpp
@@ -125,7 +125,7 @@ GetLineTgLinePerpArc( const CurveLine& crvLine1, const Point3d& ptNear1,
                       const CurveArc& crvArc2, const Point3d& ptNear2)
 {
   // l'arco deve essere piatto (no elica)
-   if ( ! crvArc2.IsFlat())
+   if ( ! crvArc2.IsPlane())
       return nullptr ;
   // versore della linea
    Vector3d vtDir1 ;
@@ -169,7 +169,7 @@ GetLineTgArcPerpArc( const CurveArc& crvArc1, const Point3d& ptNear1,
 {
   // i due archi devono giacere nello stesso piano o in piani paralleli ed essere piatti
    if ( ! AreSameOrOppositeVectorApprox( crvArc1.GetNormVersor(), crvArc2.GetNormVersor())  ||
-        ! crvArc1.IsFlat()  ||  ! crvArc2.IsFlat())
+        ! crvArc1.IsPlane()  ||  ! crvArc2.IsPlane())
       return nullptr ;
   // calcolo la retta dal centro del secondo arco tangente al primo arco e la inverto
    PtrOwner<CurveLine> pCrvPtA( GetBasicCurveLine( GetLinePointTgCurve( crvArc2.GetCenter(), crvArc1, ptNear1))) ;
@@ -215,7 +215,7 @@ GetLineTgArcPerpLine( const CurveArc& crvArc1, const Point3d& ptNear1,
                       const CurveLine& crvLine2, const Point3d& ptNear2)
 {
   // l'arco deve essere piatto (no elica)
-   if ( ! crvArc1.IsFlat())
+   if ( ! crvArc1.IsPlane())
       return nullptr ;
   // versore della linea
    Vector3d vtDir2 ;
diff --git a/LineTgTwoCurves.cpp b/LineTgTwoCurves.cpp
index d3437a3..fa73534 100644
--- a/LineTgTwoCurves.cpp
+++ b/LineTgTwoCurves.cpp
@@ -116,7 +116,7 @@ GetLineTgLineArc( const CurveLine& crvLine1, const Point3d& ptNear1,
                   const CurveArc& crvArc2, const Point3d& ptNear2)
 {
   // l'arco deve essere piatto (no elica)
-   if ( ! crvArc2.IsFlat())
+   if ( ! crvArc2.IsPlane())
       return nullptr ;
   // versore della linea
    Vector3d vtDir1 ;
@@ -162,7 +162,7 @@ GetLineTgTwoArcs( const CurveArc& crvArc1, const Point3d& ptNear1,
 {
   // verifico che i due archi abbiano lo stesso piano intrinseco e siano piatti
    if ( ! AreSameOrOppositeVectorApprox( crvArc1.GetNormVersor(), crvArc2.GetNormVersor())  ||
-        ! crvArc1.IsFlat()  ||  ! crvArc2.IsFlat())
+        ! crvArc1.IsPlane()  ||  ! crvArc2.IsPlane())
       return nullptr ;
 
   // calcolo il riferimento intrinseco del primo arco (Z->DirNorm e X->DirStart)
diff --git a/Polygon3d.cpp b/Polygon3d.cpp
index aeeba9a..a324c01 100644
--- a/Polygon3d.cpp
+++ b/Polygon3d.cpp
@@ -104,7 +104,7 @@ Polygon3d::FromPolyLine( const PolyLine& PL)
 
 //----------------------------------------------------------------------------
 bool
-Polygon3d::FromPlaneTrimmedWithBox( const Plane3d& plPlane, const Point3d& ptMin, const Point3d& ptMax)
+Polygon3d::FromPlaneTrimmedWithBox( const Plane3d& plPlane, const Point3d& ptMin, const Point3d& ptMax, bool bOnEq, bool bOnCt)
 {
   // pulisco tutto
    Clear() ;
@@ -127,33 +127,34 @@ Polygon3d::FromPlaneTrimmedWithBox( const Plane3d& plPlane, const Point3d& ptMin
   // lo trimmo con le facce del box
    Plane3d plFace ;
    plFace.Set( -ptMin.y, -Y_AX) ;      // faccia 1 (Norm = Y-) 
-   Trim( plFace, true, true) ;
+   Trim( plFace, true, bOnEq, bOnCt) ;
    plFace.Set( -ptMin.z, -Z_AX) ;      // faccia 2 (Norm = Z-) 
-   Trim( plFace, true, true) ;
+   Trim( plFace, true, bOnEq, bOnCt) ;
    plFace.Set( ptMax.y, Y_AX) ;        // faccia 3 (Norm = Y+) 
-   Trim( plFace, true, true) ;
+   Trim( plFace, true, bOnEq, bOnCt) ;
    plFace.Set( ptMax.z, Z_AX) ;        // faccia 4 (Norm = Z+) 
-   Trim( plFace, true, true) ;
+   Trim( plFace, true, bOnEq, bOnCt) ;
    plFace.Set( -ptMin.x, -X_AX) ;      // faccia 5 (Norm = X-) 
-   Trim( plFace, true, true) ;
+   Trim( plFace, true, bOnEq, bOnCt) ;
    plFace.Set( ptMax.x, X_AX) ;        // faccia 6 (Norm = X+) 
-   Trim( plFace, true, true) ;
+   Trim( plFace, true, bOnEq, bOnCt) ;
 
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Polygon3d::FromPlaneTrimmedWithBox( const Point3d& ptOn, const Vector3d& vtN, const Point3d& ptMin, const Point3d& ptMax)
+Polygon3d::FromPlaneTrimmedWithBox( const Point3d& ptOn, const Vector3d& vtN,
+                                    const Point3d& ptMin, const Point3d& ptMax, bool bOnEq, bool bOnCt)
 {
    Plane3d plPlane ;
    plPlane.Set( ptOn, vtN) ;
-   return FromPlaneTrimmedWithBox( plPlane, ptMin, ptMax) ;
+   return FromPlaneTrimmedWithBox( plPlane, ptMin, ptMax, bOnEq, bOnCt) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Polygon3d::Trim( const Plane3d& plPlane, bool bInVsOut, bool bOnEq)
+Polygon3d::Trim( const Plane3d& plPlane, bool bInVsOut, bool bOnEq, bool bOnCt)
 {
   // calcolo le distanze dei punti del poligono dal piano
    int nNbrMinus = 0 ;
@@ -176,8 +177,8 @@ Polygon3d::Trim( const Plane3d& plPlane, bool bInVsOut, bool bOnEq)
    if ( nNbrMinus == 0  &&  nNbrPlus == 0) {
      // determino se normali equiverse
       bool bEquivNormal = ( m_Plane.GetVersN() * plPlane.GetVersN() > 0) ;
-     // se relazione tra normali opposta al desiderato, lo annullo
-      if ( bOnEq != bEquivNormal)
+     // se relazione tra normali opposte a entrambi i desiderati, lo annullo
+      if ( ( bEquivNormal  &&  ! bOnEq)  ||  ( ! bEquivNormal  &&  ! bOnCt))
          m_vVert.clear() ;
       return true ;
    }
@@ -235,11 +236,11 @@ Polygon3d::Trim( const Plane3d& plPlane, bool bInVsOut, bool bOnEq)
 
 //----------------------------------------------------------------------------
 bool
-Polygon3d::Trim( const Polygon3d& plyOther, bool bInVsOut, bool bOnEq)
+Polygon3d::Trim( const Polygon3d& plyOther, bool bInVsOut, bool bOnEq, bool bOnCt)
 {
    if ( GetSideCount() == 0  ||  ! plyOther.IsValid())
       return true ;
-   return Trim( plyOther.m_Plane, bInVsOut, bOnEq) ;
+   return Trim( plyOther.m_Plane, bInVsOut, bOnEq, bOnCt) ;
 }
 
 //----------------------------------------------------------------------------
diff --git a/StmFromCurves.cpp b/StmFromCurves.cpp
index baca130..991d51d 100644
--- a/StmFromCurves.cpp
+++ b/StmFromCurves.cpp
@@ -336,7 +336,7 @@ GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, d
    bool bSectClosed = PL.IsClosed() ;
   // verifico che la linea guida sia piana
    Plane3d plGuide ;
-   if ( ! pGuide->IsFlat( plGuide, 10 * EPS_SMALL))
+   if ( ! pGuide->IsFlat( plGuide, false, 10 * EPS_SMALL))
       return nullptr ;
   // determino se la guida è chiusa
    bool bGuideClosed = pGuide->IsClosed() ;
@@ -346,9 +346,8 @@ GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, d
    pGuide->GetStartPoint( ptStart) ;
    Vector3d vtStart ;
    pGuide->GetStartDir( vtStart) ;
-   Vector3d vtExtr = Z_AX ;
-   pGuide->GetExtrusion( vtExtr) ;
-   frStart.Set( ptStart, -vtStart, vtStart ^ vtExtr) ;
+   Vector3d vtNorm = plGuide.GetVersN() ;
+   frStart.Set( ptStart, -vtStart, vtStart ^ vtNorm) ;
   // porto la sezione in questo riferimento e ve la appiattisco
    if ( ! PL.ToLoc( frStart)  ||  ! PL.Flatten())
       return nullptr ;
@@ -406,7 +405,7 @@ GetSurfTriMeshSwept( const ICurve* pSect, const ICurve* pGuide, bool bCapEnds, d
       pGuide->GetEndPoint( ptEnd) ;
       Vector3d vtEnd ;
       pGuide->GetEndDir( vtEnd) ;
-      frEnd.Set( ptEnd, -vtEnd, vtEnd ^ vtExtr) ;
+      frEnd.Set( ptEnd, -vtEnd, vtEnd ^ vtNorm) ;
      // aggiungo il cap sulla fine
       PtrOwner<ISurfTriMesh> pSce( CreateSurfTriMesh()) ;
       if ( IsNull( pSce)  ||  ! pSce->CreateByFlatContour( PL))
diff --git a/StmStandard.cpp b/StmStandard.cpp
index 9fa891a..657da5e 100644
--- a/StmStandard.cpp
+++ b/StmStandard.cpp
@@ -186,14 +186,14 @@ GetSurfTriMeshSphere( double dRadius, double dLinTol)
 
 //-------------------------------------------------------------------------------
 ISurfTriMesh*
-GetSurfTriMeshPlaneInBox( const Plane3d& plPlane, const BBox3d& b3Box)
+GetSurfTriMeshPlaneInBox( const Plane3d& plPlane, const BBox3d& b3Box, bool bOnEq, bool bOnCt)
 {
  // verifico la definizione del piano
   if ( ! plPlane.IsValid())
      return nullptr ;
  // creo il poligono corrispondente alla parte di piano limitata dal box
   Polygon3d Polyg ;
-  if ( ! Polyg.FromPlaneTrimmedWithBox( plPlane, b3Box.GetMin(), b3Box.GetMax()))
+  if ( ! Polyg.FromPlaneTrimmedWithBox( plPlane, b3Box.GetMin(), b3Box.GetMax(), bOnEq, bOnCt))
      return nullptr ;
   // creo la trimesh con questo contorno
    PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;