EgtGeomKernel :

- InTestSurfTmSurfTm affinato il controllo collisione quando una delle due superfici è chiusa e contiene l'altra. In CalcPocketing aggiunta piccola miglioria.
2026-01-23 12:38:16 +01:00
parent f72c949563
commit c2a79b2665
2 changed files with 29 additions and 23 deletions
@@ -7,7 +7,7 @@
 //
 // Modifiche : 13.11.20 LM Creazione modulo.
 //             24.03.24 DS Aggiunta TestSurfTmSurfTm.
-//             23.01.26 DS In TestSurfTmSurfTm aggiunto flag per collisione quando una delle due è chiusa e contiene l'altra.
+//             23.01.26 DS In TestSurfTmSurfTm aggiunto flag per collisione quando una delle due è chiusa e contiene l'altra.
 //
 //----------------------------------------------------------------------------

@@ -46,10 +46,10 @@ CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& Surf
   BBox3d b3BoxA, b3BoxB ;
   pSrfA->GetLocalBBox( b3BoxA) ;
   pSrfB->GetLocalBBox( b3BoxB) ;
-  // Se è necessario, espando il box di B di una costante additiva pari alla distanza di sicurezza.
+  // Se è necessario, espando il box di B di una costante additiva pari alla distanza di sicurezza.
   if ( dSafeDist > EPS_SMALL)
      b3BoxB.Expand( dSafeDist) ;
-  // Se i box non si sovrappongono, non c'è collisione. Ho finito.
+  // Se i box non si sovrappongono, non c'è collisione. Ho finito.
   if ( ! b3BoxA.Overlaps( b3BoxB))
      return false ;
  // Recupero i triangoli di A che interferiscono col box di B
@@ -62,13 +62,13 @@ CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& Surf
         continue ;
      BBox3d b3BoxTriaA ;
      trTriaA.GetLocalBBox( b3BoxTriaA) ;
-     // Se è necessario, espando il box di una costante additiva pari alla distanza di sicurezza.
+     // Se è necessario, espando il box di una costante additiva pari alla distanza di sicurezza.
      if ( dSafeDist > EPS_SMALL)
         b3BoxTriaA.Expand( dSafeDist) ;
     // Recupero i triangoli di B che interferiscono col box del triangolo di A
      INTVECTOR vNearTria ;
      pSrfB->GetAllTriaOverlapBox( b3BoxTriaA, vNearTria) ;
-     // Settare tutti i triangoli come già processati.
+     // Settare tutti i triangoli come già processati.
     // Al termine della chiamata i TempInt dei triangoli valgono 0.
      pSrfB->ResetTempInts() ;
     // Ciclo sui triangoli della superficie B che cadono nel box del triangolo corrente della Superficie A.
@@ -85,14 +85,14 @@ CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& Surf
           // Ciclo sui vertici del triangolo.
            for ( int nVB = 0 ; nVB < 3 ; ++ nVB) {
              // Se il triangolo adiacente al triangolo corrente su questo edge
-              // non è stato processato, processo il vertice e l'edge.
+              // non è stato processato, processo il vertice e l'edge.
               int nAdjTriaTempFlag ;
               if ( ! ( pSrfB->GetTempInt( nAdjTriaId[nVB], nAdjTriaTempFlag)  ||  nAdjTriaTempFlag == 0))
                  continue ;
-              // Processo il vertice: se c'è collisione fra triangolo A e sfera ho finito.
+              // Processo il vertice: se c'è collisione fra triangolo A e sfera ho finito.
               if ( CDeSimpleSpheTria( trTriaB.GetP( nVB), dSafeDist, trTriaA))
                  return true ;
-              // Processo l'edge: se c'è collisione fra triangolo A e cilindro ho finito.
+              // Processo l'edge: se c'è collisione fra triangolo A e cilindro ho finito.
               Vector3d vtEdgeV = trTriaB.GetP( ( nVB + 1) % 3) - trTriaB.GetP( nVB) ;
               double dEdgeLen = vtEdgeV.Len() ;
               vtEdgeV /= dEdgeLen ;
@@ -112,10 +112,10 @@ CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& Surf
      }
   }
  // Non ho trovato collisioni fra triangoli delle superfici.
-  // Se il BBox della prima superficie non è interno a quello della seconda e viceversa, non c'è collisione
+  // Se il BBox della prima superficie non è interno a quello della seconda e viceversa, non c'è collisione
   if ( ! b3BoxA.Encloses( b3BoxB)  &&  ! b3BoxB.Encloses( b3BoxA))
      return false ;
-  // La collisione c'è se una superficie è dentro l'altra.
+  // La collisione c'è se una superficie è dentro l'altra.
   Point3d ptPointA, ptPointB ;
   pSrfA->GetFirstVertex( ptPointA) ;
   pSrfB->GetFirstVertex( ptPointB) ;
@@ -141,10 +141,10 @@ TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double d
   BBox3d b3BoxA, b3BoxB ;
   pSrfA->GetLocalBBox( b3BoxA) ;
   pSrfB->GetLocalBBox( b3BoxB) ;
-  // Se è necessario, espando il box di B di una costante additiva pari alla distanza di sicurezza.
+  // Se è necessario, espando il box di B di una costante additiva pari alla distanza di sicurezza.
   if ( dSafeDist > EPS_SMALL)
      b3BoxB.Expand( dSafeDist) ;
-  // Se i box non si sovrappongono, non c'è collisione. Ho finito.
+  // Se i box non si sovrappongono, non c'è collisione. Ho finito.
   if ( ! b3BoxA.Overlaps( b3BoxB))
      return false ;
  // Recupero i triangoli di A che interferiscono col box di B
