EgtMachKernel :

- in Finiture aggiunta costante di approssimazione LIN_TOL_FINE.

GeoConst.h

@@ -21,6 +21,7 @@ const double MIN_SAFEDIST = 5.0 ;
 
 //----------- Costanti per approssimazioni con polilinee o poliarchi --------
 const double LIN_TOL_STD = 0.1 ;
+const double LIN_TOL_FINE = 0.01 ;
 const double LIN_TOL_MID = 0.05 ;
 const double LIN_TOL_RAW = 0.5 ;
 const double ANG_TOL_STD_DEG = 15 ;

OperUserNotesConst.h

@@ -71,8 +71,7 @@ static const std::string UN_STEPNUMBER = "StepNumber" ;
 static const std::string UN_BITANGANG = "BiTangAng" ;
 static const std::string UN_OPTIMALTYPE = "OptimalType" ;
 static const std::string UN_ANGLETOL = "AngleTol" ;
-static const std::string UN_THETA = "Theta" ;
-static const std::string UN_PHI = "Phi" ;
+static const std::string UN_TILT_ANGS = "Tilt" ;
 
 // Solo per SurfRoughing
 static const std::string UN_PLANEZ = "PlaneZ" ;

PocketingNT.cpp

@@ -116,6 +116,7 @@ static double FEED_MAX_COEFF = 1000. ;
 // 2457 = "Warning in PocketingNT : machining step (xxx) bigger than MaxMaterial (yyy)"
 // 2458 = "Warning in PocketingNT : machining depth (xxx) bigger than MaxMaterial (yyy)"
 // 2459 = "Warning in PocketingNT : No compensation in tool, so no compensation in machine"
+// 2460 = "Warning in PocketingNT : Machining toolpath empty"
 
 //----------------------------------------------------------------------------
 // Debug
@@ -3027,12 +3028,52 @@ PocketingNT::CalcLimitRegion( const ISurfFlatRegion* pSfrPock, const ISurfFlatRe
    if ( pSfrLimit == nullptr  ||  ! pSfrLimit->IsValid())
       return false ;
   // piccolo Offset di correzione
-   PtrOwner<ISurfFlatRegion> pSfrOffs( pSfrPock->CreateOffsetSurf( 10 * EPS_SMALL, ICurve::OFF_FILLET)) ;
+   PtrOwner<ISurfFlatRegion> pSfrOffs( pSfrPock->CreateOffsetSurf( 10. * EPS_SMALL, ICurve::OFF_FILLET)) ;
    if ( IsNull( pSfrOffs)  ||  ! pSfrOffs->IsValid())
       return false ;
   // sottrazione
    pSfrLimit->Subtract( *pSfrOffs) ;
 
+  // se la superficie corrente ha delle isole aperte interne al grezzo, la prevalenza va sulle isole aperte
+  // [NB. Queste isole potrebbero essere definite sul bordo del grezzo, seza che vengano riconosciute come lati aperti interni al grezzo,
+  //      per estrerema sicurezza semplifico la regione Limite]
+   if ( pSfrLimit->IsValid()) {
+      for ( int nC = 0 ; nC < pSfrPock->GetChunkCount() && pSfrLimit->IsValid() ; ++ nC) {
+         int nLoopCnt = ( pSfrPock->GetLoopCount( nC)) ;
+         if ( nLoopCnt > 1) {
+           // raggio di riferimento per offset
+            double dOutEdge = 0.5 * m_TParams.m_dDiam ;
+            if ( m_Params.m_nSubType == POCKET_SPIRALIN  ||  m_Params.m_nSubType == POCKET_ZIGZAG)
+               dOutEdge = max( dOutEdge,  m_TParams.m_dDiam - m_Params.m_dSideStep) ;
+            double dExtension = dOutEdge + GetOffsR() + 100. * EPS_SMALL ;
+            for ( int nL = 1 ; nL < nLoopCnt && pSfrLimit->IsValid() ; ++ nL) {
+               PtrOwner<ICurveComposite> pInternalLoop( ConvertCurveToComposite( pSfrPock->GetLoop( nC, nL))) ;
+               if ( IsNull( pInternalLoop)  ||  ! pInternalLoop->IsValid())
+                  return false ;
+               ICRVCOMPOPOVECTOR vCrv ;
+               GetHomogeneousParts( pInternalLoop, vCrv) ;
+               if ( ssize( vCrv) == 1  &&  vCrv[0]->GetTempProp() == TEMP_PROP_OPEN_EDGE) {
+                 // considero la curva come chiusa, le isole non sono definite
+                  OffsetCurve OffsCrv ;
+                  OffsCrv.Make( pInternalLoop, dExtension, ICurve::OFF_FILLET) ;
+                  PtrOwner<ICurve> pCrvOffs( OffsCrv.GetLongerCurve()) ;
+                  if ( ! IsNull( pCrvOffs)  &&  pCrvOffs->IsValid()) {
+                     SurfFlatRegionByContours SfrByC ;
+                     SfrByC.AddCurve( Release( pCrvOffs)) ;
+                     SfrByC.AddCurve( CloneCurveComposite( pInternalLoop)) ;
+                     PtrOwner<ISurfFlatRegion> pSfrSub( SfrByC.GetSurf()) ;
+                     if ( ! IsNull( pSfrSub)  &&  pSfrSub->IsValid()) {
+                        if ( AreOppositeVectorApprox( pSfrSub->GetNormVersor(), pSfrLimit->GetNormVersor()))
+                           pSfrSub->Invert() ;
+                        pSfrLimit->Subtract( *pSfrSub) ;
+                     }
+                  }
+               }
+            }
+         }
+      }
+   }
+
   // se richiesto non controllo dei lati aperti
    if ( m_bOpenOutRaw  &&  pSfrLimit->IsValid()) {
       double dExtension = 4. * m_TParams.m_dDiam + max( 0., m_dOpenMinSafe) + EPS_SMALL ;
@@ -4049,6 +4090,7 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId)
    }
 
   // se richiesta lavorazione
