Merge commit '025eea9c0f0d77443110bc2fc19c3a2e6ee89c45' into svuotature

2023-03-28 15:56:27 +02:00
parent 3d5398f877 025eea9c0f
commit 4d676c1f3b
23 changed files with 1029 additions and 292 deletions
@@ -172,13 +172,32 @@ Operation::GetElevation( int nPhase, const Point3d& ptP,
                         const Vector3d& vtDir, double& dElev) const
 {
   Vector3d vtNorm ;
-   return GetElevation( nPhase, ptP, vtDir, dElev, vtNorm) ;
+   INTVECTOR vRawStmId ;
+   return GetElevation( nPhase, ptP, vtDir, dElev, vtNorm, vRawStmId) ;
 }

 //----------------------------------------------------------------------------
 bool
 Operation::GetElevation( int nPhase, const Point3d& ptP,
                         const Vector3d& vtDir, double& dElev, Vector3d& vtNorm) const
+{
+   INTVECTOR vRawStmId ;
+   return GetElevation( nPhase, ptP, vtDir, dElev, vtNorm, vRawStmId) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Operation::GetElevation( int nPhase, const Point3d& ptP,
+                         const Vector3d& vtDir, double& dElev, INTVECTOR& vRawStmId) const
+{
+   Vector3d vtNorm ;
+   return GetElevation( nPhase, ptP, vtDir, dElev, vtNorm, vRawStmId) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Operation::GetElevation( int nPhase, const Point3d& ptP,
+                         const Vector3d& vtDir, double& dElev, Vector3d& vtNorm, INTVECTOR& vRawStmId) const
 {
   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
      return false ;
@@ -242,11 +261,13 @@ Operation::GetElevation( int nPhase, const Point3d& ptP,
                  }
               }
            }
-           // se c'è triangolo di intersezione, ne recupero la normale
+           // se c'è triangolo di intersezione, ne recupero la normale e salvo Id del grezzo
            if ( nTria != SVT_NULL) {
               Triangle3d Tria ;
               if ( pStm->GetTriangle( nTria, Tria))
                  vtNorm = Tria.GetN() ;
+               if ( find( vRawStmId.begin(), vRawStmId.end(), nStmId) == vRawStmId.end())
+                  vRawStmId.emplace_back( nStmId) ;
            }
         }
      }
@@ -365,32 +386,83 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool,
 {
   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
      return false ;
+  // vettore grezzi interessati
+   INTVECTOR vRawStmId ;
  // considero il punto centrale
-   if ( ! GetElevation( nPhase, ptP, vtDir, dElev))
+   if ( ! GetElevation( nPhase, ptP, vtDir, dElev, vRawStmId))
      return false ;
-  // considero più direzioni sulla circonferenza
-   const int MIN_STEP = 8 ;
-   const double LEN_STEP = 25 ;
-   int nStep = max( int( ( 2 * PIGRECO * dRad) / LEN_STEP), MIN_STEP) ;
+  // considero più posizioni sulla circonferenza
+   const int MIN_STEP = 9 ;
+   const int MAX_STEP = 127 ;
+   const double LEN_STEP = 12.5 ;
+   int nStep = Clamp( 2 * int( ( PIGRECO * dRad) / LEN_STEP) + 1, MIN_STEP, MAX_STEP) ;
   Vector3d vtRad = FromUprightOrtho( vtTool) * dRad ;
   for ( int i = 0 ; i < nStep ; ++ i) {
-     // esploro 4 posizioni sulle direzioni
-      for ( int j = 1 ; j <= 8 ; j *= 2) {
-         double dElevT = 0 ;
-         if ( ! GetElevation( nPhase, ptP + vtRad / j, vtDir, dElevT))
-            return false ;
-         dElev = max( dElev, dElevT) ;
-      }
+      double dElevT = 0 ;
+      if ( ! GetElevation( nPhase, ptP + vtRad, vtDir, dElevT, vRawStmId))
+         return false ;
+      dElev = max( dElev, dElevT) ;
     // passo alla direzione successiva
      vtRad.Rotate( vtTool, ANG_FULL / nStep) ;
   }
+  // considero i vertici che cadono entro il cilindro positivo spazzato dal fondo utensile
+   for ( auto nRawStmId : vRawStmId) {
+     // recupero la superficie
+      const ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nRawStmId)) ;
+      if ( pStm != nullptr) {
+        // recupero il riferimento della trimesh
+         Frame3d frStm ;
+         m_pGeomDB->GetGlobFrame( nRawStmId, frStm) ;
+        // ciclo sui vertici
+         Point3d ptV ;
+         int nV = pStm->GetFirstVertex( ptV) ;
+         while ( nV != SVT_NULL) {
+            ptV.ToGlob( frStm) ;
+            double dDist = ( ptV - ptP) * vtDir ;
+            if ( dDist > EPS_ZERO) {
+               if ( AreSameOrOppositeVectorApprox( vtTool, vtDir)) {
+                  Vector3d vtOrtho = OrthoCompo( ptV - ptP, vtDir) ;
+                  if ( vtOrtho.SqLen() < dRad * dRad + EPS_ZERO)
+                     dElev = max( dElev, dDist) ;
+               }
+               else {
+                  Vector3d vtOrtho = OrthoCompo( ptV - ptP, vtDir) ;
+                  Vector3d vtMajAx = vtTool ^ vtDir ; vtMajAx.Normalize() ;
+                  Vector3d vtMajOrt = ParallCompo( vtOrtho, vtMajAx) ;
+                  Vector3d vtMinOrt = ( vtOrtho - vtMajOrt) / abs( vtTool * vtDir) ;
+                  if ( vtMajOrt.SqLen() + vtMinOrt.SqLen() < dRad * dRad + EPS_ZERO)
+                     dElev = max( dElev, dDist) ;
+               }
+            }
+            nV = pStm->GetNextVertex( nV, ptV) ;
+         }
+      }
+   }
+
   return true ;
 }

 //----------------------------------------------------------------------------
 bool
