EgtGeomKernel :

- aggiunta funzione EraseFins per gli Zmap ( prima versione semplice).
2026-03-19 18:45:38 +01:00
parent a2ca0ac6f7
commit 48b2029d19
3 changed files with 166 additions and 0 deletions
@@ -1864,6 +1864,109 @@ VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
   return true ;
 }

+//----------------------------------------------------------------------------
+bool
+VolZmap::EraseFins( const Vector3d& vtDir, double dThick)
+{
+  // Verifico la Validità dello ZMap
+   if ( ! IsValid())
+      return false ;
+
+  // Per sicurezza normalizzo la direzione
+   Vector3d vtMyDir = vtDir ;
+   if ( ! vtMyDir.Normalize())
+      return false ;
+   double dMyThick = max( 10. * EPS_SMALL, dThick) ;
+
+  // Creo lo ZMap per i riferimenti degli intervalli sulle griglie
+   PtrOwner<VolZmap> pZMapCopy( CloneBasicVolZmap( this)) ;
+   if ( IsNull( pZMapCopy)  ||  ! pZMapCopy->IsValid())
+      return false ;
+
+  // Creo uno ZMap per gli intervalli da aggiungere e successivamente da rimuovere
+   VolZmap ZMapExtra ;
+   if ( ! ZMapExtra.CreateEmpty( m_MapFrame.Orig(), m_dMaxZ[1] - m_dMinZ[1], m_dMaxZ[2] - m_dMinZ[2], m_dMaxZ[0] - m_dMinZ[0],
+                                  m_dStep, IsTriDexel()))
+      return false ;
+
+   const double FIN_ANG_DEG_TOL = 55. ; // approssimazione per eccesso dell'angolo massimo possibile tra una direzione generica
+                                        // e un versore della terna globale ( arccos( 1 / sqrt( 3) ~ 54.375)
+   const double COS_FIN_ANG_DEG_TOL = cos( FIN_ANG_DEG_TOL * DEGTORAD) ;
+
+  // NB. Tutti i parametri sono sempre presi dalla Copia dello ZMap corrente
+  // Ciclo sulle griglie
+   for ( int nGrid = 0 ; nGrid < pZMapCopy->m_nMapNum ; ++ nGrid) {
+     // Verifico se l'angolo tra la direzione degli spilloni della griglia corrente è sotto alla tolleranza riseptto alla direzione
+      double dCosDir = ( nGrid == 0 ? vtMyDir.z : ( nGrid == 1 ? vtMyDir.x : vtMyDir.y)) ;
+      if ( abs( dCosDir) < COS_FIN_ANG_DEG_TOL + EPS_ANG_SMALL)
+         continue ;
+     // Aggiorno l'effettivo valore dello spessore da considerare
+      double dCurrThick = dMyThick / abs( dCosDir) ; // sicuramente esiste, essendo 55deg il limite
+     // Ciclo sul numero di dexel presenti nella Copia
+      for ( int nDex = 0 ; nDex < ssize( pZMapCopy->m_Values[nGrid]) ; ++ nDex) {
+        // Se il dexel corrente non ha sotto-intervalli passo al successivo
+         if ( pZMapCopy->m_Values[nGrid][nDex].empty())
+            continue ;
+        // Indici del dexel
+         int nI = nDex % m_nNx[nGrid] ;
+         int nJ = nDex / m_nNx[nGrid] ;
+        // Recupero il numero di intervalli presenti nel Dexel corrente
+         int nIntervals = ssize( pZMapCopy->m_Values[nGrid][nDex]) ;
+        // Scorro gli intervalli presenti
+         for ( int nInfo = 0 ; nInfo < ssize( pZMapCopy->m_Values[nGrid][nDex]) ; ++ nInfo) {
+           // Recupero l'intervallo corrente
+            Data& Interval = pZMapCopy->m_Values[nGrid][nDex][nInfo] ;
+           // Se entrambi gli estremi dell'intervallo non sono stati toccati dall'utensile, allora passo al successivo
+            bool bAnalyze = ( ( Interval.nToolMin == 1  &&  Interval.nToolMax == 1)  ||
+                              ( Interval.dMax > m_dMaxZ[nGrid] - EPS_SMALL  ||  Interval.dMin < m_dMinZ[nGrid] + EPS_SMALL)) ;
+            if ( ! bAnalyze)
+               continue ;
+           // if ( Interval.nToolMin != 1  ||  Interval.nToolMax != 1)
+           //    continue ;
+           // Se la lunghezza dell'intervallo è supriore allo spessore richiesto, non faccio nulla
+            double dLen = Interval.dMax - Interval.dMin ;
+            if ( dLen > dCurrThick - EPS_SMALL)
+               continue ;
+           // Se ZMap composto da una sola griglia, elimino il contributo lungo la direzione corrente
+            if ( ! IsTriDexel()) {
+               SubtractIntervals( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMax + EPS_SMALL,
+                                  Interval.vtMinN, Interval.vtMaxN, 1, true) ;
+            }
+           // Se Tridexel, aggiungo il contributo del cubetto corrente allo ZMap Extra
+            else
+               ZMapExtra.AddStripInterval( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMax + EPS_SMALL) ;
+         }
+      }
+   }
+  // Se non ho aggiunto alcun elemento allo ZMap Extra, non devo fare nulla
+   if ( ! ZMapExtra.IsValid())
+      return true ;
+
+  // Ciclo sulle griglie dello ZMap Extra
+   for ( int nGrid = 0 ; nGrid < ZMapExtra.m_nMapNum ; ++ nGrid) {
+     // Ciclo sul numero di dexel presenti
+      for ( int nDex = 0 ; nDex < ssize( ZMapExtra.m_Values[nGrid]) ; ++ nDex) {
+        // Se l'intervallo è vuoto, non faccio nulla
+         if ( ZMapExtra.m_Values[nGrid][nDex].empty())
+            continue ;
+        // Indici del dexel
+         int nI = nDex % m_nNx[nGrid] ;
+         int nJ = nDex / m_nNx[nGrid] ;
+        // Scorro i gli Intervalli dello Spillone corrente
+         for ( int nInfo = 0 ; nInfo < ssize( ZMapExtra.m_Values[nGrid][nDex]) ; ++ nInfo) {
+            double dMin = ZMapExtra.m_Values[nGrid][nDex][nInfo].dMin ;
+            double dMax = ZMapExtra.m_Values[nGrid][nDex][nInfo].dMax ;
+            Vector3d vtNMin = ZMapExtra.m_Values[nGrid][nDex][nInfo].vtMinN ;
+            Vector3d vtNMax =  ZMapExtra.m_Values[nGrid][nDex][nInfo].vtMaxN ;
+           // sottraggo tali contributi
+            SubtractIntervals( nGrid, nI, nJ, dMin, dMax, vtNMin, vtNMax, 1, true) ;
+         }
+      }
+   }
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)