+   bool bEmptyPocket = false ;
    if ( nClId != GDB_ID_NULL) {
      // creo gruppo per geometria di lavorazione del percorso
       int nPxId = m_pGeomDB->AddGroup( GDB_ID_NULL, nClId, Frame3d()) ;
@@ -4189,7 +4231,7 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId)
      // calcolo le lavorazioni
       Point3d ptPockStart ; pSfr->GetCentroid( ptPockStart) ;
       Point3d ptPockEnd = ptPockStart ;
-      if ( ! AddPocket( vStepInfo, vtTool, dStep, bSplitArcs, ptPockStart, ptPockEnd))
+      if ( ! AddPocket( vStepInfo, vtTool, dStep, bSplitArcs, ptPockStart, ptPockEnd, bEmptyPocket))
          return false ;
 
      // assegno il vettore estrazione al gruppo del percorso
@@ -4216,7 +4258,8 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId)
    }
 
   // incremento numero di svuotature
-   ++ m_nPockets ;
+   if ( ! bEmptyPocket)
+      ++ m_nPockets ;
 
    return true ;
 }
@@ -4701,11 +4744,12 @@ PocketingNT::CalcRetCurve( PathInfoPO& PathInfo, const StepInfoPO& StepInfo, con
 
 //----------------------------------------------------------------------------
 bool
-PocketingNT::CalcPaths( STEPINFOPOVECTOR& vStepInfo)
+PocketingNT::CalcPaths( STEPINFOPOVECTOR& vStepInfo, bool& bEmpty)
 {
   // se non ho Step, non faccio nulla
    if ( vStepInfo.empty())
       return true ;
+   bEmpty = false ;
 
   // definisco il tipo di punto iniziale
    enum START_PT { DEFAULT = 0, BY_USER = 1, BY_HEAD = 2, BY_OPEN_GEO = 3, BY_CLOSE_GEO = 4} ;
@@ -4800,8 +4844,11 @@ PocketingNT::CalcPaths( STEPINFOPOVECTOR& vStepInfo)
          return false ;
       }
      // se non ho ottenuto percorsi, errore
-      if ( vCrvPaths.empty())
-         return false ;
+      if ( vCrvPaths.empty()) {
+         m_pMchMgr->SetWarning( 2460, "Warning in PocketingNT : Machining toolpath empty") ;
+         bEmpty = true ;
+         return true ;
+      }
      // sistemo gli archi per massimo angolo al centro
       for ( int j = 0 ; j < ssize( vCrvPaths) ; ++ j)
          VerifyArcs( vCrvPaths[j]) ;
@@ -5326,15 +5373,21 @@ PocketingNT::CalcDoubleParallelPenultimateStep( int nDouble, int nIdDblS, double
 //----------------------------------------------------------------------------
 bool
 PocketingNT::AddPocket( STEPINFOPOVECTOR& vStepInfo, const Vector3d& vtTool, double dStep, bool bSplitArcs,
-                        Point3d& ptPockStart, Point3d& ptPockEnd)
+                        Point3d& ptPockStart, Point3d& ptPockEnd, bool& bEmpty)
 {
   // se non ho superfici da svuotare, non faccio nulla
    if ( vStepInfo.empty())
       return true ;
 
   // calcolo i percorsi di svuotatura per ogni Step/SubStep
-   if ( ! CalcPaths( vStepInfo))
+   if ( ! CalcPaths( vStepInfo, bEmpty))
       return false ;
+  // se svuotatura vuota, aggiorno la ProgressBar ed esco
+   if ( bEmpty) {
+      ExeProcessEvents( 100, 0) ;
+      return true ;
+   }
+
    #if DEBUG_FEED
       nGrpDebugFeed = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ;
       nLayDebugFeed = m_pGeomDB->AddGroup( GDB_ID_NULL, nGrpDebugFeed, GLOB_FRM) ;
@@ -5669,7 +5722,7 @@ PocketingNT::AddPocket( STEPINFOPOVECTOR& vStepInfo, const Vector3d& vtTool, dou
       }
    }
 
-  // aggiorno per sicurezza la ProgressBar nel caso di Step vuoti
+  // aggiorno per sicurezza la ProgressBar
    ExeProcessEvents( 100, 0) ;
    return true ;
 }