-Operation::GetPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev,
-                             double dToolLen, bool bIsSaw, double dSafeZ, const Vector3d& vtDir, double& dElev) const
+Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad, double dLen,
+                         const Vector3d& vtDir, double& dElev) const
+{
+   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
+      return false ;
+  // sopra e sotto
+   double dElev1, dElev2 ;
+   if ( ! GetElevation( nPhase, ptP, vtTool, dRad, vtDir, dElev1))
+      return false ;
+   if ( ! GetElevation( nPhase, ptP + dLen * vtTool, vtTool, dRad, vtDir, dElev2))
+      return false ;
+   dElev = max( dElev1, dElev2) ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Operation::GetAhPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev,
+                               double dToolLen, bool bIsSaw, double dSafeZ, const Vector3d& vtDir, double& dElev) const
 {
  // punto a metà lunghezza utensile
   Point3d ptQ = ptP + vtTool * dToolLen / 2 ;
@@ -710,6 +782,66 @@ Operation::GetSignedDistFromStmRaw( int nPhase, const Point3d ptP, const Vector3
 }


+//----------------------------------------------------------------------------
+bool
+Operation::GetUhPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev,
+                               double dToolLen, bool bIsSaw, double dSafeZ, const Vector3d& vtDir, double& dElev) const
+{
+  // punto a metà lunghezza utensile
+   Point3d ptQ = ptP + vtTool * dToolLen / 2 ;
+  // box di ingombro dell'utensile
+   BBox3d b3Tool ;
+   b3Tool.Set( ptP) ;
+   b3Tool.Add( ptQ) ;
+   double dExpandX = sqrt( 1 - vtTool.x * vtTool.x) * dToolRadForElev ;
+   double dExpandY = sqrt( 1 - vtTool.y * vtTool.y) * dToolRadForElev ;
+   double dExpandZ = sqrt( 1 - vtTool.z * vtTool.z) * dToolRadForElev ;
+   b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ;
+  // extra ingombro reale in Z
+   double dExtraZ = sqrt( 1 - vtTool.z * vtTool.z) * dToolRad ; 
+  // direzione di fuga per l'elevazione
+   Vector3d vtMyDir = vtDir ;
+   if ( bIsSaw  ||  vtMyDir.z > EPS_SMALL)
+      vtMyDir.z = 0 ;
+   vtMyDir.Normalize() ;
+  // determino la posizione del punto rispetto al grezzo
+  // ciclo sui grezzi
+   int nRawId = m_pMchMgr->GetFirstRawPart() ;
+   while ( nRawId != GDB_ID_NULL) {
+     // se il grezzo compare nella fase
+      if ( m_pMchMgr->VerifyRawPartPhase( nRawId, m_nPhase)) {
+         int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
+         BBox3d b3Raw ;
+         m_pGeomDB->GetGlobalBBox( nStmId, b3Raw) ;
+         b3Raw.Expand( 0.5 * dSafeZ, 0.5 * dSafeZ, 0) ;
+         if ( ! b3Raw.IsEmpty()  &&  b3Raw.OverlapsXY( b3Tool)  &&  ptP.z - dExtraZ > b3Raw.GetMax().z + 10 * EPS_SMALL) {
+            double dRawCentZ = ( b3Raw.GetMin().z + b3Raw.GetMax().z) / 2 ;
+            double dRawDimZ = b3Raw.GetMax().z - b3Raw.GetMin().z ;
+            double dToolDimZ = b3Tool.GetMax().z - b3Tool.GetMin().z ;
+           // determino elevazione del punto rispetto al grezzo a metà altezza
+            Point3d ptTest( ptP.x, ptP.y, dRawCentZ) ; 
+            double dNewElev ;
+            if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
+               dElev = max( dElev, dNewElev) ;
+           // se direzione di fuga quasi orizzontale (max 30 deg) e ingombro utensile rilevante rispetto ad altezza grezzo
+            if ( vtMyDir.z > -0.5  &&  dToolDimZ > dRawDimZ / 2) {
+              // determino elevazione del punto rispetto al grezzo a metà altezza più metà ingombro utensile
+               ptTest = Point3d( ptP.x, ptP.y, dRawCentZ + dToolDimZ / 2) ; 
+               if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
+                  dElev = max( dElev, dNewElev) ;
+              // determino elevazione del punto rispetto al grezzo a metà altezza meno metà ingombro utensile
+               ptTest = Point3d( ptP.x, ptP.y, dRawCentZ - dToolDimZ / 2) ; 
+               if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
+                  dElev = max( dElev, dNewElev) ;
+            }
+            return true ;
+         }
+      }
+      nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
+   }
+   return false ;
+}
+
 //----------------------------------------------------------------------------
 bool
 Operation::GetDistanceFromRawSide( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dDist) const
