EgtGeomKernel :

- correzione a Collision Avoid per utensile cilindrico che tocca vertice triangolo sul bordo
- in CalcPocketing tolti riferimenti a SafeZ e assegnato valore default a OpenMinSafe e a bAboveHead .

CAvToolTriangle.cpp

@@ -2503,7 +2503,7 @@ DiskSegmentEscapeDistLongMot( const Point3d& ptDiskCen, double dDiskRad,
    double dSegDist = 0. ;
    for ( int nSol = 0 ; nSol < nRoot ; ++ nSol) {
      // Soluzione interna al segmento
-      if ( vdRoots[nSol] > 0.  &&  vdRoots[nSol] < dSegLen) {
+      if ( vdRoots[nSol] > 0.  &&  vdRoots[nSol] < dSegLen + EPS_ZERO) {
          Point3d ptC = ptSeg + vdRoots[nSol] * vtSeg ;
         // Distanza del punto soluzione dal piano del disco nella posizione iniziale
          double dCurDist = PointPlaneSignedDist( ptC, ptDiskCen, vtMove) ;

CalcPocketing.cpp

@@ -49,18 +49,17 @@ struct PocketParams {
    double dRadialOffset = 0. ;               // offset radiale
    double dRadialOffset_prec = -1. ;         // offset radiale precedente
    double dOpenEdgeRad = 0. ;                // massimo raggio per estensione lati aperti
-   double dOpenMinSafe = 0. ;                // estensione minima di sicurezza
+   double dOpenMinSafe = 2. ;                // estensione minima di sicurezza
    double dMaxOptSize = 0. ;                 // dimensione per ottimizzazione
    double dAngle = 0. ;                      // angolo per orientare le passate OneWay e ZigZag
    bool bOptOffsets = true ;                 // flag per evitare Offset non necessari in SpiralIn/Out
    bool bOptOffsetsAdv = false ;             // flag per evitare Offset coperti da curve di MedialAxis in SpiralIn/Out
-   bool bAboveHead = false ;                 // flag per testa da sopra ( Z+)
-   double dSafeZ = 0. ;                      // safe Z
+   bool bAboveHead = true ;                  // flag per testa da sopra ( Z+)
    bool bSmooth = false ;                    // curve smussate
    bool bInvert = false ;                    // inversione dei percorsi
    Point3d ptStart = P_INVALID ;             // punto d'inizio
    Point3d ptEnd = P_INVALID ;               // punto di fine
-   SurfFlatRegion SrfLimit ;                 // superficie limite per estensione lati aperti
+   SurfFlatRegion SfrLimit ;                 // superficie limite per estensione lati aperti
    bool bCalcFeed = false ;                  // flag per calcolo della Feed
    double dFeed = 1000 ;                     // feed di riferimento per frazione
    double dToolFeed = 1000 ;                 // feed del tool
@@ -604,7 +603,7 @@ ExtendPathOnOpenEdge( ICurveComposite* pCrvPath, const PocketParams& PockParams,
          return false ;
    }
   // calcolo il punto fuori
-   Point3d ptOut = ptMidOpen + vtMidOut * ( PockParams.dRad + max( PockParams.dSafeZ, PockParams.dOpenMinSafe)) ;
+   Point3d ptOut = ptMidOpen + vtMidOut * ( PockParams.dRad + PockParams.dOpenMinSafe) ;
   // aggiungo al ritorno l'uscita
    pCrvPath->AddLine( ptOut, bEndOrStart) ;
    pCrvPath->SetCurveTempProp( ( bEndOrStart ? pCrvPath->GetCurveCount() - 1 : 0), 2, 0) ; // nProp 2 per le curve LeadIn/Out
@@ -1036,9 +1035,9 @@ AdjustOpenEdge( const ICurveComposite* pCrvCompo, const ICRVCOMPOPOVECTOR& vCrvI
   // L'algoritmo di allargamento presso i lati aperti è Euristico; io mi estendo a seconda della geometria del
   // lato aperto al di fuori del volume di svuotatura... Devo controllare di non rovinare delle zone al di fuori di
   // esso !
-   if ( PockParams.SrfLimit.IsValid()) {
+   if ( PockParams.SfrLimit.IsValid()) {
       pSfrInc->Offset( 50 * EPS_SMALL, ICurve::OFF_FILLET) ;
-      if ( ! pSfrInc->Subtract( PockParams.SrfLimit))
+      if ( ! pSfrInc->Subtract( PockParams.SfrLimit))
          return false ;
      // può capitare che la regione Limite mi crei più Chunk sulla pSfrInc
      // I chunk da togliere sono tutti quelli che si sono separati dalla pCrvBorder
@@ -1478,9 +1477,9 @@ GetParamOnOpenSide( const ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vOth
             if ( bFound  &&  dLen + dLenAgg > dRefLen  &&  abs( dLen + dLenAgg - dMaxLen) < LEN_TOL) {
                Point3d ptTest ;
                pCrv->GetMidPoint( ptTest) ;
-               if (( PockParams.bAboveHead  &&  ptTest.z > ptMid.z + 100 * EPS_SMALL) ||
-                   ( ! PockParams.bAboveHead  &&  ptTest.z < ptMid.z - 100 * EPS_SMALL) ||
-                   ( abs( ptTest.z - ptMid.z) < 100 * EPS_SMALL  &&  ptTest.y < ptMid.y - 100 * EPS_SMALL)) {
+               if ( ( PockParams.bAboveHead  &&  ptTest.z > ptMid.z + 100 * EPS_SMALL)  ||
+                    ( ! PockParams.bAboveHead  &&  ptTest.z < ptMid.z - 100 * EPS_SMALL)  ||
+                    ( abs( ptTest.z - ptMid.z) < 100 * EPS_SMALL  &&  ptTest.y < ptMid.y - 100 * EPS_SMALL)) {
                   dMaxLen = max( dMaxLen, dLen + dLenAgg) ;
                   ptMid = ptTest ;
                  // vettore ortogonale verso l'esterno (ruotato -90deg attorno a estrusione)
@@ -1517,10 +1516,9 @@ GetParamOnOpenSide( const ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vOth
                  // vettore d'uscita nel sistema di riferimento globale
                   Vector3d vtMidOut = vtMidOrt ;
                   vtMidOut.ToGlob( frPocket) ;
-                 // ricavo la SafeZ
-                  double dSafeZ = PockParams.dSafeZ ;
+                 // ricavo il punto fuori
                   Point3d ptOut = ptStart + vtMidOut * ( PockParams.dRad + PockParams.dRadialOffset +
-                                                       ( PockParams.dRad + max( dSafeZ, PockParams.dOpenMinSafe))) ;
+                                                       ( PockParams.dRad + PockParams.dOpenMinSafe)) ;
                  // controllo l'elevazione sopra a quel punto ( qui è un bel mistero...)
                   // double dElev = 0. ;
                   // if ( ! GetElevation( m_nPhase, ptOut, frPocket.VersZ(), m_TParams.m_dDiam, m_TParams.m_dLen,