PocketingNT.h

@@ -137,10 +137,11 @@ class PocketingNT : public Machining
       bool CalcGeoExtSurfFr( const ISurfFlatRegion* pSfrPock, const Vector3d& vtTool, double dDepth, const ISurfTriMesh* pStmRaw,
                              const SELVECTOR& vGeoSel, ISURFFRPOVECTOR& vSfrGeoExt) ;
       bool CalcLimitRegion( const ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrRaw, ISurfFlatRegion* pSfrLimit) ;
-      bool CalcPaths( STEPINFOPOVECTOR& vStepInfo) ;
+      bool CalcPaths( STEPINFOPOVECTOR& vStepInfo, bool& bEmpty) ;
       bool CalcRetCurve( PathInfoPO& PathInfo, const StepInfoPO& StepInfo, const ICurveComposite* pCrvPath,
                          const Vector3d& vtTool, bool bHolePocketing, const Point3d& ptHoleDest, bool bToolComp, bool bInVsOut, ICurveComposite* pCrvGlide) ;
-      bool AddPocket( STEPINFOPOVECTOR& vStepInfo, const Vector3d& vtTool, double dStep, bool bSplitArcs, Point3d& ptPockStart, Point3d& ptPockEnd) ;
+      bool AddPocket( STEPINFOPOVECTOR& vStepInfo, const Vector3d& vtTool, double dStep, bool bSplitArcs, Point3d& ptPockStart, Point3d& ptPockEnd,
+                      bool& bEmpty) ;
       double GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) const ;
       double GetRightStartFeed( const Vector3d& vtMove, const Vector3d& vtTool) const ;
       bool CutCurveWithLine( ICurveComposite* pCrvA, const ICurveLine* pCrvB) ;

SurfFinishing.h

@@ -100,21 +100,27 @@ class SurfFinishing : public Machining
 
    public :
       SurfFinishing( void) ;
+      Frame3d GetFrame() const { return m_Frame ; } ;                           // spostare in Machining se tutto ok
+      Frame3d& GetFrame() { return m_Frame ; } ;                                // spostare in Machining se tutto ok
+      void SetFrame( const Frame3d& frFinishing) { m_Frame = frFinishing ; } ;  // spostare in Machining se tutto ok
 
    private :
       bool MyApply( bool bRecalc, bool bPostApply) ;
       bool VerifyGeometry( SelData Id, int& nSubs) ;
       bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
       bool Chain( int nGrpDestId) ;