@@ -1292,7 +1424,7 @@ Operation::ApproxWithArcsIfUseful( ICurveComposite* pCompo, bool bCareTempProp)
            for ( int j = 0 ; j < pCC->GetCurveCount() ; ++ j)
               pCC->SetCurveTempProp( j, vInt[i].second) ;
           // reinserisco nel vettore di curve
-            vpCrvs.back().Set( Release( pCC)) ;
+            vpCrvs.back().Set( pCC) ;
         }
      }
     // riassemblo la curva e assegno le opportune proprietà
@@ -3092,7 +3224,7 @@ Operation::CalcDeltaZForHeadRotation( const DBLVECTOR& vAxStart, const DBLVECTOR
 bool
 Operation::GetExtraZ( const DBLVECTOR& vAx1, const Vector3d& vtTool1,
                      const DBLVECTOR& vAx2, const Vector3d& vtTool2,
-                      double dSafeZ, double& dExtraZ) const
+                      double dHomeZ, double& dExtraZ) const
 {
  // Recupero macchina corrente
   Machine* pMch = ( m_pMchMgr != nullptr ?  m_pMchMgr->GetCurrMachine() : nullptr) ;
@@ -3114,12 +3246,12 @@ Operation::GetExtraZ( const DBLVECTOR& vAx1, const Vector3d& vtTool1,
   if ( SpecialGetMaxZ( vAx1, vtTool1, vAx2, vtTool2, dMaxZ)) {
     // se caso standard
      if ( ! bZHomeDown) {
-         dExtraZ = min( dMaxZ, dAxZmax) - dSafeZ ;
+         dExtraZ = min( dMaxZ, dAxZmax) - dHomeZ ;
         return ( dExtraZ > EPS_SMALL) ;
      }
     // altrimenti caso con posizione sicura in basso (teste da sotto)
      else {
-         dExtraZ = max( dMaxZ, dAxZmin) - dSafeZ ;
+         dExtraZ = max( dMaxZ, dAxZmin) - dHomeZ ;
         return ( dExtraZ < EPS_SMALL) ;
      }
   }
@@ -3144,14 +3276,14 @@ Operation::GetExtraZ( const DBLVECTOR& vAx1, const Vector3d& vtTool1,
      if ( ! bZHomeDown) {
         double dZmax ;
         pMch->GetCurrAxisMax( 2, dZmax) ;
-         dExtraZ = min( vdVal[0], dZmax - dSafeZ) ;
+         dExtraZ = min( vdVal[0], dZmax - dHomeZ) ;
         return ( dExtraZ > EPS_SMALL) ;
      }
     // altrimenti caso con posizione sicura in basso (teste da sotto)
      else {
         double dZmin ;
         pMch->GetCurrAxisMin( 2, dZmin) ;
-         dExtraZ = max( vdVal[0], dZmin - dSafeZ) ;
+         dExtraZ = max( vdVal[0], dZmin - dHomeZ) ;
         return ( dExtraZ < EPS_SMALL) ;
      }
   }