EgtGeomKernel (2.7i3) :

- Aggiunta funzione in DistPointSurfTm per ottenere i triangoli a minima distanza
- Aggiunte funzioni per Offset Fillet di VolZmap e per Offset generici di superfici TriMesh aperte.

DistPointSurfTm.cpp

@@ -94,6 +94,8 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
 {
   // Inizializzo distanza non calcolata
    m_dDist = - 1. ;
+  // Vettore di indici dei triangoli più vicini inizialmente vuoto
+   m_vnMinDistTriaIndex.clear() ;
   // Controllo se la superficie è chiusa
    m_bIsSurfClosed = tmSurf.IsClosed() ;
 
@@ -184,6 +186,10 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
    if ( nMinDistTriaIndex == SVT_NULL)
       return ;
 
+  // Inizializzo il vettore dei triangoli a minima distanza
+   for ( auto& Tria : vTria)
+      m_vnMinDistTriaIndex.emplace_back( Tria.first) ;
+
   // salvo la distanza minima
    m_dDist = dMinDist ;
   // salvo il punto a distanza minima
@@ -279,6 +285,18 @@ DistPointSurfTm::GetMinDistTriaIndex( int& nMinDistIndex) const
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+DistPointSurfTm::GetMinDistTriaIndices( INTVECTOR& vMinDistTriaIndex) const
+{
+  // Distanza non valida
+   if ( m_dDist < - EPS_ZERO)
+      return false ;
+  // Distanza valida
+   vMinDistTriaIndex = m_vnMinDistTriaIndex ;
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 int
 GetSurfTmNearestVertex( const Point3d& ptP, const ISurfTriMesh& tmSurf)

SurfTriMeshOffset.cpp

@@ -15,8 +15,21 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "VolZmap.h"
+#include "SurfTriMesh.h"
+#include "EgtDev/Include/EGkDistPointSurfTm.h"
 #include "\EgtDev\Include\EGkSurfTriMeshAux.h"
 
+#define DEBUG 0
+#if DEBUG
+   #include "/EgtDev/Include/EGkGeoObjSave.h"
+   #include "/EgtDev/Include/EGkGeoPoint3d.h"
+   #include "/EgtDev/Include/EGkGeoVector3d.h"
+   #include "/EgtDev/Include/EGkStmStandard.h"
+   #include "/EgtDev/Include/EgtPerfCounter.h"
+   std::vector<IGeoObj*> VT ;
+   std::vector<Color> VC ;
+#endif
+
 using namespace std ;
 
 //----------------------------------------------------------------------------
@@ -73,11 +86,11 @@ CreateSurfTriMeshesOffset( const CISURFTMPVECTOR& vStm, double dOffs, double dPr
    if ( vStm.empty())
       return nullptr ;
   // controllo sul valore di tolleranza lineare
-   double dMyPrec = max( dPrec, 100 * EPS_SMALL) ;
+   double dMyPrec = max( dPrec, 100. * EPS_SMALL) ;
   // --- NB. ( Il valore di Offset deve essere maggiore di 10 * EPS_SMALL in valore assoluto)
   // Nel caso sia minore, restituisco semplicemente la somma delle superfici
   // ( questo valore serve per rimanere coerente con l'Offset delle curve)
-   if ( abs( dOffs) < 10 * EPS_SMALL)
+   if ( abs( dOffs) < 10. * EPS_SMALL)
       return SumStm( vStm) ;
 
   // creo lo Zmap associato alle superfici TriMesh
@@ -87,8 +100,117 @@ CreateSurfTriMeshesOffset( const CISURFTMPVECTOR& vStm, double dOffs, double dPr
    if ( ! OneVolZmap.IsValid())
       return nullptr ;
 
-  // restituisco la superficie TriMesh
+  // recupero le superfici aperte
-   return ( OneVolZmap.GetSurfTriMesh()) ;
+   CISURFTMPVECTOR vStmOpen ;
+   for ( const ISurfTriMesh* pStm : vStm) {
+      if ( pStm != nullptr  &&  pStm->IsValid() &&   ! pStm->IsClosed())
+         vStmOpen.emplace_back( pStm) ;
+   }
+
+  // --- se non ho superfici aperte
+   if ( vStmOpen.empty()) {
+     // restituisco la superficie TriMesh di Offset
+      return ( OneVolZmap.GetSurfTriMesh()) ;
+   }
+
+  // --- se ho delle superfici aperte
+  // lo Zmap creato è orientato e definisce una superficie chiusa; devo rimuovere i triangoli in eccesso
+
+  // anzitutto controllo che lo Zmap sia valido
+   if ( ! OneVolZmap.IsValid())
+      return nullptr ;
+
+  // inzializzo la superficie TriMesh da restituire
+   PtrOwner<SurfTriMesh> pStm( CreateBasicSurfTriMesh()) ;
+   if ( IsNull( pStm)  ||  ! pStm->Init( 3, 1))
+      return nullptr ;
+   PointGrid3d VertGrid ; VertGrid.Init( 50000) ;
+
+  // tolleranza di vicinanza alla superficie
+   double dTolDist = 30. * EPS_SMALL ;
+
+   #if DEBUG
+      VT.emplace_back( OneVolZmap.Clone()) ;
+      VC.emplace_back( BLACK) ;
+   #endif
+
+  // ciclo lungo i blocchi dello ZMap
+   for ( int nB = 0 ; nB < OneVolZmap.GetBlockCount() ; ++ nB) {
+
+     // recupero i triangoli
+      TRIA3DEXVECTOR vTria, vTriaSafe ;
+      OneVolZmap.GetBlockTriangles( nB, vTria) ;
+
+     // un triangolo viene ritenuto valido se è non è troppo vicino ( dOffs) alle superfici aperte
+      for ( int nT = 0 ; nT < int( vTria.size()) ; ++ nT) {
+
+        // recupero il triangolo
+         Triangle3dEx& Tria = vTria[nT] ;
+
+        // scorro le superficie aperte
+         bool bInsert = true ;
+         for ( int nS = 0 ; bInsert && nS < int( vStm.size()) ; ++ nS) {
+
+           // controllo se posso inserirlo
+            vector<DistPointSurfTm> vDistPtStm ;
+            for ( int i = 0 ; i < 3 && bInsert ; ++ i) {
+               double dDist = 0. ;
+               vDistPtStm.emplace_back( DistPointSurfTm( Tria.GetP( i), *vStm[nS])) ;
+               bInsert = ( vDistPtStm.back().GetDist( dDist) && dDist > abs( dOffs) - dTolDist) ;
+            }
+           // se il triangolo è al più a distanza di |dOffs| - dTolDist
+            if ( bInsert) {
+              // recupero i triangoli a distanza minima dai vertici del triangolo corrente
+               bool bPerp = true ;
+               for ( int i = 0 ; i < 3 && bPerp ; ++ i) {
+                  INTVECTOR vTria ;
+                  vDistPtStm[i].GetMinDistTriaIndices( vTria) ;
+                  for ( int j = 0 ; j < int( vTria.size()) && bPerp ; ++ j) {
+                     Triangle3d TriaCloser ;
+                     vStm[nS]->GetTriangle( vTria[j], TriaCloser) ;
+                     bPerp = ( abs( Tria.GetN() * TriaCloser.GetN()) < dTolDist) ;
+                  }
+               }
+              // se tutti i triangoli a distanza minima sono perpendicolari, allora non lo inserisco
+               bInsert = ( ! bPerp) ;
+            }
+         }
+
+        // se triangolo da inserire
+         if ( bInsert)
+            vTriaSafe.emplace_back( Tria) ;
+
+         #if DEBUG
+            ICurveComposite* pCompo = CreateCurveComposite() ;
+            pCompo->AddPoint( Tria.GetP( 0)) ;
+            pCompo->AddLine( Tria.GetP( 1)) ;
+            pCompo->AddLine( Tria.GetP( 2)) ;
+            pCompo->Close() ;
+            Color myCol = ( bInsert ? Color( 0., 1., 0., .5) : Color( 1., 0., 0., .5)) ;
+            VT.emplace_back( CloneCurveComposite( pCompo)) ;
+            VC.emplace_back( myCol) ;
+            ISurfFlatRegion* pSfrTria = CreateSurfFlatRegion() ;
+            pSfrTria->AddExtLoop( pCompo) ;
+            VT.emplace_back( pSfrTria) ;
+            VC.emplace_back( myCol) ;
+         #endif
+      }
+
+     // inserisco tutti i triangoli validi
+      if ( ! pStm->AddTriaFromZMap( vTriaSafe, VertGrid))
+         return nullptr ;
+   }
+
+   #if DEBUG
+      SaveGeoObj( VT, VC, "C:\\Temp\\TriangleSelection.nge") ;
+   #endif
+
+
+  // sistemo la topologia
+   if ( ! pStm->AdjustTopologyFromZMap())
+      return nullptr ;
+
+   return ( Release( pStm)) ;
 }
 
 //----------------------------------------------------------------------------

VolZmap.h

@@ -152,6 +152,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool AddSurfTm( const ISurfTriMesh* pStm) override ;
       bool SubtractSurfTm( const ISurfTriMesh* pStm) override ;
       bool MakeUniform( double dToler) override ;
+      bool Offset( double dOffs, int nType) override ;
 
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
@@ -463,13 +464,15 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool InitVolZMapOffset( const CISURFTMPVECTOR& vSurf, double dOffs, double dTol) ;
       bool InitVolZMapThickeningOffset( const CISURFTMPVECTOR& vSurf, double dOffs, double dTol) ;
       bool UpdateVolZMapByOpenSurfFilletOffset( const ISurfTriMesh* Surf, double dOffs, double dTol) ;
+      bool UpdateVolZMapByOpenSurfSharpedOffset( const ISurfTriMesh* Surf, int nType, double dOffs, double dTol) ;
       bool UpdateVolZMapByClosedSurfFilletOffset( const ISurfTriMesh* Surf, double dOffs, double dTol) ;
       bool UpdateVolZMapByClosedSurfSharpedOffset( const ISurfTriMesh* Surf, int nType, double dOffs, double dTol) ;
       bool UpdateVolZMapBySurfThickeningFilletOffset( const ISurfTriMesh* Surf, double dOffs, double dTol) ;
       bool UpdateVolZMapBySurfThickeningSharpedOffset( const ISurfTriMesh* Surf, int nType, double dOffs, double dTol) ;
       bool CreateOffsetSphereOnVertex( const Point3d& ptV, double dOffs, int nGrid, int nVertexType = 0) ;
       bool CreateOffsetCylinderOnEdge( const Point3d& ptP1, const Point3d& ptP2, double dOffs, int nGrid, int nVertexType = 0) ;
-      bool CreateOffsetExtrusionFace( const ISurfTriMesh* Surf, double dOffs, bool bThickle) ;
+      bool CreateFatOffsetExtrusionFace( const ISurfTriMesh* Surf, double dOffs, bool bThickle) ;
+      bool CreateOrientedOffsetExtrusionFace( const ISurfTriMesh* Surf, double dOffs) ;
       bool SubtractIntervalsForOffset( int nGrid, int nI, int nJ,
                                        double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax, 
                                        int nToolNum, bool bSkipSwap = false) ;
@@ -477,6 +480,10 @@ class VolZmap : public IVolZmap, public IGeoObjRW
                                   double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax,
                                   int nToolNum, bool bSkipSwap = false) ;
       bool CutByPlaneForOffset( const Plane3d& plCut) ;
+     // Funzioni per Offset di Zmap
+      bool OffsetFillet( double dOffs) ;
+      bool OffsetSharped( double dOffs, int nType) ;
+
    public :
       // ------------------------- ENUM ----------------------------------------------------------------
       enum MillingPhase {
@@ -567,6 +574,12 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       double                              m_dToolAngTolDeg ;
 } ;
 
+// Offset
+enum {
+   VOLZMAP_OFFS_FILLET = 0,
+   VOLZMAP_OFFS_CHANFER = 1,
+   VOLZMAP_OFFS_EXTENDED = 2
+} ;
 
 //-----------------------------------------------------------------------------
 inline VolZmap* CreateBasicVolZmap( void)