EgtGeomKernel :

- creazione Zmap aggiungendo TriMesh.
2024-05-15 10:57:37 +02:00
parent 34089648b0
commit 3e6aa0d81b
5 changed files with 534 additions and 25 deletions
@@ -30,7 +30,8 @@ using namespace std ;
 //----------------------------------------------------------------------------
 bool
 VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
-                            double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax, int nToolNum)
+                            double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax,
+                            int nToolNum, bool bSkipSwap)
 {
  // Controllo che dMin e dMax non siano quasi coincidenti
   if ( abs( dMax - dMin) < EPS_ZERO)
@@ -54,13 +55,13 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
   }

  // Riporto le coordinate cicliche delle normali nell'ordine di partenza (da griglia a sistema intrinseco)
-   if ( nGrid == 1) {
+   if ( !bSkipSwap  &&  nGrid == 1) {
      swap( vtNmi.x, vtNmi.z) ;
      swap( vtNmi.y, vtNmi.z) ;
      swap( vtNma.x, vtNma.z) ;
      swap( vtNma.y, vtNma.z) ;
   }
-   else if ( nGrid == 2) {
+   else if ( !bSkipSwap  &&  nGrid == 2) {
      swap( vtNmi.y, vtNmi.z) ;
      swap( vtNmi.x, vtNmi.z) ;
      swap( vtNma.y, vtNma.z) ;
@@ -250,7 +251,8 @@ VolZmap::SubtractIntervals( int nGrid, int nI, int nJ,
 //----------------------------------------------------------------------------
 bool
 VolZmap::AddIntervals( int nGrid, int nI, int nJ,
-                       double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax, int nToolNum)
+                       double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax,
+                       int nToolNum, bool bSkipSwap)
 {
  // Controllo che il numero di griglia sia entro i limiti
   if ( nGrid < 0  ||  nGrid > 2)
@@ -272,19 +274,23 @@ VolZmap::AddIntervals( int nGrid, int nI, int nJ,
  // Restringo minimo e massimo entro i limiti della mappa
   if ( dMin < m_dMinZ[nGrid]) {
      dMin = m_dMinZ[nGrid] ;
-      vtNmi = - Z_AX ;
+      if ( ! bSkipSwap)
+         vtNmi = - Z_AX ;
   }
   else if ( dMin > m_dMaxZ[nGrid]) {
      dMin = m_dMaxZ[nGrid] ;
-      vtNmi = - Z_AX ;   
+      if ( ! bSkipSwap)
+         vtNmi = - Z_AX ;
   }
   if ( dMax < m_dMinZ[nGrid]) {
      dMax = m_dMinZ[nGrid] ;
-      vtNma = Z_AX ;
+      if ( ! bSkipSwap)
+         vtNma = Z_AX ;
   }
   else if ( dMax > m_dMaxZ[nGrid]) {
      dMax = m_dMaxZ[nGrid] ;
-      vtNma = Z_AX ;   
+      if ( ! bSkipSwap)
+         vtNma = Z_AX ;
   }

  // Controllo che dMin e dMax non siano quasi coincidenti
@@ -292,13 +298,13 @@ VolZmap::AddIntervals( int nGrid, int nI, int nJ,
      return true ;

  // Riporto le coordinate cicliche nell'ordine di partenza
-   if ( nGrid == 1) {
+   if ( !bSkipSwap  &&  nGrid == 1) {
      swap( vtNmi.x, vtNmi.z) ;
      swap( vtNmi.y, vtNmi.z) ;
      swap( vtNma.x, vtNma.z) ;
      swap( vtNma.y, vtNma.z) ;
   }
-   else if ( nGrid == 2) {
+   else if ( !bSkipSwap  &&  nGrid == 2) {
      swap( vtNmi.y, vtNmi.z) ;
      swap( vtNmi.x, vtNmi.z) ;
      swap( vtNma.y, vtNma.z) ;
@@ -600,6 +606,213 @@ VolZmap::AddIntervals( int nGrid, int nI, int nJ,
   return true ;
 }

+//----------------------------------------------------------------------------
+bool 
+VolZmap::AddSubIntervalInVoxel( VolZmap* VolZmapRef, int nGrid, int nI, int nJ, int nK,
+                                double& dMin, double& dMax, Vector3d& vtMin, Vector3d& vtMax)
+{
+  // se non Tridex, esco
+   if ( ! IsTriDexel())
+      return true ;
+  
+  // Controllo che il numero di griglia sia entro i limiti
+   if ( nGrid < 0  ||  nGrid > 2)
+      return false ;
+
+  // Controllo che indici nI, nJ siano entro i limiti
+   if ( nI < 0  &&  nI >= m_nNx[nGrid]  &&
+        nJ < 0  &&  nJ >= m_nNy[nGrid])
+      return false ;
+
+  // valori di default 
+   vector<double> vTdMin = { -1., -1., -1., -1.} ;
+   vector<double> vTdMax = { -1., -1., -1., -1.} ;
+   VCT3DVECTOR vtNMin = { V_INVALID, V_INVALID, V_INVALID, V_INVALID} ;
+   VCT3DVECTOR vtNMax = { V_INVALID, V_INVALID, V_INVALID, V_INVALID} ;
+
+  // se esiste un precedente lungo x-locale
+   if ( nI != 0) {
+      int nPos = nJ * m_nNx[nGrid] + ( nI - 1) ; // recupero posizione dexel
+     // cerco l'intervallo corretto sullo Zmap di riferimento
+      for ( int it = 0 ; it < int( VolZmapRef->m_Values[nGrid][nPos].size()) ; ++ it) {
+         if ( VolZmapRef->m_Values[nGrid][nPos][it].dMax + EPS_SMALL > nK * m_dStep  &&
+              VolZmapRef->m_Values[nGrid][nPos][it].dMax - EPS_SMALL < ( nK + 1) * m_dStep) {
+            vtNMax[0] = VolZmapRef->m_Values[nGrid][nPos][it].vtMaxN ;
+            vTdMax[0] = VolZmapRef->m_Values[nGrid][nPos][it].dMax ;
+         }
+         if ( VolZmapRef->m_Values[nGrid][nPos][it].dMin + EPS_SMALL > nK * m_dStep  &&
+              VolZmapRef->m_Values[nGrid][nPos][it].dMin - EPS_SMALL < ( nK + 1) * m_dStep) {
+            vtNMin[0] = VolZmapRef->m_Values[nGrid][nPos][it].vtMinN ;
+            vTdMin[0] = VolZmapRef->m_Values[nGrid][nPos][it].dMin ;
+         }
+      }
+   }
+  // se esiste il successivo lungo x-locale
+   if ( nI != m_dMaxZ[( nGrid + 2) % 3]) {
+      int nPos = nJ * m_nNx[nGrid] + ( nI + 1) ; // recupero posizione dexel
+      for ( int it = 0 ; it < int( VolZmapRef->m_Values[nGrid][nPos].size()) ; ++ it) {
+        // cerco l'intervallo corretto sullo Zmap di riferimento
+         if ( VolZmapRef->m_Values[nGrid][nPos][it].dMax + EPS_SMALL > nK * m_dStep  &&
+              VolZmapRef->m_Values[nGrid][nPos][it].dMax - EPS_SMALL < ( nK + 1) * m_dStep) {
+            vtNMax[1] = VolZmapRef->m_Values[nGrid][nPos][it].vtMaxN ;
+            vTdMax[1] = VolZmapRef->m_Values[nGrid][nPos][it].dMax ;
+         }
+         if ( VolZmapRef->m_Values[nGrid][nPos][it].dMin + EPS_SMALL > nK * m_dStep  &&
+              VolZmapRef->m_Values[nGrid][nPos][it].dMin - EPS_SMALL < ( nK + 1) * m_dStep) {
+            vtNMin[1] = VolZmapRef->m_Values[nGrid][nPos][it].vtMinN ;
+            vTdMin[1] = VolZmapRef->m_Values[nGrid][nPos][it].dMin ;
+         }
+      }
+   }
+  // se esiste il precedente lungo y-locale
+   if ( nJ != 0) {
+      int nPos = ( nJ - 1) * m_nNx[nGrid] + nI ; // recupero posizione dexel
+      for ( int it = 0 ; it < int( VolZmapRef->m_Values[nGrid][nPos].size()) ; ++ it) {
+        // cerco l'intervallo corretto sullo Zmap di riferimento
+         if ( VolZmapRef->m_Values[nGrid][nPos][it].dMax + EPS_SMALL > nK * m_dStep  &&
+              VolZmapRef->m_Values[nGrid][nPos][it].dMax - EPS_SMALL < ( nK + 1) * m_dStep) {
+            vtNMax[2] = VolZmapRef->m_Values[nGrid][nPos][it].vtMaxN ;
+            vTdMax[2] = VolZmapRef->m_Values[nGrid][nPos][it].dMax ;
+         }
+         if ( VolZmapRef->m_Values[nGrid][nPos][it].dMin + EPS_SMALL > nK * m_dStep  &&
+              VolZmapRef->m_Values[nGrid][nPos][it].dMin - EPS_SMALL < ( nK + 1) * m_dStep) {
+            vtNMin[2] = VolZmapRef->m_Values[nGrid][nPos][it].vtMinN ;
+            vTdMin[2] = VolZmapRef->m_Values[nGrid][nPos][it].dMin ;
+         }
+      }
+   }
+  // se esiste il successivo lungo y-locale
+   if ( nJ != m_dMaxZ[( nGrid + 1) % 3]) {
+      int nPos = ( nJ + 1) * m_nNx[nGrid] + nI ; // recupero posizione dexel
+     // cerco l'intervallo corretto sullo Zmap di riferimento
+      for ( int it = 0 ; it < int( VolZmapRef->m_Values[nGrid][nPos].size()) ; ++ it) {
+         if ( VolZmapRef->m_Values[nGrid][nPos][it].dMax + EPS_SMALL > nK * m_dStep  &&
+              VolZmapRef->m_Values[nGrid][nPos][it].dMax - EPS_SMALL < ( nK + 1) * m_dStep) {
+            vtNMax[3] = VolZmapRef->m_Values[nGrid][nPos][it].vtMaxN ;
+            vTdMax[3] = VolZmapRef->m_Values[nGrid][nPos][it].dMax ;
+         }
+         if ( VolZmapRef->m_Values[nGrid][nPos][it].dMin + EPS_SMALL > nK * m_dStep  &&
+              VolZmapRef->m_Values[nGrid][nPos][it].dMin - EPS_SMALL < ( nK + 1) * m_dStep) {
+            vtNMin[3] = VolZmapRef->m_Values[nGrid][nPos][it].vtMinN ;
+            vTdMin[3] = VolZmapRef->m_Values[nGrid][nPos][it].dMin ;
+         }
+      }
+   }
+
+  // scelgo le normali che si discostano il meno possibile dalla normale della faccia del voxel
+
+  // analisi dei massimi e delle normali ---------------------------
+  // 1) angolo minimo tra la normale trovata la faccia del voxel
+   double dMinAngle = ANG_FULL ;
+  // 2) vettore di riferimento per la direzione della normale
+   vtMax = ( nGrid == 0 ? m_MapFrame.VersZ() :
+           ( nGrid == 1 ? m_MapFrame.VersX() : m_MapFrame.VersY())) ;
+   Vector3d vtRef = vtMax ;
+  // 3) determino il massimo per questo intervallo
+   dMax = ( nK + 1) * m_dStep ;
+   for ( int i = 0 ; i < 4 ; ++ i) { // scorro le normali
+      if ( vtNMax[i].IsValid()) { // se normale trovata, quindi valida...
+         double dCurrAngle ; // angolo corrente tra la normale della TriMesh e quella della faccia del voxel
+         vtNMax[i].GetAngle( vtRef, dCurrAngle) ;
+         if ( abs( dCurrAngle) < dMinAngle) { // se angolo minore del minimo trovato...
+           // aggiorno i parametri
+            dMinAngle = dCurrAngle ;
+            vtMax = vtNMax[i] ;
+            dMax = vTdMax[i] ;
+         }
+      }
+   }
+
+  // analisi dei minimi e delle normali ---------------------------
+   dMinAngle = ANG_FULL ;
+   vtRef.Invert() ;
+   dMin = nK * m_dStep ;
+   vtMin = vtRef ;
+   for ( int i = 0 ; i < 4 ; ++ i) {
+      if ( vtNMin[i].IsValid()) {
+         double dCurrAngle ;
+         vtNMin[i].GetAngle( vtRef, dCurrAngle) ;
+         if ( abs( dCurrAngle) < dMinAngle) {
+            dMinAngle = dCurrAngle  ;
+            vtMin = vtNMin[i] ;
+            dMin = vTdMin[i] ;
+         }
+      }
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+VolZmap::AddMissingIntervalsInVoxel( VolZmap* VolZmapRef, int nGrid, int nI, int nJ, double dZ, double dToler,
+                                     Vector3d vtToolMin, Vector3d vtToolMax, int nToolNum)
+{
+
+  // se non Tridex, esco
+   if ( ! IsTriDexel())
+      return true ;
+  
+  // Controllo che il numero di griglia sia entro i limiti
+   if ( nGrid < 0  ||  nGrid > 2)
+      return false ;
+
+  // Controllo che indici nI, nJ siano entro i limiti
+   if ( nI < 0  &&  nI >= m_nNx[nGrid]  &&
+        nJ < 0  &&  nJ >= m_nNy[nGrid])
+      return false ;
+
+  // passo da indici di dexel a indici di voxel
+   nI /= m_nDexVoxRatio ;
+   nJ /= m_nDexVoxRatio ;
+
+  // numero di voxel nel dexel corrente
+   int nVoxNum = int( m_nNy[(( nGrid+1) % 3)] / m_nDexVoxRatio +
+                 ( m_nNy[(( nGrid+1) % 3)] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
+
+   int nK = 0 ;
+   for ( int i = 0 ; i < nVoxNum ; ++ i) {
+     // controllo se sono nel voxel corrente
+      if ( i * m_dStep < dZ  &&  ( i + 1) * m_dStep > dZ) {
+         nK = i ;
+         break ;
+      }
+   }
+
+  // ----------- griglia successiva -----------
+   {
+      int nMyGrid = ( nGrid + 1) % 3 ;
+      int nMyI = nJ ;
+      int nMyJ = nK ;
+      int nMyK = nI ;
+      double dMyMin ;
+      double dMyMax ;
+      Vector3d vtMyMin ;
+      Vector3d vtMyMax ;
+      AddSubIntervalInVoxel( VolZmapRef, nMyGrid, nMyI, nMyJ, nMyK, dMyMin, dMyMax, vtMyMin, vtMyMax) ;
+      AddIntervals( nMyGrid, nMyI, nMyJ, dMyMin - EPS_SMALL, dMyMax + EPS_SMALL, vtMyMin, vtMyMax,
+                    nToolNum, true) ;
+   }
+
+   // ----------- griglia precedente -----------
+   {
+      int nMyGrid = ( nGrid + 2) % 3 ;
+      int nMyI = nK ;
+      int nMyJ = nI ;
+      int nMyK = nJ ;
+      double dMyMin ;
+      double dMyMax ;
+      Vector3d vtMyMin ;
+      Vector3d vtMyMax ;
+      AddSubIntervalInVoxel( VolZmapRef, nMyGrid, nMyI, nMyJ, nMyK, dMyMin, dMyMax, vtMyMin, vtMyMax) ;
+      AddIntervals( nMyGrid, nMyI, nMyJ, dMyMin - EPS_SMALL, dMyMax + EPS_SMALL, vtMyMin, vtMyMax,
+                    nToolNum, true) ;
+   }
+
+   return true ;
+
+}
+
 // ------------------------- LAVORAZIONI --------------------------------------------------------------------------------------

 //----------------------------------------------------------------------------