EgtGeomKernel :

- correzione errori compliazione con Clang-cl/LLVM.

AdjustLoops.cpp

@@ -15,30 +15,15 @@
 #include "stdafx.h"
 #include "GeoConst.h"
 #include "CurveComposite.h"
-#include "RemoveCurveDefects.h"
+#include "RemoveCurveSpikes.h"
 #include "AdjustLoops.h"
 #include "/EgtDev/Include/EGkIntersCurves.h"
 #include "/EgtDev/Include/EGkIntervals.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include <algorithm>
 
 using namespace std ;
 
-//-------------------------------------------------------
-static bool
-SortCrvCrvInfo( const IntCrvCrvInfo& aInfo1, const IntCrvCrvInfo& aInfo2)
-{
-  // confronto i valori del primo punto della curva A 
-   double dU1 = aInfo1.IciA[0].dU ;
-   double dU2 = aInfo2.IciA[0].dU ;  
-   if ( abs( dU1 - dU2) < EPS_SMALL)
-     // se sono uguali confronto i valori del primo punto della curva B
-      return aInfo1.IciB[0].dU > aInfo2.IciB[0].dU ;
-   else
-      return dU1 < dU2 ;   
-}
-
 //----------------------------------------------------------------------------
 static bool
 MyAdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst)
@@ -88,100 +73,43 @@ MyAdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst)
       return false ;
    Intervals inOk( EPS_PARAM) ;
    inOk.Set( dStart, dEnd) ;
-     
-  // recupero tutte le info delle autointersezioni
-   IntCrvCrvInfo iccInfo ;
-   ICCIVECTOR vIccInfo( sintC.GetIntersCount()) ;
-   for ( int i = 0 ; sintC.GetIntCrvCrvInfo( i, iccInfo) ; ++ i)
-      vIccInfo[i]= iccInfo ;
-  // ordino il vettore
-   sort( vIccInfo.begin(), vIccInfo.end(), SortCrvCrvInfo) ;
-  
+
   // Tolgo le parti da eliminare
-   int nCross = 0 ;
-   for ( int i = 0 ; i < int( vIccInfo.size()) ; ++ i) {
-
-      if ( i < int( vIccInfo.size()) - 1) {
-        // se anche l'intersezione successiva è overlap che parte dallo stesso punto 
-         if ( vIccInfo[i].bOverlap && vIccInfo[i+1].bOverlap && 
-              abs( vIccInfo[i].IciA[0].dU - vIccInfo[i+1].IciA[0].dU) < EPS_SMALL && 
-              abs( vIccInfo[i].IciB[0].dU - vIccInfo[i+1].IciB[0].dU) < EPS_SMALL) {
-           // elimino il tratto 
-            inOk.Subtract( vIccInfo[i].IciA[0].dU, vIccInfo[i].IciB[0].dU) ;
-           // salto le intersezioni successive già considerate rimuovendo questo intervallo 
-            int j = i + 2 ;
-            while ( j < ( int)vIccInfo.size() && vIccInfo[j].IciA[0].dU > vIccInfo[i].IciA[0].dU - EPS_SMALL && 
-               vIccInfo[j].IciA[1].dU < vIccInfo[i].IciB[0].dU + EPS_SMALL) {
-               j ++ ;
-            }
-           // aggiorno il contatore 
-            i = j - 1 ;
-            continue ;
-         }     
-      } 
-
+   IntCrvCrvInfo iccInfo ;
+   for ( int i = 0 ; sintC.GetIntCrvCrvInfo( i, iccInfo) ; ++ i) {
      // se con sovrapposizione
-      if ( vIccInfo[i].bOverlap) {
+      if ( iccInfo.bOverlap) {
         // se solo touch
-         if ( ( vIccInfo[i].IciA[0].nPrevTy == vIccInfo[i].IciA[1].nNextTy  ||
-                vIccInfo[i].IciA[0].nPrevTy == ICCT_SPK  ||  vIccInfo[i].IciA[1].nNextTy == ICCT_SPK)  &&
-                vIccInfo[i].IciA[0].nPrevTy != ICCT_NULL  &&  vIccInfo[i].IciA[1].nNextTy != ICCT_NULL) {
+         if ( ( iccInfo.IciA[0].nPrevTy == iccInfo.IciA[1].nNextTy  ||
+                iccInfo.IciA[0].nPrevTy == ICCT_SPK  ||  iccInfo.IciA[1].nNextTy == ICCT_SPK)  &&
+              iccInfo.IciA[0].nPrevTy != ICCT_NULL  &&  iccInfo.IciA[1].nNextTy != ICCT_NULL) {
            // obbligatoriamente controversi, elimino entrambi i tratti
-            inOk.Subtract( vIccInfo[i].IciA[0].dU, vIccInfo[i].IciA[1].dU) ;
-            inOk.Subtract( vIccInfo[i].IciB[0].dU, vIccInfo[i].IciB[1].dU) ;
+            inOk.Subtract( iccInfo.IciA[0].dU, iccInfo.IciA[1].dU) ;
+            inOk.Subtract( iccInfo.IciB[0].dU, iccInfo.IciB[1].dU) ;
          }
         // altrimenti attraversamento
          else {
            // elimino la parte interna
-            if ( vIccInfo[i].bCBOverEq)
-               inOk.Subtract( vIccInfo[i].IciA[0].dU, vIccInfo[i].IciB[0].dU) ;
+            if ( iccInfo.bCBOverEq)
+               inOk.Subtract( iccInfo.IciA[0].dU, iccInfo.IciB[0].dU) ;
             else
-               inOk.Subtract( min( vIccInfo[i].IciA[0].dU, vIccInfo[i].IciB[1].dU), max( vIccInfo[i].IciB[0].dU, vIccInfo[i].IciA[1].dU)) ;
+               inOk.Subtract( min( iccInfo.IciA[0].dU, iccInfo.IciB[1].dU), max( iccInfo.IciB[0].dU, iccInfo.IciA[1].dU)) ;
          }
       }
      // altrimenti
       else {
         // se solo touch
-         if ( vIccInfo[i].IciA[0].nPrevTy == vIccInfo[i].IciA[0].nNextTy  &&
-              vIccInfo[i].IciA[0].nPrevTy != ICCT_NULL  &&  vIccInfo[i].IciA[0].nNextTy != ICCT_NULL) {
-            inOk.Subtract( vIccInfo[i].IciA[0].dU, vIccInfo[i].IciA[0].dU) ;
-            inOk.Subtract( vIccInfo[i].IciB[0].dU, vIccInfo[i].IciB[0].dU) ;
+         if ( iccInfo.IciA[0].nPrevTy == iccInfo.IciA[0].nNextTy  &&
+              iccInfo.IciA[0].nPrevTy != ICCT_NULL  &&  iccInfo.IciA[0].nNextTy != ICCT_NULL) {
+            inOk.Subtract( iccInfo.IciA[0].dU, iccInfo.IciA[0].dU) ;
+            inOk.Subtract( iccInfo.IciB[0].dU, iccInfo.IciB[0].dU) ;
          }
         // altrimenti attraversamento
          else {
-            double dParA = vIccInfo[i].IciA[0].dU ;
-            double dParB = vIccInfo[i].IciB[0].dU ;
-            if ( abs( dParA - dEnd) < EPS_SMALL)
-               swap( dParA, dParB) ;
-           // verifico se uno dei due intervalli dà origine ad un tratto trascurabile
-            PtrOwner<ICurve> pCrv1( pMyCrv->CopyParamRange( dParA, dParB)) ;
-            PtrOwner<ICurve> pCrv2( pMyCrv->CopyParamRange( dParB, dParA)) ;           
-            double dArea1 = 0, dArea2 = 0 ;
-            if ( ! IsNull( pCrv1))
-               pCrv1->GetAreaXY( dArea1) ;
-            if ( ! IsNull( pCrv2))
-               pCrv2->GetAreaXY( dArea2) ;
-
-            if ( abs( dArea1) > 1e6 * abs( dArea2)) {
-              // se il tratto dParB->dParA non è significativo
-               inOk.Subtract( dStart, dParA) ;
-               inOk.Subtract( dParB, dEnd) ;             
-            }
-            else if ( abs( dArea2) > 1e6 * abs( dArea1)) {
-              // se il tratto dParA->dParB non è siginificativo
-               inOk.Subtract( dParA, dParB) ;          
-            }
-            else {
-              // se entrambe le regioni sono significative
-               if ( IsEven( nCross))
-                  inOk.Subtract( vIccInfo[i].IciA[0].dU, vIccInfo[i].IciB[0].dU) ;
-               else
-                  inOk.Add( vIccInfo[i].IciA[0].dU, vIccInfo[i].IciB[0].dU) ;
-               ++ nCross ; 
-            }         
+            inOk.Subtract( iccInfo.IciA[0].dU, iccInfo.IciB[0].dU) ;
          }
       }
-   } 
+   }
 
   // Copio le parti da conservare
    double dParS, dParE ;
@@ -251,14 +179,14 @@ MyAdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst)
             Point3d ptEnd2 ; pCrvCo2->GetEndPoint( ptEnd2) ;
            // se aperta, verifico se concatenabile alla principale
             if ( ! AreSamePointEpsilon( ptStart2, ptEnd2, 10 * EPS_SMALL)) {
-               if ( AreSamePointEpsilon( ptEnd, ptStart2, 100 * EPS_SMALL)) {
-                  pCrvCo->AddCurve( pCrvCo2, true, 100 * EPS_SMALL) ;
+               if ( AreSamePointEpsilon( ptEnd, ptStart2, 10 * EPS_SMALL)) {
+                  pCrvCo->AddCurve( pCrvCo2, true, 10 * EPS_SMALL) ;
                   CrvLst.erase( iIter2) ;
                   ptEnd = ptEnd2 ;
                   iIter2 = next( iIter) ;
                }
-               else if ( AreSamePointEpsilon( ptEnd2, ptStart, 100 * EPS_SMALL)) {
-                  pCrvCo->AddCurve( pCrvCo2, false, 100 * EPS_SMALL) ;
+               else if ( AreSamePointEpsilon( ptEnd2, ptStart, 10 * EPS_SMALL)) {
+                  pCrvCo->AddCurve( pCrvCo2, false, 10 * EPS_SMALL) ;
                   CrvLst.erase( iIter2) ;
                   ptStart = ptStart2 ;
                   iIter2 = next( iIter) ;
@@ -273,22 +201,6 @@ MyAdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst)
       ++ iIter ;
    }
 
-  // elimino le curve troppo piccole
-   for ( auto iIter = CrvLst.begin() ; iIter != CrvLst.end() ;) {
-      CurveComposite* pCrvCo = GetBasicCurveComposite( *iIter) ;
-      BBox3d b3CrvCo ;
-      double dDiam ;
-      if ( ! pCrvCo->GetLocalBBox( b3CrvCo)  ||  b3CrvCo.IsEmpty()  ||
-           ! b3CrvCo.GetDiameter( dDiam)  ||  dDiam < 20 * EPS_SMALL) {
-         delete pCrvCo ;
-         pCrvCo = nullptr ;
-         iIter = CrvLst.erase( iIter) ; 
-      }
-      else {
-         ++ iIter ;
-      }
-   }
-
   // riporto le curve nel riferimento originale
    if ( bNeedRef) {
       for ( auto pCrv : CrvLst)
@@ -303,7 +215,7 @@ MyAdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst)
 
 //----------------------------------------------------------------------------
 bool
-AdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst, bool bNeedSameProp)
+AdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst)
 {
   // elimino eventuali sovrapposizioni e accostamenti
    if ( ! MyAdjustLoops( pCurve, CrvLst))
@@ -313,12 +225,10 @@ AdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst, bool bNeedSameProp)
      // se curva composita
       CurveComposite* pCrvCo = GetBasicCurveComposite( pCrv) ;
       if ( pCrvCo != nullptr) {
-        // elimino eventuali Spikes e Small Z
-         pCrvCo->RemoveSmallDefects( 2 * LIN_TOL_MIN, ANG_TOL_STD_DEG, true) ;
         // unisco eventuali tratti allineati
-         pCrvCo->MergeCurves( LIN_TOL_MIN, ANG_TOL_STD_DEG, true, bNeedSameProp) ;
-        // richiudo i loop per sicurezza
-         pCrvCo->Close() ;
+         pCrvCo->MergeCurves( LIN_TOL_MIN, ANG_TOL_STD_DEG) ;
+        // elimino eventuali spikes
+         RemoveCurveSpikes( pCrvCo) ;
       }
    }
 

AdjustLoops.h

@@ -17,4 +17,4 @@
 
 
 //----------------------------------------------------------------------------
-bool AdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst, bool bNeedSameProp) ;
+bool AdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst) ;

Angle.cpp

@@ -63,57 +63,3 @@ AngleInSpan( double dAngDeg, double dAngRefDeg, double dAngSpanDeg)
                dAngDiffDeg < dHalfAngSpanDeg + EPS_ANG_SMALL) ;
    }
 }
-
-//----------------------------------------------------------------------------
-bool
-AngleInRange( double dAngDeg, double dAngMinDeg, double dAngMaxDeg)
-{
-   return AngleInSpan( dAngDeg, ( dAngMinDeg + dAngMaxDeg) / 2, dAngMaxDeg - dAngMinDeg) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-AdjustAngleInSpan( double& dAngDeg, double dAngRefDeg, double dAngSpanDeg)
-{
-  // Verifico consistenza intervallo
-   if ( dAngSpanDeg < -EPS_ANG_ZERO)
-      return false ;
-   // Se intervallo vero
-   if ( dAngSpanDeg > EPS_ANG_SMALL) {
-      double dTryDeg = dAngDeg ;
-     // eseguo gli aggiustamenti
-      while ( dTryDeg < dAngRefDeg - dAngSpanDeg)
-         dTryDeg += ANG_FULL ;
-      while ( dTryDeg > dAngRefDeg + dAngSpanDeg)
-         dTryDeg -= ANG_FULL ;
-     // verifico
-      if ( dTryDeg >= dAngRefDeg - dAngSpanDeg  &&  dTryDeg <= dAngRefDeg + dAngSpanDeg) {
-         dAngDeg = dTryDeg ;
-         return true ;
-      }
-      return false ;
-   }
-  // altrimenti un valore
-   else {
-      double dTryDeg = dAngDeg ;
-     // eseguo gli aggiustamenti
-      while ( dTryDeg < dAngRefDeg - EPS_ANG_SMALL)
-         dTryDeg += ANG_FULL ;
-      while ( dTryDeg > dAngRefDeg + EPS_ANG_SMALL)
-         dTryDeg -= ANG_FULL ;
-     // verifico
-      if ( abs( dTryDeg - dAngRefDeg) < EPS_ANG_SMALL) {
-         dAngDeg = dAngRefDeg ;
-         return true ;
-      }
-      else
-         return false ;
-   }
-}
-
-//----------------------------------------------------------------------------
-bool
-AdjustAngleInRange( double& dAngDeg, double dAngMinDeg, double dAngMaxDeg)
-{
-   return AdjustAngleInSpan( dAngDeg, ( dAngMinDeg + dAngMaxDeg) / 2, dAngMaxDeg - dAngMinDeg) ;
-}

ArcCenTgCurvePnt.cpp

@@ -17,10 +17,10 @@
 #include "CurveComposite.h"
 #include "CreateCurveAux.h"
 #include "GeoConst.h"
-#include "/EgtDev/Include/EGkArcCenTgCurvePnt.h"
-#include "/EgtDev/Include/EGkArcSpecial.h"
-#include "/EgtDev/Include/EGkCircleCenTgCurve.h"
-#include "/EgtDev/Include/EGkDistPointCurve.h"
+#include "/EgtDev/Include/EgkArcCenTgCurvePnt.h"
+#include "/EgtDev/Include/EgkArcSpecial.h"
+#include "/EgtDev/Include/EgkCircleCenTgCurve.h"
+#include "/EgtDev/Include/EgkDistPointCurve.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 
@@ -168,7 +168,7 @@ CurveArc* GetArcCenTgCompoPnt( const Point3d& ptCen, const CurveComposite& crvCo
       double dSqDist = SqDist( ptNearStart, ptTg) ;
       if ( dSqDist < dMinSqDist) {
          dMinSqDist = dSqDist ;
-         pCrvArc.Set( pCrvAtmp) ;
+         pCrvArc.Set( Release( pCrvAtmp)) ;
          if ( pPtTg != nullptr)
             *pPtTg = ptTg ;
       }

ArcPntDirTgCurve.cpp

@@ -16,11 +16,11 @@
 #include "CurveBezier.h"
 #include "CurveComposite.h"
 #include "CreateCurveAux.h"
+#include "DistPointLine.h"
 #include "GeoConst.h"
-#include "/EgtDev/Include/EGkArcPntDirTgCurve.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
-#include "/EgtDev/Include/EGkDistPointCurve.h"
-#include "/EgtDev/Include/EGkArcSpecial.h"
+#include "/EgtDev/Include/EgkArcPntDirTgCurve.h"
+#include "/EgtDev/Include/EgkDistPointCurve.h"
+#include "/EgtDev/Include/EgkArcSpecial.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 
@@ -204,7 +204,7 @@ GetArcPntDirTgArc( const Point3d& ptP, const Vector3d& vtDir, const CurveArc& cr
    if ( bOk1) {
       double dOffset = ( bOutSide ? crvArcL.GetRadius() : - crvArcL.GetRadius()) ;
       if ( pCrv1->GetType() == CRV_ARC)
-         bOk1 = (static_cast<CurveArc*>( Get( pCrv1)))->ExtendedOffset( dOffset) ;
+         bOk1 = (dynamic_cast<CurveArc*>(Get(pCrv1)))->ExtendedOffset( dOffset) ;
       else
          bOk1 = pCrv1->SimpleOffset( dOffset) ;
    }
@@ -235,7 +235,7 @@ GetArcPntDirTgArc( const Point3d& ptP, const Vector3d& vtDir, const CurveArc& cr
    if ( bOk2) {
       double dOffset = ( bOutSide ? - crvArcL.GetRadius() : crvArcL.GetRadius()) ;
       if ( pCrv2->GetType() == CRV_ARC)
-         bOk2 = (static_cast<CurveArc*>( Get( pCrv2)))->ExtendedOffset( dOffset) ;
+         bOk2 = (dynamic_cast<CurveArc*>(Get(pCrv2)))->ExtendedOffset( dOffset) ;
       else
          bOk2 = pCrv2->SimpleOffset( dOffset) ;
    }
@@ -297,7 +297,7 @@ GetArcPntDirTgBezier( const Point3d& ptP, const Vector3d& vtDir, const CurveBezi
       return nullptr ;
   // calcolo la circonferenza tangente a questa approssimazione
    Point3d ptTg ;
-   PtrOwner<ICurve> pCrv( GetArcPntDirTgCurve( ptP, vtDir, *pCrvCompo, ptNear, vtN, &ptTg)) ; 
+   PtrOwner<ICurve> pCrv( GetCurve( GetArcPntDirTgCurve( ptP, vtDir, *pCrvCompo, ptNear, vtN, &ptTg))) ; 
    if ( IsNull( pCrv))
       return nullptr ;
   // porto il punto di tangenza della circonferenza esattamente sulla curva di Bezier
@@ -330,14 +330,14 @@ GetArcPntDirTgCompo( const Point3d& ptP, const Vector3d& vtDir, const CurveCompo
          pCrv = crvCompo.GetNextCurve()) {
      // recupero la circonferenza tangente alla curva elementare
       Point3d ptTg ;
-      PtrOwner<ICurve> pCrvTmp( GetArcPntDirTgCurve( ptP, vtDir, *pCrv, ptNear, vtN, &ptTg)) ;
+      PtrOwner<ICurve> pCrvTmp( GetCurve( GetArcPntDirTgCurve( ptP, vtDir, *pCrv, ptNear, vtN, &ptTg))) ;
       if ( IsNull( pCrvTmp))
          continue ;
      // verifico se è la più vicina al punto desiderato
       double dSqDist = SqDist( ptNear, ptTg) ;
       if ( dSqDist < dMinSqDist) {
          dMinSqDist = dSqDist ;
-         pCrvNew.Set( pCrvTmp) ;
+         pCrvNew.Set( Release( pCrvTmp)) ;
          if ( pPtTg != nullptr)
             *pPtTg = ptTg ;
       }

ArcSpecial.cpp

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2023
+//  EgalTech 2014-2015
 //----------------------------------------------------------------------------
-// File : ArcSpecial.cpp         Data : 04.08.23       Versione : 2.5h1
+// File : ArcSpecial.cpp         Data : 15.03.15       Versione : 1.6c2
 // Contenuto : Implementazione funzioni per calcoli speciali archi.
 //
 //
@@ -14,12 +14,13 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CreateCurveAux.h"
-#include "/EgtDev/Include/EGkCurveLine.h"
-#include "/EgtDev/Include/EGkArcSpecial.h"
+#include "/EgtDev/Include/EgkCurveLine.h"
+#include "/EgtDev/Include/EgkArcSpecial.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 using namespace std ;
 
+
 //----------------------------------------------------------------------------
 // Come la CurveArc::Set2PD, ma se raggio infinito restituisce una retta
 //----------------------------------------------------------------------------
@@ -27,13 +28,15 @@ ICurve*
 GetArc2PD( const Point3d& ptStart, const Point3d& ptEnd, double dDirStartDeg)
 {
   // creo l'oggetto arco
-   PtrOwner<CurveArc> pArc( CreateBasicCurveArc()) ;
-   if ( IsNull( pArc))
+   ICurveArc* pArc = CreateCurveArc() ; 
+   if ( pArc == nullptr)
       return nullptr ;
+  // inizializzo il puntatore a curva con l'arco
+   PtrOwner<ICurve> pCrv( pArc) ;
 
   // calcolo l'arco, se ok lo restituisco ed esco
    if ( pArc->Set2PD( ptStart, ptEnd, dDirStartDeg))
-      return Release( pArc) ;
+      return Release( pCrv) ;
 
   // calcolo arco non riuscito, verifico se retta va bene
    Vector3d vtDiff = ptEnd - ptStart ;
@@ -42,12 +45,14 @@ GetArc2PD( const Point3d& ptStart, const Point3d& ptEnd, double dDirStartDeg)
    // verifico se i punti sono allineati con la direzione e nel giusto verso
    if ( abs( CrossXY( vtDiff, vtDir)) < EPS_SMALL  &&  ScalarXY( vtDiff, vtDir) > EPS_SMALL) {
      // creo l'oggetto retta
-      PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
-      if ( IsNull( pLine))
+      ICurveLine* pLine = CreateCurveLine() ;
+      if ( pLine == nullptr)
          return nullptr ;
+     // inizializzo il puntatore a curva con la retta
+      pCrv.Set( pLine) ;
      // calcolo retta, se ok la restituisco ed esco
       if ( pLine->Set( ptStart, ptEnd))
-         return Release( pLine) ;
+         return Release( pCrv) ;
    }
 
    return nullptr ;
@@ -60,59 +65,34 @@ ICurve*
 GetArc2PVN( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtDirS, const Vector3d& vtN)
 {
   // creo l'oggetto arco
-   PtrOwner<CurveArc> pArc( CreateBasicCurveArc()) ;
-   if ( IsNull( pArc))
+   ICurveArc* pArc = CreateCurveArc() ; 
+   if ( pArc == nullptr)
       return nullptr ;
+  // inizializzo il puntatore a curva con l'arco
+   PtrOwner<ICurve> pCrv( pArc) ;
 
   // calcolo l'arco, se ok lo restituisco ed esco
    if ( pArc->Set2PVN( ptStart, ptEnd, vtDirS, vtN))
-      return Release( pArc) ;
+      return Release( pCrv) ;
 
   // calcolo arco non riuscito, verifico se retta va bene
    Vector3d vtDiff = ptEnd - ptStart ;
    // verifico se i punti sono allineati con la direzione e nel giusto verso nel piano perpendicolare a vtN
    if ( abs( ( vtDiff ^ vtDirS) * vtN) < EPS_SMALL  &&  vtDiff * vtDirS > EPS_SMALL) {
      // creo l'oggetto retta
-      PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
-      if ( IsNull( pLine))
+      ICurveLine* pLine = CreateCurveLine() ;
+      if ( pLine == nullptr)
          return nullptr ;
+     // inizializzo il puntatore a curva con la retta
+      pCrv.Set( pLine) ;
      // calcolo retta, se ok la restituisco ed esco
       if ( pLine->Set( ptStart, ptEnd))
-         return Release( pLine) ;
+         return Release( pCrv) ;
    }
 
    return nullptr ;
 }
 
-//----------------------------------------------------------------------------
-// Come la CurveArc::Set2PNB, ma se bulge nullo restituisce una retta
-//----------------------------------------------------------------------------
-ICurve*
-GetArc2PNB( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtN, double dBulge)
-{
-  // creo l'oggetto arco
-   PtrOwner<CurveArc> pArc( CreateBasicCurveArc()) ;
-   if ( IsNull( pArc))
-      return nullptr ;
-
-  // calcolo l'arco, se ok lo restituisco ed esco
-   if ( pArc->Set2PNB( ptStart, ptEnd, vtN, dBulge))
-      return Release( pArc) ;
-
-  // calcolo arco non riuscito, verifico se retta va bene
-   if ( abs( dBulge) > EPS_SMALL)
-      return nullptr ;
-  // creo l'oggetto retta
-   PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
-   if ( IsNull( pLine))
-      return nullptr ;
-  // calcolo retta, se ok la restituisco ed esco
-   if ( pLine->Set( ptStart, ptEnd))
-      return Release( pLine) ;
-
-   return nullptr ;
-}
-
 //----------------------------------------------------------------------------
 // Come la CurveArc::Set3P, ma se raggio infinito restituisce una retta
 //----------------------------------------------------------------------------
@@ -120,64 +100,33 @@ ICurve*
 GetArc3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d& ptEnd, bool bCirc)
 {
   // creo l'oggetto arco
-   PtrOwner<CurveArc> pArc( CreateBasicCurveArc()) ;
-   if ( IsNull( pArc))
+   ICurveArc* pArc = CreateCurveArc() ; 
+   if ( pArc == nullptr)
       return nullptr ;
+  // inizializzo il puntatore a curva con l'arco
+   PtrOwner<ICurve> pCrv( pArc) ;
 
   // calcolo l'arco, se ok lo restituisco ed esco
    if ( pArc->Set3P( ptStart, ptOther, ptEnd, bCirc))
-      return Release( pArc) ;
+      return Release( pCrv) ;
 
-  // se era richiesta una circonferenza, errore perchè punti allineati
+  // se era richiesta una circonferenza, errore
    if ( bCirc)
       return nullptr ;
 
   // calcolo arco non riuscito, se i punti sono allineati nel giusto verso per essere una retta
    // verifico se i punti sono allineati nel giusto verso
-   if ( ( ptOther - ptStart) * ( ptEnd - ptOther) > EPS_ZERO  ||
-        AreSamePointApprox( ptOther, ptStart)  ||  AreSamePointApprox( ptEnd, ptOther)) {
+   if ( ( ptOther - ptStart) * ( ptEnd - ptOther) > EPS_ZERO) {
      // creo l'oggetto retta
-      PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
-      if ( IsNull( pLine))
+      ICurveLine* pLine = CreateCurveLine() ;
+      if ( pLine == nullptr)
          return nullptr ;
+     // inizializzo il puntatore a curva con la retta
+      pCrv.Set( pLine) ;
      // calcolo retta, se ok la restituisco ed esco
       if ( pLine->Set( ptStart, ptEnd))
-         return Release( pLine) ;
+         return Release( pCrv) ;
    }
 
    return nullptr ;
 }
-
-//----------------------------------------------------------------------------
-// Come la CurveArc::SetC2PN, ma garantisce il passaggio per gli estremi e minimizza errore sul centro
-//----------------------------------------------------------------------------
-ICurveArc*
-GetArc2PCN( const Point3d& ptStart, const Point3d& ptEnd, const Point3d& ptNearCen, const Vector3d& vtN)
-{
-  // creo l'oggetto arco
-   PtrOwner<CurveArc> pArc( CreateBasicCurveArc()) ;
-   if ( IsNull( pArc))
-      return nullptr ;
-
-  // vettori dal centro a inizio e fine
-   Vector3d vtStart = ptStart - ptNearCen ;
-   Vector3d vtEnd = ptEnd - ptNearCen ;
-
-  // determino il raggio medio
-   double dStartRad = OrthoCompo( vtStart, vtN).Len() ;
-   double dEndRad = OrthoCompo( vtEnd, vtN).Len() ;
-   double dRad = ( dStartRad + dEndRad) / 2 ;
-   if ( dRad < EPS_SMALL)
-      return nullptr ;
-
-  // determino un valore approssimato dell'angolo al centro
-   double dAngDeg ; bool bDet ;
-   if ( ! vtStart.GetRotation( vtEnd, vtN, dAngDeg, bDet)  ||  ! bDet  ||  abs( dAngDeg) < EPS_ANG_ZERO) 
-      return nullptr ;
-
-  // calcolo l'arco antiorario per i due punti con il raggio medio
-   if ( pArc->Set2PNRS( ptStart, ptEnd, vtN, dRad, ( dAngDeg > 0)))
-      return Release( pArc) ;
-
-   return nullptr ;
-}

Attribs.cpp

@@ -18,7 +18,7 @@
 #include "NgeReader.h"
 #include "GeomDB.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
-#include "/EgtDev/Include/EGnStringKeyVal.h"
+#include "/EgtDev/Include/EgnStringKeyVal.h"
 
 using namespace std ;
 
@@ -81,7 +81,8 @@ Attribs::Dump( const GeomDB& GDB, string& sOut, bool bMM, const char* szNewLine)
    }
    sOut += szNewLine ;
   // eventuali nome e stringhe informative
-   for ( auto iIter = m_slInfo.cbegin() ; iIter != m_slInfo.cend() ; ++ iIter)
+   STRLIST::const_iterator iIter ;
+   for ( iIter = m_slInfo.begin() ; iIter != m_slInfo.end() ; ++ iIter)
       sOut += *iIter + szNewLine ;
 
    return true ;
@@ -100,7 +101,7 @@ Attribs::Save( NgeWriter& ngeOut) const
   // modo
    if ( ! ngeOut.WriteUchar( m_Data[MODE], ","))
       return false ;
-  // stato (se SEL è convertito in ON)
+  // stato (se SEL è convertito in ON)
    int nStat = (( m_Data[STATUS] > GDB_ST_ON) ? GDB_ST_ON : m_Data[STATUS]) ;
    if ( ! ngeOut.WriteUchar( nStat, ","))
       return false ;
@@ -117,7 +118,8 @@ Attribs::Save( NgeWriter& ngeOut) const
    if ( ! ngeOut.WriteInt( int( m_slInfo.size()), ";", true))
       return false ;
   // stringhe di info
-   for ( auto iIter = m_slInfo.cbegin() ; iIter != m_slInfo.cend() ; ++ iIter) {
+   STRLIST::const_iterator iIter ;
+   for ( iIter = m_slInfo.begin() ; iIter != m_slInfo.end() ; ++ iIter) {
       if ( ! ngeOut.WriteString( *iIter, nullptr, true))
          return false ;
    }
@@ -133,22 +135,22 @@ Attribs::Load( NgeReader& ngeIn)
    unsigned char ucLev ;
    if ( ! ngeIn.ReadUchar( ucLev, ","))
       return false ;
-   m_Data[LEVEL] = Clamp( ucLev, GDB_LV_USER, GDB_LV_TEMP) ;
+   m_Data[LEVEL] = CLIP( ucLev, GDB_LV_USER, GDB_LV_TEMP) ;
   // modo
    unsigned char ucMode ;
    if ( ! ngeIn.ReadUchar( ucMode, ","))
       return false ;
-   m_Data[MODE] = Clamp( ucMode, GDB_MD_STD, GDB_MD_HIDDEN) ;
-  // stato (se SEL è convertito in ON)
+   m_Data[MODE] = CLIP( ucMode, GDB_MD_STD, GDB_MD_HIDDEN) ;
+  // stato (se SEL è convertito in ON)
    unsigned char ucStat ;
    if ( ! ngeIn.ReadUchar( ucStat, ","))
       return false ;
-   m_Data[STATUS] = Clamp( ucStat, GDB_ST_OFF, GDB_ST_ON) ;
+   m_Data[STATUS] = CLIP( ucStat, GDB_ST_OFF, GDB_ST_ON) ;
   // marcatura (sempre OFF)
    unsigned char ucMark ;
    if ( ! ngeIn.ReadUchar( ucMark, ";"))
       return false ;
-   m_Data[MARK] = Clamp( ucMark, GDB_MK_OFF, GDB_MK_OFF) ;
+   m_Data[MARK] = CLIP( ucMark, GDB_MK_OFF, GDB_MK_OFF) ;
   // materiale
    if ( ! ngeIn.ReadInt( m_Material, ";"))
       return false ;
@@ -175,7 +177,7 @@ Attribs::Load( NgeReader& ngeIn)
 bool
 Attribs::DataFromString( const string& sParam)
 {
-  // il primo parametro è diviso in 4 parti
+  // il primo parametro è diviso in 4 parti
    STRVECTOR vsParams ;
    Tokenize( sParam, ",", vsParams) ;
   // 4 parti
@@ -185,22 +187,22 @@ Attribs::DataFromString( const string& sParam)
    int nLev ;
    if ( ! FromString( vsParams[0], nLev))
       return false ;
-   m_Data[LEVEL] = Clamp( nLev, GDB_LV_USER, GDB_LV_TEMP) ;
+   m_Data[LEVEL] = CLIP( nLev, GDB_LV_USER, GDB_LV_TEMP) ;
   // modo
    int nMode ;
    if ( ! FromString( vsParams[1], nMode))
       return false ;
-   m_Data[MODE] = Clamp( nMode, GDB_MD_STD, GDB_MD_HIDDEN) ;
+   m_Data[MODE] = CLIP( nMode, GDB_MD_STD, GDB_MD_HIDDEN) ;
   // stato (ammessi solo OFF e ON)
    int nStat ;
    if ( ! FromString( vsParams[2], nStat))
       return false ;
-   m_Data[STATUS] = Clamp( nStat, GDB_ST_OFF, GDB_ST_ON) ;
+   m_Data[STATUS] = CLIP( nStat, GDB_ST_OFF, GDB_ST_ON) ;
   // marcatura (ammesso solo OFF)
    int nMark ;
    if ( ! FromString( vsParams[3], nMark))
       return false ;
-   m_Data[MARK] = Clamp( nMark, GDB_MK_OFF, GDB_MK_OFF) ;
+   m_Data[MARK] = CLIP( nMark, GDB_MK_OFF, GDB_MK_OFF) ;
 
    return true ;
 }
@@ -210,12 +212,13 @@ bool
 Attribs::SetName( const string& sName)
 {
   // se nome non valido, esco con errore
-   if ( sName.empty()  ||  ! IsValidVal( sName))
+   if ( ! IsValidVal( sName))
       return false ;
 
-  // può essere solo la prima stringa 
-   auto iIter = m_slInfo.begin() ;
-   if ( iIter != m_slInfo.end()  &&  FindKey( *iIter, NAME)) {
+  // può essere solo la prima stringa 
+   STRLIST::iterator iIter ;
+   if ( ( iIter = m_slInfo.begin()) != m_slInfo.end()  &&
+        FindKey( *iIter, NAME)) {
       *iIter = NAME + EQUAL + sName ;
       return true ;
    }
@@ -234,9 +237,10 @@ Attribs::SetName( const string& sName)
 bool
 Attribs::GetName( string& sName) const
 {
-  // può essere solo la prima stringa 
-   const auto iIter = m_slInfo.cbegin() ;
-   if ( iIter != m_slInfo.cend()  &&  FindKey( *iIter, NAME)) {
+  // può essere solo la prima stringa 
+   STRLIST::const_iterator iIter ;
+   if ( ( iIter = m_slInfo.begin()) != m_slInfo.end()  &&
+        FindKey( *iIter, NAME)) {
       sName = iIter->substr( NAME.length() + 1) ;
       return true ;
    }
@@ -248,18 +252,23 @@ Attribs::GetName( string& sName) const
 bool
 Attribs::ExistsName( void) const
 {
-  // può essere solo la prima stringa 
-   const auto iIter = m_slInfo.cbegin() ;
-   return ( iIter != m_slInfo.cend()  &&  FindKey( *iIter, NAME)) ;
+  // può essere solo la prima stringa 
+   STRLIST::const_iterator iIter ;
+   if ( ( iIter = m_slInfo.begin()) != m_slInfo.end()  &&
+        FindKey( *iIter, NAME))
+      return true ;
+   
+   return false ;
 }
 
 //----------------------------------------------------------------------------
 bool
 Attribs::RemoveName( void)
 {
-  // può essere solo la prima stringa 
-   const auto iIter = m_slInfo.cbegin() ;
-   if ( iIter != m_slInfo.cend()  &&  FindKey( *iIter, NAME)) {
+  // può essere solo la prima stringa 
+   STRLIST::const_iterator iIter ;
+   if ( ( iIter = m_slInfo.begin()) != m_slInfo.end()  &&
+        FindKey( *iIter, NAME)) {
       m_slInfo.pop_front() ;
       return true ;
    }
@@ -273,14 +282,14 @@ bool
 Attribs::SetInfo( const string& sKey, const string& sVal)
 {
   // se chiave o valore non validi, esco con errore
-   if ( ! IsValidKey( sKey)  ||  sVal.empty()  ||  ! IsValidVal( sVal))
+   if ( ! IsValidKey( sKey)  ||  ! IsValidVal( sVal))
       return false ;
 
-  // se è il nome
+  // se è il nome
    if ( sKey == NAME)
       return SetName( sVal) ;
 
-  // se esiste già una stringa con quella chiave la sostituisco
+  // se esiste già una stringa con quella chiave la sostituisco
    for ( auto iIter = m_slInfo.begin() ; iIter != m_slInfo.end() ; ++ iIter) {
       if ( FindKey( *iIter, sKey)) {
          *iIter = sKey + EQUAL + sVal ;
@@ -347,27 +356,6 @@ Attribs::RemoveInfo( const string& sKey)
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-Attribs::GetAllInfo( STRVECTOR& vsInfo) const
-{
-  // riservo spazio opportuno per il vettore delle stringhe
-   vsInfo.clear() ;
-
-  // se non ci sono info esco
-   if ( m_slInfo.empty())
-      return true ;
-
-   vsInfo.reserve( m_slInfo.size()) ;
-  // recupero tutte le info tranne il nome (se presente sempre al primo posto) 
-   auto iIter = m_slInfo.cbegin() ;
-   if ( FindKey( *iIter, NAME))
-      ++ iIter ;
-   for (  ; iIter != m_slInfo.cend() ; ++ iIter)
-      vsInfo.emplace_back( *iIter) ;
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 Attribs::CopyAllInfoFrom( const Attribs& attrSou)

Attribs.h

@@ -16,12 +16,14 @@
 #include "/EgtDev/Include/EGkGdbConst.h"
 #include "/EgtDev/Include/EGkColor.h"
 #include "/EgtDev/Include/EgtStringBase.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
 
 class NgeWriter ;
 class NgeReader ;
 class GeomDB ;
 
+//----------------------------------------------------------------------------
+#define CLIP( nV, nMIN, nMAX)  (( nV < nMIN) ? nMIN : (( nV > nMAX) ? nMAX : nV))
+
 //----------------------------------------------------------------------------
 class Attribs
 {
@@ -44,14 +46,14 @@ class Attribs
       bool Load( NgeReader& ngeIn) ;
       void SetLevel( int nLev)
               { m_OldData[LEVEL] = m_Data[LEVEL] ;
-                m_Data[LEVEL] = Clamp( nLev, GDB_LV_USER, GDB_LV_TEMP) ; }
+                m_Data[LEVEL] = CLIP( nLev, GDB_LV_USER, GDB_LV_TEMP) ; }
       void RevertLevel( void)
               { std::swap( m_Data[LEVEL], m_OldData[LEVEL]) ; }
       int  GetLevel( void) const
               { return m_Data[LEVEL] ; }
       void SetMode( int nMode)
               { m_OldData[MODE] = m_Data[MODE] ;
-                m_Data[MODE] = Clamp( nMode, GDB_MD_STD, GDB_MD_HIDDEN) ; }
+                m_Data[MODE] = CLIP( nMode, GDB_MD_STD, GDB_MD_HIDDEN) ; }
       void RevertMode( void)
               { std::swap( m_Data[MODE], m_OldData[MODE]) ; }
       int  GetMode( void) const
@@ -59,13 +61,13 @@ class Attribs
       void SetStatus( int nStat)
               { if ( m_Data[STATUS] != GDB_ST_SEL)
                    m_OldData[STATUS] = m_Data[STATUS] ;
-                m_Data[STATUS] = Clamp( nStat, GDB_ST_OFF, GDB_ST_SEL) ; }
+                m_Data[STATUS] = CLIP( nStat, GDB_ST_OFF, GDB_ST_SEL) ; }
       void RevertStatus( void)
               { SetStatus( m_OldData[STATUS]) ; }
       int  GetStatus( void) const
               { return m_Data[STATUS] ; }
-      void SetMark( int nMark)
-              { m_Data[MARK] = Clamp( nMark, GDB_MK_OFF, GDB_MK_ON_2) ; }
+      void SetMark( void)
+              { m_Data[MARK] = GDB_MK_ON ; }
       void ResetMark( void)
               { m_Data[MARK] = GDB_MK_OFF ; }
       int  GetMark( void) const
@@ -87,7 +89,6 @@ class Attribs
       bool GetInfo( const std::string& sKey, std::string& sVal) const ;
       bool ExistsInfo( const std::string& sKey) const ;
       bool RemoveInfo( const std::string& sKey) ;
-      bool GetAllInfo( STRVECTOR& vsInfo) const ;
       bool CopyAllInfoFrom( const Attribs& attrSou) ;
 
    private :
@@ -99,7 +100,7 @@ class Attribs
    private :
       unsigned char m_Data[DIM] ;
       unsigned char m_OldData[DIM] ;
-      int           m_Material ;
-      Color         m_Color ;
-      STRLIST       m_slInfo ;
+      int   m_Material ;
+      Color m_Color ;
+      STRLIST m_slInfo ;
 } ;

BBox3d.cpp

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2022
+//  EgalTech 2013-2013
 //----------------------------------------------------------------------------
-// File : BBox3d.cpp          Data : 17.08.22          Versione : 2.4h1
+// File : BBox3d.cpp          Data : 14.01.14          Versione : 1.5a3
 // Contenuto : Implementazione della classe axis aligned bounding box BBox3d.
 //
 //
@@ -13,8 +13,8 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "/EgtDev/Include/EGkBBox3d.h"
-#include "/EgtDev/Include/EGkFrame3d.h"
+#include "\EgtDev\Include\EGkBBox3d.h"
+#include "\EgtDev\Include\EGkFrame3d.h"
 #include <algorithm>
 
 using namespace std ;
@@ -53,8 +53,7 @@ BBox3d::Set( double dX1, double dY1, double dZ1, double dX2, double dY2, double
 bool
 BBox3d::IsValid( void) const
 {
-   return ( m_ptMin.IsValid()  &&  m_ptMax.IsValid()  &&
-            m_ptMin.x < ( m_ptMax.x + EPS_SMALL)  &&
+   return ( m_ptMin.x < ( m_ptMax.x + EPS_SMALL)  &&
             m_ptMin.y < ( m_ptMax.y + EPS_SMALL)  &&
             m_ptMin.z < ( m_ptMax.z + EPS_SMALL)) ;
 }
@@ -211,33 +210,6 @@ BBox3d::GetMinDim( Point3d& ptMin, double& dDimX, double& dDimY, double& dDimZ)
    return true ;
 }
 
-//----------------------------------------------------------------------------
-double
-BBox3d::GetDimX( void) const
-{
-   if ( ! IsValid())
-      return 0 ;
-   return ( m_ptMax.x - m_ptMin.x) ;
-}
-
-//----------------------------------------------------------------------------
-double
-BBox3d::GetDimY( void) const
-{
-   if ( ! IsValid())
-      return 0 ;
-   return ( m_ptMax.y - m_ptMin.y) ;
-}
-
-//----------------------------------------------------------------------------
-double
-BBox3d::GetDimZ( void) const
-{
-   if ( ! IsValid())
-      return 0 ;
-   return ( m_ptMax.z - m_ptMin.z) ;
-}
-
 //----------------------------------------------------------------------------
 bool
 BBox3d::GetCenterExtent( Point3d& ptCenter, Vector3d& vtExtent) const
@@ -448,141 +420,69 @@ BBox3d::EnclosesXY( const BBox3d& b3Box) const
 
 //----------------------------------------------------------------------------
 bool
-BBox3d::Overlaps( const BBox3d& b3Box) const
+BBox3d::Overlaps( const BBox3d& b3B) const
 {
-   if ( m_ptMax.x < b3Box.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3Box.m_ptMax.x + EPS_SMALL)
+   if ( m_ptMax.x < b3B.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3B.m_ptMax.x + EPS_SMALL)
       return false ;
-   if ( m_ptMax.y < b3Box.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3Box.m_ptMax.y + EPS_SMALL)
+   if ( m_ptMax.y < b3B.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3B.m_ptMax.y + EPS_SMALL)
       return false ;
-   if ( m_ptMax.z < b3Box.m_ptMin.z - EPS_SMALL  ||  m_ptMin.z > b3Box.m_ptMax.z + EPS_SMALL)
+   if ( m_ptMax.z < b3B.m_ptMin.z - EPS_SMALL  ||  m_ptMin.z > b3B.m_ptMax.z + EPS_SMALL)
       return false ;
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-BBox3d::OverlapsXY( const BBox3d& b3Box) const
+BBox3d::OverlapsXY( const BBox3d& b3B) const
 {
-   if ( m_ptMax.x < b3Box.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3Box.m_ptMax.x + EPS_SMALL)
+   if ( m_ptMax.x < b3B.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3B.m_ptMax.x + EPS_SMALL)
       return false ;
-   if ( m_ptMax.y < b3Box.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3Box.m_ptMax.y + EPS_SMALL)
+   if ( m_ptMax.y < b3B.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3B.m_ptMax.y + EPS_SMALL)
       return false ;
    return true ;
 }
 
-//----------------------------------------------------------------------------
-inline bool
-TestSeparatingAxis( const Vector3d& vtAx, const Vector3d& vtDiff, const Vector3d& vtHe,
-                    const Vector3d& vtHe2X, const Vector3d& vtHe2Y, const Vector3d& vtHe2Z)
-{
-   if ( vtAx.IsSmall())
-      return false ;
-   double dLen = ( vtAx.IsNormalized() ? 1 : vtAx.Len()) ;
-   return ( abs( vtDiff * vtAx) >
-            abs( vtHe.x * vtAx.x) + abs( vtHe.y * vtAx.y) + abs( vtHe.z * vtAx.z) +
-            abs( vtHe2X * vtAx) + abs( vtHe2Y * vtAx) + abs( vtHe2Z * vtAx) + EPS_SMALL * dLen) ;
-}
-
 //----------------------------------------------------------------------------
 bool
-BBox3d::Overlaps( const Frame3d& frBox, const BBox3d& b3Box) const
+BBox3d::FindIntersection( const BBox3d& b3B, BBox3d& b3Int) const
 {
-  // Verifico validità di entrambi i box
-   if ( ! IsValid()  ||  ! b3Box.IsValid())
-      return false ;
-
-  // Centro e semiampiezza del box
-   Point3d ptCen = ( m_ptMin + m_ptMax) / 2 ;
-   Vector3d vtHe = ( m_ptMax - m_ptMin) / 2 ;
-  // Centro e semiampiezza dell'altro box
-   Point3d ptCen2 = GetToGlob( ( b3Box.m_ptMin + b3Box.m_ptMax) / 2, frBox) ;
-   Vector3d vtHe2X = GetToGlob( Vector3d( ( b3Box.GetDimX()) / 2, 0, 0), frBox) ;
-   Vector3d vtHe2Y = GetToGlob( Vector3d( 0, ( b3Box.GetDimY()) / 2, 0), frBox) ;
-   Vector3d vtHe2Z = GetToGlob( Vector3d( 0, 0, ( b3Box.GetDimZ()) / 2), frBox) ;
-  // Vettore tra i due centri
-   Vector3d vtDiff = ptCen2 - ptCen ;
-
-  // Verifico separazione sulle normali ai piani principali del riferimento globale
-   if ( TestSeparatingAxis( X_AX, vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-   if ( TestSeparatingAxis( Y_AX, vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-   if ( TestSeparatingAxis( Z_AX, vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-
-  // Verifico separazione sulle normali ai piani principali del secondo riferimento
-   if ( TestSeparatingAxis( frBox.VersX(), vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-   if ( TestSeparatingAxis( frBox.VersY(), vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-   if ( TestSeparatingAxis( frBox.VersZ(), vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-
-  // Verifico separazione sulle altre normali ottenute come prodotto vettoriali di quelle precedenti
-   if ( TestSeparatingAxis( X_AX ^ frBox.VersX(), vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-   if ( TestSeparatingAxis( X_AX ^ frBox.VersY(), vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-   if ( TestSeparatingAxis( X_AX ^ frBox.VersZ(), vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-   if ( TestSeparatingAxis( Y_AX ^ frBox.VersX(), vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-   if ( TestSeparatingAxis( Y_AX ^ frBox.VersY(), vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-   if ( TestSeparatingAxis( Y_AX ^ frBox.VersZ(), vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-   if ( TestSeparatingAxis( Z_AX ^ frBox.VersX(), vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-   if ( TestSeparatingAxis( Z_AX ^ frBox.VersY(), vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-   if ( TestSeparatingAxis( Z_AX ^ frBox.VersZ(), vtDiff, vtHe, vtHe2X, vtHe2Y, vtHe2Z))
-      return false ;
-
-  // Si sovrappongono
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-BBox3d::FindIntersection( const BBox3d& b3Box, BBox3d& b3Int) const
-{
-   if ( ! IsValid()  ||  ! b3Box.IsValid())
+   if ( ! IsValid()  ||  ! b3B.IsValid())
       return false ;
   // verifico direttamente la sovrapposizione
-   if ( m_ptMax.x < b3Box.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3Box.m_ptMax.x + EPS_SMALL)
+   if ( m_ptMax.x < b3B.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3B.m_ptMax.x + EPS_SMALL)
       return false ;
-   if ( m_ptMax.y < b3Box.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3Box.m_ptMax.y + EPS_SMALL)
+   if ( m_ptMax.y < b3B.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3B.m_ptMax.y + EPS_SMALL)
       return false ;
-   if ( m_ptMax.z < b3Box.m_ptMin.z - EPS_SMALL  ||  m_ptMin.z > b3Box.m_ptMax.z + EPS_SMALL)
+   if ( m_ptMax.z < b3B.m_ptMin.z - EPS_SMALL  ||  m_ptMin.z > b3B.m_ptMax.z + EPS_SMALL)
       return false ;
   // calcolo il box intersezione
-   b3Int.m_ptMin.x = (( m_ptMin.x >= b3Box.m_ptMin.x) ? m_ptMin.x : b3Box.m_ptMin.x) ;
-   b3Int.m_ptMin.y = (( m_ptMin.y >= b3Box.m_ptMin.y) ? m_ptMin.y : b3Box.m_ptMin.y) ;
-   b3Int.m_ptMin.z = (( m_ptMin.z >= b3Box.m_ptMin.z) ? m_ptMin.z : b3Box.m_ptMin.z) ;
-   b3Int.m_ptMax.x = (( m_ptMax.x <= b3Box.m_ptMax.x) ? m_ptMax.x : b3Box.m_ptMax.x) ;
-   b3Int.m_ptMax.y = (( m_ptMax.y <= b3Box.m_ptMax.y) ? m_ptMax.y : b3Box.m_ptMax.y) ;
-   b3Int.m_ptMax.z = (( m_ptMax.z <= b3Box.m_ptMax.z) ? m_ptMax.z : b3Box.m_ptMax.z) ;
+   b3Int.m_ptMin.x = (( m_ptMin.x >= b3B.m_ptMin.x) ? m_ptMin.x : b3B.m_ptMin.x) ;
+   b3Int.m_ptMin.y = (( m_ptMin.y >= b3B.m_ptMin.y) ? m_ptMin.y : b3B.m_ptMin.y) ;
+   b3Int.m_ptMin.z = (( m_ptMin.z >= b3B.m_ptMin.z) ? m_ptMin.z : b3B.m_ptMin.z) ;
+   b3Int.m_ptMax.x = (( m_ptMax.x <= b3B.m_ptMax.x) ? m_ptMax.x : b3B.m_ptMax.x) ;
+   b3Int.m_ptMax.y = (( m_ptMax.y <= b3B.m_ptMax.y) ? m_ptMax.y : b3B.m_ptMax.y) ;
+   b3Int.m_ptMax.z = (( m_ptMax.z <= b3B.m_ptMax.z) ? m_ptMax.z : b3B.m_ptMax.z) ;
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-BBox3d::FindIntersectionXY( const BBox3d& b3Box, BBox3d& b3Int) const
+BBox3d::FindIntersectionXY( const BBox3d& b3B, BBox3d& b3Int) const
 {
-   if ( ! IsValid()  ||  ! b3Box.IsValid())
+   if ( ! IsValid()  ||  ! b3B.IsValid())
       return false ;
   // verifico direttamente la sovrapposizione
-   if ( m_ptMax.x < b3Box.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3Box.m_ptMax.x + EPS_SMALL)
+   if ( m_ptMax.x < b3B.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3B.m_ptMax.x + EPS_SMALL)
       return false ;
-   if ( m_ptMax.y < b3Box.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3Box.m_ptMax.y + EPS_SMALL)
+   if ( m_ptMax.y < b3B.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3B.m_ptMax.y + EPS_SMALL)
       return false ;
   // calcolo il box intersezione
-   b3Int.m_ptMin.x = (( m_ptMin.x >= b3Box.m_ptMin.x) ? m_ptMin.x : b3Box.m_ptMin.x) ;
-   b3Int.m_ptMin.y = (( m_ptMin.y >= b3Box.m_ptMin.y) ? m_ptMin.y : b3Box.m_ptMin.y) ;
-   b3Int.m_ptMin.z = 0.5 * ( m_ptMin.z + b3Box.m_ptMin.z) ;
-   b3Int.m_ptMax.x = (( m_ptMax.x <= b3Box.m_ptMax.x) ? m_ptMax.x : b3Box.m_ptMax.x) ;
-   b3Int.m_ptMax.y = (( m_ptMax.y <= b3Box.m_ptMax.y) ? m_ptMax.y : b3Box.m_ptMax.y) ;
-   b3Int.m_ptMax.z = 0.5 * ( m_ptMax.z + b3Box.m_ptMax.z) ;
+   b3Int.m_ptMin.x = (( m_ptMin.x >= b3B.m_ptMin.x) ? m_ptMin.x : b3B.m_ptMin.x) ;
+   b3Int.m_ptMin.y = (( m_ptMin.y >= b3B.m_ptMin.y) ? m_ptMin.y : b3B.m_ptMin.y) ;
+   b3Int.m_ptMin.z = 0.5 * ( m_ptMin.z + b3B.m_ptMin.z) ;
+   b3Int.m_ptMax.x = (( m_ptMax.x <= b3B.m_ptMax.x) ? m_ptMax.x : b3B.m_ptMax.x) ;
+   b3Int.m_ptMax.y = (( m_ptMax.y <= b3B.m_ptMax.y) ? m_ptMax.y : b3B.m_ptMax.y) ;
+   b3Int.m_ptMax.z = 0.5 * ( m_ptMax.z + b3B.m_ptMax.z) ;
    return true ;
 }
 

BiArcs.cpp

@@ -14,13 +14,12 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "BiArcs.h"
-#include "CurveLine.h"
 #include "CurveArc.h"
-#include "CurveComposite.h"
 #include "/EgtDev/Include/EGkAngle.h"
-#include "/EgtDev/Include/EGkArcSpecial.h"
+#include "/EgtDev/Include/EgkCurveLine.h"
+#include "/EgtDev/Include/EgkCurveComposite.h"
+#include "/EgtDev/Include/EgkArcSpecial.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 using namespace std ;
@@ -50,7 +49,7 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
       return nullptr ;
 
   // preparo la curva composita per i biarchi
-   PtrOwner<CurveComposite> pBiArc( CreateBasicCurveComposite()) ;
+   PtrOwner<ICurveComposite> pBiArc( CreateCurveComposite()) ;
    if ( IsNull( pBiArc))
       return nullptr ;
 
@@ -83,7 +82,7 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
 //----------------------------------------------------------------------------
 ICurve*
 GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir1Deg,
-          const PolyLine& PL, double& dDist, double dTol)
+          const PolyLine& PL, double& dDist)
 {
   // calcolo la curva dove giacciono i punti di giunzione tra i due archi del biarco
    PtrOwner<ICurve> pJCrv( CalcJCurve( ptP0, dDir0Deg, ptP1, dDir1Deg)) ;
@@ -95,10 +94,10 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
       pBiArc.Set( GetBiArc( ptP0, dDir0Deg, ptP1, dDir1Deg, 0.5)) ;
    }
    else {
-      const CurveArc* pArc = GetBasicCurveArc( pJCrv) ;
+      CurveArc* pArc = GetBasicCurveArc( pJCrv) ;
       if ( pArc == nullptr)
          return nullptr ;
-      double dU = -1 ;
+      double dU = - 1 ;
       double dRad = pArc->GetRadius() ;
       double dSqRad = dRad * dRad ;
       Point3d ptCen = pArc->GetCenter() ;
@@ -122,11 +121,9 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
             }
          }
       }
-     // non c'è intersezione, assegno valore medio
-      if ( dU < -0.5)
-         dU = 0.5 ;
      // elimino casi vicino agli estremi, danno solo problemi
-      dU = Clamp( dU, 0.1, 0.9) ;
+      if ( dU < 0.1  ||  dU > 0.9)
+         dU = 0.5 ;
       pBiArc.Set( GetBiArc( ptP0, dDir0Deg, ptP1, dDir1Deg, dU)) ;
    }
 
@@ -135,27 +132,15 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
       return nullptr ;
 
   // determino la massima distanza tra la curva e il biarco
+   Point3d ptP ;
    double dSqDist = 0 ;
-   const double STEP = 10 ;
-   Point3d ptCurr ;
-   bool bPnt = PL.GetFirstPoint( ptCurr) ;
-   Point3d ptPrev = ptCurr ;
-   while ( bPnt) {
-      double dLen = Dist( ptCurr, ptPrev) ;
-      int nStep = int( dLen / STEP) + 1 ;
-      int nMinStep = ( dLen > 50 * dTol ? 3 : ( dLen > 10 * dTol ? 2 : 1)) ;
-      int nMaxStep = 10 ;
-      nStep = Clamp( nStep, nMinStep, nMaxStep) ;
-      for ( int i = 1 ; i <= nStep ; ++ i) {
-         double dCoeff = double( i) / nStep ;
-         Point3d ptP = Media( ptPrev, ptCurr, dCoeff) ;
-         DistPointCurve dstPC( ptP, *pBiArc) ;
-         double dSqDistPC ;
-         if ( dstPC.GetSqDist( dSqDistPC)  &&  dSqDistPC > dSqDist)
-            dSqDist = dSqDistPC ;
-      }
-      ptPrev = ptCurr ;
-      bPnt = PL.GetNextPoint( ptCurr) ;
+   for ( bool bPnt = PL.GetFirstPoint( ptP) ;
+         bPnt ;
+         bPnt = PL.GetNextPoint( ptP)) {
+      DistPointCurve dstPC( ptP, *pBiArc) ;
+      double dSqDistPC ;
+      if ( dstPC.GetSqDist( dSqDistPC)  &&  dSqDistPC > dSqDist)
+         dSqDist = dSqDistPC ;
    }
    dDist = sqrt( dSqDist) ;
 
@@ -166,7 +151,7 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
 static ICurve*
 CalcJCurve( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir1Deg)
 {
-  // se i due punti coincidono, non si può fare alcunché
+  // se i due punti coincidono, non si può fare alcunché
    if ( AreSamePointApprox( ptP0, ptP1))
       return nullptr ;
 
@@ -175,7 +160,7 @@ CalcJCurve( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dD
 
   // se rotazione nulla, allora segmento di retta tra i due punti
    if ( abs( dAngDeg) < EPS_ANG_SMALL) {
-      PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
+      PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
       if ( IsNull( pLine)  ||  ! pLine->Set( ptP0, ptP1))
          return nullptr ;
      // inverto per avere parametrizzazione crescente allontanandosi da Dir0 e avvicinandosi a Dir1
@@ -197,7 +182,7 @@ CalcJCurve( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dD
    Vector3d vtStart = ptP0 - ptCen ;
    double dRad, dAngStart ;
    vtStart.ToSpherical( &dRad, nullptr, &dAngStart) ;
-   PtrOwner<CurveArc> pArc( CreateBasicCurveArc()) ;
+   PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
    if ( IsNull( pArc)  ||  ! pArc->SetXY( ptCen, dRad, dAngStart, dAngDeg, ( ptP1.z - ptP0.z)))
       return nullptr ;
    double dDirStartDeg = dAngStart + ( dAngDeg > 0 ? ANG_RIGHT : - ANG_RIGHT) ;
@@ -208,14 +193,14 @@ CalcJCurve( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dD
    double dDir0RelDeg = DiffAngle( dDir0Deg, dDirDiffDeg) ;
    // direzione iniziale secondo arco limite rispetto a direzione P0->P1 (dalla finale simmetrico e invert)
    double dDir1RelDeg = - DiffAngle( dDir1Deg, dDirDiffDeg) ;
-   // nel caso di direzioni a 180deg si sceglie la più compatta
+   // nel caso di direzioni a 180deg si sceglie la più compatta
    if ( abs( abs( dDir1RelDeg) - ANG_STRAIGHT) < EPS_SMALL)
       dDir1RelDeg = ( dDir0RelDeg > 0 ? ANG_STRAIGHT : - ANG_STRAIGHT) ;
    else if ( abs( abs( dDir0RelDeg) - ANG_STRAIGHT) < EPS_SMALL)
       dDir0RelDeg = ( dDir1RelDeg > 0 ? ANG_STRAIGHT : - ANG_STRAIGHT) ;
    // intervallo angolare ammissibile a partire da direzione iniziale primo arco ammissibile ( == Dir0)
    double dDeltaAngDeg = - dDir0RelDeg + dDir1RelDeg ;
-  // se non è nella regione, prendo l'altra parte di arco
+  // se non è nella regione, prendo l'altra parte di arco
    if ( ! AngleInSpan( dDirStartRelDeg, dDir0RelDeg, dDeltaAngDeg)) 
       pArc->ToExplementary() ;
   // inverto per avere parametrizzazione crescente allontanandosi da Dir0 e avvicinandosi a Dir1

BiArcs.h

@@ -13,9 +13,9 @@
 
 #pragma once
 
-#include "/EgtDev/Include/EGkBiArcs.h"
+#include "/EgtDev/Include/EgkBiArcs.h"
 
 //-----------------------------------------------------------------------------
 ICurve* GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir1Deg,
-                  const PolyLine& PL, double& dDist, double dTol) ;
+                  const PolyLine& PL, double& dDist) ;
 

CAvSilhouetteSurfTm.h

@@ -1,57 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : CAvSilhouetteSurfTm.h      Data : 16.06.24      Versione : 2.6f2
-// Contenuto : Dichiarazione della classe calcolo multi-silhouette.
-//
-//
-//
-// Modifiche : 10.06.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "CAvToolSurfTm.h"
-#include "SurfFlatRegion.h"
-#include "/EgtDev/Include/EGkCAvSilhouetteSurfTm.h"
-
-
-//-----------------------------------------------------------------------------
-class CAvParSilhouettesSurfTm : public ICAvParSilhouettesSurfTm
-{
-   public :
-     // generica
-      bool SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& frPlanes, double dTol) override ;
-      bool SetData( const CISURFTMPVECTOR& vpStm, const Frame3d& frPlanes, double dTol,
-                    double dSideAng, double dDiam, double dCornRad, double dMaxMat, double dOffsR,
-                    double dMaxDepth) override ;
-      bool GetSilhouette( double dLevel, POLYLINEVECTOR& vPL) override ;
-
-   public :
-      CAvParSilhouettesSurfTm( void) ;
-
-   private :
-      bool Prepare( void) ;
-
-   private :
-      CISURFTMPVECTOR  m_vpStm ;
-      CAvToolSurfTm    m_cavTstm ;
-      Frame3d          m_frGrid ;
-      double           m_dTol ;
-      double           m_dSharpedTol ;
-      int              m_nStepX ;
-      int              m_nStepY ;
-      double           m_dRad ;
-      double           m_dCornRad ;
-      double           m_dMaxMat ;
-      double           m_dSideAng ;
-      double           m_dOffsR ;
-      double           m_dDimZ ;
-      double           m_dLevelOffs ;
-      double           m_dMaxDepth ;
-      bool             m_bGridOk ;
-      bool             m_bTool ;
-      DBLVECTOR        m_vdGrid ;
-} ;

CAvToolSurfTm.cpp

@@ -1,21 +1,21 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2018-2024
+//  EgalTech 2018-2018
 //----------------------------------------------------------------------------
-// File : CAvToolSurfTm.cpp    Data : 07.06.24    Versione : 2.6f2
-// Contenuto : Implementazione della classe CAvToolSurfTm.
+// File : CAToolSurfTm.cpp    Data : 08.05.18    Versione : 1.9e2
+// Contenuto : Implementazione della classe CAToolSurfTm.
 //
 //
 //
 // Modifiche : 27.04.18 DS Creazione modulo.
-//             07.06.24 DS Con tolleranza lineare negativa non si controlla il punto medio.
+//
 //
 //----------------------------------------------------------------------------
 
 #include "stdafx.h"
 #include "CAvToolTriangle.h"
 #include "CAvToolSurfTm.h"
+#include "DistPointLine.h"
 #include "DllMain.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGnStringUtils.h"
 #include <thread>
 #include <future>
@@ -24,7 +24,6 @@ using namespace std ;
 
 //----------------------------------------------------------------------------
 const int STEP_PE = 50 ;
-const double MAX_MOVE = 20000 ;
 
 //----------------------------------------------------------------------------
 ICAvToolSurfTm*
@@ -38,29 +37,10 @@ CreateCAvToolSurfTm( void)
 // CAvToolSurfTm
 //----------------------------------------------------------------------------
 CAvToolSurfTm::CAvToolSurfTm( void)
-   :  m_frMove( false), m_Tool( false)
+   :  m_Tool( false)
 {
 }
 
-//----------------------------------------------------------------------------
-bool
-CAvToolSurfTm::Clear( void)
-{
-  // pulisco la lista dei puntatori a Stm
-   m_vSTM.clear() ;
-  // pulisco e inizializzo la prima posizione della lista delle basi per gli indici dei triangoli
-   m_vBaseInd.clear() ;
-   m_vBaseInd.emplace_back( 0) ;
-  // pulisco HashGrid 2d
-   m_HGrids.Clear() ;
-  // reset utensile
-   m_Tool.Clear() ;
-  // reset riferimento
-   m_frMove.Reset( false) ;
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 CAvToolSurfTm::SetSurfTm( const ISurfTriMesh& Stm)
@@ -70,9 +50,6 @@ CAvToolSurfTm::SetSurfTm( const ISurfTriMesh& Stm)
   // pulisco e inizializzo la prima posizione della lista delle basi per gli indici dei triangoli
    m_vBaseInd.clear() ;
    m_vBaseInd.emplace_back( 0) ;
-  // pulisco HashGrid 2d
-   m_HGrids.Clear() ;
-  // non tocco l'utensile
   // aggiungo la superficie
    return AddSurfTm( Stm) ;
 }
@@ -81,7 +58,7 @@ CAvToolSurfTm::SetSurfTm( const ISurfTriMesh& Stm)
 bool
 CAvToolSurfTm::AddSurfTm( const ISurfTriMesh& Stm)
 {
-  // verifico validità superficie
+  // verifico validità superficie
    const SurfTriMesh* pStm = GetBasicSurfTriMesh( &Stm) ;
    if ( pStm == nullptr  ||  ! pStm->IsValid())
       return false ;
@@ -122,227 +99,40 @@ CAvToolSurfTm::SetGenTool( const ICurveComposite* pToolOutline)
 
 //----------------------------------------------------------------------------
 bool
-CAvToolSurfTm::TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove,
-                             double& dTotDist, Vector3d* pvtTriaN) const
+CAvToolSurfTm::TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, double& dTotDist)
 {
   // Se utensile non definito, errore
    if ( m_Tool.GetType() == Tool::UNDEF)
       return false ;
-  // Se direzioni non definite, errore
-   if ( vtDir.IsSmall()  ||  vtMove.IsSmall())
-      return false ;
-  // Se riferimento di movimento già presente
-   if ( m_frMove.IsValid()) {
-     // Calcolo nuovo riferimento di movimento
-      Frame3d frMove ;
-      if ( ! AreSameOrOppositeVectorApprox( vtDir, vtMove))
-         frMove.Set( ORIG, vtMove, vtDir) ;
-      else
-         frMove.Set( ORIG, vtMove) ;
-     // Se riferimenti di movimento uguali, sfrutto HashGrid 2d
-      if ( AreSameFrame( frMove, m_frMove)) {
-        // Eseguo controllo
-         Point3d ptCurr = ptT ;
-         Vector3d vtTriaN ;
-         dTotDist = MyTestPositionHG( ptCurr, vtDir, vtTriaN) ;
-         if ( pvtTriaN != nullptr)
-            *pvtTriaN = vtTriaN ;
-         return ( dTotDist > - EPS_SMALL) ;
-      }
-   }
-  // Altrimenti eseguo controllo diretto
-   Point3d ptCurr = ptT ;
-   Vector3d vtTriaN ;
-   dTotDist = MyTestPosition( ptCurr, vtDir, vtMove, vtTriaN) ;
-   if ( pvtTriaN != nullptr)
-      *pvtTriaN = vtTriaN ;
-   return ( dTotDist > - EPS_SMALL) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CAvToolSurfTm::TestPositionAdv( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove,
-                                double& dTotDist, VCT3DVECTOR& vVtN) const
-{
-  // Funzione per calcolo collisione tra utensile e superfici ;
-  // dToTDist è la distanza di traslazione del punto ptT lungo vtDir per evitare la collisione,
-  // vVtN è la normale del triangolo che genera collsione ( NB. Nel caso di più triangoli concorrenti,
-  // vengono restituite tutte le normali trovate)
-
-  // Inizializzazione parametri
-   dTotDist = 0 ;
-   vVtN.clear() ;
- // Se utensile non definito, errore
-   if ( m_Tool.GetType() == Tool::UNDEF)
-      return false ;
-  // Se direzioni non definite, errore
-   if ( vtDir.IsSmall()  ||  vtMove.IsSmall())
-      return false ;
-  // Se riferimento di movimento già presente
-   if ( m_frMove.IsValid()) {
-     // Calcolo nuovo riferimento di movimento
-      Frame3d frMove ;
-      if ( ! AreSameOrOppositeVectorApprox( vtDir, vtMove))
-         frMove.Set( ORIG, vtMove, vtDir) ;
-      else
-         frMove.Set( ORIG, vtMove) ;
-     // Se riferimenti di movimento uguali, sfrutto HashGrid 2d
-      if ( AreSameFrame( frMove, m_frMove)) {
-        // Eseguo controllo
-         Point3d ptCurr = ptT ;
-         dTotDist = MyTestPositionHGAdv( ptCurr, vtDir, vVtN) ;
-         return ( dTotDist > - EPS_SMALL) ;
-      }
-   }
-  // Altrimenti eseguo controllo diretto
-   Point3d ptCurr = ptT ;
-   dTotDist = MyTestPositionAdv( ptCurr, vtDir, vtMove, vVtN) ;
-   return ( dTotDist > - EPS_SMALL) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CAvToolSurfTm::TestSeries( PNTUVECTOR& vPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dProgCoeff)
-{
-  // Se utensile non definito, errore
-   if ( m_Tool.GetType() == Tool::UNDEF)
-      return false ;
-  // Se direzioni non definite, errore
-   if ( vtDir.IsSmall()  ||  vtMove.IsSmall())
-      return false ;
-  // Se vettore vuoto, non devo fare alcunché
-   if ( vPntM.empty())
-      return true ;
-  // Calcolo nuovo riferimento di movimento
-   Frame3d frMove ;
+  // Imposto il riferimento di movimento
    if ( ! AreSameOrOppositeVectorApprox( vtDir, vtMove))
-      frMove.Set( ORIG, vtMove, vtDir) ;
+      m_frMove.Set( ORIG, vtMove, vtDir) ;
    else
-      frMove.Set( ORIG, vtMove) ;
-  // Se riferimento di movimento non presente o diverso dal calcolato
-   if ( ! m_frMove.IsValid()  ||  ! AreSameFrame( frMove, m_frMove)) {
-     // Salvo nuovo riferimento
-      m_frMove = frMove ;
-     // Ricalcolo HashGrid
-      if ( ! PrepareHashGrid())
-         return false ;
-   }
-  // Determino il numero di punti dell'insieme
-   m_nTotPnt = int( vPntM.size()) ;
-  // Recupero il numero massimo di thread concorrenti
-   int nThreadMax = thread::hardware_concurrency() ;
-   bool bOk = true ;
-  // Se un solo thread o pochi punti
-   if ( nThreadMax <= 1  ||  m_nTotPnt < 500) {
-      m_nCurrPnt = 0 ;
-      bOk = TestSubSeries( -1, vPntM, vtDir, 0, m_nTotPnt - 1, dProgCoeff) ;
-      ProcessEvents( int( 100 * dProgCoeff), 0) ;
-   }
-  // altrimenti
-   else {
-      const int MAX_PARTS = 32 ;
-      INTINTVECTOR vFstLst( MAX_PARTS) ;
-     // calcolo le parti del vettore
-      int nPartCnt = min( nThreadMax, MAX_PARTS) ;
-      int nPartDim = m_nTotPnt / nPartCnt + 1 ;
-      for ( int i = 0 ; i < nPartCnt ; ++ i) {
-         vFstLst[i].first = i * nPartDim ;
-         vFstLst[i].second = min( ( i + 1) * nPartDim, m_nTotPnt) - 1 ;
-      }
-     // processo le parti
-      m_nCurrPnt = 0 ;
-      m_bBreak = false ;
-      future<bool> vRes[MAX_PARTS] ;
-      for ( int i = 0 ; i < nPartCnt ; ++ i)
-         vRes[i] = async( launch::async, &CAvToolSurfTm::TestSubSeries, this, i, ref( vPntM), cref( vtDir), vFstLst[i].first, vFstLst[i].second, dProgCoeff) ;
-     // attendo i risultati
-      int nFin = 0 ;
-      int nNextPE = 0 ;
-      while ( nFin < nPartCnt) {
-         for ( int i = 0 ; i < nPartCnt ; ++ i) {
-            if ( vRes[i].valid()  &&  vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
-               bOk = vRes[i].get() && bOk ;
-               ++ nFin ;
-            }
-         }
-         if ( m_nCurrPnt > nNextPE) {
-            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt * dProgCoeff), 10) ;
-            nNextPE += STEP_PE ;
-            if ( nRes == 1)
-               m_bBreak = true ;
-         }
-      }
-      ProcessEvents( int( 100 * dProgCoeff), 0) ;
-   }
-   return bOk ;
+      m_frMove.Set( ORIG, vtMove) ;
+  // Eseguo controllo
+   Point3d ptCurr = ptT ;
+   dTotDist = MyTestPosition( ptCurr, vtDir) ;
+   return ( dTotDist > - EPS_SMALL) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-CAvToolSurfTm::TestSubSeries( int nId, PNTUVECTOR& vPntM, const Vector3d& vtDir, int nFirst, int nLast, double dProgCoeff)
-{
-  // Se vettore vuoto, non devo fare alcunché
-   if ( vPntM.empty())
-      return true ;
-  // Ciclo sui punti da verificare
-   for ( int i = nFirst ; i <= nLast ; ++ i) {
-     // verifico il punto
-      Vector3d vtTriaN ;
-      double dMove = MyTestPositionHG( vPntM[i].first, vtDir, vtTriaN) ;
-      vPntM[i].second = dMove ;
-      if ( dMove < - EPS_SMALL)
-         return false ;
-      ++ m_nCurrPnt ;
-     // se singolo thread
-      if ( nId == -1) {
-        // gestione eventi (ogni STEP_PE punti)
-         if (( m_nCurrPnt % STEP_PE) == 0) {
-            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt * dProgCoeff), 0) ;
-            if ( nRes == 1)
-               return false ;
-         }
-      }
-     // altrimenti multithread
-      else {
-         if ( m_bBreak)
-            return false ;
-      }
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dLinTol, double dProgCoeff)
+CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dLinTol)
 {
   // Se utensile non definito, errore
    if ( m_Tool.GetType() == Tool::UNDEF)
       return false ;
-  // Se direzioni non definite, errore
-   if ( vtDir.IsSmall()  ||  vtMove.IsSmall())
-      return false ;
-  // Se lista vuota, non devo fare alcunché
+  // Se lista vuota, non devo fare alcunché
    if ( lPntM.empty())
       return true ;
-  // Controllo la tolleranza lineare (se negativa non vanno fatti controlli sui punti medi)
-   if ( dLinTol > -EPS_ZERO)
-      dLinTol = max( dLinTol, EPS_SMALL) ;
-   else
-      dLinTol = -1 ;
-  // Calcolo nuovo riferimento di movimento
-   Frame3d frMove ;
+  // Imposto il riferimento di movimento
    if ( ! AreSameOrOppositeVectorApprox( vtDir, vtMove))
-      frMove.Set( ORIG, vtMove, vtDir) ;
+      m_frMove.Set( ORIG, vtMove, vtDir) ;
    else
-      frMove.Set( ORIG, vtMove) ;
-  // Se riferimento di movimento non presente o diverso dal calcolato
-   if ( ! m_frMove.IsValid()  ||  ! AreSameFrame( frMove, m_frMove)) {
-     // Salvo nuovo riferimento
-      m_frMove = frMove ;
-     // Ricalcolo HashGrid
-      if ( ! PrepareHashGrid())
-         return false ;
-   }
+      m_frMove.Set( ORIG, vtMove) ;
+  // Predispongo Hash Grid
+   if ( ! PrepareHashGrid())
+      return false ;
   // Determino il numero di punti del path
    m_nTotPnt = int( lPntM.size()) ;
   // Recupero il numero massimo di thread concorrenti
@@ -350,9 +140,8 @@ CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d&
    bool bOk = true ;
   // Se un solo thread o pochi punti
    if ( nThreadMax <= 1  ||  m_nTotPnt < 500) {
-      m_nCurrPnt = 0 ;
-      bOk = TestSubPath( -1, lPntM, vtDir, dLinTol, dProgCoeff) ;
-      ProcessEvents( int( 100 * dProgCoeff), 0) ;
+      bOk = TestSubPath( -1, lPntM, vtDir, dLinTol) ;
+      ProcessEvents( 100, 0) ;
    }
   // altrimenti
    else {
@@ -372,7 +161,7 @@ CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d&
       m_bBreak = false ;
       future<bool> vRes[MAX_PARTS] ;
       for ( int i = 0 ; i < nPartCnt ; ++ i)
-         vRes[i] = async( launch::async, &CAvToolSurfTm::TestSubPath, this, i, ref( vlPntM[i]), cref( vtDir), dLinTol, dProgCoeff) ;
+         vRes[i] = async( launch::async, &CAvToolSurfTm::TestSubPath, this, i, ref( vlPntM[i]), cref( vtDir), dLinTol) ;
      // attendo i risultati
       int nFin = 0 ;
       int nNextPE = 0 ;
@@ -384,7 +173,7 @@ CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d&
             }
          }
          if ( m_nCurrPnt > nNextPE) {
-            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt * dProgCoeff), 10) ;
+            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt), 10) ;
             nNextPE += STEP_PE ;
             if ( nRes == 1)
                m_bBreak = true ;
@@ -396,98 +185,18 @@ CAvToolSurfTm::TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d&
             lPntM.pop_back() ;
          lPntM.splice( lPntM.end(), vlPntM[i]) ;
       }
-      ProcessEvents( int( 100 * dProgCoeff), 0) ;
+      ProcessEvents( 100, 0) ;
    }
+  // pulisco HashGrid 2d
+   m_HGrids.Clear() ;
    return bOk ;
 }
 
 //----------------------------------------------------------------------------
 bool
-CAvToolSurfTm::TestSeriesAdv( PNTUVVECTVECTOR& vPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dProgCoeff)
+CAvToolSurfTm::TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, double dLinTol)
 {
-  // NB. la posizione del punto non viene modificata :
-  // get<0> vPntM[i] è il punto su cui viene posizionata la testa dell'utensile ( const)
-  // get<1> vPntM[i] è il parametro di traslazione del punto lungo vtDir per evitare collisioni con i triangoli
-  // get<2> vPntM[i] è un vettore di Vector3d contenente tutte le normali di tangenza ( a meno di 10 * EPS_SMALL)
-
-  // Se utensile non definito, errore
-   if ( m_Tool.GetType() == Tool::UNDEF)
-      return false ;
-  // Se direzioni non definite, errore
-   if ( vtDir.IsSmall()  ||  vtMove.IsSmall())
-      return false ;
-  // Se vettore vuoto, non devo fare alcunché
-   if ( vPntM.empty())
-      return true ;
-  // Calcolo nuovo riferimento di movimento
-   Frame3d frMove ;
-   if ( ! AreSameOrOppositeVectorApprox( vtDir, vtMove))
-      frMove.Set( ORIG, vtMove, vtDir) ;
-   else
-      frMove.Set( ORIG, vtMove) ;
-  // Se riferimento di movimento non presente o diverso dal calcolato
-   if ( ! m_frMove.IsValid()  ||  ! AreSameFrame( frMove, m_frMove)) {
-     // Salvo nuovo riferimento
-      m_frMove = frMove ;
-     // Ricalcolo HashGrid
-      if ( ! PrepareHashGrid())
-         return false ;
-   }
-  // Determino il numero di punti del path
-   m_nTotPnt = int( vPntM.size()) ;
-  // Recupero il numero massimo di thread concorrenti
-   int nThreadMax = thread::hardware_concurrency() ;
-   bool bOk = true ;
-  // Se un solo thread o pochi punti
-   if ( nThreadMax <= 1  ||  m_nTotPnt < 500) {
-      m_nCurrPnt = 0 ;
-      bOk = TestSubSeriesAdv( -1, vPntM, vtDir, 0, m_nTotPnt - 1, dProgCoeff) ;
-      ProcessEvents( int( 100 * dProgCoeff), 0) ;
-   }
-  // altrimenti
-   else {
-      const int MAX_PARTS = 32 ;
-      INTINTVECTOR vFstLst( MAX_PARTS) ;
-     // calcolo le parti del vettore
-      int nPartCnt = min( nThreadMax, MAX_PARTS) ;
-      int nPartDim = m_nTotPnt / nPartCnt + 1 ;
-      for ( int i = 0 ; i < nPartCnt ; ++ i) {
-         vFstLst[i].first = i * nPartDim ;
-         vFstLst[i].second = min( ( i + 1) * nPartDim, m_nTotPnt) - 1 ;
-      }
-     // processo le parti
-      m_nCurrPnt = 0 ;
-      m_bBreak = false ;
-      future<bool> vRes[MAX_PARTS] ;
-      for ( int i = 0 ; i < nPartCnt ; ++ i)
-         vRes[i] = async( launch::async, &CAvToolSurfTm::TestSubSeriesAdv, this, i, ref( vPntM), cref( vtDir), vFstLst[i].first, vFstLst[i].second, dProgCoeff) ;
-     // attendo i risultati
-      int nFin = 0 ;
-      int nNextPE = 0 ;
-      while ( nFin < nPartCnt) {
-         for ( int i = 0 ; i < nPartCnt ; ++ i) {
-            if ( vRes[i].valid()  &&  vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
-               bOk = vRes[i].get() && bOk ;
-               ++ nFin ;
-            }
-         }
-         if ( m_nCurrPnt > nNextPE) {
-            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt * dProgCoeff), 10) ;
-            nNextPE += STEP_PE ;
-            if ( nRes == 1)
-               m_bBreak = true ;
-         }
-      }
-      ProcessEvents( int( 100 * dProgCoeff), 0) ;
-   }
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CAvToolSurfTm::TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, double dLinTol, double dProgCoeff)
-{
-  // Se lista vuota, non devo fare alcunché
+  // Se lista vuota, non devo fare alcunché
    if ( lPntM.empty())
       return true ;
   // Ciclo sui punti
@@ -497,13 +206,11 @@ CAvToolSurfTm::TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, dou
    while ( itPntMCurr != lPntM.end()) {
      // verifico il punto
       ptCurr = itPntMCurr->first ;
-      Vector3d vtTriaN ;
-      double dMove = MyTestPositionHG( itPntMCurr->first, vtDir, vtTriaN) ;
-      itPntMCurr->second = dMove ;
-      if ( dMove < - EPS_SMALL)
+      itPntMCurr->second = MyTestPositionHG( itPntMCurr->first, vtDir) ;
+      if ( itPntMCurr->second < - EPS_SMALL)
          return false ;
-     // se esiste il punto precedente e richiesto devo verificare il medio
-      if ( itPntMPrev != lPntM.end()  &&  dLinTol > 0) {
+     // se esiste il punto precedente devo verificare il medio
+      if ( itPntMPrev != lPntM.end()) {
          MyTestMidPointHG( lPntM, itPntMPrev, itPntMCurr, ptPrev, ptCurr, vtDir, dLinTol, 1) ;
       }
      // passo al successivo
@@ -515,7 +222,7 @@ CAvToolSurfTm::TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, dou
       if ( nId == -1) {
         // gestione eventi (ogni STEP_PE punti)
          if (( m_nCurrPnt % STEP_PE) == 0) {
-            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt * dProgCoeff), 0) ;
+            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt), 0) ;
             if ( nRes == 1)
                return false ;
          }
@@ -529,44 +236,10 @@ CAvToolSurfTm::TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, dou
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-CAvToolSurfTm::TestSubSeriesAdv( int nId, PNTUVVECTVECTOR& vPntM, const Vector3d& vtDir, int nFirst, int nLast, double dProgCoeff)
-{
-  // Se vettore vuoto, non devo fare alcunché
-   if ( vPntM.empty())
-      return true ;
-  // Ciclo sui punti da verificare
-   for ( int i = nFirst ; i <= nLast ; ++ i) {
-     // verifico il punto
-      Point3d ptCurr = get<0>( vPntM[i]) ;
-      get<1>( vPntM[i]) = MyTestPositionHGAdv( ptCurr, vtDir, get<2>( vPntM[i])) ;
-      if ( get<1>( vPntM[i]) < - EPS_SMALL)
-         return false ;
-      ++ m_nCurrPnt ;
-     // se singolo thread
-      if ( nId == -1) {
-        // gestione eventi (ogni STEP_PE punti)
-         if (( m_nCurrPnt % STEP_PE) == 0) {
-            int nRes = ProcessEvents( int( m_nCurrPnt * 100. / m_nTotPnt * dProgCoeff), 0) ;
-            if ( nRes == 1)
-               return false ;
-         }
-      }
-     // altrimenti multithread
-      else {
-         if ( m_bBreak)
-            return false ;
-      }
-   }
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 CAvToolSurfTm::MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPntMPrev, const PNTULIST::iterator& itPntMCurr,
-                                 const Point3d& ptPrev, const Point3d& ptCurr, const Vector3d& vtDir, double dLinTol, int nLev) const
+                                 const Point3d& ptPrev, const Point3d& ptCurr, const Vector3d& vtDir, double dLinTol, int nLev)
 {
   // se superato limite di ricursione, esco
    const int MAX_LEV = 10 ;
@@ -576,8 +249,7 @@ CAvToolSurfTm::MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPn
    Point3d ptMid = Media( ptPrev, ptCurr, 0.5) ;
   // ne effettuo la correzione per evitare la collisione
    Point3d ptNewMid = ptMid ;
-   Vector3d vtTriaN ;
-   double dMidMove = MyTestPositionHG( ptNewMid, vtDir, vtTriaN) ;
+   double dMidMove = MyTestPositionHG( ptNewMid, vtDir) ;
    if ( dMidMove < - EPS_SMALL)
       return false ;
   // massima distanza ammissibile
@@ -586,7 +258,7 @@ CAvToolSurfTm::MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPn
    if ( abs(( Media( itPntMPrev->first, itPntMCurr->first, 0.5) - ptNewMid) * m_frMove.VersZ()) > 0.5 * dLinTol  ||
         SqDist( itPntMPrev->first, itPntMCurr->first) > dMaxSqDist) {
      // aggiungo
-      lPntM.emplace( itPntMCurr, ptNewMid, dMidMove) ;
+      lPntM.emplace( itPntMCurr, ptNewMid, - dMidMove) ;
       auto itPntMMid = itPntMCurr ;
       -- itPntMMid ;
      // verifico intervallo precedente
@@ -599,48 +271,20 @@ CAvToolSurfTm::MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPn
 
 //----------------------------------------------------------------------------
 double
-CAvToolSurfTm::MyTestPosition( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, Vector3d& vtTriaN) const
+CAvToolSurfTm::MyTestPosition( Point3d& ptT, const Vector3d& vtDir)
 {
-  // box dell'utensile con suo movimento
-   BBox3d b3Tool ;
-   // utensile
-   b3Tool.Add( ptT) ;
-   b3Tool.Add( ptT - vtDir * m_Tool.GetHeigth()) ;
-   if ( vtDir.IsX())
-      b3Tool.Expand( 0, m_Tool.GetRadius(), m_Tool.GetRadius()) ;
-   else if ( vtDir.IsY())
-      b3Tool.Expand( m_Tool.GetRadius(), 0, m_Tool.GetRadius()) ;
-   else if ( vtDir.IsZ())
-      b3Tool.Expand( m_Tool.GetRadius(), m_Tool.GetRadius(), 0) ;
-   else {
-      double dExpandX = m_Tool.GetRadius() * sqrt( 1 - vtDir.x * vtDir.x) ;
-      double dExpandY = m_Tool.GetRadius() * sqrt( 1 - vtDir.y * vtDir.y) ;
-      double dExpandZ = m_Tool.GetRadius() * sqrt( 1 - vtDir.z * vtDir.z) ;
-      b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ;
-   }
-   // aggiungo movimento
-   BBox3d b3Moved = b3Tool ;
-   b3Moved.Translate( MAX_MOVE * vtMove) ;
-   b3Tool.Add( b3Moved) ;
-
-  // determino movimento minimo per evitare collisione con superfici
    double dTotDist = 0 ;
-   vtTriaN = V_NULL ;
    for ( auto pStm : m_vSTM) {
-      INTVECTOR vTria ;
-      if ( pStm->GetAllTriaOverlapBox( b3Tool, vTria)) {
-         for ( int nTria : vTria) {
-            Triangle3d Tria ;
-            if ( pStm->GetTriangle( nTria, Tria)) {
-               double dDist = CAvToolTriangle( m_Tool, ptT, vtDir, Tria, vtMove) ;
-               if ( dDist < - EPS_SMALL)
-                  return -1 ;
-               if ( dDist > EPS_SMALL) {
-                  dTotDist += dDist ;
-                  ptT += dDist * vtMove ;
-                  vtTriaN = Tria.GetN() ;
-               }
-            }
+      Triangle3d Tria ;
+      for ( int nTria = pStm->GetFirstTriangle( Tria) ;
+            nTria != SVT_NULL ;
+            nTria = pStm->GetNextTriangle( nTria, Tria)) {
+         double dDist = CAvToolTriangle( m_Tool, ptT, vtDir, Tria, m_frMove.VersZ()) ;
+         if ( dDist < - EPS_SMALL)
+            return -1 ;
+         if ( dDist > EPS_SMALL) {
+            dTotDist += dDist ;
+            ptT += dDist * m_frMove.VersZ() ;
          }
       }
    }
@@ -649,61 +293,7 @@ CAvToolSurfTm::MyTestPosition( Point3d& ptT, const Vector3d& vtDir, const Vector
 
 //----------------------------------------------------------------------------
 double
-CAvToolSurfTm::MyTestPositionAdv( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, VCT3DVECTOR& vVtTriaN) const
-{
-  // box dell'utensile con suo movimento
-   BBox3d b3Tool ;
-   // utensile
-   b3Tool.Add( ptT) ;
-   b3Tool.Add( ptT - vtDir * m_Tool.GetHeigth()) ;
-   if ( vtDir.IsX())
-      b3Tool.Expand( 0, m_Tool.GetRadius(), m_Tool.GetRadius()) ;
-   else if ( vtDir.IsY())
-      b3Tool.Expand( m_Tool.GetRadius(), 0, m_Tool.GetRadius()) ;
-   else if ( vtDir.IsZ())
-      b3Tool.Expand( m_Tool.GetRadius(), m_Tool.GetRadius(), 0) ;
-   else {
-      double dExpandX = m_Tool.GetRadius() * sqrt( 1 - vtDir.x * vtDir.x) ;
-      double dExpandY = m_Tool.GetRadius() * sqrt( 1 - vtDir.y * vtDir.y) ;
-      double dExpandZ = m_Tool.GetRadius() * sqrt( 1 - vtDir.z * vtDir.z) ;
-      b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ;
-   }
-   // aggiungo movimento
-   BBox3d b3Moved = b3Tool ;
-   b3Moved.Translate( MAX_MOVE * vtMove) ;
-   b3Tool.Add( b3Moved) ;
-
-  // determino movimento minimo per evitare collisione con superfici
-   double dTotDist = 0 ;
-   vVtTriaN.clear() ;
-   for ( auto pStm : m_vSTM) {
-      INTVECTOR vTria ;
-      if ( pStm->GetAllTriaOverlapBox( b3Tool, vTria)) {
-         for ( int nTria : vTria) {
-            Triangle3d Tria ;
-            if ( pStm->GetTriangle( nTria, Tria)) {
-               double dDist = CAvToolTriangle( m_Tool, ptT, vtDir, Tria, vtMove) ;
-               if ( dDist < - EPS_SMALL)
-                  return -1 ;
-              // se devo traslare il punto, c'è collisione
-               if ( dDist > EPS_SMALL) {
-                  if ( dDist > 10 * EPS_SMALL) {
-                     vVtTriaN.clear() ;
-                     dTotDist += dDist ;
-                     ptT += ( dDist - 5 * EPS_SMALL) * m_frMove.VersZ() ;
-                  }
-                  vVtTriaN.push_back( Tria.GetN()) ;
-               }
-            }
-         }
-      }
-   }
-   return dTotDist ;
-}
-
-//----------------------------------------------------------------------------
-double
-CAvToolSurfTm::MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir, Vector3d& vtTriaN) const
+CAvToolSurfTm::MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir)
 {
   // calcolo box utensile nel riferimento di movimento
    BBox3d b3Tool ;
@@ -711,11 +301,11 @@ CAvToolSurfTm::MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir, Vector3d&
    Vector3d vtDirL = vtDir ; vtDirL.ToLoc( m_frMove) ;
    b3Tool.Add( ptTL) ;
    b3Tool.Add( ptTL - vtDirL * m_Tool.GetHeigth()) ;
-   if ( vtDirL.IsX())
+   if ( vtDirL.IsXplus()  ||  vtDirL.IsXminus())
       b3Tool.Expand( 0, m_Tool.GetRadius(), m_Tool.GetRadius()) ;
-   else if ( vtDirL.IsY())
+   else if ( vtDirL.IsYplus()  ||  vtDirL.IsYminus())
       b3Tool.Expand( m_Tool.GetRadius(), 0, m_Tool.GetRadius()) ;
-   else if ( vtDirL.IsZ())
+   else if ( vtDirL.IsZplus()  ||  vtDirL.IsZminus())
       b3Tool.Expand( m_Tool.GetRadius(), m_Tool.GetRadius(), 0) ;
    else {
       double dExpandX = m_Tool.GetRadius() * sqrt( 1 - vtDirL.x * vtDirL.x) ;
@@ -723,10 +313,8 @@ CAvToolSurfTm::MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir, Vector3d&
       double dExpandZ = m_Tool.GetRadius() * sqrt( 1 - vtDirL.z * vtDirL.z) ;
       b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ;
    }
-
-  // ciclo sui triangoli che intersecano box in 2d
+  // ciclo sui triangoli che intersecano box in 2d 
    double dTotDist = 0 ;
-   vtTriaN = V_NULL ;
    INTVECTOR vnIds ;
    if ( m_HGrids.Find( b3Tool, vnIds)) {
       for ( int i = 0 ; i < int( vnIds.size()) ; ++ i) {
@@ -742,70 +330,11 @@ CAvToolSurfTm::MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir, Vector3d&
          if ( dDist > EPS_SMALL) {
             dTotDist += dDist ;
             ptT += dDist * m_frMove.VersZ() ;
-            vtTriaN = Tria.GetN() ;
          }
          else if ( dDist < -EPS_SMALL)
             return -1 ;
       }
    }
-
-   return dTotDist ;
-}
-
-//----------------------------------------------------------------------------
-double
-CAvToolSurfTm::MyTestPositionHGAdv( Point3d& ptT, const Vector3d& vtDir, VCT3DVECTOR& vVtTriaN) const
-{
-  // calcolo box utensile nel riferimento di movimento
-   BBox3d b3Tool ;
-   Point3d ptTL = ptT ; ptTL.ToLoc( m_frMove) ;
-   Vector3d vtDirL = vtDir ; vtDirL.ToLoc( m_frMove) ;
-   b3Tool.Add( ptTL) ;
-   b3Tool.Add( ptTL - vtDirL * m_Tool.GetHeigth()) ;
-   if ( vtDirL.IsX())
-      b3Tool.Expand( 0, m_Tool.GetRadius(), m_Tool.GetRadius()) ;
-   else if ( vtDirL.IsY())
-      b3Tool.Expand( m_Tool.GetRadius(), 0, m_Tool.GetRadius()) ;
-   else if ( vtDirL.IsZ())
-      b3Tool.Expand( m_Tool.GetRadius(), m_Tool.GetRadius(), 0) ;
-   else {
-      double dExpandX = m_Tool.GetRadius() * sqrt( 1 - vtDirL.x * vtDirL.x) ;
-      double dExpandY = m_Tool.GetRadius() * sqrt( 1 - vtDirL.y * vtDirL.y) ;
-      double dExpandZ = m_Tool.GetRadius() * sqrt( 1 - vtDirL.z * vtDirL.z) ;
-      b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ;
-   }
-
-  // ciclo sui triangoli che intersecano box in 2d
-   double dTotDist = 0. ;
-   INTVECTOR vnIds ;
-   if ( m_HGrids.Find( b3Tool, vnIds)) {
-      for ( int i = 0 ; i < int( vnIds.size()) ; ++ i) {
-        // recupero la superficie
-         int nInd = vnIds[i] ;
-         int nSurf = GetSurfInd( nInd) ;
-         if ( nSurf == -1)
-            return -1 ;
-        // recupero il triangolo
-         int nT = nInd - m_vBaseInd[nSurf] ;
-         Triangle3d Tria ;
-         if ( ! m_vSTM[nSurf]->GetTriangle( nT, Tria))
-            return -1 ;
-        // calcolo della collisione
-         double dDist = CAvToolTriangle( m_Tool, ptT, vtDir, Tria, m_frMove.VersZ()) ;
-         if ( dDist < - EPS_SMALL)
-            return -1 ;
-        // se devo traslare il punto, c'è collisione
-         if ( dDist > EPS_SMALL) {
-            if ( dDist > 10 * EPS_SMALL) {
-               vVtTriaN.clear() ;
-               dTotDist += dDist ;
-               ptT += ( dDist - 5 * EPS_SMALL) * m_frMove.VersZ() ;
-            }
-            vVtTriaN.push_back( Tria.GetN()) ;
-         }
-      }
-   }
-
    return dTotDist ;
 }
 
@@ -816,7 +345,7 @@ CAvToolSurfTm::PrepareHashGrid( void)
   // pulisco HashGrid 2d
    m_HGrids.Clear() ;
   // verifico esistenza superfici
-   if ( m_vSTM.empty()  ||  m_vBaseInd.size() < m_vSTM.size() + 1)
+   if ( m_vSTM.size() == 0  ||  m_vBaseInd.size() < m_vSTM.size() + 1)
       return false ;
   // creo HashGrid 2d
    const int LIM_HG_TRIA = 256 ;
@@ -843,7 +372,7 @@ CAvToolSurfTm::PrepareHashGrid( void)
 
 //----------------------------------------------------------------------------
 int
-CAvToolSurfTm::GetSurfInd( int nT) const
+CAvToolSurfTm::GetSurfInd( int nT)
 {
   // verifico la presenza di almeno un intervallo
    if ( m_vBaseInd.size() < 2)

CAvToolSurfTm.h

@@ -34,47 +34,22 @@ class CAvToolSurfTm : public ICAvToolSurfTm
                   { return m_Tool.GetRadius() ; }
       double GetToolHeight( void) const override
                   { return m_Tool.GetHeigth() ; }
-      double GetToolTipHeight( void) const override
-                  { return m_Tool.GetTipHeigth() ; } ;
-      double GetToolTipRadius( void) const override
-                  { return m_Tool.GetTipRadius() ; } ;
-      double GetToolCornRadius( void) const override
-                  { return m_Tool.GetCornRadius() ; } ;
-      CISURFTMPVECTOR GetvStm( void) const {
-                     CISURFTMPVECTOR vcStm ;
-                     for ( int i = 0 ; i < int( m_vSTM.size()) ; ++ i)
-                        vcStm.emplace_back( CloneSurfTriMesh( m_vSTM[i])) ;
-                     return vcStm ;
-                  }
       const ICurveComposite& GetToolOutline( bool bApprox = false) const override
                   { return ( bApprox ? m_Tool.GetApproxOutline() : m_Tool.GetOutline()) ;}
-
-      bool TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove,
-                         double& dTotDist, Vector3d* pvtTriaN = nullptr) const override ;
-      bool TestPositionAdv( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove,
-                            double& dTotDist, VCT3DVECTOR& vVtN) const override ;
-
-      bool TestSeries( PNTUVECTOR& vPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dProgCoeff = 1) override ;
-      bool TestSeriesAdv( PNTUVVECTVECTOR& vPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dProgCoeff = 1) override ;
-
-      bool TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dLinTol, double dProgCoeff = 1) override ;
+      bool TestPosition( const Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, double& dTotDist) override ;
+      bool TestPath( PNTULIST& lPntM, const Vector3d& vtDir, const Vector3d& vtMove, double dLinTol) override ;
 
    public :
       CAvToolSurfTm( void) ;
-      bool Clear( void) ;
 
    private :
-      bool   TestSubSeries( int nId, PNTUVECTOR& vPntM, const Vector3d& vtDir, int nFirst, int nLast, double dProgCoeff) ;
-      bool   TestSubSeriesAdv( int nId, PNTUVVECTVECTOR& vPntM, const Vector3d& vtDir, int nFirst, int nLast, double dProgCoeff) ;
-      bool   TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, double dLinTol, double dProgCoeff) ;
-      double MyTestPosition( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, Vector3d& vtTriaN) const ;
-      double MyTestPositionAdv( Point3d& ptT, const Vector3d& vtDir, const Vector3d& vtMove, VCT3DVECTOR& vVtTriaN) const ;
-      double MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir, Vector3d& vtTriaN) const ;
-      double MyTestPositionHGAdv( Point3d& ptT, const Vector3d& vtDir, VCT3DVECTOR& vVtTriaN) const ;
+      bool   TestSubPath( int nId, PNTULIST& lPntM, const Vector3d& vtDir, double dLinTol) ;
+      double MyTestPosition( Point3d& ptT, const Vector3d& vtDir) ;
+      double MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir) ;
       bool   MyTestMidPointHG( PNTULIST& lPntM, const PNTULIST::iterator& itPntMPrev, const PNTULIST::iterator& itPntMCurr,
-                               const Point3d& ptPrev, const Point3d& ptCurr, const Vector3d& vtDir, double dLinTol, int nLev) const ;
+                               const Point3d& ptPrev, const Point3d& ptCurr, const Vector3d& vtDir, double dLinTol, int nLev) ;
       bool   PrepareHashGrid( void) ;
-      int    GetSurfInd( int nT) const ;
+      int    GetSurfInd( int nT) ;
 
    private :
       typedef std::vector<const SurfTriMesh*>    CSURFTMPVECTOR ;   // vettore di puntatori a const SurfTriMesh

CAvToolTriangle.cpp

@@ -17,8 +17,8 @@
 #include "CAvToolTriangle.h"
 #include "IntersLineSurfStd.h"
 #include "IntersLineTria.h"
+#include "DistPointLine.h"
 #include "CDeUtility.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkIntervals.h"
 #include "/EgtDev/Include/ENkPolynomialRoots.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
@@ -146,20 +146,18 @@ CAvToolTriangle( const Tool& tlTool, const Point3d& ptToolOrig,  const Vector3d&
                  const Triangle3d& trTria, const Vector3d& vtMove)
 {
   // Non ha senso che il movimento sia in direzione "opposta" a quella dell'asse utensile
-   if ( vtMove * vtToolAx < - 10 * EPS_ZERO)
+   if ( vtMove * vtToolAx < - EPS_ZERO)
       return -1. ;
   // Se avvicinamento non devo fare nulla
    if ( vtMove * trTria.GetN() < - EPS_ZERO)
-      return 0. ;
-  // Tolleranza su dischi (parti piatte perpendicolari all'asse utensile)
-   double dEpsilon = ( vtMove * vtToolAx > 0.5 ? 0 : EPS_SMALL) ;
+      return 0. ; 
   // se utensile cilindrico
    if ( tlTool.GetType() == Tool::CYLMILL) {
      // parametri geometrici
       double dHeigth = tlTool.GetHeigth() ;
       double dRadius = tlTool.GetRadius() ;
      // prima determino l'allontanamento del disco inferiore
-      double dDist = CAvDiskTriangle( ptToolOrig - ( dHeigth - dEpsilon) * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;      
+      double dDist = CAvDiskTriangle( ptToolOrig - ( dHeigth - EPS_SMALL) * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;      
       if ( dDist < - EPS_SMALL)
          return dDist ; 
      // poi verifico quello del cilindro (tenendo conto di quanto è stata allontanato il disco)
@@ -167,7 +165,7 @@ CAvToolTriangle( const Tool& tlTool, const Point3d& ptToolOrig,  const Vector3d&
       if ( dDist2 < - EPS_SMALL)
          return dDist2 ;
      // verifico quello del disco sopra
-     double dDist3 = CAvDiskTriangle( ptToolOrig - dEpsilon * vtToolAx + ( dDist + dDist2) * vtMove, vtToolAx, dRadius, trTria, vtMove) ;   
+     double dDist3 = CAvDiskTriangle( ptToolOrig - EPS_SMALL * vtToolAx + ( dDist + dDist2) * vtMove, vtToolAx, dRadius, trTria, vtMove) ;   
      if ( dDist3 < - EPS_SMALL)
          return dDist3 ;   
       return ( dDist + dDist2 + dDist3) ;
@@ -191,7 +189,7 @@ CAvToolTriangle( const Tool& tlTool, const Point3d& ptToolOrig,  const Vector3d&
          return dDist2 ;
      // verifico quello del disco sopra
      Point3d ptDiskUpOrig = ptCylOrig + dDist2 * vtMove ;
-      double dDist3 = CAvDiskTriangle( ptDiskUpOrig - dEpsilon * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;   
+      double dDist3 = CAvDiskTriangle( ptDiskUpOrig - EPS_SMALL * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;   
       if ( dDist3 < - EPS_SMALL)
          return dDist3 ;   
       return ( dDist + dDist2 + dDist3) ;
@@ -201,7 +199,7 @@ CAvToolTriangle( const Tool& tlTool, const Point3d& ptToolOrig,  const Vector3d&
      // parametri geometrici
       double dCylHeigth = tlTool.GetHeigth() - tlTool.GetTipHeigth() ;     
      // prima determino l'allontanamento del disco inferiore
-      double dDist = CAvDiskTriangle( ptToolOrig - ( tlTool.GetHeigth() - dEpsilon) * vtToolAx, vtToolAx, tlTool.GetTipRadius(),
+      double dDist = CAvDiskTriangle( ptToolOrig - ( tlTool.GetHeigth() - EPS_SMALL) * vtToolAx, vtToolAx, tlTool.GetTipRadius(),
                                       trTria, vtMove) ;
       if ( dDist < - EPS_SMALL)
          return dDist ;
@@ -222,7 +220,7 @@ CAvToolTriangle( const Tool& tlTool, const Point3d& ptToolOrig,  const Vector3d&
          return dDist3 ;
       // verifico quello del disco sopra
       Point3d ptDiskUpOrig = ptCylOrig + vtMove * dDist3 ;
-      double dDist4 = CAvDiskTriangle( ptDiskUpOrig - dEpsilon * vtToolAx, vtToolAx, tlTool.GetRadius(), trTria, vtMove) ;   
+      double dDist4 = CAvDiskTriangle( ptDiskUpOrig - EPS_SMALL * vtToolAx, vtToolAx, tlTool.GetRadius(), trTria, vtMove) ;   
       if ( dDist4 < - EPS_SMALL)
          return dDist4 ;   
       return ( dDist + dDist2 + dDist3 + dDist4) ;
@@ -249,7 +247,7 @@ CAvToolTriangle( const Tool& tlTool, const Point3d& ptToolOrig,  const Vector3d&
       double dMaxR = max( tlTool.GetRadius(), tlTool.GetTipRadius()) ;
       double dCylHeigth = tlTool.GetHeigth() - tlTool.GetTipHeigth() ;
      // prima determino l'allontanamento del disco inferiore
-      double dDist = CAvDiskTriangle( ptToolOrig - ( tlTool.GetHeigth() - dEpsilon) * vtToolAx, vtToolAx, tlTool.GetTipRadius(),
+      double dDist = CAvDiskTriangle( ptToolOrig - ( tlTool.GetHeigth() - EPS_SMALL) * vtToolAx, vtToolAx, tlTool.GetTipRadius(),
                                       trTria, vtMove) ;
       if ( dDist < - EPS_SMALL)
          return dDist ;
@@ -268,7 +266,7 @@ CAvToolTriangle( const Tool& tlTool, const Point3d& ptToolOrig,  const Vector3d&
          return dDist3 ;
      // verifico quello del disco sopra
       Point3d ptDiskUpOrig = ptCylOrig + vtMove * dDist3 ;
-      double dDist4 = CAvDiskTriangle( ptDiskUpOrig - dEpsilon * vtToolAx, vtToolAx, tlTool.GetRadius(), trTria, vtMove) ;   
+      double dDist4 = CAvDiskTriangle( ptDiskUpOrig - EPS_SMALL * vtToolAx, vtToolAx, tlTool.GetRadius(), trTria, vtMove) ;   
       if ( dDist4 < - EPS_SMALL)
          return dDist4 ;   
       return ( dDist + dDist2 + dDist3 + dDist4) ;
@@ -301,10 +299,10 @@ CAvToolTriangle( const Tool& tlTool, const Point3d& ptToolOrig,  const Vector3d&
                double dRadius = max( ptStart.x, ptEnd.x) ;
               // Se disco verso il basso dell'utensile
                if ( ptStart.x > ptEnd.x)                  
-                  dDist2 = CAvDiskTriangle( ptCompOrig + dEpsilon * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;                
+                  dDist2 = CAvDiskTriangle( ptCompOrig + EPS_SMALL * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;                
                // Se disco verso l'alto
                else                
-                  dDist2 = CAvDiskTriangle( ptCompOrig - dEpsilon * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;               
+                  dDist2 = CAvDiskTriangle( ptCompOrig - EPS_SMALL * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;               
             }
             else {
               // Verifiche curva precedente per eventuale tappo sopra
@@ -2503,7 +2501,7 @@ DiskSegmentEscapeDistLongMot( const Point3d& ptDiskCen, double dDiskRad,
    double dSegDist = 0. ;
    for ( int nSol = 0 ; nSol < nRoot ; ++ nSol) {
      // Soluzione interna al segmento
-      if ( vdRoots[nSol] > 0.  &&  vdRoots[nSol] < dSegLen + EPS_ZERO) {
+      if ( vdRoots[nSol] > 0.  &&  vdRoots[nSol] < dSegLen) {
          Point3d ptC = ptSeg + vdRoots[nSol] * vtSeg ;
         // Distanza del punto soluzione dal piano del disco nella posizione iniziale
          double dCurDist = PointPlaneSignedDist( ptC, ptDiskCen, vtMove) ;

CDeBoxClosedSurfTm.cpp

@@ -1,14 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2016-2024
+//  EgalTech 2016-2020
 //----------------------------------------------------------------------------
-// File : CDeBoxClosedSurfTm.cpp      Data : 24.03.24        Versione : 2.6c2
+// File : CDBoxSurfTm.cpp      Data : 09.01.20        Versione : 2.2a2
 // Contenuto : Implementazione della verifica di collisione tra
 //             BoundingBox e Closed SurftriMesh.
 //
 //
 // Modifiche : 05.10.16 DS Creazione modulo.
 //             09.01.20 DS Cambio nome alla funzione.
-//             24.03.24 DS Aggiunta TestCylSurfTm.
 //
 //----------------------------------------------------------------------------
 
@@ -20,86 +19,36 @@
 
 using namespace std ;
 
-//----------------------------------------------------------------------------
-// Il sistema di riferimento è allineato con il box e ha origine in un suo vertice.
-// La distanza di sicurezza ha effetto solo se maggiore di EPS_SMALL.
-// Il sistema di riferimento del box è riferito a quello della superficie.
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - false in caso di assenza di collisione.
 //----------------------------------------------------------------------------
 bool
-CDeBoxClosedSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, const ISurfTriMesh& Stm, double dSafeDist)
+CDeBoxClosedSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, const ISurfTriMesh& Stm)
 {
-  // Se il box non è ben definito non ha senso proseguire
-   if ( vtDiag.IsSmall())
-      return true ;
-  // Se superficie non valida o aperta, non ha senso proseguire
-   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
-      return true ;
-  // Recupero BBox del poliedro
+  // recupero BBox del poliedro
    BBox3d b3Poly = Stm.GetAllTriaBox() ;
-  // Calcolo il BBox del parallelepipedo
-   BBox3d b3BoxL( ORIG, ORIG + vtDiag) ;
-   if ( dSafeDist > EPS_SMALL)
-      b3BoxL.Expand( dSafeDist) ;
-   BBox3d b3Box = GetToGlob( b3BoxL, frBox) ;
-  // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Poly.Overlaps( b3Box)  ||  ! b3Poly.Overlaps( frBox, b3BoxL))
+  // calcolo il BBox del parallelepipedo
+   BBox3d b3Box( ORIG, ORIG + vtDiag) ;
+   b3Box.Expand( dSafeDist) ;
+   b3Box.ToGlob( frBox) ;
+  // confronto i due Box
+   if ( ! b3Box.Overlaps( b3Poly))
       return false ;
-  // Verifico se il parallelepipedo interferisce con i triangoli del poliedro presenti nel suo BBox
+  // recupero i triangoli che interferiscono con il box
    INTVECTOR vT ;
    Stm.GetAllTriaOverlapBox( b3Box, vT) ;
    for ( int nT : vT) {
       Triangle3d Tria ;
       if ( Stm.GetTriangle( nT, Tria)) {
-         if ( CDeBoxTria( frBox, vtDiag, Tria, dSafeDist))
+         if ( CDeBoxTria( frBox, vtDiag, dSafeDist, Tria))
             return true ;
       }
    }
-  // Se il BBox del parallelepipedo non è interno a quello del poliedro e viceversa, non c'è collisione
-   if ( ! b3Poly.Encloses( b3Box)  &&  ! b3Box.Encloses( b3Poly))
+  // Se superficie aperta, non c'è collisione
+   if ( ! Stm.IsClosed())
       return false ;
-  // Verifico se il box è dentro la superficie tramite calcolo distanza minima del suo centro
-   Point3d ptBoxCen = ORIG + vtDiag / 2 ;
-   ptBoxCen.ToGlob( frBox) ;
-   DistPointSurfTm DistBoxCenSurfCalc( ptBoxCen, Stm) ;
+  // Verifico se il box è dentro la superficie tramite calcolo distanza minima.
+   Point3d ptBoxOrig, ptBoxMax ;
+   b3Box.GetMinMax( ptBoxOrig, ptBoxMax) ;
+   DistPointSurfTm DistBoxOrigSurfCalc( ptBoxOrig, Stm) ;
   // Se il box è interno c'è collisione
-   return DistBoxCenSurfCalc.IsPointInside() ;
-}
-
-//----------------------------------------------------------------------------
-// Verifica l'interferenza tra il box e la superficie : restituisce true in caso di interferenza.
-//----------------------------------------------------------------------------
-bool
-TestBoxSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, const ISurfTriMesh& Stm, double dSafeDist)
-{
-  // Se il box non è ben definito non ha senso proseguire
-   if ( vtDiag.IsSmall())
-      return true ;
-  // Se superficie non valida, non ha senso proseguire
-   if ( ! Stm.IsValid())
-      return true ;
-  // Recupero BBox del poliedro
-   BBox3d b3Poly = Stm.GetAllTriaBox() ;
-  // Calcolo il BBox del parallelepipedo
-   BBox3d b3BoxL( ORIG, ORIG + vtDiag) ;
-   if ( dSafeDist > EPS_SMALL)
-      b3BoxL.Expand( dSafeDist) ;
-   BBox3d b3Box = GetToGlob( b3BoxL, frBox) ;
-  // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Poly.Overlaps( b3Box)  ||  ! b3Poly.Overlaps( frBox, b3BoxL))
-      return false ;
-  // Verifico se il parallelepipedo interferisce con i triangoli del poliedro presenti nel suo BBox
-   INTVECTOR vT ;
-   Stm.GetAllTriaOverlapBox( b3Box, vT) ;
-   for ( int nT : vT) {
-      Triangle3d Tria ;
-      if ( Stm.GetTriangle( nT, Tria)) {
-         if ( CDeBoxTria( frBox, vtDiag, Tria, dSafeDist))
-            return true ;
-      }
-   }
-  // Non c'è interferenza
-   return false ;
+   return DistBoxOrigSurfCalc.IsPointInside() ;
 }

CDeBoxTria.cpp

@@ -16,7 +16,6 @@
 #include "CDeBoxTria.h"
 #include "CDeSpheTria.h"
 #include "CDeCylTria.h"
-#include "CDeCapsTria.h"
 #include "/EgtDev/Include/EGkPlane3d.h"
 
 using namespace std ;
@@ -100,17 +99,9 @@ CDeSimpleBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, const Triangle3d
    Triangle3d trTriaL = trTria ;
    trTriaL.ToLoc( frBox) ;
 
-  // Calcolo il box locale del triangolo
-   BBox3d b3TriaL ;
-   trTriaL.GetLocalBBox( b3TriaL) ;
-
   // Calcolo il box come tale
    BBox3d b3Box( ORIG, ORIG + vtDiag) ;
 
-  // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Box.Overlaps( b3TriaL))
-      return false ;
-
   // Compute box center and extents
    Point3d  ptCen ;
    Vector3d vtExt ;
@@ -171,7 +162,7 @@ CDeSimpleBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, const Triangle3d
 
 //----------------------------------------------------------------------------
 bool
-CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, const Triangle3d& trTria, double dSafeDist)
+CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, const Triangle3d& trTria)
 {
   // Porto il triangolo nel riferimento del box
    Triangle3d trTriaL = trTria ;
@@ -182,45 +173,75 @@ CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, const Triangle3d& trTr
       return CDeSimpleBoxTria( Frame3d(), vtDiag, trTriaL) ;
 
   // Verifica preliminare con box esteso
-   Frame3d frTmp( Point3d( -dSafeDist, -dSafeDist, -dSafeDist)) ;
-   if ( ! CDeSimpleBoxTria( frTmp, vtDiag + 2 * Vector3d( dSafeDist, dSafeDist, dSafeDist), trTriaL))
+   Frame3d frEst( Point3d( -dSafeDist, -dSafeDist, -dSafeDist)) ;
+   if ( ! CDeSimpleBoxTria( frEst, vtDiag + 2 * Vector3d( dSafeDist, dSafeDist, dSafeDist), trTriaL))
       return false ;
 
   // Tre box aumentati con distanza di sicurezza in un sola dimensione
-   frTmp.ChangeOrig( Point3d( -dSafeDist, 0, 0)) ;
+   Frame3d frTmp = frBox ; frTmp.Translate( - dSafeDist * frBox.VersX()) ;
    if ( CDeSimpleBoxTria( frTmp, vtDiag + 2 * dSafeDist * X_AX, trTriaL))
       return true ;
-   frTmp.ChangeOrig( Point3d( 0, -dSafeDist, 0)) ;
+   frTmp = frBox ; frTmp.Translate( - dSafeDist * frBox.VersY()) ;
    if ( CDeSimpleBoxTria( frTmp, vtDiag + 2 * dSafeDist * Y_AX, trTriaL))
       return true ;
-   frTmp.ChangeOrig( Point3d( 0, 0, -dSafeDist)) ;
+   frTmp = frBox ; frTmp.Translate( - dSafeDist * frBox.VersZ()) ;
    if ( CDeSimpleBoxTria( frTmp, vtDiag + 2 * dSafeDist * Z_AX, trTriaL))
       return true ;
 
-  // Capsule centrati sui dodici spigoli
-   if ( CDeSimpleCapsTria( Point3d( 0, 0, 0), Point3d( vtDiag.x, 0, 0), dSafeDist, trTriaL))
+  // Sfere centrate negli otto vertici
+   if ( CDeSimpleSpheTria( Point3d( 0, 0, 0), dSafeDist, trTriaL))
       return true ;
-   if ( CDeSimpleCapsTria( Point3d( 0, vtDiag.y, 0), Point3d( vtDiag.x, vtDiag.y, 0), dSafeDist, trTriaL))
+   if ( CDeSimpleSpheTria( Point3d( vtDiag.x, 0, 0), dSafeDist, trTriaL))
       return true ;
-   if ( CDeSimpleCapsTria( Point3d( 0, 0, 0), Point3d( 0, vtDiag.y, 0), dSafeDist, trTriaL))
+   if ( CDeSimpleSpheTria( Point3d( vtDiag.x, vtDiag.y, 0), dSafeDist, trTriaL))
       return true ;
-   if ( CDeSimpleCapsTria( Point3d( vtDiag.x, 0, 0), Point3d( vtDiag.x, vtDiag.y, 0), dSafeDist, trTriaL))
+   if ( CDeSimpleSpheTria( Point3d( 0, vtDiag.y, 0), dSafeDist, trTriaL))
       return true ;
-   if ( CDeSimpleCapsTria( Point3d( 0, 0, vtDiag.z), Point3d( vtDiag.x, 0, vtDiag.z), dSafeDist, trTriaL))
+   if ( CDeSimpleSpheTria( Point3d( 0, 0, vtDiag.z), dSafeDist, trTriaL))
       return true ;
-   if ( CDeSimpleCapsTria( Point3d( 0, vtDiag.y, vtDiag.z), Point3d( vtDiag.x, vtDiag.y, vtDiag.z), dSafeDist, trTriaL))
+   if ( CDeSimpleSpheTria( Point3d( vtDiag.x, 0, vtDiag.z), dSafeDist, trTriaL))
       return true ;
-   if ( CDeSimpleCapsTria( Point3d( 0, 0, vtDiag.z), Point3d( 0, vtDiag.y, vtDiag.z), dSafeDist, trTriaL))
+   if ( CDeSimpleSpheTria( Point3d( vtDiag.x, vtDiag.y, vtDiag.z), dSafeDist, trTriaL))
       return true ;
-   if ( CDeSimpleCapsTria( Point3d( vtDiag.x, 0, vtDiag.z), Point3d( vtDiag.x, vtDiag.y, vtDiag.z), dSafeDist, trTriaL))
+   if ( CDeSimpleSpheTria( Point3d( 0, vtDiag.y, vtDiag.z), dSafeDist, trTriaL))
       return true ;
-   if ( CDeSimpleCapsTria( Point3d( 0, 0, 0), Point3d( 0, 0, vtDiag.z), dSafeDist, trTriaL))
+
+  // Cilindri centrati sui dodici spigoli
+   frTmp.Set( Point3d( 0, 0, 0), X_AX) ;
+   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.x, trTriaL))
       return true ;
-   if ( CDeSimpleCapsTria( Point3d( vtDiag.x, 0, 0), Point3d( vtDiag.x, 0, vtDiag.z), dSafeDist, trTriaL))
+   frTmp.Set( Point3d( 0, vtDiag.y, 0), X_AX) ;
+   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.x, trTriaL))
       return true ;
-   if ( CDeSimpleCapsTria( Point3d( vtDiag.x, vtDiag.y, 0), Point3d( vtDiag.x, vtDiag.y, vtDiag.z), dSafeDist, trTriaL))
+   frTmp.Set( Point3d( 0, 0, 0), Y_AX) ;
+   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.y, trTriaL))
       return true ;
-   if ( CDeSimpleCapsTria( Point3d( 0, vtDiag.y, 0), Point3d( 0, vtDiag.y, vtDiag.z), dSafeDist, trTriaL))
+   frTmp.Set( Point3d( vtDiag.x, 0, 0), Y_AX) ;
+   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.y, trTriaL))
+      return true ;
+   frTmp.Set( Point3d( 0, 0, vtDiag.z), X_AX) ;
+   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.x, trTriaL))
+      return true ;
+   frTmp.Set( Point3d( 0, vtDiag.y, vtDiag.z), X_AX) ;
+   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.x, trTriaL))
+      return true ;
+   frTmp.Set( Point3d( 0, 0, vtDiag.z), Y_AX) ;
+   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.y, trTriaL))
+      return true ;
+   frTmp.Set( Point3d( vtDiag.x, 0, vtDiag.z), Y_AX) ;
+   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.y, trTriaL))
+      return true ;
+   frTmp.Set( Point3d( 0., 0., 0.), Z_AX) ;
+   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.z, trTriaL))
+      return true ;
+   frTmp.Set( Point3d( vtDiag.x, 0., 0.), Z_AX) ;
+   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.z, trTriaL))
+      return true ;
+   frTmp.Set( Point3d( vtDiag.x, vtDiag.y, 0.), Z_AX) ;
+   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.z, trTriaL))
+      return true ;
+   frTmp.Set( Point3d( 0., vtDiag.y, 0.), Z_AX) ;
+   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.z, trTriaL))
       return true ;
 
    return false ;

CDeBoxTria.h

@@ -17,4 +17,4 @@
 
 //----------------------------------------------------------------------------
 bool CDeSimpleBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, const Triangle3d& trTria) ;
-bool CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, const Triangle3d& trTria, double dSafeDist) ;
+bool CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, const Triangle3d& trTria) ;

CDeCapsTria.cpp

@@ -1,104 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2022-2022
-//----------------------------------------------------------------------------
-// File : CDeCapsTria.cpp   Data : 14.05.22     Versione : 2.4e2
-// Contenuto : Implementazione della verifica di collisione tra 
-//             Capsule (cilindro con estremità semisferiche) e Triangle3d.
-//
-//
-// Modifiche :14.05.22 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "CDeCapsTria.h"
-#include "CDeSpheTria.h"
-#include "ProjPlane.h"
-#include "IntersLineCaps.h"
-#include "/EgtDev/Include/EGkPolygon3d.h"
-#include "/EgtDev/Include/EGkIntersLinePlane.h"
-#include "/EgtDev/Include/EGkDistPointTria.h"
-#include "/EgtDev/Include/EGkIntersLineSphere.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-bool
-CDeSimpleCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Triangle3d& trTria)
-{
-   // vedi Ericson, Real-Time Collision Detection, pag. 226 (Nettle method)
-
-  // Dati della capsule come sfera che si muove
-   Point3d ptC = ptP1 ;
-   Point3d ptE = ptP2 ;
-   Vector3d vtDir = ptP2 - ptP1 ;
-   double dLen = vtDir.Len() ;
-   if ( dLen < EPS_SMALL)
-      return CDeSimpleSpheTria( Media( ptP1, ptP2), dR, trTria) ;
-   vtDir /= dLen ;
-   if ( vtDir * trTria.GetN() > 0) {
-      vtDir.Invert() ;
-      ptC = ptP2 ;
-      ptE = ptP1 ;
-   }
-  // Se sfera finale dista dal piano come o meno del raggio, devo verificarla direttamente (il retro è escluso dal calcolo standard)
-   double dDistE = DistPointPlane( ptE, trTria.GetPlane()) ;
-   if ( abs( dDistE) <= dR) {
-      if ( CDeSimpleSpheTria( ptE, dR, trTria))
-         return true ;
-   }
-  // Determinazione primo possibile punto di contatto della sfera con il piano
-   Point3d ptD = ptC - trTria.GetN() * dR ;
-  // Intersezione della linea di movimento di questo punto con il piano del triangolo
-   Point3d ptP ;
-   int nLpRes = IntersLinePlane( ptD, vtDir, 1, trTria.GetPlane(), ptP, false) ;
-  // Se non c'è intersezione passante
-   if ( nLpRes != ILPT_YES) {
-     // se il centro dista dal piano non meno del raggio, allora non c'è sicuramente collisione
-      double dDistM = DistPointPlane( Media( ptP1, ptP2), trTria.GetPlane()) ;
-      if ( abs( dDistM) >= dR)
-         return false ;
-     // interseco l'asse del capsule con capsule di pari raggio con asse i lati del triangolo
-      double dU1 = INFINITO, dU2 = -INFINITO ;
-      for ( int i = 0 ; i < 3 ; ++ i) {
-         double dInt1, dInt2 ;
-         if ( IntersLineCaps( ptC, vtDir, trTria.GetP( i), trTria.GetP( ( i + 1) % 3), dR, dInt1, dInt2)) {
-            dU1 = min( dU1, dInt1) ;
-            dU2 = max( dU2, dInt2) ;
-            if ( ! ( dU1 >= dLen  ||  dU2 <= 0))
-               return true ;
-         } 
-      }
-      return false ;
-   }
-  // Determino la posizione dell'intersezione rispetto al triangolo
-   DistPointTriangle dptDist( ptP, trTria) ;
-  // Se l'intersezione sta nel triangolo
-   double dSqDist ;
-   if ( dptDist.GetSqDist( dSqDist)  &&  dSqDist < 4 * SQ_EPS_SMALL) {
-      double dPos = ( ptP - ptD) * vtDir ;
-      return ( dPos > 0  &&  dPos < dLen) ;
-   }
-  // Altrimenti, recupero il punto del triangolo più vicino all'intersezione
-   Point3d ptQ ;
-   if ( dptDist.GetMinDistPoint( ptQ)) {
-      Point3d ptI1, ptI2 ;
-      int nLsRes = IntersLineSphere( ptQ, -vtDir, ptC, dR, ptI1, ptI2) ;
-      if ( nLsRes != ILST_SEC)
-         return false ;
-      double dPos = ( ptQ - ptI1) * vtDir ;
-      return ( dPos > 0  &&  dPos < dLen) ;
-   }
-
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CDeCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Triangle3d& trTria, double dSafeDist)
-{
-   return CDeSimpleCapsTria( ptP1, ptP2, dR + max( 0., dSafeDist), trTria) ;
-}
- 

CDeCapsTria.h

@@ -1,19 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2022-2022
-//----------------------------------------------------------------------------
-// File : EGkCDeCapsTria.h      Data : 14.05.22    Versione : 2.4e2
-// Contenuto : Dichiarazione funzione verifica collisione tra
-//             Capsule (cilindro con estremità semisferiche) e Triangle3d.
-//
-// Modifiche : 14.05.22 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "/EgtDev/Include/EGkTriangle3d.h"
-
-//----------------------------------------------------------------------------
-bool CDeSimpleCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Triangle3d& trTria) ;
-bool CDeCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Triangle3d& trTria, double dSafeDist) ;

CDeClosedSurfTmClosedSurfTm.cpp

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : CDeClosedSurfTmClosedSurfTm.h    Data : 24.03.24  Versione : 2.6c2 
+// File :      CDeSurfTmSurfTm.h      Data : 13.11.20    Versione : 
 // Contenuto : Implementazione funzione verifica collisione tra
 //             SurfTm e SurfTm.
 //
 // Modifiche : 13.11.20 LM Creazione modulo.
-//             24.03.24 DS Aggiunta TestSurfTmSurfTm.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -18,81 +18,78 @@
 #include "/EgtDev/Include/EGkBBox3d.h"
 #include "/EgtDev/Include/EGkCDeClosedSurfTmClosedSurfTm.h"
 #include "/EgtDev/Include/EGkDistPointSurfTm.h"
+#include <unordered_set>
+#include <utility>
 
 using namespace std ;
 
 //----------------------------------------------------------------------------
+// La funzione restituisce true in caso di collisone, false in caso di assenza
+// di collisione o inconsistenza dei parametri di input.
 // Le due superfici devono essere espresse nel medesimo sistema di riferimento.
 // La distanza di sicurezza ha effetto solo se maggiore di EPS_SMALL.
 // Se necessario cerco la collisione con un offset della superficie B costituito
-// da sfere centrate nei vertici, cilindri con gli spigoli per asse e il triangolo
-// originale traslato della distanza di sicurezza lungo la sua normale.
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - false in caso di assenza di collisione.
-//----------------------------------------------------------------------------
+// da sfere centrate nei vertici, cilindri con i segmenti per asse e il triangolo
+// originale traslato di una costante pari alla distanza di sicurezza lungo la
+// sua normale.
 bool
-CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist)
+CDeClosedSurfTmClosedSurfTm( const SurfTriMesh& SurfA, const SurfTriMesh& SurfB, double dSafeDist)
 {
-  // Recupero le superfici base
-   const SurfTriMesh* pSrfA = GetBasicSurfTriMesh( &SurfA) ;
-   const SurfTriMesh* pSrfB = GetBasicSurfTriMesh( &SurfB) ;
-  // Se le superfici non sono valide o non sono chiuse, non ha senso proseguire
-   if ( pSrfA == nullptr ||  ! pSrfA->IsValid()  ||  ! pSrfA->IsClosed()  ||
-        pSrfB == nullptr ||  ! pSrfB->IsValid()  ||  ! pSrfB->IsClosed())
-      return true ;
-  // Se i box delle superfici non si intersecano, ho finito.
+   // Se le superfici non sono valide o non sono chiuse, non ha senso proseguire.
+   if ( ! ( SurfA.IsValid()  &&  SurfB.IsValid())  ||  ! ( SurfA.IsClosed()  &&  SurfB.IsClosed()))
+      return false ;
+   // Se i box delle superfici non si intersecano, ho finito.
    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.
+   SurfA.GetLocalBBox( b3BoxA) ;
+   SurfB.GetLocalBBox( b3BoxB) ;
+   // Se è necessario, espando il box 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.
+      b3BoxA.Expand( dSafeDist) ;
+   // 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
+   // Recupero i triangoli di B che interferiscono col box del triangolo di A
    INTVECTOR vTriaIndex ;
-   pSrfA->GetAllTriaOverlapBox( b3BoxB, vTriaIndex) ;
-  // Ciclo sui triangoli della superficie A che interferiscono col box della superficie B.
+   SurfA.GetAllTriaOverlapBox( b3BoxB, vTriaIndex) ;
+   // Ciclo sui triangoli della superficie A che cadono nel box della superficie B.
    for ( int nTA : vTriaIndex) {
       Triangle3d trTriaA ;
-      if ( ! ( pSrfA->GetTriangle( nTA, trTriaA)  &&  trTriaA.Validate()))
+      if ( ! ( SurfA.GetTriangle( nTA, trTriaA)  &&  trTriaA.Validate()))
          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
+      // 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.
-     // 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.
+      SurfB.GetAllTriaOverlapBox( b3BoxTriaA, vNearTria) ;
+      // Settare tutti i triangoli come già processati.
+      // Al termine della chiamata i TFlags dei triangoli valgono 0.
+      SurfB.ResetTempInt() ;
+      // Ciclo sui triangoli della superficie B che cadono nel box del triangolo corrente della Superficie A.
       for ( int nTB : vNearTria) {
-        // Recupero il triangolo corrente della superficie B.
-        // Se triangolo non valido salto al successivo.
+         // Recupero il triangolo corrente della superficie B.
+         // Se triangolo non valido salto al successivo.
          Triangle3d trTriaB ;
-         if ( ! ( pSrfB->GetTriangle( nTB, trTriaB)  &&  trTriaB.Validate()))
+         if ( ! ( SurfB.GetTriangle( nTB, trTriaB)  &&  trTriaB.Validate()))
             continue ;   
-        // Se necessario considero l'offset
+         // Se necessario considero l'offset
          if ( dSafeDist > EPS_SMALL) {
             int nAdjTriaId[3] ;
-            pSrfB->GetTriangleAdjacencies( nTB, nAdjTriaId) ;
-           // Ciclo sui vertici del triangolo.
+            SurfB.GetTriangleAdjacencies( nTB, nAdjTriaId) ;
+            // 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.
+               // Se il triangolo adiacente al triangolo corrente su questo edge
+               // non è stato processato, processo il vertice e l'edge.
                int nAdjTriaTempFlag ;
-               if ( ! ( pSrfB->GetTempInt( nAdjTriaId[nVB], nAdjTriaTempFlag)  ||  nAdjTriaTempFlag == 0))
+               if ( ! ( SurfB.GetTriangleTempInt( 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.
-               Vector3d vtEdgeV = trTriaB.GetP( ( nVB + 1) % 3) - trTriaB.GetP( nVB) ;
+               // Processo l'edge: se c'è collisione fra triangolo A e cilindro ho finito.
+               Vector3d vtEdgeV = trTriaB.GetP( nVB) - trTriaB.GetP( ( nVB + 1) % 3) ;
                double dEdgeLen = vtEdgeV.Len() ;
                vtEdgeV /= dEdgeLen ;
                Frame3d frCyl ;
@@ -100,111 +97,22 @@ CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& Surf
                if ( CDeSimpleCylTria( frCyl, dSafeDist, dEdgeLen, trTriaA))
                   return true ;  
             }
-           // Traslo il triangolo
+            // Traslo il triangolo
             trTriaB.Translate( dSafeDist * trTriaB.GetN()) ;
          }
-        // Processo il triangolo: se i due triangoli collidono ho finito.
+         // Processo il triangolo: se i due triangoli collidono ho finito.
          if ( CDeTriaTria( trTriaA, trTriaB))
             return true ;
-        // Segno il triangolo come processato: nTemp = 1
-         pSrfB->SetTempInt( nTB, 1) ;
+         // Segno il triangolo come processato: nTFlag = 1
+         SurfB.SetTempInt( nTB, 1) ;
       }
    }
-  // 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
-   if ( ! b3BoxA.Encloses( b3BoxB)  &&  ! b3BoxB.Encloses( b3BoxA))
-      return false ;
-  // La collisione c'è se una superficie è dentro l'altra.
+   // Non ho trovato collisioni fra triangoli delle superfici.
+   // La collisione c'è se una superficie è dentro l'altra.
    Point3d ptPointA, ptPointB ;
-   pSrfA->GetFirstVertex( ptPointA) ;
-   pSrfB->GetFirstVertex( ptPointB) ;
-   DistPointSurfTm DistPoinASrfB( ptPointA, *pSrfB) ;
-   DistPointSurfTm DistPoinBSrfA( ptPointB, *pSrfA) ;
-   return ( DistPoinASrfB.IsPointInside()  ||  DistPoinBSrfA.IsPointInside()) ;
-}
-
-//----------------------------------------------------------------------------
-// Verifica l'interferenza tra le due superfici : restituisce true in caso di interferenza.
-//----------------------------------------------------------------------------
-bool
-TestSurfTmSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist)
-{
-  // Recupero le superfici base
-   const SurfTriMesh* pSrfA = GetBasicSurfTriMesh( &SurfA) ;
-   const SurfTriMesh* pSrfB = GetBasicSurfTriMesh( &SurfB) ;
-  // Se le superfici non sono valide, non ha senso proseguire
-   if ( pSrfA == nullptr ||  ! pSrfA->IsValid()  ||
-        pSrfB == nullptr ||  ! pSrfB->IsValid())
-      return true ;
-  // Se i box delle superfici non si intersecano, ho finito.
-   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.
-   if ( dSafeDist > EPS_SMALL)
-      b3BoxB.Expand( dSafeDist) ;
-  // 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
-   INTVECTOR vTriaIndex ;
-   pSrfA->GetAllTriaOverlapBox( b3BoxB, vTriaIndex) ;
-  // Ciclo sui triangoli della superficie A che interferiscono col box della superficie B.
-   for ( int nTA : vTriaIndex) {
-      Triangle3d trTriaA ;
-      if ( ! ( pSrfA->GetTriangle( nTA, trTriaA)  &&  trTriaA.Validate()))
-         continue ;
-      BBox3d b3BoxTriaA ;
-      trTriaA.GetLocalBBox( b3BoxTriaA) ;
-     // 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.
-     // 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.
-      for ( int nTB : vNearTria) {
-        // Recupero il triangolo corrente della superficie B.
-        // Se triangolo non valido salto al successivo.
-         Triangle3d trTriaB ;
-         if ( ! ( pSrfB->GetTriangle( nTB, trTriaB)  &&  trTriaB.Validate()))
-            continue ;   
-        // Se necessario considero l'offset
-         if ( dSafeDist > EPS_SMALL) {
-            int nAdjTriaId[3] ;
-            pSrfB->GetTriangleAdjacencies( nTB, nAdjTriaId) ;
-           // 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.
-               int nAdjTriaTempFlag ;
-               if ( ! ( pSrfB->GetTempInt( nAdjTriaId[nVB], nAdjTriaTempFlag)  ||  nAdjTriaTempFlag == 0))
-                  continue ;
-              // 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.
-               Vector3d vtEdgeV = trTriaB.GetP( ( nVB + 1) % 3) - trTriaB.GetP( nVB) ;
-               double dEdgeLen = vtEdgeV.Len() ;
-               vtEdgeV /= dEdgeLen ;
-               Frame3d frCyl ;
-               frCyl.Set( trTriaB.GetP( nVB), vtEdgeV) ;
-               if ( CDeSimpleCylTria( frCyl, dSafeDist, dEdgeLen, trTriaA))
-                  return true ;  
-            }
-           // Traslo il triangolo
-            trTriaB.Translate( dSafeDist * trTriaB.GetN()) ;
-         }
-        // Processo il triangolo: se i due triangoli collidono ho finito.
-         if ( CDeTriaTria( trTriaA, trTriaB))
-            return true ;
-        // Segno il triangolo come processato: nTemp = 1
-         pSrfB->SetTempInt( nTB, 1) ;
-      }
-   }
-  // Non c'è interferenza
-   return false ;
-}
+   SurfA.GetFirstVertex( ptPointA) ;
+   SurfB.GetFirstVertex( ptPointB) ;
+   DistPointSurfTm DistPoinASurfB( ptPointA, SurfB) ;
+   DistPointSurfTm DistPoinBSurfA( ptPointB, SurfA) ;
+   return ( DistPoinASurfB.IsPointInside()  ||  DistPoinBSurfA.IsPointInside()) ;
+}

CDeConeFrustumClosedSurfTm.cpp

@@ -1,13 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : CDeConeFrustumClosedSurfTm.cpp  Data : 24.031.24  Versione : 2.6c2 
+// File : CDCylSurfTm.cpp      Data : 09.11.20        Versione : 
 // Contenuto : Implementazione della verifica di collisione tra
 //             Cone e Closed SurftriMesh.
 //
 //
 // Modifiche : 09.11.20 LM Creazione modulo.
-//             24.03.24 DS Aggiunta TestConeFrustumSurfTm.
 //
 //
 //----------------------------------------------------------------------------
@@ -21,93 +20,45 @@
 using namespace std ;
 
 //----------------------------------------------------------------------------
-// Il sistema di riferimento deve avere l'asse di simmetria del cono come asse Z e origine nel centro della base.
-// La distanza di sicurezza ha effetto solo se maggiore di EPS_SMALL, altrimenti è ignorata ed è ininfluente.
-// Il sistema di riferimento del cono è riferito a quello della superficie.
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - false in caso di assenza di collisione.
-//----------------------------------------------------------------------------
+// Il sisitema di riferimento deve avere l'asse di simmetria del cono come asse Z e origine nel centro della base.
+// La distanza di sicurezza ha effetto solo se maggiore di epsilon, altrimenti è ignorata ed è ininfluente.
+// Il sistema di riferimento del cono deve essere immerso in quello della superficie.
 bool
 CDeConeFrustumClosedSurfTm( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
-                            const ISurfTriMesh& Stm, double dSafeDist)
+                            double dSafeDist, const ISurfTriMesh& Stm)
 {
-  // Se il tronco di cono non è ben definito non ha senso proseguire
+  // Se il tronco di cono non è ben definito non ha senso proseguire.
    if ( max( dBaseRad, dTopRad) < EPS_SMALL  ||  dHeight < EPS_SMALL)
-      return true ;
-  // Se superficie non valida o aperta, non ha senso proseguire
-   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
-      return true ;
+      return false ;
   // Recupero BBox della trimesh
    BBox3d b3Surf = Stm.GetAllTriaBox() ;
   // Calcolo il BBox del tronco di cono
    double dMaxRad = max( dBaseRad, dTopRad) ;
-   BBox3d b3ConeL( Point3d( -dMaxRad, -dMaxRad, 0),
-                   Point3d( dMaxRad, dMaxRad, dHeight)) ;
-   if ( dSafeDist > EPS_SMALL)
-      b3ConeL.Expand( dSafeDist) ;
-   BBox3d b3Cone = GetToGlob( b3ConeL, frCone) ;
-  // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Surf.Overlaps( b3Cone)  ||  ! b3Surf.Overlaps( frCone, b3ConeL))
+   BBox3d b3Cone( - dMaxRad, - dMaxRad, 0, dMaxRad, dMaxRad, dHeight) ;
+   b3Cone.Expand( dSafeDist) ;
+  // Porto BBox del cono nel sistema della superficie.
+   b3Cone.ToGlob( frCone) ;
+  // Se i BBox non interferiscono, ho finito.
+   if ( ! b3Cone.Overlaps( b3Surf))
       return false ;
   // Recupero i triangoli che interferiscono con il box del cono
    INTVECTOR vT ;
    Stm.GetAllTriaOverlapBox( b3Cone, vT) ;
-  // Verifico se il tronco di cono interferisce con i triangoli del poliedro presenti nel suo BBox
+  // Ciclo sui triangoli che interferiscono col box del cono
    for ( int nT : vT) {
       Triangle3d trTria ;
       if ( Stm.GetTriangle( nT, trTria)) {
-         if ( CDeConeFrustumTria( frCone, dBaseRad, dTopRad, dHeight, trTria, dSafeDist))
+         if ( CDeConeFrustumTria( frCone, dBaseRad, dTopRad, dHeight, dSafeDist, trTria))
             return true ;
       }
    }
-  // Se il BBox del tronco di cono non è interno a quello del poliedro e viceversa, non c'è collisione
-   if ( ! b3Surf.Encloses( b3Cone)  &&  ! b3Cone.Encloses( b3Surf))
+  // Se superficie aperta, non c'è collisione
+   if ( ! Stm.IsClosed())
       return false ;
   // Verifico se il tronco di cono è dentro la superficie tramite calcolo distanza minima.
-   Point3d ptConeCen( 0, 0, dHeight / 2) ;
-   ptConeCen.ToGlob( frCone) ;
-   DistPointSurfTm DistConeCenSurfCalc( ptConeCen, Stm) ;
+   Point3d ptConeOrig ;
+   ptConeOrig.ToGlob( frCone) ;
+   DistPointSurfTm DistConeOrigSurfCalc( ptConeOrig, Stm) ;
   // Se il tronco di cono è interno c'è collisione
-   return DistConeCenSurfCalc.IsPointInside() ;
-}
-
-//----------------------------------------------------------------------------
-// Verifica l'interferenza tra il tronco di cono e la superficie : restituisce true in caso di interferenza.
-//----------------------------------------------------------------------------
-bool
-TestConeFrustumSurfTm( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
-                       const ISurfTriMesh& Stm, double dSafeDist)
-{
-  // Se il tronco di cono non è ben definito non ha senso proseguire
-   if ( max( dBaseRad, dTopRad) < EPS_SMALL  ||  dHeight < EPS_SMALL)
-      return true ;
-  // Se superficie non valida, non ha senso proseguire
-   if ( ! Stm.IsValid())
-      return true ;
-  // Recupero BBox della trimesh
-   BBox3d b3Surf = Stm.GetAllTriaBox() ;
-  // Calcolo il BBox del tronco di cono
-   double dMaxRad = max( dBaseRad, dTopRad) ;
-   BBox3d b3ConeL( Point3d( -dMaxRad, -dMaxRad, 0),
-                   Point3d( dMaxRad, dMaxRad, dHeight)) ;
-   if ( dSafeDist > EPS_SMALL)
-      b3ConeL.Expand( dSafeDist) ;
-   BBox3d b3Cone = GetToGlob( b3ConeL, frCone) ;
-  // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Surf.Overlaps( b3Cone)  ||  ! b3Surf.Overlaps( frCone, b3ConeL))
-      return false ;
-  // Recupero i triangoli che interferiscono con il box del cono
-   INTVECTOR vT ;
-   Stm.GetAllTriaOverlapBox( b3Cone, vT) ;
-  // Verifico se il tronco di cono interferisce con i triangoli del poliedro presenti nel suo BBox
-   for ( int nT : vT) {
-      Triangle3d trTria ;
-      if ( Stm.GetTriangle( nT, trTria)) {
-         if ( CDeConeFrustumTria( frCone, dBaseRad, dTopRad, dHeight, trTria, dSafeDist))
-            return true ;
-      }
-   }
-  // Non c'è interferenza
-   return false ;
-}
+   return DistConeOrigSurfCalc.IsPointInside() ;
+}

CDeConeFrustumTria.cpp

@@ -134,7 +134,7 @@ CDeSimpleConeFrustumTria( const Frame3d& frCone, double dMinRad, double dMaxRad,
 // La distanza di sicurezza ha effetto solo se maggiore di epsilon, altrimenti è ignorata ed è ininfluente.
 bool
 CDeConeFrustumTria( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
-                    const Triangle3d& trTria, double dSafeDist)
+                    double dSafeDist, const Triangle3d& trTria)
 {
   // Se il tronco di cono o il triangolo non sono ben definiti non procedo
    if ( max( dBaseRad, dTopRad) < EPS_SMALL  ||  dHeight < EPS_SMALL  ||  ! trTria.IsValid())
@@ -142,7 +142,7 @@ CDeConeFrustumTria( const Frame3d& frCone, double dBaseRad, double dTopRad, doub
 
   // Se è un cilindro chiamo la routine apposita.
    if ( abs( dBaseRad - dTopRad) < EPS_SMALL)
-      return CDeCylTria( frCone, max( dBaseRad, dTopRad), dHeight, trTria, dSafeDist) ;
+      return CDeCylTria( frCone, max( dBaseRad, dTopRad), dHeight, dSafeDist, trTria) ;
 
   // Se il raggio di base è maggiore del raggio top cambio il sistema di riferimento.
    double dMinRad = dBaseRad ;
@@ -156,11 +156,11 @@ CDeConeFrustumTria( const Frame3d& frCone, double dBaseRad, double dTopRad, doub
 
   // Se è un cono, chiamo la routine apposita
    if ( dMinRad < EPS_SMALL)
-      return CDeConeTria( frMyCone, dMaxRad, dHeight, trTria, dSafeDist) ;
+      return CDeConeTria( frMyCone, dMaxRad, dHeight, dSafeDist, trTria) ;
 
   // Se distanza di sicurezza nulla
    if ( dSafeDist < EPS_SMALL)
-      return CDeSimpleConeFrustumTria( frMyCone, dBaseRad, dTopRad, dHeight, trTria) ;
+      return CDeSimpleConeFrustumTria( frMyCone, dBaseRad, dTopRad, dHeight, trTria ) ;
 
   // Verifica preliminare con tronco di cono esteso
    double dDiffRad = dMaxRad - dMinRad ;

CDeConeFrustumTria.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : CDeConeFrustumTria.h   Data : 28.10.20     Versione : 2.2k1
+// File : CDeConTria.cpp   Data : 28.10.20     Versione : 2.2k1
 // Contenuto : Dichiarazione della verifica di collisione tra 
 //             Cone e Triangle3d.
 //
@@ -20,5 +20,6 @@
 // Il sistema di riferimento deve avere l'origine nel centro della base minore e l'asse
 // di simmetria del cono, rivolto verso la direzione di apertura, come asse Z.
 bool CDeSimpleConeFrustumTria( const Frame3d& frCone, double dMinRad, double dMaxRad, double dHeight, const Triangle3d& trTria) ;
+// Il sistema di riferimento ha l'asse Z coincidente con l'asse di simmetria del cono e l'origine nel centro della base.
 bool CDeConeFrustumTria( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
-                         const Triangle3d& trTria, double dSafeDist) ;
+                         double dSafeDist, const Triangle3d& trTria) ;

CDeConeTria.cpp

@@ -111,7 +111,7 @@ CDeSimpleConeTria( const Frame3d& frCone, double dRad, double dHeight, const Tri
 
 //----------------------------------------------------------------------------
 bool
-CDeConeTria( const Frame3d& frCone, double dRad, double dHeight, const Triangle3d& trTria, double dSafeDist)
+CDeConeTria( const Frame3d& frCone, double dRad, double dHeight, double dSafeDist, const Triangle3d& trTria)
 {
   // Verifico validità del cono
    if ( dRad < EPS_SMALL  ||  dHeight < EPS_SMALL)

CDeConeTria.h

@@ -19,4 +19,4 @@
 //----------------------------------------------------------------------------
 // Il sistema di riferimento ha asse Z coincidente con l'asse del cono e origine nel vertice del cono (punto più basso).
 bool CDeSimpleConeTria( const Frame3d& frCone, double dRad, double dHeight, const Triangle3d& trTria) ;
-bool CDeConeTria( const Frame3d& frCone, double dRad, double dHeight, const Triangle3d& trTria, double dSafeDist) ;
+bool CDeConeTria( const Frame3d& frCone, double dRad, double dHeight, double dSafeDist, const Triangle3d& trTria) ;

CDeConvexTorusClosedSurfTm.cpp

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : CDeConvexTorusTria.cpp      Data : 24.03.24    Versione : 2.6c2
+// File : CDeConvexTorusTria.cpp      Data : 18.11.20    Versione : 
 // Contenuto : Implementazione funzione verifica collisione tra
 //             toro convesso e SurfTriMesh.
 //
 // Modifiche : 18.11.20 LM Creazione modulo.
-//             24.03.24 DS Aggiunta TestConvexTorusSurfTm.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -18,90 +18,48 @@
 using namespace std ;
 
 //----------------------------------------------------------------------------
-// Il toro convesso è il solido a disco limitato dalla sola parte esterna del toro.
+// Il toro convesso è il disco limitato dalla sola parte esterna del toro.
 // Raggio principale R1, raggio secondario R2.
 // Il toro è posto nel piano XY del suo riferimento, centrato sull'origine.
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - false in caso di assenza di collisione.
-//----------------------------------------------------------------------------
+// La funzione restituisce true in caso di collisione.
 bool
-CDeConvexTorusClosedSurfTm( const Frame3d& frTorus, double dRad1, double dRad2,
-                            const ISurfTriMesh& Stm, double dSafeDist)
+CDeConvexTorusClosedSurfTm( const Frame3d& frTorusFrame, double dRad1, double dRad2,
+                            double dSafeDist, const ISurfTriMesh& Stm)
 {
-  // I raggi devono essere non nulli
-   if ( dRad1 < EPS_SMALL  ||  dRad2 < EPS_SMALL)
-      return true ;
-  // Se superficie non valida o aperta, non ha senso proseguire
-   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
-      return true ;
-  // Box della superficie
-   BBox3d b3Surf = Stm.GetAllTriaBox() ;
+  // I raggi devono essere non nulli e la superficie ben definita.
+   if ( dRad1 < EPS_SMALL  ||  dRad2 < EPS_SMALL  ||  ! Stm.IsValid())
+      return false ;
   // Box del toro (sempre completo)
-   BBox3d b3TorusL( Point3d( -dRad1 - dRad2, -dRad1 - dRad2, -dRad2),
-                    Point3d(  dRad1 + dRad2,  dRad1 + dRad2,  dRad2)) ;
+   BBox3d b3ConvTorusBox ;
+   b3ConvTorusBox.Set( Point3d( - dRad1 - dRad2, - dRad1 - dRad2, - dRad2),
+                       Point3d(   dRad1 + dRad2,   dRad1 + dRad2,   dRad2)) ;
+  // Aggiungo eventuale distanza di sicurezza
    if ( dSafeDist > EPS_SMALL)
-      b3TorusL.Expand( dSafeDist) ;
-   BBox3d b3Torus = GetToGlob( b3TorusL, frTorus) ;
+      b3ConvTorusBox.Expand( dSafeDist) ;
+  // Porto il box del toro nel riferimento della superficie (inteso some globale)
+   b3ConvTorusBox.ToGlob( frTorusFrame) ;
+  // Box della superficie
+   BBox3d b3SurfBox = Stm.GetAllTriaBox() ;
   // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Surf.Overlaps( b3Torus)  ||  ! b3Surf.Overlaps( frTorus, b3TorusL))
+   if ( ! b3ConvTorusBox.Overlaps( b3SurfBox))
       return false ;
   // Recupero i triangoli che interferiscono con il box del toro
    INTVECTOR vT ;
-   Stm.GetAllTriaOverlapBox( b3Torus, vT) ;
-  // Verifico se il toro interferisce con i triangoli del poliedro presenti nel suo BBox
+   Stm.GetAllTriaOverlapBox( b3ConvTorusBox, vT) ;
+  // Ciclo sui triangoli recuperati
    for ( int nT : vT) {
       Triangle3d trTria ;
       if ( Stm.GetTriangle( nT, trTria)) {
-         if ( CDeConvexTorusTria( frTorus, dRad1, dRad2, CT_TOT, trTria, dSafeDist))
+         if ( CDeConvexTorusTria( frTorusFrame, dRad1, dRad2, CT_TOT, dSafeDist, trTria))
             return true ;
       }
    }
-  // Se il BBox del toro non è interno a quello del poliedro e viceversa, non c'è collisione
-   if ( ! b3Surf.Encloses( b3Torus)  &&  ! b3Torus.Encloses( b3Surf))
+  // Se superficie aperta, non c'è collisione
+   if ( ! Stm.IsClosed())
       return false ;
-  // Verifico se il toro è dentro la superficie tramite calcolo distanza minima del suo centro
-   Point3d ptTorusOrig = frTorus.Orig() ;
+  // Verifico se il toro è dentro la superficie tramite calcolo distanza minima.
+   Point3d ptTorusOrig = frTorusFrame.Orig() ;
    DistPointSurfTm DistConeOrigSurfCalc( ptTorusOrig, Stm) ;
   // Se il toro è interno c'è collisione
    return ( DistConeOrigSurfCalc.IsPointInside()) ;
 }
-
-//----------------------------------------------------------------------------
-// Verifica l'interferenza tra il toro convesso e la superficie : restituisce true in caso di interferenza
-//----------------------------------------------------------------------------
-bool
-TestConvexTorusSurfTm( const Frame3d& frTorus, double dRad1, double dRad2,
-                       const ISurfTriMesh& Stm, double dSafeDist)
-{
-  // I raggi devono essere non nulli
-   if ( dRad1 < EPS_SMALL  ||  dRad2 < EPS_SMALL)
-      return true ;
-  // Se superficie non valida, non ha senso proseguire
-   if ( ! Stm.IsValid())
-      return true ;
-  // Box della superficie
-   BBox3d b3Surf = Stm.GetAllTriaBox() ;
-  // Box del toro (sempre completo)
-   BBox3d b3TorusL( Point3d( -dRad1 - dRad2, -dRad1 - dRad2, -dRad2),
-                    Point3d(  dRad1 + dRad2,  dRad1 + dRad2,  dRad2)) ;
-   if ( dSafeDist > EPS_SMALL)
-      b3TorusL.Expand( dSafeDist) ;
-   BBox3d b3Torus = GetToGlob( b3TorusL, frTorus) ;
-  // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Surf.Overlaps( b3Torus)  ||  ! b3Surf.Overlaps( frTorus, b3TorusL))
-      return false ;
-  // Recupero i triangoli che interferiscono con il box del toro
-   INTVECTOR vT ;
-   Stm.GetAllTriaOverlapBox( b3Torus, vT) ;
-  // Verifico se il toro interferisce con i triangoli del poliedro presenti nel suo BBox
-   for ( int nT : vT) {
-      Triangle3d trTria ;
-      if ( Stm.GetTriangle( nT, trTria)) {
-         if ( CDeConvexTorusTria( frTorus, dRad1, dRad2, CT_TOT, trTria, dSafeDist))
-            return true ;
-      }
-   }
-  // Non c'è interferenza
-   return false ;
-}

CDeConvexTorusTria.cpp

@@ -61,7 +61,7 @@ CDeSimpleConvexTorusTria( const Frame3d& frTorus, double dRad1, double dRad2, in
    bool bContinue = plyApprox.GetFirstPoint( ptSt)  &&  plyApprox.GetNextPoint( ptEn) ;
    while ( bContinue  &&  ! bCollision) {
       frConus.Set( Point3d( 0., 0., ptSt.z), Frame3d::TOP) ;
-      bCollision = CDeSimpleConeFrustumTria( frConus, ptSt.x, ptEn.x, ptEn.z - ptSt.z, trMyTria) ;
+      bCollision = CDeConeFrustumTria( frConus, ptSt.x, ptEn.x, ptEn.z - ptSt.z, 0., trMyTria) ;
       ptSt = ptEn ;
       bContinue = plyApprox.GetNextPoint( ptEn) ;
    }
@@ -71,7 +71,7 @@ CDeSimpleConvexTorusTria( const Frame3d& frTorus, double dRad1, double dRad2, in
 //----------------------------------------------------------------------------
 bool
 CDeConvexTorusTria( const Frame3d& frTorus, double dRad1, double dRad2, int nCtType,
-                    const Triangle3d& trTria, double dSafeDist)
+                    double dSafeDist, const Triangle3d& trTria)
 {
   // I raggi devono essere non nulli e il triangolo ben definito.
    if ( dRad1 < EPS_SMALL  ||  dRad2 < EPS_SMALL  ||  ! trTria.IsValid())

CDeConvexTorusTria.h

@@ -28,4 +28,4 @@ enum ConvexTorusType { CT_INF = -1, CT_SUP = 1, CT_TOT = 0} ;
 bool CDeSimpleConvexTorusTria( const Frame3d& frTorus, double dRad1, double dRad2, int nCtType,
                                const Triangle3d& trTria) ;
 bool CDeConvexTorusTria( const Frame3d& frTorus, double dRad1, double dRad2, int nCtType,
-                         const Triangle3d& trTria, double dSafeDist) ;
+                         double dSafeDist, const Triangle3d& trTria) ;

CDeCylClosedSurfTm.cpp

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : CDeCylClosedSurfTm.cpp      Data : 24.03.24        Versione : 2.6c2
+// File : CDCylSurfTm.cpp      Data : 09.01.20        Versione : 2.2a2
 // Contenuto : Implementazione della verifica di collisione tra
 //             Cylinder e Closed SurftriMesh.
 //
 //
 // Modifiche : 09.01.20 DS Creazione modulo.
-//             24.03.24 DS Aggiunta TestCylSurfTm.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -19,100 +19,42 @@
 
 using namespace std ;
 
-//----------------------------------------------------------------------------
-// Il sistema di riferimento deve avere l'asse di simmetria del cilindro come asse Z e origine nel centro della base o del top.
-// La distanza di sicurezza ha effetto solo se maggiore di EPS_SMALL, altrimenti è ignorata ed è ininfluente.
-// Il sistema di riferimento del cilindro è riferito a quello della superficie.
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - false in caso di assenza di collisione.
 //----------------------------------------------------------------------------
 bool
-CDeCylClosedSurfTm( const Frame3d& frCyl, double dR, double dH, const ISurfTriMesh& Stm, double dSafeDist)
+CDeCylClosedSurfTm( const Frame3d& frCyl, double dR, double dH, double dSafeDist, const ISurfTriMesh& Stm)
 {
-  // Il cilindro deve essere ben definito
-   if ( dR < EPS_SMALL  ||  dH < EPS_SMALL)
-      return true ;
-  // Se superficie non valida o aperta, non ha senso proseguire
-   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
-      return true ;
-  // Recupero BBox del poliedro
+  // recupero BBox del poliedro
    BBox3d b3Poly = Stm.GetAllTriaBox() ;
-  // Sistemazioni cilindro
-   Frame3d frMyCyl = frCyl ;
+  // sistemazioni cilindro
+   Frame3d frC = frCyl ;
    if ( dH < 0) {
-      frMyCyl.Translate( dH * frMyCyl.VersZ()) ;
-      dH = -dH ;
+      frC.Translate( dH * frC.VersZ()) ;
+      dH = - dH ;
    }
-  // Calcolo il BBox del cilindro
-   BBox3d b3CylL( Point3d( -dR, -dR, 0),
-                  Point3d(  dR,  dR, dH)) ;
-   if ( dSafeDist > EPS_SMALL)
-      b3CylL.Expand( dSafeDist) ;
-   BBox3d b3Cyl = GetToGlob( b3CylL, frMyCyl) ;
-  // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Poly.Overlaps( b3Cyl)  ||  ! b3Poly.Overlaps( frMyCyl, b3CylL))
+  // calcolo il BBox del cilindro
+   BBox3d b3Cyl( -dR, -dR, 0, dR, dR, dH) ;
+   b3Cyl.Expand( dSafeDist) ;
+   b3Cyl.ToGlob( frC) ;
+  // confronto i due Box
+   if ( ! b3Cyl.Overlaps( b3Poly))
       return false ;
-  // Verifico se il cilindro interferisce con i triangoli del poliedro presenti nel suo BBox
+  // recupero i triangoli che interferiscono con il box del Cilindro
    INTVECTOR vT ;
    Stm.GetAllTriaOverlapBox( b3Cyl, vT) ;
    for ( int nT : vT) {
       Triangle3d Tria ;
       if ( Stm.GetTriangle( nT, Tria)) {
-         if ( CDeCylTria( frMyCyl, dR, dH, Tria, dSafeDist))
+         if ( CDeCylTria( frC, dR, dH, dSafeDist, Tria))
             return true ;
       }
    }
-  // Se il BBox del cilindro non è interno a quello del poliedro e viceversa, non c'è collisione
-   if ( ! b3Poly.Encloses( b3Cyl)  &&  ! b3Cyl.Encloses( b3Poly))
+  // Se superficie aperta, non c'è collisione
+   if ( ! Stm.IsClosed())
       return false ;
-  // Verifico se il cilindro è dentro la superficie tramite calcolo distanza minima del suo centro
-   Point3d ptCylCen( 0, 0, dH / 2) ;
-   ptCylCen.ToGlob( frMyCyl) ;
-   DistPointSurfTm DistCylCenSurfCalc( ptCylCen, Stm) ;
+  // Verifico se il cilindro è dentro la superficie tramite calcolo distanza minima.
+   Point3d ptCylOrig( 0., 0., - dSafeDist) ;
+   ptCylOrig.ToGlob( frC) ;
+   DistPointSurfTm DistCylOrigSurfCalc( ptCylOrig, Stm) ;
   // Se il cilindro è interno c'è collisione
-   return ( DistCylCenSurfCalc.IsPointInside()) ;
-}
-
-//----------------------------------------------------------------------------
-// Verifica l'interferenza tra il cilindro e la superficie : restituisce true in caso di interferenza
-//----------------------------------------------------------------------------
-bool
-TestCylSurfTm( const Frame3d& frCyl, double dR, double dH, const ISurfTriMesh& Stm, double dSafeDist)
-{
-  // Il cilindro deve essere ben definito
-   if ( dR < EPS_SMALL  ||  dH < EPS_SMALL)
-      return true ;
-  // Se superficie non valida, non ha senso proseguire
-   if ( ! Stm.IsValid())
-      return true ;
-  // Recupero BBox della superficie poligonale
-   BBox3d b3Poly = Stm.GetAllTriaBox() ;
-  // Sistemazioni cilindro
-   Frame3d frMyCyl = frCyl ;
-   if ( dH < 0) {
-      frMyCyl.Translate( dH * frMyCyl.VersZ()) ;
-      dH = -dH ;
-   }
-  // Calcolo il BBox del cilindro
-   BBox3d b3CylL( Point3d( -dR, -dR, 0),
-                  Point3d(  dR,  dR, dH)) ;
-   if ( dSafeDist > EPS_SMALL)
-      b3CylL.Expand( dSafeDist) ;
-   BBox3d b3Cyl = GetToGlob( b3CylL, frMyCyl) ;
-  // Se i BBox non interferiscono, non c'è interferenza
-   if ( ! b3Poly.Overlaps( b3Cyl)  ||  ! b3Poly.Overlaps( frMyCyl, b3CylL))
-      return false ;
-  // Verifico se il cilindro interferisce con i triangoli del poliedro presenti nel suo BBox
-   INTVECTOR vT ;
-   Stm.GetAllTriaOverlapBox( b3Cyl, vT) ;
-   for ( int nT : vT) {
-      Triangle3d Tria ;
-      if ( Stm.GetTriangle( nT, Tria)) {
-         if ( CDeCylTria( frMyCyl, dR, dH, Tria, dSafeDist))
-            return true ;
-      }
-   }
-  // Non c'è interferenza
-   return false ;
+   return ( DistCylOrigSurfCalc.IsPointInside()) ;
 }

CDeCylTria.cpp

@@ -13,9 +13,9 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
+#include "DistPointLine.h"
 #include "CDeCylTria.h"
 #include "CDeConvexTorusTria.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkPolygon3d.h"
 
 using namespace std ;
@@ -84,7 +84,7 @@ CDeSimpleCylTria( const Frame3d& frCyl, double dR, double dH, const Triangle3d&
 
 //----------------------------------------------------------------------------
 bool
-CDeCylTria( const Frame3d& frCyl, double dR, double dH, const Triangle3d& trTria, double dSafeDist)
+CDeCylTria( const Frame3d& frCyl, double dR, double dH, double dSafeDist, const Triangle3d& trTria)
 {
   // Se distanza di sicurezza nulla
    if ( dSafeDist < EPS_SMALL)

CDeCylTria.h

@@ -16,4 +16,4 @@
 
 //----------------------------------------------------------------------------
 bool CDeSimpleCylTria( const Frame3d& frCyl, double dR, double dH, const Triangle3d& trTria) ;
-bool CDeCylTria( const Frame3d& frCyl, double dR, double dH, const Triangle3d& trTria, double dSafeDist) ;
+bool CDeCylTria( const Frame3d& frCyl, double dR, double dH, double dSafeDist, const Triangle3d& trTria) ;

CDeRectPrismoidClosedSurfTm.cpp

@@ -1,12 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : CDeRectPrismoidClosedSurfTm.h    Data : 24.03.24  Versione : 2.6c2
+// File : CDePyramidClosedSurfTm.h      Data : 09.11.20    Versione : 
 // Contenuto : Implementazione funzione verifica collisione tra
 //             Prismoide a basi rettangolari e Closed SurfTriMesh.
 //
 // Modifiche : 09.11.20 LM Creazione modulo.
-//             24.03.24 DS Aggiunta TestRectPrismoidSurfTm.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -22,100 +22,49 @@ using namespace std ;
 // Il sistema di riferimento deve avere l'origine nel centro della Base, asse X lungo
 // un segmento della stessa e asse Z ortogonale alle basi e diretta verso la base Top.
 // Il sistema di riferimento della piramide deve essere immerso in quello della superficie.
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - false in caso di assenza di collisione.
-//----------------------------------------------------------------------------
 bool
 CDeRectPrismoidClosedSurfTm( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
                              double dLenghtTopX, double dLenghtTopY, double dHeight,
-                             const ISurfTriMesh& Stm, double dSafeDist)
+                             double dSafeDist, const ISurfTriMesh& Stm)
 {
-  // Se il tronco di piramide non è definito non ha senso proseguire.
+  // Se il tronco di piramide non è definito o la superficie non ben definita non ha senso proseguire.
    if ( max( dLenghtBaseX, dLenghtTopX) < EPS_SMALL  ||
         max( dLenghtBaseY, dLenghtTopY) < EPS_SMALL  ||
-        dHeight < EPS_SMALL)
-      return true ;
-  // Se superficie non valida o aperta, non ha senso proseguire
-   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
-      return true ;
+        dHeight < EPS_SMALL  ||  ! Stm.IsValid())
+      return false ;
   // Recupero BBox della trimesh
    BBox3d b3Surf = Stm.GetAllTriaBox() ;
   // Calcolo il BBox del tronco di piramide
    double dMaxLenX = max( dLenghtBaseX, dLenghtTopX) ;
    double dMaxLenY = max( dLenghtBaseY, dLenghtTopY) ;
-   BBox3d b3PyrL( Point3d( -dMaxLenX / 2, -dMaxLenY / 2, 0.),
-                  Point3d(  dMaxLenX / 2,  dMaxLenY / 2, dHeight)) ;
-   if ( dSafeDist > EPS_SMALL)
-      b3PyrL.Expand( dSafeDist) ;
-   BBox3d b3Pyr = GetToGlob( b3PyrL, frPrismoid) ;
+   BBox3d b3Pyr( -dMaxLenX / 2, -dMaxLenY / 2, 0., dMaxLenX / 2, dMaxLenY / 2, dHeight) ;
+  // Se la distanza di sicurezza è maggiore di epsilon aumento le dimensioni del tronco di piramide.
+   if ( dSafeDist > EPS_SMALL) {
+      b3Pyr.Expand( dSafeDist) ;
+   }
+  // Porto BBox del tronco di piramide nel sistema della superficie.
+   b3Pyr.ToGlob( frPrismoid) ;
   // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Surf.Overlaps( b3Pyr)  ||  ! b3Surf.Overlaps( frPrismoid, b3PyrL))
+   if ( ! b3Pyr.Overlaps( b3Surf))
       return false ;
   // Recupero i triangoli che interferiscono con il box del tronco di piramide.
    INTVECTOR vT ;
    Stm.GetAllTriaOverlapBox( b3Pyr, vT) ;
-  // Verifico se il tronco di piramide interferisce con i triangoli del poliedro presenti nel suo BBox
+  // Ciclo sui triangoli che interferiscono col box del tronco di piramide.
    for ( int nT : vT) {
       Triangle3d trTria ; 
       if ( Stm.GetTriangle( nT, trTria)) {
          if ( CDeRectPrismoidTria( frPrismoid, dLenghtBaseX, dLenghtBaseY, dLenghtTopX, dLenghtTopY, dHeight,
-                                    trTria, dSafeDist))
+                                   dSafeDist, trTria))
             return true ;
       }
    }
-  // Se il BBox del tronco di piramide non è interno a quello del poliedro e viceversa, non c'è collisione
-   if ( ! b3Surf.Encloses( b3Pyr)  &&  ! b3Pyr.Encloses( b3Surf))
+  // Se superficie aperta, non c'è collisione
+   if ( ! Stm.IsClosed())
       return false ;
-  // Verifico se il tronco di piramide è dentro la superficie tramite calcolo distanza minima del suo centro
-   Point3d ptPyrCen( 0, 0, dHeight / 2) ;
-   ptPyrCen.ToGlob( frPrismoid) ;
-   DistPointSurfTm DistPyrCenSurfCalc( ptPyrCen, Stm) ;
-  // C'è collisione se il tronco di piramide è interno
-   return ( DistPyrCenSurfCalc.IsPointInside()) ;
-}
-
-//----------------------------------------------------------------------------
-// Verifica l'interferenza tra il Prismoide a basi rettangolari e la superficie : restituisce true in caso di interferenza.
-//----------------------------------------------------------------------------
-bool
-TestRectPrismoidSurfTm( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
-                        double dLenghtTopX, double dLenghtTopY, double dHeight,
-                        const ISurfTriMesh& Stm, double dSafeDist)
-{
-  // Se il tronco di piramide non è definito non ha senso proseguire.
-   if ( max( dLenghtBaseX, dLenghtTopX) < EPS_SMALL  ||
-        max( dLenghtBaseY, dLenghtTopY) < EPS_SMALL  ||
-        dHeight < EPS_SMALL)
-      return true ;
-  // Se superficie non valida, non ha senso proseguire
-   if ( ! Stm.IsValid())
-      return true ;
-  // Recupero BBox della trimesh
-   BBox3d b3Surf = Stm.GetAllTriaBox() ;
-  // Calcolo il BBox del tronco di piramide
-   double dMaxLenX = max( dLenghtBaseX, dLenghtTopX) ;
-   double dMaxLenY = max( dLenghtBaseY, dLenghtTopY) ;
-   BBox3d b3PyrL( Point3d( -dMaxLenX / 2, -dMaxLenY / 2, 0.),
-                  Point3d(  dMaxLenX / 2,  dMaxLenY / 2, dHeight)) ;
-   if ( dSafeDist > EPS_SMALL)
-      b3PyrL.Expand( dSafeDist) ;
-   BBox3d b3Pyr = GetToGlob( b3PyrL, frPrismoid) ;
-  // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Surf.Overlaps( b3Pyr)  ||  ! b3Surf.Overlaps( frPrismoid, b3PyrL))
-      return false ;
-  // Recupero i triangoli che interferiscono con il box del tronco di piramide.
-   INTVECTOR vT ;
-   Stm.GetAllTriaOverlapBox( b3Pyr, vT) ;
-  // Verifico se il tronco di piramide interferisce con i triangoli del poliedro presenti nel suo BBox
-   for ( int nT : vT) {
-      Triangle3d trTria ; 
-      if ( Stm.GetTriangle( nT, trTria)) {
-         if ( CDeRectPrismoidTria( frPrismoid, dLenghtBaseX, dLenghtBaseY, dLenghtTopX, dLenghtTopY, dHeight,
-                                    trTria, dSafeDist))
-            return true ;
-      }
-   }
-  // Non c'è interferenza
-   return false ;
+  // Verifico se il tronco di piramide è dentro la superficie tramite calcolo distanza minima.
+   Point3d ptPyrOrig = frPrismoid.Orig() ;
+   DistPointSurfTm DistBoxOrigSurfCalc( ptPyrOrig, Stm) ;
+   // C'è collisione se il tronco di piramide è interno.
+   return ( DistBoxOrigSurfCalc.IsPointInside()) ;
 }

CDeRectPrismoidTria.cpp

@@ -14,7 +14,6 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CDeRectPrismoidTria.h"
-#include "CDeCapsTria.h"
 #include "CDeBoxTria.h"
 #include "CDeCylTria.h"
 #include "CDeSpheTria.h"
@@ -134,7 +133,7 @@ CDeSimpleRectPrismoidTria( const Frame3d& frPrismoid, double dLenghtBaseX, doubl
 bool
 CDeRectPrismoidTria( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
                      double dLenghtTopX, double dLenghtTopY, double dHeight,
-                     const Triangle3d& trTria, double dSafeDist)
+                     double dSafeDist, const Triangle3d& trTria)
 {
   // Se il tronco di piramide o il triangolo non sono ben definiti non procedo
    if ( max( dLenghtBaseX, dLenghtTopX) < EPS_SMALL  ||
@@ -142,13 +141,9 @@ CDeRectPrismoidTria( const Frame3d& frPrismoid, double dLenghtBaseX, double dLen
         dHeight < EPS_SMALL  ||  ! trTria.IsValid())
       return false ;
 
-  // Porto il triangolo nel riferimento del prismoide
-   Triangle3d trTriaL = trTria ;
-   trTriaL.ToLoc( frPrismoid) ;
-
   // Se distanza di sicurezza nulla
    if ( dSafeDist < EPS_SMALL)
-      return CDeSimpleRectPrismoidTria( Frame3d(), dLenghtBaseX, dLenghtBaseY, dLenghtTopX, dLenghtTopY, dHeight, trTriaL) ;
+      return CDeSimpleRectPrismoidTria( frPrismoid, dLenghtBaseX, dLenghtBaseY, dLenghtTopX, dLenghtTopY, dHeight, trTria) ;
    
   // Verifiche con offset esteso
    double dHDiffX = ( dLenghtBaseX - dLenghtTopX) / 2 ;
@@ -161,37 +156,37 @@ CDeRectPrismoidTria( const Frame3d& frPrismoid, double dLenghtBaseX, double dLen
    double dSecAy = sqrt( 1 + dTgAy * dTgAy) ;
    double dOffsBaseY = dSafeDist * ( dSecAy + dTgAy) ;
    double dOffsTopY = dSafeDist * ( dSecAy - dTgAy) ;
-   Frame3d frTmp( Point3d( 0, 0, -dSafeDist)) ;
-   if ( ! CDeSimpleRectPrismoidTria( frTmp, dLenghtBaseX + 2 * dOffsBaseX, dLenghtBaseY + 2 * dOffsBaseY,
-                                     dLenghtTopX + 2 * dOffsTopX, dLenghtTopY + 2 * dOffsTopY, dHeight + 2 * dSafeDist, trTriaL))
+   Frame3d frFrame = frPrismoid ; frFrame.Translate( - dSafeDist * frFrame.VersZ()) ;
+   if ( ! CDeSimpleRectPrismoidTria( frFrame, dLenghtBaseX + 2 * dOffsBaseX, dLenghtBaseY + 2 * dOffsBaseY,
+                                     dLenghtTopX + 2 * dOffsTopX, dLenghtTopY + 2 * dOffsTopY, dHeight + 2 * dSafeDist, trTria))
       return false ;
 
   // Offset fine
   // Box sotto
-   frTmp.ChangeOrig( Point3d( 0, 0, -dSafeDist)) ;
-   if ( CDeSimpleBoxTria( frTmp, Vector3d( dLenghtBaseX, dLenghtBaseY, dSafeDist), trTriaL))
+   frFrame = frPrismoid ; frFrame.Translate( - dSafeDist * frFrame.VersZ()) ;
+   if ( CDeSimpleBoxTria( frFrame, Vector3d( dLenghtBaseX, dLenghtBaseY, dSafeDist), trTria))
       return true ;
   // Box sopra
-   frTmp.ChangeOrig( Point3d( 0, 0, dHeight)) ;
-   if ( CDeSimpleBoxTria( frTmp, Vector3d( dLenghtTopX, dLenghtTopY, dSafeDist), trTriaL))
+   frFrame = frPrismoid ; frFrame.Translate( dHeight * frFrame.VersZ()) ;
+   if ( CDeSimpleBoxTria( frFrame, Vector3d( dLenghtTopX, dLenghtTopY, dSafeDist), trTria))
       return true ;
   // Prismoide allungato in X
    double dHypoX = sqrt( dHDiffX * dHDiffX + dHeight * dHeight) ;
    double dOffsX = dSafeDist * dHeight / dHypoX ;
    double dMoveXZ = dSafeDist * dHDiffX / dHypoX ;
-   frTmp.ChangeOrig( Point3d( 0, 0, dMoveXZ)) ;
-   if ( CDeSimpleRectPrismoidTria( frTmp, dLenghtBaseX + 2 * dOffsX, dLenghtBaseY,
-                                   dLenghtTopX + 2 * dOffsX, dLenghtTopY, dHeight, trTriaL))
+   frFrame = frPrismoid ; frFrame.Translate( dMoveXZ * frFrame.VersZ()) ;
+   if ( CDeSimpleRectPrismoidTria( frFrame, dLenghtBaseX + 2 * dOffsX, dLenghtBaseY,
+                                   dLenghtTopX + 2 * dOffsX, dLenghtTopY, dHeight, trTria))
       return true ;
   // Prismoide allungato in Y
    double dHypoY = sqrt( dHDiffY * dHDiffY + dHeight * dHeight) ;
    double dOffsY = dSafeDist * dHeight / dHypoY ;
    double dMoveYZ = dSafeDist * dHDiffY / dHypoY ;
-   frTmp.ChangeOrig( Point3d( 0, 0, dMoveYZ)) ;
-   if ( CDeSimpleRectPrismoidTria( frTmp, dLenghtBaseX, dLenghtBaseY + 2 * dOffsY,
-                                   dLenghtTopX, dLenghtTopY + 2 * dOffsY, dHeight, trTriaL))
+   frFrame = frPrismoid ; frFrame.Translate( dMoveYZ * frFrame.VersZ()) ;
+   if ( CDeSimpleRectPrismoidTria( frFrame, dLenghtBaseX, dLenghtBaseY + 2 * dOffsY,
+                                   dLenghtTopX, dLenghtTopY + 2 * dOffsY, dHeight, trTria))
       return true ;
-  // Vertici
+  // Sfere centrate nei vertici
    double dHalfBaseX = dLenghtBaseX / 2 ;
    double dHalfBaseY = dLenghtBaseY / 2 ;
    double dHalfTopX = dLenghtTopX / 2 ;
@@ -204,30 +199,55 @@ CDeRectPrismoidTria( const Frame3d& frPrismoid, double dLenghtBaseX, double dLen
                        Point3d( dHalfTopX, -dHalfTopY, dHeight),
                        Point3d( dHalfTopX, dHalfTopY, dHeight),
                        Point3d( -dHalfTopX, dHalfTopY, dHeight)} ;
-  // Capsule centrati sui dodici spigoli
-   if ( CDeSimpleCapsTria( vVert[0], vVert[1], dSafeDist, trTriaL))
+   for ( auto& ptV : vVert) {
+      ptV.ToGlob( frPrismoid) ;
+      if ( CDeSimpleSpheTria( ptV, dSafeDist, trTria))
+         return true ;
+   }
+  // Cilindri con i segmenti come asse
+   frFrame.Set( vVert[0], frPrismoid.VersX()) ;
+   if ( CDeSimpleCylTria( frFrame, dSafeDist, dLenghtBaseX, trTria))
       return true ;
-   if ( CDeSimpleCapsTria( vVert[1], vVert[2], dSafeDist, trTriaL))
+   frFrame.Set( vVert[1], frPrismoid.VersY()) ;
+   if ( CDeSimpleCylTria( frFrame, dSafeDist, dLenghtBaseY, trTria))
       return true ;
-   if ( CDeSimpleCapsTria( vVert[2], vVert[3], dSafeDist, trTriaL))
+   frFrame.Set( vVert[2], -frPrismoid.VersX()) ;
+   if ( CDeSimpleCylTria( frFrame, dSafeDist, dLenghtBaseX, trTria))
       return true ;
-   if ( CDeSimpleCapsTria( vVert[3], vVert[0], dSafeDist, trTriaL))
+   frFrame.Set( vVert[3], -frPrismoid.VersY()) ;
+   if ( CDeSimpleCylTria( frFrame, dSafeDist, dLenghtBaseY, trTria))
       return true ;
-   if ( CDeSimpleCapsTria( vVert[4], vVert[5], dSafeDist, trTriaL))
+   frFrame.Set( vVert[4], frPrismoid.VersX()) ;
+   if (CDeSimpleCylTria( frFrame, dSafeDist, dLenghtTopX, trTria))
       return true ;
-   if ( CDeSimpleCapsTria( vVert[5], vVert[6], dSafeDist, trTriaL))
+   frFrame.Set( vVert[5], frPrismoid.VersY()) ;
+   if ( CDeSimpleCylTria( frFrame, dSafeDist, dLenghtTopY, trTria))
       return true ;
-   if ( CDeSimpleCapsTria( vVert[6], vVert[7], dSafeDist, trTriaL))
+   frFrame.Set( vVert[6], -frPrismoid.VersX()) ;
+   if ( CDeSimpleCylTria( frFrame, dSafeDist, dLenghtTopX, trTria))
       return true ;
-   if ( CDeSimpleCapsTria( vVert[7], vVert[4], dSafeDist, trTriaL))
+   frFrame.Set( vVert[7], -frPrismoid.VersY()) ;
+   if ( CDeSimpleCylTria( frFrame, dSafeDist, dLenghtTopY, trTria))
       return true ;
-   if ( CDeSimpleCapsTria( vVert[0], vVert[4], dSafeDist, trTriaL))
+   Vector3d vtSeg04 = vVert[4] - vVert[0] ;
+   double dLenSeg04 = vtSeg04.Len() ;
+   frFrame.Set( vVert[0], vtSeg04) ;
+   if ( CDeSimpleCylTria( frFrame, dSafeDist, dLenSeg04, trTria))
       return true ;
-   if ( CDeSimpleCapsTria( vVert[1], vVert[5], dSafeDist, trTriaL))
+   Vector3d vtSeg15 = vVert[5] - vVert[1] ;
+   double dLenSeg15 = vtSeg15.Len() ;
+   frFrame.Set( vVert[1], vtSeg15) ;
+   if ( CDeSimpleCylTria( frFrame, dSafeDist, dLenSeg15, trTria))
       return true ;
-   if ( CDeSimpleCapsTria( vVert[2], vVert[6], dSafeDist, trTriaL))
+   Vector3d vtSeg26 = vVert[6] - vVert[2] ;
+   double dLenSeg26 = vtSeg26.Len() ;
+   frFrame.Set( vVert[2], vtSeg26) ;
+   if ( CDeSimpleCylTria( frFrame, dSafeDist, dLenSeg26, trTria))
       return true ;
-   if ( CDeSimpleCapsTria( vVert[3], vVert[7], dSafeDist, trTriaL))
+   Vector3d vtSeg37 = vVert[7] - vVert[3] ;
+   double dLenSeg37 = vtSeg37.Len();
+   frFrame.Set( vVert[3], vtSeg37) ;
+   if ( CDeSimpleCylTria( frFrame, dSafeDist, dLenSeg37, trTria))
       return true ;
 
    return false ;

CDeRectPrismoidTria.h

@@ -26,4 +26,4 @@ bool CDeSimpleRectPrismoidTria( const Frame3d& frPrismoid, double dLenghtBaseX,
 // asse X lungo un lato della stessa e asse Z ortogonale alle basi e diretta verso la base Top.
 bool CDeRectPrismoidTria( const Frame3d& frPrismoid, double dLenghtBaseX, double dLenghtBaseY,
                           double dLenghtTopX, double dLenghtTopY, double dHeight,
-                          const Triangle3d& trTria, double dSafeDist) ;
+                          double dSafeDist, const Triangle3d& trTria) ;

CDeSpheClosedSurfTm.cpp

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : CDCylSurfTm.cpp      Data : 24.03.24        Versione : 2.6c2
+// File : CDCylSurfTm.cpp      Data : 09.01.20        Versione : 2.2a2
 // Contenuto : Implementazione della verifica di collisione tra
 //             Sphere e Closed SurftriMesh.
 //
 //
 // Modifiche : 09.01.20 DS Creazione modulo.
-//             24.03.24 DS Aggiunta TestSpheSurfTm.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -19,79 +19,33 @@
 
 using namespace std ;
 
-//----------------------------------------------------------------------------
-// La funzione restituisce :
-// - true in caso di collisione o inconsistenza dei parametri di input
-// - false in caso di assenza di collisione.
 //----------------------------------------------------------------------------
 bool
-CDeSpheClosedSurfTm( const Point3d& ptCen, double dR, const ISurfTriMesh& Stm, double dSafeDist)
+CDeSpheClosedSurfTm( const Point3d& ptCen, double dR, double dSafeDist, const ISurfTriMesh& Stm)
 {
-  // Il raggio deve essere non nullo
-   if ( dR < EPS_SMALL)
-      return true ;
-  // Se superficie non valida o aperta, non ha senso proseguire
-   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
-      return true ;
-  // Recupero BBox del poliedro
+  // recupero BBox del poliedro
    BBox3d b3Poly = Stm.GetAllTriaBox() ;
-  // Calcolo il BBox della sfera
+  // calcolo il BBox della sfera
    BBox3d b3Sphe( ptCen, dR) ;
-   if ( dSafeDist > EPS_SMALL)
-      b3Sphe.Expand( dSafeDist) ;
-  // Se i BBox non interferiscono, non c'è collisione
+   b3Sphe.Expand( dSafeDist) ;
+  // confronto i due Box
    if ( ! b3Sphe.Overlaps( b3Poly))
       return false ;
-  // Verifico se la sfera interferisce con i triangoli del poliedro presenti nel suo BBox
+  // recupero i triangoli che interferiscono con il box della Sfera
    INTVECTOR vT ;
    Stm.GetAllTriaOverlapBox( b3Sphe, vT) ;
    for ( int nT : vT) {
       Triangle3d Tria ;
       if ( Stm.GetTriangle( nT, Tria)) {
-         if ( CDeSpheTria( ptCen, dR, Tria, dSafeDist))
+         if ( CDeSpheTria( ptCen, dR, dSafeDist, Tria))
             return true ;
       }
    }
-  // Se il BBox della sfera non è interno a quello del poliedro e viceversa, non c'è collisione
-   if ( ! b3Sphe.Encloses( b3Poly)  &&  ! b3Poly.Encloses( b3Sphe))
+  // Se superficie aperta, non c'è collisione
+   if ( ! Stm.IsClosed())
       return false ;
-  // Verifico se la sfera è dentro la superficie tramite calcolo distanza minima del suo centro
+  // Verifico se la sfera è dentro la superficie tramite calcolo distanza minima.
    DistPointSurfTm DistCenSurfCalc( ptCen, Stm) ;
-  // C'è collisione se la sfera è interna.
+   // C'è collisione se la sfera è interna.
    return ( DistCenSurfCalc.IsPointInside()) ;
 }
-
-//----------------------------------------------------------------------------
-// Verifica l'interferenza tra la sfera e la superficie : restituisce true in caso di interferenza
-//----------------------------------------------------------------------------
-bool
-TestSpheSurfTm( const Point3d& ptCen, double dR, const ISurfTriMesh& Stm, double dSafeDist)
-{
-  // Il raggio deve essere non nullo
-   if ( dR < EPS_SMALL)
-      return true ;
-  // Se superficie non valida, non ha senso proseguire
-   if ( ! Stm.IsValid())
-      return true ;
-  // Recupero BBox del poliedro
-   BBox3d b3Poly = Stm.GetAllTriaBox() ;
-  // Calcolo il BBox della sfera
-   BBox3d b3Sphe( ptCen, dR) ;
-   if ( dSafeDist > EPS_SMALL)
-      b3Sphe.Expand( dSafeDist) ;
-  // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Sphe.Overlaps( b3Poly))
-      return false ;
-  // Verifico se la sfera interferisce con i triangoli del poliedro presenti nel suo BBox
-   INTVECTOR vT ;
-   Stm.GetAllTriaOverlapBox( b3Sphe, vT) ;
-   for ( int nT : vT) {
-      Triangle3d Tria ;
-      if ( Stm.GetTriangle( nT, Tria)) {
-         if ( CDeSpheTria( ptCen, dR, Tria, dSafeDist))
-            return true ;
-      }
-   }
-  // Non c'è interferenza
-   return false ;
-}

CDeSpheTria.cpp

@@ -31,7 +31,7 @@ CDeSimpleSpheTria( const Point3d& ptCen, double dR, const Triangle3d& trTria)
 
 //----------------------------------------------------------------------------
 bool
-CDeSpheTria( const Point3d& ptCen, double dR, const Triangle3d& trTria, double dSafeDist)
+CDeSpheTria( const Point3d& ptCen, double dR, double dSafeDist, const Triangle3d& trTria)
 {
    return CDeSimpleSpheTria( ptCen, dR + max( 0., dSafeDist), trTria) ;
 }

CDeSpheTria.h

@@ -16,4 +16,4 @@
 
 //----------------------------------------------------------------------------
 bool CDeSimpleSpheTria( const Point3d& ptCen, double dR, const Triangle3d& trTria) ;
-bool CDeSpheTria( const Point3d& ptCen, double dR, const Triangle3d& trTria, double dSafeDist) ;
+bool CDeSpheTria( const Point3d& ptCen, double dR, double dSafeDist, const Triangle3d& trTria) ;

CDeTriaTria.cpp

@@ -12,10 +12,11 @@
 //----------------------------------------------------------------------------
 
 #include "stdafx.h"
+#include "DistLineLine.h"
 #include "CDeTriaTria.h"
-#include "/EgtDev/Include/EGkDistLineLine.h"
 #include "/EgtDev/Include/EGkIntersPlanePlane.h"
 #include <array>
+#include <algorithm>
 
 using namespace std ;
 
@@ -33,7 +34,7 @@ GetTwoGreater( int nVal0, int nVal1, int nVal2, int& nFirstMaxPos, int& nSecondM
       }
       else {
          nFirstMaxPos = 2 ;
-         nSecondMaxPos = 0 ;
+         nSecondMaxPos = 1 ;
       }
    }
    else if ( nVal0 > nVal2) {
@@ -108,7 +109,7 @@ CDeTriaTria( const Triangle3d& trTriaA, const Triangle3d& trTriaB)
             DistLineLine LineLineDistCalc( ptStA, PtEnA, ptStB, PtEnB) ;
             double dSqSegSegDist ;
             LineLineDistCalc.GetSqDist( dSqSegSegDist) ;
-            if ( dSqSegSegDist < SQ_EPS_SMALL)
+            if ( dSqSegSegDist < EPS_SMALL * EPS_SMALL)
                return true ;
          }
       }
@@ -135,14 +136,14 @@ CDeTriaTria( const Triangle3d& trTriaA, const Triangle3d& trTriaB)
    vtSegFirstA /= dSegLenFirstA ;
    DistLineLine LineLineDistCalcFirstA( ptLineP, vtLineV, 100., trTriaA.GetP( nFirstMaxPosA), vtSegFirstA, dSegLenFirstA, false) ;
    double dIntParStA, dOtherParFirstA ;
-   LineLineDistCalcFirstA.GetPositionsAtMinDistPoints( dIntParStA, dOtherParFirstA) ;
+   LineLineDistCalcFirstA.GetParamsAtMinDistPoints( dIntParStA, dOtherParFirstA) ;
    // Limito la retta col secondo segmento trovato di A
    Vector3d vtSegSecondA = trTriaA.GetP( ( nSecondMaxPosA + 1) % 3) - trTriaA.GetP( nSecondMaxPosA) ;
    double dSegLenSecondA = vtSegSecondA.Len() ;
    vtSegSecondA /= dSegLenSecondA ;
    DistLineLine LineLineDistCalcSecondA( ptLineP, vtLineV, 100., trTriaA.GetP( nSecondMaxPosA), vtSegSecondA, dSegLenSecondA, false) ;
    double dIntParEnA, dOtherParSecondA ;
-   LineLineDistCalcSecondA.GetPositionsAtMinDistPoints( dIntParEnA, dOtherParSecondA) ;
+   LineLineDistCalcSecondA.GetParamsAtMinDistPoints( dIntParEnA, dOtherParSecondA) ;
    // Ordino i parametri lungo la retta di intersezione fra i piani
    if ( dIntParStA > dIntParEnA) {
       swap( dIntParStA, dIntParEnA) ;
@@ -162,14 +163,14 @@ CDeTriaTria( const Triangle3d& trTriaA, const Triangle3d& trTriaB)
    vtSegFirstB /= dSegLenFirstB ;
    DistLineLine LineLineDistCalcFirstB( ptLineP, vtLineV, 100., trTriaB.GetP( nFirstMaxPosB), vtSegFirstB, dSegLenFirstB, false) ;
    double dIntParStB, dOtherParFirstB ;
-   LineLineDistCalcFirstB.GetPositionsAtMinDistPoints( dIntParStB, dOtherParFirstB) ;
+   LineLineDistCalcFirstB.GetParamsAtMinDistPoints( dIntParStB, dOtherParFirstB) ;
    // Limito la retta col secondo segmento trovato di B
    Vector3d vtSegSecondB = trTriaB.GetP( ( nSecondMaxPosB + 1) % 3) - trTriaB.GetP( nSecondMaxPosB) ;
    double dSegLenSecondB = vtSegSecondB.Len() ;
    vtSegSecondB /= dSegLenSecondB ;
-   DistLineLine LineLineDistCalcSecondB( ptLineP, vtLineV, 100., trTriaB.GetP( nSecondMaxPosB), vtSegSecondB, dSegLenSecondB, false) ;
+   DistLineLine LineLineDistCalcSecondB( ptLineP, vtLineV, 100., trTriaB.GetP( nSecondMaxPosA), vtSegSecondB, dSegLenSecondB, false) ;
    double dIntParEnB, dOtherParSecondB ;
-   LineLineDistCalcSecondB.GetPositionsAtMinDistPoints( dIntParEnB, dOtherParSecondB) ;
+   LineLineDistCalcSecondB.GetParamsAtMinDistPoints( dIntParEnB, dOtherParSecondB) ;
    // Ordino i parametri lungo la retta di intersezione fra i piani
    if ( dIntParStB > dIntParEnB) {
       swap( dIntParStB, dIntParEnB) ;

CDeUtility.cpp

@@ -1,6 +1,6 @@
 #include "stdafx.h"
 #include "CDeUtility.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
+#include "DistPointLine.h"
 #include "/EgtDev/Include/ENkPolynomialRoots.h"
 
 using namespace std ;
@@ -368,4 +368,4 @@ ClampSegmentOutPlane( const Plane3d& plPlane, Point3d& ptSegP, const Vector3d& v
       dSegLen -= dIntersLen ;
    }
    return true ;
-}
+}

ChainCurves.cpp

@@ -2,7 +2,7 @@
 //  EgalTech 2013-2014
 //----------------------------------------------------------------------------
 // File : ChainCurves.cpp           Data : 20.07.14       Versione : 1.5g3
-// Contenuto : Implementazione della funzione ChainCurves, per creare una o più
+// Contenuto : Implementazione della funzione ChainCurves, per creare una o più
 //             curve composite a partire dalle curve date.
 //
 //
@@ -13,9 +13,9 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "/EgtDev/Include/EGkChainCurves.h"
-#include "/EgtDev/Include/EGkGeomDB.h"
-#include "/EgtDev/Include/EGkCurve.h"
+#include "/EgtDev/Include/EgkChainCurves.h"
+#include "/EgtDev/Include/EgkGeomDB.h"
+#include "/EgtDev/Include/EgkCurve.h"
 #include <algorithm>
 
 using namespace std ;
@@ -43,10 +43,10 @@ bool
 ChainCurves::AddCurve( int nId, const Point3d& ptStart, const Vector3d& vtStart,
                        const Point3d& ptEnd, const Vector3d& vtEnd)
 {
-  // verifico validità Id
+  // verifico validità Id
    if ( nId <= 0)
       return false ;
-  // verifico non sia già stata aggiunta la stessa entità
+  // verifico non sia già stata aggiunta la stessa entità
    if ( ! m_sCrvId.insert( nId).second)
       return true ;
   // inserisco i dati della curva nel vettore
@@ -68,7 +68,7 @@ ChainCurves::GetChainFromNear( const Point3d& ptStart, bool bHaltOnFork, INTVECT
    m_bIsFork = false ;
    m_vFork.clear() ;
 
-  // recupero l'entità più vicina al punto di start
+  // recupero l'entità più vicina al punto di start
    int nStart ;
    INTVECTOR vStart ;
    if ( ! m_PointGrid.FindNearest( ptStart, vStart)  ||
@@ -82,7 +82,7 @@ ChainCurves::GetChainFromNear( const Point3d& ptStart, bool bHaltOnFork, INTVECT
    // tolgo dal grid
    RemoveEntityFromGrid( nId) ;
 
-  // se devo fermarmi su biforcazione, verifico se sono già su vecchia biforcazione
+  // se devo fermarmi su biforcazione, verifico se sono già su vecchia biforcazione
    bool bSkip = false ;
    if ( bHaltOnFork) {
       auto iIter = GetForkPoint( m_vCrvData[nId].ptEnd) ;
@@ -93,7 +93,7 @@ ChainCurves::GetChainFromNear( const Point3d& ptStart, bool bHaltOnFork, INTVECT
       }
    }
 
-  // concateno dopo la fine dell'entità di partenza
+  // concateno dopo la fine dell'entità di partenza
    INTVECTOR vIdsAfter ;
    bool bClosed = false ;
    if ( ! bSkip  &&  ! GetChainFromPoint( m_vCrvData[nId].ptEnd, m_vCrvData[nId].vtEnd,
@@ -102,7 +102,7 @@ ChainCurves::GetChainFromNear( const Point3d& ptStart, bool bHaltOnFork, INTVECT
       return false ;
    }
 
-  // se devo fermarmi su biforcazione, verifico se sono già su vecchia biforcazione
+  // se devo fermarmi su biforcazione, verifico se sono già su vecchia biforcazione
    bool bRevSkip = false ;
    if ( bHaltOnFork) {
       auto iIter = GetForkPoint( m_vCrvData[nId].ptStart) ;
@@ -113,7 +113,7 @@ ChainCurves::GetChainFromNear( const Point3d& ptStart, bool bHaltOnFork, INTVECT
       }
    }
 
-  // se non ho già chiuso l'anello, concateno prima dell'inizio dell'entità di partenza
+  // se non ho già chiuso l'anello, concateno prima dell'inizio dell'entità di partenza
    INTVECTOR vIdsBefore ;
    if ( ! bClosed) {
       bool bRevClosed ;
@@ -258,7 +258,7 @@ ChainCurves::RemoveEntityFromGrid( int nId)
 bool
 ChainCurves::ChooseStart( const Point3d& ptStart, const INTVECTOR& vStart, int& nStart)
 {
-  // numero di entità candidate
+  // numero di entità candidate
    int nSize = int( vStart.size()) ;
 
   // se nessuna, errore
@@ -273,7 +273,7 @@ ChainCurves::ChooseStart( const Point3d& ptStart, const INTVECTOR& vStart, int&
 
   // altrimenti, cerco la migliore
    int nI = - 1 ;
-   double dDistMin = INFINITO ;
+   double dSqDistMin = SQ_INFINITO ;
    for ( int i = 0 ; i < nSize ; ++ i) {
      // recupero indice e verso
       int nId = abs( vStart[i]) - 1 ;
@@ -281,12 +281,9 @@ ChainCurves::ChooseStart( const Point3d& ptStart, const INTVECTOR& vStart, int&
      // calcolo un punto vicino all'estremo lungo la tangente
       Point3d ptNear = ( bEquiv ? m_vCrvData[nId].ptStart + m_vCrvData[nId].vtStart :
                                   m_vCrvData[nId].ptEnd - m_vCrvData[nId].vtEnd) ;
-      double dDist = Dist( ptStart, ptNear) ;
-      // tengo il segmento più vicino al punto
-      // favorendo eventualmente quello equiverso se entro EPS da un concorrente
-      if ( dDist < dDistMin - EPS_SMALL  ||
-         ((dDist < dDistMin + EPS_SMALL)  &&  bEquiv  &&  vStart[nI] < 0)) {
-         dDistMin = dDist ;
+      double dSqDist = SqDist( ptStart, ptNear) ;
+      if ( dSqDist < dSqDistMin) {
+         dSqDistMin = dSqDist ;
          nI = i ;
       }
    }
@@ -305,7 +302,7 @@ bool
 ChainCurves::ChooseNext( const Point3d& ptCurr, const Vector3d& vtCurr, const INTVECTOR& vNext, bool bHaltOnFork, int& nNext)
 {
    INTVECTOR vMyNext = vNext ;
-  // scarto quelle entità che sono più vicine all'altro estremo del più vicino
+  // scarto quelle entità che sono più vicine all'altro estremo del più vicino
    int nM = -1 ;
    Point3d ptRef ;
    double dSqMinDist = m_dToler * m_dToler ;
@@ -322,19 +319,19 @@ ChainCurves::ChooseNext( const Point3d& ptCurr, const Vector3d& vtCurr, const IN
       }
    }
    for ( int i = 0 ; i < int( vMyNext.size()) ; ++ i) {
-     // salto l'entità più vicina
+     // salto l'entità più vicina
       if ( i == nM)
          continue ;
      // recupero indice e verso
       int nId = abs( vMyNext[i]) - 1 ;
       bool bEquiv = ( vMyNext[i] > 0) ;
-     // verifico se più vicino al più vicino
+     // verifico se più vicino al più vicino
       double dCurrSqDist = SqDist( ptCurr, ( bEquiv ? m_vCrvData[nId].ptStart : m_vCrvData[nId].ptEnd)) ;
       double dRefSqDist = SqDist( ptRef, ( bEquiv ? m_vCrvData[nId].ptStart : m_vCrvData[nId].ptEnd)) ;
       if ( dRefSqDist < dCurrSqDist)
          vMyNext[i] = 0 ;
    }
-  // cerco la direzione più vicina
+  // cerco la direzione più vicina
    int nI = -1 ;
    int nF = 0 ;
    INTVECTOR vFork ;
@@ -346,7 +343,7 @@ ChainCurves::ChooseNext( const Point3d& ptCurr, const Vector3d& vtCurr, const IN
      // recupero indice e verso
       int nId = abs( vMyNext[i]) - 1 ;
       bool bEquiv = ( vMyNext[i] > 0) ;
-     // incremento contatore indice entità tra cui scegliere
+     // incremento contatore indice entità tra cui scegliere
       ++ nF ;
       vFork.push_back( vMyNext[i]) ;
      // se vietata inversione, salto se controverso
@@ -390,7 +387,7 @@ bool
 ChainCurves::ChoosePrev( const Point3d& ptCurr, const Vector3d& vtCurr, const INTVECTOR& vPrev, bool bHaltOnFork, int& nPrev)
 {
    INTVECTOR vMyPrev = vPrev ;
-  // scarto quelle entità che sono più vicine all'altro estremo del più vicino
+  // scarto quelle entità che sono più vicine all'altro estremo del più vicino
    int nM = -1 ;
    Point3d ptRef ;
    double dSqMinDist = m_dToler * m_dToler ;
@@ -407,19 +404,19 @@ ChainCurves::ChoosePrev( const Point3d& ptCurr, const Vector3d& vtCurr, const IN
       }
    }
    for ( int i = 0 ; i < int( vMyPrev.size()) ; ++ i) {
-     // salto l'entità più vicina
+     // salto l'entità più vicina
       if ( i == nM)
          continue ;
      // recupero indice e verso
       int nId = abs( vMyPrev[i]) - 1 ;
       bool bEquiv = ( vMyPrev[i] < 0) ;
-     // verifico se più vicino al più vicino
+     // verifico se più vicino al più vicino
       double dCurrSqDist = SqDist( ptCurr, ( bEquiv ? m_vCrvData[nId].ptEnd : m_vCrvData[nId].ptStart)) ;
       double dRefSqDist = SqDist( ptRef, ( bEquiv ? m_vCrvData[nId].ptEnd : m_vCrvData[nId].ptStart)) ;
       if ( dRefSqDist < dCurrSqDist)
          vMyPrev[i] = 0 ;
    }
-  // cerco la direzione più vicina
+  // cerco la direzione più vicina
    int nI = - 1 ;
    int nF = 0 ;
    double dProScaMax = - 1.1 ; 
@@ -431,7 +428,7 @@ ChainCurves::ChoosePrev( const Point3d& ptCurr, const Vector3d& vtCurr, const IN
      // recupero indice e verso
       int nId = abs( vMyPrev[i]) - 1 ;
       bool bEquiv = ( vMyPrev[i] < 0) ;
-     // incremento contatore indice entità tra cui scegliere
+     // incremento contatore indice entità tra cui scegliere
       ++ nF ;
       vFork.push_back( vMyPrev[i]) ;
      // se vietata inversione, salto se controverso

Circle2P.cpp

@@ -1,44 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2022-2022
-//----------------------------------------------------------------------------
-// File : Circle2P.cpp        Data : 18.08.22       Versione : 2.4h2
-// Contenuto : Implementazione funzioni per calcolo circonferenze per 2 punti
-//             diametrali.
-//
-//
-// Modifiche : 18.08.22 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "CurveArc.h"
-#include "/EgtDev/Include/EGkCircle2P.h"
-#include "/EgtDev/Include/EgtPointerOwner.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-ICurveArc*
-GetCircle2P( const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtN)
-{
-  // Verifico che i due punti siano distinti
-   if ( AreSamePointEpsilon( ptP1, ptP2, EPS_SMALL))
-      return nullptr ;
-  // verifico che la normale non sia allineata con i punti
-   Vector3d vtO = OrthoCompo( vtN, ptP2 - ptP1) ;
-   if ( ! vtO.Normalize())
-      return nullptr ;
-
-  // Creo l'oggetto arco
-   PtrOwner<CurveArc> pCrvArc( CreateBasicCurveArc()) ;
-   if ( IsNull( pCrvArc))
-      return nullptr ;
-
-  // Eseguo calcoli
-   if ( ! pCrvArc->SetCPAN( Media( ptP1, ptP2), ptP1, ANG_FULL, 0, vtO))
-      return nullptr ;
-
-   return Release( pCrvArc) ;
-}

CircleCenTgCurve.cpp

@@ -16,10 +16,10 @@
 #include "CurveBezier.h"
 #include "CurveComposite.h"
 #include "CreateCurveAux.h"
+#include "DistPointLine.h"
 #include "GeoConst.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
-#include "/EgtDev/Include/EGkCircleCenTgCurve.h"
-#include "/EgtDev/Include/EGkDistPointCurve.h"
+#include "/EgtDev/Include/EgkCircleCenTgCurve.h"
+#include "/EgtDev/Include/EgkDistPointCurve.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 using namespace std ;
@@ -239,7 +239,7 @@ GetCircleCenTgCompo( const Point3d& ptCen, const Vector3d& vtN, const CurveCompo
       double dSqDist = SqDist( ptNear, ptTg) ;
       if ( dSqDist < dMinSqDist) {
          dMinSqDist = dSqDist ;
-         pCrvArc.Set( pCrvAtmp) ;
+         pCrvArc.Set( Release( pCrvAtmp)) ;
          if ( pPtTg != nullptr)
             *pPtTg = ptTg ;
       }

Color.cpp

@@ -17,7 +17,7 @@
 #include "/EgtDev/Include/EGkColor.h"
 #include "/EgtDev/Include/EGkAngle.h"
 #include "/EgtDev/Include/EGnStringUtils.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
+#include "/EgtDev/Include/EGtNumUtils.h"
 #include <algorithm>
 
 using namespace std ;

CurveArc.cpp

@@ -22,12 +22,9 @@
 #include "GeoObjFactory.h"
 #include "NgeWriter.h"
 #include "NgeReader.h"
-#include "Voronoi.h"
 #include "/EgtDev/Include/EGkAngle.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
-#include "/EgtDev/Include/ENkPolynomialRoots.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include <new>
 
@@ -62,14 +59,13 @@ class ArcApproxer
 //----------------------------------------------------------------------------
 CurveArc::CurveArc( void)
    : m_nStatus( TO_VERIFY), m_PtCen(), m_VtN(), m_VtS(), m_dRad(),
-     m_dAngCenDeg(), m_dDeltaN(), m_VtExtr(), m_dThick(), m_nTempProp{0,0}, m_dTempParam{0.0, 0.0}, m_pVoronoiObj( nullptr)
+     m_dAngCenDeg(), m_dDeltaN(), m_VtExtr(), m_dThick(), m_nTempProp()
 {
 }
 
 //----------------------------------------------------------------------------
 CurveArc::~CurveArc( void)
 {
-   ResetVoronoiObject() ;
 }
 
 //----------------------------------------------------------------------------
@@ -91,9 +87,7 @@ CurveArc::Set( const Point3d& ptCen, const Vector3d& vtN, double dRad,
   // sistemo i versori
    m_VtN.Normalize() ;
    m_VtS.Normalize() ;
-  
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -119,8 +113,6 @@ CurveArc::Set( const Point3d& ptCen, const Vector3d& vtN, double dRad)
    m_dDeltaN = 0 ;
    m_nStatus = TO_VERIFY ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -142,8 +134,6 @@ CurveArc::SetXY( const Point3d& ptCen, double dRad, double dAngIniDeg, double dA
    m_dDeltaN = dDeltaZ ;
    m_nStatus = TO_VERIFY ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -165,8 +155,6 @@ CurveArc::SetXY( const Point3d& ptCen, double dRad)
    m_dDeltaN = 0 ;
    m_nStatus = TO_VERIFY ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -189,7 +177,7 @@ CurveArc::Set3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d&
   // calcolo del versore normale
    m_VtN = vtA ^ vtB ;
    double dNSqLen = m_VtN.SqLen() ;
-   // se i punti sono praticamente allineati non si può calcolare la circonferenza
+   // se i punti sono praticamente allineati non si può calcolare la circonferenza
    if ( ! m_VtN.Normalize( EPS_ZERO))
       return false ;
   // calcolo del centro
@@ -216,21 +204,19 @@ CurveArc::Set3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d&
       if ( ! m_VtS.GetRotation( ( ptEnd - m_PtCen), m_VtN, dAng2Deg, bDet2)  ||  ! bDet2)
          return false ;
      // deduzione dell'angolo al centro
-      // se uno dei due angoli è nullo, errore
+      // se uno dei due angoli è nullo, errore
       if ( abs( dAng1Deg) < EPS_ANG_SMALL  ||  abs( dAng2Deg) < EPS_ANG_SMALL)
          return false ;
-      // se i due angoli hanno lo stesso segno e Ang1 è minore di Ang2 in modulo
+      // se i due angoli hanno lo stesso segno e Ang1 è minore di Ang2 in modulo
       else if ( dAng1Deg * dAng2Deg > 0  &&  abs( dAng1Deg) < abs( dAng2Deg))
          m_dAngCenDeg = dAng2Deg ;
-     // altrimenti hanno segno opposto oppure Ang1 è maggiore di Ang2 in modulo
+     // altrimenti hanno segno opposto oppure Ang1 è maggiore di Ang2 in modulo
       else
          m_dAngCenDeg = - _copysign( ANG_FULL, dAng2Deg) + dAng2Deg ;
    }
-  // non c'è DeltaN
+  // non c'è DeltaN
    m_dDeltaN = 0 ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -255,7 +241,7 @@ CurveArc::Set2PNB( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& v
    Vector3d vtDiff = ptFin - ptIni ;
    if ( vtDiff.IsSmall())
       return false ;
-  // deltaN eventuale ( è componente parallela a VtN)
+  // deltaN eventuale ( è componente parallela a VtN)
    m_dDeltaN = vtDiff * m_VtN ;
    vtDiff -= m_dDeltaN * m_VtN ;
    if ( abs( m_dDeltaN) < EPS_SMALL)
@@ -278,8 +264,6 @@ CurveArc::Set2PNB( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& v
   // calcolo l'angolo al centro
    m_dAngCenDeg = 4 * atan( dBulge) * RADTODEG ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -304,7 +288,7 @@ CurveArc::Set2PD( const Point3d& ptStart, const Point3d& ptEnd, double dDirStart
   // calcolo del versore normale
    m_VtN = vtA ^ vtB ;
    double dNSqLen = m_VtN.SqLen() ;
-   // se tangente e punti sono praticamente allineati non si può calcolare la circonferenza
+   // se tangente e punti sono praticamente allineati non si può calcolare la circonferenza
    if ( ! m_VtN.Normalize( EPS_ZERO))
       return false ;
   // calcolo del centro
@@ -321,7 +305,7 @@ CurveArc::Set2PD( const Point3d& ptStart, const Point3d& ptEnd, double dDirStart
    double dAng1Deg ;
    if ( ! m_VtS.GetRotation( ( ptEnd - m_PtCen), m_VtN, dAng1Deg, bDet1)  ||  ! bDet1)
       return false ;
-   // poichè il senso di rotazione è sempre CCW, se l'angolo è negativo prendo il suo complemento al giro
+   // poichè il senso di rotazione è sempre CCW, se l'angolo è negativo prendo il suo complemento al giro
     if ( dAng1Deg < 0)
        m_dAngCenDeg = ANG_FULL + dAng1Deg ;
     else
@@ -336,8 +320,6 @@ CurveArc::Set2PD( const Point3d& ptStart, const Point3d& ptEnd, double dDirStart
       m_dDeltaN = - m_dDeltaN ;
    }
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -398,7 +380,7 @@ CurveArc::Set2PRS( const Point3d& ptStart, const Point3d& ptEnd, double dRad, bo
    if ( dLenA > ( dRad - EPS_ZERO))
       dLenH = 0 ;
    else
-      dLenH = sqrt( dRad * dRad - dLenA * dLenA) ;
+      dLenH= sqrt( dRad * dRad - dLenA * dLenA) ;
   // versore dal punto medio della corda al centro
    Vector3d vtH = vtA / dLenA ;
    vtH.Rotate( Z_AX, 0, ( bCCW ? 1 : -1)) ;
@@ -410,19 +392,16 @@ CurveArc::Set2PRS( const Point3d& ptStart, const Point3d& ptEnd, double dRad, bo
    m_dRad = dRad ;
   // calcolo il versore di start
    m_VtS = ( ptStart - m_PtCen) / m_dRad ;
-   m_VtS.Normalize() ;
   // calcolo l'angolo al centro
    bool bDet ;
    if ( ! m_VtS.GetRotation( ( ptEnd - m_PtCen), m_VtN, m_dAngCenDeg, bDet)  ||  ! bDet)
       return false ;
-   // quando è 180deg il segno è determinato solo dal senso
+   // quando è 180deg il segno è determinato solo dal senso
    if ( abs( m_dAngCenDeg - ANG_STRAIGHT) < 10 * EPS_ANG_SMALL  &&
         ( ( bCCW  &&  m_dAngCenDeg < 0)  ||
           ( ! bCCW  &&  m_dAngCenDeg > 0)))
       m_dAngCenDeg = - m_dAngCenDeg ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -477,8 +456,6 @@ CurveArc::SetCPA( const Point3d& ptCen, const Point3d& ptStart, double dAngCenDe
   // assegno l'angolo al centro
    m_dAngCenDeg = dAngCenDeg ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -530,12 +507,11 @@ CurveArc::SetC2P( const Point3d& ptCen, const Point3d& ptStart, const Point3d& p
    if ( m_dRad < EPS_ZERO)
       return false ;
    m_VtS /= m_dRad ;
-  // calcolo l'angolo al centro (la funzione trova sempre il più piccolo)
+  // calcolo l'angolo al centro (la funzione trova sempre il più piccolo)
    bool bDet ;
    if ( ! m_VtS.GetRotation( ( ptNearEnd - m_PtCen), m_VtN, m_dAngCenDeg, bDet)  ||  ! bDet)
       return false ;
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -588,7 +564,7 @@ CurveArc::Clone( void) const
 bool
 CurveArc::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const CurveArc* pCA = GetBasicCurveArc( pGObjSrc) ;
+   const CurveArc* pCA = dynamic_cast<const CurveArc*>( pGObjSrc) ;
    if ( pCA == nullptr)
       return false ;
    return CopyFrom( *pCA) ;
@@ -602,10 +578,7 @@ CurveArc::CopyFrom( const CurveArc& caSrc)
       return true ;
    m_VtExtr = caSrc.m_VtExtr ;
    m_dThick = caSrc.m_dThick ;
-   m_nTempProp[0] = caSrc.m_nTempProp[0] ;
-   m_nTempProp[1] = caSrc.m_nTempProp[1] ;
-   m_dTempParam[0] = caSrc.m_dTempParam[0] ;
-   m_dTempParam[1] = caSrc.m_dTempParam[1] ;
+   m_nTempProp = caSrc.m_nTempProp ;
    return Set( caSrc.m_PtCen, caSrc.m_VtN, caSrc.m_dRad,
                caSrc.m_VtS, caSrc.m_dAngCenDeg, caSrc.m_dDeltaN) ;
 }
@@ -723,8 +696,29 @@ CurveArc::Load( NgeReader& ngeIn)
 bool
 CurveArc::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
 {
-  // richiamo della funzione generale
-   return GetBBox( GLOB_FRM, b3Loc, nFlag) ;
+  // verifico lo stato
+   if ( m_nStatus != OK)
+      return false ;
+  // assegno il box in locale
+   b3Loc.Reset() ;
+   double dLinTol = LIN_TOL_APPROX ;
+   double dAngTolDeg = ANG_TOL_APPROX_DEG ;
+   if ( ( nFlag & BBF_EXACT) != 0)
+      dLinTol = LIN_TOL_MIN ;
+   ArcApproxer aAppr( dLinTol, dAngTolDeg, false, *this) ;
+   double  dU ;
+   Point3d ptPos ;
+   while ( aAppr.GetPoint( dU, ptPos))
+      b3Loc.Add( ptPos) ;
+  // se c'è estrusione, devo tenerne conto
+   if ( ! m_VtExtr.IsSmall()  &&  abs( m_dThick) > EPS_SMALL) {
+      Point3d ptMinExtr = b3Loc.GetMin() + m_VtExtr * m_dThick ;
+      Point3d ptMaxExtr = b3Loc.GetMax() + m_VtExtr * m_dThick ;
+      b3Loc.Add( ptMinExtr) ;
+      b3Loc.Add( ptMaxExtr) ;
+   } 
+
+   return true ;
 }
 
 //----------------------------------------------------------------------------
@@ -734,94 +728,23 @@ CurveArc::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
   // assegno il box nel riferimento
    b3Ref.Reset() ;
-
-  // ricavo il riferimento intrinseco dell'arco
-   Frame3d frArc;
-   frArc.Set( m_PtCen, ( m_dAngCenDeg > 0 ? m_VtN : -m_VtN), m_VtS) ;
-
-  // pendenza intrinseca
-   double dPitch = m_dDeltaN * ( m_dAngCenDeg > 0 ? 1 : -1) / abs( m_dAngCenDeg * DEGTORAD) ;
-
-  // cordinate nel frRef dei versori del sistema di riferimento dell'arco
-   Vector3d vtXRef = frArc.VersX() ;
-   vtXRef.ToGlob( frRef) ;
-   Vector3d vtYRef = frArc.VersY() ;
-   vtYRef.ToGlob( frRef) ;
-   Vector3d vtZRef = frArc.VersZ() ;
-   vtZRef.ToGlob( frRef) ;
-
-  // il punto iniziale e finale sono punti candidati per estremanti
-   Point3d ptS, ptE ;
-   GetStartPoint( ptS) ;
-   ptS.ToGlob( frRef) ;
-   b3Ref.Add( ptS) ;
-   GetEndPoint( ptE) ;
-   ptE.ToGlob( frRef) ;
-   b3Ref.Add( ptE) ;
-
-  // vettore degli angoli dei punti candidati estremi
-   DBLVECTOR vdTheta ;
-
-   // arco piatto
-   if ( abs( dPitch) < EPS_SMALL) {
-      double dAngXDeg = atan2( vtYRef.x, vtXRef.x) * RADTODEG ;
-      bool bAngXSmall = (abs( dAngXDeg) <= EPS_ANG_ZERO) ;
-      if ( ! bAngXSmall) {
-         vdTheta.push_back( dAngXDeg) ;
-         vdTheta.push_back( dAngXDeg + ANG_STRAIGHT) ;
-      }
-      double dAngYDeg = atan2( vtYRef.y, vtXRef.y) * RADTODEG ;
-      bool bAngYSmall = (abs( dAngYDeg) <= EPS_ANG_ZERO) ;
-      if ( ! bAngYSmall) {
-         vdTheta.push_back( dAngYDeg) ;
-         vdTheta.push_back( dAngYDeg + ANG_STRAIGHT) ;
-      }
-      double dAngZDeg = atan2( vtYRef.z, vtXRef.z) * RADTODEG ;
-      bool bAngZSmall = (abs( dAngZDeg) <= EPS_ANG_ZERO) ;
-      if ( ! bAngZSmall) {
-         vdTheta.push_back( dAngZDeg) ;
-         vdTheta.push_back( dAngZDeg + ANG_STRAIGHT) ;
-      }
-      if ( bAngXSmall  ||  bAngYSmall  || bAngZSmall)
-         vdTheta.push_back( ANG_STRAIGHT) ;
+   double dLinTol = LIN_TOL_APPROX ;
+   double dAngTolDeg = ANG_TOL_APPROX_DEG ;
+   if ( ( nFlag & BBF_EXACT) != 0)
+      dLinTol = LIN_TOL_MIN ;
+   ArcApproxer aAppr( dLinTol, dAngTolDeg, false, *this) ;
+   double  dU ;
+   Point3d ptPos ;
+   while ( aAppr.GetPoint( dU, ptPos)) {
+      ptPos.ToGlob( frRef) ;
+      b3Ref.Add( ptPos) ;
    }
-  // altrimenti arco di elica
-   else {
-      for ( int i = 0 ; i < 3 ; ++ i) {
-         DBLVECTOR vdPoly{ m_dRad * vtYRef.v[i] + dPitch * vtZRef.v[i],
-                           - 2 * m_dRad * vtXRef.v[i],
-                           - m_dRad * vtYRef.v[i] + dPitch * vtZRef.v[i]} ;
-         DBLVECTOR vdRoot ;
-         int nRoot = PolynomialRoots( 2, vdPoly, vdRoot) ;
-         for ( int i = 0 ; i < nRoot ; ++ i) {
-            double dAngDeg = atan2( 2 * vdRoot[i], (1 - vdRoot[i] * vdRoot[i])) * RADTODEG ;
-            if ( abs( dAngDeg) > EPS_ANG_ZERO) {
-               vdTheta.push_back( dAngDeg) ;
-               vdTheta.push_back( dAngDeg + ANG_STRAIGHT) ;
-            }
-            else
-               vdTheta.push_back( ANG_STRAIGHT) ;
-         }
-      }
-   }
-
-  // verifica degli angoli sull'arco ed eventuale considerazione dei punti
-   for ( int i = 0 ; i < int( vdTheta.size()) ; ++ i) {
-      double dTheta = ( vdTheta[i] > 0 ? vdTheta[i] : vdTheta[i] + ANG_FULL) ;
-      if ( dTheta < abs( m_dAngCenDeg)) {
-         Point3d ptP ;
-         GetPointD1D2( dTheta / ( abs( m_dAngCenDeg)), FROM_MINUS, ptP) ;
-         ptP.ToGlob( frRef) ;
-         b3Ref.Add( ptP) ;
-      }
-   }
-   
-  // se c'è estrusione, devo tenerne conto
+  // se c'è estrusione, devo tenerne conto
    if ( ! m_VtExtr.IsSmall()  &&  abs( m_dThick) > EPS_SMALL) {
       Vector3d vtFrExtr = m_VtExtr ;
       vtFrExtr.ToGlob( frRef) ;
@@ -839,7 +762,7 @@ bool
 CurveArc::Validate( void)
 {
    if ( m_nStatus == TO_VERIFY) {
-     // limito l'angolo al centro a un giro se è piatto ( non è elica)
+     // limito l'angolo al centro a un giro se è piatto ( non è elica)
       if ( abs( m_dDeltaN) < EPS_SMALL) {
          if ( m_dAngCenDeg > ANG_FULL)
             m_dAngCenDeg = ANG_FULL ;
@@ -847,10 +770,10 @@ CurveArc::Validate( void)
             m_dAngCenDeg = - ANG_FULL ;
       }
      // eseguo il controllo
-      m_nStatus = ( ( m_PtCen.IsValid()  &&
-                      m_VtN.IsNormalized()  &&  m_VtS.IsNormalized()  &&  AreOrthoApprox( m_VtN, m_VtS)  &&
-                      m_dRad > EPS_SMALL  &&  m_dRad < MAX_ARC_RAD  &&
-                      abs( m_dAngCenDeg) > EPS_ANG_ZERO) ? OK : ERR) ;
+      m_nStatus = ( ( m_VtN.IsNormalized()  &&  m_VtS.IsNormalized()  &&
+                    AreOrthoApprox( m_VtN, m_VtS)  &&
+                    m_dRad > EPS_SMALL  &&  m_dRad < MAX_ARC_RAD  &&
+                    abs( m_dAngCenDeg) > EPS_ANG_ZERO) ? OK : ERR) ;
    }
 
    return ( m_nStatus == OK) ;
@@ -905,7 +828,7 @@ CurveArc::GetEndPoint( Point3d& ptEnd) const
    double dAng = m_dAngCenDeg * DEGTORAD ;
    Vector3d vtDir = cos( dAng) * m_VtS + sin( dAng) * ( m_VtN ^ m_VtS) ;
    ptEnd = m_PtCen + m_dRad * vtDir ;
-   if ( abs( m_dDeltaN) > 0.1 * EPS_SMALL)
+   if ( abs( m_dDeltaN) > EPS_SMALL)
       ptEnd += m_dDeltaN * m_VtN  ;
 
    return true ;
@@ -923,7 +846,7 @@ CurveArc::GetMidPoint( Point3d& ptMid) const
    double dAng = 0.5 * m_dAngCenDeg * DEGTORAD ;
    Vector3d vtDir = cos( dAng) * m_VtS + sin( dAng) * ( m_VtN ^ m_VtS) ;
    ptMid = m_PtCen + m_dRad * vtDir ;
-   if ( abs( m_dDeltaN) > 0.1 * EPS_SMALL)
+   if ( abs( m_dDeltaN) > EPS_SMALL)
       ptMid += ( 0.5 * m_dDeltaN) * m_VtN  ;
 
    return true ;
@@ -951,7 +874,7 @@ CurveArc::GetCentroid( Point3d& ptCen) const
       return false ;
   // approssimo la curva con una polilinea
    PolyLine PL ;
-   if ( ! ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, APL_STD, PL))
+   if ( ! ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
       return false ;
   // calcolo il centro mediante PolygonPlane
    Point3d ptP ;
@@ -973,14 +896,17 @@ CurveArc::GetDir( double dU, Vector3d& vtDir) const
       return false ;
 
   // il parametro U deve essere compreso tra 0 e 1
-   dU = Clamp( dU, 0., 1.) ;
+   if ( dU < 0)
+      dU = 0 ;
+   else if ( dU > 1)
+      dU = 1 ;
 
   // versore al punto  nel piano della circonferenza (ruoto m_VtS di dU * m_dAngCenDeg attorno a m_VtN)
    double dAng = dU * m_dAngCenDeg * DEGTORAD ;
    Vector3d vtRad = cos( dAng) * m_VtS + sin( dAng) * ( m_VtN ^ m_VtS) ;
   // calcolo della tangente nel punto finale
    vtDir = ( m_dRad * m_dAngCenDeg * DEGTORAD) * ( m_VtN ^ vtRad) ;
-   if ( abs( m_dDeltaN) > 0.1 * EPS_SMALL)
+   if ( abs( m_dDeltaN) > EPS_SMALL)
       vtDir += m_dDeltaN * m_VtN ;
   // normalizzo
    return vtDir.Normalize( EPS_ZERO) ;
@@ -995,7 +921,10 @@ CurveArc::GetPointD1D2( double dU, Side nS, Point3d& ptPos, Vector3d* pvtDer1, V
       return false ;
 
   // il parametro U deve essere compreso tra 0 e 1
-   dU = Clamp( dU, 0., 1.) ;
+   if ( dU < 0)
+      dU = 0 ;
+   else if ( dU > 1)
+      dU = 1 ;
 
   // versore al punto nel piano della circonferenza (ruoto m_VtS di dU di m_dAngCenDeg attorno a m_VtN)
    double dAng = dU * m_dAngCenDeg * DEGTORAD ;
@@ -1003,13 +932,13 @@ CurveArc::GetPointD1D2( double dU, Side nS, Point3d& ptPos, Vector3d* pvtDer1, V
 
   // calcolo del punto
    ptPos = m_PtCen + m_dRad * vtDir ;
-   if ( abs( m_dDeltaN) > 0.1 * EPS_SMALL)
+   if ( abs( m_dDeltaN) > EPS_SMALL)
       ptPos += ( dU * m_dDeltaN) * m_VtN  ;
 
   // calcolo della derivata prima
    if ( pvtDer1 != nullptr) {
       *pvtDer1 = ( m_dRad * m_dAngCenDeg * DEGTORAD) * ( m_VtN ^ vtDir) ;
-      if ( abs( m_dDeltaN) > 0.1 * EPS_SMALL)
+      if ( abs( m_dDeltaN) > EPS_SMALL)
          *pvtDer1 += m_dDeltaN * m_VtN ;
    }    
 
@@ -1031,7 +960,7 @@ CurveArc::GetLength( double& dLen) const
   // lunghezza dell'arco piano
    dLen = m_dRad * abs( m_dAngCenDeg) * DEGTORAD ;
   // aggiunta eventuale parte ortogonale
-   if ( abs( m_dDeltaN) > 0.1 * EPS_SMALL)
+   if ( abs( m_dDeltaN) > EPS_SMALL)
       dLen = sqrt( dLen * dLen + m_dDeltaN * m_dDeltaN) ;
 
    return ( dLen > EPS_SMALL) ;
@@ -1168,7 +1097,7 @@ CurveArc::ApproxWithLines( double dLinTol, double dAngTolDeg, int nType, PolyLin
          return false ;
    }
 
-  // se necessario, sistemo per convessità dalla parte ammessa
+  // se necessario, sistemo per convessità dalla parte ammessa
    if ( nType == APL_RIGHT_CONVEX  ||  nType == APL_LEFT_CONVEX) {
       if ( ! PL.MakeConvex( vtExtr, ( nType == APL_LEFT_CONVEX)))
          return false ;
@@ -1242,7 +1171,7 @@ CurveArc::CopyParamRange( double dUStart, double dUEnd) const
       return nullptr ;
   // se il parametro start supera quello di end
    if ( dUStart > dUEnd - EPS_PARAM) {
-     // se curva aperta, il trim la cancella completamente quindi non resta alcunchè
+     // se curva aperta, il trim la cancella completamente quindi non resta alcunchè
       if ( ! IsClosed())
          return nullptr ;
      // se curva chiusa, il trim si avvolge attorno al punto di giunzione
@@ -1272,7 +1201,7 @@ CurveArc::Invert( void)
       return false ;
 
   // il centro va spostato di DeltaN
-   if ( abs( m_dDeltaN) > 0.1 * EPS_SMALL)
+   if ( abs( m_dDeltaN) > EPS_SMALL)
       m_PtCen += m_dDeltaN * m_VtN ;
   // il versore normale rimane inalterato
   // il versore iniziale diventa quello finale
@@ -1283,9 +1212,7 @@ CurveArc::Invert( void)
    m_dAngCenDeg = - m_dAngCenDeg ;
   // l'incremento sulla normale inverte il segno
    m_dDeltaN = - m_dDeltaN ;
-   
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
+
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
   
@@ -1319,8 +1246,6 @@ CurveArc::SimpleOffset( double dDist, int nType)
   // aggiorno il raggio
    m_dRad = dNewRad ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -1332,7 +1257,7 @@ bool
 CurveArc::MyExtendedOffset( double dDist, bool bAll, int nType)
 {
   // bAll == true fa accettare raggi nulli ==> da usare solo internamente 
-  // quando si è sicuri di aumentare subito il raggio o di cancellare
+  // quando si è sicuri di aumentare subito il raggio o di cancellare
 
   // la curva deve essere validata
    if ( m_nStatus != OK)
@@ -1365,8 +1290,6 @@ CurveArc::MyExtendedOffset( double dDist, bool bAll, int nType)
   // aggiorno il raggio
    m_dRad = dNewRad ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -1410,7 +1333,7 @@ CurveArc::ModifyEnd( const Point3d& ptNewEnd)
    ptOldEndIntr.ToLoc( frIntr) ;
    Point3d ptEndIntr = ptNewEnd ;
    ptEndIntr.ToLoc( frIntr) ;
-  // se coincidono nel piano XY, è cambiato solo il deltaN
+  // se coincidono nel piano XY, è cambiato solo il deltaN
    if ( AreSamePointXYExact( ptOldEndIntr, ptEndIntr)) {
       m_dDeltaN += ptEndIntr.z - ptOldEndIntr.z ;
    }
@@ -1439,8 +1362,6 @@ CurveArc::ModifyEnd( const Point3d& ptNewEnd)
       m_dDeltaN = arcAux.m_dDeltaN ;
    }
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1451,11 +1372,13 @@ CurveArc::ModifyEnd( const Point3d& ptNewEnd)
 bool
 CurveArc::TrimStartAtParam( double dUTrim)
 {
+   double dLen ;
+
+
   // riporto i parametri nel loro range
-   dUTrim = Clamp( dUTrim, 0., 1.) ;
+   dUTrim = ( ( dUTrim < 0) ? 0 : (( dUTrim > 1) ? 1 : dUTrim)) ;
 
   // recupero lunghezza
-   double dLen ;
    if ( ! GetLength( dLen))
       return false ;
 
@@ -1467,11 +1390,13 @@ CurveArc::TrimStartAtParam( double dUTrim)
 bool
 CurveArc::TrimEndAtParam( double dUTrim)
 {
+   double dLen ;
+
+
   // riporto i parametri nel loro range
-   dUTrim = Clamp( dUTrim, 0., 1.) ;
+   dUTrim = ( ( dUTrim < 0) ? 0 : (( dUTrim > 1) ? 1 : dUTrim)) ;
 
   // recupero lunghezza
-   double dLen ;
    if ( ! GetLength( dLen))
       return false ;
 
@@ -1519,15 +1444,13 @@ CurveArc::TrimStartAtLen( double dLenTrim)
       dAngRot = m_dAngCenDeg * dLenTrim / dLen ;
       m_VtS.Rotate( m_VtN, dAngRot) ;
       m_dAngCenDeg -= dAngRot ;
-      if ( abs( m_dDeltaN) > 0.1 * EPS_SMALL) {
+      if ( abs( m_dDeltaN) > EPS_SMALL) {
          dMoveN = m_dDeltaN * dLenTrim / dLen ;
          m_PtCen.Translate( m_VtN * dMoveN) ;
          m_dDeltaN -= dMoveN ;
       }
    }
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -1551,12 +1474,10 @@ CurveArc::TrimEndAtLen( double dLenTrim)
   // eseguo il trim
    if ( ( dLen - dLenTrim) > EPS_ZERO) {
       m_dAngCenDeg *= dLenTrim / dLen ;
-      if ( abs( m_dDeltaN) > 0.1 * EPS_SMALL)
+      if ( abs( m_dDeltaN) > EPS_SMALL)
          m_dDeltaN *= dLenTrim / dLen ;
    }
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -1600,8 +1521,6 @@ CurveArc::ExtendEndByLen( double dLenExt)
    else if ( abs( m_dAngCenDeg) > ANG_FULL)
       m_dAngCenDeg = _copysign( ANG_FULL, m_dAngCenDeg) ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -1616,10 +1535,6 @@ CurveArc::Translate( const Vector3d& vtMove)
    if ( m_nStatus != OK)
       return false ;
 
-  // traslo Voronoi
-   if ( m_pVoronoiObj != nullptr)      
-      m_pVoronoiObj->Translate( vtMove) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1637,14 +1552,10 @@ CurveArc::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, dou
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità dell'asse di rotazione
+  // verifico validità dell'asse di rotazione
    if ( vtAx.IsSmall())
       return false ;
 
-  // ruoto Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1674,8 +1585,6 @@ CurveArc::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dC
      // verifico non sia nulla
       if ( abs( dCoeffX) < EPS_ZERO  ||  m_dRad * abs( dCoeffX) <= EPS_SMALL)
          return false ;
-     // imposto ricalcolo di Voronoi
-      ResetVoronoiObject() ;
      // imposto ricalcolo della grafica
       m_OGrMgr.Reset() ;
      // scalo il centro e le dimensioni lineari
@@ -1703,8 +1612,6 @@ CurveArc::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dC
      // verifico non sia nulla
       if ( abs( dCoeffY) < EPS_ZERO  ||  m_dRad * abs( dCoeffY) <= EPS_SMALL)
          return false ;
-     // imposto ricalcolo di Voronoi
-      ResetVoronoiObject() ;
      // imposto ricalcolo della grafica
       m_OGrMgr.Reset() ;
      // scalo il centro e le dimensioni lineari
@@ -1732,8 +1639,6 @@ CurveArc::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dC
      // verifico non sia nulla
       if ( abs( dCoeffZ) < EPS_ZERO  ||  m_dRad * abs( dCoeffZ) <= EPS_SMALL)
          return false ;
-     // imposto ricalcolo di Voronoi
-      ResetVoronoiObject() ;
      // imposto ricalcolo della grafica
       m_OGrMgr.Reset() ;
      // scalo il centro e le dimensioni lineari
@@ -1761,8 +1666,6 @@ CurveArc::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dC
      // verifico non sia nulla
       if ( abs( dCoeffX) < EPS_ZERO  ||  m_dRad * abs( dCoeffX) <= EPS_SMALL)
          return false ;
-     // imposto ricalcolo di Voronoi
-      ResetVoronoiObject() ;
      // imposto ricalcolo della grafica
       m_OGrMgr.Reset() ;
      // scalo il centro e le dimensioni lineari
@@ -1792,12 +1695,10 @@ CurveArc::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità del piano di specchiatura
+  // verifico validità del piano di specchiatura
    if ( vtNorm.IsSmall())
       return false ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1820,17 +1721,15 @@ CurveArc::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vt
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità dei parametri
+  // verifico validità dei parametri
    if ( vtNorm.IsSmall()  ||  vtDir.IsSmall())
       return false ;
 
-  // possibile solo se l'arco è piatto e il piano di scorrimento coincide con quello dell'arco
+  // possibile solo se l'arco è piatto e il piano di scorrimento coincide con quello dell'arco
    if ( ! ( abs( m_dDeltaN) < EPS_SMALL)  ||  
         ! AreSameOrOppositeVectorExact( m_VtN, vtNorm))
       return false ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1854,18 +1753,11 @@ CurveArc::ToGlob( const Frame3d& frRef)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
-   if ( IsGlobFrame( frRef))
-      return true ;
-
-  // trasformo Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->ToGlob( frRef) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1883,18 +1775,11 @@ CurveArc::ToLoc( const Frame3d& frRef)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
-   if ( IsGlobFrame( frRef))
-      return true ;
-
-  // trasformo Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->ToLoc( frRef) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1912,21 +1797,14 @@ CurveArc::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dei frame
+  // verifico validità dei frame
    if ( frOri.GetType() == Frame3d::ERR  ||  frDest.GetType() == Frame3d::ERR)
       return false ;
-
-  // se i due riferimenti coincidono, non devo fare alcunché
+  // se i due riferimenti coincidono, non devo fare alcunché
    if ( AreSameFrame( frOri, frDest))
       return true ;
-
-  // trasformo Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->LocToLoc( frOri, frDest) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
-
   // trasformo il centro e i versori
    return ( m_PtCen.LocToLoc( frOri, frDest)  &&
             m_VtN.LocToLoc( frOri, frDest)  &&
@@ -1947,8 +1825,6 @@ CurveArc::InvertN( void)
    m_dAngCenDeg = - m_dAngCenDeg ;
    m_dDeltaN = - m_dDeltaN ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2000,12 +1876,12 @@ CurveArc::MyCalcPointParamPosiz( const Point3d& ptP, double& dU, int& nPos, doub
   // verifica posizione punto su arco
    nPos = PP_NULL ;         // fuori
    if ( abs( DiffAngle( dAngDeg, 0) * DEGTORAD * m_dRad) < dLinTol) {
-      nPos = ( IsACircle() ? PP_MID : PP_START) ;   // se cerchio è interno, altrimenti vicino a inizio
+      nPos = ( IsACircle() ? PP_MID : PP_START) ;   // se cerchio è interno, altrimenti vicino a inizio
       dU = AngleNearAngle( dAngDeg, 0) / m_dAngCenDeg ;
       dU = max( dU, 0.) ;
    }
    else if ( abs( DiffAngle( dAngDeg, m_dAngCenDeg) * DEGTORAD * m_dRad) < dLinTol) {
-      nPos = ( IsACircle() ? PP_MID : PP_END) ;     // se cerchio è interno, altrimenti vicino a fine
+      nPos = ( IsACircle() ? PP_MID : PP_END) ;     // se cerchio è interno, altrimenti vicino a fine
       dU = AngleNearAngle( dAngDeg, m_dAngCenDeg) / m_dAngCenDeg ;
       dU = min( dU, 1.) ;
    }
@@ -2022,15 +1898,9 @@ CurveArc::ChangeRadius( double dNewRadius)
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità del raggio
-   if ( ! ( dNewRadius > EPS_SMALL  &&  dNewRadius < MAX_ARC_RAD))
-      return false ;
-  
   // cambio il raggio
    m_dRad = dNewRadius ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2050,8 +1920,6 @@ CurveArc::ChangeDeltaN( double dNewDeltaN)
   // cambio il parametro
    m_dDeltaN = dNewDeltaN ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2068,15 +1936,9 @@ CurveArc::ChangeAngCenter( double dNewAngCenDeg)
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico accettabilità angolo
-   if ( ! ( abs( m_dAngCenDeg) > EPS_ANG_ZERO))
-      return false ;
-
   // cambio il parametro
    m_dAngCenDeg = dNewAngCenDeg ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2101,8 +1963,6 @@ CurveArc::ChangeStartPoint( double dU)
    if ( ! vtDir.Normalize())
       return false ;
    m_VtS = vtDir ;
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
    return true ;
@@ -2122,8 +1982,6 @@ CurveArc::ToExplementary( void)
   // basta prendere l'angolo al centro che completa il giro
    m_dAngCenDeg = - _copysign( ANG_FULL, m_dAngCenDeg) + m_dAngCenDeg ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2153,8 +2011,6 @@ CurveArc::Flip( void)
    m_VtS.Normalize() ;
    m_dAngCenDeg = - m_dAngCenDeg ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2164,14 +2020,18 @@ CurveArc::Flip( void)
 
 //----------------------------------------------------------------------------
 // Oggetto locale per approssimazione di archi
-// Approx interna è quella cordale standard.
-// Approx esterna è quella tangente a inizio e fine con metà tratto e un punto in più.
+// Approx interna è quella cordale standard.
+// Approx esterna è quella tangente a inizio e fine con metà tratto e un punto in più.
 // I punti si calcolano a partire dal triangolo tra due punti consecutivi interni e il centro,
 // usando il versore medio dal centro e moltiplicandolo per il coefficiente ( 2 / ( 1 + cosA)).
-// Il versore dell'ultimo punto è già stato calcolato per il penultimo.
+// Il versore dell'ultimo punto è già stato calcolato per il penultimo.
 //----------------------------------------------------------------------------
 ArcApproxer::ArcApproxer( double dLinTol, double dAngTolDeg, bool bInside, const CurveArc& arArc)
 {
+   int nStep ;
+   double dAngStepDeg ;
+
+
   // inizializzazioni
    m_nTotPnt = 0 ;
    m_nCurrPnt = - 1 ;
@@ -2189,7 +2049,6 @@ ArcApproxer::ArcApproxer( double dLinTol, double dAngTolDeg, bool bInside, const
       dAngTolDeg = min( dAngTolDeg, ANG_TOL_EXT_MAX_DEG) ;
 
   // determinazione dello step angolare
-   double dAngStepDeg ;
    double dLinTolRel = dLinTol / arArc.GetRadius() ;
    if ( bInside)
       dAngStepDeg = sqrt( 8 * dLinTolRel) * RADTODEG ;
@@ -2198,7 +2057,7 @@ ArcApproxer::ArcApproxer( double dLinTol, double dAngTolDeg, bool bInside, const
    dAngStepDeg = min( dAngStepDeg, dAngTolDeg) ;
 
   // dall'angolo al centro ricavo il numero di passi
-   int nStep = int( abs( arArc.GetAngCenter()) / dAngStepDeg + 0.999) ;
+   nStep = (int) ( abs( arArc.GetAngCenter()) / dAngStepDeg + 0.999) ;
    nStep = max( nStep, 1) ;
 
   // sistemo lo step (per il numero intero di passi)
@@ -2225,6 +2084,10 @@ ArcApproxer::ArcApproxer( double dLinTol, double dAngTolDeg, bool bInside, const
 bool
 ArcApproxer::GetPoint( double& dU, Point3d& ptP)
 {
+   Vector3d vtA1p ;
+   Vector3d vtA2p ;
+
+
   // incremento indice punto corrente
    ++ m_nCurrPnt ;
 
@@ -2243,7 +2106,7 @@ ArcApproxer::GetPoint( double& dU, Point3d& ptP)
    if ( ! m_bInside  &&  m_nCurrPnt == m_nTotPnt - 1) {
       dU = 1 ;
       ptP = m_PtCen + m_vtA1 * m_dRad ;
-      if ( abs( m_dDeltaN) > 0.1 * EPS_SMALL)
+      if ( abs( m_dDeltaN) > EPS_SMALL)
          ptP += ( dU * m_dDeltaN) * m_VtN  ;
       return true ;
    } 
@@ -2255,8 +2118,8 @@ ArcApproxer::GetPoint( double& dU, Point3d& ptP)
    else
       dU = ( m_nCurrPnt - 0.5) / (double) ( m_nTotPnt - 2)  ;
    // nuovo valore versori
-   Vector3d vtA1p = m_vtA1 ;
-   Vector3d vtA2p = m_vtA2 ;
+   vtA1p = m_vtA1 ;
+   vtA2p = m_vtA2 ;
    m_vtA1 = m_dCosA * vtA1p + m_dSinA * vtA2p ;
    m_vtA2 = - m_dSinA * vtA1p + m_dCosA * vtA2p ;
    // calcolo del punto
@@ -2264,47 +2127,8 @@ ArcApproxer::GetPoint( double& dU, Point3d& ptP)
       ptP = m_PtCen + m_vtA1 * m_dRad ;
    else
       ptP = m_PtCen + ( vtA1p + m_vtA1) * ( m_dRad / ( 1 + m_dCosA)) ;
-   if ( abs( m_dDeltaN) > 0.1 * EPS_SMALL)
+   if ( abs( m_dDeltaN) > EPS_SMALL)
       ptP += ( dU * m_dDeltaN) * m_VtN  ;
 
    return true ;
 }
-
-//----------------------------------------------------------------------------
-bool
-CurveArc::CalcVoronoiObject() const
-{
-   if ( m_nStatus != OK)
-      return false ;
- 
-  // creo oggetto vroni con la curva
-   m_pVoronoiObj = new( std::nothrow) Voronoi( this, false) ;
-   if ( m_pVoronoiObj == nullptr)
-      return false ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-Voronoi*
-CurveArc::GetVoronoiObject() const
-{
-   if ( m_nStatus != OK)
-      return nullptr ;
-
-  // se non è stato calcolato, lo calcolo
-   if ( m_pVoronoiObj == nullptr)
-      CalcVoronoiObject() ;
-
-  // restituisco Voronoi
-   return m_pVoronoiObj ;
-}
-
-//----------------------------------------------------------------------------
-void
-CurveArc::ResetVoronoiObject() const
-{
-   if ( m_pVoronoiObj != nullptr)
-      delete m_pVoronoiObj ;
-   m_pVoronoiObj = nullptr ;
-}

CurveArc.h

@@ -19,8 +19,6 @@
 #include "GeoObjRW.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 
-class Voronoi ;
-
 //----------------------------------------------------------------------------
 class CurveArc : public ICurveArc, public IGeoObjRW
 {
@@ -51,16 +49,10 @@ class CurveArc : public ICurveArc, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp, int nPropInd = 0) override
-              { if ( nPropInd >= 0  &&  nPropInd < 2)
-                   m_nTempProp[nPropInd] = nProp ; } 
-      int  GetTempProp( int nPropInd = 0) const override
-              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
-      void SetTempParam( double dParam, int nParamInd = 0) override
-              { if ( nParamInd >= 0  &&  nParamInd < 2)
-                   m_dTempParam[nParamInd] = dParam ; } 
-      double GetTempParam( int nParamInd = 0) const override
-                { return (( nParamInd >= 0  &&  nParamInd < 2) ? m_dTempParam[nParamInd] : 0.0) ; }
+      void SetTempProp( int nProp) override
+              { m_nTempProp = nProp ; } 
+      int  GetTempProp( void) const override
+              { return m_nTempProp ; } 
 
    public :                      // ICurve
       bool IsSimple( void) const override
@@ -186,14 +178,11 @@ class CurveArc : public ICurveArc, public IGeoObjRW
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
-      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
-      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
-      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       CurveArc( void) ;
-      CurveArc( const CurveArc& caSrc) : m_pVoronoiObj( nullptr)
+      CurveArc( const CurveArc& caSrc)
                      { if ( ! CopyFrom( caSrc))
                           LOG_ERROR( GetEGkLogger(), "CurveArc : copy constructor error")}
       CurveArc& operator =( const CurveArc& caSrc)
@@ -202,14 +191,11 @@ class CurveArc : public ICurveArc, public IGeoObjRW
                        return *this ; }
       bool MyExtendedOffset( double dDist, bool bAll, int nType = OFF_FILLET) ;
       bool MyCalcPointParamPosiz( const Point3d& ptP, double& dU, int& nPos, double dLinTol) const ;
-      Voronoi* GetVoronoiObject( void) const ;
-      void ResetVoronoiObject( void) const ;
 
    private :
       bool CopyFrom( const CurveArc& caSrc) ;
       bool Validate( void) ;
-      bool GetDir( double dU, Vector3d& vtDir) const ;      
-      bool CalcVoronoiObject( void) const ;
+      bool GetDir( double dU, Vector3d& vtDir) const ;
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
@@ -225,23 +211,17 @@ class CurveArc : public ICurveArc, public IGeoObjRW
       double   m_dDeltaN ;             // variazione di quota lungo VtN della fine rispetto all'inizio
       Vector3d m_VtExtr ;              // vettore estrusione (normalmente coincide con m_VtN)
       double   m_dThick ;              // spessore
-      int      m_nTempProp[2] ;        // vettore proprietà temporanee 
-      double   m_dTempParam[2] ;       // vettore parametri temporanei
-      mutable Voronoi* m_pVoronoiObj ; // Voronoi
+      int      m_nTempProp ;           // proprietà temporanea 
 } ;
 
 //-----------------------------------------------------------------------------
 inline CurveArc* CreateBasicCurveArc( void)
-               { return ( static_cast<CurveArc*>( CreateGeoObj( CRV_ARC))) ; }
+               { return (static_cast<CurveArc*>( CreateGeoObj( CRV_ARC))) ; }
 inline CurveArc* CloneBasicCurveArc( const IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_ARC)
                    return nullptr ;
-                 return ( static_cast<CurveArc*>( pGObj->Clone())) ; }
+                 return (static_cast<CurveArc*>(pGObj->Clone())) ; }
 inline const CurveArc* GetBasicCurveArc( const IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_ARC)
-                   return nullptr ;
-                 return ( static_cast<const CurveArc*>( pGObj)) ; }
+               { return (dynamic_cast<const CurveArc*>(pGObj)) ; }
 inline CurveArc* GetBasicCurveArc( IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_ARC)
-                   return nullptr ;
-                 return ( static_cast<CurveArc*>( pGObj)) ; }
+               { return (dynamic_cast<CurveArc*>(pGObj)) ; }

CurveAux.h

@@ -13,9 +13,7 @@
 
 #pragma once
 
-#include "/EgtDev/Include/EGkCurveAux.h"
-
-class Voronoi ;
+#include "/EgtDev/Include/EgkCurveAux.h"
 
 //----------------------------------------------------------------------------
 bool IsClosed( const ICurve& crvC) ;
@@ -33,5 +31,3 @@ bool CurveGetArea( const ICurve& crvC, Plane3d& plPlane, double& dArea) ;
 bool CurveDump( const ICurve& crvC, std::string& sOut, bool bMM, const char* szNewLine) ;
 bool CopyExtrusion( const ICurve* pSouCrv, ICurve* pDestCrv) ;
 bool CopyThickness( const ICurve* pSouCrv, ICurve* pDestCrv) ;
-ICurveBezier* ApproxCurveBezierWithSingleCubic( const ICurve* pCrv) ;
-Voronoi* GetCurveVoronoi( const ICurve& crvC) ;

CurveBezier.cpp

@@ -13,30 +13,25 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "CurveAux.h"
 #include "CurveBezier.h"
 #include "CurveComposite.h"
 #include "DistPointCrvBezier.h"
 #include "BiArcs.h"
 #include "GeoConst.h"
 #include "PolygonPlane.h"
+#include "DistPointLine.h"
 #include "GeoObjFactory.h"
 #include "NgeWriter.h"
 #include "NgeReader.h"
 #include "PolynomialPoint3d.h"
 #include "Bernstein.h"
 #include "deCasteljau.h"
-#include "Voronoi.h"
-#include "IntersLineLine.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
 #include "/EgtDev/Include/ENkPolynomial.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
-#include "/EgtDev/Include/EGkGeoPoint3d.h"
-#include "/EgtDev/Include/EGkCurveLine.h"
 #include <array>
 
 using namespace std ;
@@ -50,14 +45,13 @@ GEOOBJ_REGISTER( CRV_BEZIER, NGE_C_BEZ, CurveBezier) ;
 //----------------------------------------------------------------------------
 CurveBezier::CurveBezier( void)
    : m_nStatus( TO_VERIFY), m_nDeg(), m_bRat( false), m_dParSing( -2),
-     m_VtExtr(), m_dThick(), m_nTempProp{0,0}, m_dTempParam{0.0,0.0}, m_pVoronoiObj( nullptr)
+     m_VtExtr(), m_dThick(), m_nTempProp()
 {
 }
 
 //----------------------------------------------------------------------------
 CurveBezier::~CurveBezier( void)
 {
-   ResetVoronoiObject() ;
 }
 
 //----------------------------------------------------------------------------
@@ -81,8 +75,6 @@ CurveBezier::Init( int nDeg, bool bIsRational)
       m_vWeCtrl.clear() ;
    m_nStatus = TO_VERIFY ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -107,8 +99,6 @@ CurveBezier::SetControlPoint( int nInd, const Point3d& ptCtrl)
   // annullo analisi presenza singolarità
    m_dParSing = - 2 ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -134,40 +124,12 @@ CurveBezier::SetControlPoint( int nInd, const Point3d& ptCtrl, double dW)
   // annullo analisi presenza singolarità
    m_dParSing = - 2 ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-CurveBezier::SetControlWeight( int nInd, double dW)
-{
-   // verifico validità, razionalità e indice
-   if ( m_nStatus != OK  ||  ! m_bRat  ||  nInd < 0  ||  nInd > m_nDeg)
-      return false ;
-
-   // verifico che il peso non sia nullo o negativo
-   if ( dW < EPS_SMALL)
-      return false ;
-
-   // assegno il valore e il peso
-   m_vWeCtrl[nInd] = dW ;
-
-   // annullo analisi presenza singolarità
-   m_dParSing = - 2 ;
-
-   // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
-   // imposto ricalcolo della grafica
-   m_OGrMgr.Reset() ;
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 CurveBezier::FromArc( const ICurveArc& crArc)
@@ -225,35 +187,6 @@ CurveBezier::FromArc( const ICurveArc& crArc)
       SetControlPoint( 1, ptNew1, dW) ;
       SetControlPoint( 2, ptNew2, dW) ;
       SetControlPoint( 3, ptEnd, 1) ;
-
-   //// anziché usare una bezier cubica approssimo le eliche con più bezier quadratiche razionali.
-   //// più è grande l'angolo al centro dell'arco e maggiore sarà l'errore di approssimazione
-   //
-   //  // quadratica razionale
-   //  // peso del punto di controllo intermedio
-   //   double dW = dCosAhalf ;
-   //  // calcolo dei punti di controllo
-   //   Point3d  ptStart ;
-   //   crArc.GetStartPoint( ptStart) ;
-   //   Point3d  ptEnd ;
-   //   crArc.GetEndPoint( ptEnd) ;
-   //  // Point3d ptMed = Media( ptStart, ptEnd, 0.5) ;
-   //  //Vector3d vtDir = ptMed - crArc.GetCenter() ;
-   //  // Point3d ptNew = crArc.GetCenter() + vtDir / ( dCosAhalf * dCosAhalf) ;
-   //   Vector3d vtStart ; crArc.GetStartDir( vtStart) ;
-   //   Vector3d vtEnd ; crArc.GetEndDir( vtEnd) ;
-   //   PtrOwner<CurveLine> pCrvLine1( CreateBasicCurveLine()) ;
-   //   pCrvLine1->SetPVL( ptStart, vtStart, 10) ;
-   //   PtrOwner<CurveLine> pCrvLine2( CreateBasicCurveLine()) ;
-   //   pCrvLine2->SetPVL( ptEnd, vtEnd, 10) ;
-   //   IntersLineLine ill( *pCrvLine1, *pCrvLine2, false) ;
-   //   IntCrvCrvInfo iccInfo ; ill.GetIntCrvCrvInfo( iccInfo) ;
-   //   Point3d ptNew = 0.5 * (iccInfo.IciA->ptI + iccInfo.IciB->ptI) ;
-   //  // inserimento nella curva dei punti di controllo con i pesi
-   //   Init( 2, true) ;
-   //   SetControlPoint( 0, ptStart, 1) ;
-   //   SetControlPoint( 1, ptNew, dW) ;
-   //   SetControlPoint( 2, ptEnd, 1) ;
    }
 
   // copio estrusione e spessore
@@ -263,30 +196,6 @@ CurveBezier::FromArc( const ICurveArc& crArc)
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-CurveBezier::FromLine( const ICurveLine& crLine)
-{
-   if ( ! crLine.IsValid())
-      return false ;
-   double dWeight = 1 ;
-   int nCount = 0 ;
-   Point3d ptStart ; crLine.GetStartPoint( ptStart) ;
-   SetControlPoint( nCount, ptStart, dWeight) ;
-   ++nCount ;
-   double dPart = 1. / m_nDeg ;
-   for ( int i = 1 ; i < m_nDeg ; ++i) {
-      double dU = i * dPart ;
-      Point3d ptMid ; crLine.GetPointD1D2( dU, ICurve::FROM_MINUS, ptMid) ;
-      SetControlPoint( nCount, ptMid, dWeight) ;
-      ++nCount ;
-   }
-   Point3d ptEnd ; crLine.GetEndPoint( ptEnd) ;
-   SetControlPoint( nCount, ptEnd, dWeight) ;
-   ++nCount ;
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 CurveBezier::IsAPoint( void) const
@@ -355,7 +264,7 @@ CurveBezier::Clone( void) const
 bool
 CurveBezier::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const CurveBezier* pCB = GetBasicCurveBezier( pGObjSrc) ;
+   const CurveBezier* pCB = dynamic_cast<const CurveBezier*>( pGObjSrc) ;
    if ( pCB == nullptr)
       return false ;
    return CopyFrom( *pCB) ;
@@ -369,16 +278,12 @@ CurveBezier::CopyFrom( const CurveBezier& cbSrc)
       return true ;
    if ( ! Init( cbSrc.m_nDeg, cbSrc.m_bRat))
       return false ;
-   m_dParSing = cbSrc.m_dParSing ;
    m_vPtCtrl = cbSrc.m_vPtCtrl ;
    if ( cbSrc.m_bRat)
       m_vWeCtrl = cbSrc.m_vWeCtrl ;
    m_VtExtr = cbSrc.m_VtExtr ;
    m_dThick = cbSrc.m_dThick ;
-   m_nTempProp[0] = cbSrc.m_nTempProp[0] ;
-   m_nTempProp[1] = cbSrc.m_nTempProp[1] ;
-   m_dTempParam[0] = cbSrc.m_dTempParam[0] ;
-   m_dTempParam[1] = cbSrc.m_dTempParam[1] ;
+   m_nTempProp = cbSrc.m_nTempProp ;
    return true ;
 }
 
@@ -516,24 +421,8 @@ CurveBezier::Load( NgeReader& ngeIn)
 bool
 CurveBezier::Validate( void)
 {
-   if ( m_nStatus == TO_VERIFY) {
-      for ( const auto& ptP : m_vPtCtrl) {
-         if ( ! ptP.IsValid()) {
-            m_nStatus = ERR ;
-            break ;
-         }
-      }
-   }
-   if ( m_nStatus == TO_VERIFY) {
-      for ( const auto& dWe : m_vWeCtrl) {
-         if ( ! isfinite( dWe)) {
-            m_nStatus = ERR ;
-            break ;
-         }
-      }
-   }
    if ( m_nStatus == TO_VERIFY)
-      m_nStatus = ( ( m_nDeg >= 1  &&  m_vPtCtrl.size() >= 2) ? OK : ERR) ;
+      m_nStatus = ( ( m_nDeg > 0  &&  m_vPtCtrl.size() > 0) ? OK : ERR) ;
 
    return ( m_nStatus == OK) ;
 }
@@ -556,7 +445,7 @@ CurveBezier::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
    else {
      // costruisco una approssimazione lineare
       PolyLine PL ;
-      if ( ! ApproxWithLines( LIN_TOL_MIN, ANG_TOL_APPROX_DEG, APL_STD, PL))
+      if ( ! ApproxWithLines( LIN_TOL_MIN, ANG_TOL_APPROX_DEG, ICurve::APL_STD, PL))
          return false ;
      // ciclo sui punti della approssimazione
       Point3d  ptTemp ;
@@ -599,7 +488,7 @@ CurveBezier::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
    else {
      // costruisco una approssimazione lineare
       PolyLine PL ;
-      if ( ! ApproxWithLines( LIN_TOL_MIN, ANG_TOL_APPROX_DEG, APL_STD, PL))
+      if ( ! ApproxWithLines( LIN_TOL_MIN, ANG_TOL_APPROX_DEG, ICurve::APL_STD, PL))
          return false ;
      // ciclo sui punti della approssimazione
       Point3d  ptTemp ;
@@ -711,7 +600,7 @@ CurveBezier::GetMidPoint( Point3d& ptMid) const
       return false ;
   // determino il valore del parametro a metà lunghezza
    double dLen, dMid ;
-   if ( ! GetLengthAtParam( 1, dLen)  ||  ! GetParamAtLength( 0.5 * dLen, dMid))
+   if ( ! GetLength( dLen)  ||  ! GetParamAtLength( 0.5 * dLen, dMid))
       return false ;      
   // calcolo il punto
    return GetPointD1D2( dMid, ptMid) ;
@@ -726,7 +615,7 @@ CurveBezier::GetCentroid( Point3d& ptCen) const
       return false ;
   // approssimo la curva con una polilinea
    PolyLine PL ;
-   if ( ! ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, APL_STD, PL))
+   if ( ! ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
       return false ;
   // calcolo il centro mediante PolygonPlane
    Point3d ptP ;
@@ -748,7 +637,7 @@ CurveBezier::GetMidDir( Vector3d& vtDir) const
       return false ;
   // determino il valore del parametro a metà lunghezza
    double dLen, dMid ;
-   if ( ! GetLengthAtParam( 1, dLen)  ||  ! GetParamAtLength( 0.5 * dLen, dMid))
+   if ( ! GetLength( dLen)  ||  ! GetParamAtLength( 0.5 * dLen, dMid))
       return false ;      
   // calcolo la direzione
    return ::GetTang( *this, dMid, FROM_MINUS, vtDir) ;
@@ -1537,7 +1426,7 @@ CurveBezier::ApproxWithArcsXY( double dLinTol, double dAngTolDeg, PolyArc& PA) c
 
   // costruisco una approssimazione lineare
    PolyLine PL ;
-   if ( ! ApproxWithLines( dLinTol, dAngTolDeg, APL_STD, PL))
+   if ( ! ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, PL))
       return false ;
 
   // approssimo la curva per approssimazioni successive mediante bisezione
@@ -1570,7 +1459,7 @@ CurveBezier::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAngTo
             return false ;
          vtDir.ToSpherical( nullptr, nullptr, &dDir1Deg) ;
         // costruisco un biarco sulla polilinea (secondo metodo di Z. Sir)
-         pCrv.Set( GetBiArc( ptP0, dDir0Deg, ptP1, dDir1Deg, PL, dMaxDist, dLinTol)) ;
+         pCrv.Set( GetBiArc( ptP0, dDir0Deg, ptP1, dDir1Deg, PL, dMaxDist)) ;
          if ( IsNull( pCrv))
             return false ;
       }
@@ -1586,7 +1475,7 @@ CurveBezier::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAngTo
             return false ;
          if ( ! pCC->FromPolyLine( PL))
             return false ;
-         pCrv.Set( pCC) ;
+         pCrv.Set( Release( pCC)) ;
          dMaxDist = 0 ;
       }
      // se la polilinea ha un solo punto, esco
@@ -1698,8 +1587,6 @@ CurveBezier::Invert( void)
    for ( int i = 0 ; i < nMid ; ++ i)
       swap( m_vPtCtrl[i], m_vPtCtrl[m_nDeg-i]) ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
   
@@ -1717,8 +1604,6 @@ CurveBezier::ModifyStart( const Point3d& ptNewStart)
   // modifico il primo punto di controllo
    m_vPtCtrl[0] = ptNewStart ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1736,8 +1621,6 @@ CurveBezier::ModifyEnd( const Point3d& ptNewEnd)
   // modifico l'ultimo punto di controllo
    m_vPtCtrl[m_nDeg] = ptNewEnd ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1762,8 +1645,6 @@ CurveBezier::TrimStartAtParam( double dUTrim)
          return false ;
    }
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -1788,8 +1669,6 @@ CurveBezier::TrimEndAtParam( double dUTrim)
          return false ;
    }
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -1807,24 +1686,12 @@ CurveBezier::TrimStartEndAtParam( double dUStartTrim, double dUEndTrim)
   // verifico che i trim non cancellino interamente la curva
    if ( dUStartTrim > dUEndTrim - EPS_PARAM)
       return false ;
-   // se razionale devo trovare il punto di trim iniziale per ricalcolare il parametro di trim
-   Point3d ptStart ;
-   if( m_bRat)
-      GetPointD1D2( dUStartTrim, ptStart) ;
   // trim finale
    if ( ! TrimEndAtParam( dUEndTrim))
       return false ;
   // trim iniziale con il parametro opportunamente ricalcolato
-   double dNewUStartTrim ;
-   if( m_bRat)
-      GetParamAtPoint( ptStart, dNewUStartTrim) ;
-   else
-      dNewUStartTrim = dUStartTrim / dUEndTrim ;
-   //trim iniziale
-   if( ! TrimStartAtParam( dNewUStartTrim))
-      return false ;
-
-   return true ;
+   double dNewUStartTrim = dUStartTrim / dUEndTrim ;
+   return TrimStartAtParam( dNewUStartTrim) ;
 }
 
 //----------------------------------------------------------------------------
@@ -1840,10 +1707,7 @@ CurveBezier::TrimStartAtLen( double dLenTrim)
       return false ;
 
   // utilizzo il trim sui parametri
-   if( ! TrimStartAtParam( dUTrim))
-      return false ;
-
-   return true ;
+   return TrimStartAtParam( dUTrim) ;
 }
 
 //----------------------------------------------------------------------------
@@ -1859,10 +1723,7 @@ CurveBezier::TrimEndAtLen( double dLenTrim)
       return false ;
 
   // utilizzo il trim sui parametri
-   if( ! TrimEndAtParam( dUTrim))
-      return false ;
-
-   return true ;
+   return TrimEndAtParam( dUTrim) ;
 }
 
 //----------------------------------------------------------------------------
@@ -1874,7 +1735,7 @@ CurveBezier::ExtendStartByLen( double dLenExt)
       return false ;
   // determino la lunghezza originale della curva
    double dLen ;
-   if ( ! GetLengthAtParam( 1, dLen))
+   if ( ! GetLength( dLen))
       return false ;
   // stimo il valore del parametro al nuovo punto iniziale
    double dUTrim = - dLenExt / dLen ;
@@ -1908,9 +1769,6 @@ CurveBezier::ExtendStartByLen( double dLenExt)
          m_vWeCtrl[i] = vWeCtrl[i] ;
       }
    }
-
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
    return true ;
@@ -1925,7 +1783,7 @@ CurveBezier::ExtendEndByLen( double dLenExt)
       return false ;
   // determino la lunghezza originale della curva
    double dLen ;
-   if ( ! GetLengthAtParam( 1, dLen))
+   if ( ! GetLength( dLen))
       return false ;
   // stimo il valore del parametro al nuovo punto finale
    double dUTrim = 1 + dLenExt / dLen ;
@@ -1959,9 +1817,6 @@ CurveBezier::ExtendEndByLen( double dLenExt)
          m_vWeCtrl[i] = vWeCtrl[i] ;
       }
    }
-
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
    return true ;   
@@ -1975,10 +1830,6 @@ CurveBezier::Translate( const Vector3d& vtMove)
    if ( m_nStatus != OK)
       return false ;
 
-  // traslo Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->Translate( vtMove) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2001,10 +1852,6 @@ CurveBezier::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng,
    if ( vtAx.IsSmall())
       return false ;
 
-  // ruoto Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2047,8 +1894,6 @@ CurveBezier::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double
    if ( ! bOk)
       return false ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2078,8 +1923,6 @@ CurveBezier::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
    if ( vtNorm.IsSmall())
       return false ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2104,8 +1947,6 @@ CurveBezier::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d&
    if ( vtNorm.IsSmall()  ||  vtDir.IsSmall())
       return false ;
 
-  // imposto ricalcolo Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2130,18 +1971,11 @@ CurveBezier::ToGlob( const Frame3d& frRef)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
+
   // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
-   if ( IsGlobFrame( frRef))
-      return true ;
-
-  // trasformo Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->ToGlob( frRef) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2161,18 +1995,11 @@ CurveBezier::ToLoc( const Frame3d& frRef)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
+
   // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
-   if ( IsGlobFrame( frRef))
-      return true ;
-
-  // trasformo Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->ToLoc( frRef) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2192,18 +2019,11 @@ CurveBezier::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
+
   // verifico validità dei frame
    if ( frOri.GetType() == Frame3d::ERR  ||  frDest.GetType() == Frame3d::ERR)
       return false ;
 
-  // se i due riferimenti coincidono, non devo fare alcunché
-   if ( AreSameFrame( frOri, frDest))
-      return true ;
-
-  // trasformo Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->LocToLoc( frOri, frDest) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2215,180 +2035,3 @@ CurveBezier::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
 
    return true ;
 }
-
-//----------------------------------------------------------------------------
-bool
-CurveBezier::CalcVoronoiObject() const
-{
-   if ( m_nStatus != OK)
-      return false ;
- 
-  // creo oggetto vroni con la curva
-   m_pVoronoiObj = new( std::nothrow) Voronoi( this, false) ;
-   if ( m_pVoronoiObj == nullptr)
-      return false ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-Voronoi* 
-CurveBezier::GetVoronoiObject() const
-{
-   if ( m_nStatus != OK)
-      return nullptr ;
- 
-  // se non è stato calcolato, lo calcolo
-   if ( m_pVoronoiObj == nullptr)
-      CalcVoronoiObject() ;
- 
-  // restituisco Voronoi
-   return m_pVoronoiObj ;
-}
-
-//----------------------------------------------------------------------------
-void
-CurveBezier::ResetVoronoiObject() const
-{ 
-   if ( m_pVoronoiObj != nullptr)
-      delete m_pVoronoiObj ;
-   m_pVoronoiObj = nullptr ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CurveBezier::MakeRational( void)
-{ 
-   if ( m_bRat)
-      return true ;
-   // creo il vettore dei pesi e li setto tutti a 1
-   m_vWeCtrl.assign( m_nDeg + 1, 1) ;
-   // aggiorno il flag rational
-   m_bRat = true ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CurveBezier::MakeRationalStandardForm( void)
-{ 
-   if ( ! m_bRat)
-      return false ;
-   double dW0 = m_vWeCtrl.front() ;
-   double dWn = m_vWeCtrl.back() ;
-   if ( dW0 > 1 - EPS_ZERO  &&  dWn > 1 - EPS_ZERO)
-      return true ;
-   if ( dW0 < EPS_ZERO  ||  dWn < EPS_ZERO)
-      return false ;
-
-  // formula del Farin
-   double dCoeff = pow( dW0 / dWn, 1. / m_nDeg) ;
-   for ( int i = 0 ; i < m_nDeg + 1 ; ++i)
-      m_vWeCtrl[i] *= Pow( dCoeff, i) / dW0 ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CurveBezier::MakeNonRational( double dTol)
-{
-   if ( ! m_bRat)
-      return true ;
-
-   // controllo se i pesi sono tutti == 1 allora è una finta razionale e mi basta fare una copia dei punti di controllo
-   bool bIsActualRat = false ;
-   for ( int i = 0 ; i < m_nDeg ; ++i) {
-      if ( abs( m_vWeCtrl[i] - 1) > EPS_SMALL) {
-         bIsActualRat = true ;
-         break ;
-      }
-   }
-
-   bool bOk = true ;
-   if ( ! bIsActualRat) {
-      PtrOwner<CurveBezier> pNewBez( CreateBasicCurveBezier()) ;
-      for ( int p = 0 ; p < m_nDeg ; ++p) {
-         Point3d pt = GetControlPoint( p) ;
-         pNewBez->SetControlPoint( p, pt) ;
-      }
-   }
-   else {
-      // provo ad approssimare la curva di bezier con una controparte non razionale
-      int nDeg = m_nDeg ;
-      // punto di rientro in caso fallisca il primo tentativo
-      retry :
-         nDeg += 2 ;
-         PtrOwner<CurveBezier> pNewBez( CreateBasicCurveBezier()) ;
-         pNewBez->Init( nDeg, false) ;
-         PNTVECTOR vPntCtrl ;
-         PNTVECTOR vPntSampling ;
-         for ( int p = 0 ; p < nDeg + 1 ; ++p) {
-            Point3d pt ; GetPointD1D2( double( p) / nDeg, pt) ;
-            pNewBez->SetControlPoint( p, pt) ;
-            vPntCtrl.push_back( pt) ;
-         }
-         vPntSampling = vPntCtrl ;
-         int c = 0 ;
-         double dErr = INFINITO ;
-         while ( dErr > dTol  &&  c < 100) {
-            double dErrMax = 0 ;
-            // calcolo le differenze tra i punti di sampling sulla nuova curva e quelli sulla curva originale
-            for ( int p = 0 ; p < nDeg + 1 ; ++p) {
-               Point3d pt ; pNewBez->GetPointD1D2( double( p) / nDeg, pt) ;
-               Vector3d vDiff = vPntSampling[p] - pt ;
-               double dErrLoc = vDiff.Len() ;
-               if( dErrLoc > dErrMax)
-                  dErrMax = dErrLoc ;
-               // aggiorno il vettore dei punti di controllo della nuova curva
-               vPntCtrl[p] += vDiff ;
-            }
-            dErr = dErrMax ;
-            // aggiorno i punti di controllo della nuova curva
-            for ( int i = 0 ; i < nDeg + 1 ; ++i)
-               pNewBez->SetControlPoint( i, vPntCtrl[i]) ;
-            ++c ;
-         }
-
-         // calcolo l'errore di approssimazione sulla curva
-         CalcBezierApproxError( this, pNewBez, dErr) ;
-         bOk = dErr < dTol ;
-         if ( bOk) {
-            // aggiorno la curva di bezier originale con quella approssimata
-            Init( nDeg, false) ;
-            for ( int i = 0 ; i < nDeg + 1 ; ++i) {
-               SetControlPoint( i, pNewBez->GetControlPoint( i)) ;
-               SetControlWeight( i, pNewBez->GetControlWeight( i)) ;
-            }
-         }
-         else if ( nDeg < m_nDeg + 4)
-            goto retry ;
-   }
-
-   return bOk ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CurveBezier::IsALine( void) const
-{
-   Point3d ptStart ; GetStartPoint( ptStart) ;
-   Point3d ptEnd ; GetEndPoint( ptEnd) ;
-   for ( int i = 1 ; i < m_nDeg ; ++i) {
-      Point3d ptCtrl = GetControlPoint( i) ;
-      DistPointLine dpl( ptCtrl, ptStart, ptEnd) ;
-      double dDist = 0 ; dpl.GetDist( dDist) ;
-      if( dDist > EPS_SMALL)
-         return false ;
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-PNTVECTOR
-CurveBezier::GetAllControlPoints( void) const
-{
-   PNTVECTOR vPntCtrl = m_vPtCtrl ;
-   return vPntCtrl ;
-}

CurveBezier.h

@@ -19,8 +19,7 @@
 #include "DllMain.h"
 #include "GeoObjRW.h"
 #include "/EgtDev/Include/EGkCurveBezier.h"
-
-class Voronoi ;
+#include "/EgtDev/Include/EgtNumCollection.h"
 
 //----------------------------------------------------------------------------
 class CurveBezier : public ICurveBezier, public IGeoObjRW
@@ -52,16 +51,10 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp, int nPropInd = 0) override
-              { if ( nPropInd >= 0  &&  nPropInd < 2)
-                   m_nTempProp[nPropInd] = nProp ; } 
-      int  GetTempProp( int nPropInd = 0) const override
-              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
-      void SetTempParam( double dParam, int nParamInd = 0) override
-              { if ( nParamInd >= 0  &&  nParamInd < 2)
-                   m_dTempParam[nParamInd] = dParam ; } 
-      double GetTempParam( int nParamInd = 0) const override
-                { return (( nParamInd >= 0  &&  nParamInd < 2) ? m_dTempParam[nParamInd] : 0.0) ; }
+      void SetTempProp( int nProp) override
+              { m_nTempProp = nProp ; } 
+      int  GetTempProp( void) const override
+              { return m_nTempProp ; } 
 
    public :                      // ICurve
       bool IsSimple( void) const override { return true ; }
@@ -117,7 +110,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
       ICurve* CopyParamRange( double dUStart, double dUEnd) const override ;
       bool Invert( void) override ;
       bool SimpleOffset( double dDist, int nType = OFF_FILLET) override
-              { return false ; }  // l'offset di crvBezier non è crvBezier tranne in casi molto particolari
+              { return false ; }  // l'offset di crvBezier non è crvBezier tranne in casi molto particolari
       bool ModifyStart( const Point3d& ptNewStart) override ;
       bool ModifyEnd( const Point3d& ptNewEnd) override ;
       bool SetExtrusion( const Vector3d& vtExtr) override
@@ -137,9 +130,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
       bool Init( int nDeg, bool bIsRational) override ;
       bool SetControlPoint( int nInd, const Point3d& ptCtrl) override ;
       bool SetControlPoint( int nInd, const Point3d& ptCtrl, double dW) override ;
-      bool SetControlWeight( int nInd, double dW) override ;
       bool FromArc( const ICurveArc& crArc) override ;
-      bool FromLine( const ICurveLine& crLine) override ;
       int  GetDegree( void) const override
                 { return m_nDeg ; }
       bool IsRational( void) const override
@@ -149,23 +140,15 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
       double GetControlWeight( int nInd, bool* pbOk = NULL) const override ;
       bool GetControlPolygonLength( double& dLen) const override ;
       int  GetSingularParam( double& dPar) const override ;
-      bool MakeRational( void) override ;
-      bool MakeRationalStandardForm( void) override ;
-      bool MakeNonRational( double dTol) override ;
-      bool IsALine( void) const override ;
-      PNTVECTOR GetAllControlPoints( void) const ;  // non aggiunta in interfaccia
 
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
-      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
-      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
-      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       CurveBezier( void) ;
-      CurveBezier( const CurveBezier& cbSrc) : m_pVoronoiObj( nullptr)
+      CurveBezier( const CurveBezier& cbSrc)
                      { if ( ! CopyFrom( cbSrc))
                           LOG_ERROR( GetEGkLogger(), "CurveBezier : copy constructor error")}
       CurveBezier& operator =( const CurveBezier& cbSrc)
@@ -174,8 +157,6 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
                        return *this ; }
       bool ApproxWithLines( int nStep, PolyLine& PL) const ;
       bool GetApproxLength( double& dLen) const ;
-      Voronoi* GetVoronoiObject( void) const ;
-      void ResetVoronoiObject( void) const ;
 
    private :
       bool CopyFrom( const CurveBezier& cbSrc) ;
@@ -192,40 +173,33 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
       bool ApproxWithArcsXY(double dLinTol, double dAngTolDeg, PolyArc& PA) const;
       bool BiArcOrSplit(int nLev, PolyLine& PL, double dLinTol, double dAngTolDeg, PolyArc& PA) const;
       bool ToPowerBase( PolynomialPoint3d& pol3P) const ;
-      bool ToPowerBase( PolynomialPoint3d& pol3Num, Polynomial& polDen) const ;      
-      bool CalcVoronoiObject( void) const ;
+      bool ToPowerBase( PolynomialPoint3d& pol3Num, Polynomial& polDen) const ;
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
-      static const int MAXDEG = 21 ;
+      static const int MAXDEG = 11 ;
 
    private :
-      ObjGraphicsMgr m_OGrMgr ;         // gestore grafica dell'oggetto
-      Status         m_nStatus ;        // stato
-      int            m_nDeg ;           // grado
-      bool           m_bRat ;           // flag di razionale/polinomiale
-      mutable double m_dParSing ;       // eventuale parametro della singolarità (-1=no, -2=da calcolare)
-      PNTVECTOR      m_vPtCtrl ;        // vettore dei punti di controllo
-      DBLVECTOR      m_vWeCtrl ;        // vettore dei pesi di controllo
-      Vector3d       m_VtExtr ;         // vettore estrusione (normalmente coincide con m_VtN)
-      double         m_dThick ;         // spessore
-      int            m_nTempProp[2] ;   // vettore proprietà temporanee
-      double         m_dTempParam[2] ;  // vettore parametri temporanei
-      mutable Voronoi* m_pVoronoiObj ;  // Voronoi
+      ObjGraphicsMgr m_OGrMgr ;        // gestore grafica dell'oggetto
+      Status         m_nStatus ;       // stato
+      int            m_nDeg ;          // grado
+      bool           m_bRat ;          // flag di razionale/polinomiale
+      mutable double m_dParSing ;      // eventuale parametro della singolarità (-1=no, -2=da calcolare)
+      PNTVECTOR      m_vPtCtrl ;       // vettore dei punti di controllo
+      DBLVECTOR      m_vWeCtrl ;       // vettore dei pesi di controllo
+      Vector3d       m_VtExtr ;        // vettore estrusione (normalmente coincide con m_VtN)
+      double         m_dThick ;        // spessore
+      int            m_nTempProp ;     // proprietà temporanea 
 } ;
 
 //-----------------------------------------------------------------------------
 inline CurveBezier* CreateBasicCurveBezier( void)
-               { return ( static_cast<CurveBezier*>( CreateGeoObj( CRV_BEZIER))) ; }
+               { return (static_cast<CurveBezier*>( CreateGeoObj( CRV_BEZIER))) ; }
 inline CurveBezier* CloneBasicCurveBezier( const IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_BEZIER)
                     return nullptr ;
-                 return ( static_cast<CurveBezier*>( pGObj->Clone())) ; }
+                 return (static_cast<CurveBezier*>(pGObj->Clone())) ; }
 inline const CurveBezier* GetBasicCurveBezier( const IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_BEZIER)
-                    return nullptr ;
-                 return ( static_cast<const CurveBezier*>( pGObj)) ; }
+               { return (dynamic_cast<const CurveBezier*>(pGObj)) ; }
 inline CurveBezier* GetBasicCurveBezier( IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_BEZIER)
-                    return nullptr ;
-                 return ( static_cast<CurveBezier*>( pGObj)) ; }
+               { return (dynamic_cast<CurveBezier*>(pGObj)) ; }

CurveByApprox.cpp

@@ -16,8 +16,7 @@
 #include "CurveComposite.h"
 #include "CalcDerivate.h"
 #include "BiArcs.h"
-#include "RemoveCurveDefects.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
+#include "DistPointLine.h"
 #include "/EgtDev/Include/EGkCurveByApprox.h"
 #include "/EgtDev/Include/EGkPolyLine.h"
 #include "/EgtDev/Include/EGkPolyArc.h"
@@ -57,78 +56,28 @@ ICurve*
 CurveByApprox::GetCurve( int nType, double dLinTol, double dAngTolDeg, double dLinFea)
 {
   // se da approssimare con archi
-   if ( nType == ARCS  ||  nType == ARCS_CORNER) {
+   if ( nType == ARCS_CORNER) {
      // calcolo approssimazione
       PolyArc PA ;
-      if ( nType == ARCS) {
-         if ( ! GetArcs( dLinTol, dAngTolDeg, PA))
-            return nullptr ;
-      }
-      else {
-         if ( ! GetArcsCorner( dLinTol, dAngTolDeg, dLinFea, PA))
-            return nullptr ;
-      }
+      if ( ! GetArcs( dLinTol, dAngTolDeg, dLinFea, PA))
+         return nullptr ;
      // creo la composita formata da questa approssimazione
       PtrOwner<CurveComposite> pCC( CreateBasicCurveComposite()) ;
       if ( ! pCC->FromPolyArc( PA))
          return nullptr ;
-     // elimino eventuali Small Z
-      pCC->RemoveSmallDefects( dLinTol, dAngTolDeg) ;
      // eventuale fusione di curve compatibili
       pCC->MergeCurves( dLinTol, dAngTolDeg) ;
      // restituisco la curva
       return Release( pCC) ;
    }
   // altrimenti con curve di Bezier cubiche
-   else if ( nType == CUBIC_BEZIERS) {
-      // !!! NON ANCORA IMPLEMENTATA !!!
-      return nullptr ;
-   }
-  // tipi non previsti
+   // !!! NON ANCORA IMPLEMENTATA !!!
    return nullptr ;
 }
 
 //----------------------------------------------------------------------------
 bool
-CurveByApprox::GetArcs( double dLinTol, double dAngTolDeg, PolyArc& PA)
-{
-  // pulisco il poliarco
-   PA.Clear() ;
-
-  // calcolo una parametrizzazione
-   if ( ! CalcParameterization())
-      return false ;
-
-  // calcolo le tangenti
-   if ( ! CalcAkimaTangents( false))
-      return false ;
-
-  // approssimo come unico tratto
-
-  // creo la polilinea che unisce i punti
-   PolyLine PL ;
-   int nPnt = int( m_vPnt.size()) ;
-   for ( int j = 0 ; j < nPnt ; ++ j)
-      PL.AddUPoint( j, m_vPnt[j]) ;
-  // verifico se retta verticale
-   BBox3d b3PL ;
-   if ( ! PL.GetLocalBBox( b3PL))
-      return false ;
-   if ( b3PL.GetDimX() < EPS_SMALL  &&  b3PL.GetDimY() < EPS_SMALL) {
-      PA.AddUPoint( 0, m_vPnt[0], 0) ;
-      PA.AddUPoint( nPnt - 1, m_vPnt[nPnt - 1], 0) ;
-   }
-  // altrimenti eseguo l'approssimazione con archi
-   else {
-      if ( ! BiArcOrSplit( 0, PL, dLinTol, dAngTolDeg, PA))
-         return false ;
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-CurveByApprox::GetArcsCorner( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA)
+CurveByApprox::GetArcs( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA)
 {
   // pulisco il poliarco
    PA.Clear() ;
@@ -153,18 +102,9 @@ CurveByApprox::GetArcsCorner( double dLinTol, double dAngTolDeg, double dLinFea,
       PolyLine PL ;
       for ( int j = nPrev ; j <= m_vSplits[i] ; ++ j)
          PL.AddUPoint( j, m_vPnt[j]) ;
-     // verifico se retta verticale
-      BBox3d b3PL ;
-      if ( ! PL.GetLocalBBox( b3PL))
+     // eseguo l'approssimazione con archi
+      if ( ! BiArcOrSplit( 0, PL, dLinTol, dAngTolDeg, PA))
          return false ;
-      if ( b3PL.GetDimX() < EPS_SMALL  &&  b3PL.GetDimY() < EPS_SMALL) {
-         PA.AddUPoint( m_vSplits[i], m_vPnt[m_vSplits[i]], 0) ;
-      }
-     // altrimenti eseguo l'approssimazione con archi
-      else {
-         if ( ! BiArcOrSplit( 0, PL, dLinTol, dAngTolDeg, PA))
-            return false ;
-      }
      // salvo fine come prox inizio
       nPrev = m_vSplits[i] ;
    }
@@ -439,12 +379,12 @@ CurveByApprox::CalcSplitPoints( double dLinTol, double dAngTolDeg, double dLinFe
          m_vSplits.push_back(i) ;
          continue ;
       }
-     // verifico linearità del tratto precedente
+     // verifico linearità del tratto precedente
       bool bPrevLin = vtPrev.SqLen() > dSqLinFea  &&
                       ( m_vNextDer[i-1] * m_vPrevDer[i]) > dAngTolCos  &&
                       ( vtPrev ^ m_vNextDer[i-1]).SqLen() < dSqLinTol  &&
                       ( vtPrev ^ m_vPrevDer[i]).SqLen() < dSqLinTol ;
-     // verifico linearità del tratto successivo
+     // verifico linearità del tratto successivo
       bool bNextLin = vtNext.SqLen() > dSqLinFea  &&
                       ( m_vNextDer[i] * m_vPrevDer[i+1]) > dAngTolCos  &&
                       ( vtNext ^ m_vNextDer[i]).SqLen() < dSqLinTol  &&
@@ -483,7 +423,7 @@ CurveByApprox::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAng
       PtrOwner<ICurve> pCrv ;
       double dMaxDist ;
 
-     // se la polilinea ha più di 2 punti
+     // se la polilinea ha più di 2 punti
       if ( PL.GetPointNbr() > 2)  {
         // calcolo punti e direzioni agli estremi della polilinea usando la curva di Bezier
          int nI ;
@@ -501,12 +441,11 @@ CurveByApprox::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAng
          ptP1 = m_vPnt[nI] ;
          m_vPrevDer[nI].ToSpherical( nullptr, nullptr, &dDir1Deg) ;
         // costruisco un biarco sulla polilinea (secondo metodo di Z. Sir)
-         pCrv.Set( GetBiArc( ptP0, dDir0Deg, ptP1, dDir1Deg, PL, dMaxDist, dLinTol)) ;
-        // forzo la spezzatura della curva
+         pCrv.Set( GetBiArc( ptP0, dDir0Deg, ptP1, dDir1Deg, PL, dMaxDist)) ;
          if ( IsNull( pCrv))
-            dMaxDist = 2 * dLinTol ;
+            return false ;
       }
-     // se la polilinea è formata da 2 punti
+     // se la polilinea è formata da 2 punti
       else if ( PL.GetPointNbr() == 2) {
         // se molto vicini, esco
          double dLen ;
@@ -514,9 +453,11 @@ CurveByApprox::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAng
             return true ;
         // costruisco la retta che li unisce
          PtrOwner<CurveComposite> pCC( CreateBasicCurveComposite()) ;
-         if ( IsNull( pCC)  ||  ! pCC->FromPolyLine( PL))
+         if ( IsNull( pCC))
             return false ;
-         pCrv.Set( pCC) ;
+         if ( ! pCC->FromPolyLine( PL))
+            return false ;
+         pCrv.Set( Release( pCC)) ;
          dMaxDist = 0 ;
       }
      // se la polilinea ha un solo punto, esco
@@ -525,15 +466,13 @@ CurveByApprox::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAng
 
      // se raggiunto il massimo livello di recursione, forzo l'accettazione del biarco
       if ( nLev >= MAX_LEV) {
-         if ( IsNull( pCrv))
-            return false ;
          dMaxDist = 0 ;
         // segnalo situazione per debug
          if ( GetEGkDebugLev() >= 5)
             LOG_DBG_ERR( GetEGkLogger(), "ERROR : Exceeded recursions")
       }
 
-     // se lunghezza abbastanza piccola, forzo l'accettazione della curva
+     // se lunghezza abbastanza picccola, forzo l'accettazione della curva
       double dLen ;
       if ( PL.GetApproxLength( dLen)  &&  dLen < 10 * EPS_SMALL)
          dMaxDist = 0 ;
@@ -564,7 +503,7 @@ CurveByApprox::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAng
       return false ;
    }
 
-  // spezzo l'intervallo in due parti a metà
+  // spezzo l'intervallo in due parti a metà
    double dParStart, dParEnd ;
    if ( ! PL.GetFirstU( dParStart)  ||  ! PL.GetLastU( dParEnd))
       return false ;
@@ -572,9 +511,9 @@ CurveByApprox::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAng
    PolyLine PL2 ;
    if ( ! PL.Split( dParMid, PL2))
       return false ;
-  // prima metà
+  // prima metà
    if ( ! BiArcOrSplit( nLev + 1, PL, dLinTol, dAngTolDeg, PA))
       return false ;
-  // seconda metà
+  // seconda metà
    return BiArcOrSplit( nLev + 1, PL2, dLinTol, dAngTolDeg, PA) ;
 }

CurveByInterp.cpp

@@ -14,10 +14,10 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CalcDerivate.h"
-#include "CurveBezier.h"
-#include "CurveComposite.h"
 #include "/EgtDev/Include/EGkCurveByInterp.h"
-#include "/EgtDev/Include/EGkBiArcs.h"
+#include "/EgtDev/Include/EgkCurveComposite.h"
+#include "/EgtDev/Include/EgkBiArcs.h"
+#include "/EgtDev/Include/EgkCurveBezier.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 
@@ -63,7 +63,7 @@ CurveByInterp::GetCurve( int nMethod, int nType)
   // se richiesti biarchi
    if ( nType == BIARCS) {
      // creo la curva composita
-      PtrOwner<CurveComposite> pCrvCompo( CreateBasicCurveComposite()) ;
+      PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
       if ( IsNull( pCrvCompo))
          return nullptr ;
      // ciclo sugli intervalli
@@ -83,13 +83,13 @@ CurveByInterp::GetCurve( int nMethod, int nType)
   // se richieste curve di Bezier cubiche
    if ( nType == CUBIC_BEZIERS) {
      // creo la curva composita
-      PtrOwner<CurveComposite> pCrvCompo( CreateBasicCurveComposite()) ;
+      PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
       if ( IsNull( pCrvCompo))
          return nullptr ;
      // ciclo sugli intervalli
       for ( int i = 1 ; i < int( m_vPnt.size()) ; ++ i) {
         // creo una curva di Bezier cubica per ogni intervallo
-         PtrOwner<CurveBezier> pCBez( CreateBasicCurveBezier()) ;
+         PtrOwner<ICurveBezier> pCBez( CreateCurveBezier()) ;
          if ( IsNull( pCBez))
             return nullptr ;
          pCBez->Init( 3, false) ;

CurveComposite.h

@@ -1,13 +1,12 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2022
+//  EgalTech 2013-2021
 //----------------------------------------------------------------------------
-// File : CurveComposite.h       Data : 24.03.22          Versione : 2.4c2
+// File : CurveComposite.h       Data : 03.04.21          Versione : 2.3d1
 // Contenuto : Dichiarazione della classe Curva composita.
 //
 //
 //
 // Modifiche : 16.04.13 DS Creazione modulo.
-//             24.03.22 DS Aggiunto metodo AddLineTg.
 //
 //
 //----------------------------------------------------------------------------
@@ -21,8 +20,6 @@
 #include "/EgtDev/Include/EGkCurveComposite.h"
 #include <deque>
 
-class Voronoi ;
-
 //----------------------------------------------------------------------------
 class CurveComposite : public ICurveComposite, public IGeoObjRW
 {
@@ -53,16 +50,10 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp, int nPropInd = 0) override
-              { if ( nPropInd >= 0  &&  nPropInd < 2)
-                   m_nTempProp[nPropInd] = nProp ; }
-      int  GetTempProp( int nPropInd = 0) const override
-              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
-      void SetTempParam( double dParam, int nParamInd = 0) override
-              { if ( nParamInd >= 0  &&  nParamInd < 2)
-                  m_dTempParam[nParamInd] = dParam ; } 
-      double GetTempParam( int nParamInd = 0) const override
-                { return (( nParamInd >= 0  &&  nParamInd < 2) ? m_dTempParam[nParamInd] : 0.0) ; }
+      void SetTempProp( int nProp) override
+              { m_nTempProp = nProp ; } 
+      int  GetTempProp( void) const override
+              { return m_nTempProp ; } 
 
    public :                      // ICurve
       bool IsSimple( void) const override
@@ -150,11 +141,10 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool IsParamAtJoint( double dU) const override ;
       ICurve* RemoveFirstOrLastCurve(  bool bLast = true) override ;
       bool ChangeStartPoint( double dU) override ;
-      bool AddPoint( const Point3d& ptStart) override ;  // funzione per aggiungere il ptStart prima di usare la funzione AddLine
+      bool AddPoint( const Point3d& ptStart) override ;
       bool AddLine( const Point3d& ptNew, bool bEndOrStart = true) override ;
-      bool AddLineTg( double dLen, bool bEndOrStart = true) override ;
-      bool AddArc2P( const Point3d& ptOther, const Point3d& ptNew, bool bEndOrStart = true) override ;
       bool AddArcTg( const Point3d& ptNew, bool bEndOrStart = true) override ;
+      bool AddArc2P( const Point3d& ptOther, const Point3d& ptNew, bool bEndOrStart = true) override ;
       bool AddJoint( double dU) override ;
       bool ModifyJoint( int nU, const Point3d& ptNewJoint) override ;
       bool RemoveJoint( int nU) override ;
@@ -163,33 +153,22 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool ModifyCurveToLine( int nCrv) override ;
       bool ArcsToBezierCurves( void) override ;
       bool ArcsBezierCurvesToArcsPerpExtr( double dLinTol, double dAngTolDeg) override ;
-      bool StraightArcsToLines( double dLinTol, double dAngTolDeg) override ;
       bool MergeCurves( double dLinTol, double dAngTolDeg, bool bStartEnd = true, bool bNeedSameProp = false) override ;
-      bool RemoveSmallParts( double dLinTol, double dAngTolDeg) override ;
-      bool RemoveSmallDefects( double dLinTol, double dAngTolDeg, bool bAlsoSpikes = false) override ;
       bool RemoveUndercutOnY( double dLinTol, double dAngTolDeg) override ;
       bool IsAPoint( void) const override ;
       bool IsALine( double dLinTol, Point3d& ptStart, Point3d& ptEnd) const override ;
       bool IsACircle( double dLinTol, Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW) const override ;
-      bool IsARectangle( double dLinTol, Point3d& ptP, Vector3d& vtL1, Vector3d& vtL2) const override ;
-      bool IsATrapezoid( double dLinTol, Point3d& ptP, Vector3d& vtB1, Vector3d& vtL1, Vector3d& vtB2) const override ;
-      bool SetCurveTempProp( int nCrv, int nProp, int nPropInd = 0) override ;
-      bool GetCurveTempProp( int nCrv, int& nProp, int nPropInd = 0) const override ;
-      bool SetCurveTempParam( int nCrv, double dParam, int nParamInd = 0) override ;
-      bool GetCurveTempParam( int nCrv, double& dParam, int nParamInd = 0) const override ;
-      bool GetOnlyPoint( Point3d& ptStart) const override ;
-      
+      bool SetCurveTempProp( int nCrv, int nProp) override ;
+      bool GetCurveTempProp( int nCrv, int& nProp) const override ;
+
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
-      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
-      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
-      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       CurveComposite( void) ;
-      CurveComposite( const CurveComposite& ccSrc) : m_pVoronoiObj( nullptr)
+      CurveComposite( const CurveComposite& ccSrc)
                      { if ( ! CopyFrom( ccSrc))
                           LOG_ERROR( GetEGkLogger(), "CurveComposite : copy constructor error") }
       CurveComposite& operator =( const CurveComposite& ccSrc)
@@ -198,82 +177,43 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
                        return *this ; }
       bool RelocateFrom( CurveComposite& ccSrc) ;
       bool GetApproxLength( double& dLen) const ;
-      Voronoi* GetVoronoiObject( void) const ;
-      void ResetVoronoiObject( void) const ;
 
    private :
       bool CopyFrom( const CurveComposite& ccSrc) ;
       bool Validate( void) ;
-      bool TestClosure( void) ;
       bool AddCurveByRelocate( CurveComposite& ccSrc, bool bEndOrStart = true, double dLinTol = EPS_SMALL) ;
       bool AddSimpleCurve( ICurve* pSmplCrv, bool bEndOrStart = true, double dLinTol = EPS_SMALL) ;
       bool GetIndSCurveAndLocPar( double dU, Side nS, int& nSCrv, double& dLocU) const ;
       bool SimpleOffsetXY( double dDist, int nType = OFF_FILLET) ;
-      bool IsOneCircle( Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW) const ;      
-      bool CalcVoronoiObject( void) const ;
+      bool IsOneCircle( Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW) const ;
 
    private :
-      enum Status { ERR = 0, OK = 1, TO_VERIFY = 2, IS_A_POINT = 3} ;
+      enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
 
    private :
       typedef std::deque<ICurve*>      PCRVSMPL_DEQUE ;
+      typedef PCRVSMPL_DEQUE::iterator PCSD_ITER ;
       typedef PCRVSMPL_DEQUE::const_iterator PCSD_CONST_ITER ;
 
    private :
-      ObjGraphicsMgr   m_OGrMgr ;        // gestore grafica dell'oggetto
-      Status           m_nStatus ;       // stato
-      PCRVSMPL_DEQUE   m_CrvSmplS ;      // deque di curve semplici
-      Vector3d         m_VtExtr ;        // vettore estrusione (normalmente coincide con m_VtN)
-      double           m_dThick ;        // spessore
-      Point3d          m_ptStart ;       // punto iniziale per composita vuota per Add di linee o archi
-      int              m_nTempProp[2] ;  // vettore proprietà temporanee
-      double           m_dTempParam[2] ; // vettore parametri temporanei 
-      mutable Voronoi* m_pVoronoiObj ;   // Voronoi
-      mutable PCSD_CONST_ITER m_Iter ;   // iteratore      
+      ObjGraphicsMgr m_OGrMgr ;        // gestore grafica dell'oggetto
+      Status         m_nStatus ;       // stato
+      PCRVSMPL_DEQUE m_CrvSmplS ;      // deque di curve semplici
+      Vector3d       m_VtExtr ;        // vettore estrusione (normalmente coincide con m_VtN)
+      double         m_dThick ;        // spessore
+      Point3d        m_ptStart ;       // punto iniziale per composita vuota per Add di linee o archi
+      int            m_nTempProp ;     // proprietà temporanea 
+      mutable PCSD_CONST_ITER m_Iter ; // iteratore
 } ;
 
 //-----------------------------------------------------------------------------
 inline CurveComposite* CreateBasicCurveComposite( void)
-               { return ( static_cast<CurveComposite*>( CreateGeoObj( CRV_COMPO))) ; }
+               { return (static_cast<CurveComposite*>( CreateGeoObj( CRV_COMPO))) ; }
 inline CurveComposite* CloneBasicCurveComposite( const IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_COMPO)
                     return nullptr ;
-                 return ( static_cast<CurveComposite*>( pGObj->Clone())) ; }
+                 return (static_cast<CurveComposite*>(pGObj->Clone())) ; }
 inline const CurveComposite* GetBasicCurveComposite( const IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_COMPO)
-                    return nullptr ;
-                 return ( static_cast<const CurveComposite*>( pGObj)) ; }
+               { return (dynamic_cast<const CurveComposite*>(pGObj)) ; }
 inline CurveComposite* GetBasicCurveComposite( IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_COMPO)
-                    return nullptr ;
-                 return ( static_cast<CurveComposite*>( pGObj)) ; }
-inline CurveComposite* ConvertCurveToBasicComposite( IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  ( pGObj->GetType() & GEO_CURVE) == 0) {
-                    delete pGObj ;
-                    return nullptr ;
-                 }
-                 CurveComposite* pCrvCo = CreateBasicCurveComposite() ;
-                 if ( pCrvCo == nullptr) {
-                    delete pGObj ;
-                    return nullptr ;
-                 }
-                 ICurve* pCrv = static_cast<ICurve*>( pGObj) ;
-                 Vector3d vtExtr ;
-                 if ( pCrv->GetExtrusion( vtExtr)  &&  ! vtExtr.IsSmall())
-                    pCrvCo->SetExtrusion( vtExtr) ;
-                 double dThick ;
-                 if ( pCrv->GetThickness( dThick)  &&  abs( dThick) > EPS_SMALL)
-                    pCrvCo->SetThickness( dThick) ;
-                 for ( int i = 0 ; i < 2 ; ++ i) {
-                    int nProp = pCrv->GetTempProp( i) ;
-                    if ( nProp != 0)
-                       pCrvCo->SetTempProp( nProp, i) ;
-                 }
-                 for ( int i = 0 ; i < 2 ; ++ i) {
-                    double dParam = pCrv->GetTempParam( i) ;
-                    if ( abs( dParam) > EPS_SMALL)
-                       pCrvCo->SetTempParam( dParam, i) ;
-                 }
-                 pCrvCo->AddCurve( pCrv) ;
-                 return pCrvCo ;
-               }
+               { return (dynamic_cast<CurveComposite*>(pGObj)) ; }

CurveCompositeOffset.cpp

@@ -17,8 +17,8 @@
 #include "CurveLine.h"
 #include "CurveArc.h"
 #include "GeoConst.h"
-#include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDev/Include/EGkIntersCurves.h"
+#include "/EgtDev/Include/EgkCurve.h"
+#include "/EgtDev/Include/EgkIntersCurves.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 using namespace std ;

CurveLine.cpp

@@ -14,13 +14,11 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "CurveLine.h"
+#include "DistPointLine.h"
 #include "GeoObjFactory.h"
 #include "NgeWriter.h"
 #include "NgeReader.h"
-#include "Voronoi.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include <new>
 
@@ -31,15 +29,13 @@ GEOOBJ_REGISTER( CRV_LINE, NGE_C_LIN, CurveLine) ;
 
 //----------------------------------------------------------------------------
 CurveLine::CurveLine( void)
-   : m_nStatus( TO_VERIFY), m_PtStart(), m_PtEnd(), m_VtExtr(), m_dThick(), 
-     m_nTempProp{0,0}, m_dTempParam{0.0,0.0}, m_pVoronoiObj( nullptr)
+   : m_nStatus( TO_VERIFY), m_PtStart(), m_PtEnd(), m_VtExtr(), m_dThick(), m_nTempProp()
 {
 }
 
 //----------------------------------------------------------------------------
 CurveLine::~CurveLine( void)
 {
-   ResetVoronoiObject() ;
 }
 
 //----------------------------------------------------------------------------
@@ -51,8 +47,6 @@ CurveLine::Set( const Point3d& ptStart, const Point3d& ptEnd)
    m_PtEnd = ptEnd ;
    m_nStatus = TO_VERIFY ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -72,8 +66,6 @@ CurveLine::SetPVL( const Point3d& ptStart, const Vector3d& vtDir, double dLen)
    m_PtEnd = ptStart + vtDelta ;
    m_nStatus = TO_VERIFY ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -91,8 +83,6 @@ CurveLine::SetPDL( const Point3d& ptStart, double dDirAngDeg, double dLen)
    m_PtEnd = ptStart + vtDelta ;
    m_nStatus = TO_VERIFY ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -119,7 +109,7 @@ CurveLine::Clone( void) const
 bool
 CurveLine::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const CurveLine* pCL = GetBasicCurveLine( pGObjSrc) ;
+   const CurveLine* pCL = dynamic_cast<const CurveLine*>( pGObjSrc) ;
    if ( pCL == nullptr)
       return false ;
    return CopyFrom( *pCL) ;
@@ -133,10 +123,7 @@ CurveLine::CopyFrom( const CurveLine& clSrc)
       return true ;
    m_VtExtr = clSrc.m_VtExtr ;
    m_dThick = clSrc.m_dThick ;
-   m_nTempProp[0] = clSrc.m_nTempProp[0] ;
-   m_nTempProp[1] = clSrc.m_nTempProp[1] ;
-   m_dTempParam[0] = clSrc.m_dTempParam[0] ;
-   m_dTempParam[1] = clSrc.m_dTempParam[1] ;
+   m_nTempProp = clSrc.m_nTempProp ;
    return Set( clSrc.m_PtStart, clSrc.m_PtEnd) ;
 }
 
@@ -162,7 +149,7 @@ CurveLine::Dump( string& sOut, bool bMM, const char* szNewLine) const
   // dati generali di una curva
    if ( ! CurveDump( *this, sOut, bMM, szNewLine))
       return false ;
-  // parametri : sono già compresi nei dati generali (PS e PE)
+  // parametri : sono già compresi nei dati generali (PS e PE)
 
    return true ;
 }
@@ -223,7 +210,7 @@ CurveLine::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
       return false ;
   // assegno il box in locale
    b3Loc.Set( m_PtStart, m_PtEnd) ;
-  // se c'è estrusione, devo tenerne conto
+  // se c'è estrusione, devo tenerne conto
    if ( ! m_VtExtr.IsSmall()  &&  abs( m_dThick) > EPS_SMALL) {
       Point3d ptMinExtr = b3Loc.GetMin() + m_VtExtr * m_dThick ;
       Point3d ptMaxExtr = b3Loc.GetMax() + m_VtExtr * m_dThick ;
@@ -241,7 +228,7 @@ CurveLine::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
   // porto gli estremi nel riferimento passato
@@ -251,7 +238,7 @@ CurveLine::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
    ptFrEnd.ToGlob( frRef) ;
   // assegno il box nel riferimento
    b3Ref.Set( ptFrStart, ptFrEnd) ;
-  // se c'è estrusione, devo tenerne conto
+  // se c'è estrusione, devo tenerne conto
    if ( ! m_VtExtr.IsSmall()  &&  abs( m_dThick) > EPS_SMALL) {
       Vector3d vtFrExtr = m_VtExtr ;
       vtFrExtr.ToGlob( frRef) ;
@@ -269,7 +256,7 @@ bool
 CurveLine::Validate( void)
 {
    if ( m_nStatus == TO_VERIFY)
-      m_nStatus = ( m_PtStart.IsValid() && m_PtEnd.IsValid() && ! AreSamePointApprox( m_PtStart, m_PtEnd) ? OK : ERR) ;
+      m_nStatus = ( ! AreSamePointApprox( m_PtStart, m_PtEnd) ? OK : ERR) ;
 
    return ( m_nStatus == OK) ;
 }
@@ -366,7 +353,10 @@ CurveLine::GetPointD1D2( double dU, Side nS, Point3d& ptPos, Vector3d* pvtDer1,
       return false ;
 
   // il parametro U deve essere compreso tra 0 e 1
-   dU = Clamp( dU, 0., 1.) ;
+   if ( dU < 0)
+      dU = 0 ;
+   else if ( dU > 1)
+      dU = 1 ;
 
   // calcolo del punto
    ptPos = Media( m_PtStart, m_PtEnd, dU) ;
@@ -390,7 +380,7 @@ CurveLine::GetLength( double& dLen) const
    if ( m_nStatus != OK)
       return false ;
 
-  // la lunghezza è la distanza tra gli estremi
+  // la lunghezza è la distanza tra gli estremi
    dLen = Dist( m_PtStart, m_PtEnd) ;
 
    return ( dLen > EPS_SMALL) ;
@@ -416,7 +406,7 @@ CurveLine::GetLengthAtParam( double dU, double& dLen) const
       return true ;
    }
 
-  // la lunghezza totale è la distanza tra gli estremi
+  // la lunghezza totale è la distanza tra gli estremi
    double dTotLen = Dist( m_PtStart, m_PtEnd) ;
 
   // fine
@@ -448,7 +438,7 @@ CurveLine::GetParamAtLength( double dLen, double& dU) const
       return true ;
    }
 
-  // la lunghezza totale è la distanza tra gli estremi
+  // la lunghezza totale è la distanza tra gli estremi
    double dTotLen = Dist( m_PtStart, m_PtEnd) ;
 
   // se dopo fine, errore
@@ -567,8 +557,6 @@ CurveLine::Invert( void)
   // inverto i punti estremi
    swap( m_PtStart, m_PtEnd) ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
   
@@ -600,8 +588,6 @@ CurveLine::SimpleOffset( double dDist, int nType)
    m_PtStart += vtDir * dDist ;
    m_PtEnd += vtDir * dDist ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -622,8 +608,6 @@ CurveLine::ModifyStart( const Point3d& ptNewStart)
   // assegno il nuovo inizio
    m_PtStart = ptNewStart ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -644,8 +628,6 @@ CurveLine::ModifyEnd( const Point3d& ptNewEnd)
   // assegno la nuova fine
    m_PtEnd = ptNewEnd ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -657,7 +639,7 @@ bool
 CurveLine::TrimStartAtParam( double dUTrim)
 {
   // riporto i parametri nel loro range
-   dUTrim = Clamp( dUTrim, 0., 1.) ;
+   dUTrim = ( ( dUTrim < 0) ? 0 : (( dUTrim > 1) ? 1 : dUTrim)) ;
 
   // recupero lunghezza
    double dLen ;
@@ -673,7 +655,7 @@ bool
 CurveLine::TrimEndAtParam( double dUTrim)
 {
   // riporto i parametri nel loro range
-   dUTrim = Clamp( dUTrim, 0., 1.) ;
+   dUTrim = ( ( dUTrim < 0) ? 0 : (( dUTrim > 1) ? 1 : dUTrim)) ;
 
   // recupero lunghezza
    double dLen ;
@@ -721,8 +703,6 @@ CurveLine::TrimStartAtLen( double dLenTrim)
    if ( dLenTrim > EPS_ZERO)
       m_PtStart = Media( m_PtStart, m_PtEnd, ( dLenTrim / dLen)) ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -747,8 +727,6 @@ CurveLine::TrimEndAtLen( double dLenTrim)
    if ( ( dLen - dLenTrim) > EPS_ZERO)
       m_PtEnd = Media( m_PtStart, m_PtEnd, ( dLenTrim / dLen)) ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -771,8 +749,6 @@ CurveLine::ExtendStartByLen( double dLenExt)
   // sposto il punto iniziale
    m_PtStart -= vtDir * dLenExt ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -795,8 +771,6 @@ CurveLine::ExtendEndByLen( double dLenExt)
   // sposto il punto finale
    m_PtEnd += vtDir * dLenExt ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -810,11 +784,6 @@ CurveLine::Translate( const Vector3d& vtMove)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-
-  // traslo Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->Translate( vtMove) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -832,14 +801,10 @@ CurveLine::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, do
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dell'asse di rotazione
+  // verifico validità dell'asse di rotazione
    if ( vtAx.IsSmall())
       return false ;
 
-  // ruoto Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -871,8 +836,6 @@ CurveLine::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double d
    if ( AreSamePointApprox( ptNewStart, ptNewEnd))
       return false ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -898,12 +861,10 @@ CurveLine::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del piano di specchiatura
+  // verifico validità del piano di specchiatura
    if ( vtNorm.IsSmall())
       return false ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -923,12 +884,10 @@ CurveLine::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& v
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dei parametri
+  // verifico validità dei parametri
    if ( vtNorm.IsSmall()  ||  vtDir.IsSmall())
       return false ;
 
-  // imposto ricalcolo di Voronoi
-   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -953,18 +912,10 @@ CurveLine::ToGlob( const Frame3d& frRef)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
-   if ( IsGlobFrame( frRef))
-      return true ;
-
-  // trasformo Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->ToGlob( frRef) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -979,18 +930,10 @@ CurveLine::ToLoc( const Frame3d& frRef)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validità del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
-  // se frame identità, non devo fare alcunché
-   if ( IsGlobFrame( frRef))
-      return true ;
-
-  // trasformo Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->ToLoc( frRef) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1005,18 +948,13 @@ CurveLine::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità dei frame
+  // verifico validità dei frame
    if ( frOri.GetType() == Frame3d::ERR  ||  frDest.GetType() == Frame3d::ERR)
       return false ;
-
-  // se i due riferimenti coincidono, non devo fare alcunché
+  // se i due riferimenti coincidono, non devo fare alcunché
    if ( AreSameFrame( frOri, frDest))
       return true ;
 
-  // trasformo Voronoi
-   if ( m_pVoronoiObj != nullptr)
-      m_pVoronoiObj->LocToLoc( frOri, frDest) ;
-
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1052,42 +990,3 @@ CurveLine::CalcPointParamPosiz( const Point3d& ptP, bool bOnXY, double& dU, int&
       nPos = ICurve::PP_MID ;       // nell'interno
    return true ;
 }
-
-//----------------------------------------------------------------------------
-bool
-CurveLine::CalcVoronoiObject() const
-{
-   if ( m_nStatus != OK)
-      return false ;
-
-  // creo oggetto vroni con la curva
-   m_pVoronoiObj = new( std::nothrow) Voronoi( this, false) ;
-   if ( m_pVoronoiObj == nullptr)
-      return false ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-Voronoi* 
-CurveLine::GetVoronoiObject() const
-{
-   if ( m_nStatus != OK)
-      return nullptr ;
-
-  // se non è stato calcolato, lo calcolo
-   if ( m_pVoronoiObj == nullptr)
-      CalcVoronoiObject() ;
-
-  // restituisco Voronoi
-   return m_pVoronoiObj ;
-}
-
-//----------------------------------------------------------------------------
-void
-CurveLine::ResetVoronoiObject() const
-{
-   if ( m_pVoronoiObj != nullptr)
-      delete m_pVoronoiObj ;
-   m_pVoronoiObj = nullptr ;
-}

CurveLine.h

@@ -19,8 +19,6 @@
 #include "GeoObjRW.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
 
-class Voronoi ;
-
 //----------------------------------------------------------------------------
 class CurveLine : public ICurveLine, public IGeoObjRW
 {
@@ -51,16 +49,10 @@ class CurveLine : public ICurveLine, public IGeoObjRW
                { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
                { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp, int nPropInd = 0) override
-              { if ( nPropInd >= 0  &&  nPropInd < 2)
-                   m_nTempProp[nPropInd] = nProp ; } 
-      int  GetTempProp( int nPropInd = 0) const override
-              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
-      void SetTempParam( double dParam, int nParamInd = 0) override
-              { if ( nParamInd >= 0  &&  nParamInd < 2)
-                  m_dTempParam[nParamInd] = dParam ; } 
-      double GetTempParam( int nParamInd = 0) const override
-                { return (( nParamInd >= 0  &&  nParamInd < 2) ? m_dTempParam[nParamInd] : 0.0) ; }
+      void SetTempProp( int nProp) override
+               { m_nTempProp = nProp ; }
+      int  GetTempProp( void) const override
+               { return m_nTempProp ; }
 
    public :                      // ICurve
       bool IsSimple( void) const override
@@ -146,55 +138,43 @@ class CurveLine : public ICurveLine, public IGeoObjRW
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
-      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
-      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
-      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       CurveLine( void) ;
-      CurveLine( const CurveLine& clSrc) : m_pVoronoiObj( nullptr)
+      CurveLine( const CurveLine& clSrc)
                   { if ( ! CopyFrom( clSrc))
                        LOG_ERROR( GetEGkLogger(), "CurveLine : copy constructor error") }
       CurveLine& operator =( const CurveLine& clSrc)
                   { if ( ! CopyFrom( clSrc))
                        LOG_ERROR( GetEGkLogger(), "CurveLine : copy error")
                     return *this ; }
-      Voronoi* GetVoronoiObject( void) const ;
-      void ResetVoronoiObject( void) const ;
 
    private :
       bool CopyFrom( const CurveLine& clSrc) ;
-      bool Validate( void) ;      
-      bool CalcVoronoiObject( void) const ;      
+      bool Validate( void) ;
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
 
    private :
-      ObjGraphicsMgr m_OGrMgr ;         // gestore grafica dell'oggetto
-      Status   m_nStatus ;              // stato
-      Point3d  m_PtStart ;              // punto iniziale
-      Point3d  m_PtEnd ;                // punto finale
-      Vector3d m_VtExtr ;               // vettore estrusione
-      double   m_dThick ;               // spessore
-      int      m_nTempProp[2] ;         // vettore proprietà temporanee
-      double   m_dTempParam[2] ;        // vettore parametri temporanei
-      mutable Voronoi* m_pVoronoiObj ;  // Voronoi
+      ObjGraphicsMgr m_OGrMgr ;        // gestore grafica dell'oggetto
+      Status   m_nStatus ;             // stato
+      Point3d  m_PtStart ;             // punto iniziale
+      Point3d  m_PtEnd ;               // punto finale
+      Vector3d m_VtExtr ;              // vettore estrusione
+      double   m_dThick ;              // spessore
+      int      m_nTempProp ;           // proprietà temporanea 
 } ;
 
 //-----------------------------------------------------------------------------
 inline CurveLine* CreateBasicCurveLine( void)
-               { return ( static_cast<CurveLine*>( CreateGeoObj( CRV_LINE))) ; }
+               { return (static_cast<CurveLine*>( CreateGeoObj( CRV_LINE))) ; }
 inline CurveLine* CloneBasicCurveLine( const IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_LINE)
                     return nullptr ;
-                 return ( static_cast<CurveLine*>( pGObj->Clone())) ; }
+                 return (static_cast<CurveLine*>(pGObj->Clone())) ; }
 inline const CurveLine* GetBasicCurveLine( const IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_LINE)
-                    return nullptr ;
-                 return ( static_cast<const CurveLine*>( pGObj)) ; }
+               { return (dynamic_cast<const CurveLine*>(pGObj)) ; }
 inline CurveLine* GetBasicCurveLine( IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_LINE)
-                    return nullptr ;
-                 return ( static_cast<CurveLine*>( pGObj)) ; }
+               { return (dynamic_cast<CurveLine*>(pGObj)) ; }

DistLineLine.cpp

@@ -1,42 +1,39 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2024
+//  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File : DistLineLine.cpp      Data : 10.05.24         Versione : 2.6e3
+// File : DistLineLine.h      Data : 06.11.20         Versione : 2.2k1
 // Contenuto : Implementazione della classe distanza fra elementi lineari.
 //
 //
 //
 // Modifiche : 06.11.20 LM Creazione modulo.
-//             12.08.22 DS Correzioni e migliorie varie.
+//
 //
 //----------------------------------------------------------------------------
 
 #include "stdafx.h"
-#include "/EgtDev/Include/EGkDistLineLine.h"
+#include "DistLineLine.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EGkGeoCollection.h"
 #include "/EgtDev/Include/EGkGeoConst.h"
-
-using namespace std ;
+#include <algorithm>
 
 //----------------------------------------------------------------------------
 DistLineLine::DistLineLine( const Point3d& ptSt1, const Point3d& ptEn1,
                             const Point3d& ptSt2, const Point3d& ptEn2,
                             bool bIsSegment1, bool bIsSegment2)
 {
-  // reset oggetto
-   m_dSqDist = - 1 ;
-   m_dDist = - 1 ;
-  // calcolo direzione segmenti
    Vector3d vtD1 = ptEn1 - ptSt1 ;
    double dLen1 = vtD1.Len() ;
    Vector3d vtD2 = ptEn2 - ptSt2 ;
-   double dLen2 = vtD2.Len() ;
-   if ( dLen1 < EPS_SMALL  ||  dLen2 < EPS_SMALL)
+   double dLen2 = vtD1.Len() ;
+   if ( dLen1 < EPS_SMALL  ||  dLen2 < EPS_SMALL) {
+      m_dSqDist = - 1 ;
+      m_dDist = - 1 ;
       return ;
+   }
    vtD1 /= dLen1 ;
    vtD2 /= dLen2 ;
-  // eseguo
    Calculate( ptSt1, vtD1, dLen1, ptSt2, vtD2, dLen2, bIsSegment1, bIsSegment2) ;
 }
 
@@ -46,43 +43,37 @@ DistLineLine::DistLineLine( const Point3d& ptSt1, const Vector3d& vtD1, double d
                             const Point3d& ptSt2, const Vector3d& vtD2, double dLen2,
                             bool bIsSegment1, bool bIsSegment2)
 {
-  // reset oggetto
-   m_dSqDist = - 1 ;
-   m_dDist = - 1 ;
-  // verifico segmenti
-   if ( dLen1 < EPS_SMALL  ||  dLen2 < EPS_SMALL)
+   if ( dLen1 < EPS_SMALL  ||  dLen2 < EPS_SMALL) {
+      m_dSqDist = - 1 ;
+      m_dDist = - 1 ;
       return ;
-  // eseguo
+   }
    Calculate( ptSt1, vtD1, dLen1, ptSt2, vtD2, dLen2, bIsSegment1, bIsSegment2) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-DistLineLine::GetSqDist( double& dSqDist) const
+DistLineLine::GetSqDist( double& dSqDist)
 {
    if ( m_dSqDist < 0)
       return false ;
-
    dSqDist = m_dSqDist ;
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-DistLineLine::GetDist( double& dDist) const
+DistLineLine::GetDist( double& dDist)
 {
    if ( m_dSqDist < 0)
       return false ;
-
-   if ( m_dDist < 0)
-      m_dDist = sqrt( m_dSqDist) ;
-   dDist = m_dDist ;
+   dDist = sqrt( m_dSqDist) ;
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-DistLineLine::GetMinDistPoints( Point3d& ptMinDist1, Point3d& ptMinDist2) const
+DistLineLine::GetMinDistPoints( Point3d& ptMinDist1, Point3d& ptMinDist2)
 {
    if ( m_dSqDist < 0)
       return false ;
@@ -93,48 +84,55 @@ DistLineLine::GetMinDistPoints( Point3d& ptMinDist1, Point3d& ptMinDist2) const
 
 //----------------------------------------------------------------------------
 bool
-DistLineLine::GetPositionsAtMinDistPoints( double& dPos1, double& dPos2) const
+DistLineLine::GetParamsAtMinDistPoints( double& dPar1, double& dPar2)
 {
    if ( m_dSqDist < 0)
       return false ;
-   dPos1 = m_dPos1 ;
-   dPos2 = m_dPos2 ;
+   dPar1 = m_dPar1 ;
+   dPar2 = m_dPar2 ;
    return true ;
 }
 
 //----------------------------------------------------------------------------
-// Calcola la distanza fra i due elementi lineari, i punti di minima distanza e le loro posizioni.
-// Se i due elementi sono paralleli i punti di minimo sono scelti secondo convenienza.
+// Calcola la distanza fra i due elemnti lineari, i punti di minima distanza e
+// i loro rispettivi parametri.
+// Se la coppia di punti di minima distanza non è unica ne viene scelta una
+// in base a comodità di calcolo.
 void
 DistLineLine::Calculate( const Point3d& ptSt1, const Vector3d& vtD1, double dLen1,
                          const Point3d& ptSt2, const Vector3d& vtD2, double dLen2,
                          bool bIsSegment1, bool bIsSegment2)
 {
-  // Se elementi paralleli o antiparalleli
+  // Caso di elementi lineari paralleli/antiparalleli
    if ( AreSameOrOppositeVectorExact( vtD1, vtD2)) {
-     // Se il primo elemento è una retta infinita
-      if ( ! bIsSegment1) {
-         Vector3d vtStSt = ptSt2 - ptSt1 ;
-         double dLong = vtStSt * vtD1 ;
-         Vector3d vtDist = vtStSt - dLong * vtD1 ;
-         m_dSqDist = vtDist.SqLen() ;
-         m_dPos1 = dLong ;
-         m_dPos2 = 0 ;
-         m_ptMinDist1 = ptSt1 + dLong * vtD1 ;
-         m_ptMinDist2 = ptSt2 ;
-      } 
-     // se altrimenti il secondo elemento è una retta infinita
-      else if ( ! bIsSegment2) {
-         Vector3d vtStSt = ptSt1 - ptSt2 ;
-         double dLong = vtStSt * vtD2 ;
-         Vector3d vtDist = vtStSt - dLong * vtD2 ;
-         m_dSqDist = vtDist.SqLen() ;
-         m_dPos1 = 0 ;
-         m_dPos2 = dLong ;
-         m_ptMinDist1 = ptSt1 ;
-         m_ptMinDist2 = ptSt2 + dLong * vtD2 ;
+     // Almeno un elemento è una retta
+      if ( ! ( bIsSegment1  &&  bIsSegment2)) {
+        // Il primo elemento è segmento, quindi deve essere una retta il secondo
+         if ( bIsSegment1) {
+            Vector3d vtStSt = ptSt1 - ptSt2 ;
+            double dLong = vtStSt * vtD2 ;
+            Vector3d vtDist = vtStSt - dLong * vtD2 ;
+            m_dSqDist = vtDist.SqLen() ;
+            m_dDist = sqrt( m_dSqDist) ;
+            m_dPar1 = 0 ;
+            m_dPar2 = dLong ;
+            m_ptMinDist1 = ptSt1 ;
+            m_ptMinDist2 = ptSt2 + dLong * vtD2 ;
+         }
+        // Il primo elemento è una retta
+         else {
+            Vector3d vtStSt = ptSt2 - ptSt1 ;
+            double dLong = vtStSt * vtD1 ;
+            Vector3d vtDist = vtStSt - dLong * vtD1 ;
+            m_dSqDist = vtDist.SqLen() ;
+            m_dDist = sqrt( m_dSqDist) ;
+            m_dPar1 = dLong ;
+            m_dPar2 = 0 ;
+            m_ptMinDist1 = ptSt1 + dLong * vtD1 ;
+            m_ptMinDist2 = ptSt2 ;
+         }
       }
-     // altrimenti entrambi gli elementi sono segmenti
+     // Entrambi gli elementi sono segmenti
       else {
          Point3d ptEn1 = ptSt1 + dLen1 * vtD1 ;
          Point3d ptEn2 = ptSt2 + dLen2 * vtD2 ;
@@ -142,7 +140,7 @@ DistLineLine::Calculate( const Point3d& ptSt1, const Vector3d& vtD1, double dLen
          Vector3d vtStEn = ptEn2 - ptSt1 ;
          double dStU = vtStSt * vtD1 ;
          double dEnU = vtStEn * vtD1 ;
-        // Classifico i punti del secondo segmento in base alla loro
+        // Classifico i punti del segmento segmento in base alla loro
         // coordinata rispetto all'ordinamento generato dal primo.
          double dMinPar, dMaxPar ;
          Point3d ptMinPar, ptMaxPar ;
@@ -161,71 +159,70 @@ DistLineLine::Calculate( const Point3d& ptSt1, const Vector3d& vtD1, double dLen
         // Possibili posizioni reciproche dei segmenti
          if ( dMinPar > dLen1) {
             m_dSqDist = SqDist( ptEn1, ptMinPar) ;
+            m_dDist = sqrt( m_dSqDist) ;
             m_ptMinDist1 = ptEn1 ;
             m_ptMinDist2 = ptMinPar ;
-            m_dPos1 = dLen1 ;
-            m_dPos2 = Clamp( ( m_ptMinDist2 - ptSt2) * vtD2, 0., dLen2) ;
+            m_dPar1 = dLen1 ;
+            m_dPar2 = Clamp( ( m_ptMinDist2 - ptSt2) * vtD2, 0., dLen2) ;
          }
          else if ( dMinPar > 0) {
-            m_dSqDist = max( vtStSt * vtStSt - dStU * dStU, 0.) ;
+            m_dSqDist = std::max( vtStSt * vtStSt - dStU * dStU, 0.) ;
+            m_dDist = sqrt( m_dSqDist) ;
             m_ptMinDist1 = ptSt1 + dMinPar * vtD1 ;
             m_ptMinDist2 = ptMinPar ;
-            m_dPos1 = dMinPar ;
-            m_dPos2 = Clamp( ( m_ptMinDist2 - ptSt2) * vtD2, 0., dLen2) ;
+            m_dPar1 = dMinPar ;
+            m_dPar2 = Clamp( ( m_ptMinDist2 - ptSt2) * vtD2, 0., dLen2) ;
          }
          else if ( dMaxPar > 0) {
-            m_dSqDist = max( vtStSt * vtStSt - dStU * dStU, 0.) ;
+            m_dSqDist = std::max( vtStSt * vtStSt - dStU * dStU, 0.) ;
+            m_dDist = sqrt( m_dSqDist) ;
             m_ptMinDist1 = ptSt1 ;
             m_ptMinDist2 = ptSt2 + ( ptSt1 - ptSt2) * vtD2 * vtD2 ;
-            m_dPos1 = 0 ;
-            m_dPos2 = Clamp( ( m_ptMinDist2 - ptSt2) * vtD2, 0., dLen2) ;
+            m_dPar1 = 0 ;
+            m_dPar2 = Clamp( ( m_ptMinDist2 - ptSt2) * vtD2, 0., dLen2) ;
          }
          else {
             m_dSqDist = SqDist( ptSt1, ptMaxPar) ;
+            m_dDist = sqrt( m_dSqDist) ;
             m_ptMinDist1 = ptSt1 ;
             m_ptMinDist2 = ptMaxPar ;
-            m_dPos1 = 0 ;
-            m_dPos2 = Clamp( ( m_ptMinDist2 - ptSt2) * vtD2, 0., dLen2) ;
+            m_dPar1 = 0 ;
+            m_dPar2 = Clamp( ( m_ptMinDist2 - ptSt2) * vtD2, 0., dLen2) ;
          }
       }
+      return ;
    }
   // Caso generale
-   else {
-     // Posizioni a distanza minima tra rette illimitate
-      Vector3d vtStSt = ptSt2 - ptSt1 ;
-      double dDist01 = vtStSt * vtD1 ;
-      double dDist02 = vtStSt * vtD2 ;
-      double dDotD1D2 = vtD1 * vtD2 ;
-      double dT1 = ( dDist01 - dDotD1D2 * dDist02) / ( 1 - dDotD1D2 * dDotD1D2) ;
-      double dT2 = ( dDotD1D2 * dDist01 - dDist02) / ( 1 - dDotD1D2 * dDotD1D2) ;
-     // Posizioni minime e massime sui segmenti
-      double dMin1 = ( bIsSegment1 ? 0 : -INFINITO) ;
-      double dMax1 = ( bIsSegment1 ? dLen1 : INFINITO) ;
-      double dMin2 = ( bIsSegment2 ? 0 : -INFINITO) ;
-      double dMax2 = ( bIsSegment2 ? dLen2 : INFINITO) ;
-     // Se entrambe le posizioni stanno nei segmenti 
-      if ( dT1 >= dMin1  &&  dT1 <= dMax1  &&  dT2 >= dMin2  &&  dT2 <= dMax2) {
-         m_dPos1 = dT1 ;
-         m_dPos2 = dT2 ;
-      }
-     // se altrimenti solo la prima sta nel segmento
-      else if ( dT1 >= dMin1  &&  dT1 <= dMax1) {
-         m_dPos2 = Clamp( dT2, dMin2, dMax2) ;
-         m_dPos1 = Clamp( (( ptSt2 + m_dPos2 * vtD2) - ptSt1) * vtD1, dMin1, dMax1) ;
-      }
-     // se altrimenti solo la seconda sta nel segmento
-      else if ( dT2 >= dMin2  &&  dT2 <= dMax2) {
-         m_dPos1 = Clamp( dT1, dMin1, dMax1) ;
-         m_dPos2 = Clamp( (( ptSt1 + m_dPos1 * vtD1) - ptSt2) * vtD2, dMin2, dMax2) ;
-      }
-     // altrimenti nessuna sta nel suo segmento
-      else {
-         m_dPos1 = Clamp( dT1, dMin1, dMax1) ;
-         m_dPos2 = Clamp( (( ptSt1 + m_dPos1 * vtD1) - ptSt2) * vtD2, dMin2, dMax2) ;
-         m_dPos1 = Clamp( (( ptSt2 + m_dPos2 * vtD2) - ptSt1) * vtD1, dMin1, dMax1) ;
-      }
-      m_ptMinDist1 = ptSt1 + m_dPos1 * vtD1 ;
-      m_ptMinDist2 = ptSt2 + m_dPos2 * vtD2 ;
-      m_dSqDist = SqDist( m_ptMinDist1, m_ptMinDist2) ;
+   Vector3d vtDist0 = ptSt2 - ptSt1 ;
+   double dDist01 = vtDist0 * vtD1 ;
+   double dDist02 = vtDist0 * vtD2 ;
+   double dDotD1D2 = vtD1 * vtD2 ;
+   double dT1 = dDist01 + ( ( dDist01 * dDotD1D2 - dDist02) * dDotD1D2) / ( 1 - dDotD1D2 * dDotD1D2) ;
+   double dT2 = ( dDist01 * dDotD1D2 - dDist02) / ( 1 - dDotD1D2 * dDotD1D2) ;
+   double dMin1 = - INFINITO ;
+   double dMax1 = INFINITO ;
+   double dMin2 = - INFINITO ;
+   double dMax2 = INFINITO ;
+   double dSt1On2 = ( ptSt1 - ptSt2) * vtD2 ;
+   double dEn1On2 = ( ptSt1 + dLen1 * vtD1 - ptSt2) * vtD2 ;
+   if ( bIsSegment1) {
+      dMin1 = 0 ;
+      dMax1 = dLen1 ;
+      dMin2 = std::min( dSt1On2, dEn1On2) ;
+      dMax2 = std::max( dSt1On2, dEn1On2) ;
    }
-}
+   if ( bIsSegment2) {
+      double dSt2On1 = ( ptSt2 - ptSt1) * vtD1 ;
+      double dEn2On1 = ( ptSt2 + dLen2 * vtD2 - ptSt1) * vtD1 ;
+      dMin1 = std::max( dMin1, std::min( dSt2On1, dEn2On1)) ;
+      dMax1 = std::min( dMax1, std::max( dSt2On1, dEn2On1)) ;
+      dMin2 = std::max( dMin2, 0.) ;
+      dMax2 = std::min( dMax2, dLen2) ;
+   }
+   m_dPar1 = Clamp( dT1, dMin1, dMax1) ;
+   m_dPar2 = Clamp( dT2, dMin2, dMax2) ;
+   m_ptMinDist1 = ptSt1 + m_dPar1 * vtD1 ;
+   m_ptMinDist2 = ptSt2 + m_dPar2 * vtD2 ;
+   m_dSqDist = SqDist( m_ptMinDist1, m_ptMinDist2) ;
+   m_dDist = sqrt( m_dSqDist) ;
+}  

DistLineLine.h

@@ -0,0 +1,53 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2020-2020
+//----------------------------------------------------------------------------
+// File : DistLineLine.h      Data : 06.11.20         Versione : 2.2k1
+// Contenuto : Dichiarazione della classe distanza fra elementi lineari.
+//
+//
+//
+// Modifiche : 06.11.20 LM Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkVector3d.h"
+#include "/EgtDev/Include/EGkPoint3d.h"
+
+//----------------------------------------------------------------------------
+class DistLineLine
+{
+   public :
+      DistLineLine( const Point3d& ptSt1, const Point3d& ptEn1,
+                    const Point3d& ptSt2, const Point3d& ptEn2,
+                    bool bIsSegment1 = true, bool bIsSegment2 = true) ;
+      DistLineLine( const Point3d& ptSt1, const Vector3d& vtD1, double dLen1,
+                    const Point3d& ptSt2, const Vector3d& vtD2, double dLen2,
+                    bool bIsSegment1 = true, bool bIsSegment2 = true) ;
+
+   public :
+      bool GetSqDist( double& dSqDist) ;
+      bool GetDist( double& dDist) ;
+      bool IsEpsilon( double dTol) {
+         double dSqDist ;
+         return ( GetSqDist( dSqDist)  &&  ( dSqDist < SQ_EPS_ZERO  ||  dSqDist < dTol * dTol)) ;
+      }
+      bool IsSmall( void) { return IsEpsilon( EPS_SMALL) ; }
+      bool IsZero( void) { return IsEpsilon( EPS_ZERO) ;  }
+      bool GetMinDistPoints( Point3d& ptMinDist1, Point3d& ptMinDist2) ;
+      bool GetParamsAtMinDistPoints( double& dPar1, double& dPar2) ;
+
+   private :
+      void Calculate( const Point3d& ptSt1, const Vector3d& vtD1, double dLen1,
+                      const Point3d& ptSt2, const Vector3d& vtD2, double dLen2,
+                      bool bIsSegment1 = true, bool bIsSegment2 = true) ;
+   private:
+      double  m_dSqDist ;
+      double  m_dDist ;
+      double  m_dPar1 ;
+      double  m_dPar2 ;
+      Point3d m_ptMinDist1 ;
+      Point3d m_ptMinDist2 ;
+} ;

DistPointArc.cpp

@@ -122,13 +122,14 @@ DistPointArc::DistPointHelix( const Point3d& ptP, const ICurveArc& arArc)
 
   // cerco la minima distanza per la polilinea
    MDCVECTOR vApproxMin ;
+   MDCVECTOR::iterator Iter ;
    if ( ! CalcMinDistPointPolyLine( ptP, PL, dLinTol, vApproxMin))
       return ;
 
   // raffino i punti trovati
    double dPolishedPar ;
    Point3d ptPolishedQ ;
-   for ( auto Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
+   for ( Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
      // eseguo raffinamento
       if ( PolishMinDistPointCurve( ptP, arArc, *Iter, dPolishedPar, ptPolishedQ)) {
          (*Iter).dDist = Dist( ptP, ptPolishedQ) ;
@@ -147,7 +148,7 @@ DistPointArc::DistPointHelix( const Point3d& ptP, const ICurveArc& arArc)
 
 //----------------------------------------------------------------------------
 bool
-DistPointArc::GetSqDist( double& dSqDist) const
+DistPointArc::GetSqDist( double& dSqDist)
 {
    if ( m_dDist < 0)
       return false ;
@@ -158,7 +159,7 @@ DistPointArc::GetSqDist( double& dSqDist) const
 
 //----------------------------------------------------------------------------
 bool
-DistPointArc::GetDist( double& dDist) const
+DistPointArc::GetDist( double& dDist)
 {
    if ( m_dDist < 0)
       return false ;
@@ -169,7 +170,7 @@ DistPointArc::GetDist( double& dDist) const
 
 //----------------------------------------------------------------------------
 bool
-DistPointArc::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const
+DistPointArc::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag)
 {
    if ( m_dDist < 0)
       return false ;
@@ -184,7 +185,7 @@ DistPointArc::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const
 
 //----------------------------------------------------------------------------
 bool
-DistPointArc::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const
+DistPointArc::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag)
 {
    if ( m_dDist < 0)
       return false ;

DistPointArc.h

@@ -27,18 +27,17 @@ class DistPointArc
       DistPointArc( const Point3d& ptP, const ICurveArc& arArc) ;
 
    public :
-      bool GetSqDist( double& dSqDist) const ;
-      bool GetDist( double& dDist) const ;
-      bool IsEpsilon( double dTol) const
+      bool GetSqDist( double& dSqDist) ;
+      bool GetDist( double& dDist) ;
+      bool IsEpsilon( double dTol)
               { double dSqDist ; return ( GetSqDist( dSqDist) && ( dSqDist < SQ_EPS_ZERO || dSqDist < dTol * dTol)) ; }
-      bool IsSmall( void) const
+      bool IsSmall( void)
               { return IsEpsilon( EPS_SMALL) ; }
-      bool IsZero( void) const
+      bool IsZero( void)
               { return IsEpsilon( EPS_ZERO) ; }
-      int  GetNbrMinDist( void) const
-              { return (int) m_Info.size() ; }
-      bool GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const ;
-      bool GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const ;
+      int  GetNbrMinDist( void) { return (int) m_Info.size() ; }
+      bool GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) ;
+      bool GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) ;
 
    private :
       DistPointArc( void) ;

DistPointCrvAux.cpp

@@ -14,39 +14,42 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "DllMain.h"
-#include "GeoConst.h"
 #include "DistPointCrvAux.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
+#include "DistPointLine.h"
+#include "GeoConst.h"
 
 
 //----------------------------------------------------------------------------
 bool
 CalcMinDistPointPolyLine( const Point3d& ptP, PolyLine& PL, double dLinTol, MDCVECTOR& vApproxMin)
 {
+   double dSqDist ;
+   double dPar ;
+   double dUIni ;
+   double dUFin ;
+   Point3d ptIni ;
+   Point3d ptFin ;
+   double dMinDist ;
+   double dSqMinDist ;
+   MinDistCalc approxMin ;
 
-   vApproxMin.reserve( 4) ;
-   vApproxMin.clear() ;
 
    bool bFound = false ;
    bool bOnEnd = false ;
-   double dUIni, dUFin ;
-   Point3d ptIni, ptFin ;
-   double dMinDist, dSqMinDist ;
+   vApproxMin.reserve( 4) ;
+   vApproxMin.clear() ;
    for ( bool bLine = PL.GetFirstULine( &dUIni, &ptIni, &dUFin, &ptFin) ;
          bLine ;
          bLine = PL.GetNextULine( &dUIni, &ptIni, &dUFin, &ptFin)) {
      // calcolo la distanza del punto dal segmento
       DistPointLine dstPtLn( ptP, ptIni, ptFin) ;
-      double dSqDist ;
       if ( ! dstPtLn.GetSqDist( dSqDist))
          continue ;
      // altro punto con la stessa minima distanza già trovata
       if ( bFound  &&  abs( dSqDist - dSqMinDist) < 2 * dMinDist * dLinTol) {
         // salvo i dati nella struttura
-         MinDistCalc approxMin ;
          approxMin.dDist = dMinDist ;
          dstPtLn.GetMinDistPoint( approxMin.ptQ) ;
-         double dPar ;
          dstPtLn.GetParamAtMinDistPoint( dPar) ;
          approxMin.dPar = ( 1 - dPar) * dUIni + dPar * dUFin ;
          approxMin.dParMin = dUIni ;
@@ -63,10 +66,8 @@ CalcMinDistPointPolyLine( const Point3d& ptP, PolyLine& PL, double dLinTol, MDCV
          dSqMinDist = dSqDist ;
          dMinDist = sqrt( dSqMinDist) ;
         // salvo i dati nella struttura
-         MinDistCalc approxMin ;
          approxMin.dDist = dMinDist ;
          dstPtLn.GetMinDistPoint( approxMin.ptQ) ;
-         double dPar ;
          dstPtLn.GetParamAtMinDistPoint( dPar) ;
          approxMin.dPar = ( 1 - dPar) * dUIni + dPar * dUFin ;
          approxMin.dParMin = dUIni ;
@@ -156,10 +157,13 @@ bool
 FilterMinDistPointCurve( const Point3d& ptP, const ICurve& cCurve,
                          const MDCVECTOR& vApproxMin, double& dMinDist, MDPCIVECTOR& Info)
 {
+   MDCVECTOR::const_iterator Iter ;
+
+
   // determino i minimi raffinati da tenere
    bool bFound = false ;
    bool bLastOnEnd = false ;       // flag per ultimo punto su fine del suo intervallo
-   for ( auto Iter = vApproxMin.cbegin() ; Iter != vApproxMin.cend() ; ++Iter) {
+   for ( Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
      // altro punto con la stessa minima distanza
       if ( bFound  &&  abs( (*Iter).dDist - dMinDist) < EPS_SMALL) {
         // se abbastanza lontano e non su bordi intervallino lo aggiungo

DistPointCrvBezier.cpp

@@ -44,6 +44,7 @@ DistPointCrvBezier::DistPointCrvBezier( const Point3d& ptP, const ICurveBezier&
 
   // cerco la minima distanza per la polilinea
    MDCVECTOR vApproxMin ;
+   MDCVECTOR::iterator Iter ;
    if ( ! CalcMinDistPointPolyLine( ptP, PL, dLinTol, vApproxMin))
       return ;
 
@@ -51,7 +52,7 @@ DistPointCrvBezier::DistPointCrvBezier( const Point3d& ptP, const ICurveBezier&
    double dSingP ;
    if ( CrvBez.GetSingularParam( dSingP) == 0)
       dSingP = - 1 ;
-   for ( auto Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
+   for ( Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
      // imposto flag per singolarità agli estremi
       (*Iter).bParMinSing = abs( (*Iter).dParMin - dSingP) < EPS_SMALL ; 
       (*Iter).bParMaxSing = abs( (*Iter).dParMax - dSingP) < EPS_SMALL ; 
@@ -60,7 +61,7 @@ DistPointCrvBezier::DistPointCrvBezier( const Point3d& ptP, const ICurveBezier&
   // raffino i punti trovati
    double dPolishedPar ;
    Point3d ptPolishedQ ;
-   for ( auto Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
+   for ( Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
      // eseguo raffinamento
       if ( PolishMinDistPointCurve( ptP, CrvBez, *Iter, dPolishedPar, ptPolishedQ)) {
          (*Iter).dDist = Dist( ptP, ptPolishedQ) ;
@@ -79,7 +80,7 @@ DistPointCrvBezier::DistPointCrvBezier( const Point3d& ptP, const ICurveBezier&
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvBezier::GetSqDist( double& dSqDist) const
+DistPointCrvBezier::GetSqDist( double& dSqDist)
 {
    if ( m_dDist < 0)
       return false ;
@@ -90,7 +91,7 @@ DistPointCrvBezier::GetSqDist( double& dSqDist) const
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvBezier::GetDist( double& dDist) const
+DistPointCrvBezier::GetDist( double& dDist)
 {
    if ( m_dDist < 0)
       return false ;
@@ -101,7 +102,7 @@ DistPointCrvBezier::GetDist( double& dDist) const
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvBezier::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const
+DistPointCrvBezier::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag)
 {
    if ( m_dDist < 0)
       return false ;
@@ -116,7 +117,7 @@ DistPointCrvBezier::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) c
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvBezier::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const
+DistPointCrvBezier::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag)
 {
    if ( m_dDist < 0)
       return false ;

DistPointCrvBezier.h

@@ -27,18 +27,17 @@ class DistPointCrvBezier
       DistPointCrvBezier( const Point3d& ptP, const ICurveBezier& CrvBez) ;
 
    public :
-      bool GetSqDist( double& dSqDist) const ;
-      bool GetDist( double& dDist) const ;
-      bool IsEpsilon( double dTol) const
+      bool GetSqDist( double& dSqDist) ;
+      bool GetDist( double& dDist) ;
+      bool IsEpsilon( double dTol)
               { double dSqDist ; return ( GetSqDist( dSqDist) && ( dSqDist < SQ_EPS_ZERO || dSqDist < dTol * dTol)) ; }
-      bool IsSmall( void) const
+      bool IsSmall( void)
               { return IsEpsilon( EPS_SMALL) ; }
-      bool IsZero( void) const
+      bool IsZero( void)
               { return IsEpsilon( EPS_ZERO) ; }
-      int  GetNbrMinDist( void) const
-              { return (int) m_Info.size() ; }
-      bool GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const ;
-      bool GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const ;
+      int  GetNbrMinDist( void) { return (int) m_Info.size() ; }
+      bool GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) ;
+      bool GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) ;
 
    private :
       DistPointCrvBezier( void) ;

DistPointCrvComposite.cpp

@@ -50,7 +50,7 @@ DistPointCrvComposite::DistPointCrvComposite( const Point3d& ptP, const ICurveCo
       }
      // altrimenti, per curve successive
       else {
-        // verifico se la distanza minima dal box è superiore al minimo già trovato
+        // verifico se la distanza minima dal box è superiore al minimo già trovato
          BBox3d b3B ;
          if ( pCrvSmpl->GetLocalBBox( b3B)  &&
               b3B.SqDistFromPoint( ptP) <= m_dDist * m_dDist) {
@@ -89,23 +89,13 @@ DistPointCrvComposite::DistPointCrvComposite( const Point3d& ptP, const ICurveCo
                      }
                   }
                  // altrimenti aggiungo
-                  else {
-                     if ( dCurrDist < m_dDist) {
-                       // aggiorno i minimi
-                        m_dDist = dCurrDist ;
-                       // inserisco in testa
-                        m_Info.insert( m_Info.begin(), aInfo) ;                       
-                     }
-                     else {
-                       // inserisco in coda
-                        m_Info.push_back( aInfo) ;
-                     }
-                  }
+                  else
+                     m_Info.push_back( aInfo) ;
                  // passo al successivo
                   ++ i ;
                }
             }
-           // con minima distanza più bassa
+           // con minima distanza più bassa
             else if ( dCurrDist < m_dDist) {
               // aggiorno i minimi
                m_dDist = dCurrDist ;
@@ -129,7 +119,7 @@ DistPointCrvComposite::DistPointCrvComposite( const Point3d& ptP, const ICurveCo
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvComposite::GetSqDist( double& dSqDist) const
+DistPointCrvComposite::GetSqDist( double& dSqDist)
 {
    if ( m_dDist < 0)
       return false ;
@@ -140,7 +130,7 @@ DistPointCrvComposite::GetSqDist( double& dSqDist) const
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvComposite::GetDist( double& dDist) const
+DistPointCrvComposite::GetDist( double& dDist)
 {
    if ( m_dDist < 0)
       return false ;
@@ -151,7 +141,7 @@ DistPointCrvComposite::GetDist( double& dDist) const
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvComposite::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const
+DistPointCrvComposite::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag)
 {
    if ( m_dDist < 0)
       return false ;
@@ -166,7 +156,7 @@ DistPointCrvComposite::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvComposite::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const
+DistPointCrvComposite::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag)
 {
    if ( m_dDist < 0)
       return false ;

DistPointCrvComposite.h

@@ -26,18 +26,17 @@ class DistPointCrvComposite
       DistPointCrvComposite( const Point3d& ptP, const ICurveComposite& CrvCompo) ;
 
    public :
-      bool GetSqDist( double& dSqDist) const ;
-      bool GetDist( double& dDist) const ;
-      bool IsEpsilon( double dTol) const
+      bool GetSqDist( double& dSqDist) ;
+      bool GetDist( double& dDist) ;
+      bool IsEpsilon( double dTol)
               { double dSqDist ; return ( GetSqDist( dSqDist) && ( dSqDist < SQ_EPS_ZERO || dSqDist < dTol * dTol)) ; }
-      bool IsSmall( void) const
+      bool IsSmall( void)
               { return IsEpsilon( EPS_SMALL) ; }
-      bool IsZero( void) const
+      bool IsZero( void)
               { return IsEpsilon( EPS_ZERO) ; }
-      int  GetNbrMinDist( void) const
-              { return (int) m_Info.size() ; }
-      bool GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const ;
-      bool GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const ;
+      int  GetNbrMinDist( void) { return (int) m_Info.size() ; }
+      bool GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) ;
+      bool GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) ;
 
    private :
       DistPointCrvComposite( void) ;

DistPointCurve.cpp

@@ -13,10 +13,10 @@
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
+#include "DistPointLine.h"
 #include "DistPointArc.h"
 #include "DistPointCrvBezier.h"
 #include "DistPointCrvComposite.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 
 
@@ -47,8 +47,6 @@ DistPointCurve::DistPointCurve( const Point3d& ptP, const ICurve& Curve, bool bI
    case CRV_COMPO :
       CrvCompositeCalculate( ptP, Curve) ;
       break ;
-   default :
-      break ;
    }
   // salvo il punto
    m_ptP = ptP ;
@@ -100,7 +98,7 @@ DistPointCurve::CrvCompositeCalculate( const Point3d& ptP, const ICurve& Curve)
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetSqDist( double& dSqDist) const
+DistPointCurve::GetSqDist( double& dSqDist)
 {
    if ( m_dDist < 0)
       return false ;
@@ -111,7 +109,7 @@ DistPointCurve::GetSqDist( double& dSqDist) const
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetDist( double& dDist) const
+DistPointCurve::GetDist( double& dDist)
 {
    if ( m_dDist < 0)
       return false ;
@@ -122,7 +120,7 @@ DistPointCurve::GetDist( double& dDist) const
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const
+DistPointCurve::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag)
 {
    if ( m_dDist < 0  ||  nInd < 0  ||  nInd >= (int) m_Info.size())
       return false ;
@@ -134,7 +132,7 @@ DistPointCurve::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetMinDistPoint( double dNearParam, Point3d& ptMinDist, int& nFlag) const
+DistPointCurve::GetMinDistPoint( double dNearParam, Point3d& ptMinDist, int& nFlag)
 {
    if ( m_dDist < 0  ||  m_Info.empty())
       return false ;
@@ -152,7 +150,7 @@ DistPointCurve::GetMinDistPoint( double dNearParam, Point3d& ptMinDist, int& nFl
       }
    }
 
-  // cerco punto discreto più vicino (anche estremi di zone continue)
+  // cerco punto discreto più vicino (anche estremi di zone continue)
    double dParam ;
    for ( int i = 0 ; i < (int) m_Info.size() ; ++ i) {
       if ( i == 0  ||
@@ -168,7 +166,7 @@ DistPointCurve::GetMinDistPoint( double dNearParam, Point3d& ptMinDist, int& nFl
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const
+DistPointCurve::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag)
 {
    if ( m_dDist < 0  ||  nInd < 0  ||  nInd >= (int) m_Info.size())
       return false ;
@@ -180,7 +178,7 @@ DistPointCurve::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) co
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetParamAtMinDistPoint( double dNearParam, double& dParam, int& nFlag) const
+DistPointCurve::GetParamAtMinDistPoint( double dNearParam, double& dParam, int& nFlag)
 {
    if ( m_dDist < 0  ||  m_Info.empty())
       return false ;
@@ -197,7 +195,7 @@ DistPointCurve::GetParamAtMinDistPoint( double dNearParam, double& dParam, int&
       }
    }
 
-  // cerco punto discreto più vicino (anche estremi di zone continue)
+  // cerco punto discreto più vicino (anche estremi di zone continue)
    for ( int i = 0 ; i < (int) m_Info.size() ; ++ i) {
       if ( i == 0  ||
            abs( m_Info[i].dPar - dNearParam) < abs( dParam - dNearParam)) {
@@ -211,7 +209,7 @@ DistPointCurve::GetParamAtMinDistPoint( double dNearParam, double& dParam, int&
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide) const
+DistPointCurve::GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide)
 {
    if ( m_dDist < 0  ||  nInd < 0  ||  nInd >= (int) m_Info.size())
       return false ;
@@ -232,20 +230,9 @@ DistPointCurve::GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide
    Vector3d vtTg = 0.5 * ( vtPreTg + vtPostTg) ;
   // se tangenti opposte, si deve ricalcolare spostandosi un poco
    if ( ! vtTg.Normalize()) {
-      double dDeltaU = 1000 * EPS_PARAM ;    
-      double dParPre = m_Info[nInd].dPar - dDeltaU ;
-      double dParPost = m_Info[nInd].dPar + dDeltaU ;
-     // verifico se il parametro deve essere modificato per adattarsi a curva chiusa
-      if ( m_pCurve->IsClosed()) {
-         double dParS, dParE ;
-         m_pCurve->GetDomain( dParS, dParE) ;
-         if ( dParPre < dParS)
-            dParPre = dParE - dDeltaU ;
-         if ( dParPost > dParE)
-            dParPost = dParS + dDeltaU ;      
-      }
-      if ( ! m_pCurve->GetPointTang( dParPre, ICurve::FROM_MINUS, ptQ, vtPreTg)  ||
-           ! m_pCurve->GetPointTang( dParPost, ICurve::FROM_PLUS, ptQ, vtPostTg))
+      double dDeltaU = 1000 * EPS_PARAM ;
+      if ( ! m_pCurve->GetPointTang( m_Info[nInd].dPar - dDeltaU, ICurve::FROM_MINUS, ptQ, vtPreTg)  ||
+           ! m_pCurve->GetPointTang( m_Info[nInd].dPar + dDeltaU, ICurve::FROM_PLUS, ptQ, vtPostTg))
          return false ;
       vtTg = 0.5 * ( vtPreTg + vtPostTg) ;
       if ( ! vtTg.Normalize( EPS_ZERO))
@@ -270,12 +257,12 @@ DistPointCurve::GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide) const
+DistPointCurve::GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide)
 {
    if ( m_dDist < 0  ||  m_Info.empty())
       return false ;
 
-  // cerco punto discreto più vicino (anche estremi di zone continue)
+  // cerco punto discreto più vicino (anche estremi di zone continue)
    int nInd ;
    double dParam ;
    for ( int i = 0 ; i < (int) m_Info.size() ; ++ i) {
@@ -291,7 +278,7 @@ DistPointCurve::GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, i
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetMinDistInfo( int nInd, MinDistPCInfo& aInfo) const
+DistPointCurve::GetMinDistInfo( int nInd, MinDistPCInfo& aInfo)
 {
    if ( m_dDist < 0  ||  nInd < 0  ||  nInd >= (int) m_Info.size())
       return false ;

DistPointLine.cpp

@@ -1,19 +1,19 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2024
+//  EgalTech 2013-2013
 //----------------------------------------------------------------------------
-// File : DistPointLine.cpp       Data : 20.05.24          Versione : 2.6e5
+// File : DistPointLine.cpp       Data : 17.12.13          Versione : 1.4l1
 // Contenuto : Implementazione della classe distanza punto da linea/segmento.
 //
 //
 //
 // Modifiche : 17.12.13 DS Creazione modulo.
-//             20.05.24 DS Reso pubblico in Include.
+//
 //
 //----------------------------------------------------------------------------
 
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
+#include "DistPointLine.h"
 
 
 //----------------------------------------------------------------------------
@@ -95,7 +95,7 @@ DistPointLine::Calculate( const Point3d& ptP,
 
 //----------------------------------------------------------------------------
 bool
-DistPointLine::GetSqDist( double& dSqDist) const
+DistPointLine::GetSqDist( double& dSqDist)
 {
    if ( m_dSqDist < 0)
       return false ;
@@ -106,7 +106,7 @@ DistPointLine::GetSqDist( double& dSqDist) const
 
 //----------------------------------------------------------------------------
 bool
-DistPointLine::GetDist( double& dDist) const
+DistPointLine::GetDist( double& dDist)
 {
    if ( m_dSqDist < 0)
       return false ;
@@ -119,7 +119,7 @@ DistPointLine::GetDist( double& dDist) const
 
 //----------------------------------------------------------------------------
 bool
-DistPointLine::GetMinDistPoint( Point3d& ptMinDist) const
+DistPointLine::GetMinDistPoint( Point3d& ptMinDist)
 {
    if ( m_dSqDist < 0)
       return false ;
@@ -130,7 +130,7 @@ DistPointLine::GetMinDistPoint( Point3d& ptMinDist) const
 
 //----------------------------------------------------------------------------
 bool
-DistPointLine::GetParamAtMinDistPoint( double& dParam) const
+DistPointLine::GetParamAtMinDistPoint( double& dParam)
 {
    if ( m_dSqDist < 0)
       return false ;

DistPointLine.h

@@ -0,0 +1,58 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2013-2014
+//----------------------------------------------------------------------------
+// File : DistPointLine.h      Data : 02.01.14          Versione : 1.5a1
+// Contenuto : Dichiarazione della classe distanza punto da linea/segmento.
+//
+//
+//
+// Modifiche : 30.12.12 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkPoint3d.h"
+#include "/EgtDev/Include/EGkCurveLine.h"
+
+
+//-----------------------------------------------------------------------------
+class DistPointLine
+{
+   friend class DistPointCurve ;
+
+   public :
+      DistPointLine( const Point3d& ptP,
+                     const ICurveLine& crvLine, bool bIsSegment = true) ;
+      DistPointLine( const Point3d& ptP,
+                     const Point3d& ptIni, const Point3d& ptFin, bool bIsSegment = true) ;
+      DistPointLine( const Point3d& ptP,
+                     const Point3d& ptIni, const Vector3d& vtDir, double dLen, bool bIsSegment = true) ;
+
+   public :
+      bool GetSqDist( double& dSqDist) ;
+      bool GetDist( double& dDist) ;
+      bool IsEpsilon( double dTol)
+              { double dSqDist ; return ( GetSqDist( dSqDist) && ( dSqDist < SQ_EPS_ZERO || dSqDist < dTol * dTol)) ; }
+      bool IsSmall( void)
+              { return IsEpsilon( EPS_SMALL) ; }
+      bool IsZero( void)
+              { return IsEpsilon( EPS_ZERO) ; }
+      int  GetNbrMinDist( void)
+              { return (( m_dSqDist < 0) ? 0 : 1) ; }
+      bool GetMinDistPoint( Point3d& ptMinDist) ;
+      bool GetParamAtMinDistPoint( double& dParam) ;
+
+   private :
+      DistPointLine( void) ;
+      void Calculate( const Point3d& ptP,
+                      const Point3d& ptIni, const Vector3d& vtDir, double dLen, bool bIsSegment) ;
+
+   private :
+      double  m_dSqDist ;
+      double  m_dDist ;
+      double  m_dParam ;
+      Point3d m_ptMinDist ;
+} ;
+

DistPointSurfFr.cpp

@@ -1,156 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2018-2020
-//----------------------------------------------------------------------------
-// File : DistPointSurfTm.cpp     Data : 19.12.20        Versione : 2.2l3
-// Contenuto : Implementazione della classe distanza Punto da Trimesh.
-//
-//
-//
-// Modifiche : 07.12.18 LM Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#include "stdafx.h"
-#include "SurfFlatRegion.h"
-#include "/EgtDev/Include/EGkDistPointCurve.h"
-#include "/EgtDev/Include/EGkDistPointSurfFr.h"
-
-using namespace std ;
-
-//----------------------------------------------------------------------------
-DistPointSurfFr::DistPointSurfFr( const Point3d& ptP, const ISurfFlatRegion& frSurf)
-   : m_dDist( -1)
-{
-  // FlatRegion non valida 
-   if ( &frSurf == nullptr  ||  ! frSurf.IsValid())
-      return ;
-  // Calcolo la distanza
-   Calculate( ptP, frSurf) ;
-}
-
-//----------------------------------------------------------------------------
-void 
-DistPointSurfFr::Calculate( const Point3d& ptP, const ISurfFlatRegion& frSurf)
-{
-  // Inizializzo distanza non calcolata
-   m_dDist = -1 ;
-
-  // Converto regione in classe base
-   const SurfFlatRegion* pSfr = GetBasicSurfFlatRegion( &frSurf) ;
-   if ( pSfr == nullptr)
-      return ;
-
-  // ciclo sulle parti della regione
-   for ( int nC = 0 ; nC < pSfr->GetChunkCount() ; nC ++) {
-      // ciclo sui loop della parte di regione
-      for ( int nL = 0 ; nL < pSfr->GetLoopCount( nC) ; nL ++) {
-         PtrOwner<ICurve> pLoop( pSfr->GetLoop( nC, nL)) ;
-         if ( IsNull( pLoop)) {
-            m_dDist = -1 ;
-            return ;
-         }
-         DistPointCurve DPL( ptP, *pLoop) ;
-         double dDist ;
-         if ( DPL.GetDist( dDist)  &&  ( m_dDist < -EPS_SMALL  ||  dDist < m_dDist)) {
-            m_dDist = dDist ;
-            int nFlag ;
-            m_nMinChunk = nC ;
-            m_nMinLoop = nL ;
-            DPL.GetParamAtMinDistPoint( 0, m_dMinPar, nFlag) ;
-            DPL.GetMinDistPoint( 0, m_ptMinDistPoint, nFlag) ;
-            DPL.GetSideAtMinDistPoint( 0, pSfr->GetNormVersor(), m_nSide) ;
-         } 
-      }
-   }
-  // se trovata, aggiorno minima distanza sul piano
-   if ( m_dDist > - EPS_SMALL) {
-      Point3d ptOn = ptP - ( ptP - pSfr->GetPlanePoint()) * pSfr->GetNormVersor() * pSfr->GetNormVersor() ;
-      m_dDistOnPlane = min( Dist( ptOn, m_ptMinDistPoint), m_dDist) ;
-   }
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfFr::GetDist( double& dDist) const
-{
-   if ( m_dDist < 0)
-      return false ;
-   dDist = m_dDist ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfFr::GetDistOnRegionPlane( double& dDist) const
-{
-   if ( m_dDist < 0)
-      return false ;
-   dDist = m_dDistOnPlane ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfFr::GetPointAtMinDist( Point3d& ptMinDist) const
-{
-   if ( m_dDist < 0)
-      return false ;
-   ptMinDist = m_ptMinDistPoint ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfFr::GetParamAtMinDist( int& nMinChunk, int& nMinLoop, double& dMinPar) const
-{
-   if ( m_dDist < 0)
-      return false ;
-   nMinChunk = m_nMinChunk ;
-   nMinLoop = m_nMinLoop ;
-   dMinPar = m_dMinPar ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfFr::GetSideAtMinDist( int& nSide) const
-{
-   if ( m_dDist < 0)
-      return false ;
-   nSide = m_nSide ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-IsPointInsideSurfFr( const Point3d& ptP, const ISurfFlatRegion* pSfr, double dMinDist, bool& bInside, int& nChunk)
-{
-  // default non include
-   bInside = false ;
-   nChunk = -1 ;
-  // verifica regione
-   if ( pSfr == nullptr  ||  ! pSfr->IsValid())
-      return false ;
-  // verifico se la proiezione del punto sul piano della regione sta nel suo box
-   Point3d ptOn = ptP - ( ptP - pSfr->GetPlanePoint()) * pSfr->GetNormVersor() * pSfr->GetNormVersor() ;
-   BBox3d b3Box ;
-   pSfr->GetLocalBBox( b3Box) ;
-   b3Box.Expand( dMinDist) ;
-   if ( ! b3Box.Encloses( ptOn))
-      return true ;
-  // determino dove sta il punto
-   DistPointSurfFr DPR( ptP, *pSfr) ;
-   double dDist ; int nMinCh, nMinL; double dMinPar ; int nSide ;
-   if ( DPR.GetDistOnRegionPlane( dDist)  &&  DPR.GetParamAtMinDist( nMinCh, nMinL, dMinPar)  &&  DPR.GetSideAtMinDist( nSide)) {
-      if ( abs( dMinDist) < EPS_SMALL)
-         bInside = ( nSide != PRS_OUT) ;
-      else if ( dMinDist < 0)
-         bInside = ( nSide == PRS_IN  &&  dDist > abs( dMinDist) - EPS_SMALL) ;
-      else
-         bInside = ( nSide != PRS_OUT  ||  dDist < dMinDist + EPS_SMALL) ;
-      if ( bInside)
-         nChunk = nMinCh ;
-   }
-   return true ;
-}

DistPointSurfTm.cpp

@@ -12,21 +12,19 @@
 //----------------------------------------------------------------------------
 
 #include "stdafx.h"
-#include "SurfTriMesh.h"
 #include "/EgtDev/Include/EGkDistPointTria.h"
 #include "/EgtDev/Include/EGkDistPointSurfTm.h"
-#include "/EgtDev/Include/EGkIntersLineTria.h"
 
 using namespace std ;
 
 //----------------------------------------------------------------------------
 // Calcola la differenza fra i bounding-box A e B.
-// L'insieme differenza non è un bounding-box, ma è esprimibile come unione di al più sei bounding-box.
+// L'insieme differenza non è un bounding-box, ma è esprimibile come unione di al più sei bounding-box.
 // Se l'insieme differenza fra i box non ha misura nulla viene restituito true, false altrimenti.
-// I casi in cui non vengono trovati box di misura positiva sono quelli in cui o il box A è contenuto
-// nel box B; uno di questi si verifica se il box A è vuoto.
+// I casi in cui non vengono trovati box di misura positiva sono quelli in cui o il box A è contenuto
+// nel box B; uno di questi si verifica se il box A è vuoto.
 // Nel vettore vBoxDiff vengono restituiti i box la cui unione costituisce la differenza fra A e B.
-static bool 
+bool 
 BoundingBoxDifference( const BBox3d& boxA, const BBox3d& boxB, BOXVECTOR& vBoxDiff) 
 {
   // Svuoto il risultato
@@ -34,7 +32,7 @@ BoundingBoxDifference( const BBox3d& boxA, const BBox3d& boxB, BOXVECTOR& vBoxDi
   // Se box A vuoto, risultato vuoto
    if ( boxA.IsEmpty())
       return false ;
-  // Se box B vuoto o i box non si intersecano, risultato è ancora A
+  // Se box B vuoto o i box non si intersecano, risultato è ancora A
    BBox3d boxInt ;
    if ( boxB.IsSmall()  ||  ! boxA.FindIntersection( boxB, boxInt)) {
       vBoxDiff.emplace_back( boxA) ;
@@ -94,241 +92,33 @@ 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() ;
-
-  // Lavoro con l'oggetto superficie trimesh di base
-   const SurfTriMesh* pStm = GetBasicSurfTriMesh( &tmSurf) ;
-   if ( pStm == nullptr)
-      return ;  
 
   // Recupero e verifico il box locale della superficie
-   BBox3d b3Stm = pStm->GetAllTriaBox() ;
+   BBox3d b3Stm = tmSurf.GetAllTriaBox() ;
    if ( b3Stm.IsEmpty())
       return ;
 
-  // Cerco triangoli in box centrati sul punto dato di ampiezza crescente ed escludendo le parti già verificate.
-  // Termino quando non trovo più triangoli che possano soddisfare la richiesta. 
+  // Determino i triangoli vicini e fra di essi cerco quello di minima distanza.
+  // Considero un box centrato nel punto P; finché all'interno del box non trovo un set di triangoli
+  // fra cui quello a distanza minima dal punto P ha distanza minore del minimo semi-lato del box,
+  // continuo a ingrandire il box. La condizione di terminazione garantisce di trovare il tiangolo di
+  // distanza minima della trimesh intera.
    Point3d ptMin, ptMax ; b3Stm.GetMinMax( ptMin, ptMax) ;
-   double dDeltaLen = max( min( min( b3Stm.GetDimX(), b3Stm.GetDimY()), b3Stm.GetDimZ()) / 40., 20.) ;
+   double dDeltaLen = max( min( min( ptMax.x - ptMin.x, ptMax.y - ptMin.y), ptMax.z - ptMin.z) / 40., 10.) ;
    double dBoxHalfLenX = max( max( ptMin.x - ptP.x, ptP.x - ptMax.x), 0.) + dDeltaLen ;
    double dBoxHalfLenY = max( max( ptMin.y - ptP.y, ptP.y - ptMax.y), 0.) + dDeltaLen ;
    double dBoxHalfLenZ = max( max( ptMin.z - ptP.z, ptP.z - ptMax.z), 0.) + dDeltaLen ;
-  // Considero anche il box precedente per poter analizzare solo il volume differenza tra i due
+  // Considero anche il box precedente per poter analizzare solo lo spazio differenza tra i due
    BBox3d boxPPrev( ptP) ;
    BBox3d boxP( ptP, dBoxHalfLenX, dBoxHalfLenY, dBoxHalfLenZ) ;
   // Variabili distanza minima, indice del triangolo di distanza minima, punto di distanza minima 
-   double dMinDist = DBL_MAX ;
+   double dMinSqDist = DBL_MAX ;
    int nMinDistTriaIndex = SVT_NULL ;
    Point3d ptMinDistPoint ;
-  // Finché non si verifica la condizione di terminazione ingrandisco il box.
-   pStm->ResetTempInts() ;
    bool bContinue = true ;
-
-  // creazione del vettore dei triangoli più vicini a ptP
-   vector<pair<int, Triangle3d>> vTria ; // <indice triangolo, Triangolo>
+  // Finché non si verifica la condizione di terminazione ingrandisco il box.
    while ( bContinue) {
-     // Calcolo il box differenza con il precedente per non esplorare parti già considerate
-      BOXVECTOR vBox ;
-      BoundingBoxDifference( boxP, boxPPrev, vBox) ;
-     // Ciclo sui box differenza
-      bool bCollide = false ;
-      for ( const auto& b3Box : vBox) {
-        // interseco il box con quello della superficie e ne verifico la distanza minima dal punto
-         BBox3d b3Int ;
-         if ( ! b3Box.FindIntersection( b3Stm, b3Int)  ||  b3Int.DistFromPoint( ptP) > dMinDist)
-            continue ;
-        // ricerca sui triangoli nel box
-         bCollide = true ;
-         INTVECTOR vnIds ;
-         if ( pStm->GetAllTriaOverlapBox( b3Int, vnIds)) {
-           // Ciclo sui triangoli del sotto-box corrente
-            for ( auto nT : vnIds) {
-               int nTriaTemp ;
-               Triangle3d trCurTria ;
-               if ( pStm->GetTempInt( nT, nTriaTemp)  &&  nTriaTemp == 0  &&  pStm->GetTriangle( nT, trCurTria)) {
-                  pStm->SetTempInt( nT, 1) ;
-                  DistPointTriangle distPT( ptP, trCurTria) ;
-                  double dCurrDist ;
-                 // Se la distanza del triangolo è valida e minore di quella attuale aggiorno
-                  if ( distPT.GetDist( dCurrDist)) {
-                    // se distanze uguali...
-                     if ( abs( dCurrDist - dMinDist) < EPS_SMALL)
-                       // aggiungo il triangolo
-                        vTria.emplace_back( make_pair( nT, trCurTria)) ;
-                    // se minore...
-                     else if ( dCurrDist < dMinDist) {
-                        // pulisco il vettore
-                        vTria.clear() ;
-                        dMinDist = dCurrDist ;
-                        nMinDistTriaIndex = nT ;
-                        distPT.GetMinDistPoint( ptMinDistPoint) ;
-                       // aggiungo il triangolo
-                        vTria.emplace_back( make_pair( nT, trCurTria)) ;
-                     }
-                  }
-               }
-            }
-         }
-      }
-     // Se si verifica la condizione di terminazione arresto il ciclo altrimenti aggiorno i box 
-      if ( ! bCollide  ||  dMinDist < EPS_SMALL)
-         bContinue = false ;
-      else {
-        boxPPrev = boxP ;
-        boxP.Expand( dDeltaLen) ;
-      }
-   }
-
-  // se non ho trovato nessun triangolo, esco
-   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
-   m_ptMinDistPoint = ptMinDistPoint ;
-  // se il punto è sulla TriMesh...
-   if ( m_dDist < EPS_SMALL) {
-      m_nMinDistTriaIndex = nMinDistTriaIndex ;
-      m_bIsInside = false ;
-      return ;
-   }
-  // se ho un solo triangolo, allora deduco le informazioni da lui
-   else if ( int( vTria.size()) == 1) {
-      m_nMinDistTriaIndex = vTria.back().first ;
-      m_bIsInside = ( ( ptP - m_ptMinDistPoint) * vTria.back().second.GetN() < - EPS_SMALL) ;
-      return ;
-   }
-  
-  // controllo se tutti i triangoli a minima distanza forniscono la stessa informazione
-  // ( il punto potrebbe essere esterno a tutti, interno a tutti o indefinito )
-   bool bInside = false ;
-   bool bOutside = false ;
-   for ( int i = 0 ; i < int( vTria.size()) ; ++ i) { // scorro i triangoli a minima distanza
-      if ( ( ptP - vTria[i].second.GetP( 0)) * vTria[i].second.GetN() < - EPS_SMALL)
-         bInside = true ;
-      else
-         bOutside = true ;
-   }
-
-  // inizializzo le variabili membro
-   m_nMinDistTriaIndex = nMinDistTriaIndex ;
-   m_bIsInside = false ;
-
-  // se le informazioni non sono coerenti, allora :
-  // 1) calcolo i centroidi dei triangoli in questione
-  // 2) ottengo il punto medio di questi centroidi
-  // 3) controllo quale triangolo interseca il segmento che parte da ptP e arriva a tale punto
-  // 4) userò questo triangolo per classificare ptP
-   if ( bOutside == bInside) {
-     // calcolo il baricentro complessivo
-      Point3d ptBar_tot ;
-      for ( auto& Tria : vTria)
-         ptBar_tot += Tria.second.GetCentroid() ;
-      ptBar_tot /= int( vTria.size()) ;
-     // per ogni triangolo, cerco quello che interseca il segmento
-      for ( auto& Tria : vTria) {
-         Point3d ptInters1, ptInters2 ;
-         int nType = IntersLineTria( ptP, ptBar_tot, Tria.second, ptInters1, ptInters2) ;
-         if ( nType == ILTT_IN) { // se intersezione ho finito
-            DistPointTriangle( ptP, Tria.second).GetMinDistPoint( m_ptMinDistPoint) ;
-            m_bIsInside = ( ( ptP - m_ptMinDistPoint) * Tria.second.GetN() < - EPS_SMALL) ;
-            m_nMinDistTriaIndex = Tria.first ;
-            break ;
-         }
-      }
-   }
-   else // se informazioni coerenti
-      m_bIsInside = bInside ;
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfTm::GetDist( double& dDist) const
-{
-  // Distanza non valida
-   if ( m_dDist < -EPS_ZERO)
-      return false ;
-  // Distanza valida
-   dDist = m_dDist ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool 
-DistPointSurfTm::GetMinDistPoint( Point3d& ptMinDistPoint) const
-{
-  // Distanza non valida
-   if ( m_dDist < -EPS_ZERO)
-      return false ;
-  // Distanza valida
-   ptMinDistPoint = m_ptMinDistPoint ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-DistPointSurfTm::GetMinDistTriaIndex( int& nMinDistIndex) const
-{
-  // Distanza non valida
-   if ( m_dDist < -EPS_ZERO)
-      return false ;
-  // Distanza valida 
-   nMinDistIndex = m_nMinDistTriaIndex ;
-   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)
-{
-  // Lavoro con l'oggetto superficie trimesh di base
-   const SurfTriMesh* pStm = GetBasicSurfTriMesh( &tmSurf) ;
-   if ( pStm == nullptr)
-      return SVT_NULL ;
-   
-  // Recupero e verifico il box locale della superficie
-   BBox3d b3Stm = pStm->GetAllTriaBox() ;
-   if ( b3Stm.IsEmpty())
-      return SVT_NULL ;
-
-  // Cerco triangoli in box centrati sul punto dato di ampiezza crescente ed escludendo le parti già verificate.
-  // Termino quando non trovo più triangoli che possano soddisfare la richiesta. 
-   Point3d ptMin, ptMax ; b3Stm.GetMinMax( ptMin, ptMax) ;
-   double dDeltaLen = max( min( min( b3Stm.GetDimX(), b3Stm.GetDimY()), b3Stm.GetDimZ()) / 40., 20.) ;
-   double dBoxHalfLenX = max( max( ptMin.x - ptP.x, ptP.x - ptMax.x), 0.) + dDeltaLen ;
-   double dBoxHalfLenY = max( max( ptMin.y - ptP.y, ptP.y - ptMax.y), 0.) + dDeltaLen ;
-   double dBoxHalfLenZ = max( max( ptMin.z - ptP.z, ptP.z - ptMax.z), 0.) + dDeltaLen ;
-  // Considero anche il box precedente per poter analizzare solo il volume differenza tra i due
-   BBox3d boxPPrev( ptP) ;
-   BBox3d boxP( ptP, dBoxHalfLenX, dBoxHalfLenY, dBoxHalfLenZ) ;
-  // Variabili distanza minima 
-   int nVert = SVT_NULL ;
-   double dMinSqDist = DBL_MAX ;
-  // Finché non si verifica la condizione di terminazione ingrandisco il box.
-   pStm->ResetTempInts() ;
-   bool bContinue = true ;
-   while ( bContinue) {
-     // Calcolo il box differenza con il precedente per non esplorare parti già considerate
+     // Calcolo il box differenza con il precedente per non esplorare parti già considerate
       BOXVECTOR vBox ;
       BoundingBoxDifference( boxP, boxPPrev, vBox) ;
      // Ciclo sui box differenza
@@ -341,23 +131,18 @@ GetSurfTmNearestVertex( const Point3d& ptP, const ISurfTriMesh& tmSurf)
         // ricerca sui triangoli nel box
          bCollide = true ;
          INTVECTOR vnIds ; 
-         if ( pStm->GetAllTriaOverlapBox( b3Int, vnIds)) { 
+         if ( tmSurf.GetAllTriaOverlapBox( b3Int, vnIds)) { 
            // Ciclo sui triangoli del sotto-box corrente
             for ( auto nT : vnIds) {
-               int nTriaTemp ;
-               int nIdVert[3] ;
-               if ( pStm->GetTempInt( nT, nTriaTemp)  &&  nTriaTemp == 0  &&  pStm->GetTriangle( nT, nIdVert)) {
-                  pStm->SetTempInt( nT, 1) ;
-                  for ( int i = 0 ; i < 3 ; ++ i) {
-                     Point3d ptVert ;
-                     if ( ! pStm->GetVertex( nIdVert[i], ptVert))
-                        continue ;
-                     double dCurrSqDist = SqDist( ptP, ptVert) ;
-                     if ( dCurrSqDist < dMinSqDist) {
-                        dMinSqDist = dCurrSqDist ;
-                        nVert = nIdVert[i] ;
-                     }
-                  }
+               Triangle3d trCurTria ;
+               tmSurf.GetTriangle( nT, trCurTria) ;
+               DistPointTriangle distPT( ptP, trCurTria) ;
+               double dCurSqDist ;
+              // Se la distanza del triangolo è valida e minore di quella attuale aggiorno 
+               if ( distPT.GetSqDist( dCurSqDist)  &&  dCurSqDist < dMinSqDist) {
+                  dMinSqDist = dCurSqDist ;
+                  nMinDistTriaIndex = nT ;
+                  distPT.GetMinDistPoint( ptMinDistPoint) ;
                }
             }
          }
@@ -371,5 +156,49 @@ GetSurfTmNearestVertex( const Point3d& ptP, const ISurfTriMesh& tmSurf)
       }
    }
 
-   return nVert ;
+   if ( nMinDistTriaIndex != SVT_NULL) {
+      m_dDist = sqrt( max( dMinSqDist, 0.)) ;
+      m_nMinDistTriaIndex = nMinDistTriaIndex ;
+      m_ptMinDistPoint = ptMinDistPoint ;
+      Triangle3d trMinDistTria ;
+      tmSurf.GetTriangle( m_nMinDistTriaIndex, trMinDistTria) ;
+      trMinDistTria.Validate() ;
+      m_bIsInside = ( ( ptP - m_ptMinDistPoint) * trMinDistTria.GetN() < - EPS_SMALL)  &&  tmSurf.IsClosed() ;
+   }
+}
+
+//----------------------------------------------------------------------------
+bool
+DistPointSurfTm::GetDist( double& dDist)
+{
+  // Distanza non valida
+   if ( m_dDist < -EPS_ZERO)
+      return false ;
+  // Distanza valida
+   dDist = m_dDist ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool 
+DistPointSurfTm::GetMinDistPoint( Point3d& ptMinDistPoint)
+{
+  // Distanza non valida
+   if ( m_dDist < -EPS_ZERO)
+      return false ;
+  // Distanza valida
+   ptMinDistPoint = m_ptMinDistPoint ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+DistPointSurfTm::GetMinDistTriaIndex( int& nMinDistIndex)
+{
+  // Distanza non valida
+   if ( m_dDist < -EPS_ZERO)
+      return false ;
+  // Distanza valida 
+   nMinDistIndex = m_nMinDistTriaIndex ;
+   return true ;
 }

DistPointTria.cpp

@@ -14,7 +14,7 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "ProjPlane.h"
-#include "/EgtDev/Include/EGkDistPointLine.h"
+#include "DistPointLine.h"
 #include "/EgtDev/Include/EGkDistPointTria.h"
 
 

DllMain.h

@@ -20,5 +20,4 @@
 int GetEGkDebugLev( void) ;
 ILogger* GetEGkLogger( void) ;
 const std::string& GetEGkKey( void) ;
-bool GetEGkNetHwKey( void) ;
 int ProcessEvents( int nProg, int nPause) ;

EGkDllMain.cpp

@@ -16,7 +16,7 @@
 #include "DllMain.h"
 #include "FontManager.h"
 #include "\EgtDev\Include\EGkDllMain.h"
-#include "\EgtDev\Include\EGnGetModuleVer.h"
+#include "\EgtDev\Include\EgnGetModuleVer.h"
 #include "\EgtDev\Include\EgtTrace.h"
 #include "\EgtDev\Include\SELkLockId.h"
 
@@ -115,7 +115,6 @@ GetEGkLogger( void)
 //-----------------------------------------------------------------------------
 static string s_sKey ;
 static int s_nKeyType = KEY_LOCK_TYPE_ANY ;
-static bool s_bNetHwKey = false ;
 
 //-----------------------------------------------------------------------------
 void
@@ -131,13 +130,6 @@ SetEGkKeyType( int nType)
    s_nKeyType = nType ;
 }
 
-//-----------------------------------------------------------------------------
-void
-SetEGkNetHwKey( bool bNetHwKey)
-{
-   s_bNetHwKey = bNetHwKey ;
-}
-
 //-----------------------------------------------------------------------------
 const string&
 GetEGkKey( void)
@@ -146,33 +138,17 @@ GetEGkKey( void)
    return s_sKey ;
 }
 
-//-----------------------------------------------------------------------------
-bool
-GetEGkNetHwKey( void)
-{
-   return s_bNetHwKey ;
-}
-
 //-----------------------------------------------------------------------------
 void
 InitFontManager( const string& sNfeFontDir, const string& sDefaultFont)
 {
   // recupero il font manager
    FontManager& fntMgr = FontManager::GetFontManager() ;
+
   // lo inizializzo
    fntMgr.Init( sNfeFontDir, sDefaultFont) ;
 }
 
-//-----------------------------------------------------------------------------
-void
-SetDefaultFont( const string& sDefaultFont)
-{
-  // recupero il font manager
-   FontManager& fntMgr = FontManager::GetFontManager() ;
-  // imposto il dato
-   fntMgr.SetDefaultFont( sDefaultFont) ;
-}
-
 //-----------------------------------------------------------------------------
 const string&
 GetNfeFontDir( void)

EgtGeomKernel.vcxproj

@@ -22,7 +22,7 @@
     <ProjectGuid>{9A98A202-2853-454A-84CA-DCD1714176C9}</ProjectGuid>
     <RootNamespace>EgtGeomKernel</RootNamespace>
     <Keyword>MFCDLLProj</Keyword>
-    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
@@ -30,7 +30,7 @@
     <UseDebugLibraries>true</UseDebugLibraries>
     <CharacterSet>Unicode</CharacterSet>
     <UseOfMfc>false</UseOfMfc>
-    <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset>v120_xp</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
@@ -46,12 +46,12 @@
     <WholeProgramOptimization>false</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
     <UseOfMfc>false</UseOfMfc>
-    <PlatformToolset>v143</PlatformToolset>
+    <PlatformToolset>v120_xp</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
     <UseOfMfc>false</UseOfMfc>
     <PlatformToolset>ClangCL</PlatformToolset>
@@ -86,7 +86,6 @@
     <OutDir>$(SolutionDir)$(Configuration)$(PlatformArchitecture)\</OutDir>
     <IntDir>$(Configuration)$(PlatformArchitecture)\</IntDir>
     <IncludePath>C:\;$(IncludePath)</IncludePath>
-    <EnableClangTidyCodeAnalysis>false</EnableClangTidyCodeAnalysis>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <TargetName>$(ProjectName)R$(PlatformArchitecture)</TargetName>
@@ -102,7 +101,6 @@
     <OutDir>$(SolutionDir)$(Configuration)$(PlatformArchitecture)\</OutDir>
     <IntDir>$(Configuration)$(PlatformArchitecture)\</IntDir>
     <IncludePath>C:\;$(IncludePath)</IncludePath>
-    <EnableClangTidyCodeAnalysis>false</EnableClangTidyCodeAnalysis>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -116,8 +114,7 @@
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <EnablePREfast>false</EnablePREfast>
-      <LanguageStandard>stdcpp17</LanguageStandard>
-      <AdditionalIncludeDirectories>C:\EgtDev\Extern\abseil\Include</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>\EgtDev\Extern\GeometricToolsEngine</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -152,8 +149,7 @@ copy $(TargetPath) \EgtProg\DllD32</Command>
       <MinimalRebuild>false</MinimalRebuild>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <LanguageStandard>stdcpp17</LanguageStandard>
-      <AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
+      <AdditionalIncludeDirectories>\EgtDev\Extern\GeometricToolsEngine</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -200,7 +196,7 @@ copy $(TargetPath) \EgtProg\DllD64</Command>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <WholeProgramOptimization>false</WholeProgramOptimization>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <LanguageStandard>stdcpp17</LanguageStandard>
+      <AdditionalIncludeDirectories>\EgtDev\Extern\GeometricToolsEngine</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -239,16 +235,14 @@ copy $(TargetPath) \EgtProg\Dll32</Command>
       <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
       <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
+      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
       <OmitFramePointers>true</OmitFramePointers>
       <FloatingPointModel>Precise</FloatingPointModel>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
-      <EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
+      <EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
       <WholeProgramOptimization>false</WholeProgramOptimization>
       <DebugInformationFormat>None</DebugInformationFormat>
-      <LanguageStandard>stdcpp17</LanguageStandard>
-      <AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
-      <IntelJCCErratum>true</IntelJCCErratum>
+      <AdditionalIncludeDirectories>\EgtDev\Extern\GeometricToolsEngine</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -281,14 +275,11 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="Attribs.cpp" />
     <ClCompile Include="BBox3d.cpp" />
     <ClCompile Include="BiArcs.cpp" />
-    <ClCompile Include="CalcPocketing.cpp" />
-    <ClCompile Include="CAvSilhouetteSurfTm.cpp" />
     <ClCompile Include="CAvSimpleSurfFrMove.cpp" />
     <ClCompile Include="CAvToolSurfTm.cpp" />
     <ClCompile Include="CAvToolTriangle.cpp" />
     <ClCompile Include="CDeBoxClosedSurfTm.cpp" />
     <ClCompile Include="CDeBoxTria.cpp" />
-    <ClCompile Include="CDeCapsTria.cpp" />
     <ClCompile Include="CDeClosedSurfTmClosedSurfTm.cpp" />
     <ClCompile Include="CDeConeFrustumClosedSurfTm.cpp" />
     <ClCompile Include="CDeConeFrustumTria.cpp" />
@@ -304,52 +295,19 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="CDeTriaTria.cpp" />
     <ClCompile Include="CDeUtility.cpp" />
     <ClCompile Include="ChainCurves.cpp" />
-    <ClCompile Include="Circle2P.cpp" />
     <ClCompile Include="CircleCenTgCurve.cpp" />
     <ClCompile Include="Color.cpp" />
     <ClCompile Include="CreateCurveAux.cpp" />
     <ClCompile Include="CurveByApprox.cpp" />
     <ClCompile Include="CurveByInterp.cpp" />
     <ClCompile Include="CurveCompositeOffset.cpp" />
-    <ClCompile Include="DistPointSurfFr.cpp" />
-    <ClCompile Include="IntersCurveSurfTm.cpp">
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
-    </ClCompile>
-    <ClCompile Include="IntersLineVolZmap.cpp" />
-    <ClCompile Include="IntersPlaneVolZmap.cpp" />
-    <ClCompile Include="IntersLineSurfBez.cpp" />
-    <ClCompile Include="SurfTriMeshOffset.cpp" />
-    <ClCompile Include="VolZmapOffset.cpp" />
-    <ClCompile Include="PolygonElevation.cpp" />
-    <ClCompile Include="Quaternion.cpp" />
-    <ClCompile Include="RotationMinimizingFrame.cpp" />
-    <ClCompile Include="RotationXplaneFrame.cpp" />
-    <ClCompile Include="SbzFromCurves.cpp" />
-    <ClCompile Include="SbzStandard.cpp" />
-    <ClCompile Include="Voronoi.cpp" />
     <ClInclude Include="..\Include\EGkCDeClosedSurfTmClosedSurfTm.h" />
     <ClInclude Include="..\Include\EGkCDeConeFrustumClosedSurfTm.h" />
     <ClInclude Include="..\Include\EGkCDeConvexTorusClosedSurfTm.h" />
     <ClInclude Include="..\Include\EGkCDeRectPrismoidClosedSurfTm.h" />
-    <ClInclude Include="..\Include\EGkDistLineLine.h" />
-    <ClInclude Include="..\Include\EGkDistPointLine.h" />
-    <ClInclude Include="..\Include\EGkIntersCurveSurfTm.h" />
     <ClInclude Include="..\Include\EGkIntersLineBox.h" />
-    <ClInclude Include="..\Include\EGkIntersLineVolZmap.h" />
     <ClInclude Include="..\Include\EGkIntersPlaneBox.h" />
-    <ClInclude Include="..\Include\EGkIntersPlaneVolZmap.h" />
-    <ClInclude Include="..\Include\EGkPolygonElevation.h" />
-    <ClInclude Include="..\Include\EGkQuaternion.h" />
-    <ClInclude Include="..\Include\EGkRotationMinimizingFrame.h" />
-    <ClInclude Include="..\Include\EGkRotationXplaneFrame.h" />
-    <ClInclude Include="..\Include\EGkSubtractProjectedFacesOnStmFace.h" />
-    <ClInclude Include="..\Include\EGkSurfTriMeshAux.h" />
-    <ClInclude Include="CAvSilhouetteSurfTm.h" />
     <ClInclude Include="CDeBoxTria.h" />
-    <ClInclude Include="CDeCapsTria.h" />
     <ClInclude Include="CDeConeFrustumTria.h" />
     <ClInclude Include="CDeConeTria.h" />
     <ClInclude Include="CDeConvexTorusTria.h" />
@@ -363,11 +321,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="DistPointSurfTm.cpp" />
     <ClCompile Include="DistPointTria.cpp" />
     <ClCompile Include="ExtDimension.cpp" />
-    <ClCompile Include="HashGrids1d.cpp" />
     <ClCompile Include="IntersLineBox.cpp" />
-    <ClCompile Include="IntersLineCaps.cpp" />
-    <ClCompile Include="IntersLineCone.cpp" />
-    <ClCompile Include="IntersLineCyl.cpp" />
     <ClCompile Include="IntersLineSphere.cpp" />
     <ClCompile Include="IntersLineSurfStd.cpp" />
     <ClCompile Include="IntersPlaneBox.cpp" />
@@ -376,9 +330,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="IntersPlaneTria.cpp" />
     <ClCompile Include="IntersSurfTmSurfTm.cpp" />
     <ClCompile Include="IntersTriaTria.cpp" />
-    <ClCompile Include="OffsetAux.cpp" />
-    <ClCompile Include="Tree.cpp" />
-    <ClCompile Include="MedialAxis.cpp" />
     <ClCompile Include="OffsetCurve.cpp" />
     <ClCompile Include="DistPointArc.cpp" />
     <ClCompile Include="DistPointCrvAux.cpp" />
@@ -415,7 +366,12 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="IntersCurveCurve.cpp" />
     <ClCompile Include="IntersLineArc.cpp" />
     <ClCompile Include="IntersLineLine.cpp" />
-    <ClCompile Include="IntersLinePlane.cpp" />
+    <ClCompile Include="IntersLinePlane.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
+    </ClCompile>
     <ClCompile Include="IntersLineSurfTm.cpp" />
     <ClCompile Include="IntersLineTria.cpp" />
     <ClCompile Include="Intervals.cpp" />
@@ -433,21 +389,18 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="OffsetCurveOnX.cpp" />
     <ClCompile Include="Polygon3d.cpp" />
     <ClCompile Include="AdjustLoops.cpp" />
-    <ClCompile Include="ProjectCurveSurf.cpp" />
-    <ClCompile Include="RemoveCurveDefects.cpp" />
+    <ClCompile Include="RemoveCurveSpikes.cpp" />
     <ClCompile Include="SelfIntersCurve.cpp" />
     <ClCompile Include="SfrCreate.cpp" />
-    <ClCompile Include="SubtractProjectedFacesOnStmFace.cpp" />
-    <ClCompile Include="SurfAux.cpp" />
     <ClCompile Include="SurfBezier.cpp" />
     <ClCompile Include="SurfFlatRegion.cpp" />
     <ClCompile Include="SurfFlatRegionBooleans.cpp" />
     <ClCompile Include="SurfFlatRegionOffset.cpp" />
     <ClCompile Include="SurfTriMeshBooleans.cpp" />
-    <ClCompile Include="SurfTriMeshCuts.cpp" />
-    <ClCompile Include="SurfTriMeshUtilities.cpp" />
     <ClCompile Include="TextureData.cpp" />
     <ClCompile Include="Tool.cpp" />
+    <ClCompile Include="tpp_assert.cpp" />
+    <ClCompile Include="tpp_impl.cpp" />
     <ClCompile Include="UserObjDefault.cpp" />
     <ClCompile Include="UserObjFactory.cpp" />
     <ClCompile Include="OutTsc.cpp" />
@@ -478,7 +431,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="VolZmapGraphics.cpp" />
     <ClCompile Include="VolZmapVolume.cpp" />
     <ClCompile Include="VolZmap.cpp" />
-    <ClInclude Include="Voronoi.h" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\Include\EGkAngle.h" />
@@ -495,14 +447,14 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="..\Include\EGkChainCurves.h" />
     <ClInclude Include="..\Include\EGkCircleCenTgCurve.h" />
     <ClInclude Include="..\Include\EGkColor.h" />
-    <ClInclude Include="..\Include\EGkCurve.h" />
-    <ClInclude Include="..\Include\EGkCurveArc.h" />
-    <ClInclude Include="..\Include\EGkCurveAux.h" />
-    <ClInclude Include="..\Include\EGkCurveBezier.h" />
+    <ClInclude Include="..\Include\EgkCurve.h" />
+    <ClInclude Include="..\Include\EgkCurveArc.h" />
+    <ClInclude Include="..\Include\EgkCurveAux.h" />
+    <ClInclude Include="..\Include\EgkCurveBezier.h" />
     <ClInclude Include="..\Include\EGkCurveByApprox.h" />
-    <ClInclude Include="..\Include\EGkCurveComposite.h" />
+    <ClInclude Include="..\Include\EgkCurveComposite.h" />
     <ClInclude Include="..\Include\EGkCurveByInterp.h" />
-    <ClInclude Include="..\Include\EGkCurveLine.h" />
+    <ClInclude Include="..\Include\EgkCurveLine.h" />
     <ClInclude Include="..\Include\EGkCurveLocal.h" />
     <ClInclude Include="..\Include\EGkCurvePointDiffGeom.h" />
     <ClInclude Include="..\Include\EGkDistPointCurve.h" />
@@ -605,12 +557,14 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="CAvSimpleSurfFrMove.h" />
     <ClInclude Include="CAvToolSurfTm.h" />
     <ClInclude Include="CreateCurveAux.h" />
+    <ClInclude Include="DistLineLine.h" />
     <ClInclude Include="DistPointArc.h" />
     <ClInclude Include="DistPointCrvAux.h" />
     <ClInclude Include="DistPointCrvBezier.h" />
     <ClInclude Include="DistPointCrvComposite.h" />
+    <ClInclude Include="DistPointLine.h" />
     <ClInclude Include="DllMain.h" />
-    <ClInclude Include="earcut.hpp" />
+    <ClInclude Include="dpoint.hpp" />
     <ClInclude Include="ExtDimension.h" />
     <ClInclude Include="ExtText.h" />
     <ClInclude Include="FontAux.h" />
@@ -639,16 +593,10 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="IntersArcArc.h" />
     <ClInclude Include="IntersCrvCompoCrvCompo.h" />
     <ClInclude Include="IntersLineArc.h" />
-    <ClInclude Include="IntersLineBox.h" />
-    <ClInclude Include="IntersLineCaps.h" />
-    <ClInclude Include="IntersLineCone.h" />
-    <ClInclude Include="IntersLineCyl.h" />
     <ClInclude Include="IntersLineLine.h" />
     <ClInclude Include="IntersLineSurfStd.h" />
     <ClInclude Include="IntersLineTria.h" />
     <ClInclude Include="IterManager.h" />
-    <ClInclude Include="OffsetAux.h" />
-    <ClInclude Include="Tree.h" />
     <ClInclude Include="Material.h" />
     <ClInclude Include="FontNfe.h" />
     <ClInclude Include="MC_Tables.h" />
@@ -658,13 +606,16 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="ObjGraphicsMgr.h" />
     <ClInclude Include="FontOs.h" />
     <ClInclude Include="AdjustLoops.h" />
-    <ClInclude Include="RemoveCurveDefects.h" />
-    <ClInclude Include="SurfAux.h" />
+    <ClInclude Include="RemoveCurveSpikes.h" />
     <ClInclude Include="SurfBezier.h" />
     <ClInclude Include="SurfFlatRegion.h" />
     <ClInclude Include="TextureData.h" />
     <ClInclude Include="Tool.h" />
     <ClInclude Include="CAvToolTriangle.h" />
+    <ClInclude Include="tpp_assert.hpp" />
+    <ClInclude Include="tpp_interface.hpp" />
+    <ClInclude Include="triangle.h" />
+    <ClInclude Include="triangle_impl.hpp" />
     <ClInclude Include="UserObjDefault.h" />
     <ClInclude Include="OutTsc.h" />
     <ClInclude Include="PointsPCA.h" />

EgtGeomKernel.vcxproj.filters

@@ -43,18 +43,15 @@
     <Filter Include="File di origine\GeoOffset">
       <UniqueIdentifier>{f07670fd-9429-4b7e-ac6d-1c0022e756fb}</UniqueIdentifier>
     </Filter>
-    <Filter Include="File di origine\GeoProject">
-      <UniqueIdentifier>{d96752da-1884-4a73-ba1b-5b20b606e469}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="File di origine\GeoElevation">
-      <UniqueIdentifier>{4c6a9dc5-8fac-4ecd-bde6-3e37e056712e}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="File di origine\GeoCollisionAvoid">
-      <UniqueIdentifier>{ae52e402-3063-45e3-b9f7-1710035a1f56}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="File di origine\GeoCollisionDetection">
+    <Filter Include="File di origine\GeoCollision">
       <UniqueIdentifier>{865b76ee-b10d-41fc-861c-b48ce52fa277}</UniqueIdentifier>
     </Filter>
+    <Filter Include="File di intestazione\tpp">
+      <UniqueIdentifier>{9596e38a-8880-4ab5-bd65-e1db39c92ac5}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="File di origine\tpp">
+      <UniqueIdentifier>{636e60fa-4b24-4a7b-b2e9-74e1c1e8fb31}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Vector3d.cpp">
@@ -276,9 +273,6 @@
     <ClCompile Include="IntersLineSurfTm.cpp">
       <Filter>File di origine\GeoInters</Filter>
     </ClCompile>
-    <ClCompile Include="IntersLineSurfBez.cpp">
-      <Filter>File di origine\GeoInters</Filter>
-    </ClCompile>
     <ClCompile Include="CircleCenTgCurve.cpp">
       <Filter>File di origine\GeoCreate</Filter>
     </ClCompile>
@@ -339,7 +333,7 @@
     <ClCompile Include="OffsetCurveOnX.cpp">
       <Filter>File di origine\GeoOffset</Filter>
     </ClCompile>
-    <ClCompile Include="RemoveCurveDefects.cpp">
+    <ClCompile Include="RemoveCurveSpikes.cpp">
       <Filter>File di origine\GeoInters</Filter>
     </ClCompile>
     <ClCompile Include="Polygon3d.cpp">
@@ -378,8 +372,17 @@
     <ClCompile Include="IntersLineSurfStd.cpp">
       <Filter>File di origine\GeoInters</Filter>
     </ClCompile>
+    <ClCompile Include="CAvToolTriangle.cpp">
+      <Filter>File di origine\GeoCollision</Filter>
+    </ClCompile>
+    <ClCompile Include="CAvToolSurfTm.cpp">
+      <Filter>File di origine\GeoCollision</Filter>
+    </ClCompile>
     <ClCompile Include="CDeBoxTria.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
+    </ClCompile>
+    <ClCompile Include="CAvSimpleSurfFrMove.cpp">
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="IntersSurfTmSurfTm.cpp">
       <Filter>File di origine\GeoInters</Filter>
@@ -397,19 +400,19 @@
       <Filter>File di origine\Geo</Filter>
     </ClCompile>
     <ClCompile Include="CDeCylTria.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="CDeBoxClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="CDeCylClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="CDeSpheTria.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="CDeSpheClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="SurfBezier.cpp">
       <Filter>File di origine\Geo</Filter>
@@ -427,130 +430,40 @@
       <Filter>File di origine\GeoDist</Filter>
     </ClCompile>
     <ClCompile Include="CDeTriaTria.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="CDeConeTria.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="CDeUtility.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="CDeClosedSurfTmClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="CDeConeFrustumClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="CDeConeFrustumTria.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="CDeConvexTorusClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="CDeConvexTorusTria.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="CDeRectPrismoidClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
     <ClCompile Include="CDeRectPrismoidTria.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
+      <Filter>File di origine\GeoCollision</Filter>
     </ClCompile>
-    <ClCompile Include="SurfTriMeshUtilities.cpp">
-      <Filter>File di origine\Geo</Filter>
+    <ClCompile Include="tpp_assert.cpp">
+      <Filter>File di origine\tpp</Filter>
     </ClCompile>
-    <ClCompile Include="SurfTriMeshCuts.cpp">
-      <Filter>File di origine\Geo</Filter>
-    </ClCompile>
-    <ClCompile Include="HashGrids1d.cpp">
-      <Filter>File di origine\Base</Filter>
-    </ClCompile>
-    <ClCompile Include="CDeCapsTria.cpp">
-      <Filter>File di origine\GeoCollisionDetection</Filter>
-    </ClCompile>
-    <ClCompile Include="Circle2P.cpp">
-      <Filter>File di origine\GeoCreate</Filter>
-    </ClCompile>
-    <ClCompile Include="MedialAxis.cpp">
-      <Filter>File di origine\GeoOffset</Filter>
-    </ClCompile>
-    <ClCompile Include="Tree.cpp">
-      <Filter>File di origine\Base</Filter>
-    </ClCompile>
-    <ClCompile Include="IntersLineCyl.cpp">
-      <Filter>File di origine\GeoInters</Filter>
-    </ClCompile>
-    <ClCompile Include="IntersLineCone.cpp">
-      <Filter>File di origine\GeoInters</Filter>
-    </ClCompile>
-    <ClCompile Include="IntersLineCaps.cpp">
-      <Filter>File di origine\GeoInters</Filter>
-    </ClCompile>
-    <ClCompile Include="ProjectCurveSurf.cpp">
-      <Filter>File di origine\GeoProject</Filter>
-    </ClCompile>
-    <ClCompile Include="SubtractProjectedFacesOnStmFace.cpp">
-      <Filter>File di origine\GeoProject</Filter>
-    </ClCompile>
-    <ClCompile Include="SurfAux.cpp">
-      <Filter>File di origine\Geo</Filter>
-    </ClCompile>
-    <ClCompile Include="CalcPocketing.cpp">
-      <Filter>File di origine\GeoOffset</Filter>
-    </ClCompile>
-    <ClCompile Include="OffsetAux.cpp">
-      <Filter>File di origine\GeoOffset</Filter>
-    </ClCompile>
-    <ClCompile Include="Voronoi.cpp">
-      <Filter>File di origine\Base</Filter>
-    </ClCompile>
-    <ClCompile Include="PolygonElevation.cpp">
-      <Filter>File di origine\GeoElevation</Filter>
-    </ClCompile>
-    <ClCompile Include="IntersCurveSurfTm.cpp">
-      <Filter>File di origine\GeoInters</Filter>
-    </ClCompile>
-    <ClCompile Include="CAvSimpleSurfFrMove.cpp">
-      <Filter>File di origine\GeoCollisionAvoid</Filter>
-    </ClCompile>
-    <ClCompile Include="CAvToolSurfTm.cpp">
-      <Filter>File di origine\GeoCollisionAvoid</Filter>
-    </ClCompile>
-    <ClCompile Include="CAvToolTriangle.cpp">
-      <Filter>File di origine\GeoCollisionAvoid</Filter>
-    </ClCompile>
-    <ClCompile Include="IntersLineVolZmap.cpp">
-      <Filter>File di origine\GeoInters</Filter>
-    </ClCompile>
-    <ClCompile Include="IntersPlaneVolZmap.cpp">
-      <Filter>File di origine\GeoInters</Filter>
-    </ClCompile>
-    <ClCompile Include="SbzStandard.cpp">
-      <Filter>File di origine\GeoCreate</Filter>
-    </ClCompile>
-    <ClCompile Include="RotationMinimizingFrame.cpp">
-      <Filter>File di origine\Base</Filter>
-    </ClCompile>
-    <ClCompile Include="RotationXplaneFrame.cpp">
-      <Filter>File di origine\Base</Filter>
-    </ClCompile>
-    <ClCompile Include="Quaternion.cpp">
-      <Filter>File di origine\Base</Filter>
-    </ClCompile>
-    <ClCompile Include="CAvSilhouetteSurfTm.cpp">
-      <Filter>File di origine\GeoCollisionAvoid</Filter>
-    </ClCompile>
-    <ClCompile Include="SbzFromCurves.cpp">
-      <Filter>File di origine\GeoCreate</Filter>
-    </ClCompile>
-    <ClCompile Include="DistPointSurfFr.cpp">
-      <Filter>File di origine\GeoDist</Filter>
-    </ClCompile>
-    <ClCompile Include="VolZmapOffset.cpp">
-      <Filter>File di origine\Geo</Filter>
-    </ClCompile>
-    <ClCompile Include="SurfTriMeshOffset.cpp">
-      <Filter>File di origine\GeoOffset</Filter>
+    <ClCompile Include="tpp_impl.cpp">
+      <Filter>File di origine\tpp</Filter>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
@@ -608,6 +521,9 @@
     <ClInclude Include="DistPointArc.h">
       <Filter>File di intestazione</Filter>
     </ClInclude>
+    <ClInclude Include="DistPointLine.h">
+      <Filter>File di intestazione</Filter>
+    </ClInclude>
     <ClInclude Include="DistPointCrvBezier.h">
       <Filter>File di intestazione</Filter>
     </ClInclude>
@@ -719,28 +635,28 @@
     <ClInclude Include="..\Include\EGkChainCurves.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
-    <ClInclude Include="..\Include\EGkCurveBezier.h">
+    <ClInclude Include="..\Include\EgkCurveBezier.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
     <ClInclude Include="..\Include\EGkColor.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
-    <ClInclude Include="..\Include\EGkCurve.h">
+    <ClInclude Include="..\Include\EgkCurve.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
-    <ClInclude Include="..\Include\EGkCurveArc.h">
+    <ClInclude Include="..\Include\EgkCurveArc.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
-    <ClInclude Include="..\Include\EGkCurveAux.h">
+    <ClInclude Include="..\Include\EgkCurveAux.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
     <ClInclude Include="..\Include\EGkCurveByInterp.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
-    <ClInclude Include="..\Include\EGkCurveComposite.h">
+    <ClInclude Include="..\Include\EgkCurveComposite.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
-    <ClInclude Include="..\Include\EGkCurveLine.h">
+    <ClInclude Include="..\Include\EgkCurveLine.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
     <ClInclude Include="..\Include\EGkCurvePointDiffGeom.h">
@@ -935,7 +851,7 @@
     <ClInclude Include="..\Include\EGkIntersLineSurfTm.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
-    <ClInclude Include="RemoveCurveDefects.h">
+    <ClInclude Include="RemoveCurveSpikes.h">
       <Filter>File di intestazione</Filter>
     </ClInclude>
     <ClInclude Include="..\Include\EGkIntersPlanePlane.h">
@@ -1130,6 +1046,9 @@
     <ClInclude Include="..\Include\EGkIntersPlaneBox.h">
       <Filter>File di intestazione\Include</Filter>
     </ClInclude>
+    <ClInclude Include="DistLineLine.h">
+      <Filter>File di intestazione</Filter>
+    </ClInclude>
     <ClInclude Include="CDeUtility.h">
       <Filter>File di intestazione</Filter>
     </ClInclude>
@@ -1169,71 +1088,20 @@
     <ClInclude Include="CDeRectPrismoidTria.h">
       <Filter>File di intestazione</Filter>
     </ClInclude>
-    <ClInclude Include="earcut.hpp">
-      <Filter>File di intestazione</Filter>
+    <ClInclude Include="dpoint.hpp">
+      <Filter>File di intestazione\tpp</Filter>
     </ClInclude>
-    <ClInclude Include="IntersLineBox.h">
-      <Filter>File di intestazione</Filter>
+    <ClInclude Include="tpp_assert.hpp">
+      <Filter>File di intestazione\tpp</Filter>
     </ClInclude>
-    <ClInclude Include="CDeCapsTria.h">
-      <Filter>File di intestazione</Filter>
+    <ClInclude Include="tpp_interface.hpp">
+      <Filter>File di intestazione\tpp</Filter>
     </ClInclude>
-    <ClInclude Include="Tree.h">
-      <Filter>File di intestazione</Filter>
+    <ClInclude Include="triangle.h">
+      <Filter>File di intestazione\tpp</Filter>
     </ClInclude>
-    <ClInclude Include="IntersLineCyl.h">
-      <Filter>File di intestazione</Filter>
-    </ClInclude>
-    <ClInclude Include="IntersLineCone.h">
-      <Filter>File di intestazione</Filter>
-    </ClInclude>
-    <ClInclude Include="IntersLineCaps.h">
-      <Filter>File di intestazione</Filter>
-    </ClInclude>
-    <ClInclude Include="SurfAux.h">
-      <Filter>File di intestazione</Filter>
-    </ClInclude>
-    <ClInclude Include="OffsetAux.h">
-      <Filter>File di intestazione</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkPolygonElevation.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkSubtractProjectedFacesOnStmFace.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="Voronoi.h">
-      <Filter>File di intestazione</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkIntersCurveSurfTm.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkIntersPlaneVolZmap.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkIntersLineVolZmap.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkRotationMinimizingFrame.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkRotationXplaneFrame.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkQuaternion.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkDistLineLine.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkDistPointLine.h">
-      <Filter>File di intestazione\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="CAvSilhouetteSurfTm.h">
-      <Filter>File di intestazione</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkSurfTriMeshAux.h">
-      <Filter>File di intestazione\Include</Filter>
+    <ClInclude Include="triangle_impl.hpp">
+      <Filter>File di intestazione\tpp</Filter>
     </ClInclude>
   </ItemGroup>
   <ItemGroup>

ExtDimension.h

@@ -28,7 +28,7 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
       ExtDimension* Clone( void) const override ;
       GeoObjType GetType( void) const override ;
       bool IsValid( void) const override
-               { return ( m_nType != DT_NONE) ; }
+        { return ( m_nType != DT_NONE) ; }
       const std::string& GetTitle( void) const override ;
       bool Dump( std::string& sOut, bool bMM = true, const char* szNewLine = "\n") const override ;
       bool GetLocalBBox( BBox3d& b3Loc, int nFlag = BBF_STANDARD) const override ;
@@ -50,16 +50,10 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp, int nPropInd = 0) override
-              { if ( nPropInd >= 0  &&  nPropInd < 2)
-                   m_nTempProp[nPropInd] = nProp ; } 
-      int  GetTempProp( int nPropInd = 0) const override
-              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
-      void SetTempParam( double dParam, int nParamInd = 0) override
-              { if ( nParamInd >= 0  &&  nParamInd < 2)
-                  m_dTempParam[nParamInd] = dParam ; } 
-      double GetTempParam( int nParamInd = 0) const override
-                { return (( nParamInd >= 0  &&  nParamInd < 2) ? m_dTempParam[nParamInd] : 0.0) ; }
+      void SetTempProp( int nProp) override
+              { m_nTempProp = nProp ; } 
+      int  GetTempProp( void) const override
+              { return m_nTempProp ; } 
 
    public :                      // IExtDimension
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -67,15 +61,6 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
                      int nDecDigit, const std::string& sFont, double dTextHeight) override ;
       bool SetLinear( const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptPos,
                       const Vector3d& vtN, const Vector3d& vtDir, const std::string& sText) override ;
-      bool SetRadial( const Point3d& ptCen, const Point3d& ptPos,
-                      const Vector3d& vtN, const std::string& sText) override ;
-      bool SetDiametral( const Point3d& ptCen, const Point3d& ptPos,
-                         const Vector3d& vtN, const std::string& sText) override ;
-      bool SetAngular( const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptPos,
-                       const Vector3d& vtN, const std::string& sText) override ;
-      bool SetAngularEx( const Point3d& ptV1, const Point3d& ptP1,
-                         const Point3d& ptV2, const Point3d& ptP2, const Point3d& ptPos,
-                         const Vector3d& vtN, const std::string& sText) override ;
       const Vector3d& GetNormVersor( void) const override
                         { return m_vtN ; } 
       const Vector3d& GetDirVersor( void) const override
@@ -108,16 +93,12 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
                         { return m_dTextHeight ; }
       bool GetMidPoint( Point3d& ptMid) const override ;
       bool GetCenterPoint( Point3d& ptCen) const override ;
-      const std::string& GetSubType( void) const override ;
       bool ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST& lstPL) const override ;
 
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
-      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
-      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
-      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       ExtDimension( void) ;
@@ -131,12 +112,12 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
 
    private :
       bool CopyFrom( const ExtDimension& gpSrc) ;
+      const std::string& GetSubType( void) const ;
       bool Update( void) const ;
-      double GetTextHalfDist( const Point3d& ptText, bool bUseRot = true) const ;
+      double GetTextHalfDist( const Point3d& ptText) const ;
       bool GetArrowHead( const Point3d& ptTip, const Vector3d& vtDir, PolyLine& PL) const ;
       bool SetCurrFont( FontManager& fntMgr) const ;
       bool ApproxTextWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST& lstPL) const ;
-      bool GetTextMyBBox( BBox3d& b3Loc) const ;
       bool GetTextMyBBox( const Point3d& ptPos, BBox3d& b3Loc) const ;
       bool GetTextLocalBBox( BBox3d& b3Loc) const ;
       bool GetTextBBox( const Frame3d& frRef, BBox3d& b3Ref) const ;
@@ -151,14 +132,13 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
       Point3d             m_ptP3 ;          // terzo punto
       Point3d             m_ptP4 ;          // quarto punto
       Point3d             m_ptP5 ;          // quinto punto
-      Point3d             m_ptP6 ;          // sesto punto; nel caso delle quotature angolari � il centro
+      Point3d             m_ptP6 ;          // sesto punto
       Point3d             m_ptPos ;         // posizione ricevuta della quota
       std::string         m_sText ;         // testo della quota
       mutable bool        m_bToCalc ;       // flag dati effettivi da ricalcolare 
       mutable std::string m_sCalcText ;     // testo effettivo della quota
       mutable Point3d     m_ptCalcPos ;     // posizione effettiva della quota
       mutable bool        m_bCalcArrowIn ;  // flag posizione effettiva delle frecce
-      mutable bool        m_bCalcTextOn ;   // flag posizione del testo sulla linea di misura
       mutable Point3d     m_ptCalcP7 ;      // settimo punto effettivo
       mutable Point3d     m_ptCalcP8 ;      // ottavo punto effettivo
       double              m_dExtLineLen ;   // lunghezza di estensione della linea
@@ -168,22 +148,5 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
       int                 m_nDecDigit ;     // numero di cifre decimali
       std::string         m_sFont ;         // font del testo
       double              m_dTextHeight ;   // altezza del testo
-      int                 m_nTempProp[2] ;  // vettore propriet� temporanee
-      double              m_dTempParam[2] ; // vettore parametri temporanei
+      int                 m_nTempProp ;     // proprietà temporanea 
 } ;
-
-//-----------------------------------------------------------------------------
-inline ExtDimension* CreateBasicExtDimension( void)
-               { return ( static_cast<ExtDimension*>( CreateGeoObj( EXT_DIMENSION))) ; }
-inline ExtDimension* CloneBasicExtDimension( const IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != EXT_DIMENSION)
-                    return nullptr ;
-                 return ( static_cast<ExtDimension*>( pGObj->Clone())) ; }
-inline const ExtDimension* GetBasicExtDimension( const IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != EXT_DIMENSION)
-                    return nullptr ;
-                 return ( static_cast<const ExtDimension*>( pGObj)) ; }
-inline ExtDimension* GetBasicExtDimension( IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != EXT_DIMENSION)
-                    return nullptr ;
-                 return ( static_cast<ExtDimension*>( pGObj)) ; }

ExtText.cpp

@@ -35,9 +35,8 @@ GEOOBJ_REGISTER( EXT_TEXT, NGE_E_TXT, ExtText) ;
 //----------------------------------------------------------------------------
 ExtText::ExtText( void)
    : m_pSTM( nullptr), m_bNoSTM( false), m_ptP(), m_vtN( 0, 0, 1), m_vtD( 1, 0, 0), m_sFont(),
-     m_nWeight( 400), m_bItalic( false), m_dHeight( 10), m_dRatio( 1), m_dAddAdvance( 0),
-     m_nTempProp{0,0}, m_dTempParam{0.0,0.0}
-{    
+     m_nWeight( 400), m_bItalic( false), m_dHeight( 10), m_dRatio( 1), m_dAddAdvance( 0), m_nTempProp()
+{
 }
 
 //----------------------------------------------------------------------------
@@ -160,7 +159,7 @@ ExtText::Clone( void) const
 bool
 ExtText::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const ExtText* pTxt = GetBasicExtText( pGObjSrc) ;
+   const ExtText* pTxt = dynamic_cast<const ExtText*>( pGObjSrc) ;
    if ( pTxt == nullptr)
       return false ;
    return CopyFrom( *pTxt) ;
@@ -185,10 +184,7 @@ ExtText::CopyFrom( const ExtText& clSrc)
    m_dRatio = clSrc.m_dRatio ; 
    m_dAddAdvance = clSrc.m_dAddAdvance ;
    m_nInsPos = clSrc.m_nInsPos ; 
-   m_nTempProp[0] = clSrc.m_nTempProp[0] ;
-   m_nTempProp[1] = clSrc.m_nTempProp[1] ;
-   m_dTempParam[0] = clSrc.m_dTempParam[0] ;
-   m_dTempParam[1] = clSrc.m_dTempParam[1] ;
+   m_nTempProp = clSrc.m_nTempProp ;
    return true ;
 }
 
@@ -400,11 +396,8 @@ ExtText::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
 bool
 ExtText::Translate( const Vector3d& vtMove)
 {
-  // imposto ricalcolo della grafica
    ResetAuxSurf() ;
    m_OGrMgr.Reset() ;
-
-  // eseguo
    m_ptP.Translate( vtMove) ;
    return true ;
 }
@@ -413,15 +406,8 @@ ExtText::Translate( const Vector3d& vtMove)
 bool
 ExtText::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
 {
-  // verifico validità dell'asse di rotazione
-   if ( vtAx.IsSmall())
-      return false ;
-
-  // imposto ricalcolo della grafica
    ResetAuxSurf() ;
    m_OGrMgr.Reset() ; 
-
-  // eseguo
    return ( m_ptP.Rotate( ptAx, vtAx, dCosAng, dSinAng)  &&
             m_vtN.Rotate( vtAx, dCosAng, dSinAng)  &&
             m_vtD.Rotate( vtAx, dCosAng, dSinAng)) ;
@@ -543,18 +529,9 @@ ExtText::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtD
 bool
 ExtText::ToGlob( const Frame3d& frRef)
 {
-  // verifico validità del frame
-   if ( frRef.GetType() == Frame3d::ERR)
-      return false ;
-
-  // se frame identità, non devo fare alcunché
-   if ( IsGlobFrame( frRef))
-      return true ;
-
   // imposto ricalcolo della grafica
    ResetAuxSurf() ;
    m_OGrMgr.Reset() ;
-
   // trasformo punto e versori
    return ( m_ptP.ToGlob( frRef)  &&
             m_vtN.ToGlob( frRef)  &&
@@ -565,18 +542,9 @@ ExtText::ToGlob( const Frame3d& frRef)
 bool
 ExtText::ToLoc( const Frame3d& frRef)
 {
-  // verifico validità del frame
-   if ( frRef.GetType() == Frame3d::ERR)
-      return false ;
-
-  // se frame identità, non devo fare alcunché
-   if ( IsGlobFrame( frRef))
-      return true ;
-
   // imposto ricalcolo della grafica
    ResetAuxSurf() ;
    m_OGrMgr.Reset() ;
-
   // trasformo punto e versori
    return ( m_ptP.ToLoc( frRef)  &&
             m_vtN.ToLoc( frRef)  &&
@@ -590,15 +558,12 @@ ExtText::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
   // verifico validità dei frame
    if ( frOri.GetType() == Frame3d::ERR  ||  frDest.GetType() == Frame3d::ERR)
       return false ;
-
   // se i due riferimenti coincidono, non devo fare alcunché
    if ( AreSameFrame( frOri, frDest))
       return true ;
-
   // imposto ricalcolo della grafica
    ResetAuxSurf() ;
    m_OGrMgr.Reset() ;
-
   // trasformo punto e versori
    return ( m_ptP.ToGlob( frOri)  &&  m_ptP.ToLoc( frDest)  &&
             m_vtN.ToGlob( frOri)  &&  m_vtN.ToLoc( frDest)  &&
@@ -884,7 +849,7 @@ ExtText::GetAuxSurf( void) const
   // per ogni regione richiedo la superficie ausiliaria e la aggiungo a quella generale
    for ( const auto& pSfr : lstSfr) {
      // recupero la superficie trimesh
-      PtrOwner<SurfTriMesh> pStm( GetBasicSurfFlatRegion( pSfr)->CalcAuxSurf( LIN_TOL_STD, ANG_TOL_STD_DEG)) ;
+      PtrOwner<ISurfTriMesh> pStm( GetBasicSurfFlatRegion( pSfr)->CalcAuxSurf( LIN_TOL_STD, ANG_TOL_STD_DEG)) ;
       if ( pStm != nullptr) {
          Triangle3d Tria ;
          int nT = pStm->GetFirstTriangle( Tria) ;

ExtText.h

@@ -50,16 +50,10 @@ class ExtText : public IExtText, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp, int nPropInd = 0) override
-              { if ( nPropInd >= 0  &&  nPropInd < 2)
-                   m_nTempProp[nPropInd] = nProp ; } 
-      int  GetTempProp( int nPropInd = 0) const override
-              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
-      void SetTempParam( double dParam, int nParamInd = 0) override
-              { if ( nParamInd >= 0  &&  nParamInd < 2)
-                  m_dTempParam[nParamInd] = dParam ; } 
-      double GetTempParam( int nParamInd = 0) const override
-                { return (( nParamInd >= 0  &&  nParamInd < 2) ? m_dTempParam[nParamInd] : 0.0) ; }
+      void SetTempProp( int nProp) override
+              { m_nTempProp = nProp ; } 
+      int  GetTempProp( void) const override
+              { return m_nTempProp ; } 
 
    public :                      // IExtText
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -113,10 +107,7 @@ class ExtText : public IExtText, public IGeoObjRW
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
-      bool PreSave( GdbGeo& Wrapper) const override { return true ; }
-      bool PostSave( GdbGeo& Wrapper) const override { return true ; }
       bool Load( NgeReader& ngeIn) override ;
-      bool PostLoad( GdbGeo& Wrapper) override { return true ; }
 
    public :
       ExtText( void) ;
@@ -152,22 +143,5 @@ class ExtText : public IExtText, public IGeoObjRW
       double         m_dRatio ;        // rapporto tra larghezza e altezza
       double         m_dAddAdvance ;   // avanzamento addizionale tra caratteri
       int            m_nInsPos ;       // posizione del punto di inserimento rispetto al testo
-      int            m_nTempProp[2] ;  // vettore proprietà temporanee
-      double         m_dTempParam[2] ; // vettore parametri temporanei
+      int            m_nTempProp ;     // proprietà temporanea 
 } ;
-
-//-----------------------------------------------------------------------------
-inline ExtText* CreateBasicExtText( void)
-               { return ( static_cast<ExtText*>( CreateGeoObj( EXT_TEXT))) ; }
-inline ExtText* CloneBasicExtText( const IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != EXT_TEXT)
-                    return nullptr ;
-                 return ( static_cast<ExtText*>( pGObj->Clone())) ; }
-inline const ExtText* GetBasicExtText( const IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != EXT_TEXT)
-                    return nullptr ;
-                 return ( static_cast<const ExtText*>( pGObj)) ; }
-inline ExtText* GetBasicExtText( IGeoObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetType() != EXT_TEXT)
-                    return nullptr ;
-                 return ( static_cast<ExtText*>( pGObj)) ; }

FilletChamfer.cpp

@@ -15,167 +15,95 @@
 #include "stdafx.h"
 #include "CurveArc.h"
 #include "CurveLine.h"
-#include "/EgtDev/Include/EGkFilletChamfer.h"
-#include "/EgtDev/Include/EGkDistPointCurve.h"
-#include "/EgtDev/Include/EGkIntersCurves.h"
-#include "/EgtDev/Include/EgkOffsetCurve.h"
+#include "/EgtDev/Include/EgkFilletChamfer.h"
+#include "/EgtDev/Include/EgkDistPointCurve.h"
+#include "/EgtDev/Include/EgkIntersCurves.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 
 using namespace std ;
 
-//----------------------------------------------------------------------------
-static bool
-CalcForFillet( const ICurve& cCrv1, const Point3d& ptNear1,
-               const ICurve& cCrv2, const Point3d& ptNear2,
-               const Vector3d& vtNorm, double dRadius,
-               Point3d& ptCen, Point3d& ptTg1, Point3d& ptTg2,
-               int& nSide1, int& nSide2, double& dSinA, double& dTgPar1, double& dTgPar2)
-{
-  // calcolo un riferimento sul piano perpendicolare alla normale
-   Frame3d frIntr ;
-   if ( ! frIntr.Set( ORIG, vtNorm))
-      return false ;
-
-  // determino il lato di offset della curva 1
-   DistPointCurve dPC1( ptNear2, cCrv1) ;
-   if ( ! dPC1.GetSideAtMinDistPoint( 0, vtNorm, nSide1))
-      return false ;
-   double dOffs1 = ( nSide1 == MDS_RIGHT ? dRadius : - dRadius) ;
-  // calcolo gli offset nel piano locale e dal lato opportuno di una copia della curva 1
-   PtrOwner<ICurve> pCopy1( cCrv1.Clone()) ;
-   if ( IsNull( pCopy1))
-      return false ;
-   pCopy1->ToLoc( frIntr) ;
-   pCopy1->SetExtrusion( Z_AX) ;
-   OffsetCurve OffsCrv1 ;
-   OffsCrv1.Make( pCopy1, dOffs1, ICurve::OFF_FILLET) ;
-   ICURVEPOVECTOR vOffs1 ;  
-   ICurve* pCrv = OffsCrv1.GetLongerCurve() ;
-   while ( pCrv != nullptr) {
-      vOffs1.emplace_back( pCrv) ;
-      pCrv = OffsCrv1.GetLongerCurve() ;
-   }
-   if ( vOffs1.empty())
-      return false ;
-
-  // determino il lato di offset della curva 2
-   DistPointCurve dPC2( ptNear1, cCrv2) ;
-   if ( ! dPC2.GetSideAtMinDistPoint( 0, vtNorm, nSide2))
-      return false ;
-   double dOffs2 = ( nSide2 == MDS_RIGHT ? dRadius : - dRadius) ;
-  // calcolo gli offset nel piano locale e dal lato opportuno di una copia della curva 2
-   PtrOwner<ICurve> pCopy2( cCrv2.Clone()) ;
-   if ( IsNull( pCopy2))
-      return false ;
-   pCopy2->ToLoc( frIntr) ;
-   pCopy2->SetExtrusion( Z_AX) ;
-   OffsetCurve OffsCrv2 ;
-   OffsCrv2.Make( pCopy2, dOffs2, ICurve::OFF_FILLET) ;
-   ICURVEPOVECTOR vOffs2 ;
-   pCrv = OffsCrv2.GetLongerCurve() ;
-   while ( pCrv != nullptr) {
-      vOffs2.emplace_back( pCrv) ;
-      pCrv = OffsCrv2.GetLongerCurve() ;
-   }
-   if ( vOffs2.empty())
-      return false ;
-
-  // calcolo le intersezioni tra tutte le curve di offset e seleziono quella più vicina ai punti passati
-   Point3d ptInt1 = P_INVALID, ptInt2 = P_INVALID ;
-   Point3d ptNearI = Media( ptNear1, ptNear2) ;
-   ptNearI.ToLoc( frIntr) ;
-   double dMinDist = INFINITO ;
-   for ( int i = 0 ; i < int( vOffs1.size()) ; i++) {
-      for ( int j = 0 ; j < int( vOffs2.size()) ; j ++) {
-         IntersCurveCurve intCC( *vOffs1[i], *vOffs2[j]) ;
-         if ( intCC.GetIntersCount() == 0)
-            continue ;
-         Point3d ptInt1Curr, ptInt2Curr ;
-         if ( ! intCC.GetIntersPointNearTo( 0, ptNearI, ptInt1Curr)  ||
-              ! intCC.GetIntersPointNearTo( 1, ptNearI, ptInt2Curr))
-            return false ;
-         Point3d ptCenCurr = Media( ptInt1Curr, ptInt2Curr) ;
-         double dDist = Dist( ptNearI, ptCenCurr) ;
-         if ( dDist < dMinDist - EPS_SMALL) {
-            dMinDist = dDist ;
-            ptInt1 = ptInt1Curr ;
-            ptInt2 = ptInt2Curr ;
-         }
-      }  
-   }
-  // se non sono state trovate intersezioni esco
-   if ( ! ptInt1.IsValid()  ||  ! ptInt2.IsValid())
-      return false ;   
-   
-   ptInt1.ToGlob( frIntr) ;
-   ptInt2.ToGlob( frIntr) ;
-   ptCen = Media( ptInt1, ptInt2) ;
-
-  // proiezione del punto di intersezione sulla prima curva
-   DistPointCurve dPCI1( ptInt1, cCrv1) ;
-   int nFlag1 ;
-   if ( ! dPCI1.GetParamAtMinDistPoint( 0, dTgPar1, nFlag1)  ||  nFlag1 != MDPCI_NORMAL)
-      return false ;
-   Vector3d vtTg1 ;
-   if ( ! cCrv1.GetPointTang( dTgPar1, ICurve::FROM_MINUS, ptTg1, vtTg1))
-      return false ;
-
-  // proiezione del punto di intersezione sulla seconda curva
-   DistPointCurve dPCI2( ptInt2, cCrv2) ;
-   int nFlag2 ;
-   if ( ! dPCI2.GetParamAtMinDistPoint( 0, dTgPar2, nFlag2)  ||  nFlag2 != MDPCI_NORMAL)
-      return false ;
-   Vector3d vtTg2 ;
-   if ( ! cCrv2.GetPointTang( dTgPar2, ICurve::FROM_MINUS, ptTg2, vtTg2))
-      return false ;
-
-  // determino rotazione tra le curve
-   dSinA = ( vtTg1 ^ vtTg2) * vtNorm ;
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 ICurveArc*
 CreateFillet( const ICurve& cCrv1, const Point3d& ptNear1,
               const ICurve& cCrv2, const Point3d& ptNear2,
               const Vector3d& vtNorm, double dRadius, double& dPar1, double& dPar2)
 {
-  // verifico validità parametri ricevuti
+  // verifico validità parametri ricevuti
    if ( &cCrv1 == nullptr  ||  &ptNear1 == nullptr  ||
         &cCrv2 == nullptr  ||  &ptNear2 == nullptr  ||
         &vtNorm == nullptr  ||  &dPar1 == nullptr  ||  &dPar2 == nullptr)
       return nullptr ;
 
-  // verifico il minimo raggio
-   if ( dRadius < 10 * EPS_SMALL)
+  // calcolo un riferimento sul piano perpendicolare alla normale
+   Frame3d frIntr ;
+   if ( ! frIntr.Set( ORIG, vtNorm))
       return nullptr ;
 
-  // eseguo calcoli
-   Point3d ptCen, ptTg1, ptTg2 ;
-   int nSide1, nSide2 ;
-   double dSinA, dTgPar1, dTgPar2 ;
-   if ( ! CalcForFillet( cCrv1, ptNear1, cCrv2, ptNear2, vtNorm, dRadius,
-                         ptCen, ptTg1, ptTg2, nSide1, nSide2, dSinA, dTgPar1, dTgPar2))
+  // determino il lato di offset della curva 1
+   DistPointCurve dPC1( ptNear2, cCrv1) ;
+   int nSide1 ;
+   if ( ! dPC1.GetSideAtMinDistPoint( 0, vtNorm, nSide1))
+      return nullptr ;
+   double dOffs1 = ( nSide1 == MDS_RIGHT ? dRadius : - dRadius) ;
+  // calcolo l'offset nel piano locale e dal lato opportuno di una copia della curva 1
+   PtrOwner<ICurve> pCopy1( cCrv1.Clone()) ;
+   if ( IsNull( pCopy1))
+      return nullptr ;
+   pCopy1->ToLoc( frIntr) ;
+   pCopy1->SetExtrusion( Z_AX) ;
+   if ( ! pCopy1->SimpleOffset( dOffs1, ICurve::OFF_FILLET))
       return nullptr ;
 
-  // se tangenti parallele al contatto con fillet, ricalcolo con raggio più piccolo
-   bool bParallel = ( abs( dSinA) < EPS_SMALL) ;
-   if ( bParallel) {
-      Point3d ptQQQ, ptQQ1, ptQQ2 ;
-      double dQQQ1, dQQQ2 ;
-      if ( ! CalcForFillet( cCrv1, ptNear1, cCrv2, ptNear2, vtNorm, dRadius - 10 * EPS_SMALL,
-                            ptQQQ, ptQQ1, ptQQ2, nSide1, nSide2, dSinA, dQQQ1, dQQQ2)  ||  abs( dSinA) < EPS_SMALL)
-         return nullptr ;
-   }
-
-  // verifico dimensione minima
-   double dLen = Dist( ptTg1, ptTg2) ;
-   if ( dLen < 2 * EPS_SMALL)
+  // determino il lato di offset della curva 2
+   DistPointCurve dPC2( ptNear1, cCrv2) ;
+   int nSide2 ;
+   if ( ! dPC2.GetSideAtMinDistPoint( 0, vtNorm, nSide2))
+      return nullptr ;
+   double dOffs2 = ( nSide2 == MDS_RIGHT ? dRadius : - dRadius) ;
+  // calcolo l'offset nel piano locale e dal lato opportuno di una copia della curva 2
+   PtrOwner<ICurve> pCopy2( cCrv2.Clone()) ;
+   if ( IsNull( pCopy2))
+      return nullptr ;
+   pCopy2->ToLoc( frIntr) ;
+   pCopy2->SetExtrusion( Z_AX) ;
+   if ( ! pCopy2->SimpleOffset( dOffs2, ICurve::OFF_FILLET))
       return nullptr ;
 
-  // orientamento tra le curve
-   bool bCCW = ( dSinA > 0) ;
+  // calcolo l'intersezione tra le due curve
+   Point3d ptInt1, ptInt2 ;
+   Point3d ptNear1I = ptNear1 ;
+   ptNear1I.ToLoc( frIntr) ;
+   IntersCurveCurve intCC( *pCopy1, *pCopy2) ;
+   if ( ! intCC.GetIntersPointNearTo( 0, ptNear1I, ptInt1)  ||
+        ! intCC.GetIntersPointNearTo( 1, ptNear1I, ptInt2))
+      return nullptr ;
+   ptInt1.ToGlob( frIntr) ;
+   ptInt2.ToGlob( frIntr) ;
+
+  // proiezione del punto di intersezione sulla prima curva
+   DistPointCurve dPCI1( ptInt1, cCrv1) ;
+   double dTgPar1 ;
+   int nFlag1 ;
+   if ( ! dPCI1.GetParamAtMinDistPoint( 0, dTgPar1, nFlag1)  ||  nFlag1 != MDPCI_NORMAL)
+      return nullptr ;
+   Point3d ptTg1 ;
+   Vector3d vtTg1 ;
+   if ( ! cCrv1.GetPointTang( dTgPar1, ICurve::FROM_MINUS, ptTg1, vtTg1))
+      return nullptr ;
+
+  // proiezione del punto di intersezione sulla seconda curva
+   DistPointCurve dPCI2( ptInt2, cCrv2) ;
+   double dTgPar2 ;
+   int nFlag2 ;
+   if ( ! dPCI2.GetParamAtMinDistPoint( 0, dTgPar2, nFlag2)  ||  nFlag2 != MDPCI_NORMAL)
+      return nullptr ;
+   Point3d ptTg2 ;
+   Vector3d vtTg2 ;
+   if ( ! cCrv2.GetPointTang( dTgPar2, ICurve::FROM_MINUS, ptTg2, vtTg2))
+      return nullptr ;
+
+  // determino rotazione tra le curve
+   bool bCCW = (( vtTg1 ^ vtTg2) * vtNorm) > 0 ;
 
   // assegno i valori dei parametri di trim (+ da inizio, - da fine)
    if ( bCCW) {
@@ -190,17 +118,8 @@ CreateFillet( const ICurve& cCrv1, const Point3d& ptNear1,
   // creo l'arco di fillet
    PtrOwner<CurveArc> crvFillet( CreateBasicCurveArc()) ;
    if ( IsNull( crvFillet)  ||
-        ! crvFillet->SetC2PN( ptCen, ptTg1, ptTg2, vtNorm))
+        ! crvFillet->SetC2PN( ptInt1, ptTg1, ptTg2, vtNorm))
       return nullptr ;
-  // se direzioni agli estremi praticamente parallele
-   if ( bParallel) {
-     // calcolo il verso dell'arco di fillet
-      bool bFilletCcw = ( ( bCCW  &&  nSide1 == nSide2)  ||  ( ! bCCW  &&  nSide1 != nSide2)) ;
-     // si deve verificare se va usato l'arco esplementare
-      bool bArcCcw = ( crvFillet->GetAngCenter() > 0) ;
-      if ( bFilletCcw != bArcCcw)
-         crvFillet->ToExplementary() ;
-   }
    return Release(crvFillet) ;
 }
 
@@ -210,16 +129,12 @@ CreateChamfer( const ICurve& cCrv1, const Point3d& ptNear1,
                const ICurve& cCrv2, const Point3d& ptNear2,
                const Vector3d& vtNorm, double dDist, double& dPar1, double& dPar2)
 {
-  // verifico validità parametri ricevuti
+  // verifico validità parametri ricevuti
    if ( &cCrv1 == nullptr  ||  &ptNear1 == nullptr  ||
         &cCrv2 == nullptr  ||  &ptNear2 == nullptr  ||
         &vtNorm == nullptr  ||  &dPar1 == nullptr  ||  &dPar2 == nullptr)
       return nullptr ;
 
-  // verifico lo smusso minimo
-   if ( dDist < 10 * EPS_SMALL)
-      return nullptr ;
-
   // calcolo un riferimento sul piano perpendicolare alla normale
    Frame3d frIntr ;
    if ( ! frIntr.Set( ORIG, vtNorm))

FontAux.h

@@ -14,7 +14,7 @@
 #pragma once
 
 #include "/EgtDev/Include/EGkVector3d.h"
-#include "/EgtDev/Include/EgtNumCollection.h"
+#include "/EgtDev/Include/EGtNumCollection.h"
 
 //----------------------------------------------------------------------------
 double AdjustFontRatio( double dRatio) ;

FontManager.cpp

@@ -17,9 +17,9 @@
 #include "/EgtDev/Include/EGkGeomDB.h"
 #include "/EgtDev/Include/EGkGdbIterator.h"
 #include "/EgtDev/Include/EGkCurve.h"
-#include "/EgtDev/Include/EGnStringUtils.h"
-#include "/EgtDev/Include/EGnFileUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
+#include "/EgtDev/Include/EgnStringUtils.h"
+#include "/EgtDev/Include/EgnFileUtils.h"
 
 using namespace std ;
 

FontManager.h

@@ -29,8 +29,6 @@ class FontManager
 
    public :
       bool Init( const std::string& sNfeFontDir, const std::string& sDefaultFont) ;
-      bool SetDefaultFont( const std::string& sDefaultFont)
-               { m_sDefaultFont = sDefaultFont ; return true ; }
       bool SetCurrFont( const std::string& sFont, int nWeight, bool bItalic,
                         double dHeight, double dRatio, double dAddAdvance) ;
       const std::string& GetNfeFontDir( void) const
@@ -56,7 +54,7 @@ class FontManager
       OsFont      m_OsFont ;
 
    private :
-      FontManager( void) : m_bCurrNfeFont( false)  {}
+      FontManager( void) {}
       FontManager( FontManager const& copy) = delete ;
       FontManager& operator=( FontManager const& copy) = delete ;
 } ;

FontNfe.cpp

@@ -16,8 +16,8 @@
 #include "FontNfe.h"
 #include "FontAux.h"
 #include "FontConst.h"
-#include "GdbIterator.h"
 #include "/EgtDev/Include/EGkGeomDB.h"
+#include "/EgtDev/Include/EGkGdbIterator.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "/EgtDev/Include/EGkCurveAux.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
@@ -81,19 +81,21 @@ NfeFont::SetCurrFont( const string& sFont, int nWeight, bool bItalic,
       if ( ! m_pGDB->Load( sFont))
          return false ;
      // recupero i parametri generali del font (devono essere nel gruppo 1)
-      GdbIterator iIter( m_pGDB) ;
-      if ( ! iIter.GoTo( 1))
+      PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGDB)) ;
+      if ( IsNull( pIter))
          return false ;
-      if ( ! iIter.GetInfo( NFE_H, m_dH)  ||
-           ! iIter.GetInfo( NFE_HCAP, m_dHCap)  ||
-           ! iIter.GetInfo( NFE_HX, m_dHx)  ||
-           ! iIter.GetInfo( NFE_ASC, m_dAsc)  ||
-           ! iIter.GetInfo( NFE_DESC, m_dDesc)  ||
-           ! iIter.GetInfo( NFE_ADV, m_dAdv))
+      if ( ! pIter->GoTo( 1))
+         return false ;
+      if ( ! pIter->GetInfo( NFE_H, m_dH)  ||
+           ! pIter->GetInfo( NFE_HCAP, m_dHCap)  ||
+           ! pIter->GetInfo( NFE_HX, m_dHx)  ||
+           ! pIter->GetInfo( NFE_ASC, m_dAsc)  ||
+           ! pIter->GetInfo( NFE_DESC, m_dDesc)  ||
+           ! pIter->GetInfo( NFE_ADV, m_dAdv))
          return false ;
       if ( m_dH < EPS_SMALL  ||  m_dHCap < EPS_SMALL  ||  m_dHx < EPS_SMALL)
          return false ;
-      if ( ! iIter.GetInfo( NFE_ITALIC, m_dItalicShearCoeff))
+      if ( ! pIter->GetInfo( NFE_ITALIC, m_dItalicShearCoeff))
          m_dItalicShearCoeff = NFE_ITALIC_STD_SHEAR_COEFF ;
      // aggiorno la path del font
       m_sFont = sFontUp ;
@@ -159,6 +161,11 @@ NfeFont::GetXBox( const string& sText, int nInsPos, bool bCapOrBound, BBox3d& b3
    if ( m_pGDB == nullptr  ||  m_sFont.empty())
       return false ;
 
+  // creo un iteratore
+   PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGDB)) ;
+   if ( IsNull( pIter))
+      return false ;
+
   // calcolo i fattori di scala
    double dScaY = m_dHeight / m_dHCap ;
    double dScaX = dScaY * m_dRatio ;
@@ -222,7 +229,9 @@ NfeFont::GetOutline( const string& sText, int nInsPos, ICURVEPLIST& lstPC) const
       return false ;
 
   // creo un iteratore
-   GdbIterator iIter( m_pGDB) ;
+   PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGDB)) ;
+   if ( IsNull( pIter))
+      return false ;
 
   // calcolo i fattori di scala
    double dScaY = m_dHeight / m_dHCap ;
@@ -256,9 +265,9 @@ NfeFont::GetOutline( const string& sText, int nInsPos, ICURVEPLIST& lstPC) const
       if ( nGroup < NFE_MIN_CHAR  ||  m_pGDB->GetGdbType( nGroup) != GDB_TY_GROUP)
          nGroup = NFE_ERR_CHAR ;
      // ciclo sulle entità geometriche del carattere
-      bool bIter = iIter.GoToFirstInGroup( nGroup) ;
+      bool bIter = pIter->GoToFirstInGroup( nGroup) ;
       while ( bIter) {
-         const ICurve* pCrv = GetCurve( iIter.GetGeoObj()) ;
+         const ICurve* pCrv = GetCurve( pIter->GetGeoObj()) ;
          if ( pCrv != nullptr) {
            // copio la curva (trasformando eventuali archi in CurveBezier)
             ICurve* pCrvNew = CurveToNoArcsCurve( pCrv) ;
@@ -272,7 +281,7 @@ NfeFont::GetOutline( const string& sText, int nInsPos, ICURVEPLIST& lstPC) const
            // inserisco in lista la nuova curva
             lstPC.push_back( pCrvNew) ;
          }
-         bIter = iIter.GoToNext() ;
+         bIter = pIter->GoToNext() ;
       }
      // recupero lo spostamento per il prossimo carattere
       double dAdvance ;
@@ -305,7 +314,9 @@ NfeFont::ApproxWithLines( const string& sText, int nInsPos, double dLinTol, doub
       return false ;
 
   // creo un iteratore
-   GdbIterator iIter( m_pGDB) ;
+   PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGDB)) ;
+   if ( IsNull( pIter))
+      return false ;
 
   // controllo valore tolleranza lineare
    if ( dLinTol > FNT_MAX_LINTOL_TO_H * m_dHeight)
@@ -343,9 +354,9 @@ NfeFont::ApproxWithLines( const string& sText, int nInsPos, double dLinTol, doub
       if ( nGroup < NFE_MIN_CHAR  ||  m_pGDB->GetGdbType( nGroup) != GDB_TY_GROUP)
          nGroup = NFE_ERR_CHAR ;
      // ciclo sulle entità geometriche del carattere
-      bool bIter = iIter.GoToFirstInGroup( nGroup) ;
+      bool bIter = pIter->GoToFirstInGroup( nGroup) ;
       while ( bIter) {
-         const ICurve* pCrv = GetCurve( iIter.GetGeoObj()) ;
+         const ICurve* pCrv = GetCurve( pIter->GetGeoObj()) ;
          if ( pCrv != nullptr) {
            // copia temporanea della curva (trasformando eventuali archi in CurveBezier)
             PtrOwner<ICurve> pCrvNew( CurveToNoArcsCurve( pCrv)) ;
@@ -360,7 +371,7 @@ NfeFont::ApproxWithLines( const string& sText, int nInsPos, double dLinTol, doub
             lstPL.emplace_back() ;
             pCrvNew->ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, lstPL.back()) ;
          }
-         bIter = iIter.GoToNext() ;
+         bIter = pIter->GoToNext() ;
       }
      // recupero lo spostamento per il prossimo carattere
       double dAdvance ;
@@ -389,7 +400,9 @@ NfeFont::ApproxWithArcs( const string& sText, int nInsPos, double dLinTol, doubl
       return false ;
 
   // creo un iteratore
-   GdbIterator iIter(  m_pGDB) ;
+   PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGDB)) ;
+   if ( IsNull( pIter))
+      return false ;
 
   // controllo valore tolleranza lineare
    if ( dLinTol > FNT_MAX_LINTOL_TO_H * m_dHeight)
@@ -427,9 +440,9 @@ NfeFont::ApproxWithArcs( const string& sText, int nInsPos, double dLinTol, doubl
       if ( nGroup < NFE_MIN_CHAR  ||  m_pGDB->GetGdbType( nGroup) != GDB_TY_GROUP)
          nGroup = NFE_ERR_CHAR ;
      // ciclo sulle entità geometriche del carattere
-      bool bIter = iIter.GoToFirstInGroup( nGroup) ;
+      bool bIter = pIter->GoToFirstInGroup( nGroup) ;
       while ( bIter) {
-         const ICurve* pCrv = GetCurve( iIter.GetGeoObj()) ;
+         const ICurve* pCrv = GetCurve( pIter->GetGeoObj()) ;
          if ( pCrv != nullptr) {
            // copia temporanea della curva (trasformando eventuali archi in CurveBezier)
             PtrOwner<ICurve> pCrvNew( CurveToNoArcsCurve( pCrv)) ;
@@ -444,7 +457,7 @@ NfeFont::ApproxWithArcs( const string& sText, int nInsPos, double dLinTol, doubl
             lstPA.emplace_back() ;
             pCrv->ApproxWithArcs( dLinTol, dAngTolDeg, lstPA.back()) ;
          }
-         bIter = iIter.GoToNext() ;
+         bIter = pIter->GoToNext() ;
       }
      // recupero lo spostamento per il prossimo carattere
       double dAdvance ;
@@ -471,6 +484,11 @@ NfeFont::GetTextLines( const string& sText, int nInsPos, PNTVECTOR& vPt, STRVECT
    if ( m_pGDB == nullptr  ||  m_sFont.empty())
       return false ;
 
+  // creo un iteratore
+   PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGDB)) ;
+   if ( IsNull( pIter))
+      return false ;
+
   // calcolo i fattori di scala
    double dScaY = m_dHeight / m_dHCap ;
    double dScaX = dScaY * m_dRatio ;
@@ -493,7 +511,7 @@ NfeFont::GetTextLines( const string& sText, int nInsPos, PNTVECTOR& vPt, STRVECT
       int nLbLen ;
       if ( IsLineBreak( vCode, i, nLbLen)) {
         // salvo la linea, se contiene qualcosa
-         if ( ! vTmpCode.empty()) {
+         if ( vTmpCode.size() > 0) {
             string sLine ;
             SetCodePoints( vTmpCode, sLine) ;
             vLine.push_back( sLine) ;
@@ -523,7 +541,7 @@ NfeFont::GetTextLines( const string& sText, int nInsPos, PNTVECTOR& vPt, STRVECT
          dMaxW = vtMove.x ;
    }
   // salvo eventuale ultima linea
-   if ( ! vTmpCode.empty()) {
+   if ( vTmpCode.size() > 0) {
       string sLine ;
       SetCodePoints( vTmpCode, sLine) ;
       vLine.push_back( sLine) ;

FontOs.cpp

@@ -16,15 +16,15 @@
 #include "FontOs.h"
 #include "FontAux.h"
 #include "FontConst.h"
-#include "CurveLine.h"
-#include "CurveBezier.h"
-#include "CurveComposite.h"
 #include "SurfFlatRegion.h"
 #include "GeoConst.h"
 #include "/EgtDev/Include/EGkGeomDB.h"
 #include "/EgtDev/Include/EGkGdbIterator.h"
 #include "/EgtDev/Include/EGkCurve.h"
 #include "/EgtDev/Include/EGkCurveAux.h"
+#include "/EgtDev/Include/EGkCurveComposite.h"
+#include "/EgtDev/Include/EGkCurveLine.h"
+#include "/EgtDev/Include/EGkCurveBezier.h"
 #include "/EgtDev/Include/EGkSfrCreate.h"
 #include "/EgtDev/Include/EGnStringUtils.h"
 #include "/EgtDev/Include/EGnFileUtils.h"
@@ -298,7 +298,8 @@ OsFont::GetOutline( const string& sText, int nInsPos, ICURVEPLIST& lstPC) const
       if ( ! GetCharOutline( vCode[i], dAdvance, lstTmpPC))
          return false ;
      // lo trasformo opportunamente
-      for ( auto iIter = lstTmpPC.begin() ; iIter != lstTmpPC.end() ; ++ iIter) {
+      ICURVEPLIST::iterator iIter ;
+      for ( iIter = lstTmpPC.begin() ; iIter != lstTmpPC.end() ; ++ iIter) {
         // trasformazioni
          (*iIter)->Scale( GLOB_FRM, dScaX, dScaY, dScaZ) ;  
          (*iIter)->Translate( vtMove) ;
@@ -377,7 +378,8 @@ OsFont::GetRegion( const string& sText, int nInsPos, ISURFFRPLIST& lstSFR) const
       if ( ! GetCharOutline( vCode[i], dAdvance, lstPC))
          return false ;
      // lo trasformo opportunamente
-      for ( auto iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter) {
+      ICURVEPLIST::iterator iIter ;
+      for ( iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter) {
         // inverto i percorsi per avere gli esterni CCW
          (*iIter)->Invert() ;
         // la trasformo per avere solo archi e rette
@@ -463,7 +465,8 @@ OsFont::ApproxWithLines( const string& sText, int nInsPos, double dLinTol, doubl
       if ( ! GetCharOutline( vCode[i], dAdvance, lstPC))
          return false ;
      // lo approssimo con segmenti di retta
-      for ( auto iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter) {
+      ICURVEPLIST::iterator iIter ;
+      for ( iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter) {
         // trasformazioni
          (*iIter)->Scale( GLOB_FRM, dScaX, dScaY, dScaZ) ;  
          (*iIter)->Translate( vtMove) ;
@@ -476,7 +479,7 @@ OsFont::ApproxWithLines( const string& sText, int nInsPos, double dLinTol, doubl
       if ( vtMove.x > dMaxW)
          dMaxW = vtMove.x ;
      // ciclo di pulizia
-      for ( auto iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter)
+      for ( iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter)
          delete (*iIter) ;
       lstPC.clear() ;
    }
@@ -547,7 +550,8 @@ OsFont::ApproxWithArcs( const string& sText, int nInsPos, double dLinTol, double
       if ( ! GetCharOutline( vCode[i], dAdvance, lstPC))
          return false ;
      // lo approssimo con segmenti di arco e retta
-      for ( auto iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter) {
+      ICURVEPLIST::iterator iIter ;
+      for ( iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter) {
         // trasformazioni
          (*iIter)->Scale( GLOB_FRM, dScaX, dScaY, dScaZ) ;
          (*iIter)->Translate( vtMove) ;
@@ -560,7 +564,7 @@ OsFont::ApproxWithArcs( const string& sText, int nInsPos, double dLinTol, double
       if ( vtMove.x > dMaxW)
          dMaxW = vtMove.x ;
      // ciclo di pulizia
-      for ( auto iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter)
+      for ( iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter)
          delete (*iIter) ;
       lstPC.clear() ;
    }
@@ -619,7 +623,7 @@ OsFont::GetTextLines( const string& sText, int nInsPos, PNTVECTOR& vPt, STRVECTO
       int nLbLen ;
       if ( IsLineBreak( vCode, i, nLbLen)) {
         // salvo la linea, se contiene qualcosa
-         if ( ! vTmpCode.empty()) {
+         if ( vTmpCode.size() > 0) {
             string sLine ;
             SetCodePoints( vTmpCode, sLine) ;
             vLine.push_back( sLine) ;
@@ -646,7 +650,7 @@ OsFont::GetTextLines( const string& sText, int nInsPos, PNTVECTOR& vPt, STRVECTO
          dMaxW = vtMove.x ;
    }
   // salvo eventuale ultima linea
-   if ( ! vTmpCode.empty()) {
+   if ( vTmpCode.size() > 0) {
       string sLine ;
       SetCodePoints( vTmpCode, sLine) ;
       vLine.push_back( sLine) ;
@@ -727,7 +731,7 @@ OsFont::GetCharOutline( unsigned int nChar, double& dAdvance, ICURVEPLIST& lstPC
       if ( pHeader->dwType == TT_POLYGON_TYPE) {
 
         // creo curva composita
-         PtrOwner<CurveComposite> pCCompo( CreateBasicCurveComposite()) ;
+         PtrOwner<ICurveComposite> pCCompo( CreateCurveComposite()) ;
          if ( IsNull( pCCompo))
             return false ;
 
@@ -820,7 +824,7 @@ OsFont::AddLineToCompo( ICurveComposite* pCCompo, const Point3d& ptStart, const
       return false ;
 
   // creo retta, la imposto e la inserisco nella curva composita
-   PtrOwner<CurveLine> pCLine( CreateBasicCurveLine()) ;
+   PtrOwner<ICurveLine> pCLine( CreateCurveLine()) ;
    if ( IsNull( pCLine))
       return false ;
    if ( ! pCLine->Set( ptStart, ptEnd))
@@ -841,7 +845,7 @@ OsFont::AddCBezierQuadToCompo( ICurveComposite* pCCompo,
       return false ;
 
   // creo curva di Bezier quadratica, la imposto e la inserisco nella curva composita
-   PtrOwner<CurveBezier> pCBezier( CreateBasicCurveBezier()) ;
+   PtrOwner<ICurveBezier> pCBezier( CreateCurveBezier()) ;
    if ( IsNull( pCBezier))
       return false ;
    if ( ! pCBezier->Init( 2, false)  ||

Frame3d.cpp

@@ -37,23 +37,6 @@ Frame3d::Set( const Point3d& ptOrig, const Vector3d& vtDirX,
         ! m_vtVersZ.Normalize())
       return false ;
 
-  // se ci sono errori molto piccoli di ortogonalità, li correggo
-   double dOrtXZ = m_vtVersX * m_vtVersZ ;
-   if ( dOrtXZ > EPS_ZERO  &&  dOrtXZ < 10 * EPS_ZERO) {
-      m_vtVersX = OrthoCompo( m_vtVersX, m_vtVersZ) ;
-      m_vtVersX.Normalize() ;
-   }
-   double dOrtYX = m_vtVersY * m_vtVersX ;
-   if ( dOrtYX > EPS_ZERO  &&  dOrtYX < 10 * EPS_ZERO) {
-      m_vtVersY = OrthoCompo( m_vtVersY, m_vtVersX) ;
-      m_vtVersY.Normalize() ;
-   }
-   double dOrtYZ = m_vtVersY * m_vtVersZ ;
-   if ( dOrtYZ > EPS_ZERO  &&  dOrtYZ < 10 * EPS_ZERO) {
-      m_vtVersY = OrthoCompo( m_vtVersY, m_vtVersZ) ;
-      m_vtVersY.Normalize() ;
-   }
-
   // verifica della ortogonalità dei versori e del senso destrorso
    if ( ! Verify())
       return false ;
@@ -241,10 +224,10 @@ Frame3d::Set( const Point3d& ptOrig, double dAngCDeg, double dAngADeg, double dA
 
 //----------------------------------------------------------------------------
 bool
-Frame3d::Reset( bool bGlob) 
+Frame3d::Reset( void) 
 {
-   m_nType = ( bGlob ? TOP : ERR) ;
-   m_nZType = ( bGlob ? TOP : ERR) ;
+   m_nType = TOP ;
+   m_nZType = TOP ;
    m_ptOrig = ORIG ;
    m_vtVersX = X_AX ;
    m_vtVersY = Y_AX ;
@@ -473,9 +456,6 @@ Frame3d::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
 bool
 Frame3d::Verify( void)
 {
-  // verifica origine
-   if ( ! m_ptOrig.IsValid())
-      return false ;
   // verifica della ortogonalità dei versori e del senso destrorso
    double dOrtXY = m_vtVersX * m_vtVersY ;
    double dOrtYZ = m_vtVersY * m_vtVersZ ;

GdbExecutor.h

@@ -14,10 +14,10 @@
 #pragma once
 
 #include "OutTsc.h"
-#include "/EgtDev/Include/EGkGdbExecutor.h"
+#include "/EgtDev/Include/EgkGdbExecutor.h"
 #include "/EgtDev/Include/EgtPerfCounter.h"
 #include "/EgtDev/Include/EgtExecMgr.h"
-#include "/EgtDev/Include/EGkGeoCollection.h"
+#include "/EgtDev/Include/EgkGeoCollection.h"
 #include "Tool.h"
 
 class PolyLine ;

GdbGeo.cpp

@@ -101,10 +101,6 @@ GdbGeo::Save( int nBaseId, NgeWriter& ngeOut, INTUNORDSET* pSavedIds) const
    if ( pGObjRW == nullptr)
       return false ;
 
-  // eventuali modifiche prima del salvataggio
-   if ( ! pGObjRW->PreSave( * const_cast<GdbGeo*>( this)))
-      return false ;
-
   // tipo entità e identificativi
    if ( ! ngeOut.WriteKey( pGObjRW->GetNgeId()))
       return false ;
@@ -128,11 +124,7 @@ GdbGeo::Save( int nBaseId, NgeWriter& ngeOut, INTUNORDSET* pSavedIds) const
   // parametri geometrici
    if ( ! ngeOut.WriteKey( NGE_G))
       return false ;
-   if ( ! pGObjRW->Save( ngeOut))
-      return false ;
-
-  // eventuali ripristini dopo il salvataggio
-   return pGObjRW->PostSave( * const_cast<GdbGeo*>( this)) ;
+   return pGObjRW->Save( ngeOut) ;
 }
 
 //----------------------------------------------------------------------------
@@ -189,7 +181,7 @@ GdbGeo::Load( int nNgeId, NgeReader& ngeIn, int nBaseGdbId, int& nParentId)
 
   // parametri geometrici
    IGeoObjRW* pGObjRW = dynamic_cast<IGeoObjRW*>( m_pGeoObj) ;
-   return ( pGObjRW != nullptr  &&  pGObjRW->Load( ngeIn)  &&  pGObjRW->PostLoad( *this)) ;
+   return ( pGObjRW != nullptr  &&  pGObjRW->Load( ngeIn)) ;
 }
 
 //----------------------------------------------------------------------------
@@ -336,7 +328,7 @@ GdbGeo::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoe
         // curva originale
          ICurve* pCrv = GetCurve( m_pGeoObj) ;
         // trasformo in curva di Bezier (semplice o composta)
-         ICurve* pCrvNew = ArcToBezierCurve( GetCurveArc( pCrv)) ;
+         ICurve* pCrvNew = ArcToBezierCurve( pCrv) ;
          if ( pCrvNew == nullptr)
             return false ;
         // assegno alla nuova curva estrusione e spessore di quella originale
@@ -389,7 +381,7 @@ GdbGeo::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDi
       if ( ! pArc->IsPlane()  ||
            ! AreSameOrOppositeVectorExact( pArc->GetNormVersor(), vtNorm)) {
         // trasformo in curva di Bezier (semplice o composta)
-         ICurve* pCrvNew = ArcToBezierCurve( GetCurveArc( m_pGeoObj)) ;
+         ICurve* pCrvNew = ArcToBezierCurve( GetCurve( m_pGeoObj)) ;
          if ( pCrvNew == nullptr)
             return false ;
         // assegno alla nuova curva estrusione e spessore di quella originale

GdbGeo.h

@@ -54,10 +54,6 @@ class GdbGeo : public GdbObj
 
 //----------------------------------------------------------------------------
 inline const GdbGeo* GetGdbGeo( const GdbObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetGdbType() != GDB_TY_GEO)
-                    return nullptr ;
-                 return static_cast<const GdbGeo*>( pGObj) ; }
+               { return dynamic_cast<const GdbGeo*>(pGObj) ; }
 inline GdbGeo* GetGdbGeo( GdbObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetGdbType() != GDB_TY_GEO)
-                    return nullptr ;
-                 return static_cast<GdbGeo*>( pGObj) ; }
+               { return dynamic_cast<GdbGeo*>(pGObj) ; }

GdbGroup.cpp

@@ -44,7 +44,7 @@ GdbGroup::~GdbGroup( void)
    // nel sorgente aggiorno lista dei riferimenti
    INTVECTOR vnList ;
    pGdbObj->GetInfo( GDB_SI_LIST, vnList) ;
-   const auto iFind = find( vnList.begin(), vnList.end(), m_nId) ;
+   INTVECTOR::const_iterator iFind = find( vnList.begin(), vnList.end(), m_nId) ;
    if ( iFind != vnList.end())
       vnList.erase( iFind) ;
    if ( vnList.empty())

GdbGroup.h

@@ -91,10 +91,6 @@ class GdbGroup : public GdbObj
 
 //----------------------------------------------------------------------------
 inline const GdbGroup* GetGdbGroup( const GdbObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetGdbType() != GDB_TY_GROUP)
-                    return nullptr ;
-                 return static_cast<const GdbGroup*>( pGObj) ; }
+               { return dynamic_cast<const GdbGroup*>(pGObj) ; }
 inline GdbGroup* GetGdbGroup( GdbObj* pGObj)
-               { if ( pGObj == nullptr  ||  pGObj->GetGdbType() != GDB_TY_GROUP)
-                    return nullptr ;
-                 return static_cast<GdbGroup*>( pGObj) ; }
+               { return dynamic_cast<GdbGroup*>(pGObj) ; }

GdbIterator.cpp

@@ -24,7 +24,7 @@ using namespace std ;
 IGdbIterator*
 CreateGdbIterator( IGeomDB* pGDB)
 {
-   if ( static_cast<GeomDB*>( pGDB) == nullptr)
+   if ( dynamic_cast<GeomDB*>( pGDB) == nullptr)
       return nullptr ;
    return static_cast<IGdbIterator*> ( new( nothrow) GdbIterator( pGDB)) ;
 }
@@ -53,7 +53,7 @@ GdbIterator::~GdbIterator( void)
 bool
 GdbIterator::SetGDB( IGeomDB* pGDB)
 {
-   m_pGDB = static_cast<GeomDB*>( pGDB) ;
+   m_pGDB = dynamic_cast<GeomDB*>( pGDB) ;
    if ( m_pGDB == nullptr)
       return false ;
 
@@ -105,7 +105,7 @@ GdbIterator::GoToFirstInGroup( const IGdbIterator& iIter)
       return false ;
    }
 
-   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB) {
       m_pCurrObj = nullptr ;
       return false ;
@@ -167,7 +167,7 @@ GdbIterator::GoToLastInGroup( const IGdbIterator& iIter)
       return false ;
    }
 
-   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB) {
       m_pCurrObj = nullptr ;
       return false ;
@@ -263,7 +263,7 @@ GdbIterator::GoToFirstNameInGroup( const IGdbIterator& iIter, const string& sNam
       return false ;
    }
   // converto in oggetto iteratore di base
-   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB) {
       m_pCurrObj = nullptr ;
       return false ;
@@ -345,7 +345,7 @@ GdbIterator::GoToLastNameInGroup( const IGdbIterator& iIter, const string& sName
       return false ;
    }
   // converto in oggetto iteratore di base
-   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB) {
       m_pCurrObj = nullptr ;
       return false ;
@@ -474,7 +474,7 @@ GdbIterator::GoToFirstGroupInGroup( const IGdbIterator& iIter)
       return false ;
    }
   // converto in oggetto iteratore di base
-   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB) {
       m_pCurrObj = nullptr ;
       return false ;
@@ -553,7 +553,7 @@ GdbIterator::GoToLastGroupInGroup( const IGdbIterator& iIter)
       return false ;
    }
   // converto in oggetto iteratore di base
-   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB) {
       m_pCurrObj = nullptr ;
       return false ;
@@ -1254,13 +1254,13 @@ GdbIterator::GetCalcStatus( int& nStat) const
 
 //----------------------------------------------------------------------------
 bool
-GdbIterator::SetMark( int nMark)
+GdbIterator::SetMark( void)
 {
    if ( m_pGDB == nullptr  ||  m_pCurrObj == nullptr)
       return false ;
 
   // imposto la marcatura
-   return m_pCurrObj->SetMark( nMark) ;
+   return m_pCurrObj->SetMark() ;
 }
 
 //----------------------------------------------------------------------------
@@ -1468,8 +1468,7 @@ GdbIterator::SetInfo( const string& sKey, int nInfo)
 bool
 GdbIterator::SetInfo( const string& sKey, double dInfo)
 {
-   int nErr ;
-   return ( SetInfo( sKey, ToString( dInfo, 6, &nErr)) && nErr == 0) ;
+   return SetInfo( sKey, ToString( dInfo)) ;
 }
 
 //----------------------------------------------------------------------------
@@ -1619,62 +1618,6 @@ GdbIterator::RemoveInfo( const string& sKey)
    return m_pCurrObj->RemoveInfo( sKey) ;
 }
 
-//----------------------------------------------------------------------------
-bool
-GdbIterator::GetAllInfo( STRVECTOR& vsInfo) const
-{
-   if ( m_pGDB == nullptr  ||  m_pCurrObj == nullptr)
-      return false ;
-
-  // recupero tutte le Info
-   return m_pCurrObj->GetAllInfo( vsInfo) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-GdbIterator::CopyAllInfoFrom( const IGdbIterator& iIter)
-{
-   if ( m_pGDB == nullptr  ||  m_pCurrObj == nullptr)
-      return false ;
-
-  // recupero l'oggetto sorgente
-   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
-   if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB  ||  pIter->m_pCurrObj == nullptr)
-      return false ;
-   const GdbObj* pGdbObjSou = pIter->m_pCurrObj ;
-
-  // copio tutte le Info
-   if ( m_pCurrObj != pGdbObjSou  &&  pGdbObjSou->m_pAttribs != nullptr) {
-      m_pCurrObj->GetSafeAttribs() ;
-      return ( m_pCurrObj->m_pAttribs != nullptr  &&  m_pCurrObj->m_pAttribs->CopyAllInfoFrom( *(pGdbObjSou->m_pAttribs))) ;
-   }
-   else
-      return true ;
-}
-
-//----------------------------------------------------------------------------
-// Stipple (significativo solo per curve)
-
-//----------------------------------------------------------------------------
-bool
-GdbIterator::SetStipple( int nFactor, int nPattern)
-{
-   if ( m_pGDB == nullptr  ||  m_pCurrObj == nullptr)
-      return false ;
-  // imposto lo stipple
-   return m_pCurrObj->SetStipple( nFactor, nPattern) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-GdbIterator::GetStipple( int& nFactor, int& nPattern) const
-{
-   if ( m_pGDB == nullptr  ||  m_pCurrObj == nullptr)
-      return false ;
-  // recupero lo stipple
-   return m_pCurrObj->GetStipple( nFactor, nPattern) ;
-}
-
 //----------------------------------------------------------------------------
 // TextureData
 //----------------------------------------------------------------------------

GdbIterator.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2023
+//  EgalTech 2013-2013
 //----------------------------------------------------------------------------
-// File : GdbIterator.h         Data : 09.07.23          Versione : 2.5g1
+// File : GdbIterator.h         Data : 04.12.13          Versione : 1.4a3
 // Contenuto : Dichiarazione della classe GdbIterator.
 //
 //
@@ -103,7 +103,7 @@ class GdbIterator : public IGdbIterator
       bool RevertStatus( void) override ;
       bool GetStatus( int& nStat) const override ;
       bool GetCalcStatus( int& nStat) const override ;
-      bool SetMark( int nMark = GDB_MK_ON) override ;
+      bool SetMark( void) override ;
       bool ResetMark( void) override ;
       bool GetMark( int& nMark) const override ;
       bool GetCalcMark( int& nMark) const override ;
@@ -142,11 +142,6 @@ class GdbIterator : public IGdbIterator
       bool GetInfo( const std::string& sKey, STRVECTOR& vsInfo) const override ;
       bool ExistsInfo( const std::string& sKey) const override ;
       bool RemoveInfo( const std::string& sKey) override ;
-      bool GetAllInfo( STRVECTOR& vsInfo) const override ;
-      bool CopyAllInfoFrom( const IGdbIterator& iIter) override ;
-     // Stipple
-      bool SetStipple( int nFactor, int nPattern) override ;
-      bool GetStipple( int& nFactor, int& nPattern) const override ;
      // TextureData
       bool SetTextureName( const std::string& sTxrName) override ;
       bool SetTextureFrame( const Frame3d& frTxrRef) override ;

GdbObj.cpp

@@ -31,9 +31,9 @@ using namespace std ;
 
 //----------------------------------------------------------------------------
 GdbObj::GdbObj( void)
-   : m_nId( GDB_ID_NULL), m_pAttribs( nullptr), m_nStpFactor( 0), m_nStpPattern( 0), m_pTxrData( nullptr),
-     m_pUserObj( nullptr), m_pGDB( nullptr), m_pNext( nullptr), m_pPrev( nullptr), m_pParent( nullptr),
-     m_pSelNext( nullptr), m_pSelPrev( nullptr)
+   : m_nId( GDB_ID_NULL), m_pAttribs( nullptr), m_pTxrData( nullptr), m_pUserObj( nullptr),
+     m_pSelPrev( nullptr), m_pSelNext( nullptr),
+     m_pGDB( nullptr), m_pNext( nullptr), m_pPrev( nullptr), m_pParent( nullptr)
 {
 }
 
@@ -72,9 +72,6 @@ GdbObj::CopyFrom( const GdbObj* pSou)
    if ( m_pAttribs != nullptr)
       delete m_pAttribs ;
    m_pAttribs = nullptr ;
-  // reset stipple
-   m_nStpFactor = 0 ;
-   m_nStpPattern = 0 ;
   // elimino eventuali dati della texture pre-esistenti
    if ( m_pTxrData != nullptr)
       delete m_pTxrData ;
@@ -93,10 +90,6 @@ GdbObj::CopyFrom( const GdbObj* pSou)
   // copio Id
    m_nId = pSou->m_nId ;
 
-  // copio stipple
-   m_nStpFactor = pSou->m_nStpFactor ;
-   m_nStpPattern = pSou->m_nStpPattern ;
-
   // copio gli attributi, i dati della texture e UserObj
    return ( CopyAttribsFrom( pSou) && CopyTextureDataFrom( pSou) && CopyUserObjFrom( pSou)) ;
 }
@@ -612,14 +605,14 @@ GdbObj::GetCalcStatus( int& nStat, int nLev) const
 
 //----------------------------------------------------------------------------
 bool
-GdbObj::SetMark( int nMark)
+GdbObj::SetMark( void)
 {
   // verifico esistenza (con eventuale creazione) degli attributi
    if ( GetSafeAttribs() == nullptr)
       return false ;
 
   // assegno la marcatura
-   m_pAttribs->SetMark( nMark) ;
+   m_pAttribs->SetMark() ;
    return true ;
 }
 
@@ -659,8 +652,8 @@ GdbObj::GetCalcMark( int& nMark) const
       nObjMark = m_pAttribs->GetMark() ;
 
   // se la marcatura è ON, non ho bisogno di sapere altro
-   if ( nObjMark == GDB_MK_ON  ||  nObjMark == GDB_MK_ON_2) {
-      nMark = nObjMark ;
+   if ( nObjMark == GDB_MK_ON) {
+      nMark = GDB_MK_ON ;
       return true ;
    }
 
@@ -862,8 +855,7 @@ GdbObj::SetInfo( const string& sKey, int nInfo)
 bool
 GdbObj::SetInfo( const string& sKey, double dInfo)
 {
-   int nErr ; 
-   return ( SetInfo( sKey, ToString( dInfo, 6, &nErr)) && nErr == 0) ;
+   return SetInfo( sKey, ToString( dInfo)) ;
 }
 
 //----------------------------------------------------------------------------
@@ -1031,39 +1023,6 @@ GdbObj::RemoveInfo( const string& sKey)
    return m_pAttribs->RemoveInfo( sKey) ;
 }
 
-//----------------------------------------------------------------------------
-bool
-GdbObj::GetAllInfo( STRVECTOR& vsInfo) const
-{
-  // se non ci sono attributi
-   if ( m_pAttribs == nullptr) {
-      vsInfo.clear() ;
-      return true ;
-   }
-  // recupero tutte le Info
-   return m_pAttribs->GetAllInfo( vsInfo) ;
-}
-
-//----------------------------------------------------------------------------
-// Stipple (significativo solo per curve, per ora non viene salvato)
-//----------------------------------------------------------------------------
-bool
-GdbObj::SetStipple( int nFactor, int nPattern)
-{
-   m_nStpFactor = nFactor ;
-   m_nStpPattern = nPattern ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-GdbObj::GetStipple( int& nFactor, int& nPattern) const
-{
-   nFactor = m_nStpFactor ;
-   nPattern = m_nStpPattern ;
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 // TextureData
 //----------------------------------------------------------------------------

GdbObj.h

@@ -81,7 +81,7 @@ class GdbObj
       bool IsSelected( void) const ;
       bool GetStatus( int& nStat) const ;
       bool GetCalcStatus( int& nStat, int nLev = 0) const ;
-      bool SetMark( int nMark) ;
+      bool SetMark( void) ;
       bool ResetMark( void) ;
       bool GetMark( int& nMark) const ;
       bool GetCalcMark( int& nMark) const ;
@@ -119,9 +119,6 @@ class GdbObj
       bool GetInfo( const std::string& sKey, STRVECTOR& vsInfo) const ;
       bool ExistsInfo( const std::string& sKey) const ;
       bool RemoveInfo( const std::string& sKey) ;
-      bool GetAllInfo( STRVECTOR& vsInfo) const ;
-      bool SetStipple( int nFactor, int nPattern) ;
-      bool GetStipple( int& nFactor, int& nPattern) const ;
       bool SaveTextureData( NgeWriter& ngeOut) const ;
       bool LoadTextureData( NgeReader& ngeIn) ;
       TextureData* GetTextureData( void)
@@ -163,8 +160,6 @@ class GdbObj
    public :
       int          m_nId ;
       Attribs*     m_pAttribs ;
-      int          m_nStpFactor ;
-      int          m_nStpPattern ;
       TextureData* m_pTxrData ;
       IUserObj*    m_pUserObj ;