@@ -157,13 +157,13 @@ TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double d
         continue ;
      BBox3d b3BoxTriaA ;
      trTriaA.GetLocalBBox( b3BoxTriaA) ;
-     // Se è necessario, espando il box di una costante additiva pari alla distanza di sicurezza.
+     // Se è necessario, espando il box di una costante additiva pari alla distanza di sicurezza.
      if ( dSafeDist > EPS_SMALL)
         b3BoxTriaA.Expand( dSafeDist) ;
     // Recupero i triangoli di B che interferiscono col box del triangolo di A
      INTVECTOR vNearTria ;
      pSrfB->GetAllTriaOverlapBox( b3BoxTriaA, vNearTria) ;
-     // Settare tutti i triangoli come già processati.
+     // Settare tutti i triangoli come già processati.
     // Al termine della chiamata i TempInt dei triangoli valgono 0.
      pSrfB->ResetTempInts() ;
     // Ciclo sui triangoli della superficie B che cadono nel box del triangolo corrente della Superficie A.
@@ -180,14 +180,14 @@ TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double d
           // Ciclo sui vertici del triangolo.
            for ( int nVB = 0 ; nVB < 3 ; ++ nVB) {
              // Se il triangolo adiacente al triangolo corrente su questo edge
-              // non è stato processato, processo il vertice e l'edge.
+              // non è stato processato, processo il vertice e l'edge.
               int nAdjTriaTempFlag ;
               if ( ! ( pSrfB->GetTempInt( nAdjTriaId[nVB], nAdjTriaTempFlag)  ||  nAdjTriaTempFlag == 0))
                  continue ;
-              // Processo il vertice: se c'è collisione fra triangolo A e sfera ho finito.
+              // Processo il vertice: se c'è collisione fra triangolo A e sfera ho finito.
               if ( CDeSimpleSpheTria( trTriaB.GetP( nVB), dSafeDist, trTriaA))
                  return true ;
-              // Processo l'edge: se c'è collisione fra triangolo A e cilindro ho finito.
+              // Processo l'edge: se c'è collisione fra triangolo A e cilindro ho finito.
               Vector3d vtEdgeV = trTriaB.GetP( ( nVB + 1) % 3) - trTriaB.GetP( nVB) ;
               double dEdgeLen = vtEdgeV.Len() ;
               vtEdgeV /= dEdgeLen ;
@@ -206,25 +206,25 @@ TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double d
         pSrfB->SetTempInt( nTB, 1) ;
      }
   }
-  // Se non richiesto test di inclusione, non c'è interferenza
+  // Se non richiesto test di inclusione, non c'è interferenza
   if ( ! bTestEnclosion)
      return false ;
-  // Se la prima superficie è chiusa, verifico se include totalmente la seconda
+  // Se la prima superficie è chiusa, verifico se include totalmente la seconda
   if ( pSrfA->IsClosed()  &&  b3BoxA.Encloses( b3BoxB)) {
      Point3d ptPointB ;
      pSrfB->GetFirstVertex( ptPointB) ;
      DistPointSurfTm DistPoinBSrfA( ptPointB, *pSrfA) ;
-      if ( DistPoinBSrfA.IsPointInside())
+      if ( DistPoinBSrfA.IsPointInside()  ||  DistPoinBSrfA.IsEpsilon( dSafeDist))
         return true ;
   }
-  // Se la seconda superficie è chiusa, verifico se include totalmente la prima
+  // Se la seconda superficie è chiusa, verifico se include totalmente la prima
   if ( pSrfB->IsClosed()  &&  b3BoxB.Encloses( b3BoxA)) {
      Point3d ptPointA ;
      pSrfA->GetFirstVertex( ptPointA) ;
      DistPointSurfTm DistPoinASrfB( ptPointA, *pSrfB) ;
-      if ( DistPoinASrfB.IsPointInside())
+      if ( DistPoinASrfB.IsPointInside()  ||  DistPoinASrfB.IsEpsilon( dSafeDist))
         return true ;
   }
-  // Non c'è interferenza
+  // Non c'è interferenza
   return false ;
 }
@@ -6053,6 +6053,7 @@ CalcSpiral( const ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrOrig, co
  // ricavo le regioni progressive
   double dOffsPrec = 0. ;
   int nCrvFirstOffs = 0 ;
+   bool bLastNotValid = false ;
   while ( nIter < MAX_ITER) {
     // Offset della regione attuale
      PtrOwner<ISurfFlatRegion> pSfrOffsVR( pSrfAct->CreateOffsetSurf( - dOffs, ICurve::OFF_FILLET)) ;
@@ -6063,6 +6064,7 @@ CalcSpiral( const ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrOrig, co
          pSfrOffsVR.Set( pSrfAct->CreateOffsetSurf( - dOffs + 5 * EPS_SMALL, ICurve::OFF_FILLET)) ;
          if ( IsNull( pSfrOffsVR))
             return false ;
+          bLastNotValid = true ;
      }

     // se primo Offset
@@ -6094,6 +6096,10 @@ CalcSpiral( const ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrOrig, co
            bool bInsert = true ;
            if ( ! CheckIfOffsetIsNecessary( pSrfAct, pCrvCompoBorder, dOffs, dOffsPrec, nIter, PockParams, bInsert))
               return false ;
+           // per evitare di allacciare una curva di regione non svuotata alla prima curva di Offset
+           // ( quindi avere un entrata nel pieno del grezzo) controllo di non eliminare il secondo Offset
+            if ( ! bInsert  &&  nChunks == 1  &&  bLastNotValid)
+                  bInsert = true ;
            if ( bInsert) {
               // imposto come secondo TempParam il Side di classificazione
                  pCrvCompoBorder->SetTempParam( j == 0 ? MDS_RIGHT : MDS_LEFT, 1) ;