+      bool FlattenCurves( ICURVEPOVECTOR& vpCrv) const ;
+      bool UpdateFrameAndToolDir( int nAuxId, bool& bRecalc) ;
       bool GetSurfacesByIds( SURFLOCALVECTOR& vSrfLoc, SURFLOCALVECTOR& vSrfSuppLoc, Frame3d& frSurf) ;
-      bool CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dRad, double dLen, double& dElev) const ; ;
+      bool CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dRad, double dLen, double& dElev) const ;
       bool SetCAvTlStmForSurfaces( ICAvToolSurfTm* pCAvTlStm, const ISurfFlatRegion* pSfrCnt, double dDepth,
                                    double dToolLen, double dToolDiam, double dToolCornRad,
                                    double dToolSideAng, double dToolMaxMat, double dMachOffsR,
                                    const SURFLOCALVECTOR& vSurfLoc, const SURFLOCALVECTOR& vSurfSuppLoc) ;
-      bool EraseMaxDownSurf( const SURFLOCALVECTOR& vSurfLoc, const Frame3d& frSurf, const Vector3d& vtTool,
-                             double dDepth, ISurfFlatRegion* pSfrCnt) ;
-      bool ProcessCrvCompo( int nPathId, int nPvId, int nClId) ;
+      bool EraseMaxDownSurf( const SURFLOCALVECTOR& vSurfLoc, const Frame3d& frSurf, const Vector3d& vtMove,
+                             double dDepth, ISurfFlatRegion* pSfrCnt) const ;
+      bool EraseMaxDownStartEndPolyLine( PolyLine& PL) const ;
+      bool ProcessCrv( int nPathId, int nPvId, int nClId) ;
       bool ProcessSfr( int nPathId, int nPvId, int nClId) ;
       bool SimplifyCurve( ICurveComposite* pCompo, const Frame3d& frLocXY,
                           double dMergeLinTol = 200. * EPS_SMALL, double dMergeAndTolDeg = 200. * EPS_ANG_SMALL,
@@ -126,26 +132,26 @@ class SurfFinishing : public Machining
                                     ICurveComposite* pCrv) const ;
      // lavorazioni per superfici
       bool AddZigZag( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
-                      const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
+                      const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs) ;
       bool AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
-                      const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
+                      const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs) ;
       bool AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
-                      const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs, bool bInVsOut) ;
+                      const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs, bool bInVsOut) ;
       bool AddZConst( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
                       const ISurfFlatRegion* pSfrCnt, const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
       bool AddOptimal( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
                        const ISurfFlatRegion* pSfrCntZigZag, const ISurfFlatRegion* pSfrCntZConst, const Vector3d& vtTool,
-                       double dDepth, double dElev, bool bSplitArcs) ;
+                       const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs) ;
       bool AddPencil( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
                       const ISurfFlatRegion* pSfrCnt, const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
      // lavorazioni per curve
       bool AddProjection( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ICurveComposite* pCompo,
-                          const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
+                          const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs) ;
      // creazione del percorso finale di lavorazione
       bool AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ICRVCOMPOPOVECTOR& vCrvCompo,
-                         const Vector3d& vtTool, double dElev, double dDepth, bool bSplitArcs) ;
+                         const Vector3d& vtTool, const Vector3d& vtMove, double dElev, double dDepth, bool bSplitArcs) ;
      // collisione con i percorsi di lavorazione
-      bool CorrectPathByCollision( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Vector3d& vtTool,
+      bool CorrectPathByCollision( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Vector3d& vtTool, const Vector3d& vtMove,
                                    double dDepth, ICRVCOMPOPOVECTOR& vpCrvs) ;
 
       bool WorkPencilCurves( const ICRVCOMPOPOVECTOR& vCrvCompo, const ISurfFlatRegion* pSfrCnt, int nPencilType, double dOffs, int nOffs,
@@ -198,13 +204,12 @@ class SurfFinishing : public Machining
       bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, bool bSplitArcs) ;
       bool CalcLeadOutEnd( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtTool, const Vector3d& vtNorm, Point3d& ptP1) const ;
       bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Point3d& ptP1, const Vector3d& vtTool, bool bSplitArcs) ;
