EgtGeomKernel :

- modifica alla sincronizzazione tra curve per trimming.

CalcPocketing.cpp

@@ -66,7 +66,6 @@ struct PocketParams {
    bool bSmooth = false ;                    // curve smussate
    bool bInvert = false ;                    // inversione dei percorsi
    bool bAvoidOpt = false ;                  // flag per evitare casi ottimizzati
-   bool bConventionalMilling = true ;        // flag per Conventional Milling Vs Climb Milling per svuotature a curva singola
    bool bAllowZigZagOneWayBorders = false ;  // flag per abilitare le curve di bordo per ZigZag/OneWay
    Point3d ptStart = P_INVALID ;             // punto d'inizio
    Point3d ptEnd = P_INVALID ;               // punto di fine
@@ -2115,7 +2114,7 @@ GetSinglePocketingCurves( ISurfFlatRegion* pSfr, PocketParams& PockParams,
       return false ;
 
   // imposto le Feed e inverto i percorsi per tali curve se richiesto
-   bool bAllowInvert = ( ! PockParams.bConventionalMilling) ;
+   bool bAllowInvert = ( PockParams.nType == POCKET_ZIGZAG  ||  PockParams.nType == POCKET_CONFORMAL_ZIGZAG) ;
    for ( int i = 0 ; i < ssize( vCrvSingleCurves) ; ++ i) {
      /*
          Idea : Feed proporzionale al minimo Offset per annullare la regione
@@ -3762,9 +3761,9 @@ AdjustTrapeziodLeadIn( ICurveComposite* pCrvRes, const PocketParams& PockParam,
   // se esiste almeno un aperto
    if ( nTmpProp > 0) {
      // se solo lato3 aperto
+      bool bCheckHead = ( nTmpProp != 8  &&  nTmpProp != 2) ;
       if ( nTmpProp == 2)
          pCrvRes->Invert() ; // entro dall'unico aperto
-      bool bCheckHead = ( nTmpProp != 8  &&  nTmpProp != 2) ;
       if ( bCheckHead) {
         // recupero gli estremi della curva corrente e la inverto in base alla Testa
          Point3d ptS ; pCrvRes->GetStartPoint( ptS) ;
@@ -3776,15 +3775,9 @@ AdjustTrapeziodLeadIn( ICurveComposite* pCrvRes, const PocketParams& PockParam,
             pCrvRes->Invert() ;
       }
    }
-   else if ( ! PockParam.bConventionalMilling) { // per sgrossature
-      Point3d ptS ; pCrvRes->GetStartPoint( ptS) ;
-      Point3d ptE ; pCrvRes->GetEndPoint( ptE) ;
-      if ( SqDist( ptE, PockParam.ptEnd) < SqDist( ptE, PockParam.ptEnd) + EPS_SMALL)
-         pCrvRes->Invert() ;
-   }
 
   // Assegno la Feed
-   AssignFeedSpiralOpt( 1, PockParam, pCrvRes) ;
+      AssignFeedSpiralOpt( 1, PockParam, pCrvRes) ;
   // Se curva da invertire, inverto
    if ( PockParam.bInvert)
       pCrvRes->Invert() ;
@@ -9416,7 +9409,7 @@ CalcSpiralPocketing( const ISurfFlatRegion* pSfr, int nType, const PocketParams&
    return ( CalcPocketing( pSfr, PockParams.dRad, PockParams.dRadialOffset, PockParams.dSideStep,
                            PockParams.dAngle, PockParams.dOpenMinSafe, nType, PockParams.bSmooth,
                            PockParams.bCalcUnclearedRegs, PockParams.bInvert, PockParams.bAvoidOpt,
-                           PockParams.bConventionalMilling, PockParams.bAllowZigZagOneWayBorders, PockParams.bCalcFeed, PockParams.ptStart,
+                           PockParams.bAllowZigZagOneWayBorders, PockParams.bCalcFeed, PockParams.ptStart,
                            pSfrLimit, PockParams.bAvoidOpt, PockParams.dMaxOptSize,
                            PockParams.nLiType, PockParams.dLiTang, PockParams.dLiElev, PockParams.nLoType, PockParams.dLoTang,
                            PockParams.bPolishing, PockParams.dEpicyclesRad, PockParams.dEpicyclesDist, vCrvCompoRes)) ;
@@ -9715,7 +9708,7 @@ SmoothExtensionLinesByIntersection( ICRVCOMPOPOVECTOR& vCrvPaths, const PocketPa
 bool
 CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadOffs, double dStep, double dAngle,
                double dOpenMinSafe, int nType, bool bSmooth, bool bCalcUnclReg, bool bInvert, bool bAvoidOpt,
-               bool bConventionalMilling, bool bAllowZigZagOneWayBorders, bool bCalcFeed, const Point3d& ptEndPrec,
+               bool bAllowZigZagOneWayBorders, bool bCalcFeed, const Point3d& ptEndPrec,
                const ISurfFlatRegion* pSfrLimit, bool bAllOffs, double dMaxOptSize,
                int nLiType, double dLiTang, double dLiElev, int nLoType, double dLoTang,
                bool bPolishing, double dEpicyclesRad, double dEpicyclesDist, ICRVCOMPOPOVECTOR& vCrvCompoRes)
@@ -9743,7 +9736,6 @@ CalcPocketing( const ISurfFlatRegion* pSfr, double dRad, double dRadOffs, double
    myParams.bInvert = bInvert ;
    myParams.bAvoidOpt = bAvoidOpt ;
    myParams.bCalcFeed = bCalcFeed ;
-   myParams.bConventionalMilling = bConventionalMilling ;
    myParams.bAllowZigZagOneWayBorders = bAllowZigZagOneWayBorders ;
    myParams.bOptOffsets = ( ! bAllOffs) ;
    myParams.dMaxOptSize = dMaxOptSize ;

CurveAux.cpp

@@ -2711,6 +2711,7 @@ GetIsoPointOnSecondCurve( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2, doub
    Point3d ptCurr1 ;
    Vector3d vtCurr1 ;
    pCrvEdge1->GetPointD1D2( dUCurr1, ICurve::FROM_MINUS, ptCurr1, &vtCurr1) ;
+   vtCurr1.Normalize() ;
    // --- Piano di taglio per punto a minima distanza
    IntersCurvePlane ICP( *pCrvEdge2, ptCurr1, vtCurr1) ;
    int nIndParCloser = - 1, nIndPointCloser = -1 ;
@@ -2786,29 +2787,36 @@ GetIsoPointOnSecondCurve( const ICurve* pCrvEdge1, const ICurve* pCrvEdge2, doub
 
    // Verifico se le direzioni tangenti sono tra di loro circa parallele
    const double COS_ANG_TOL = cos( 15. * DEGTORAD) ;
-   if ( vtCurr1 * vtCurr2 < COS_ANG_TOL) {
-      // Se fuori dalla tolleranza, recupero il miglior versore tangente sul secondo bordo nell'intervallo successivo di lunghezza ( 2. * dMyDist)
+   const double COS_SMALL_ANG_TOL = cos( 4. * DEGTORAD) ;
+   double dSearchLen = dMyDist / 2 ;
+   int NUM_STEP = 10 ;
+   // se poco fuori tolleranza controllo se ho un punto abbastanza vicino con la stessa tangente
+   if ( vtCurr1 * vtCurr2 < COS_SMALL_ANG_TOL) {
+      // Se tanto fuori dalla tolleranza, recupero il miglior versore tangente sul secondo bordo nell'intervallo successivo di lunghezza ( 2. * dMyDist)
+      if ( vtCurr1 * vtCurr2 < COS_ANG_TOL) {
+         dSearchLen = dMyDist ;
+         NUM_STEP = 20 ;
+      }
       pCrvEdge2->GetLengthAtPoint( ptCurr2, dLenCurr2) ;
-      double dLimInfLen2 = Clamp( dLenCurr2 - dMyDist, dLenPrev2, dLen2) ;
-      double dLimSupLen2 = Clamp( dLenCurr2 + dMyDist, dLenPrev2, dLen2) ;
+      double dLimInfLen2 = Clamp( dLenCurr2 - dSearchLen, dLenPrev2, dLen2) ;
+      double dLimSupLen2 = Clamp( dLenCurr2 + dSearchLen, dLenPrev2, dLen2) ;
       // [Controllo migliorabile, magari mendiante metodo di bisezione (?)]
-      const int NUM_STEP = 20 ;
-      double dMinCos = - 1. - EPS_ZERO ;
-      const double DEGTOL = 5. ;
+      
+      double dMin = INFINITO ;
+      const double dCoeff = 0.1 ;
       for ( int i = 0 ; i <= NUM_STEP ; ++ i) {
          double dLen = dLimInfLen2 + i * ( dLimSupLen2 - dLimInfLen2) / NUM_STEP ;
          double dUStep2 ; pCrvEdge2->GetParamAtLength( dLen, dUStep2) ;
          Point3d ptStep2 ; Vector3d vtStep2 = V_NULL ;
          pCrvEdge2->GetPointD1D2( dUStep2, ICurve::FROM_MINUS, ptStep2, &vtStep2) ; vtStep2.Normalize() ;
          double dStepCos2 = vtCurr1 * vtStep2 ;
-         double dAngTol = ( i < NUM_STEP / 2 ? ( 2. * DEGTOL) / NUM_STEP * i :
-            ( - 2. * DEGTOL) / NUM_STEP * ( i - NUM_STEP)) ;
-         double dCosTol = 1. - cos( dAngTol * DEGTORAD) ;
-         if ( dStepCos2 + dCosTol > dMinCos) {
+         double dDist = Dist( ptCurr1, ptCurr2) ;
+         double dVal = (1 - dStepCos2) + dCoeff * dDist / dMyDist ;
+         if ( dVal < dMin) {
             ptCurr2 = ptStep2 ;
             vtCurr2 = vtStep2 ;
             dUCurr2 = dUStep2 ;
-            dMinCos = dStepCos2 + dCosTol ;
+            dMin = dVal ;
          }
       }
    }