-      bool GetLastGoodPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Point3d& ptStart,
-                             const Point3d& ptEnd, const Vector3d& vtInit, const Vector3d& vtTool,
-                             bool bLeadInVsOut, Point3d& ptP1) const ;
-      bool GetLinkFromPaths( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtTool, const ISurfFlatRegion* pSfrCnt,
+      bool GetLastGoodPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Point3d& ptStart, const Point3d& ptEnd,
+                             const Vector3d& vtInit, const Vector3d& vtTool, const Vector3d& vtMove, bool bLeadInVsOut, Point3d& ptP1) const ;
+      bool GetLinkFromPaths( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtTool, const Vector3d& vtMove, const ISurfFlatRegion* pSfrCnt,
                              double dDepth, double dSafeZ, ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, ICurveComposite* pCrvLink) const ;
       bool GetSurfaceNormalAtPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf,
-                                    const Point3d& ptTool, const Vector3d& vtTool, Vector3d& vtNorm) const ;
+                                    const Point3d& ptTool, const Vector3d& vtTool, const Vector3d& vtMove, Vector3d& vtNorm) const ;
       bool GetActiveSurfaces( INTVECTOR& vSurfId, INTVECTOR& vSurfSuppId) const ;
       int ProcessSquare( int nFlag, double dLevel, double dQPt0, double dQpt1, double dQpt2, double dQpt3,
                          int& nI1s, int& nI1e, int& nI2s, int& nI2e) const ;
@@ -218,10 +223,11 @@ class SurfFinishing : public Machining
                             double dLimInfClippingAng, double dLimSupClippingAng, const Vector3d& vtAxL, const Vector3d& vtMoveL, ICAvToolSurfTm* pCAvTlStm,
                             ICRVCOMPOPOVECTOR& vCrvCompo) const ;
       bool AreSameSfrChunkEpsilon( const ISurfFlatRegion* pSfrChunkA, const ISurfFlatRegion* pSfrChunkB, double dMaxDist) const ;
-      bool CalcOptimalZigZagRegion( const ISurfFlatRegion* pSfrCntLoc, const ISurfFlatRegion* pSfrZLevelColl, const SURFLOCALVECTOR& vSrfLoc,
-                                    const Frame3d& frSurf, const Vector3d& vtTool, double dDepth, double dSplitAngDeg, ISURFFRPOVECTOR& vpSfrZigZagProj) const ;
+      bool CalcOptimalZigZagRegion( const ISurfFlatRegion* pSfrCntLoc, const ISurfFlatRegion* pSfrZLevelColl, ISURFFRPOVECTOR& vpSfrZigZagProj) const ;
       double GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) const ;
       double GetRadiusForStartEndElevation( void) const ;
+      double GetLocalSideAngle() const ;
+      bool GetLocalToolDir( Vector3d& vtToolLoc) const ;
 
    private :
       double GetSpeed() const
@@ -238,6 +244,7 @@ class SurfFinishing : public Machining
          { return ( IsUnknownValue( m_Params.m_dOffsR) ? m_TParams.m_dOffsR : m_Params.m_dOffsR) ; }
       double GetSideStep( void) const
          { return Clamp( m_Params.m_dSideStep, 0.1, m_TParams.m_dTDiam) ; }
+      
       int GetLeadInType( void) const ;
       int GetLeadOutType( void) const ;
 
@@ -245,6 +252,9 @@ class SurfFinishing : public Machining
       SELVECTOR         m_vId ;             // identificativi entità geometriche da lavorare
       SurfFinishingData m_Params ;          // parametri lavorazione
       ToolData          m_TParams ;         // parametri utensile
+      Frame3d           m_Frame ;           // terna per orientamento finitura ZigZag/OneWay
+      double            m_dTheta ;          // orientamento verticale utensile rispetto a m_Frame
+      double            m_dPhi ;            // orientamento orizzontale utesnile rispetto a m_Frame
       double            m_dTHoldBase ;      // posizione base del porta-utensile
       double            m_dTHoldLen ;       // lunghezza del porta-utensile
       double            m_dTHoldDiam ;      // diametro del porta-utensile