EgtGeomKernel :

- migliorie varie.

AdjustLoops.cpp

@@ -149,11 +149,36 @@ MyAdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst)
          }
         // altrimenti attraversamento
          else {
-            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 ;
+            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 ; 
+            }         
          }
       }
    } 
@@ -226,14 +251,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, 10 * EPS_SMALL)) {
-                  pCrvCo->AddCurve( pCrvCo2, true, 10 * EPS_SMALL) ;
+               if ( AreSamePointEpsilon( ptEnd, ptStart2, 100 * EPS_SMALL)) {
+                  pCrvCo->AddCurve( pCrvCo2, true, 100 * EPS_SMALL) ;
                   CrvLst.erase( iIter2) ;
                   ptEnd = ptEnd2 ;
                   iIter2 = next( iIter) ;
                }
-               else if ( AreSamePointEpsilon( ptEnd2, ptStart, 10 * EPS_SMALL)) {
-                  pCrvCo->AddCurve( pCrvCo2, false, 10 * EPS_SMALL) ;
+               else if ( AreSamePointEpsilon( ptEnd2, ptStart, 100 * EPS_SMALL)) {
+                  pCrvCo->AddCurve( pCrvCo2, false, 100 * EPS_SMALL) ;
                   CrvLst.erase( iIter2) ;
                   ptStart = ptStart2 ;
                   iIter2 = next( iIter) ;
@@ -278,7 +303,7 @@ MyAdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst)
 
 //----------------------------------------------------------------------------
 bool
-AdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst)
+AdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst, bool bNeedSameProp)
 {
   // elimino eventuali sovrapposizioni e accostamenti
    if ( ! MyAdjustLoops( pCurve, CrvLst))
@@ -291,7 +316,7 @@ AdjustLoops( ICurve* pCurve, ICURVEPLIST& CrvLst)
         // 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) ;
+         pCrvCo->MergeCurves( LIN_TOL_MIN, ANG_TOL_STD_DEG, true, bNeedSameProp) ;
       }
    }
 

AdjustLoops.h

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

ArcCenTgCurvePnt.cpp

@@ -168,7 +168,7 @@ CurveArc* GetArcCenTgCompoPnt( const Point3d& ptCen, const CurveComposite& crvCo
       double dSqDist = SqDist( ptNearStart, ptTg) ;
       if ( dSqDist < dMinSqDist) {
          dMinSqDist = dSqDist ;
-         pCrvArc.Set( Release( pCrvAtmp)) ;
+         pCrvArc.Set( pCrvAtmp) ;
          if ( pPtTg != nullptr)
             *pPtTg = ptTg ;
       }

ArcPntDirTgCurve.cpp

@@ -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 = (dynamic_cast<CurveArc*>(Get(pCrv1)))->ExtendedOffset( dOffset) ;
+         bOk1 = (static_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 = (dynamic_cast<CurveArc*>(Get(pCrv2)))->ExtendedOffset( dOffset) ;
+         bOk2 = (static_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( GetCurve( GetArcPntDirTgCurve( ptP, vtDir, *pCrvCompo, ptNear, vtN, &ptTg))) ; 
+   PtrOwner<ICurve> pCrv( 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( GetCurve( GetArcPntDirTgCurve( ptP, vtDir, *pCrv, ptNear, vtN, &ptTg))) ;
+      PtrOwner<ICurve> pCrvTmp( 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( Release( pCrvTmp)) ;
+         pCrvNew.Set( pCrvTmp) ;
          if ( pPtTg != nullptr)
             *pPtTg = ptTg ;
       }

ArcSpecial.cpp

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2014-2022
+//  EgalTech 2014-2023
 //----------------------------------------------------------------------------
-// File : ArcSpecial.cpp         Data : 18.08.22       Versione : 2.4h2
+// File : ArcSpecial.cpp         Data : 04.08.23       Versione : 2.5h1
 // Contenuto : Implementazione funzioni per calcoli speciali archi.
 //
 //
@@ -20,7 +20,6 @@
 
 using namespace std ;
 
-
 //----------------------------------------------------------------------------
 // Come la CurveArc::Set2PD, ma se raggio infinito restituisce una retta
 //----------------------------------------------------------------------------
@@ -28,7 +27,7 @@ ICurve*
 GetArc2PD( const Point3d& ptStart, const Point3d& ptEnd, double dDirStartDeg)
 {
   // creo l'oggetto arco
-   PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
+   PtrOwner<CurveArc> pArc( CreateBasicCurveArc()) ;
    if ( IsNull( pArc))
       return nullptr ;
 
@@ -43,7 +42,7 @@ 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<ICurveLine> pLine( CreateCurveLine()) ;
+      PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
       if ( IsNull( pLine))
          return nullptr ;
      // calcolo retta, se ok la restituisco ed esco
@@ -61,7 +60,7 @@ ICurve*
 GetArc2PVN( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtDirS, const Vector3d& vtN)
 {
   // creo l'oggetto arco
-   PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
+   PtrOwner<CurveArc> pArc( CreateBasicCurveArc()) ;
    if ( IsNull( pArc))
       return nullptr ;
 
@@ -74,7 +73,7 @@ GetArc2PVN( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtDirS
    // 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<ICurveLine> pLine( CreateCurveLine()) ;
+      PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
       if ( IsNull( pLine))
          return nullptr ;
      // calcolo retta, se ok la restituisco ed esco
@@ -85,6 +84,35 @@ GetArc2PVN( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtDirS
    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
 //----------------------------------------------------------------------------
@@ -92,7 +120,7 @@ ICurve*
 GetArc3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d& ptEnd, bool bCirc)
 {
   // creo l'oggetto arco
-   PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
+   PtrOwner<CurveArc> pArc( CreateBasicCurveArc()) ;
    if ( IsNull( pArc))
       return nullptr ;
 
@@ -108,7 +136,7 @@ GetArc3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d& ptEnd,
    // verifico se i punti sono allineati nel giusto verso
    if ( ( ptOther - ptStart) * ( ptEnd - ptOther) > EPS_ZERO) {
      // creo l'oggetto retta
-      PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
+      PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
       if ( IsNull( pLine))
          return nullptr ;
      // calcolo retta, se ok la restituisco ed esco
@@ -126,7 +154,7 @@ ICurveArc*
 GetArc2PCN( const Point3d& ptStart, const Point3d& ptEnd, const Point3d& ptNearCen, const Vector3d& vtN)
 {
   // creo l'oggetto arco
-   PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
+   PtrOwner<CurveArc> pArc( CreateBasicCurveArc()) ;
    if ( IsNull( pArc))
       return nullptr ;
 

Attribs.cpp

@@ -81,8 +81,7 @@ Attribs::Dump( const GeomDB& GDB, string& sOut, bool bMM, const char* szNewLine)
    }
    sOut += szNewLine ;
   // eventuali nome e stringhe informative
-   STRLIST::const_iterator iIter ;
-   for ( iIter = m_slInfo.begin() ; iIter != m_slInfo.end() ; ++ iIter)
+   for ( auto iIter = m_slInfo.cbegin() ; iIter != m_slInfo.cend() ; ++ iIter)
       sOut += *iIter + szNewLine ;
 
    return true ;
@@ -101,7 +100,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 ;
@@ -118,8 +117,7 @@ Attribs::Save( NgeWriter& ngeOut) const
    if ( ! ngeOut.WriteInt( int( m_slInfo.size()), ";", true))
       return false ;
   // stringhe di info
-   STRLIST::const_iterator iIter ;
-   for ( iIter = m_slInfo.begin() ; iIter != m_slInfo.end() ; ++ iIter) {
+   for ( auto iIter = m_slInfo.cbegin() ; iIter != m_slInfo.cend() ; ++ iIter) {
       if ( ! ngeOut.WriteString( *iIter, nullptr, true))
          return false ;
    }
@@ -141,7 +139,7 @@ Attribs::Load( NgeReader& ngeIn)
    if ( ! ngeIn.ReadUchar( ucMode, ","))
       return false ;
    m_Data[MODE] = CLIP( ucMode, GDB_MD_STD, GDB_MD_HIDDEN) ;
-  // stato (se SEL è convertito in ON)
+  // stato (se SEL è convertito in ON)
    unsigned char ucStat ;
    if ( ! ngeIn.ReadUchar( ucStat, ","))
       return false ;
@@ -177,7 +175,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
@@ -215,10 +213,9 @@ Attribs::SetName( const string& sName)
    if ( sName.empty()  ||  ! IsValidVal( sName))
       return false ;
 
-  // può essere solo la prima stringa 
-   STRLIST::iterator iIter ;
-   if ( ( iIter = m_slInfo.begin()) != m_slInfo.end()  &&
-        FindKey( *iIter, NAME)) {
+  // può essere solo la prima stringa 
+   auto iIter = m_slInfo.begin() ;
+   if ( iIter != m_slInfo.end()  &&  FindKey( *iIter, NAME)) {
       *iIter = NAME + EQUAL + sName ;
       return true ;
    }
@@ -237,10 +234,9 @@ Attribs::SetName( const string& sName)
 bool
 Attribs::GetName( string& sName) const
 {
-  // può essere solo la prima stringa 
-   STRLIST::const_iterator iIter ;
-   if ( ( iIter = m_slInfo.begin()) != m_slInfo.end()  &&
-        FindKey( *iIter, NAME)) {
+  // può essere solo la prima stringa 
+   const auto iIter = m_slInfo.cbegin() ;
+   if ( iIter != m_slInfo.cend()  &&  FindKey( *iIter, NAME)) {
       sName = iIter->substr( NAME.length() + 1) ;
       return true ;
    }
@@ -252,23 +248,18 @@ Attribs::GetName( string& sName) const
 bool
 Attribs::ExistsName( void) const
 {
-  // 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 ;
+  // può essere solo la prima stringa 
+   const auto iIter = m_slInfo.cbegin() ;
+   return ( iIter != m_slInfo.cend()  &&  FindKey( *iIter, NAME)) ;
 }
 
 //----------------------------------------------------------------------------
 bool
 Attribs::RemoveName( void)
 {
-  // può essere solo la prima stringa 
-   STRLIST::const_iterator iIter ;
-   if ( ( iIter = m_slInfo.begin()) != m_slInfo.end()  &&
-        FindKey( *iIter, NAME)) {
+  // può essere solo la prima stringa 
+   const auto iIter = m_slInfo.cbegin() ;
+   if ( iIter != m_slInfo.cend()  &&  FindKey( *iIter, NAME)) {
       m_slInfo.pop_front() ;
       return true ;
    }
@@ -285,11 +276,11 @@ Attribs::SetInfo( const string& sKey, const string& sVal)
    if ( ! IsValidKey( sKey)  ||  sVal.empty()  ||  ! 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 ;
@@ -362,6 +353,11 @@ 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() ;

BBox3d.cpp

@@ -53,7 +53,8 @@ BBox3d::Set( double dX1, double dY1, double dZ1, double dX2, double dY2, double
 bool
 BBox3d::IsValid( void) const
 {
-   return ( m_ptMin.x < ( m_ptMax.x + EPS_SMALL)  &&
+   return ( m_ptMin.IsValid()  &&  m_ptMax.IsValid()  &&
+            m_ptMin.x < ( m_ptMax.x + EPS_SMALL)  &&
             m_ptMin.y < ( m_ptMax.y + EPS_SMALL)  &&
             m_ptMin.z < ( m_ptMax.z + EPS_SMALL)) ;
 }
@@ -447,69 +448,141 @@ BBox3d::EnclosesXY( const BBox3d& b3Box) const
 
 //----------------------------------------------------------------------------
 bool
-BBox3d::Overlaps( const BBox3d& b3B) const
+BBox3d::Overlaps( const BBox3d& b3Box) const
 {
-   if ( m_ptMax.x < b3B.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3B.m_ptMax.x + EPS_SMALL)
+   if ( m_ptMax.x < b3Box.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3Box.m_ptMax.x + EPS_SMALL)
       return false ;
-   if ( m_ptMax.y < b3B.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3B.m_ptMax.y + EPS_SMALL)
+   if ( m_ptMax.y < b3Box.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3Box.m_ptMax.y + EPS_SMALL)
       return false ;
-   if ( m_ptMax.z < b3B.m_ptMin.z - EPS_SMALL  ||  m_ptMin.z > b3B.m_ptMax.z + EPS_SMALL)
+   if ( m_ptMax.z < b3Box.m_ptMin.z - EPS_SMALL  ||  m_ptMin.z > b3Box.m_ptMax.z + EPS_SMALL)
       return false ;
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-BBox3d::OverlapsXY( const BBox3d& b3B) const
+BBox3d::OverlapsXY( const BBox3d& b3Box) const
 {
-   if ( m_ptMax.x < b3B.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3B.m_ptMax.x + EPS_SMALL)
+   if ( m_ptMax.x < b3Box.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3Box.m_ptMax.x + EPS_SMALL)
       return false ;
-   if ( m_ptMax.y < b3B.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3B.m_ptMax.y + EPS_SMALL)
+   if ( m_ptMax.y < b3Box.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3Box.m_ptMax.y + EPS_SMALL)
       return false ;
    return true ;
 }
 
 //----------------------------------------------------------------------------
-bool
-BBox3d::FindIntersection( const BBox3d& b3B, BBox3d& b3Int) const
+inline bool
+TestSeparatingAxis( const Vector3d& vtAx, const Vector3d& vtDiff, const Vector3d& vtHe,
+                    const Vector3d& vtHe2X, const Vector3d& vtHe2Y, const Vector3d& vtHe2Z)
 {
-   if ( ! IsValid()  ||  ! b3B.IsValid())
+   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
+{
+  // 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())
       return false ;
   // verifico direttamente la sovrapposizione
-   if ( m_ptMax.x < b3B.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3B.m_ptMax.x + EPS_SMALL)
+   if ( m_ptMax.x < b3Box.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3Box.m_ptMax.x + EPS_SMALL)
       return false ;
-   if ( m_ptMax.y < b3B.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3B.m_ptMax.y + EPS_SMALL)
+   if ( m_ptMax.y < b3Box.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3Box.m_ptMax.y + EPS_SMALL)
       return false ;
-   if ( m_ptMax.z < b3B.m_ptMin.z - EPS_SMALL  ||  m_ptMin.z > b3B.m_ptMax.z + EPS_SMALL)
+   if ( m_ptMax.z < b3Box.m_ptMin.z - EPS_SMALL  ||  m_ptMin.z > b3Box.m_ptMax.z + EPS_SMALL)
       return false ;
   // calcolo il box intersezione
-   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) ;
+   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) ;
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-BBox3d::FindIntersectionXY( const BBox3d& b3B, BBox3d& b3Int) const
+BBox3d::FindIntersectionXY( const BBox3d& b3Box, BBox3d& b3Int) const
 {
-   if ( ! IsValid()  ||  ! b3B.IsValid())
+   if ( ! IsValid()  ||  ! b3Box.IsValid())
       return false ;
   // verifico direttamente la sovrapposizione
-   if ( m_ptMax.x < b3B.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3B.m_ptMax.x + EPS_SMALL)
+   if ( m_ptMax.x < b3Box.m_ptMin.x - EPS_SMALL  ||  m_ptMin.x > b3Box.m_ptMax.x + EPS_SMALL)
       return false ;
-   if ( m_ptMax.y < b3B.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3B.m_ptMax.y + EPS_SMALL)
+   if ( m_ptMax.y < b3Box.m_ptMin.y - EPS_SMALL  ||  m_ptMin.y > b3Box.m_ptMax.y + EPS_SMALL)
       return false ;
   // calcolo il box intersezione
-   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) ;
+   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) ;
    return true ;
 }
 

BiArcs.cpp

@@ -14,12 +14,13 @@
 //--------------------------- Include ----------------------------------------
 #include "stdafx.h"
 #include "BiArcs.h"
+#include "CurveLine.h"
 #include "CurveArc.h"
+#include "CurveComposite.h"
 #include "/EgtDev/Include/EGkAngle.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 ;
@@ -49,7 +50,7 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
       return nullptr ;
 
   // preparo la curva composita per i biarchi
-   PtrOwner<ICurveComposite> pBiArc( CreateCurveComposite()) ;
+   PtrOwner<CurveComposite> pBiArc( CreateBasicCurveComposite()) ;
    if ( IsNull( pBiArc))
       return nullptr ;
 
@@ -94,10 +95,10 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
       pBiArc.Set( GetBiArc( ptP0, dDir0Deg, ptP1, dDir1Deg, 0.5)) ;
    }
    else {
-      CurveArc* pArc = GetBasicCurveArc( pJCrv) ;
+      const 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() ;
@@ -121,9 +122,11 @@ GetBiArc( const Point3d& ptP0, double dDir0Deg, const Point3d& ptP1, double dDir
             }
          }
       }
-     // elimino casi vicino agli estremi, danno solo problemi
-      if ( dU < 0.1  ||  dU > 0.9)
+     // 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) ;
       pBiArc.Set( GetBiArc( ptP0, dDir0Deg, ptP1, dDir1Deg, dU)) ;
    }
 
@@ -132,15 +135,24 @@ 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 ;
-   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 ;
+   const double STEP = 10 ;
+   Point3d ptCurr ;
+   bool bPnt = PL.GetFirstPoint( ptCurr) ;
+   Point3d ptPrev = ptCurr ;
+   while ( bPnt) {
+      double dLen = Dist( ptCurr, ptPrev) ;
+      int nStep = ( dLen < STEP ? 2 : 1) * int( dLen / STEP) + 1 ;
+      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) ;
    }
    dDist = sqrt( dSqDist) ;
 
@@ -160,7 +172,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<ICurveLine> pLine( CreateCurveLine()) ;
+      PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
       if ( IsNull( pLine)  ||  ! pLine->Set( ptP0, ptP1))
          return nullptr ;
      // inverto per avere parametrizzazione crescente allontanandosi da Dir0 e avvicinandosi a Dir1
@@ -182,7 +194,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<ICurveArc> pArc( CreateCurveArc()) ;
+   PtrOwner<CurveArc> pArc( CreateBasicCurveArc()) ;
    if ( IsNull( pArc)  ||  ! pArc->SetXY( ptCen, dRad, dAngStart, dAngDeg, ( ptP1.z - ptP0.z)))
       return nullptr ;
    double dDirStartDeg = dAngStart + ( dAngDeg > 0 ? ANG_RIGHT : - ANG_RIGHT) ;

CAvToolSurfTm.cpp

@@ -1,8 +1,8 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2018-2018
 //----------------------------------------------------------------------------
-// File : CAToolSurfTm.cpp    Data : 08.05.18    Versione : 1.9e2
-// Contenuto : Implementazione della classe CAToolSurfTm.
+// File : CAvToolSurfTm.cpp    Data : 08.05.18    Versione : 1.9e2
+// Contenuto : Implementazione della classe CAvToolSurfTm.
 //
 //
 //
@@ -301,11 +301,11 @@ CAvToolSurfTm::MyTestPositionHG( Point3d& ptT, const Vector3d& vtDir)
    Vector3d vtDirL = vtDir ; vtDirL.ToLoc( m_frMove) ;
    b3Tool.Add( ptTL) ;
    b3Tool.Add( ptTL - vtDirL * m_Tool.GetHeigth()) ;
-   if ( vtDirL.IsXplus()  ||  vtDirL.IsXminus())
+   if ( vtDirL.IsX())
       b3Tool.Expand( 0, m_Tool.GetRadius(), m_Tool.GetRadius()) ;
-   else if ( vtDirL.IsYplus()  ||  vtDirL.IsYminus())
+   else if ( vtDirL.IsY())
       b3Tool.Expand( m_Tool.GetRadius(), 0, m_Tool.GetRadius()) ;
-   else if ( vtDirL.IsZplus()  ||  vtDirL.IsZminus())
+   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) ;

CAvToolTriangle.cpp

@@ -146,18 +146,20 @@ 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 < - EPS_ZERO)
+   if ( vtMove * vtToolAx < - 10 * EPS_ZERO)
       return -1. ;
   // Se avvicinamento non devo fare nulla
    if ( vtMove * trTria.GetN() < - EPS_ZERO)
-      return 0. ; 
+      return 0. ;
+  // Tolleranza su dischi (parti piatte perpendicolari all'asse utensile)
+   double dEpsilon = ( vtMove * vtToolAx > 0.5 ? 0 : EPS_SMALL) ;
   // 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 - EPS_SMALL) * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;      
+      double dDist = CAvDiskTriangle( ptToolOrig - ( dHeigth - dEpsilon) * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;      
       if ( dDist < - EPS_SMALL)
          return dDist ; 
      // poi verifico quello del cilindro (tenendo conto di quanto è stata allontanato il disco)
@@ -165,7 +167,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 - EPS_SMALL * vtToolAx + ( dDist + dDist2) * vtMove, vtToolAx, dRadius, trTria, vtMove) ;   
+     double dDist3 = CAvDiskTriangle( ptToolOrig - dEpsilon * vtToolAx + ( dDist + dDist2) * vtMove, vtToolAx, dRadius, trTria, vtMove) ;   
      if ( dDist3 < - EPS_SMALL)
          return dDist3 ;   
       return ( dDist + dDist2 + dDist3) ;
@@ -189,7 +191,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 - EPS_SMALL * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;   
+      double dDist3 = CAvDiskTriangle( ptDiskUpOrig - dEpsilon * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;   
       if ( dDist3 < - EPS_SMALL)
          return dDist3 ;   
       return ( dDist + dDist2 + dDist3) ;
@@ -199,7 +201,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() - EPS_SMALL) * vtToolAx, vtToolAx, tlTool.GetTipRadius(),
+      double dDist = CAvDiskTriangle( ptToolOrig - ( tlTool.GetHeigth() - dEpsilon) * vtToolAx, vtToolAx, tlTool.GetTipRadius(),
                                       trTria, vtMove) ;
       if ( dDist < - EPS_SMALL)
          return dDist ;
@@ -220,7 +222,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 - EPS_SMALL * vtToolAx, vtToolAx, tlTool.GetRadius(), trTria, vtMove) ;   
+      double dDist4 = CAvDiskTriangle( ptDiskUpOrig - dEpsilon * vtToolAx, vtToolAx, tlTool.GetRadius(), trTria, vtMove) ;   
       if ( dDist4 < - EPS_SMALL)
          return dDist4 ;   
       return ( dDist + dDist2 + dDist3 + dDist4) ;
@@ -247,7 +249,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() - EPS_SMALL) * vtToolAx, vtToolAx, tlTool.GetTipRadius(),
+      double dDist = CAvDiskTriangle( ptToolOrig - ( tlTool.GetHeigth() - dEpsilon) * vtToolAx, vtToolAx, tlTool.GetTipRadius(),
                                       trTria, vtMove) ;
       if ( dDist < - EPS_SMALL)
          return dDist ;
@@ -266,7 +268,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 - EPS_SMALL * vtToolAx, vtToolAx, tlTool.GetRadius(), trTria, vtMove) ;   
+      double dDist4 = CAvDiskTriangle( ptDiskUpOrig - dEpsilon * vtToolAx, vtToolAx, tlTool.GetRadius(), trTria, vtMove) ;   
       if ( dDist4 < - EPS_SMALL)
          return dDist4 ;   
       return ( dDist + dDist2 + dDist3 + dDist4) ;
@@ -299,10 +301,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 + EPS_SMALL * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;                
+                  dDist2 = CAvDiskTriangle( ptCompOrig + dEpsilon * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;                
                // Se disco verso l'alto
                else                
-                  dDist2 = CAvDiskTriangle( ptCompOrig - EPS_SMALL * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;               
+                  dDist2 = CAvDiskTriangle( ptCompOrig - dEpsilon * vtToolAx, vtToolAx, dRadius, trTria, vtMove) ;               
             }
             else {
               // Verifiche curva precedente per eventuale tappo sopra

CDeBoxClosedSurfTm.cpp

@@ -19,34 +19,47 @@
 
 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, double dSafeDist, const ISurfTriMesh& Stm)
+CDeBoxClosedSurfTm( const Frame3d& frBox, const Vector3d& vtDiag, const ISurfTriMesh& Stm, double dSafeDist)
 {
-  // recupero BBox del poliedro
+  // 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
    BBox3d b3Poly = Stm.GetAllTriaBox() ;
-  // calcolo il BBox del parallelepipedo
-   BBox3d b3Box( ORIG, ORIG + vtDiag) ;
+  // Calcolo il BBox del parallelepipedo
+   BBox3d b3BoxL( ORIG, ORIG + vtDiag) ;
    if ( dSafeDist > EPS_SMALL)
-      b3Box.Expand( dSafeDist) ;
-   b3Box.ToGlob( frBox) ;
+      b3BoxL.Expand( dSafeDist) ;
+   BBox3d b3Box = GetToGlob( b3BoxL, frBox) ;
   // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Box.Overlaps( b3Poly))
+   if ( ! b3Poly.Overlaps( b3Box)  ||  ! b3Poly.Overlaps( frBox, b3BoxL))
       return false ;
-  // recupero i triangoli che interferiscono con il box
+  // 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, dSafeDist, Tria))
+         if ( CDeBoxTria( frBox, vtDiag, Tria, dSafeDist))
             return true ;
       }
    }
-  // Se superficie aperta, non c'è collisione
-   if ( ! Stm.IsClosed())
+  // Se il BBox del parallelepipedo non è interno a quello del poliedro e viceversa, non c'è collisione
+   if ( ! b3Poly.Encloses( b3Box)  &&  ! b3Box.Encloses( b3Poly))
       return false ;
-  // Verifico se il box è dentro la superficie tramite calcolo distanza minima.
+  // 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) ;

CDeBoxTria.cpp

@@ -171,7 +171,7 @@ CDeSimpleBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, const Triangle3d
 
 //----------------------------------------------------------------------------
 bool
-CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, const Triangle3d& trTria)
+CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, const Triangle3d& trTria, double dSafeDist)
 {
   // Porto il triangolo nel riferimento del box
    Triangle3d trTriaL = trTria ;
@@ -182,78 +182,21 @@ CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, cons
       return CDeSimpleBoxTria( Frame3d(), vtDiag, trTriaL) ;
 
   // Verifica preliminare con box esteso
-   Frame3d frEst( Point3d( -dSafeDist, -dSafeDist, -dSafeDist)) ;
-   if ( ! CDeSimpleBoxTria( frEst, vtDiag + 2 * Vector3d( dSafeDist, dSafeDist, dSafeDist), trTriaL))
+   Frame3d frTmp( Point3d( -dSafeDist, -dSafeDist, -dSafeDist)) ;
+   if ( ! CDeSimpleBoxTria( frTmp, vtDiag + 2 * Vector3d( dSafeDist, dSafeDist, dSafeDist), trTriaL))
       return false ;
 
   // Tre box aumentati con distanza di sicurezza in un sola dimensione
-   Frame3d frTmp = frBox ; frTmp.Translate( - dSafeDist * frBox.VersX()) ;
+   frTmp.ChangeOrig( Point3d( -dSafeDist, 0, 0)) ;
    if ( CDeSimpleBoxTria( frTmp, vtDiag + 2 * dSafeDist * X_AX, trTriaL))
       return true ;
-   frTmp = frBox ; frTmp.Translate( - dSafeDist * frBox.VersY()) ;
+   frTmp.ChangeOrig( Point3d( 0, -dSafeDist, 0)) ;
    if ( CDeSimpleBoxTria( frTmp, vtDiag + 2 * dSafeDist * Y_AX, trTriaL))
       return true ;
-   frTmp = frBox ; frTmp.Translate( - dSafeDist * frBox.VersZ()) ;
+   frTmp.ChangeOrig( Point3d( 0, 0, -dSafeDist)) ;
    if ( CDeSimpleBoxTria( frTmp, vtDiag + 2 * dSafeDist * Z_AX, trTriaL))
       return true ;
 
-#if 1
-  // Sfere centrate negli otto vertici
-   if ( CDeSimpleSpheTria( Point3d( 0, 0, 0), dSafeDist, trTriaL))
-      return true ;
-   if ( CDeSimpleSpheTria( Point3d( vtDiag.x, 0, 0), dSafeDist, trTriaL))
-      return true ;
-   if ( CDeSimpleSpheTria( Point3d( vtDiag.x, vtDiag.y, 0), dSafeDist, trTriaL))
-      return true ;
-   if ( CDeSimpleSpheTria( Point3d( 0, vtDiag.y, 0), dSafeDist, trTriaL))
-      return true ;
-   if ( CDeSimpleSpheTria( Point3d( 0, 0, vtDiag.z), dSafeDist, trTriaL))
-      return true ;
-   if ( CDeSimpleSpheTria( Point3d( vtDiag.x, 0, vtDiag.z), dSafeDist, trTriaL))
-      return true ;
-   if ( CDeSimpleSpheTria( Point3d( vtDiag.x, vtDiag.y, vtDiag.z), dSafeDist, trTriaL))
-      return true ;
-   if ( CDeSimpleSpheTria( Point3d( 0, vtDiag.y, vtDiag.z), dSafeDist, trTriaL))
-      return true ;
-
-  // Cilindri centrati sui dodici spigoli
-   frTmp.Set( Point3d( 0, 0, 0), X_AX) ;
-   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.x, trTriaL))
-      return true ;
-   frTmp.Set( Point3d( 0, vtDiag.y, 0), X_AX) ;
-   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.x, trTriaL))
-      return true ;
-   frTmp.Set( Point3d( 0, 0, 0), Y_AX) ;
-   if ( CDeSimpleCylTria( frTmp, dSafeDist, vtDiag.y, trTriaL))
-      return true ;
-   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 ;
-#else
   // Capsule centrati sui dodici spigoli
    if ( CDeSimpleCapsTria( Point3d( 0, 0, 0), Point3d( vtDiag.x, 0, 0), dSafeDist, trTriaL))
       return true ;
@@ -279,7 +222,6 @@ CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, cons
       return true ;
    if ( CDeSimpleCapsTria( Point3d( 0, vtDiag.y, 0), Point3d( 0, vtDiag.y, vtDiag.z), dSafeDist, trTriaL))
       return true ;
-#endif
 
    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, double dSafeDist, const Triangle3d& trTria) ;
+bool CDeBoxTria( const Frame3d& frBox, const Vector3d& vtDiag, const Triangle3d& trTria, double dSafeDist) ;

CDeCapsTria.cpp

@@ -16,6 +16,7 @@
 #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"
@@ -31,6 +32,7 @@ CDeSimpleCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Tr
 
   // 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)
@@ -39,6 +41,13 @@ CDeSimpleCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Tr
    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 ;
@@ -48,15 +57,20 @@ CDeSimpleCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Tr
   // 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 dDist = DistPointPlane( ptP, trTria.GetPlane()) ;
-      if ( abs( dDist) >= dR)
+      double dDistM = DistPointPlane( Media( ptP1, ptP2), trTria.GetPlane()) ;
+      if ( abs( dDistM) >= dR)
          return false ;
-     // !!! DA FARE !!!! 
-     // si deve intersecare l'asse del capsule con i cilindri centrati sui lati del triangolo
-     // se intersezione inferiore a dLen allora collisione
-     // altrimenti si deve intersecare l'asse del capsule con le sfere centrate sui vertici del triangolo
-     // se intersezione inferiore a dLen allora collisione
-     // per ora salto
+     // 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
@@ -65,7 +79,7 @@ CDeSimpleCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Tr
    double dSqDist ;
    if ( dptDist.GetSqDist( dSqDist)  &&  dSqDist < 4 * SQ_EPS_SMALL) {
       double dPos = ( ptP - ptD) * vtDir ;
-      return ( dPos > -dR  &&  dPos < dLen) ;
+      return ( dPos > 0  &&  dPos < dLen) ;
    }
   // Altrimenti, recupero il punto del triangolo più vicino all'intersezione
    Point3d ptQ ;
@@ -75,7 +89,7 @@ CDeSimpleCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Tr
       if ( nLsRes != ILST_SEC)
          return false ;
       double dPos = ( ptQ - ptI1) * vtDir ;
-      return ( dPos > -dR  &&  dPos < dLen) ;
+      return ( dPos > 0  &&  dPos < dLen) ;
    }
 
    return false ;
@@ -83,7 +97,7 @@ CDeSimpleCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Tr
 
 //----------------------------------------------------------------------------
 bool
-CDeCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, double dSafeDist, const Triangle3d& trTria)
+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

@@ -16,4 +16,4 @@
 
 //----------------------------------------------------------------------------
 bool CDeSimpleCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Triangle3d& trTria) ;
-bool CDeCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, double dSafeDist, const Triangle3d& trTria) ;
+bool CDeCapsTria( const Point3d& ptP1, const Point3d& ptP2, double dR, const Triangle3d& trTria, double dSafeDist) ;

CDeClosedSurfTmClosedSurfTm.cpp

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2020-2020
 //----------------------------------------------------------------------------
-// File :      CDeSurfTmSurfTm.h      Data : 13.11.20    Versione : 
+// File :      CDeSurfTmSurfTm.h      Data : 14.06.23    Versione : 2.5f3 
 // Contenuto : Implementazione funzione verifica collisione tra
 //             SurfTm e SurfTm.
 //
@@ -18,78 +18,81 @@
 #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 i segmenti per asse e il triangolo
-// originale traslato di una costante pari alla distanza di sicurezza lungo la
-// sua normale.
+// 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.
+//----------------------------------------------------------------------------
 bool
-CDeClosedSurfTmClosedSurfTm( const SurfTriMesh& SurfA, const SurfTriMesh& SurfB, double dSafeDist)
+CDeClosedSurfTmClosedSurfTm( const ISurfTriMesh& SurfA, const ISurfTriMesh& SurfB, double dSafeDist)
 {
-   // 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.
+  // 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.
    BBox3d b3BoxA, b3BoxB ;
-   SurfA.GetLocalBBox( b3BoxA) ;
-   SurfB.GetLocalBBox( b3BoxB) ;
-   // Se è necessario, espando il box di una costante additiva pari alla distanza di sicurezza.
+   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)
-      b3BoxA.Expand( dSafeDist) ;
-   // Se i box non si sovrappongono, non c'è collisione. Ho finito.
+      b3BoxB.Expand( dSafeDist) ;
+  // Se i box non si sovrappongono, non c'è collisione. Ho finito.
    if ( ! b3BoxA.Overlaps( b3BoxB))
       return false ;
-   // Recupero i triangoli di B che interferiscono col box del triangolo di A
+  // Recupero i triangoli di A che interferiscono col box di B
    INTVECTOR vTriaIndex ;
-   SurfA.GetAllTriaOverlapBox( b3BoxB, vTriaIndex) ;
-   // Ciclo sui triangoli della superficie A che cadono nel box della superficie B.
+   pSrfA->GetAllTriaOverlapBox( b3BoxB, vTriaIndex) ;
+  // Ciclo sui triangoli della superficie A che interferiscono col box della superficie B.
    for ( int nTA : vTriaIndex) {
       Triangle3d trTriaA ;
-      if ( ! ( SurfA.GetTriangle( nTA, trTriaA)  &&  trTriaA.Validate()))
+      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.
+     // 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 ;
-      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.
+      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.
+        // Recupero il triangolo corrente della superficie B.
+        // Se triangolo non valido salto al successivo.
          Triangle3d trTriaB ;
-         if ( ! ( SurfB.GetTriangle( nTB, trTriaB)  &&  trTriaB.Validate()))
+         if ( ! ( pSrfB->GetTriangle( nTB, trTriaB)  &&  trTriaB.Validate()))
             continue ;   
-         // Se necessario considero l'offset
+        // Se necessario considero l'offset
          if ( dSafeDist > EPS_SMALL) {
             int nAdjTriaId[3] ;
-            SurfB.GetTriangleAdjacencies( nTB, nAdjTriaId) ;
-            // Ciclo sui vertici del triangolo.
+            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.
+              // Se il triangolo adiacente al triangolo corrente su questo edge
+              // non è stato processato, processo il vertice e l'edge.
                int nAdjTriaTempFlag ;
-               if ( ! ( SurfB.GetTriangleTempInt( nAdjTriaId[nVB], nAdjTriaTempFlag)  ||  nAdjTriaTempFlag == 0))
+               if ( ! ( pSrfB->GetTempInt( nAdjTriaId[nVB], nAdjTriaTempFlag)  ||  nAdjTriaTempFlag == 0))
                   continue ;
-               // Processo il vertice: se c'è collisione fra triangolo A e sfera ho finito.
+              // Processo il vertice: se c'è collisione fra triangolo A e sfera ho finito.
                if ( CDeSimpleSpheTria( trTriaB.GetP( nVB), dSafeDist, trTriaA))
                   return true ;
-               // Processo l'edge: se c'è collisione fra triangolo A e cilindro ho finito.
-               Vector3d vtEdgeV = trTriaB.GetP( nVB) - trTriaB.GetP( ( nVB + 1) % 3) ;
+              // 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 ;
@@ -97,22 +100,25 @@ CDeClosedSurfTmClosedSurfTm( const SurfTriMesh& SurfA, const SurfTriMesh& SurfB,
                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: nTFlag = 1
-         SurfB.SetTempInt( nTB, 1) ;
+        // Segno il triangolo come processato: nTemp = 1
+         pSrfB->SetTempInt( nTB, 1) ;
       }
    }
-   // Non ho trovato collisioni fra triangoli delle superfici.
-   // La collisione c'è se una superficie è dentro l'altra.
+  // 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.
    Point3d ptPointA, ptPointB ;
-   SurfA.GetFirstVertex( ptPointA) ;
-   SurfB.GetFirstVertex( ptPointB) ;
-   DistPointSurfTm DistPoinASurfB( ptPointA, SurfB) ;
-   DistPointSurfTm DistPoinBSurfA( ptPointB, SurfA) ;
-   return ( DistPoinASurfB.IsPointInside()  ||  DistPoinBSurfA.IsPointInside()) ;
-}
+   pSrfA->GetFirstVertex( ptPointA) ;
+   pSrfB->GetFirstVertex( ptPointB) ;
+   DistPointSurfTm DistPoinASrfB( ptPointA, *pSrfB) ;
+   DistPointSurfTm DistPoinBSrfA( ptPointB, *pSrfA) ;
+   return ( DistPoinASrfB.IsPointInside()  ||  DistPoinBSrfA.IsPointInside()) ;
+}

CDeConeFrustumClosedSurfTm.cpp

@@ -21,39 +21,47 @@ 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 epsilon, altrimenti è ignorata ed è ininfluente.
-// Il sistema di riferimento del cono deve essere immerso in quello della superficie.
+// 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.
+//----------------------------------------------------------------------------
 bool
 CDeConeFrustumClosedSurfTm( const Frame3d& frCone, double dBaseRad, double dTopRad, double dHeight,
-                            double dSafeDist, const ISurfTriMesh& Stm)
+                            const ISurfTriMesh& Stm, double dSafeDist)
 {
-  // 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 false ;
+      return true ;
+  // Se superficie non valida o aperta, non ha senso proseguire
+   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
+      return true ;
   // Recupero BBox della trimesh
    BBox3d b3Surf = Stm.GetAllTriaBox() ;
   // Calcolo il BBox del tronco di cono
    double dMaxRad = max( dBaseRad, dTopRad) ;
-   BBox3d b3Cone( - dMaxRad, - dMaxRad, 0, dMaxRad, dMaxRad, dHeight) ;
+   BBox3d b3ConeL( Point3d( -dMaxRad, -dMaxRad, 0),
+                   Point3d( dMaxRad, dMaxRad, dHeight)) ;
    if ( dSafeDist > EPS_SMALL)
-      b3Cone.Expand( dSafeDist) ;
-   b3Cone.ToGlob( frCone) ;
+      b3ConeL.Expand( dSafeDist) ;
+   BBox3d b3Cone = GetToGlob( b3ConeL, frCone) ;
   // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Cone.Overlaps( b3Surf))
+   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) ;
-  // Ciclo sui triangoli che interferiscono col box del cono
+  // 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, dSafeDist, trTria))
+         if ( CDeConeFrustumTria( frCone, dBaseRad, dTopRad, dHeight, trTria, dSafeDist))
             return true ;
       }
    }
-  // Se superficie aperta, non c'è collisione
-   if ( ! Stm.IsClosed())
+  // 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))
       return false ;
   // Verifico se il tronco di cono è dentro la superficie tramite calcolo distanza minima.
    Point3d ptConeCen( 0, 0, dHeight / 2) ;

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,
-                    double dSafeDist, const Triangle3d& trTria)
+                    const Triangle3d& trTria, double dSafeDist)
 {
   // 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, dSafeDist, trTria) ;
+      return CDeCylTria( frCone, max( dBaseRad, dTopRad), dHeight, trTria, dSafeDist) ;
 
   // 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, dSafeDist, trTria) ;
+      return CDeConeTria( frMyCone, dMaxRad, dHeight, trTria, dSafeDist) ;
 
   // 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

@@ -20,6 +20,5 @@
 // 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,
-                         double dSafeDist, const Triangle3d& trTria) ;
+                         const Triangle3d& trTria, double dSafeDist) ;

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, double dSafeDist, const Triangle3d& trTria)
+CDeConeTria( const Frame3d& frCone, double dRad, double dHeight, const Triangle3d& trTria, double dSafeDist)
 {
   // 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, double dSafeDist, const Triangle3d& trTria) ;
+bool CDeConeTria( const Frame3d& frCone, double dRad, double dHeight, const Triangle3d& trTria, double dSafeDist) ;

CDeConvexTorusClosedSurfTm.cpp

@@ -18,47 +18,50 @@
 using namespace std ;
 
 //----------------------------------------------------------------------------
-// Il toro convesso è il disco limitato dalla sola parte esterna del toro.
+// Il toro convesso è il solido a 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.
+// La funzione restituisce :
+// - true in caso di collisione o inconsistenza dei parametri di input
+// - false in caso di assenza di collisione.
+//----------------------------------------------------------------------------
 bool
-CDeConvexTorusClosedSurfTm( const Frame3d& frTorusFrame, double dRad1, double dRad2,
-                            double dSafeDist, const ISurfTriMesh& Stm)
+CDeConvexTorusClosedSurfTm( const Frame3d& frTorus, double dRad1, double dRad2,
+                            const ISurfTriMesh& Stm, double dSafeDist)
 {
-  // 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 b3ConvTorusBox ;
-   b3ConvTorusBox.Set( Point3d( - dRad1 - dRad2, - dRad1 - dRad2, - dRad2),
-                       Point3d(   dRad1 + dRad2,   dRad1 + dRad2,   dRad2)) ;
-  // Aggiungo eventuale distanza di sicurezza
-   if ( dSafeDist > EPS_SMALL)
-      b3ConvTorusBox.Expand( dSafeDist) ;
-  // Porto il box del toro nel riferimento della superficie (inteso some globale)
-   b3ConvTorusBox.ToGlob( frTorusFrame) ;
+  // 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 b3SurfBox = Stm.GetAllTriaBox() ;
+   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 ( ! b3ConvTorusBox.Overlaps( b3SurfBox))
+   if ( ! b3Surf.Overlaps( b3Torus)  ||  ! b3Surf.Overlaps( frTorus, b3TorusL))
       return false ;
   // Recupero i triangoli che interferiscono con il box del toro
    INTVECTOR vT ;
-   Stm.GetAllTriaOverlapBox( b3ConvTorusBox, vT) ;
-  // Ciclo sui triangoli recuperati
+   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( frTorusFrame, dRad1, dRad2, CT_TOT, dSafeDist, trTria))
+         if ( CDeConvexTorusTria( frTorus, dRad1, dRad2, CT_TOT, trTria, dSafeDist))
             return true ;
       }
    }
-  // Se superficie aperta, non c'è collisione
-   if ( ! Stm.IsClosed())
+  // Se il BBox del toro non è interno a quello del poliedro e viceversa, non c'è collisione
+   if ( ! b3Surf.Encloses( b3Torus)  &&  ! b3Torus.Encloses( b3Surf))
       return false ;
-  // Verifico se il toro è dentro la superficie tramite calcolo distanza minima.
-   Point3d ptTorusOrig = frTorusFrame.Orig() ;
+  // Verifico se il toro è dentro la superficie tramite calcolo distanza minima del suo centro
+   Point3d ptTorusOrig = frTorus.Orig() ;
    DistPointSurfTm DistConeOrigSurfCalc( ptTorusOrig, Stm) ;
   // Se il toro è interno c'è collisione
    return ( DistConeOrigSurfCalc.IsPointInside()) ;

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 = CDeConeFrustumTria( frConus, ptSt.x, ptEn.x, ptEn.z - ptSt.z, 0., trMyTria) ;
+      bCollision = CDeSimpleConeFrustumTria( frConus, ptSt.x, ptEn.x, ptEn.z - ptSt.z, 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,
-                    double dSafeDist, const Triangle3d& trTria)
+                    const Triangle3d& trTria, double dSafeDist)
 {
   // 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,
-                         double dSafeDist, const Triangle3d& trTria) ;
+                         const Triangle3d& trTria, double dSafeDist) ;

CDeCylClosedSurfTm.cpp

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2020-2020
+//  EgalTech 2020-2024
 //----------------------------------------------------------------------------
-// File : CDCylSurfTm.cpp      Data : 09.01.20        Versione : 2.2a2
+// File : CDCylSurfTm.cpp      Data : 15.02.24        Versione : 2.6b2
 // Contenuto : Implementazione della verifica di collisione tra
 //             Cylinder e Closed SurftriMesh.
 //
@@ -19,42 +19,56 @@
 
 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, double dSafeDist, const ISurfTriMesh& Stm)
+CDeCylClosedSurfTm( const Frame3d& frCyl, double dR, double dH, const ISurfTriMesh& Stm, double dSafeDist)
 {
-  // recupero BBox del poliedro
+  // 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
    BBox3d b3Poly = Stm.GetAllTriaBox() ;
-  // sistemazioni cilindro
-   Frame3d frC = frCyl ;
+  // Sistemazioni cilindro
+   Frame3d frMyCyl = frCyl ;
    if ( dH < 0) {
-      frC.Translate( dH * frC.VersZ()) ;
-      dH = - dH ;
+      frMyCyl.Translate( dH * frMyCyl.VersZ()) ;
+      dH = -dH ;
    }
-  // calcolo il BBox del cilindro
-   BBox3d b3Cyl( -dR, -dR, 0, dR, dR, dH) ;
+  // Calcolo il BBox del cilindro
+   BBox3d b3CylL( Point3d( -dR, -dR, 0),
+                  Point3d(  dR,  dR, dH)) ;
    if ( dSafeDist > EPS_SMALL)
-      b3Cyl.Expand( dSafeDist) ;
-   b3Cyl.ToGlob( frC) ;
+      b3CylL.Expand( dSafeDist) ;
+   BBox3d b3Cyl = GetToGlob( b3CylL, frMyCyl) ;
   // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Cyl.Overlaps( b3Poly))
+   if ( ! b3Poly.Overlaps( b3Cyl)  ||  ! b3Poly.Overlaps( frMyCyl, b3CylL))
       return false ;
-  // recupero i triangoli che interferiscono con il box del Cilindro
+  // 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( frC, dR, dH, dSafeDist, Tria))
+         if ( CDeCylTria( frMyCyl, dR, dH, Tria, dSafeDist))
             return true ;
       }
    }
-  // Se superficie aperta, non c'è collisione
-   if ( ! Stm.IsClosed())
+  // Se il BBox del cilindro non è interno a quello del poliedro e viceversa, non c'è collisione
+   if ( ! b3Poly.Encloses( b3Cyl)  &&  ! b3Cyl.Encloses( b3Poly))
       return false ;
-  // Verifico se il cilindro è dentro la superficie tramite calcolo distanza minima.
+  // Verifico se il cilindro è dentro la superficie tramite calcolo distanza minima del suo centro
    Point3d ptCylCen( 0, 0, dH / 2) ;
-   ptCylCen.ToGlob( frC) ;
+   ptCylCen.ToGlob( frMyCyl) ;
    DistPointSurfTm DistCylCenSurfCalc( ptCylCen, Stm) ;
   // Se il cilindro è interno c'è collisione
    return ( DistCylCenSurfCalc.IsPointInside()) ;

CDeCylTria.cpp

@@ -84,7 +84,7 @@ CDeSimpleCylTria( const Frame3d& frCyl, double dR, double dH, const Triangle3d&
 
 //----------------------------------------------------------------------------
 bool
-CDeCylTria( const Frame3d& frCyl, double dR, double dH, double dSafeDist, const Triangle3d& trTria)
+CDeCylTria( const Frame3d& frCyl, double dR, double dH, const Triangle3d& trTria, double dSafeDist)
 {
   // 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, double dSafeDist, const Triangle3d& trTria) ;
+bool CDeCylTria( const Frame3d& frCyl, double dR, double dH, const Triangle3d& trTria, double dSafeDist) ;

CDeRectPrismoidClosedSurfTm.cpp

@@ -22,47 +22,55 @@ 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,
-                             double dSafeDist, const ISurfTriMesh& Stm)
+                             const ISurfTriMesh& Stm, double dSafeDist)
 {
-  // Se il tronco di piramide non è definito o la superficie non ben definita non ha senso proseguire.
+  // 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  ||  ! Stm.IsValid())
-      return false ;
+        dHeight < EPS_SMALL)
+      return true ;
+  // Se superficie non valida o aperta, non ha senso proseguire
+   if ( ! Stm.IsValid()  ||  ! Stm.IsClosed())
+      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 b3Pyr( -dMaxLenX / 2, -dMaxLenY / 2, 0., dMaxLenX / 2, dMaxLenY / 2, dHeight) ;
+   BBox3d b3PyrL( Point3d( -dMaxLenX / 2, -dMaxLenY / 2, 0.),
+                  Point3d(  dMaxLenX / 2,  dMaxLenY / 2, dHeight)) ;
    if ( dSafeDist > EPS_SMALL)
-      b3Pyr.Expand( dSafeDist) ;
-   b3Pyr.ToGlob( frPrismoid) ;
+      b3PyrL.Expand( dSafeDist) ;
+   BBox3d b3Pyr = GetToGlob( b3PyrL, frPrismoid) ;
   // Se i BBox non interferiscono, non c'è collisione
-   if ( ! b3Pyr.Overlaps( b3Surf))
+   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) ;
-  // Ciclo sui triangoli che interferiscono col box del tronco di piramide.
+  // 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,
-                                   dSafeDist, trTria))
+                                    trTria, dSafeDist))
             return true ;
       }
    }
-  // Se superficie aperta, non c'è collisione
-   if ( ! Stm.IsClosed())
+  // 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))
       return false ;
-  // Verifico se il tronco di piramide è dentro la superficie tramite calcolo distanza minima.
+  // 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.
+  // C'è collisione se il tronco di piramide è interno
    return ( DistPyrCenSurfCalc.IsPointInside()) ;
 }

CDeRectPrismoidTria.cpp

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

CDeSpheClosedSurfTm.cpp

@@ -19,34 +19,44 @@
 
 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, double dSafeDist, const ISurfTriMesh& Stm)
+CDeSpheClosedSurfTm( const Point3d& ptCen, double dR, const ISurfTriMesh& Stm, double dSafeDist)
 {
-  // recupero BBox del poliedro
+  // 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
    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
    if ( ! b3Sphe.Overlaps( b3Poly))
       return false ;
-  // recupero i triangoli che interferiscono con il box della Sfera
+  // 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, dSafeDist, Tria))
+         if ( CDeSpheTria( ptCen, dR, Tria, dSafeDist))
             return true ;
       }
    }
-  // Se superficie aperta, non c'è collisione
-   if ( ! Stm.IsClosed())
+  // Se il BBox della sfera non è interno a quello del poliedro e viceversa, non c'è collisione
+   if ( ! b3Sphe.Encloses( b3Poly)  &&  ! b3Poly.Encloses( b3Sphe))
       return false ;
-  // Verifico se la sfera è dentro la superficie tramite calcolo distanza minima.
+  // Verifico se la sfera è dentro la superficie tramite calcolo distanza minima del suo centro
    DistPointSurfTm DistCenSurfCalc( ptCen, Stm) ;
-   // C'è collisione se la sfera è interna.
+  // C'è collisione se la sfera è interna.
    return ( DistCenSurfCalc.IsPointInside()) ;
 }

CDeSpheTria.cpp

@@ -31,7 +31,7 @@ CDeSimpleSpheTria( const Point3d& ptCen, double dR, const Triangle3d& trTria)
 
 //----------------------------------------------------------------------------
 bool
-CDeSpheTria( const Point3d& ptCen, double dR, double dSafeDist, const Triangle3d& trTria)
+CDeSpheTria( const Point3d& ptCen, double dR, const Triangle3d& trTria, double dSafeDist)
 {
    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, double dSafeDist, const Triangle3d& trTria) ;
+bool CDeSpheTria( const Point3d& ptCen, double dR, const Triangle3d& trTria, double dSafeDist) ;

CDeTriaTria.cpp

@@ -34,7 +34,7 @@ GetTwoGreater( int nVal0, int nVal1, int nVal2, int& nFirstMaxPos, int& nSecondM
       }
       else {
          nFirstMaxPos = 2 ;
-         nSecondMaxPos = 1 ;
+         nSecondMaxPos = 0 ;
       }
    }
    else if ( nVal0 > nVal2) {
@@ -168,7 +168,7 @@ CDeTriaTria( const Triangle3d& trTriaA, const Triangle3d& trTriaB)
    Vector3d vtSegSecondB = trTriaB.GetP( ( nSecondMaxPosB + 1) % 3) - trTriaB.GetP( nSecondMaxPosB) ;
    double dSegLenSecondB = vtSegSecondB.Len() ;
    vtSegSecondB /= dSegLenSecondB ;
-   DistLineLine LineLineDistCalcSecondB( ptLineP, vtLineV, 100., trTriaB.GetP( nSecondMaxPosA), vtSegSecondB, dSegLenSecondB, false) ;
+   DistLineLine LineLineDistCalcSecondB( ptLineP, vtLineV, 100., trTriaB.GetP( nSecondMaxPosB), vtSegSecondB, dSegLenSecondB, false) ;
    double dIntParEnB, dOtherParSecondB ;
    LineLineDistCalcSecondB.GetPositionsAtMinDistPoints( dIntParEnB, dOtherParSecondB) ;
    // Ordino i parametri lungo la retta di intersezione fra i piani

CDeUtility.cpp

@@ -368,4 +368,4 @@ ClampSegmentOutPlane( const Plane3d& plPlane, Point3d& ptSegP, const Vector3d& v
       dSegLen -= dIntersLen ;
    }
    return true ;
-}
+}

CircleCenTgCurve.cpp

@@ -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( Release( pCrvAtmp)) ;
+         pCrvArc.Set( pCrvAtmp) ;
          if ( pPtTg != nullptr)
             *pPtTg = ptTg ;
       }

CurveArc.cpp

@@ -22,9 +22,12 @@
 #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>
 
@@ -59,15 +62,14 @@ 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_dAngCenDeg(), m_dDeltaN(), m_VtExtr(), m_dThick(), m_nTempProp{0,0}, m_dTempParam{0.0, 0.0}, m_pVoronoiObj( nullptr)
 {
-   m_nTempProp[0] = 0 ;
-   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
 CurveArc::~CurveArc( void)
 {
+   ResetVoronoiObject() ;
 }
 
 //----------------------------------------------------------------------------
@@ -89,7 +91,9 @@ 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() ;
 
@@ -115,6 +119,8 @@ 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() ;
 
@@ -136,6 +142,8 @@ 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() ;
 
@@ -157,6 +165,8 @@ 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() ;
 
@@ -219,6 +229,8 @@ CurveArc::Set3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d&
   // non c'è DeltaN
    m_dDeltaN = 0 ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -266,6 +278,8 @@ 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() ;
 
@@ -322,6 +336,8 @@ 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() ;
 
@@ -404,6 +420,8 @@ CurveArc::Set2PRS( const Point3d& ptStart, const Point3d& ptEnd, double dRad, bo
           ( ! bCCW  &&  m_dAngCenDeg > 0)))
       m_dAngCenDeg = - m_dAngCenDeg ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -458,6 +476,8 @@ 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() ;
 
@@ -513,7 +533,8 @@ CurveArc::SetC2P( const Point3d& ptCen, const Point3d& ptStart, const Point3d& p
    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() ;
 
@@ -566,7 +587,7 @@ CurveArc::Clone( void) const
 bool
 CurveArc::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const CurveArc* pCA = dynamic_cast<const CurveArc*>( pGObjSrc) ;
+   const CurveArc* pCA = GetBasicCurveArc( pGObjSrc) ;
    if ( pCA == nullptr)
       return false ;
    return CopyFrom( *pCA) ;
@@ -582,6 +603,8 @@ CurveArc::CopyFrom( const CurveArc& caSrc)
    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] ;
    return Set( caSrc.m_PtCen, caSrc.m_VtN, caSrc.m_dRad,
                caSrc.m_VtS, caSrc.m_dAngCenDeg, caSrc.m_dDeltaN) ;
 }
@@ -701,7 +724,6 @@ CurveArc::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
 {
   // richiamo della funzione generale
    return GetBBox( GLOB_FRM, b3Loc, nFlag) ;
-
 }
 
 //----------------------------------------------------------------------------
@@ -717,115 +739,87 @@ CurveArc::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
   // assegno il box nel riferimento
    b3Ref.Reset() ;
 
-  // ricavo il Frame3D solidale all'arco
-   Frame3d frArc; frArc.Set( m_PtCen, m_dAngCenDeg > 0 ? m_VtN : - m_VtN, m_VtS) ;
+  // ricavo il riferimento intrinseco dell'arco
+   Frame3d frArc;
+   frArc.Set( m_PtCen, ( m_dAngCenDeg > 0 ? m_VtN : -m_VtN), m_VtS) ;
 
-  // cordinate nel FrRef dei versori del sistema di riferimento dell'arco
-   Vector3d a = frArc.VersX() ;
-   a.ToGlob( frRef) ;
-   double ax = a.x ;
-   double ay = a.y ;
-   double az = a.z ;
+  // pendenza intrinseca
+   double dPitch = m_dDeltaN * ( m_dAngCenDeg > 0 ? 1 : -1) / abs( m_dAngCenDeg * DEGTORAD) ;
 
-   Vector3d b = frArc.VersY() ;
-   b.ToGlob( frRef) ;
-   double bx = b.x ;
-   double by = b.y ;
-   double bz = b.z ;
-
-   Vector3d c = frArc.VersZ() ;
-   c.ToGlob( frRef) ;
-   double nx = c.x ;
-   double ny = c.y ;
-   double nz = c.z ;
-
-  // vettore degli angoli e dei punti di estremi
-   PNTVECTOR vPoints ;
-   DBLVECTOR vdTheta ;
+  // 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 ;
-   GetPointD1D2( 0, FROM_PLUS, ptS) ; if ( ! abs( m_dAngCenDeg - 360) < EPS_SMALL) { GetPointD1D2( 1, FROM_MINUS, ptE) ; }
-   vPoints.push_back( ptS) ; if ( ! abs( m_dAngCenDeg - 360) < EPS_SMALL) { vPoints.push_back( ptE) ; }
+   GetStartPoint( ptS) ;
+   ptS.ToGlob( frRef) ;
+   b3Ref.Add( ptS) ;
+   GetEndPoint( ptE) ;
+   ptE.ToGlob( frRef) ;
+   b3Ref.Add( ptE) ;
 
-  // angolo al centro, raggio e parametro Q
-   double dAngCenRad = m_dAngCenDeg * DEGTORAD ;
-   ptE.ToLoc( frArc) ; ptS.ToLoc( frArc) ;
-   double Q = ( ptE.z - ptS.z) / abs( dAngCenRad) ;
-   double dRad = m_dRad ;
+  // vettore degli angoli dei punti candidati estremi
+   DBLVECTOR vdTheta ;
 
-   if ( abs( Q) < EPS_SMALL) {
-      if ( abs( ax) > EPS_SMALL) {
-         vdTheta.push_back( atan( bx / ax)) ;
-         vdTheta.push_back( vdTheta.back() > 0 ? vdTheta.back() + PIGRECO : vdTheta.back() - PIGRECO) ;
+   // 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) ;
       }
-      if ( abs( ay) > EPS_SMALL) {
-         vdTheta.push_back( atan( by / ay)) ;
-         vdTheta.push_back( vdTheta.back() > 0 ? vdTheta.back() + PIGRECO : vdTheta.back() - PIGRECO) ;
+      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) ;
       }
-      if ( abs( az) > EPS_SMALL) {
-         vdTheta.push_back( atan( bz / az)) ;
-         vdTheta.push_back( vdTheta.back() > 0 ? vdTheta.back() + PIGRECO : vdTheta.back() - PIGRECO) ;
+      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) ;
    }
+  // altrimenti arco di elica
    else {
-
-      vector<double> Va ; Va.push_back( ax) ; Va.push_back( ay) ; Va.push_back( az) ;
-      vector<double> Vb ; Vb.push_back( bx) ; Vb.push_back( by) ; Vb.push_back( bz) ;
-      vector<double> Vn ; Vn.push_back( nx) ; Vn.push_back( ny) ; Vn.push_back( nz) ;
-
-      for ( int i = 0 ; i < 3 ; i++) {
-         double delta = dRad * dRad * Va[i] * Va[i] - Q * Q * Vn[i] * Vn[i] + Vb[i] * Vb[i] * dRad * dRad ;
-         if ( delta > 0) {
-            double t1 = ( dRad * Va[i] + sqrt( delta)) / ( Q * Vn[i] - dRad * Vb[i]) ;
-            if ( abs( 1 - t1 * t1) > EPS_SMALL) {
-               vdTheta.push_back( atan( 2 * t1 / (1 - t1 * t1))) ;
-               vdTheta.push_back(vdTheta.back() > 0 ? vdTheta.back() + PIGRECO : vdTheta.back() - PIGRECO);
-            }
-            double t2 = ( dRad * Va[i] - sqrt( delta)) / ( Q * Vn[i] - dRad * Vb[i]) ;
-            if ( abs( 1 - t2 * t2) > EPS_SMALL){
-               vdTheta.push_back( atan( 2 * t2 / ( 1 - t2 * t2))) ;
-               vdTheta.push_back( vdTheta.back() > 0 ? vdTheta.back() + PIGRECO : vdTheta.back() - PIGRECO) ;
+      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) ;
          }
       }
    }
 
-   vdTheta.push_back( PIGRECO) ;
-   vdTheta.push_back( PIGRECO / 2) ;
-   vdTheta.push_back( 3 * PIGRECO / 2) ;
-
-   for ( int i = 0 ; i < vdTheta.size() ; i++) {
-      double dTheta = vdTheta[i] > 0 ? vdTheta[i] : 2 * PIGRECO + vdTheta[i] ;
-      if ( dTheta < abs( dAngCenRad)) {
-         Point3d pt ;
-         GetPointD1D2( dTheta / ( abs( dAngCenRad)), FROM_MINUS, pt) ;
-         vPoints.push_back( pt) ;
+  // 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) ;
       }
    }
-
-   for (int i = 0; i < vPoints.size(); i++) {
-      vPoints[i].ToGlob( frRef) ;
-      b3Ref.Add( vPoints[i]) ;
-   }
    
-   return true ;
-
-  /*
-   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) ;
-   }
-
-   */
-
   // se c'è estrusione, devo tenerne conto
    if ( ! m_VtExtr.IsSmall()  &&  abs( m_dThick) > EPS_SMALL) {
       Vector3d vtFrExtr = m_VtExtr ;
@@ -852,10 +846,10 @@ CurveArc::Validate( void)
             m_dAngCenDeg = - ANG_FULL ;
       }
      // eseguo il controllo
-      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) ;
+      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) ;
    }
 
    return ( m_nStatus == OK) ;
@@ -978,10 +972,7 @@ CurveArc::GetDir( double dU, Vector3d& vtDir) const
       return false ;
 
   // il parametro U deve essere compreso tra 0 e 1
-   if ( dU < 0)
-      dU = 0 ;
-   else if ( dU > 1)
-      dU = 1 ;
+   dU = Clamp( dU, 0., 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 ;
@@ -1003,10 +994,7 @@ CurveArc::GetPointD1D2( double dU, Side nS, Point3d& ptPos, Vector3d* pvtDer1, V
       return false ;
 
   // il parametro U deve essere compreso tra 0 e 1
-   if ( dU < 0)
-      dU = 0 ;
-   else if ( dU > 1)
-      dU = 1 ;
+   dU = Clamp( dU, 0., 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 ;
@@ -1294,7 +1282,9 @@ 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() ;
   
@@ -1328,6 +1318,8 @@ 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() ;
 
@@ -1372,6 +1364,8 @@ 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() ;
 
@@ -1444,6 +1438,8 @@ CurveArc::ModifyEnd( const Point3d& ptNewEnd)
       m_dDeltaN = arcAux.m_dDeltaN ;
    }
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1455,7 +1451,7 @@ bool
 CurveArc::TrimStartAtParam( double dUTrim)
 {
   // riporto i parametri nel loro range
-   dUTrim = ( ( dUTrim < 0) ? 0 : (( dUTrim > 1) ? 1 : dUTrim)) ;
+   dUTrim = Clamp( dUTrim, 0., 1.) ;
 
   // recupero lunghezza
    double dLen ;
@@ -1471,7 +1467,7 @@ bool
 CurveArc::TrimEndAtParam( double dUTrim)
 {
   // riporto i parametri nel loro range
-   dUTrim = ( ( dUTrim < 0) ? 0 : (( dUTrim > 1) ? 1 : dUTrim)) ;
+   dUTrim = Clamp( dUTrim, 0., 1.) ;
 
   // recupero lunghezza
    double dLen ;
@@ -1529,6 +1525,8 @@ CurveArc::TrimStartAtLen( double dLenTrim)
       }
    }
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -1556,6 +1554,8 @@ CurveArc::TrimEndAtLen( double dLenTrim)
          m_dDeltaN *= dLenTrim / dLen ;
    }
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
    m_OGrMgr.Reset() ;
 
@@ -1599,6 +1599,8 @@ 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() ;
 
@@ -1613,6 +1615,8 @@ CurveArc::Translate( const Vector3d& vtMove)
    if ( m_nStatus != OK)
       return false ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1634,6 +1638,8 @@ CurveArc::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, dou
    if ( vtAx.IsSmall())
       return false ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1663,6 +1669,8 @@ 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
@@ -1690,6 +1698,8 @@ 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
@@ -1717,6 +1727,8 @@ 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
@@ -1744,6 +1756,8 @@ 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
@@ -1777,6 +1791,8 @@ CurveArc::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
    if ( vtNorm.IsSmall())
       return false ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1808,6 +1824,8 @@ CurveArc::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vt
         ! AreSameOrOppositeVectorExact( m_VtN, vtNorm))
       return false ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1831,11 +1849,16 @@ CurveArc::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 ;
+
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1853,11 +1876,16 @@ CurveArc::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 ;
+
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1878,11 +1906,16 @@ CurveArc::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 di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
+
   // trasformo il centro e i versori
    return ( m_PtCen.LocToLoc( frOri, frDest)  &&
             m_VtN.LocToLoc( frOri, frDest)  &&
@@ -1903,6 +1936,8 @@ CurveArc::InvertN( void)
    m_dAngCenDeg = - m_dAngCenDeg ;
    m_dDeltaN = - m_dDeltaN ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1983,6 +2018,8 @@ CurveArc::ChangeRadius( double dNewRadius)
   // cambio il raggio
    m_dRad = dNewRadius ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2002,6 +2039,8 @@ CurveArc::ChangeDeltaN( double dNewDeltaN)
   // cambio il parametro
    m_dDeltaN = dNewDeltaN ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2025,6 +2064,8 @@ CurveArc::ChangeAngCenter( double dNewAngCenDeg)
   // cambio il parametro
    m_dAngCenDeg = dNewAngCenDeg ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2049,6 +2090,8 @@ 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 ;
@@ -2068,6 +2111,8 @@ 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() ;
 
@@ -2097,6 +2142,8 @@ CurveArc::Flip( void)
    m_VtS.Normalize() ;
    m_dAngCenDeg = - m_dAngCenDeg ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2211,3 +2258,42 @@ ArcApproxer::GetPoint( double& dU, Point3d& ptP)
 
    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,6 +19,8 @@
 #include "GeoObjRW.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 
+class Voronoi ;
+
 //----------------------------------------------------------------------------
 class CurveArc : public ICurveArc, public IGeoObjRW
 {
@@ -54,6 +56,11 @@ class CurveArc : public ICurveArc, public IGeoObjRW
                    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) ; }
 
    public :                      // ICurve
       bool IsSimple( void) const override
@@ -183,7 +190,7 @@ class CurveArc : public ICurveArc, public IGeoObjRW
 
    public :
       CurveArc( void) ;
-      CurveArc( const CurveArc& caSrc)
+      CurveArc( const CurveArc& caSrc) : m_pVoronoiObj( nullptr)
                      { if ( ! CopyFrom( caSrc))
                           LOG_ERROR( GetEGkLogger(), "CurveArc : copy constructor error")}
       CurveArc& operator =( const CurveArc& caSrc)
@@ -192,11 +199,14 @@ 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 ;
 
    private :
       bool CopyFrom( const CurveArc& caSrc) ;
       bool Validate( void) ;
-      bool GetDir( double dU, Vector3d& vtDir) const ;
+      bool GetDir( double dU, Vector3d& vtDir) const ;      
+      bool CalcVoronoiObject( void) const ;
+      void ResetVoronoiObject( void) const ;
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
@@ -212,17 +222,23 @@ 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
+      int      m_nTempProp[2] ;        // vettore proprietà temporanee 
+      double   m_dTempParam[2] ;       // vettore parametri temporanei
+      mutable Voronoi* m_pVoronoiObj ; // Voronoi
 } ;
 
 //-----------------------------------------------------------------------------
 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)
-               { return (dynamic_cast<const CurveArc*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_ARC)
+                   return nullptr ;
+                 return ( static_cast<const CurveArc*>( pGObj)) ; }
 inline CurveArc* GetBasicCurveArc( IGeoObj* pGObj)
-               { return (dynamic_cast<CurveArc*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_ARC)
+                   return nullptr ;
+                 return ( static_cast<CurveArc*>( pGObj)) ; }

CurveAux.cpp

@@ -19,6 +19,7 @@
 #include "CurveArc.h"
 #include "CurveBezier.h"
 #include "CurveComposite.h"
+#include "Voronoi.h"
 #include "/EgtDev/Include/EGkDistPointCurve.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
@@ -30,9 +31,8 @@ using namespace std ;
 bool
 IsClosed( const ICurve& crvC)
 {
-   Point3d ptStart ;
-   Point3d ptEnd ;
-   return ( crvC.GetStartPoint( ptStart)  &&  crvC.GetEndPoint( ptEnd)  &&   AreSamePointApprox( ptStart, ptEnd)) ;
+   Point3d ptStart, ptEnd ;
+   return ( crvC.GetStartPoint( ptStart)  &&  crvC.GetEndPoint( ptEnd)  &&  AreSamePointApprox( ptStart, ptEnd)) ;
 }
 
 //----------------------------------------------------------------------------
@@ -295,7 +295,7 @@ CurveGetAreaXY( const ICurve& crvC, double& dArea)
       return false ;
   // approssimo la curva con una polilinea
    PolyLine PL ;
-   crvC.ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL) ;
+   crvC.ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL_INT, PL) ;
   // calcolo l'area
    double dAreaXY = 0 ;
    PL.GetAreaXY( dAreaXY) ;
@@ -314,7 +314,7 @@ CurveGetArea( const ICurve& crvC, Plane3d& plPlane, double& dArea)
       return false ;
   // approssimo la curva con una polilinea
    PolyLine PL ;
-   crvC.ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL) ;
+   crvC.ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL_INT, PL) ;
   // calcolo l'area
    Plane3d plMyPlane ;
    double dMyArea = 0 ;
@@ -365,9 +365,11 @@ CurveDump( const ICurve& crvC, string& sOut, bool bMM, const char* szNewLine)
   // altri dati per curva chiusa
    double dAreaXY ;
    if ( CurveGetAreaXY( crvC, dAreaXY)) {
-      bool bCCW = ( dAreaXY > 0) ; 
+      bool bCCW = ( dAreaXY > 0) ;
+      double dAreaUi = GetAreaInUiUnits( abs( dAreaXY), bMM) ;
+      int nDec = ( dAreaUi > 100 ? 1 : ( dAreaUi > 0.1 ? 3 : 6)) ;
       sOut += string( "Closed") + ( bCCW ? " CCW" : " CW") + " AreaXY=" +
-              ToString( GetAreaInUiUnits( abs( dAreaXY), bMM),1) + szNewLine ;
+              ToString( dAreaUi, nDec) + szNewLine ;
    }
 
    return true ;
@@ -509,14 +511,7 @@ CurveToArcsPerpExtrCurve( const ICurve* pCrv, double dLinTol, double dAngTolDeg)
 bool
 NurbsCurveCanonicalize( CNurbsData& cnData)
 {
-  // se periodica
-   if ( cnData.bPeriodic) {
-     // va trasformata in non-periodica (clamped)
-     // vedere The NurbsBook di Les Piegl e Tiller
-     // mancano esempi per testare
-      return false ;
-   }
-  // se con nodi extra
+   // se con nodi extra
    if ( cnData.bExtraKnotes) {
       int nKnotesNbr = int( cnData.vU.size()) ;
       if ( nKnotesNbr < 4)
@@ -525,7 +520,173 @@ NurbsCurveCanonicalize( CNurbsData& cnData)
       for ( int i = 0 ; i < nKnotesNbr - 2 ; ++ i)
          cnData.vU[i] = cnData.vU[i+1] ;
       cnData.vU.resize( nKnotesNbr - 2) ;
-      return true ;
+   }
+
+  // se periodica
+   if ( cnData.bPeriodic  ||  ! cnData.bClamped) {
+     // va trasformata in non-periodica (clamped)
+     // bisogna aumentare la molteplicità dei nodi u_p-1 e u_(m-p+1) fino ad arrivare al grado della nurbs
+     // e poi scartare nodi e punti fuori dalla regione clamped ( al di fuori della regione u_p-1 -> u_(m-p+1))
+
+      // l'agoritmo per l'inserimento dei nodi l' A5.1 del libro delle Nurbs ( Piegl e Tiller), con qualche modifica
+      // agli indici perché uso u_p-1 e u_(m-p+1), anziché u_p e u_m-p
+
+      // comincio ad aumentare la molteplictià del nodo u_m-p+1
+      int nCP = int( cnData.vCP.size()) ;
+      int nU = nCP + cnData.nDeg - 1 ;
+      int nDeg = cnData.nDeg ;
+      PNTVECTOR vBC ;
+      vBC.resize( nDeg + 1) ;
+      DBLVECTOR vBW ;
+      vBW.resize( nDeg + 1) ;
+
+     // trovo il nodo di cui aumentare la molteplicità e ne calcolo la molteplicità
+      int b = nU - nDeg - 1 + 1 ;
+      int i = b ;
+      while ( b > 0  &&  abs( cnData.vU[b] - cnData.vU[b - 1]) < EPS_ZERO)
+         -- b ;
+      int mult = min( i - b + 1, nDeg) ; // mi aspetto che sia 1, ma comunque sarà < nDeg
+     // recupero i punti da modificare
+      if ( ! cnData.bRat) {
+         for ( int i = 0 ; i <= nDeg - mult ; ++ i)
+            vBC[i] = cnData.vCP[b - nDeg + 1 + i] ;
+      }
+      else {
+         for ( int i = 0 ; i <= nDeg - mult ; ++ i) {
+            vBC[i] = cnData.vCP[b - nDeg + 1 + i] * cnData.vW[b - nDeg + 1 + i] ;
+            vBW[i] = cnData.vW[b - nDeg + 1 + i] ;
+         }
+      }
+
+     // salvo i punti inalterati
+      int r = nDeg - mult ;  // numero di volte che dovrò inserire il nodo
+      cnData.vCP.resize( nCP + r) ;
+      for ( int p = nCP - 1 ; p > b - mult  ; --p) {
+         cnData.vCP[r + p] = cnData.vCP[p] ;
+      }
+      if ( cnData.bRat ) {
+         cnData.vW.resize( nCP + r) ;
+         for ( int p = nCP - 1 ; p > b - mult  ; --p) {
+            cnData.vW[r + p] = cnData.vW[p] ;
+         }
+      }
+
+     // procedo all'inserimento
+      int L = 0 ;
+      double alpha ;
+      if ( mult < nDeg) {
+        // inserisco il nodo r volte
+         for ( int j = 1 ; j <= r ; ++ j) {
+            L = b - nDeg + j ;
+            for ( int i = 0; i <= r - j ; ++i) {
+               alpha = (cnData.vU[b] - cnData.vU[L + i])/ ( cnData.vU[i + b + 1] - cnData.vU[L + i]) ;
+               vBC[i] = alpha * vBC[i +1 ] + ( 1 - alpha) * vBC[i] ;
+               if ( cnData.bRat) {
+                  vBW[i] = alpha * vBW[i + 1] + ( 1 - alpha) * vBW[i] ;
+               }
+            }
+            cnData.vCP[L + 1] = vBC[0] ;
+            cnData.vCP[b + nDeg - j - mult] = vBC[r - j] ;
+            if ( cnData.bRat ) {
+               cnData.vW[L + 1] = vBW[0] ;
+               cnData.vW[b + nDeg - j - mult] = vBW[r-j] ;
+            }
+         }
+      }
+
+     // allungo il vettore dei nodi e sposto gli ultimi nodi
+      cnData.vU.resize( nU + r) ;
+      for ( int p = nU - 1 ; p > b ; --p)
+         cnData.vU[p + r] = cnData.vU[p] ;
+     // aggiungo i nodi nuovi
+      for ( int p = 0 ; p < r ; ++p)
+         cnData.vU[b + 1 + p] = cnData.vU[b] ;
+      nU = nU + r ;
+      nCP = nCP + r ;
+
+     // aumento la molteplicità del punto u_p-1
+      b = nDeg - 1 ;
+      i = b ;
+      while ( b > 0  &&  abs( cnData.vU[b] - cnData.vU[b - 1]) < EPS_ZERO)
+         -- b ;
+      mult = min( i - b + 1, nDeg) ; // mi aspetto che sia 1, ma comunque sarà < cnData.nDeg
+     // recupero i punti da modificare
+      if ( ! cnData.bRat) {
+         for ( int i = 0 ; i <= nDeg - mult  ; ++ i)
+            vBC[i] = cnData.vCP[i] ;
+      }
+      else {
+         for ( int i = 0 ; i <= nDeg - mult ; ++ i) {
+            vBC[i] = cnData.vCP[i] * cnData.vW[i] ;
+            vBW[i] = cnData.vW[i] ;
+         }
+      }
+
+      r = nDeg - mult ;
+     // salvo i punti inalterati
+      cnData.vCP.resize( nCP + r) ;
+      for ( int p = nCP - 1 ; p > b - mult  ; --p) {
+         cnData.vCP[r + p] = cnData.vCP[p] ;
+      }
+      if ( cnData.bRat ) {
+         cnData.vW.resize( nCP + r) ;
+         for ( int p = nCP - 1 ; p > b - mult  ; --p) {
+            cnData.vW[r + p] = cnData.vW[p] ;
+         }
+      }
+
+     // procedo all'inserimento
+      L = 0 ;
+      if ( mult < nDeg) {
+        // inserisco il nodo r volte
+         for ( int j = 1 ; j <= r ; ++ j) {
+            L = b - nDeg + j ;
+            for ( int i = 0; i <= r - j ; ++i) {
+               alpha = (cnData.vU[b] - cnData.vU[L + i])/ ( cnData.vU[i + b + 1] - cnData.vU[L + i]) ;
+               vBC[i] = alpha * vBC[i + 1] + ( 1 - alpha) * vBC[i] ;
+               if ( cnData.bRat) {
+                  vBW[i] = alpha * vBW[i + 1] + ( 1 - alpha) * vBW[i] ;
+               }
+            }
+            cnData.vCP[L + 1] = vBC[0] ;
+            cnData.vCP[b + nDeg - j - mult] = vBC[r - j] ;
+            if ( cnData.bRat ) {
+               cnData.vW[L + 1] = vBW[0] ;
+               cnData.vW[b + nDeg - j - mult] = vBW[r - j] ;
+            }
+         }
+      }
+
+     // allungo il vettore dei nodi e sposto gli ultimi nodi
+      cnData.vU.resize(nU + r) ;
+      for ( int p = nU - 1 ; p > b ; --p)
+         cnData.vU[p+r] = cnData.vU[p] ;
+     // aggiungo i nodi nuovi
+      for ( int p = 0 ; p < r ; ++p)
+         cnData.vU[b + 1 + p] = cnData.vU[b] ;
+      nU = nU + r ;
+      nCP = nCP + r ;
+
+     // rendo la curva chiusa e non periodica eliminando i primi e gli ultimi nDeg punti e nodi
+      cnData.bPeriodic = false ;
+      nCP = nCP - 2 * ( nDeg - 1);
+      nU = nU - 2 * ( nDeg - 1);
+      PNTVECTOR vCP_clamped ;
+      vCP_clamped.resize( nCP) ;
+      DBLVECTOR vU_clamped ;
+      vU_clamped.resize( nU) ;
+      for ( int i = 0 ; i < nCP ; ++i) {
+         if ( ! cnData.bRat)
+            vCP_clamped[i] = cnData.vCP[i + nDeg - 1] ;
+         else 
+            vCP_clamped[i] = cnData.vCP[i + nDeg - 1] / cnData.vW[i + nDeg - 1] ;
+      }
+      cnData.vCP = vCP_clamped ;
+      for ( int i = 0 ; i < nU ; ++i) {
+         vU_clamped[i] = cnData.vU[i + nDeg - 1] ;
+      }
+      cnData.vU = vU_clamped ;
+
    }
 
    return true ;
@@ -557,11 +718,11 @@ NurbsToBezierCurve( const CNurbsData& cnData)
    }
    if ( ! bOk)
       return nullptr ;
-
+  
   // se 1 solo intervallo, la Nurbs è già una curva di Bezier
    if ( nInt == 1) {
      // creo la curva di Bezier
-      PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
+      PtrOwner<CurveBezier> pCrvBez( CreateBasicCurveBezier()) ;
       if ( IsNull( pCrvBez))
          return nullptr ;
      // la inizializzo
@@ -585,7 +746,7 @@ NurbsToBezierCurve( const CNurbsData& cnData)
    }
 
   // altrimenti è equivalente ad una curva composita, la creo
-   PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
+   PtrOwner<CurveComposite> pCrvCompo( CreateBasicCurveComposite()) ;
    if ( IsNull( pCrvCompo))
       return nullptr ;
 
@@ -647,7 +808,7 @@ NurbsToBezierCurve( const CNurbsData& cnData)
       }
 
      // costruisco la curva di Bezier e la inserisco nella curva composita
-      PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
+      PtrOwner<CurveBezier> pCrvBez( CreateBasicCurveBezier()) ;
       if ( IsNull( pCrvBez))
          return nullptr ;
      // se precedente saltata
@@ -683,7 +844,6 @@ NurbsToBezierCurve( const CNurbsData& cnData)
          pCrvBez.Reset() ;
          bPrevRejected = true ;
       }
-
      // inizializzazioni per la prossima curva di Bezier
       if ( b < nU - 1) {
          if ( ! cnData.bRat) {
@@ -707,6 +867,30 @@ NurbsToBezierCurve( const CNurbsData& cnData)
       }
    }
 
+   // se la curva ha grado 1, manca da aggiungere l'ultimo tratto
+   if ( cnData.nDeg == 1 ) {
+      // costruisco la curva di Bezier e la inserisco nella curva composita
+      PtrOwner<CurveBezier> pCrvBez( CreateBasicCurveBezier()) ;
+      if ( ! pCrvBez->Init( cnData.nDeg, cnData.bRat))
+         return nullptr ;
+      if ( ! cnData.bRat) {
+         for ( int i = 0 ; i <= cnData.nDeg ; ++ i) {
+            if ( ! pCrvBez->SetControlPoint( i, vBC[i]))
+               return nullptr ;
+         }
+      }
+      else {
+         for ( int i = 0 ; i <= cnData.nDeg ; ++ i) {
+            if ( ! pCrvBez->SetControlPoint( i, vBC[i] / vBW[i], vBW[i]))
+               return nullptr ;
+         }
+      }
+      if ( ! pCrvBez->IsAPoint()) {
+         if ( ! pCrvCompo->AddCurve( Release( pCrvBez)))
+            return nullptr ;
+      }
+   }
+
   // restituisco la curva composita
    return Release( pCrvCompo) ;
 }
@@ -729,7 +913,7 @@ FlattenCurve( const ICurve& crCrv, double dToler, double dAngToler, int nFlag)
       return nullptr ;
   // Verifico se curva già piatta
    PolyLine PL ;
-   if ( ! crCrv.ApproxWithLines( LIN_TOL_FINE, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
+   if ( ! crCrv.ApproxWithLines( LIN_TOL_FINE, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL_INT, PL))
       return nullptr ;
    bool bFlat = true ;
    Plane3d plFlat ; plFlat.Set( ptCen, plMid.GetVersN()) ;
@@ -856,3 +1040,50 @@ AdjustCurveSlope( ICurveComposite* pCrv, double dNini, double dNfin)
    pCrv->ModifyEnd( ptFin) ;
    return true ;
 }
+
+//----------------------------------------------------------------------------
+Voronoi*
+GetCurveVoronoi( const ICurve& crvC)
+{
+   switch ( crvC.GetType()) {
+   case CRV_LINE : return GetBasicCurveLine( &crvC)->GetVoronoiObject() ;
+   case CRV_ARC : return GetBasicCurveArc( &crvC)->GetVoronoiObject() ;
+   case CRV_BEZIER : return GetBasicCurveBezier( &crvC)->GetVoronoiObject() ;
+   case CRV_COMPO : return GetBasicCurveComposite( &crvC)->GetVoronoiObject() ;
+   }
+   return nullptr ;
+}
+
+//----------------------------------------------------------------------------
+bool 
+CalcCurveVoronoiDiagram( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, int nBound) 
+{
+   Voronoi* pVoronoiObj = GetCurveVoronoi( crvC) ;
+   if ( pVoronoiObj == nullptr)
+      return false ;
+
+   return pVoronoiObj->CalcVoronoiDiagram( vCrvs, nBound) ;
+}
+
+//----------------------------------------------------------------------------
+bool 
+CalcCurveMedialAxis( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, int nSide)
+{
+   Voronoi* pVoronoiObj = GetCurveVoronoi( crvC) ;
+   if ( pVoronoiObj == nullptr)
+      return false ;
+
+   return pVoronoiObj->CalcMedialAxis( vCrvs, nSide) ;
+}
+
+//----------------------------------------------------------------------------
+bool 
+CalcCurveFatCurve( const ICurve& crvC, ICURVEPOVECTOR& vCrvs, double dRadius, bool bSquareEnds, bool bSquareMids)
+{
+   Voronoi* pVoronoiObj = GetCurveVoronoi( crvC) ;
+   if ( pVoronoiObj == nullptr)
+      return false ;
+
+   return pVoronoiObj->CalcFatCurve( vCrvs, dRadius, bSquareEnds, bSquareMids) ; 
+}
+

CurveAux.h

@@ -15,6 +15,8 @@
 
 #include "/EgtDev/Include/EGkCurveAux.h"
 
+class Voronoi ;
+
 //----------------------------------------------------------------------------
 bool IsClosed( const ICurve& crvC) ;
 bool IsValidParam( const ICurve& crvC, double dPar, ICurve::Side nSide) ;
@@ -31,3 +33,4 @@ 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) ;
+Voronoi* GetCurveVoronoi( const ICurve& crvC) ;

CurveBezier.cpp

@@ -26,6 +26,7 @@
 #include "PolynomialPoint3d.h"
 #include "Bernstein.h"
 #include "deCasteljau.h"
+#include "Voronoi.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
@@ -45,15 +46,14 @@ 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_VtExtr(), m_dThick(), m_nTempProp{0,0}, m_dTempParam{0.0,0.0}, m_pVoronoiObj( nullptr)
 {
-   m_nTempProp[0] = 0 ;
-   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
 CurveBezier::~CurveBezier( void)
 {
+   ResetVoronoiObject() ;
 }
 
 //----------------------------------------------------------------------------
@@ -77,6 +77,8 @@ CurveBezier::Init( int nDeg, bool bIsRational)
       m_vWeCtrl.clear() ;
    m_nStatus = TO_VERIFY ;
 
+  // imposto ricalcolo Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -101,6 +103,8 @@ 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() ;
 
@@ -126,6 +130,8 @@ 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() ;
 
@@ -266,7 +272,7 @@ CurveBezier::Clone( void) const
 bool
 CurveBezier::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const CurveBezier* pCB = dynamic_cast<const CurveBezier*>( pGObjSrc) ;
+   const CurveBezier* pCB = GetBasicCurveBezier( pGObjSrc) ;
    if ( pCB == nullptr)
       return false ;
    return CopyFrom( *pCB) ;
@@ -287,6 +293,8 @@ CurveBezier::CopyFrom( const CurveBezier& cbSrc)
    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] ;
    return true ;
 }
 
@@ -424,8 +432,24 @@ 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 > 0  &&  m_vPtCtrl.size() > 0) ? OK : ERR) ;
+      m_nStatus = ( ( m_nDeg >= 1  &&  m_vPtCtrl.size() >= 2) ? OK : ERR) ;
 
    return ( m_nStatus == OK) ;
 }
@@ -603,7 +627,7 @@ CurveBezier::GetMidPoint( Point3d& ptMid) const
       return false ;
   // determino il valore del parametro a metà lunghezza
    double dLen, dMid ;
-   if ( ! GetLength( dLen)  ||  ! GetParamAtLength( 0.5 * dLen, dMid))
+   if ( ! GetLengthAtParam( 1, dLen)  ||  ! GetParamAtLength( 0.5 * dLen, dMid))
       return false ;      
   // calcolo il punto
    return GetPointD1D2( dMid, ptMid) ;
@@ -640,7 +664,7 @@ CurveBezier::GetMidDir( Vector3d& vtDir) const
       return false ;
   // determino il valore del parametro a metà lunghezza
    double dLen, dMid ;
-   if ( ! GetLength( dLen)  ||  ! GetParamAtLength( 0.5 * dLen, dMid))
+   if ( ! GetLengthAtParam( 1, dLen)  ||  ! GetParamAtLength( 0.5 * dLen, dMid))
       return false ;      
   // calcolo la direzione
    return ::GetTang( *this, dMid, FROM_MINUS, vtDir) ;
@@ -1478,7 +1502,7 @@ CurveBezier::BiArcOrSplit( int nLev, PolyLine& PL, double dLinTol, double dAngTo
             return false ;
          if ( ! pCC->FromPolyLine( PL))
             return false ;
-         pCrv.Set( Release( pCC)) ;
+         pCrv.Set( pCC) ;
          dMaxDist = 0 ;
       }
      // se la polilinea ha un solo punto, esco
@@ -1590,6 +1614,8 @@ 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() ;
   
@@ -1607,6 +1633,8 @@ 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() ;
 
@@ -1624,6 +1652,8 @@ 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() ;
 
@@ -1648,6 +1678,8 @@ 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() ;
 
@@ -1672,6 +1704,8 @@ 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() ;
 
@@ -1738,7 +1772,7 @@ CurveBezier::ExtendStartByLen( double dLenExt)
       return false ;
   // determino la lunghezza originale della curva
    double dLen ;
-   if ( ! GetLength( dLen))
+   if ( ! GetLengthAtParam( 1, dLen))
       return false ;
   // stimo il valore del parametro al nuovo punto iniziale
    double dUTrim = - dLenExt / dLen ;
@@ -1772,6 +1806,9 @@ 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 ;
@@ -1786,7 +1823,7 @@ CurveBezier::ExtendEndByLen( double dLenExt)
       return false ;
   // determino la lunghezza originale della curva
    double dLen ;
-   if ( ! GetLength( dLen))
+   if ( ! GetLengthAtParam( 1, dLen))
       return false ;
   // stimo il valore del parametro al nuovo punto finale
    double dUTrim = 1 + dLenExt / dLen ;
@@ -1820,6 +1857,9 @@ 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 ;   
@@ -1833,6 +1873,8 @@ CurveBezier::Translate( const Vector3d& vtMove)
    if ( m_nStatus != OK)
       return false ;
 
+  // imposto ricalcolo Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1855,6 +1897,8 @@ CurveBezier::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng,
    if ( vtAx.IsSmall())
       return false ;
 
+  // imposto ricalcolo Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1897,6 +1941,8 @@ 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() ;
 
@@ -1926,6 +1972,8 @@ CurveBezier::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
    if ( vtNorm.IsSmall())
       return false ;
 
+  // imposto ricalcolo Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1950,6 +1998,8 @@ 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() ;
 
@@ -1974,11 +2024,16 @@ 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 ;
+
+  // imposto ricalcolo Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -1998,11 +2053,16 @@ 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 ;
+
+  // imposto ricalcolo Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2022,11 +2082,16 @@ 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 ;
+
+  // imposto ricalcolo Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -2038,3 +2103,42 @@ 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 ;
+}

CurveBezier.h

@@ -19,7 +19,8 @@
 #include "DllMain.h"
 #include "GeoObjRW.h"
 #include "/EgtDev/Include/EGkCurveBezier.h"
-#include "/EgtDev/Include/EgtNumCollection.h"
+
+class Voronoi ;
 
 //----------------------------------------------------------------------------
 class CurveBezier : public ICurveBezier, public IGeoObjRW
@@ -56,6 +57,11 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
                    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) ; }
 
    public :                      // ICurve
       bool IsSimple( void) const override { return true ; }
@@ -149,7 +155,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
 
    public :
       CurveBezier( void) ;
-      CurveBezier( const CurveBezier& cbSrc)
+      CurveBezier( const CurveBezier& cbSrc) : m_pVoronoiObj( nullptr)
                      { if ( ! CopyFrom( cbSrc))
                           LOG_ERROR( GetEGkLogger(), "CurveBezier : copy constructor error")}
       CurveBezier& operator =( const CurveBezier& cbSrc)
@@ -158,6 +164,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
                        return *this ; }
       bool ApproxWithLines( int nStep, PolyLine& PL) const ;
       bool GetApproxLength( double& dLen) const ;
+      Voronoi* GetVoronoiObject( void) const ;
 
    private :
       bool CopyFrom( const CurveBezier& cbSrc) ;
@@ -174,33 +181,41 @@ 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 ToPowerBase( PolynomialPoint3d& pol3Num, Polynomial& polDen) const ;      
+      bool CalcVoronoiObject( void) const ;
+      void ResetVoronoiObject( void) const ;
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
       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
+      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
 } ;
 
 //-----------------------------------------------------------------------------
 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)
-               { return (dynamic_cast<const CurveBezier*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_BEZIER)
+                    return nullptr ;
+                 return ( static_cast<const CurveBezier*>( pGObj)) ; }
 inline CurveBezier* GetBasicCurveBezier( IGeoObj* pGObj)
-               { return (dynamic_cast<CurveBezier*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_BEZIER)
+                    return nullptr ;
+                 return ( static_cast<CurveBezier*>( pGObj)) ; }

CurveByApprox.cpp

@@ -57,11 +57,17 @@ ICurve*
 CurveByApprox::GetCurve( int nType, double dLinTol, double dAngTolDeg, double dLinFea)
 {
   // se da approssimare con archi
-   if ( nType == ARCS_CORNER) {
+   if ( nType == ARCS  ||  nType == ARCS_CORNER) {
      // calcolo approssimazione
       PolyArc PA ;
-      if ( ! GetArcs( dLinTol, dAngTolDeg, dLinFea, PA))
-         return nullptr ;
+      if ( nType == ARCS) {
+         if ( ! GetArcs( dLinTol, dAngTolDeg, PA))
+            return nullptr ;
+      }
+      else {
+         if ( ! GetArcsCorner( dLinTol, dAngTolDeg, dLinFea, PA))
+            return nullptr ;
+      }
      // creo la composita formata da questa approssimazione
       PtrOwner<CurveComposite> pCC( CreateBasicCurveComposite()) ;
       if ( ! pCC->FromPolyArc( PA))
@@ -74,13 +80,55 @@ CurveByApprox::GetCurve( int nType, double dLinTol, double dAngTolDeg, double dL
       return Release( pCC) ;
    }
   // altrimenti con curve di Bezier cubiche
-   // !!! NON ANCORA IMPLEMENTATA !!!
+   else if ( nType == CUBIC_BEZIERS) {
+      // !!! NON ANCORA IMPLEMENTATA !!!
+      return nullptr ;
+   }
+  // tipi non previsti
    return nullptr ;
 }
 
 //----------------------------------------------------------------------------
 bool
-CurveByApprox::GetArcs( double dLinTol, double dAngTolDeg, double dLinFea, PolyArc& PA)
+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)
 {
   // pulisco il poliarco
    PA.Clear() ;
@@ -105,9 +153,18 @@ CurveByApprox::GetArcs( double dLinTol, double dAngTolDeg, double dLinFea, PolyA
       PolyLine PL ;
       for ( int j = nPrev ; j <= m_vSplits[i] ; ++ j)
          PL.AddUPoint( j, m_vPnt[j]) ;
-     // eseguo l'approssimazione con archi
-      if ( ! BiArcOrSplit( 0, PL, dLinTol, dAngTolDeg, PA))
+     // verifico se retta verticale
+      BBox3d b3PL ;
+      if ( ! PL.GetLocalBBox( b3PL))
          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] ;
    }
@@ -456,11 +513,9 @@ 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))
+         if ( IsNull( pCC)  ||  ! pCC->FromPolyLine( PL))
             return false ;
-         if ( ! pCC->FromPolyLine( PL))
-            return false ;
-         pCrv.Set( Release( pCC)) ;
+         pCrv.Set( pCC) ;
          dMaxDist = 0 ;
       }
      // se la polilinea ha un solo punto, esco

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/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<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
+      PtrOwner<CurveComposite> pCrvCompo( CreateBasicCurveComposite()) ;
       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<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
+      PtrOwner<CurveComposite> pCrvCompo( CreateBasicCurveComposite()) ;
       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<ICurveBezier> pCBez( CreateCurveBezier()) ;
+         PtrOwner<CurveBezier> pCBez( CreateBasicCurveBezier()) ;
          if ( IsNull( pCBez))
             return nullptr ;
          pCBez->Init( 3, false) ;

CurveComposite.h

@@ -21,6 +21,8 @@
 #include "/EgtDev/Include/EGkCurveComposite.h"
 #include <deque>
 
+class Voronoi ;
+
 //----------------------------------------------------------------------------
 class CurveComposite : public ICurveComposite, public IGeoObjRW
 {
@@ -53,9 +55,14 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       void SetTempProp( int nProp, int nPropInd = 0) override
               { if ( nPropInd >= 0  &&  nPropInd < 2)
-                   m_nTempProp[nPropInd] = nProp ; } 
+                   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) ; }
 
    public :                      // ICurve
       bool IsSimple( void) const override
@@ -156,7 +163,9 @@ 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 ;
@@ -164,9 +173,11 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       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 nPropNum = 0) override ;
-      bool GetCurveTempProp( int nCrv, int& nProp, int nPropNum = 0) 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 ;
+      
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
       bool Save( NgeWriter& ngeOut) const override ;
@@ -174,7 +185,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
 
    public :
       CurveComposite( void) ;
-      CurveComposite( const CurveComposite& ccSrc)
+      CurveComposite( const CurveComposite& ccSrc) : m_pVoronoiObj( nullptr)
                      { if ( ! CopyFrom( ccSrc))
                           LOG_ERROR( GetEGkLogger(), "CurveComposite : copy constructor error") }
       CurveComposite& operator =( const CurveComposite& ccSrc)
@@ -183,43 +194,82 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
                        return *this ; }
       bool RelocateFrom( CurveComposite& ccSrc) ;
       bool GetApproxLength( double& dLen) const ;
+      Voronoi* GetVoronoiObject( 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 IsOneCircle( Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW) const ;      
+      bool CalcVoronoiObject( void) const ;
+      void ResetVoronoiObject( void) const ;
 
    private :
       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 
-      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[2] ;  // vettore proprietà temporanee
+      double           m_dTempParam[2] ; // vettore parametri temporanei 
+      mutable Voronoi* m_pVoronoiObj ;   // Voronoi
+      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)
-               { return (dynamic_cast<const CurveComposite*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_COMPO)
+                    return nullptr ;
+                 return ( static_cast<const CurveComposite*>( pGObj)) ; }
 inline CurveComposite* GetBasicCurveComposite( IGeoObj* pGObj)
-               { return (dynamic_cast<CurveComposite*>(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 ;
+               }

CurveLine.cpp

@@ -18,7 +18,9 @@
 #include "GeoObjFactory.h"
 #include "NgeWriter.h"
 #include "NgeReader.h"
+#include "Voronoi.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
+#include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include <new>
 
@@ -29,15 +31,15 @@ GEOOBJ_REGISTER( CRV_LINE, NGE_C_LIN, CurveLine) ;
 
 //----------------------------------------------------------------------------
 CurveLine::CurveLine( void)
-   : m_nStatus( TO_VERIFY), m_PtStart(), m_PtEnd(), m_VtExtr(), m_dThick()
+   : 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_nTempProp[0] = 0 ;
-   m_nTempProp[0] = 0 ;
 }
 
 //----------------------------------------------------------------------------
 CurveLine::~CurveLine( void)
 {
+   ResetVoronoiObject() ;
 }
 
 //----------------------------------------------------------------------------
@@ -49,6 +51,8 @@ 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() ;
 
@@ -68,6 +72,8 @@ 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() ;
 
@@ -85,6 +91,8 @@ 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() ;
 
@@ -111,7 +119,7 @@ CurveLine::Clone( void) const
 bool
 CurveLine::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const CurveLine* pCL = dynamic_cast<const CurveLine*>( pGObjSrc) ;
+   const CurveLine* pCL = GetBasicCurveLine( pGObjSrc) ;
    if ( pCL == nullptr)
       return false ;
    return CopyFrom( *pCL) ;
@@ -127,6 +135,8 @@ CurveLine::CopyFrom( const CurveLine& clSrc)
    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] ;
    return Set( clSrc.m_PtStart, clSrc.m_PtEnd) ;
 }
 
@@ -259,7 +269,7 @@ bool
 CurveLine::Validate( void)
 {
    if ( m_nStatus == TO_VERIFY)
-      m_nStatus = ( ! AreSamePointApprox( m_PtStart, m_PtEnd) ? OK : ERR) ;
+      m_nStatus = ( m_PtStart.IsValid() && m_PtEnd.IsValid() && ! AreSamePointApprox( m_PtStart, m_PtEnd) ? OK : ERR) ;
 
    return ( m_nStatus == OK) ;
 }
@@ -356,10 +366,7 @@ CurveLine::GetPointD1D2( double dU, Side nS, Point3d& ptPos, Vector3d* pvtDer1,
       return false ;
 
   // il parametro U deve essere compreso tra 0 e 1
-   if ( dU < 0)
-      dU = 0 ;
-   else if ( dU > 1)
-      dU = 1 ;
+   dU = Clamp( dU, 0., 1.) ;
 
   // calcolo del punto
    ptPos = Media( m_PtStart, m_PtEnd, dU) ;
@@ -560,6 +567,8 @@ CurveLine::Invert( void)
   // inverto i punti estremi
    swap( m_PtStart, m_PtEnd) ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
   
@@ -591,6 +600,8 @@ 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() ;
 
@@ -611,6 +622,8 @@ CurveLine::ModifyStart( const Point3d& ptNewStart)
   // assegno il nuovo inizio
    m_PtStart = ptNewStart ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -631,6 +644,8 @@ CurveLine::ModifyEnd( const Point3d& ptNewEnd)
   // assegno la nuova fine
    m_PtEnd = ptNewEnd ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -642,7 +657,7 @@ bool
 CurveLine::TrimStartAtParam( double dUTrim)
 {
   // riporto i parametri nel loro range
-   dUTrim = ( ( dUTrim < 0) ? 0 : (( dUTrim > 1) ? 1 : dUTrim)) ;
+   dUTrim = Clamp( dUTrim, 0., 1.) ;
 
   // recupero lunghezza
    double dLen ;
@@ -658,7 +673,7 @@ bool
 CurveLine::TrimEndAtParam( double dUTrim)
 {
   // riporto i parametri nel loro range
-   dUTrim = ( ( dUTrim < 0) ? 0 : (( dUTrim > 1) ? 1 : dUTrim)) ;
+   dUTrim = Clamp( dUTrim, 0., 1.) ;
 
   // recupero lunghezza
    double dLen ;
@@ -706,6 +721,8 @@ 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() ;
 
@@ -730,6 +747,8 @@ 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() ;
 
@@ -752,6 +771,8 @@ 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() ;
 
@@ -774,6 +795,8 @@ 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() ;
 
@@ -787,6 +810,9 @@ CurveLine::Translate( const Vector3d& vtMove)
   // la curva deve essere validata
    if ( m_nStatus != OK)
       return false ;
+
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -808,6 +834,8 @@ CurveLine::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, do
    if ( vtAx.IsSmall())
       return false ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -839,6 +867,8 @@ 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() ;
 
@@ -868,6 +898,8 @@ CurveLine::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
    if ( vtNorm.IsSmall())
       return false ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -891,6 +923,8 @@ CurveLine::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& v
    if ( vtNorm.IsSmall()  ||  vtDir.IsSmall())
       return false ;
 
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -919,6 +953,12 @@ CurveLine::ToGlob( const Frame3d& frRef)
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
+  // se frame identità, non devo fare alcunché
+   if ( IsGlobFrame( frRef))
+      return true ;
+
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -937,6 +977,12 @@ CurveLine::ToLoc( const Frame3d& frRef)
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
+  // se frame identità, non devo fare alcunché
+   if ( IsGlobFrame( frRef))
+      return true ;
+
+  // imposto ricalcolo di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -954,10 +1000,13 @@ CurveLine::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 di Voronoi
+   ResetVoronoiObject() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
@@ -993,3 +1042,42 @@ 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,6 +19,8 @@
 #include "GeoObjRW.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
 
+class Voronoi ;
+
 //----------------------------------------------------------------------------
 class CurveLine : public ICurveLine, public IGeoObjRW
 {
@@ -54,6 +56,11 @@ class CurveLine : public ICurveLine, public IGeoObjRW
                    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) ; }
 
    public :                      // ICurve
       bool IsSimple( void) const override
@@ -143,39 +150,48 @@ class CurveLine : public ICurveLine, public IGeoObjRW
 
    public :
       CurveLine( void) ;
-      CurveLine( const CurveLine& clSrc)
+      CurveLine( const CurveLine& clSrc) : m_pVoronoiObj( nullptr)
                   { 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 ;
 
    private :
       bool CopyFrom( const CurveLine& clSrc) ;
-      bool Validate( void) ;
+      bool Validate( void) ;      
+      bool CalcVoronoiObject( void) const ;
+      void ResetVoronoiObject( void) const ;
 
    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
+      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
 } ;
 
 //-----------------------------------------------------------------------------
 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)
-               { return (dynamic_cast<const CurveLine*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_LINE)
+                    return nullptr ;
+                 return ( static_cast<const CurveLine*>( pGObj)) ; }
 inline CurveLine* GetBasicCurveLine( IGeoObj* pGObj)
-               { return (dynamic_cast<CurveLine*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_LINE)
+                    return nullptr ;
+                 return ( static_cast<CurveLine*>( pGObj)) ; }

DistLineLine.cpp

@@ -59,7 +59,7 @@ DistLineLine::DistLineLine( const Point3d& ptSt1, const Vector3d& vtD1, double d
 
 //----------------------------------------------------------------------------
 bool
-DistLineLine::GetSqDist( double& dSqDist)
+DistLineLine::GetSqDist( double& dSqDist) const
 {
    if ( m_dSqDist < 0)
       return false ;
@@ -70,7 +70,7 @@ DistLineLine::GetSqDist( double& dSqDist)
 
 //----------------------------------------------------------------------------
 bool
-DistLineLine::GetDist( double& dDist)
+DistLineLine::GetDist( double& dDist) const
 {
    if ( m_dSqDist < 0)
       return false ;
@@ -83,7 +83,7 @@ DistLineLine::GetDist( double& dDist)
 
 //----------------------------------------------------------------------------
 bool
-DistLineLine::GetMinDistPoints( Point3d& ptMinDist1, Point3d& ptMinDist2)
+DistLineLine::GetMinDistPoints( Point3d& ptMinDist1, Point3d& ptMinDist2) const
 {
    if ( m_dSqDist < 0)
       return false ;
@@ -94,7 +94,7 @@ DistLineLine::GetMinDistPoints( Point3d& ptMinDist1, Point3d& ptMinDist2)
 
 //----------------------------------------------------------------------------
 bool
-DistLineLine::GetPositionsAtMinDistPoints( double& dPos1, double& dPos2)
+DistLineLine::GetPositionsAtMinDistPoints( double& dPos1, double& dPos2) const
 {
    if ( m_dSqDist < 0)
       return false ;

DistLineLine.h

@@ -28,16 +28,16 @@ class DistLineLine
                     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 GetPositionsAtMinDistPoints( double& dPos1, double& dPos2) ;
+      bool GetSqDist( double& dSqDist) const ;
+      bool GetDist( double& dDist) const ;
+      bool IsEpsilon( double dTol) const
+              { double dSqDist ; return ( GetSqDist( dSqDist)  &&  ( dSqDist < SQ_EPS_ZERO  ||  dSqDist < dTol * dTol)) ; }
+      bool IsSmall( void) const
+              { return IsEpsilon( EPS_SMALL) ; }
+      bool IsZero( void) const
+              { return IsEpsilon( EPS_ZERO) ;  }
+      bool GetMinDistPoints( Point3d& ptMinDist1, Point3d& ptMinDist2) const ;
+      bool GetPositionsAtMinDistPoints( double& dPos1, double& dPos2) const ;
 
    private :
       void Calculate( const Point3d& ptSt1, const Vector3d& vtD1, double dLen1,
@@ -45,7 +45,7 @@ class DistLineLine
                       bool bIsSegment1, bool bIsSegment2) ;
    private:
       double  m_dSqDist ;
-      double  m_dDist ;
+      mutable double  m_dDist ;
       double  m_dPos1 ;
       double  m_dPos2 ;
       Point3d m_ptMinDist1 ;

DistPointArc.cpp

@@ -122,14 +122,13 @@ 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 ( Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
+   for ( auto Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
      // eseguo raffinamento
       if ( PolishMinDistPointCurve( ptP, arArc, *Iter, dPolishedPar, ptPolishedQ)) {
          (*Iter).dDist = Dist( ptP, ptPolishedQ) ;
@@ -148,7 +147,7 @@ DistPointArc::DistPointHelix( const Point3d& ptP, const ICurveArc& arArc)
 
 //----------------------------------------------------------------------------
 bool
-DistPointArc::GetSqDist( double& dSqDist)
+DistPointArc::GetSqDist( double& dSqDist) const
 {
    if ( m_dDist < 0)
       return false ;
@@ -159,7 +158,7 @@ DistPointArc::GetSqDist( double& dSqDist)
 
 //----------------------------------------------------------------------------
 bool
-DistPointArc::GetDist( double& dDist)
+DistPointArc::GetDist( double& dDist) const
 {
    if ( m_dDist < 0)
       return false ;
@@ -170,7 +169,7 @@ DistPointArc::GetDist( double& dDist)
 
 //----------------------------------------------------------------------------
 bool
-DistPointArc::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag)
+DistPointArc::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const
 {
    if ( m_dDist < 0)
       return false ;
@@ -185,7 +184,7 @@ DistPointArc::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag)
 
 //----------------------------------------------------------------------------
 bool
-DistPointArc::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag)
+DistPointArc::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const
 {
    if ( m_dDist < 0)
       return false ;

DistPointArc.h

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

DistPointCrvAux.cpp

@@ -156,13 +156,10 @@ 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 ( Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
+   for ( auto Iter = vApproxMin.cbegin() ; Iter != vApproxMin.cend() ; ++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,7 +44,6 @@ 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 ;
 
@@ -52,7 +51,7 @@ DistPointCrvBezier::DistPointCrvBezier( const Point3d& ptP, const ICurveBezier&
    double dSingP ;
    if ( CrvBez.GetSingularParam( dSingP) == 0)
       dSingP = - 1 ;
-   for ( Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
+   for ( auto 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 ; 
@@ -61,7 +60,7 @@ DistPointCrvBezier::DistPointCrvBezier( const Point3d& ptP, const ICurveBezier&
   // raffino i punti trovati
    double dPolishedPar ;
    Point3d ptPolishedQ ;
-   for ( Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
+   for ( auto Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
      // eseguo raffinamento
       if ( PolishMinDistPointCurve( ptP, CrvBez, *Iter, dPolishedPar, ptPolishedQ)) {
          (*Iter).dDist = Dist( ptP, ptPolishedQ) ;
@@ -80,7 +79,7 @@ DistPointCrvBezier::DistPointCrvBezier( const Point3d& ptP, const ICurveBezier&
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvBezier::GetSqDist( double& dSqDist)
+DistPointCrvBezier::GetSqDist( double& dSqDist) const
 {
    if ( m_dDist < 0)
       return false ;
@@ -91,7 +90,7 @@ DistPointCrvBezier::GetSqDist( double& dSqDist)
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvBezier::GetDist( double& dDist)
+DistPointCrvBezier::GetDist( double& dDist) const
 {
    if ( m_dDist < 0)
       return false ;
@@ -102,7 +101,7 @@ DistPointCrvBezier::GetDist( double& dDist)
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvBezier::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag)
+DistPointCrvBezier::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const
 {
    if ( m_dDist < 0)
       return false ;
@@ -117,7 +116,7 @@ DistPointCrvBezier::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag)
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvBezier::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag)
+DistPointCrvBezier::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const
 {
    if ( m_dDist < 0)
       return false ;

DistPointCrvBezier.h

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

DistPointCrvComposite.cpp

@@ -129,7 +129,7 @@ DistPointCrvComposite::DistPointCrvComposite( const Point3d& ptP, const ICurveCo
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvComposite::GetSqDist( double& dSqDist)
+DistPointCrvComposite::GetSqDist( double& dSqDist) const
 {
    if ( m_dDist < 0)
       return false ;
@@ -140,7 +140,7 @@ DistPointCrvComposite::GetSqDist( double& dSqDist)
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvComposite::GetDist( double& dDist)
+DistPointCrvComposite::GetDist( double& dDist) const
 {
    if ( m_dDist < 0)
       return false ;
@@ -151,7 +151,7 @@ DistPointCrvComposite::GetDist( double& dDist)
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvComposite::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag)
+DistPointCrvComposite::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const
 {
    if ( m_dDist < 0)
       return false ;
@@ -166,7 +166,7 @@ DistPointCrvComposite::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag
 
 //----------------------------------------------------------------------------
 bool
-DistPointCrvComposite::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag)
+DistPointCrvComposite::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const
 {
    if ( m_dDist < 0)
       return false ;

DistPointCrvComposite.h

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

DistPointCurve.cpp

@@ -98,7 +98,7 @@ DistPointCurve::CrvCompositeCalculate( const Point3d& ptP, const ICurve& Curve)
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetSqDist( double& dSqDist)
+DistPointCurve::GetSqDist( double& dSqDist) const
 {
    if ( m_dDist < 0)
       return false ;
@@ -109,7 +109,7 @@ DistPointCurve::GetSqDist( double& dSqDist)
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetDist( double& dDist)
+DistPointCurve::GetDist( double& dDist) const
 {
    if ( m_dDist < 0)
       return false ;
@@ -120,7 +120,7 @@ DistPointCurve::GetDist( double& dDist)
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag)
+DistPointCurve::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag) const
 {
    if ( m_dDist < 0  ||  nInd < 0  ||  nInd >= (int) m_Info.size())
       return false ;
@@ -132,7 +132,7 @@ DistPointCurve::GetMinDistPoint( int nInd, Point3d& ptMinDist, int& nFlag)
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetMinDistPoint( double dNearParam, Point3d& ptMinDist, int& nFlag)
+DistPointCurve::GetMinDistPoint( double dNearParam, Point3d& ptMinDist, int& nFlag) const
 {
    if ( m_dDist < 0  ||  m_Info.empty())
       return false ;
@@ -166,7 +166,7 @@ DistPointCurve::GetMinDistPoint( double dNearParam, Point3d& ptMinDist, int& nFl
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag)
+DistPointCurve::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag) const
 {
    if ( m_dDist < 0  ||  nInd < 0  ||  nInd >= (int) m_Info.size())
       return false ;
@@ -178,7 +178,7 @@ DistPointCurve::GetParamAtMinDistPoint( int nInd, double& dParam, int& nFlag)
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetParamAtMinDistPoint( double dNearParam, double& dParam, int& nFlag)
+DistPointCurve::GetParamAtMinDistPoint( double dNearParam, double& dParam, int& nFlag) const
 {
    if ( m_dDist < 0  ||  m_Info.empty())
       return false ;
@@ -209,7 +209,7 @@ DistPointCurve::GetParamAtMinDistPoint( double dNearParam, double& dParam, int&
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide)
+DistPointCurve::GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide) const
 {
    if ( m_dDist < 0  ||  nInd < 0  ||  nInd >= (int) m_Info.size())
       return false ;
@@ -257,7 +257,7 @@ DistPointCurve::GetSideAtMinDistPoint( int nInd, const Vector3d& vtN, int& nSide
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide)
+DistPointCurve::GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, int& nSide) const
 {
    if ( m_dDist < 0  ||  m_Info.empty())
       return false ;
@@ -278,7 +278,7 @@ DistPointCurve::GetSideAtMinDistPoint( double dNearParam, const Vector3d& vtN, i
 
 //----------------------------------------------------------------------------
 bool
-DistPointCurve::GetMinDistInfo( int nInd, MinDistPCInfo& aInfo)
+DistPointCurve::GetMinDistInfo( int nInd, MinDistPCInfo& aInfo) const
 {
    if ( m_dDist < 0  ||  nInd < 0  ||  nInd >= (int) m_Info.size())
       return false ;

DistPointLine.cpp

@@ -95,7 +95,7 @@ DistPointLine::Calculate( const Point3d& ptP,
 
 //----------------------------------------------------------------------------
 bool
-DistPointLine::GetSqDist( double& dSqDist)
+DistPointLine::GetSqDist( double& dSqDist) const
 {
    if ( m_dSqDist < 0)
       return false ;
@@ -106,7 +106,7 @@ DistPointLine::GetSqDist( double& dSqDist)
 
 //----------------------------------------------------------------------------
 bool
-DistPointLine::GetDist( double& dDist)
+DistPointLine::GetDist( double& dDist) const
 {
    if ( m_dSqDist < 0)
       return false ;
@@ -119,7 +119,7 @@ DistPointLine::GetDist( double& dDist)
 
 //----------------------------------------------------------------------------
 bool
-DistPointLine::GetMinDistPoint( Point3d& ptMinDist)
+DistPointLine::GetMinDistPoint( Point3d& ptMinDist) const
 {
    if ( m_dSqDist < 0)
       return false ;
@@ -130,7 +130,7 @@ DistPointLine::GetMinDistPoint( Point3d& ptMinDist)
 
 //----------------------------------------------------------------------------
 bool
-DistPointLine::GetParamAtMinDistPoint( double& dParam)
+DistPointLine::GetParamAtMinDistPoint( double& dParam) const
 {
    if ( m_dSqDist < 0)
       return false ;

DistPointLine.h

@@ -31,18 +31,18 @@ class DistPointLine
                      const Point3d& ptIni, const Vector3d& vtDir, double dLen, bool bIsSegment = true) ;
 
    public :
-      bool GetSqDist( double& dSqDist) ;
-      bool GetDist( double& dDist) ;
-      bool IsEpsilon( double dTol)
+      bool GetSqDist( double& dSqDist) const ;
+      bool GetDist( double& dDist) const ;
+      bool IsEpsilon( double dTol) const
               { double dSqDist ; return ( GetSqDist( dSqDist) && ( dSqDist < SQ_EPS_ZERO || dSqDist < dTol * dTol)) ; }
-      bool IsSmall( void)
+      bool IsSmall( void) const
               { return IsEpsilon( EPS_SMALL) ; }
-      bool IsZero( void)
+      bool IsZero( void) const
               { return IsEpsilon( EPS_ZERO) ; }
-      int  GetNbrMinDist( void)
+      int  GetNbrMinDist( void) const
               { return (( m_dSqDist < 0) ? 0 : 1) ; }
-      bool GetMinDistPoint( Point3d& ptMinDist) ;
-      bool GetParamAtMinDistPoint( double& dParam) ;
+      bool GetMinDistPoint( Point3d& ptMinDist) const ;
+      bool GetParamAtMinDistPoint( double& dParam) const ;
 
    private :
       DistPointLine( void) ;
@@ -51,7 +51,7 @@ class DistPointLine
 
    private :
       double  m_dSqDist ;
-      double  m_dDist ;
+      mutable double  m_dDist ;
       double  m_dParam ;
       Point3d m_ptMinDist ;
 } ;

DistPointSurfTm.cpp

@@ -12,6 +12,7 @@
 //----------------------------------------------------------------------------
 
 #include "stdafx.h"
+#include "SurfTriMesh.h"
 #include "/EgtDev/Include/EGkDistPointTria.h"
 #include "/EgtDev/Include/EGkDistPointSurfTm.h"
 
@@ -24,7 +25,7 @@ using namespace std ;
 // 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.
-bool 
+static bool 
 BoundingBoxDifference( const BBox3d& boxA, const BBox3d& boxB, BOXVECTOR& vBoxDiff) 
 {
   // Svuoto il risultato
@@ -93,30 +94,33 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
   // Inizializzo distanza non calcolata
    m_dDist = - 1. ;
 
+  // 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 = tmSurf.GetAllTriaBox() ;
+   BBox3d b3Stm = pStm->GetAllTriaBox() ;
    if ( b3Stm.IsEmpty())
       return ;
 
-  // 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.
+  // 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( ptMax.x - ptMin.x, ptMax.y - ptMin.y), ptMax.z - ptMin.z) / 40., 10.) ;
+   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 lo spazio differenza tra i due
+  // 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, indice del triangolo di distanza minima, punto di distanza minima 
    double dMinSqDist = DBL_MAX ;
    int nMinDistTriaIndex = SVT_NULL ;
    Point3d ptMinDistPoint ;
-   bool bContinue = true ;
   // 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
       BOXVECTOR vBox ;
@@ -131,18 +135,21 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
         // ricerca sui triangoli nel box
          bCollide = true ;
          INTVECTOR vnIds ; 
-         if ( tmSurf.GetAllTriaOverlapBox( b3Int, vnIds)) { 
+         if ( pStm->GetAllTriaOverlapBox( b3Int, vnIds)) { 
            // Ciclo sui triangoli del sotto-box corrente
             for ( auto nT : vnIds) {
+               int nTriaTemp ;
                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) ;
+               if ( pStm->GetTempInt( nT, nTriaTemp)  &&  nTriaTemp == 0  &&  pStm->GetTriangle( nT, trCurTria)) {
+                  pStm->SetTempInt( nT, 1) ;
+                  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) ;
+                  }
                }
             }
          }
@@ -161,15 +168,15 @@ DistPointSurfTm::Calculate( const Point3d& ptP, const ISurfTriMesh& tmSurf)
       m_nMinDistTriaIndex = nMinDistTriaIndex ;
       m_ptMinDistPoint = ptMinDistPoint ;
       Triangle3d trMinDistTria ;
-      tmSurf.GetTriangle( m_nMinDistTriaIndex, trMinDistTria) ;
+      pStm->GetTriangle( m_nMinDistTriaIndex, trMinDistTria) ;
       trMinDistTria.Validate() ;
-      m_bIsInside = ( ( ptP - m_ptMinDistPoint) * trMinDistTria.GetN() < - EPS_SMALL)  &&  tmSurf.IsClosed() ;
+      m_bIsInside = ( ( ptP - m_ptMinDistPoint) * trMinDistTria.GetN() < - EPS_SMALL)  &&  pStm->IsClosed() ;
    }
 }
 
 //----------------------------------------------------------------------------
 bool
-DistPointSurfTm::GetDist( double& dDist)
+DistPointSurfTm::GetDist( double& dDist) const
 {
   // Distanza non valida
    if ( m_dDist < -EPS_ZERO)
@@ -181,7 +188,7 @@ DistPointSurfTm::GetDist( double& dDist)
 
 //----------------------------------------------------------------------------
 bool 
-DistPointSurfTm::GetMinDistPoint( Point3d& ptMinDistPoint)
+DistPointSurfTm::GetMinDistPoint( Point3d& ptMinDistPoint) const
 {
   // Distanza non valida
    if ( m_dDist < -EPS_ZERO)
@@ -193,7 +200,7 @@ DistPointSurfTm::GetMinDistPoint( Point3d& ptMinDistPoint)
 
 //----------------------------------------------------------------------------
 bool
-DistPointSurfTm::GetMinDistTriaIndex( int& nMinDistIndex)
+DistPointSurfTm::GetMinDistTriaIndex( int& nMinDistIndex) const
 {
   // Distanza non valida
    if ( m_dDist < -EPS_ZERO)
@@ -202,3 +209,80 @@ DistPointSurfTm::GetMinDistTriaIndex( int& nMinDistIndex)
    nMinDistIndex = m_nMinDistTriaIndex ;
    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
+      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.SqDistFromPoint( ptP) > dMinSqDist)
+            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 ;
+               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] ;
+                     }
+                  }
+               }
+            }
+         }
+      }
+     // Se si verifica la condizione di terminazione arresto il ciclo altrimenti aggiorno i box 
+      if ( ! bCollide  ||  dMinSqDist < EPS_SMALL * EPS_SMALL)
+         bContinue = false ;
+      else {
+        boxPPrev = boxP ;
+        boxP.Expand( dDeltaLen) ;
+      }
+   }
+
+   return nVert ;
+}

EgtGeomKernel.vcxproj

@@ -22,7 +22,7 @@
     <ProjectGuid>{9A98A202-2853-454A-84CA-DCD1714176C9}</ProjectGuid>
     <RootNamespace>EgtGeomKernel</RootNamespace>
     <Keyword>MFCDLLProj</Keyword>
-    <WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0.20348.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
@@ -116,6 +116,7 @@
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <EnablePREfast>false</EnablePREfast>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -198,6 +199,7 @@ copy $(TargetPath) \EgtProg\DllD64</Command>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <WholeProgramOptimization>false</WholeProgramOptimization>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -236,7 +238,7 @@ copy $(TargetPath) \EgtProg\Dll32</Command>
       <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
       <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
       <OmitFramePointers>true</OmitFramePointers>
       <FloatingPointModel>Precise</FloatingPointModel>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
@@ -278,6 +280,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="Attribs.cpp" />
     <ClCompile Include="BBox3d.cpp" />
     <ClCompile Include="BiArcs.cpp" />
+    <ClCompile Include="CalcPocketing.cpp" />
     <ClCompile Include="CAvSimpleSurfFrMove.cpp" />
     <ClCompile Include="CAvToolSurfTm.cpp" />
     <ClCompile Include="CAvToolTriangle.cpp" />
@@ -306,12 +309,28 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="CurveByApprox.cpp" />
     <ClCompile Include="CurveByInterp.cpp" />
     <ClCompile Include="CurveCompositeOffset.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="PolygonElevation.cpp" />
+    <ClCompile Include="RotationMinimizeFrame.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\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\EGkSubtractProjectedFacesOnStmFace.h" />
     <ClInclude Include="CDeBoxTria.h" />
     <ClInclude Include="CDeCapsTria.h" />
     <ClInclude Include="CDeConeFrustumTria.h" />
@@ -329,6 +348,9 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <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" />
@@ -337,6 +359,8 @@ 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" />
@@ -392,9 +416,12 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="OffsetCurveOnX.cpp" />
     <ClCompile Include="Polygon3d.cpp" />
     <ClCompile Include="AdjustLoops.cpp" />
+    <ClCompile Include="ProjectCurveSurfTm.cpp" />
     <ClCompile Include="RemoveCurveDefects.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" />
@@ -434,6 +461,8 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="VolZmapGraphics.cpp" />
     <ClCompile Include="VolZmapVolume.cpp" />
     <ClCompile Include="VolZmap.cpp" />
+    <ClInclude Include="RotationMinimizeFrame.h" />
+    <ClInclude Include="Voronoi.h" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\Include\EGkAngle.h" />
@@ -597,10 +626,15 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <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" />
@@ -611,6 +645,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="FontOs.h" />
     <ClInclude Include="AdjustLoops.h" />
     <ClInclude Include="RemoveCurveDefects.h" />
+    <ClInclude Include="SurfAux.h" />
     <ClInclude Include="SurfBezier.h" />
     <ClInclude Include="SurfFlatRegion.h" />
     <ClInclude Include="TextureData.h" />

EgtGeomKernel.vcxproj.filters

@@ -43,7 +43,16 @@
     <Filter Include="File di origine\GeoOffset">
       <UniqueIdentifier>{f07670fd-9429-4b7e-ac6d-1c0022e756fb}</UniqueIdentifier>
     </Filter>
-    <Filter Include="File di origine\GeoCollision">
+    <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">
       <UniqueIdentifier>{865b76ee-b10d-41fc-861c-b48ce52fa277}</UniqueIdentifier>
     </Filter>
   </ItemGroup>
@@ -366,17 +375,8 @@
     <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\GeoCollision</Filter>
-    </ClCompile>
-    <ClCompile Include="CAvSimpleSurfFrMove.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="IntersSurfTmSurfTm.cpp">
       <Filter>File di origine\GeoInters</Filter>
@@ -394,19 +394,19 @@
       <Filter>File di origine\Geo</Filter>
     </ClCompile>
     <ClCompile Include="CDeCylTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeBoxClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeCylClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeSpheTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeSpheClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="SurfBezier.cpp">
       <Filter>File di origine\Geo</Filter>
@@ -424,34 +424,34 @@
       <Filter>File di origine\GeoDist</Filter>
     </ClCompile>
     <ClCompile Include="CDeTriaTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeConeTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeUtility.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeClosedSurfTmClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeConeFrustumClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeConeFrustumTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeConvexTorusClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeConvexTorusTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeRectPrismoidClosedSurfTm.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="CDeRectPrismoidTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="SurfTriMeshUtilities.cpp">
       <Filter>File di origine\Geo</Filter>
@@ -463,7 +463,7 @@
       <Filter>File di origine\Base</Filter>
     </ClCompile>
     <ClCompile Include="CDeCapsTria.cpp">
-      <Filter>File di origine\GeoCollision</Filter>
+      <Filter>File di origine\GeoCollisionDetection</Filter>
     </ClCompile>
     <ClCompile Include="Circle2P.cpp">
       <Filter>File di origine\GeoCreate</Filter>
@@ -471,6 +471,60 @@
     <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="ProjectCurveSurfTm.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="RotationMinimizeFrame.cpp">
+      <Filter>File di origine\Geo</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="stdafx.h">
@@ -1103,6 +1157,45 @@
     <ClInclude Include="CDeCapsTria.h">
       <Filter>File di intestazione</Filter>
     </ClInclude>
+    <ClInclude Include="Tree.h">
+      <Filter>File di intestazione</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="RotationMinimizeFrame.h">
+      <Filter>File di intestazione</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtGeomKernel.rc">

ExtDimension.h

@@ -55,6 +55,11 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
                    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) ; }
 
    public :                      // IExtDimension
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -62,6 +67,12 @@ 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& ptP1, const Point3d& ptV, 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
@@ -119,6 +130,7 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
       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 ;
@@ -133,13 +145,14 @@ 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
+      Point3d             m_ptP6 ;          // sesto punto; nel caso delle quotature angolari � il centro
       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
@@ -149,5 +162,22 @@ 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 
+      int                 m_nTempProp[2] ;  // vettore propriet� temporanee
+      double              m_dTempParam[2] ; // vettore parametri temporanei
 } ;
+
+//-----------------------------------------------------------------------------
+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,10 +35,9 @@ 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_nTempProp[1] = 0 ;
+     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}
+{    
 }
 
 //----------------------------------------------------------------------------
@@ -161,7 +160,7 @@ ExtText::Clone( void) const
 bool
 ExtText::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const ExtText* pTxt = dynamic_cast<const ExtText*>( pGObjSrc) ;
+   const ExtText* pTxt = GetBasicExtText( pGObjSrc) ;
    if ( pTxt == nullptr)
       return false ;
    return CopyFrom( *pTxt) ;
@@ -188,6 +187,8 @@ ExtText::CopyFrom( const ExtText& clSrc)
    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] ;
    return true ;
 }
 
@@ -399,8 +400,11 @@ 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 ;
 }
@@ -409,8 +413,15 @@ 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)) ;
@@ -532,9 +543,18 @@ 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)  &&
@@ -545,9 +565,18 @@ 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)  &&
@@ -561,12 +590,15 @@ 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)  &&
@@ -852,7 +884,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<ISurfTriMesh> pStm( GetBasicSurfFlatRegion( pSfr)->CalcAuxSurf( LIN_TOL_STD, ANG_TOL_STD_DEG)) ;
+      PtrOwner<SurfTriMesh> pStm( GetBasicSurfFlatRegion( pSfr)->CalcAuxSurf( LIN_TOL_STD, ANG_TOL_STD_DEG)) ;
       if ( pStm != nullptr) {
          Triangle3d Tria ;
          int nT = pStm->GetFirstTriangle( Tria) ;

ExtText.h

@@ -55,6 +55,11 @@ class ExtText : public IExtText, public IGeoObjRW
                    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) ; }
 
    public :                      // IExtText
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -144,5 +149,22 @@ 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 
+      int            m_nTempProp[2] ;  // vettore proprietà temporanee
+      double         m_dTempParam[2] ; // vettore parametri temporanei
 } ;
+
+//-----------------------------------------------------------------------------
+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)) ; }

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,21 +81,19 @@ 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)
-      PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGDB)) ;
-      if ( IsNull( pIter))
+      GdbIterator iIter( m_pGDB) ;
+      if ( ! iIter.GoTo( 1))
          return false ;
-      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))
+      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))
          return false ;
       if ( m_dH < EPS_SMALL  ||  m_dHCap < EPS_SMALL  ||  m_dHx < EPS_SMALL)
          return false ;
-      if ( ! pIter->GetInfo( NFE_ITALIC, m_dItalicShearCoeff))
+      if ( ! iIter.GetInfo( NFE_ITALIC, m_dItalicShearCoeff))
          m_dItalicShearCoeff = NFE_ITALIC_STD_SHEAR_COEFF ;
      // aggiorno la path del font
       m_sFont = sFontUp ;
@@ -161,11 +159,6 @@ 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 ;
@@ -229,9 +222,7 @@ NfeFont::GetOutline( const string& sText, int nInsPos, ICURVEPLIST& lstPC) const
       return false ;
 
   // creo un iteratore
-   PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGDB)) ;
-   if ( IsNull( pIter))
-      return false ;
+   GdbIterator iIter( m_pGDB) ;
 
   // calcolo i fattori di scala
    double dScaY = m_dHeight / m_dHCap ;
@@ -265,9 +256,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 = pIter->GoToFirstInGroup( nGroup) ;
+      bool bIter = iIter.GoToFirstInGroup( nGroup) ;
       while ( bIter) {
-         const ICurve* pCrv = GetCurve( pIter->GetGeoObj()) ;
+         const ICurve* pCrv = GetCurve( iIter.GetGeoObj()) ;
          if ( pCrv != nullptr) {
            // copio la curva (trasformando eventuali archi in CurveBezier)
             ICurve* pCrvNew = CurveToNoArcsCurve( pCrv) ;
@@ -281,7 +272,7 @@ NfeFont::GetOutline( const string& sText, int nInsPos, ICURVEPLIST& lstPC) const
            // inserisco in lista la nuova curva
             lstPC.push_back( pCrvNew) ;
          }
-         bIter = pIter->GoToNext() ;
+         bIter = iIter.GoToNext() ;
       }
      // recupero lo spostamento per il prossimo carattere
       double dAdvance ;
@@ -314,9 +305,7 @@ NfeFont::ApproxWithLines( const string& sText, int nInsPos, double dLinTol, doub
       return false ;
 
   // creo un iteratore
-   PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGDB)) ;
-   if ( IsNull( pIter))
-      return false ;
+   GdbIterator iIter( m_pGDB) ;
 
   // controllo valore tolleranza lineare
    if ( dLinTol > FNT_MAX_LINTOL_TO_H * m_dHeight)
@@ -354,9 +343,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 = pIter->GoToFirstInGroup( nGroup) ;
+      bool bIter = iIter.GoToFirstInGroup( nGroup) ;
       while ( bIter) {
-         const ICurve* pCrv = GetCurve( pIter->GetGeoObj()) ;
+         const ICurve* pCrv = GetCurve( iIter.GetGeoObj()) ;
          if ( pCrv != nullptr) {
            // copia temporanea della curva (trasformando eventuali archi in CurveBezier)
             PtrOwner<ICurve> pCrvNew( CurveToNoArcsCurve( pCrv)) ;
@@ -371,7 +360,7 @@ NfeFont::ApproxWithLines( const string& sText, int nInsPos, double dLinTol, doub
             lstPL.emplace_back() ;
             pCrvNew->ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, lstPL.back()) ;
          }
-         bIter = pIter->GoToNext() ;
+         bIter = iIter.GoToNext() ;
       }
      // recupero lo spostamento per il prossimo carattere
       double dAdvance ;
@@ -400,9 +389,7 @@ NfeFont::ApproxWithArcs( const string& sText, int nInsPos, double dLinTol, doubl
       return false ;
 
   // creo un iteratore
-   PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGDB)) ;
-   if ( IsNull( pIter))
-      return false ;
+   GdbIterator iIter(  m_pGDB) ;
 
   // controllo valore tolleranza lineare
    if ( dLinTol > FNT_MAX_LINTOL_TO_H * m_dHeight)
@@ -440,9 +427,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 = pIter->GoToFirstInGroup( nGroup) ;
+      bool bIter = iIter.GoToFirstInGroup( nGroup) ;
       while ( bIter) {
-         const ICurve* pCrv = GetCurve( pIter->GetGeoObj()) ;
+         const ICurve* pCrv = GetCurve( iIter.GetGeoObj()) ;
          if ( pCrv != nullptr) {
            // copia temporanea della curva (trasformando eventuali archi in CurveBezier)
             PtrOwner<ICurve> pCrvNew( CurveToNoArcsCurve( pCrv)) ;
@@ -457,7 +444,7 @@ NfeFont::ApproxWithArcs( const string& sText, int nInsPos, double dLinTol, doubl
             lstPA.emplace_back() ;
             pCrv->ApproxWithArcs( dLinTol, dAngTolDeg, lstPA.back()) ;
          }
-         bIter = pIter->GoToNext() ;
+         bIter = iIter.GoToNext() ;
       }
      // recupero lo spostamento per il prossimo carattere
       double dAdvance ;
@@ -484,11 +471,6 @@ 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 ;

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,8 +298,7 @@ OsFont::GetOutline( const string& sText, int nInsPos, ICURVEPLIST& lstPC) const
       if ( ! GetCharOutline( vCode[i], dAdvance, lstTmpPC))
          return false ;
      // lo trasformo opportunamente
-      ICURVEPLIST::iterator iIter ;
-      for ( iIter = lstTmpPC.begin() ; iIter != lstTmpPC.end() ; ++ iIter) {
+      for ( auto iIter = lstTmpPC.begin() ; iIter != lstTmpPC.end() ; ++ iIter) {
         // trasformazioni
          (*iIter)->Scale( GLOB_FRM, dScaX, dScaY, dScaZ) ;  
          (*iIter)->Translate( vtMove) ;
@@ -464,8 +463,7 @@ OsFont::ApproxWithLines( const string& sText, int nInsPos, double dLinTol, doubl
       if ( ! GetCharOutline( vCode[i], dAdvance, lstPC))
          return false ;
      // lo approssimo con segmenti di retta
-      ICURVEPLIST::iterator iIter ;
-      for ( iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter) {
+      for ( auto iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter) {
         // trasformazioni
          (*iIter)->Scale( GLOB_FRM, dScaX, dScaY, dScaZ) ;  
          (*iIter)->Translate( vtMove) ;
@@ -478,7 +476,7 @@ OsFont::ApproxWithLines( const string& sText, int nInsPos, double dLinTol, doubl
       if ( vtMove.x > dMaxW)
          dMaxW = vtMove.x ;
      // ciclo di pulizia
-      for ( iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter)
+      for ( auto iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter)
          delete (*iIter) ;
       lstPC.clear() ;
    }
@@ -549,8 +547,7 @@ 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
-      ICURVEPLIST::iterator iIter ;
-      for ( iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter) {
+      for ( auto iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter) {
         // trasformazioni
          (*iIter)->Scale( GLOB_FRM, dScaX, dScaY, dScaZ) ;
          (*iIter)->Translate( vtMove) ;
@@ -563,7 +560,7 @@ OsFont::ApproxWithArcs( const string& sText, int nInsPos, double dLinTol, double
       if ( vtMove.x > dMaxW)
          dMaxW = vtMove.x ;
      // ciclo di pulizia
-      for ( iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter)
+      for ( auto iIter = lstPC.begin() ; iIter != lstPC.end() ; ++ iIter)
          delete (*iIter) ;
       lstPC.clear() ;
    }
@@ -730,7 +727,7 @@ OsFont::GetCharOutline( unsigned int nChar, double& dAdvance, ICURVEPLIST& lstPC
       if ( pHeader->dwType == TT_POLYGON_TYPE) {
 
         // creo curva composita
-         PtrOwner<ICurveComposite> pCCompo( CreateCurveComposite()) ;
+         PtrOwner<CurveComposite> pCCompo( CreateBasicCurveComposite()) ;
          if ( IsNull( pCCompo))
             return false ;
 
@@ -823,7 +820,7 @@ OsFont::AddLineToCompo( ICurveComposite* pCCompo, const Point3d& ptStart, const
       return false ;
 
   // creo retta, la imposto e la inserisco nella curva composita
-   PtrOwner<ICurveLine> pCLine( CreateCurveLine()) ;
+   PtrOwner<CurveLine> pCLine( CreateBasicCurveLine()) ;
    if ( IsNull( pCLine))
       return false ;
    if ( ! pCLine->Set( ptStart, ptEnd))
@@ -844,7 +841,7 @@ OsFont::AddCBezierQuadToCompo( ICurveComposite* pCCompo,
       return false ;
 
   // creo curva di Bezier quadratica, la imposto e la inserisco nella curva composita
-   PtrOwner<ICurveBezier> pCBezier( CreateCurveBezier()) ;
+   PtrOwner<CurveBezier> pCBezier( CreateBasicCurveBezier()) ;
    if ( IsNull( pCBezier))
       return false ;
    if ( ! pCBezier->Init( 2, false)  ||

Frame3d.cpp

@@ -456,6 +456,9 @@ 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.cpp

@@ -1423,8 +1423,7 @@ GdbExecutor::CurveArcChangeRadius( const STRVECTOR& vsParams)
    if ( ! GetLengthParam( vsParams[1], dNewRad))
       return false ;
   // esecuzione
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
      // recupero l'arco
       ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( *Iter)) ; 
       if ( pCrvArc == nullptr)
@@ -1452,8 +1451,7 @@ GdbExecutor::CurveArcChangeDeltaN( const STRVECTOR& vsParams)
    if ( ! GetLengthParam( vsParams[1], dNewDeltaN))
       return false ;
   // esecuzione
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
      // recupero l'arco
       ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( *Iter)) ; 
       if ( pCrvArc == nullptr)
@@ -1686,8 +1684,7 @@ GdbExecutor::CurveCompoMake( const STRVECTOR& vsParams)
    if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest))
       return false ;
   // esecuzione
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
      // recupero la curva
       int nIdCrv = *Iter ;
       const ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ; 
@@ -1722,7 +1719,7 @@ GdbExecutor::CurveCompoMake( const STRVECTOR& vsParams)
    if ( AddGeoObj( vsParams[0], vsParams[1], Release( pCrvCompo))) {
      // se richiesto, cancello le curve originali
       if ( bErase) {
-         for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+         for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
             if ( ! m_pGDB->Erase( *Iter))
                return false ;
          }
@@ -2309,8 +2306,7 @@ GdbExecutor::SurfTriMeshByTriangleSoup( const STRVECTOR& vsParams)
    if ( ! StmFts.Start())
       return false ;
   // Recupero tutti i triangoli delle superfici sorgenti e li inserisco nella nuova
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
      // recupero la superficie sorgente
       const ISurfTriMesh* pStmS = GetSurfTriMesh( m_pGDB->GetGeoObj( *Iter)) ;
       if ( pStmS == nullptr)
@@ -2340,7 +2336,7 @@ GdbExecutor::SurfTriMeshByTriangleSoup( const STRVECTOR& vsParams)
    if ( AddGeoObj( vsParams[0], vsParams[1], pSTM)) {
      // se richiesto, cancello le curve originali
       if ( bErase) {
-         for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+         for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
             if ( ! m_pGDB->Erase( *Iter))
                return false ;
          }
@@ -2534,8 +2530,7 @@ GdbExecutor::SurfTriMeshDoCompacting( const STRVECTOR& vsParams)
    if ( ! GetNamesParam( vsParams[0], vnNames))
       return false ;
   // opero sui diversi oggetti
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
      // recupero la superficie
       ISurfTriMesh* pStm = GetSurfTriMesh( m_pGDB->GetGeoObj( *Iter)) ;
       if ( pStm == nullptr)
@@ -2572,8 +2567,7 @@ GdbExecutor::SurfTriMeshDoSewing( const STRVECTOR& vsParams)
    if ( ! GetNamesParam( vsParams[1], vnNames))
       return false ;
   // esecuzione
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
      // recupero la superficie da cucire
       const ISurfTriMesh* pStmS = GetSurfTriMesh( m_pGDB->GetGeoObj( *Iter)) ;
       if ( pStmS == nullptr)
@@ -2590,7 +2584,7 @@ GdbExecutor::SurfTriMeshDoSewing( const STRVECTOR& vsParams)
    }
   // se richiesto, cancello le superfici cucite alla prima
    if ( bErase) {
-      for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter)
+      for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter)
          m_pGDB->Erase( *Iter) ;
    }
    return true ;
@@ -3079,7 +3073,7 @@ GdbExecutor::VolZmapBBoxZmapIntersection( const STRVECTOR& vsParams)
       return false ;
    bool bInt ;
 
-   bInt = ! pZmap->AvoidBox( frBBoxFrame, ptEnd - ORIG) ; 
+   bInt = pZmap->CDeBox( frBBoxFrame, ptEnd - ORIG) ; 
 
    return true ;
 }*/
@@ -5432,8 +5426,7 @@ GdbExecutor::TextOutline( const STRVECTOR& vsParams)
    pTXT->GetOutline( lstPCRV) ;
   // inserisco le curve nel gruppo destinazione dopo aver sistemato il cambio di riferimento
    bool bOk = true ;
-   ICURVEPLIST::iterator iIter ;
-   for ( iIter = lstPCRV.begin() ; iIter != lstPCRV.end() ; ++ iIter) {
+   for ( auto iIter = lstPCRV.begin() ; iIter != lstPCRV.end() ; ++ iIter) {
       (*iIter)->LocToLoc( frTXT, frDest) ;
       if ( m_pGDB->AddGeoObj( GDB_ID_NULL, nIdDest, (*iIter)) == GDB_ID_NULL) {
          delete (*iIter) ;
@@ -5510,8 +5503,7 @@ GdbExecutor::GetNamesParam( const string& sParam, INTVECTOR& vnNames)
   // converto in interi
    vnNames.clear() ;
    vnNames.reserve( vsNames.size()) ;
-   STRVECTOR::iterator Iter ;
-   for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
+   for ( auto Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) {
       Trim( (*Iter), " \t\r\n()") ;
       int nId = GetIdParam( *Iter) ;
       if ( nId != GDB_ID_SEL) {
@@ -5538,8 +5530,7 @@ GdbExecutor::GetVectorParam( const string& sParam, const Frame3d& frVect, Vector
      // divido in parti
       STRVECTOR vsParams ;
       Tokenize( sParam, ",", vsParams) ;
-      STRVECTOR::iterator Iter ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+      for ( auto Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
          Trim( (*Iter), " \t\r\n()") ;
      // se 2 parti, allora Z = 0
       if ( vsParams.size() == 2) {
@@ -5594,8 +5585,7 @@ GdbExecutor::GetVectorParam( const string& sParam, const Frame3d& frVect, Vector
      // recupero i parametri associati
       STRVECTOR vsParams ;
       Tokenize( sParam.substr( 3, sParam.length()-4), ",", "(", ")", vsParams) ;
-      STRVECTOR::iterator Iter ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+      for ( auto Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
          Trim( (*Iter), " \t\r\n") ;
      // ci deve essere almeno un parametro
       if ( vsParams.size() < 1)
@@ -5747,8 +5737,7 @@ GdbExecutor::GetPointParam( const string& sParam, const Frame3d& frPnt, Point3d&
      // divido in parti
       STRVECTOR vsParams ;
       Tokenize( sParam, ",", vsParams) ;
-      STRVECTOR::iterator Iter ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+      for ( auto Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
          Trim( (*Iter), " \t\r\n()") ;
      // se 2 parti, allora Z = 0
       if ( vsParams.size() == 2) {
@@ -5778,8 +5767,7 @@ GdbExecutor::GetPointParam( const string& sParam, const Frame3d& frPnt, Point3d&
      // recupero i parametri associati
       STRVECTOR vsParams ;
       Tokenize( sParam.substr( 3, sParam.length()-4), ",", "(", ")", vsParams) ;
-      STRVECTOR::iterator Iter ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+      for ( auto Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
          Trim( (*Iter), " \t\r\n") ;
      // ci deve essere almeno un parametro
       if ( vsParams.size() < 1)
@@ -5962,8 +5950,7 @@ GdbExecutor::GetPointsParam( const string& sParam, const Frame3d& frPnt, PolyLin
    Tokenize( sParam.substr( 1, sParam.length()-2), ",", "(", ")", vsPoints) ;
   // converto in punti
    PL.Clear() ;
-   STRVECTOR::iterator Iter ;
-   for ( Iter = vsPoints.begin() ; Iter != vsPoints.end() ; ++Iter) {
+   for ( auto Iter = vsPoints.begin() ; Iter != vsPoints.end() ; ++Iter) {
       Trim( (*Iter), " \t\r\n") ;
       if ( GetIdParam( *Iter) == GDB_ID_SEL) {
          int nId = m_pGDB->GetFirstSelectedObj() ;
@@ -5997,8 +5984,7 @@ GdbExecutor::GetPointWParam( const string& sParam, const Frame3d& frPnt, Point3d
   // divido in parti
    STRVECTOR vsParams ;
    Tokenize( sParam.substr( 1, sParam.length()-2), ",", "(", ")", vsParams) ;
-   STRVECTOR::iterator Iter ;
-   for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+   for ( auto Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
       Trim( (*Iter), " \t\r\n") ;
 
   // se 4 parti, sono 3 coordinate e un peso
@@ -6037,8 +6023,7 @@ GdbExecutor::GetPointWsParam( const string& sParam, const Frame3d& frPnt, PolyAr
    Tokenize( sParam.substr( 1, sParam.length()-2), ",", "(", ")", vsPointWs) ;
   // converto in punti
    PA.Clear() ;
-   STRVECTOR::iterator Iter ;
-   for ( Iter = vsPointWs.begin() ; Iter != vsPointWs.end() ; ++Iter) {
+   for ( auto Iter = vsPointWs.begin() ; Iter != vsPointWs.end() ; ++Iter) {
       Trim( (*Iter), " \t\r\n") ;
       Point3d ptP ;
       double  dBulge ;
@@ -6059,8 +6044,7 @@ GdbExecutor::GetLengthParam( const string& sParam, double& dLen)
      // recupero i parametri associati
       STRVECTOR vsParams ;
       Tokenize( sParam.substr( 1), ",", vsParams) ;
-      STRVECTOR::iterator Iter ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+      for ( auto Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
          Trim( (*Iter), " \t\r\n()") ;
      // ci deve essere almeno un parametro
       if ( vsParams.size() < 1)
@@ -6082,8 +6066,7 @@ GdbExecutor::GetLengthParam( const string& sParam, double& dLen)
      // recupero i parametri associati
       STRVECTOR vsParams ;
       Tokenize( sParam.substr( 1), ",", vsParams) ;
-      STRVECTOR::iterator Iter ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+      for ( auto Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
          Trim( (*Iter), " \t\r\n()") ;
      // ci deve essere almeno un parametro
       if ( vsParams.size() < 1)
@@ -6118,8 +6101,7 @@ GdbExecutor::GetDirParam( const string& sParam, const Frame3d& frDir, double& dD
      // recupero i parametri associati
       STRVECTOR vsParams ;
       Tokenize( sParam.substr( 3, sParam.length()-4), ",", "(", ")", vsParams) ;
-      STRVECTOR::iterator Iter ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+      for ( auto Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
          Trim( (*Iter), " \t\r\n") ;
      // ci deve essere almeno un parametro
       if ( vsParams.size() < 1)
@@ -6263,8 +6245,7 @@ GdbExecutor::GetFrameParam( const string& sParam, const Frame3d& frRef, Frame3d&
      // divido in parti ed elimino spazi iniziali/finali
       STRVECTOR vsParams ;
       Tokenize( sTmp, ",", "(", ")", vsParams) ;
-      STRVECTOR::iterator Iter ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+      for ( auto Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
          Trim( (*Iter), " \t\r\n") ;
      // verifico siano 4 parti e le converto
       if ( vsParams.size() != 4)
@@ -6291,8 +6272,7 @@ GdbExecutor::GetFrameParam( const string& sParam, const Frame3d& frRef, Frame3d&
       // divido in parti ed elimino spazi iniziali/finali
       STRVECTOR vsParams ;
       Tokenize( sTmp, ",", "(", ")", vsParams) ;
-      STRVECTOR::iterator Iter ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+      for ( auto Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
          Trim( (*Iter), " \t\r\n") ;
      // se c'è un parametro è l'origine
       Point3d ptOrig ;
@@ -6358,8 +6338,7 @@ GdbExecutor::GetColorParam( const string& sParam, bool& bByParent, Color& cCol)
      // divido in parti
       STRVECTOR vsParams ;
       Tokenize( sParam, ",", vsParams) ;
-      STRVECTOR::iterator Iter ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+      for ( auto Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
          Trim( (*Iter), " \t\r\n()") ;
      // devono essere 3 o 4 parametri ( Red, Green, Blue [, Alpha])
       if ( vsParams.size() != 3  &&  vsParams.size() != 4)
@@ -6387,8 +6366,7 @@ GdbExecutor::GetColorParam( const string& sParam, bool& bByParent, Color& cCol)
      // recupero i parametri associati
       STRVECTOR vsParams ;
       Tokenize( sParam.substr( 1), ",", vsParams) ;
-      STRVECTOR::iterator Iter ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+      for ( auto Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
          Trim( (*Iter), " \t\r\n()") ;
      // ci deve essere un parametro
       if ( vsParams.size() != 1)
@@ -6421,8 +6399,7 @@ GdbExecutor::GetMaterialParam( const string& sParam, bool& bByParent, int& nMat)
      // recupero i parametri associati
       STRVECTOR vsParams ;
       Tokenize( sParam.substr( 1), ",", vsParams) ;
-      STRVECTOR::iterator Iter ;
-      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+      for ( auto Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
          Trim( (*Iter), " \t\r\n()") ;
      // ci deve essere un parametro
       if ( vsParams.size() != 1)
@@ -6479,8 +6456,7 @@ GdbExecutor::ExecuteLevel( const string& sCmd2, const STRVECTOR& vsParams)
    else
       return false ;
   // esecuzione impostazione livello
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       if ( ! m_pGDB->SetLevel( *Iter, nLevel))
          return false ;
    }
@@ -6511,8 +6487,7 @@ GdbExecutor::ExecuteMode( const string& sCmd2, const STRVECTOR& vsParams)
    else
       return false ;
   // esecuzione impostazione modo
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       if ( ! m_pGDB->SetMode( *Iter, nMode))
          return false ;
    }
@@ -6543,8 +6518,7 @@ GdbExecutor::ExecuteStatus( const string& sCmd2, const STRVECTOR& vsParams)
    else
       return false ;
   // esecuzione impostazione stato
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       if ( ! m_pGDB->SetStatus( *Iter, nStat))
          return false ;
    }
@@ -6565,8 +6539,7 @@ GdbExecutor::ExecuteSelect( const string& sCmd2, const STRVECTOR& vsParams)
       if ( ! GetNamesParam( vsParams[0], vnNames))
          return false ;
      // esecuzione selezione
-      INTVECTOR::iterator Iter ;
-      for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+      for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
          if ( ! m_pGDB->SelectObj( *Iter))
             return false ;
       }
@@ -6610,8 +6583,7 @@ GdbExecutor::ExecuteSelect( const string& sCmd2, const STRVECTOR& vsParams)
             nFilter = EXT_TEXT ; 
       }
      // esecuzione selezione di tutti gli oggetti di ogni gruppo
-      INTVECTOR::iterator Iter ;
-      for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+      for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
          if ( ! m_pGDB->SelectGroupObjs( *Iter, nFilter))
             return false ;
       }
@@ -6635,8 +6607,7 @@ GdbExecutor::ExecuteDeselect( const string& sCmd2, const STRVECTOR& vsParams)
       if ( ! GetNamesParam( vsParams[0], vnNames))
          return false ;
      // esecuzione deselezione
-      INTVECTOR::iterator Iter ;
-      for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+      for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
          if ( ! m_pGDB->DeselectObj( *Iter))
             return false ;
       }
@@ -6652,8 +6623,7 @@ GdbExecutor::ExecuteDeselect( const string& sCmd2, const STRVECTOR& vsParams)
       if ( ! GetNamesParam( vsParams[0], vnNames))
          return false ;
      // esecuzione deselezione di tutti gli oggetti di ogni gruppo
-      INTVECTOR::iterator Iter ;
-      for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+      for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
          if ( ! m_pGDB->DeselectGroupObjs( *Iter))
             return false ;
       }
@@ -6710,8 +6680,7 @@ GdbExecutor::MaterialColor( const STRVECTOR& vsParams)
    if ( ! GetColorParam( vsParams[1], bByParent, cCol))
       return false ;
   // esecuzione impostazione colore
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       if ( bByParent) {
          if ( ! m_pGDB->SetMaterial( *Iter, GDB_MT_PARENT))
             return false ;
@@ -6741,8 +6710,7 @@ GdbExecutor::MaterialMaterial( const STRVECTOR& vsParams)
    if ( ! GetMaterialParam( vsParams[1], bByParent, nMat))
       return false ;
   // esecuzione impostazione colore
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       if ( bByParent) {
          if ( ! m_pGDB->SetMaterial( *Iter, GDB_MT_PARENT))
             return false ;
@@ -6789,8 +6757,7 @@ GdbExecutor::ExecuteName( const string& sCmd2, const STRVECTOR& vsParams)
       if ( ! GetStringParam( vsParams[1], sName))
          return false ;
      // eseguo assegnazione nome
-      INTVECTOR::iterator Iter ;
-      for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+      for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
          if ( ! m_pGDB->SetName( *Iter, sName))
             return false ;
       }
@@ -6806,8 +6773,7 @@ GdbExecutor::ExecuteName( const string& sCmd2, const STRVECTOR& vsParams)
       if ( ! GetNamesParam( vsParams[0], vnNames))
          return false ;
      // eseguo rimozione nome
-      INTVECTOR::iterator Iter ;
-      for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+      for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
          if ( ! m_pGDB->RemoveName( *Iter))
             return false ;
       }
@@ -6839,8 +6805,7 @@ GdbExecutor::ExecuteInfo( const string& sCmd2, const STRVECTOR& vsParams)
       if ( ! GetStringParam( vsParams[2], sInfo))
          return false ;
      // eseguo assegnazione Info di data Key
-      INTVECTOR::iterator Iter ;
-      for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+      for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
          if ( ! m_pGDB->SetInfo( *Iter, sKey, sInfo))
             return false ;
       }
@@ -6860,8 +6825,7 @@ GdbExecutor::ExecuteInfo( const string& sCmd2, const STRVECTOR& vsParams)
       if ( ! GetStringParam( vsParams[1], sKey))
          return false ;
      // eseguo rimozione nome Info di data Key
-      INTVECTOR::iterator Iter ;
-      for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+      for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
          if ( ! m_pGDB->RemoveInfo( *Iter, sKey))
             return false ;
       }
@@ -7010,8 +6974,7 @@ GdbExecutor::ExecuteRelocate( const string& sCmd2, const STRVECTOR& vsParams)
   // recupero flag per globale
    bool bGlob = ( sCmd2 == "GLOB"  ||  sCmd2 == "G") ;
   // esecuzione rilocazioni
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       if ( bGlob) {
          if ( ! m_pGDB->RelocateGlob( *Iter, GetIdParam( vsParams[1]), nSonBeforeAfter))
             return false ;
@@ -7036,8 +6999,7 @@ GdbExecutor::ExecuteErase( const string& sCmd2, const STRVECTOR& vsParams)
    if ( ! GetNamesParam( vsParams[0], vnNames))
       return false ;
   // esecuzione cancellazioni
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       if ( ! m_pGDB->Erase( *Iter))
          return false ;
    }
@@ -7079,8 +7041,7 @@ GdbExecutor::ExecuteTranslate( const string& sCmd2, const STRVECTOR& vsParams)
    if ( ! GetVectorParam( vsParams[1], frRef, vtVN))
       return false ;
   // esecuzione traslazioni
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       switch ( nTraType) {
       case TRA_LOC :
          if ( ! m_pGDB->Translate( *Iter, vtVN))
@@ -7144,8 +7105,7 @@ GdbExecutor::ExecuteRotate( const string& sCmd2, const STRVECTOR& vsParams)
    if ( ! FromString( vsParams[3], dAngDeg))
       return false ;
   // esecuzione rotazioni
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       switch ( nRotType) {
       case ROT_LOC :
          if ( ! m_pGDB->Rotate( *Iter, ptPC, vtVN, dAngDeg))
@@ -7214,8 +7174,7 @@ GdbExecutor::ExecuteScale( const string& sCmd2, const STRVECTOR& vsParams)
         ! FromString( vsParams[4], dCoeffZ))
       return false ;
   // esecuzione scalature
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       switch ( nScaType) {
       case SCA_LOC :
          if ( ! m_pGDB->Scale( *Iter, frFrame, dCoeffX, dCoeffY, dCoeffZ))
@@ -7273,8 +7232,7 @@ GdbExecutor::ExecuteMirror( const string& sCmd2, const STRVECTOR& vsParams)
    if ( ! GetVectorParam( vsParams[2], frRef, vtVN))
       return false ;
   // esecuzione specchiature
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       switch ( nMirType) {
       case MIR_LOC :
          if ( ! m_pGDB->Mirror( *Iter, ptPC, vtVN))
@@ -7340,8 +7298,7 @@ GdbExecutor::ExecuteShear( const string& sCmd2, const STRVECTOR& vsParams)
    if ( ! FromString( vsParams[4], dCoeff))
       return false ;
   // esecuzione scorrimenti
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       switch ( nMirType) {
       case MIR_LOC :
          if ( ! m_pGDB->Shear( *Iter, ptPC, vtNorm, vtDir, dCoeff))
@@ -7400,8 +7357,7 @@ GdbExecutor::CurveModifyInvert( const STRVECTOR& vsParams)
    if ( ! GetNamesParam( vsParams[0], vnNames))
       return false ;
   // esecuzione inversione curve
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       ICurve* pCurve = GetCurve( m_pGDB->GetGeoObj( *Iter)) ;
       if ( pCurve == nullptr  ||  ! pCurve->Invert())
          return false ;
@@ -7518,8 +7474,7 @@ GdbExecutor::CurveModifyTrim( const STRVECTOR& vsParams, int nTrimType)
    if ( ! FromString( vsParams[1], dPar))
       return false ;
   // esecuzione trim
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       ICurve* pCurve ;
       if ( ( pCurve = GetCurve( m_pGDB->GetGeoObj( *Iter))) != nullptr) {
          switch ( nTrimType) {
@@ -7718,8 +7673,7 @@ GdbExecutor::CurveCopyByChain( const STRVECTOR& vsParams)
   // preparo i dati per il concatenamento
    ChainCurves chainC ;
    chainC.Init( bAllowInvert, dToler, int( vnNames.size())) ;
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
      // recupero la curva e il suo riferimento
       ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( *Iter)) ;
       if ( pCrv == nullptr)
@@ -7748,10 +7702,9 @@ GdbExecutor::CurveCopyByChain( const STRVECTOR& vsParams)
       if ( IsNull( pCrvCompo))
          return false ;
      // recupero le curve semplici e le inserisco nella curva composita
-      INTVECTOR::iterator Iter2 ;
-      for ( Iter2 = vIds.begin() ; Iter2 != vIds.end() ; ++Iter2) {
-         int nId = abs( *Iter2) ;
-         bool bInvert = ( *Iter2 < 0) ;
+      for ( auto Iter = vIds.cbegin() ; Iter != vIds.cend() ; ++Iter) {
+         int nId = abs( *Iter) ;
+         bool bInvert = ( *Iter < 0) ;
         // recupero la curva e il suo riferimento
          ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nId)) ;
          if ( pCrv == nullptr)
@@ -7806,8 +7759,7 @@ GdbExecutor::SurfModifyInvert( const STRVECTOR& vsParams)
    if ( ! GetNamesParam( vsParams[0], vnNames))
       return false ;
   // esecuzione inversione normale superficie 
-   INTVECTOR::iterator Iter ;
-   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+   for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
       ISurf* pSurf = GetSurf( m_pGDB->GetGeoObj( *Iter)) ;
       if ( pSurf == nullptr  ||  ! pSurf->Invert())
          return false ;
@@ -8049,8 +8001,7 @@ GdbExecutor::ExecuteOutTsc( const string& sCmd2, const STRVECTOR& vsParams)
       if ( ! GetNamesParam( vsParams[0], vnNames))
          return false ;
      // esecuzione
-      INTVECTOR::iterator Iter ;
-      for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+      for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
         // recupero l'oggetto ed eseguo l'output
          if ( ! OutGroupTsc( *Iter, nFlag))
             return false ;
@@ -8073,8 +8024,7 @@ GdbExecutor::ExecuteOutTsc( const string& sCmd2, const STRVECTOR& vsParams)
       if ( ! GetNamesParam( vsParams[0], vnNames))
          return false ;
      // esecuzione
-      INTVECTOR::iterator Iter ;
-      for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+      for ( auto Iter = vnNames.cbegin() ; Iter != vnNames.cend() ; ++Iter) {
         // recupero l'oggetto ed eseguo l'output
          if ( ! m_OutTsc.PutGeoObj( m_pGDB->GetGeoObj( *Iter), nFlag))
             return false ;

GdbGeo.h

@@ -54,6 +54,10 @@ class GdbGeo : public GdbObj
 
 //----------------------------------------------------------------------------
 inline const GdbGeo* GetGdbGeo( const GdbObj* pGObj)
-               { return dynamic_cast<const GdbGeo*>(pGObj) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetGdbType() != GDB_TY_GEO)
+                    return nullptr ;
+                 return static_cast<const GdbGeo*>( pGObj) ; }
 inline GdbGeo* GetGdbGeo( GdbObj* pGObj)
-               { return dynamic_cast<GdbGeo*>(pGObj) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetGdbType() != GDB_TY_GEO)
+                    return nullptr ;
+                 return static_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) ;
-   INTVECTOR::const_iterator iFind = find( vnList.begin(), vnList.end(), m_nId) ;
+   const auto iFind = find( vnList.begin(), vnList.end(), m_nId) ;
    if ( iFind != vnList.end())
       vnList.erase( iFind) ;
    if ( vnList.empty())

GdbGroup.h

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

GdbIterator.cpp

@@ -24,7 +24,7 @@ using namespace std ;
 IGdbIterator*
 CreateGdbIterator( IGeomDB* pGDB)
 {
-   if ( dynamic_cast<GeomDB*>( pGDB) == nullptr)
+   if ( static_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 = dynamic_cast<GeomDB*>( pGDB) ;
+   m_pGDB = static_cast<GeomDB*>( pGDB) ;
    if ( m_pGDB == nullptr)
       return false ;
 
@@ -105,7 +105,7 @@ GdbIterator::GoToFirstInGroup( const IGdbIterator& iIter)
       return false ;
    }
 
-   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = static_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 = dynamic_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = static_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 = dynamic_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = static_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 = dynamic_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = static_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 = dynamic_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = static_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 = dynamic_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB) {
       m_pCurrObj = nullptr ;
       return false ;
@@ -1468,7 +1468,8 @@ GdbIterator::SetInfo( const string& sKey, int nInfo)
 bool
 GdbIterator::SetInfo( const string& sKey, double dInfo)
 {
-   return SetInfo( sKey, ToString( dInfo)) ;
+   int nErr ;
+   return ( SetInfo( sKey, ToString( dInfo, 6, &nErr)) && nErr == 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -1637,7 +1638,7 @@ GdbIterator::CopyAllInfoFrom( const IGdbIterator& iIter)
       return false ;
 
   // recupero l'oggetto sorgente
-   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
+   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 ;
@@ -1651,6 +1652,29 @@ GdbIterator::CopyAllInfoFrom( const IGdbIterator& iIter)
       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-2022
+//  EgalTech 2013-2023
 //----------------------------------------------------------------------------
-// File : GdbIterator.h         Data : 29.01.23          Versione : 2.5a2
+// File : GdbIterator.h         Data : 09.07.23          Versione : 2.5g1
 // Contenuto : Dichiarazione della classe GdbIterator.
 //
 //
@@ -144,6 +144,9 @@ class GdbIterator : public IGdbIterator
       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,10 +31,9 @@ using namespace std ;
 
 //----------------------------------------------------------------------------
 GdbObj::GdbObj( void)
-   : m_nId( GDB_ID_NULL), m_pAttribs( nullptr), m_pTxrData( nullptr), m_pUserObj( nullptr),
-     m_pGDB( nullptr), m_pNext( nullptr), m_pPrev( nullptr), m_pParent( nullptr),
+   : 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)
-     
 {
 }
 
@@ -73,6 +72,9 @@ 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 ;
@@ -91,6 +93,10 @@ 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)) ;
 }
@@ -856,7 +862,8 @@ GdbObj::SetInfo( const string& sKey, int nInfo)
 bool
 GdbObj::SetInfo( const string& sKey, double dInfo)
 {
-   return SetInfo( sKey, ToString( dInfo)) ;
+   int nErr ; 
+   return ( SetInfo( sKey, ToString( dInfo, 6, &nErr)) && nErr == 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -1037,6 +1044,26 @@ GdbObj::GetAllInfo( STRVECTOR& vsInfo) const
    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

@@ -120,6 +120,8 @@ class GdbObj
       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)
@@ -161,6 +163,8 @@ class GdbObj
    public :
       int          m_nId ;
       Attribs*     m_pAttribs ;
+      int          m_nStpFactor ;
+      int          m_nStpPattern ;
       TextureData* m_pTxrData ;
       IUserObj*    m_pUserObj ;
 

GeoFrame3d.cpp

@@ -29,10 +29,8 @@ GEOOBJ_REGISTER( GEO_FRAME3D, NGE_G_FRM, GeoFrame3d) ;
 
 //----------------------------------------------------------------------------
 GeoFrame3d::GeoFrame3d( void)
-   : m_frF()
+   : m_frF(), m_nTempProp{0,0}, m_dTempParam{0.0,0.0}
 {
-   m_nTempProp[0] = 0 ;
-   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -104,7 +102,7 @@ GeoFrame3d::Clone( void) const
 bool
 GeoFrame3d::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const GeoFrame3d* pGFr = dynamic_cast<const GeoFrame3d*>( pGObjSrc) ;
+   const GeoFrame3d* pGFr = GetBasicGeoFrame3d( pGObjSrc) ;
    if ( pGFr == nullptr)
       return false ;
    return CopyFrom( *pGFr) ;
@@ -118,6 +116,8 @@ GeoFrame3d::CopyFrom( const GeoFrame3d& gfSrc)
       return true ;
    m_nTempProp[0] = gfSrc.m_nTempProp[0] ;
    m_nTempProp[1] = gfSrc.m_nTempProp[1] ;
+   m_dTempParam[0] = gfSrc.m_dTempParam[0] ;
+   m_dTempParam[1] = gfSrc.m_dTempParam[1] ;
    return Set( gfSrc.m_frF) ;
 }
 

GeoFrame3d.h

@@ -62,6 +62,11 @@ class GeoFrame3d : public IGeoFrame3d, public IGeoObjRW
                    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) ; }
 
    public :                      // IGeoFrame3d
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -97,4 +102,21 @@ class GeoFrame3d : public IGeoFrame3d, public IGeoObjRW
       ObjGraphicsMgr m_OGrMgr ;        // gestore grafica dell'oggetto
       Frame3d        m_frF ;           // oggetto
       int            m_nTempProp[2] ;  // vettore proprietà temporanee 
+      double         m_dTempParam[2] ; // vettore parametri temporanei
 } ;
+
+//-----------------------------------------------------------------------------
+inline GeoFrame3d* CreateBasicGeoFrame3d( void)
+               { return ( static_cast<GeoFrame3d*>( CreateGeoObj( GEO_FRAME3D))) ; }
+inline GeoFrame3d* CloneBasicGeoFrame3d( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_FRAME3D)
+                    return nullptr ;
+                 return ( static_cast<GeoFrame3d*>( pGObj->Clone())) ; }
+inline const GeoFrame3d* GetBasicGeoFrame3d( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_FRAME3D)
+                    return nullptr ;
+                 return ( static_cast<const GeoFrame3d*>( pGObj)) ; }
+inline GeoFrame3d* GetBasicGeoFrame3d( IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_FRAME3D)
+                    return nullptr ;
+                 return ( static_cast<GeoFrame3d*>( pGObj)) ; }

GeoPoint3d.cpp

@@ -28,10 +28,8 @@ GEOOBJ_REGISTER( GEO_PNT3D, NGE_G_PNT, GeoPoint3d) ;
 
 //----------------------------------------------------------------------------
 GeoPoint3d::GeoPoint3d( void)
-   : m_ptP()
+   : m_ptP(), m_nTempProp{0,0}, m_dTempParam{0.0,0.0}
 {
-   m_nTempProp[0] = 0 ;
-   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -72,7 +70,7 @@ GeoPoint3d::Clone( void) const
 bool
 GeoPoint3d::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const GeoPoint3d* pGP = dynamic_cast<const GeoPoint3d*>( pGObjSrc) ;
+   const GeoPoint3d* pGP = GetBasicGeoPoint3d( pGObjSrc) ;
    if ( pGP == nullptr)
       return false ;
    return CopyFrom( *pGP) ;
@@ -86,6 +84,8 @@ GeoPoint3d::CopyFrom( const GeoPoint3d& clSrc)
       return true ;
    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] ;
    return Set( clSrc.m_ptP) ;
 }
 

GeoPoint3d.h

@@ -62,6 +62,11 @@ class GeoPoint3d : public IGeoPoint3d, public IGeoObjRW
                    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) ; }
 
    public :                      // IGeoPoint3d
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -91,4 +96,21 @@ class GeoPoint3d : public IGeoPoint3d, public IGeoObjRW
       ObjGraphicsMgr m_OGrMgr ;        // gestore grafica dell'oggetto
       Point3d        m_ptP ;           // oggetto
       int            m_nTempProp[2] ;  // vettore proprietà temporanee 
+      double         m_dTempParam[2] ; // vettore parametri temporanei 
 } ;
+
+//-----------------------------------------------------------------------------
+inline GeoPoint3d* CreateBasicGeoPoint3d( void)
+               { return ( static_cast<GeoPoint3d*>( CreateGeoObj( GEO_PNT3D))) ; }
+inline GeoPoint3d* CloneBasicGeoPoint3d( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_PNT3D)
+                    return nullptr ;
+                 return ( static_cast<GeoPoint3d*>( pGObj->Clone())) ; }
+inline const GeoPoint3d* GetBasicGeoPoint3d( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_PNT3D)
+                    return nullptr ;
+                 return ( static_cast<const GeoPoint3d*>( pGObj)) ; }
+inline GeoPoint3d* GetBasicGeoPoint3d( IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_PNT3D)
+                    return nullptr ;
+                 return ( static_cast<GeoPoint3d*>( pGObj)) ; }

GeoVector3d.cpp

@@ -29,10 +29,8 @@ GEOOBJ_REGISTER( GEO_VECT3D, NGE_G_VEC, GeoVector3d) ;
 
 //----------------------------------------------------------------------------
 GeoVector3d::GeoVector3d( void)
-   : m_vtV()
+   : m_vtV(), m_ptBase(), m_nTempProp{0,0}, m_dTempParam{0.0,0.0}
 {
-   m_nTempProp[0] = 0 ;
-   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -88,7 +86,7 @@ GeoVector3d::Clone( void) const
 bool
 GeoVector3d::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const GeoVector3d* pGV = dynamic_cast<const GeoVector3d*>( pGObjSrc) ;
+   const GeoVector3d* pGV = GetBasicGeoVector3d( pGObjSrc) ;
    if ( pGV == nullptr)
       return false ;
    return CopyFrom( *pGV) ;
@@ -102,6 +100,8 @@ GeoVector3d::CopyFrom( const GeoVector3d& clSrc)
       return true ;
    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] ;
    return Set( clSrc.m_vtV, clSrc.m_ptBase) ;
 }
 

GeoVector3d.h

@@ -70,6 +70,11 @@ class GeoVector3d : public IGeoVector3d, public IGeoObjRW
                    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) ; }
 
    public :                      // IGeoVector3d
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -106,4 +111,21 @@ class GeoVector3d : public IGeoVector3d, public IGeoObjRW
       Vector3d       m_vtV ;           // oggetto
       Point3d        m_ptBase ;        // punto base da cui tracciare il vettore
       int            m_nTempProp[2] ;  // vettore proprietà temporanee 
+      double         m_dTempParam[2] ; // vettore parametri temporanei 
 } ;
+
+//-----------------------------------------------------------------------------
+inline GeoVector3d* CreateBasicGeoVector3d( void)
+               { return ( static_cast<GeoVector3d*>( CreateGeoObj( GEO_VECT3D))) ; }
+inline GeoVector3d* CloneBasicGeoVector3d( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_VECT3D)
+                    return nullptr ;
+                 return ( static_cast<GeoVector3d*>( pGObj->Clone())) ; }
+inline const GeoVector3d* GetBasicGeoVector3d( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_VECT3D)
+                    return nullptr ;
+                 return ( static_cast<const GeoVector3d*>( pGObj)) ; }
+inline GeoVector3d* GetBasicGeoVector3d( IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_VECT3D)
+                    return nullptr ;
+                 return ( static_cast<GeoVector3d*>( pGObj)) ; }

GeomDB.cpp

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2013
+//  EgalTech 2013-2023
 //----------------------------------------------------------------------------
-// File : GeomDB.cpp           Data : 08.04.13          Versione : 1.3a5
+// File : GeomDB.cpp           Data : 29.05.23          Versione : 2.5e5
 // Contenuto : Implementazione della classe GeomDB.
 //
 //
@@ -21,38 +21,63 @@
 #include "NgeReader.h"
 #include "NgeWriter.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
-#include "/EgtDev/Include/SELkLockId.h"
-#include "/EgtDev/Include/SELkKeyProc.h"
+#include "/EgtDev/Include/EGnGetKeyData.h"
 #include "/EgtDev/Include/EgtStringConverter.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include "/EgtDev/Include/EgtNumCollection.h"
 #include "/EgtDev/Include/EgtKeyCodes.h"
+#include "/EgtDev/Include/SELkLockId.h"
+#include "/EgtDev/Include/SELkKeyProc.h"
 #include <new>
 #include <stack>
+#include <thread>
 
 using namespace std ;
 
+//----------------------------------------------------------------------------
+class LockAddErase
+{
+   public :
+      LockAddErase(std::atomic_flag& bAddEraseOn, bool bUse = true): m_bAddEraseOn( bAddEraseOn), m_bUse( bUse)
+         {  if ( ! m_bUse) return ;
+            while ( m_bAddEraseOn.test_and_set()) {
+               this_thread::sleep_for( chrono::nanoseconds{ 1}) ;
+            }
+         } ;
+
+      ~LockAddErase( void)
+         {  if ( ! m_bUse) return ;
+            m_bAddEraseOn.clear() ;
+         } ;
+
+   private :
+      std::atomic_flag& m_bAddEraseOn ;
+      bool m_bUse ;
+} ;
+
 //----------------------------------------------------------------------------
 IGeomDB*
 CreateGeomDB( void)
 {
   // verifico la chiave e le opzioni
-   if ( ! GetEGkNetHwKey()) {
-      unsigned int nOpt1, nOpt2 ;
-      int nOptExpDays ;
-      int nRet = GetKeyOptions( GetEGkKey(), KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
+   unsigned int nOpt1, nOpt2 ;
+   int nOptExpDays ;
+   int nRet = GetEGnKeyOptions( KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
                                 nOpt1, nOpt2, nOptExpDays) ;
-      if ( nRet != KEY_OK  &&  ! EqualNoCase( GetEGkKey(), "EGkBase")) {
-         if ( nRet != KEY_OK) {
-            string sErr = "Error on Key (GKC/" + ToString( nRet) + ")" ;
-            LOG_ERROR( GetEGkLogger(), sErr.c_str()) ;
-            return nullptr ;
-         }
-         if ( (nOpt1 & KEYOPT_EGK_BASE) == 0  ||  nOptExpDays < GetCurrDay()) {
-            string sErr = "Error on Key (GKC/OPT)" ;
-            LOG_ERROR( GetEGkLogger(), sErr.c_str()) ;
-            return nullptr ;
-         }
+   if ( ! GetEGkNetHwKey())
+      nRet = GetKeyOptions( GetEGkKey(), KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
+                            nOpt1, nOpt2, nOptExpDays) ;
+  // controllo i risultati
+   if ( nRet != KEY_OK  &&  ! EqualNoCase( GetEGkKey(), "EGkBase")) {
+      if ( nRet != KEY_OK) {
+         string sErr = "Error on Key (GKC/" + ToString( nRet) + ")" ;
+         LOG_ERROR( GetEGkLogger(), sErr.c_str()) ;
+         return nullptr ;
+      }
+      if ( ( nOpt1 & KEYOPT_EGK_BASE) == 0  ||  nOptExpDays < GetCurrDay()) {
+         string sErr = "Error on Key (GKC/OPT)" ;
+         LOG_ERROR( GetEGkLogger(), sErr.c_str()) ;
+         return nullptr ;
       }
    }
 
@@ -65,6 +90,7 @@ CreateGeomDB( void)
 //----------------------------------------------------------------------------
 GeomDB::GeomDB( void)
 {
+   m_bAddEraseOn.clear() ;
    m_GrpRadix.SetGeomDB( this) ;
    m_GrpRadix.m_nId = GDB_ID_ROOT ;
    m_GrpRadix.SetMaterial( Color()) ;
@@ -275,21 +301,23 @@ bool
 GeomDB::Save( int nId, const string& sFileOut, int nFlag) const
 {
   // verifico la chiave e le opzioni
-   if ( ! GetEGkNetHwKey()) {
-      unsigned int nOpt1, nOpt2 ;
-      int nOptExpDays ;
-      int nRet = GetKeyOptions( GetEGkKey(), KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
+   unsigned int nOpt1, nOpt2 ;
+   int nOptExpDays ;
+   int nRet = GetEGnKeyOptions( KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
                                 nOpt1, nOpt2, nOptExpDays) ;
-      if ( nRet != KEY_OK) {
-         string sErr = "Error on Key (GKS/" + ToString( nRet) + ")" ;
-         LOG_ERROR( GetEGkLogger(), sErr.c_str()) ;
-         return false ;
-      }
-      if ( (nOpt1 & KEYOPT_EGK_SAVE) == 0  ||  nOptExpDays < GetCurrDay()) {
-         string sErr = "Error on Key (GKS/OPT)" ;
-         LOG_ERROR( GetEGkLogger(), sErr.c_str()) ;
-         return false ;
-      }
+   if ( ! GetEGkNetHwKey())
+      nRet = GetKeyOptions( GetEGkKey(), KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
+                            nOpt1, nOpt2, nOptExpDays) ;
+  // controllo i risultati
+   if ( nRet != KEY_OK) {
+      string sErr = "Error on Key (GKS/" + ToString( nRet) + ")" ;
+      LOG_ERROR( GetEGkLogger(), sErr.c_str()) ;
+      return false ;
+   }
+   if ( ( nOpt1 & KEYOPT_EGK_SAVE) == 0  ||  nOptExpDays < GetCurrDay()) {
+      string sErr = "Error on Key (GKS/OPT)" ;
+      LOG_ERROR( GetEGkLogger(), sErr.c_str()) ;
+      return false ;
    }
 
   // assegno Id base
@@ -387,21 +415,23 @@ bool
 GeomDB::Save( const INTVECTOR& vId, const string& sFileOut, int nFlag) const
 {
   // verifico la chiave e le opzioni
-   if ( ! GetEGkNetHwKey()) {
-      unsigned int nOpt1, nOpt2 ;
-      int nOptExpDays ;
-      int nRet = GetKeyOptions( GetEGkKey(), KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
+   unsigned int nOpt1, nOpt2 ;
+   int nOptExpDays ;
+   int nRet = GetEGnKeyOptions( KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
                                 nOpt1, nOpt2, nOptExpDays) ;
-      if ( nRet != KEY_OK) {
-         string sErr = "Error on Key (GKS/" + ToString( nRet) + ")" ;
-         LOG_ERROR( GetEGkLogger(), sErr.c_str()) ;
-         return false ;
-      }
-      if ( (nOpt1 & KEYOPT_EGK_SAVE) == 0  ||  nOptExpDays < GetCurrDay()) {
-         string sErr = "Error on Key (GKS/OPT)" ;
-         LOG_ERROR( GetEGkLogger(), sErr.c_str()) ;
-         return false ;
-      }
+   if ( ! GetEGkNetHwKey())
+      nRet = GetKeyOptions( GetEGkKey(), KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
+                            nOpt1, nOpt2, nOptExpDays) ;
+  // controllo i risultati
+   if ( nRet != KEY_OK) {
+      string sErr = "Error on Key (GKS/" + ToString( nRet) + ")" ;
+      LOG_ERROR( GetEGkLogger(), sErr.c_str()) ;
+      return false ;
+   }
+   if ( ( nOpt1 & KEYOPT_EGK_SAVE) == 0  ||  nOptExpDays < GetCurrDay()) {
+      string sErr = "Error on Key (GKS/OPT)" ;
+      LOG_ERROR( GetEGkLogger(), sErr.c_str()) ;
+      return false ;
    }
 
   // assegno Id base (nessuna riduzione degli Id)
@@ -423,7 +453,7 @@ GeomDB::Save( const INTVECTOR& vId, const string& sFileOut, int nFlag) const
       return false ;
 
   // ciclo sugli oggetti da esportare
-   unordered_set<int> usSavedId ;
+   INTUNORDSET usSavedId ;
    for ( const auto nId : vId) {
 
      // se già salvato, passo oltre
@@ -588,25 +618,32 @@ GeomDB::GetGdbObj( int nId) const
 
 //----------------------------------------------------------------------------
 bool
-GeomDB::InsertInGeomDB( GdbObj* pGObj, int nRefId, int nSonBeforeAfter, bool bTestId)
+GeomDB::InsertInGeomDB( GdbObj* pGObj, int nRefId, int nSonBeforeAfter, bool bLockAddErase, bool bTestId)
 {
   // verifico validità oggetto puntato
    if ( pGObj == nullptr)
       return false ;
 
-  // se richiesta, verifica validità e unicità del nome
-   if ( bTestId  &&  ( pGObj->m_nId <= GDB_ID_ROOT  ||  ExistsObj( pGObj->m_nId)))
+  // verifico validità del riferimento
+   if ( nRefId < GDB_ID_ROOT)
       return false ;
 
   // oggetto e riferimento non possono essere la stessa cosa
    if ( pGObj->m_nId == nRefId)
       return ( ! IS_GDB_SON( nSonBeforeAfter)) ;
 
+  // verifico unicità esecuzione, se necessaria
+   LockAddErase Lock( m_bAddEraseOn, bLockAddErase) ;
+
   // cerco il riferimento
    GdbObj* pGRef = GetGdbObj( nRefId) ;
    if ( pGRef == nullptr)
       return false ;
 
+  // se richiesta, verifica validità e unicità del nome
+   if ( bTestId  &&  ( pGObj->m_nId <= GDB_ID_ROOT  ||  ExistsObj( pGObj->m_nId)))
+      return false ;
+
   // assegno il riferimento al DB geometrico
    pGObj->SetGeomDB( this) ;
 
@@ -622,7 +659,7 @@ GeomDB::InsertInGeomDB( GdbObj* pGObj, int nRefId, int nSonBeforeAfter, bool bTe
    }
   // inserisco come figlio, in testa alla lista del padre
    else if ( nSonBeforeAfter == GDB_FIRST_SON){
-      GdbGroup* pGroup = dynamic_cast<GdbGroup*> ( pGRef) ;
+      GdbGroup* pGroup = ::GetGdbGroup( pGRef) ;
       if ( pGroup == nullptr)
          return false ;
      // inserisco in testa alla lista del padre
@@ -631,7 +668,7 @@ GeomDB::InsertInGeomDB( GdbObj* pGObj, int nRefId, int nSonBeforeAfter, bool bTe
    }
   // inserisco come figlio, in coda alla lista del padre
    else {
-      GdbGroup* pGroup = dynamic_cast<GdbGroup*> ( pGRef) ;
+      GdbGroup* pGroup = ::GetGdbGroup( pGRef) ;
       if ( pGroup == nullptr)
          return false ;
      // inserisco in coda alla lista del padre
@@ -660,6 +697,8 @@ GeomDB::InsertGroup( int nId, int nRefId, int nSonBeforeAfter, const Frame3d& fr
   // verifico validità apparente RefId
    if ( nRefId < GDB_ID_ROOT)
       return GDB_ID_NULL ;
+  // verifico unicità esecuzione
+   LockAddErase Lock( m_bAddEraseOn) ;
   // verifico validità Id
    if ( nId <= GDB_ID_ROOT)
       nId = m_IdManager.GetNewId() ;
@@ -674,7 +713,7 @@ GeomDB::InsertGroup( int nId, int nRefId, int nSonBeforeAfter, const Frame3d& fr
   // assegno riferimento
    pGdbGroup->SetFrame( frFrame) ;
   // inserisco nel DB
-   if ( ! InsertInGeomDB( pGdbGroup, nRefId, nSonBeforeAfter)) {
+   if ( ! InsertInGeomDB( pGdbGroup, nRefId, nSonBeforeAfter, false)) {
       delete pGdbGroup ;
       return GDB_ID_NULL ;
    }
@@ -695,6 +734,8 @@ GeomDB::InsertGeoObj( int nId, int nRefId, int nSonBeforeAfter, IGeoObj* pGeoObj
 {
   // assegno GeoObj a gestore puntatore con rilascio automatico
    PtrOwner<IGeoObj> pRPGeoObj( pGeoObj) ;
+  // verifico unicità esecuzione
+   LockAddErase Lock( m_bAddEraseOn) ;
   // verifico validità identificativo
    if ( nId <= GDB_ID_ROOT)
       nId = m_IdManager.GetNewId() ;
@@ -712,7 +753,7 @@ GeomDB::InsertGeoObj( int nId, int nRefId, int nSonBeforeAfter, IGeoObj* pGeoObj
   // assegno dati
    pGdbGeo->m_pGeoObj = Release( pRPGeoObj) ;
   // inserisco nel DB
-   if ( ! InsertInGeomDB( pGdbGeo, nRefId, nSonBeforeAfter)) {
+   if ( ! InsertInGeomDB( pGdbGeo, nRefId, nSonBeforeAfter, false)) {
       delete pGdbGeo ;
       return GDB_ID_NULL ;
    }
@@ -1195,6 +1236,9 @@ GeomDB::GetRefBBox( int nId, const Frame3d& frRef, BBox3d& b3Ref, int nFlag) con
 int
 GeomDB::Copy( int nIdSou, int nIdDest, int nRefId, int nSonBeforeAfter, bool bGlob)
 {
+  // verifico unicità esecuzione
+   LockAddErase Lock( m_bAddEraseOn) ;
+
   // verifico Id destinazione
    if ( nIdDest <= GDB_ID_ROOT)
       nIdDest = m_IdManager.GetNewId() ;
@@ -1237,7 +1281,7 @@ GeomDB::Copy( int nIdSou, int nIdDest, int nRefId, int nSonBeforeAfter, bool bGl
    }
 
   // inserisco nel DB (non rilascio il puntatore)
-   if ( ! InsertInGeomDB( pGdODest, nRefId, nSonBeforeAfter))
+   if ( ! InsertInGeomDB( pGdODest, nRefId, nSonBeforeAfter, false))
       return GDB_ID_NULL ;
 
   // rilascio il puntatore
@@ -1249,10 +1293,17 @@ GeomDB::Copy( int nIdSou, int nIdDest, int nRefId, int nSonBeforeAfter, bool bGl
 bool
 GeomDB::Relocate( int nId, int nRefId, int nSonBeforeAfter, bool bGlob)
 {
-  // l'oggetto e il riferimento non possono coincidere
+  // verifico validità del riferimento
+   if ( nRefId < GDB_ID_ROOT)
+      return false ;
+
+   // l'oggetto e il riferimento non possono coincidere
    if ( nId == nRefId)
       return ( ! IS_GDB_SON( nSonBeforeAfter)) ;
 
+  // verifico unicità esecuzione
+   LockAddErase Lock( m_bAddEraseOn) ;
+
   // verifico esistenza dell'oggetto
    GdbObj* pGdbObj = GetGdbObj( nId) ;
    if ( pGdbObj == nullptr)
@@ -1296,7 +1347,7 @@ GeomDB::Relocate( int nId, int nRefId, int nSonBeforeAfter, bool bGlob)
    pGdbObj->Remove() ;
 
   // lo inserisco nella posizione opportuna
-   if ( ! InsertInGeomDB( pGdbObj, nRefId, nSonBeforeAfter, false)) {
+   if ( ! InsertInGeomDB( pGdbObj, nRefId, nSonBeforeAfter, false, false)) {
      // in caso di errore (condizione assai remota qui) cancello tutto
       m_IdManager.RemoveObj( pGdbObj->m_nId) ;
       m_SelManager.RemoveObj( pGdbObj) ;
@@ -1377,9 +1428,14 @@ GeomDB::GetNewId( void) const
 bool
 GeomDB::ChangeId( int nId, int nNewId)
 {
+  // se Id non validi, ritorno errore
+   if ( nId <= GDB_ID_ROOT  ||  nNewId <= GDB_ID_ROOT)
+      return false ;
   // se Id identici, non faccio alcunché
    if ( nNewId == nId)
       return true ;
+  // verifico unicità esecuzione
+   LockAddErase Lock( m_bAddEraseOn) ;
   // verifico nuovo Id
    if ( ExistsObj( nNewId))
       return false ;
@@ -1420,7 +1476,10 @@ GeomDB::Erase( GdbObj* pGdbObj)
    if ( pGdbObj == nullptr  ||  pGdbObj == &m_GrpRadix)
       return false ;
 
-  // notifico eventuale UserObj
+  // verifico unicità esecuzione
+   LockAddErase Lock( m_bAddEraseOn) ;
+
+   // notifico eventuale UserObj
    if ( pGdbObj->m_pUserObj != nullptr) {
      // recupero il successivo
       const GdbObj* pGdbNext = pGdbObj->GetNext() ;
@@ -1445,6 +1504,10 @@ GeomDB::RemoveGeoObjAndErase( int nId)
   // non si può cancellare il gruppo radice (escludo anche Id non validi)
    if ( nId <= GDB_ID_ROOT)
       return nullptr ;
+
+  // verifico unicità esecuzione
+   LockAddErase Lock( m_bAddEraseOn) ;
+
   // recupero l'oggetto geometrico
    GdbGeo* pGdbGeo = ::GetGdbGeo( m_IdManager.FindObj( nId)) ;
    if ( pGdbGeo == nullptr)
@@ -1452,6 +1515,7 @@ GeomDB::RemoveGeoObjAndErase( int nId)
    IGeoObj* pGeoObj = pGdbGeo->m_pGeoObj ;
   // annullo il riferimento alla geometria nell'entità
    pGdbGeo->m_pGeoObj = nullptr ;
+
   // tolgo dalla lista e disalloco
    pGdbGeo->Remove() ;
    delete pGdbGeo ;
@@ -1487,6 +1551,10 @@ GeomDB::EmptyGroup( GdbObj* pGdbObj)
    GdbGroup* pGrp = ::GetGdbGroup( pGdbObj) ;
    if ( pGrp == nullptr)
       return false ;
+
+  // verifico unicità esecuzione
+   LockAddErase Lock( m_bAddEraseOn) ;
+
   // lo svuoto
    return pGrp->Clear() ;
 }
@@ -2717,7 +2785,8 @@ GeomDB::SetInfo( int nId, const string& sKey, int nInfo)
 bool
 GeomDB::SetInfo( int nId, const string& sKey, double dInfo)
 {
-   return SetInfo( nId, sKey, ToString( dInfo)) ;
+   int nErr ;
+   return ( SetInfo( nId, sKey, ToString( dInfo, 6, &nErr)) && nErr == 0) ;
 }
 
 //----------------------------------------------------------------------------
@@ -2922,6 +2991,51 @@ GeomDB::CopyAllInfoFrom( int nId, int nSouId)
       return true ;
 }
 
+//----------------------------------------------------------------------------
+// Stipple (significativo solo per curve)
+//----------------------------------------------------------------------------
+bool
+GeomDB::DumpStipple( int nId, string& sOut, bool bMM, const char* szNewLine) const
+{
+  // recupero l'oggetto
+   const GdbObj* pGdbObj = GetGdbObj( nId) ;
+   if ( pGdbObj == nullptr)
+      return false ;
+  // eseguo il dump
+   if ( pGdbObj->m_nStpFactor != 0) {
+     // nome della texture
+      sOut += "Stipple=" ;
+      sOut += ToString( pGdbObj->m_nStpFactor) ;
+      sOut += "-" + ToString( pGdbObj->m_nStpPattern, 1, 16) ;
+      sOut += szNewLine ;
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::SetStipple( int nId, int nFactor, int nPattern)
+{
+  // recupero l'oggetto
+   GdbObj* pGdbObj = GetGdbObj( nId) ;
+   if ( pGdbObj == nullptr)
+      return false ;
+  // imposto lo stipple
+   return pGdbObj->SetStipple( nFactor, nPattern) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GeomDB::GetStipple( int nId, int& nFactor, int& nPattern) const
+{
+  // recupero l'oggetto
+   const GdbObj* pGdbObj = GetGdbObj( nId) ;
+   if ( pGdbObj == nullptr)
+      return false ;
+  // recupero lo stipple
+   return pGdbObj->GetStipple( nFactor, nPattern) ;
+}
+
 //----------------------------------------------------------------------------
 // TextureData
 //----------------------------------------------------------------------------
@@ -2933,7 +3047,7 @@ GeomDB::DumpTextureData( int nId, string& sOut, bool bMM, const char* szNewLine)
    if ( pGdbObj == nullptr)
       return false ;
   // eseguo il dump
-   if ( pGdbObj->m_pTxrData  != nullptr)
+   if ( pGdbObj->m_pTxrData != nullptr)
       return pGdbObj->m_pTxrData->Dump( *this, sOut, bMM, szNewLine) ;
    else
       return true ;

GeomDB.h

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2013-2014
+//  EgalTech 2013-2023
 //----------------------------------------------------------------------------
-// File : GeomDB.h           Data : 03.12.14          Versione : 1.5l1
+// File : GeomDB.h           Data : 09.07.23          Versione : 2.5g1
 // Contenuto : Dichiarazione della classe GeomDB.
 //
 //
 //
 // Modifiche : 22.01.13 DS Creazione modulo.
-//             03.12.14 DS Aggiunta gestione riferimento di griglia.
+//
 //
 //----------------------------------------------------------------------------
 
@@ -20,6 +20,7 @@
 #include "SelManager.h"
 #include "GdbMaterialMgr.h"
 #include "/EgtDev/Include/EGkGeomDB.h"
+#include <atomic>
 
 //----------------------------------------------------------------------------
 class GeomDB : public IGeomDB
@@ -181,6 +182,10 @@ class GeomDB : public IGeomDB
       bool RemoveInfo( int nId, const std::string& sKey) override ;
       bool GetAllInfo( int nId, STRVECTOR& vsInfo) const override ;
       bool CopyAllInfoFrom( int nId, int nSouId) override ;
+     // Stipple (significativo solo per curve)
+      bool DumpStipple( int nId, std::string& sOut, bool bMM = true, const char* szNewLine = "\n") const override ;
+      bool SetStipple( int nId, int nFactor, int nPattern) override ;
+      bool GetStipple( int nId, int& nFactor, int& nPattern) const override ;
      // TextureData
       bool DumpTextureData( int nId, std::string& sOut, bool bMM = true, const char* szNewLine = "\n") const override ;
       bool SetTextureName( int nId, const std::string& sTxrName) override ;
@@ -222,14 +227,14 @@ class GeomDB : public IGeomDB
       GdbObj* GetGdbObj( int nId) ;
       const GdbObj* GetGdbObj( int nId) const ;
       GdbGeo* GetGdbGeo( int nId)
-                 { return dynamic_cast<GdbGeo*>( GetGdbObj( nId)) ; }
+                 { return ::GetGdbGeo( GetGdbObj( nId)) ; }
       const GdbGeo* GetGdbGeo( int nId) const
-                 { return dynamic_cast<const GdbGeo*>( GetGdbObj( nId)) ; }
+                 { return ::GetGdbGeo( GetGdbObj( nId)) ; }
       GdbGroup* GetGdbGroup( int nId)
-                 { return dynamic_cast<GdbGroup*>( GetGdbObj( nId)) ; }
+                 { return ::GetGdbGroup( GetGdbObj( nId)) ; }
       const GdbGroup* GetGdbGroup( int nId) const
-                 { return dynamic_cast<const GdbGroup*>( GetGdbObj( nId)) ; }
-      bool InsertInGeomDB( GdbObj* pGObj, int nRefId, int nSonBeforeAfter, bool bTestId = true) ;
+                 { return ::GetGdbGroup( GetGdbObj( nId)) ; }
+      bool InsertInGeomDB( GdbObj* pGObj, int nRefId, int nSonBeforeAfter, bool bLockAddErase = true, bool bTestId = true) ;
       int  Copy( int nIdSou, int nIdDest, int nRefId, int nSonBeforeAfter, bool bGlob) ;
       bool Relocate( int nId, int nRefId, int nSonBeforeAfter, bool bGlob) ;
       bool Erase( GdbObj* pGObj) ;
@@ -253,10 +258,11 @@ class GeomDB : public IGeomDB
                  { return m_IterManager.RemoveGdbIterator( pIter) ; }
 
    private :
-      IdManager      m_IdManager ;        // gestore del nuovo Id
-      IterManager    m_IterManager ;      // gestore lista iteratori attivi
-      SelManager     m_SelManager ;       // gestore lista oggetti selezionati
-      GdbMaterialMgr m_MatManager ;       // gestore lista materiali
-      GdbGroup       m_GrpRadix ;         // gruppo radice di tutto il DB
-      Frame3d        m_GridFrame ;        // riferimento della griglia
+      IdManager            m_IdManager ;        // gestore del nuovo Id
+      IterManager          m_IterManager ;      // gestore lista iteratori attivi
+      SelManager           m_SelManager ;       // gestore lista oggetti selezionati
+      GdbMaterialMgr       m_MatManager ;       // gestore lista materiali
+      GdbGroup             m_GrpRadix ;         // gruppo radice di tutto il DB
+      Frame3d              m_GridFrame ;        // riferimento della griglia
+      std::atomic_flag     m_bAddEraseOn ;      // flag esecuzione inserimento o cancellazione in corso (per multi thread)
 } ;

IntersCurveCurve.cpp

@@ -659,11 +659,8 @@ IntersCurveCurve::CalcCurveInOrOut( const ICurve* pCurveA, const ICurve* pCurveB
 bool
 IntersCurveCurve::GetCurveOutClass( const ICurve* pCurve, int& nClass)
 {
-   PolyLine PL ;
-   if ( ! pCurve->ApproxWithLines( LIN_TOL_APPROX, ANG_TOL_APPROX_DEG, ICurve::APL_SPECIAL, PL))
-      return false ;
    double dArea ;
-   if ( ! PL.GetAreaXY( dArea))
+   if ( ! pCurve->GetAreaXY( dArea))
       return false ;
    nClass = (( dArea > 0) ? CRVC_OUT : CRVC_IN) ;
    return true ;

IntersCurveSurfTm.cpp

@@ -0,0 +1,223 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2024-2024
+//----------------------------------------------------------------------------
+// File : IntersCurveSurfTm.cpp      Data : 23.02.24        Versione : 2.6b4
+// Contenuto : Implementazione della intersezione curva/superficie trimesh.
+//
+//
+//
+// Modifiche : 23.02.24 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "GeoConst.h"
+#include "/EgtDev/Include/EGkIntersLineTria.h"
+#include "/EgtDev/Include/EGkIntersCurveSurfTm.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+static void
+UpdateInfoIntersCurveSurfTm( const Point3d& ptL, const Vector3d& vtDir, double dLen, double dUs, double dUe,
+                             int nT, const Triangle3d& Tria, ICSIVECTOR& vInfo)
+{
+   Point3d ptInt, ptInt2 ;
+   int nRes = IntersLineTria( ptL, vtDir, dLen, Tria, ptInt, ptInt2, true) ;
+   if ( nRes == ILTT_IN  ||  nRes == ILTT_EDGE  ||  nRes == ILTT_VERT) {
+      double dU = dUs + ( ptInt - ptL) * vtDir / dLen * ( dUe - dUs) ;
+      double dCosDN = vtDir * Tria.GetN() ;
+      vInfo.emplace_back( nRes, dU, nT, dCosDN, ptInt) ;
+   }
+   else if ( nRes == ILTT_SEGM  ||  nRes == ILTT_SEGM_ON_EDGE) {
+      double dU = dUs + ( ptInt - ptL) * vtDir / dLen * ( dUe - dUs) ;
+      double dU2 = dUs + ( ptInt2 - ptL) * vtDir / dLen * ( dUe - dUs) ;
+      double dCosDN = vtDir * Tria.GetN() ;
+      vInfo.emplace_back( nRes, dU, dU2, nT, dCosDN, ptInt, ptInt2) ;
+   }
+}
+
+//----------------------------------------------------------------------------
+static void
+OrderInfoIntersCurveSurfTm( ICSIVECTOR& vInfo)
+{
+  // se non trovati, esco 
+   if ( vInfo.size() == 0)
+      return ;
+  // ordino il vettore delle intersezioni secondo il senso crescente del parametro di linea
+   sort( vInfo.begin(), vInfo.end(), 
+            []( const IntCrvStmInfo& a, const IntCrvStmInfo& b)
+               {  double dUa = ( ( a.nILTT == ILTT_SEGM  ||  a.nILTT == ILTT_SEGM_ON_EDGE) ? ( a.dU + a.dU2) / 2 : a.dU) ;
+                  double dUb = ( ( b.nILTT == ILTT_SEGM  ||  b.nILTT == ILTT_SEGM_ON_EDGE) ? ( b.dU + b.dU2) / 2 : b.dU) ;
+                  return ( dUa < dUb) ; }) ;
+}
+
+//----------------------------------------------------------------------------
+//  Intersezione di una curva con una superficie TriMesh
+//----------------------------------------------------------------------------
+bool
+IntersCurveSurfTm( const ICurve& Curve, const ISurfTriMesh& Stm, double dLinTol, ICSIVECTOR& vInfo)
+{
+  // verifico i parametri ricevuti
+   if ( & Curve == nullptr  ||  &Stm == nullptr  ||  &vInfo == nullptr)
+      return false ;
+   dLinTol = max( dLinTol, EPS_SMALL) ;
+   vInfo.clear() ;
+
+  // approssimo la curva con una spezzata
+   PolyLine PL ;
+   if ( ! Curve.ApproxWithLines( dLinTol, ANG_TOL_APPROX_DEG, ICurve::APL_SPECIAL, PL))
+      return false ;
+
+  // per ogni segmento dell'approssimante cerco l'intersezione con la superficie
+   double dParS, dParE ;
+   Point3d ptStart, ptEnd ;
+   bool bFound = PL.GetFirstULine( &dParS, &ptStart, &dParE, &ptEnd) ;
+   while ( bFound) {
+      Vector3d vtDir = ptEnd - ptStart ;
+      double dLen = vtDir.Len() ;
+      if ( dLen > EPS_SMALL) {
+         vtDir /= dLen ;
+        // cerco i triangoli intersecati dal segmento
+         const double BOX_STEP = 10 ;
+         int nStep = int( ceil( dLen / BOX_STEP)) ;
+         Vector3d vtStep = dLen / nStep * vtDir ;
+         INTVECTOR vPrevT ;
+         for ( int i = 0 ; i < nStep ; ++ i) {
+            BBox3d b3Box( ptStart + i * vtStep, ptStart + ( i + 1) * vtStep) ;
+            INTVECTOR vT ;
+            if ( Stm.GetAllTriaOverlapBox( b3Box, vT)) {
+               for ( auto nT : vT) {
+                 // se triangolo non ancora intersecato
+                  if ( find( vPrevT.begin(), vPrevT.end(), nT) == vPrevT.end()) {
+                     vPrevT.emplace_back( nT) ;
+                     Triangle3d Tria ;
+                     Stm.GetTriangle( nT, Tria) ;
+                    // aggiorno info con intersezione
+                     UpdateInfoIntersCurveSurfTm( ptStart, vtDir, dLen, dParS, dParE, nT, Tria, vInfo) ;
+                  }
+               }
+            }
+         }
+      }
+     // passo al segmento successivo
+      bFound = PL.GetNextULine( &dParS, &ptStart, &dParE, &ptEnd) ;
+   }
+
+  // ordino il vettore delle eventuali intersezioni secondo il senso crescente del parametro di linea
+   OrderInfoIntersCurveSurfTm( vInfo) ;
+   
+   return true ;
+}
+//----------------------------------------------------------------------------
+bool
+IntersCurveSurfTmExt( const ICurve& Curve, const ISurfTriMesh& Stm, double dLinTol, INTDBLVECTOR& vInters)
+{
+   ICSIVECTOR vInfo ;
+   vInters.clear() ;
+   return ( IntersCurveSurfTm( Curve, Stm, dLinTol, vInfo)  &&  FilterCurveSurfTmInters( Curve, vInfo, vInters)) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+FilterCurveSurfTmInters( const ICurve& Curve, const ICSIVECTOR& vInfo, INTDBLVECTOR& vInters)
+{
+  // verifico i parametri ricevuti
+   if ( & Curve == nullptr  ||  &vInfo == nullptr  ||  &vInters == nullptr)
+      return false ;
+   vInters.clear() ;
+  // info sulla curva
+   bool bClosedCrv = Curve.IsClosed() ;
+   double dParSCrv, dParECrv ;
+   Curve.GetDomain( dParSCrv, dParECrv) ;
+   // ciclo sulle intersezioni
+   for ( const auto& Info : vInfo) {
+     // se intersezione puntuale
+      if ( Info.nILTT == ILTT_VERT  ||  Info.nILTT == ILTT_EDGE  ||  Info.nILTT == ILTT_IN) {
+         int nFlag = CSIT_NONE ;
+         if ( Info.dCosDN > EPS_ZERO)
+            nFlag = CSIT_IN_OUT ;
+         else if ( Info.dCosDN < -EPS_ZERO)
+            nFlag = CSIT_OUT_IN ;
+         vInters.emplace_back( nFlag, Info.dU) ;
+      }
+     // se altrimenti intersezione con coincidenza
+      else if ( Info.nILTT == ILTT_SEGM  ||  Info.nILTT == ILTT_SEGM_ON_EDGE) {
+         vInters.emplace_back( CSIT_IN_ON, Info.dU) ;
+         vInters.emplace_back( CSIT_ON_IN, Info.dU2) ;
+      }
+   }
+  // elimino intersezioni ripetute
+   int nStart = ( bClosedCrv ? 0 : 1) ;
+   for ( int j = nStart ; j < int( vInters.size()) ; ) {
+     // intersezione precedente
+      int i = ( j > 0 ? j - 1 : int( vInters.size()) - 1) ;
+     // se hanno lo stesso parametro 
+      if ( abs( vInters[i].second - vInters[j].second) < EPS_PARAM  ||
+           ( bClosedCrv  &&  abs( vInters[i].second - dParECrv) < EPS_PARAM  &&  abs( vInters[j].second - dParSCrv) < EPS_PARAM)) {
+        // flag per eseguita cancellazione
+         bool bSomeErased = false ;
+        // se sono entrambe entranti o uscenti, elimino la seconda
+         if ( ( vInters[i].first == CSIT_OUT_IN  &&  vInters[j].first == CSIT_OUT_IN)  ||
+              ( vInters[i].first == CSIT_IN_OUT  &&  vInters[j].first == CSIT_IN_OUT)) {
+            vInters.erase( vInters.begin() + j) ;
+            bSomeErased = true ;
+         }
+        // se una entrante e l'altra uscente, cambio in touch da fuori ed elimino la seconda
+         else if ( vInters[i].first == CSIT_OUT_IN  &&  vInters[j].first == CSIT_IN_OUT) {
+            vInters[i].first = CSIT_OUT_OUT ;
+            vInters.erase( vInters.begin() + j) ;
+            bSomeErased = true ;
+         }
+        // se una uscente e l'altra entrante, cambio in touch da dentro ed elimino la seconda
+         else if ( vInters[i].first == CSIT_IN_OUT  &&  vInters[j].first == CSIT_OUT_IN) {
+            vInters[i].first = CSIT_IN_IN ;
+            vInters.erase( vInters.begin() + j) ;
+            bSomeErased = true ;
+         }
+        // se una touch da fuori o da dentro e l'altra entrante o uscente, elimino la prima
+         else if ( ( vInters[i].first == CSIT_OUT_OUT  ||  vInters[i].first == CSIT_IN_IN)  &&
+                   ( vInters[j].first == CSIT_OUT_IN  ||  vInters[j].first == CSIT_IN_OUT)) {
+            vInters.erase( vInters.begin() + i) ;
+            bSomeErased = true ;
+         }
+        // se una entrante o uscente e l'altra touch da fuori o da dentro, elimino la seconda
+         else if ( ( vInters[i].first == CSIT_OUT_IN  ||  vInters[i].first == CSIT_IN_OUT)  &&
+                   ( vInters[j].first == CSIT_OUT_OUT  ||  vInters[j].first == CSIT_IN_IN)) {
+            vInters.erase( vInters.begin() + j) ;
+            bSomeErased = true ;
+         }
+        // se una puntuale e l'altra inizio di coincidenza, elimino la prima
+         else if ( ( vInters[i].first == CSIT_OUT_IN  ||  vInters[i].first == CSIT_IN_OUT  ||  vInters[i].first == CSIT_NONE)  &&
+                   ( vInters[j].first == CSIT_IN_ON  ||  vInters[j].first == CSIT_OUT_ON)) {
+            vInters[j].first = ( vInters[i].first == CSIT_IN_OUT ? CSIT_IN_ON : CSIT_OUT_ON) ;
+            vInters.erase( vInters.begin() + i) ;
+            bSomeErased = true ;
+         }
+        // se una fine di coincidenza e l'altra puntuale, elimino la seconda
+         else if ( ( vInters[i].first == CSIT_ON_IN  ||  vInters[i].first == CSIT_ON_OUT)  &&
+                   ( vInters[j].first == CSIT_OUT_IN  ||  vInters[j].first == CSIT_IN_OUT  ||  vInters[j].first == CSIT_NONE)) {
+            vInters[i].first = ( vInters[j].first == CSIT_IN_OUT ? CSIT_ON_OUT : CSIT_ON_IN) ;
+            vInters.erase( vInters.begin() + j) ;
+            bSomeErased = true ;
+         }
+        // se una fine di coincidenza e l'altra inizio di coincidenza, elimino entrambe
+         else if ( ( vInters[i].first == CSIT_ON_IN  ||  vInters[i].first == CSIT_ON_OUT)  &&
+                   ( vInters[j].first == CSIT_IN_ON  ||  vInters[j].first == CSIT_OUT_ON)) {
+            vInters.erase( vInters.begin() + j) ;
+            vInters.erase( vInters.begin() + ( j > 0 ? i : i - 1)) ;
+            bSomeErased = true ;
+         }
+         if ( bSomeErased) {
+            if ( j > 0)
+               -- j ;
+            continue ;
+         }
+      }
+     // passo alla successiva
+      ++ j ;
+   }
+   return true ;
+}

IntersLineBox.cpp

@@ -22,7 +22,7 @@ using namespace std ;
 
 //----------------------------------------------------------------------------
 // Linea e box allineato assi devono essere nel medesimo sistema di riferimento.
-// In caso di intersezione viene restituito true e i parametri in dU1 e dU2.
+// In caso di intersezione viene restituito true e i parametri lunghezza in dU1 e dU2.
 //----------------------------------------------------------------------------
 bool
 IntersLineBox( const Point3d& ptL, const Vector3d& vtL,

IntersLineBox.h

@@ -17,7 +17,7 @@
 
 //----------------------------------------------------------------------------
 // Linea e box allineato agli assi sono nel medesimo riferimento.
-// Con intersezione viene restituito true e i parametri in dU1 e dU2.
+// Con intersezione viene restituito true e i parametri lunghezza in dU1 e dU2.
 //----------------------------------------------------------------------------
 bool
 IntersLineBox( const Point3d& ptL, const Vector3d& vtL,

IntersLineCaps.cpp

@@ -0,0 +1,58 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2023-2023
+//----------------------------------------------------------------------------
+// File : IntersLineCaps.cpp        Data : 22.05.23          Versione : 2.5e3
+// Contenuto : Implementazione della intersezione linea/capsule.
+//
+//
+//
+// Modifiche : 22.05.23 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "IntersLineCaps.h"
+#include "DistLineLine.h"
+#include "/EgtDev/Include/EGkIntersLineSphere.h"
+
+using namespace std ;
+
+
+//----------------------------------------------------------------------------
+// Linea e capsule sono nel medesimo riferimento.
+// Il capsule è definito con centri delle due estremità, e raggio.
+// In caso di intersezione viene restituito true e i parametri in dU1 e dU2.
+//----------------------------------------------------------------------------
+bool
+IntersLineCaps( const Point3d& ptL, const Vector3d& vtL,
+                const Point3d& ptCaps1, const Point3d& ptCaps2, double dRad,
+                double& dU1, double& dU2) 
+{
+  // Determino versore e lunghezza asse Capsule
+   Vector3d vtCaps = ptCaps2 - ptCaps1 ;
+   double dLen = vtCaps.Len() ;
+   if ( dLen < EPS_SMALL) {
+      Point3d ptInt1, ptInt2 ;
+      if ( IntersLineSphere( ptL, vtL, Media( ptCaps1, ptCaps2), dRad, ptInt1, ptInt2) != ILST_SEC)
+         return false ;
+      dU1 = ( ptInt1 - ptL) * vtL ;
+      dU2 = ( ptInt2 - ptL) * vtL ;
+      return true ;
+   }
+   vtCaps /= dLen ;
+  // Distanza tra la linea e il segmento asse del capsule
+   DistLineLine dstLL( ptL, vtL, 1, ptCaps1, vtCaps, dLen, false, true) ;
+   double dSqDist ;
+   if ( dstLL.GetSqDist( dSqDist)  &&  dSqDist >= dRad * dRad)
+      return false ;
+  // Calcolo i punti di intersezione
+   Point3d ptRef, ptTmp ;
+   dstLL.GetMinDistPoints( ptRef, ptTmp) ;
+   double dSqDelta = dRad * dRad - dSqDist ;
+   double dDist = sqrt( dSqDelta) ;
+   dU1 = ( ptRef - ptL) * vtL - dDist ;
+   dU2 = dU1 + 2 * dDist ;
+   return true ;
+}

IntersLineCaps.h

@@ -0,0 +1,25 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2023-2023
+//----------------------------------------------------------------------------
+// File : IntersLineCaps.h         Data : 22.05.23         Versione : 2.5e4
+// Contenuto : Dichiarazione funzioni base per intersezione linea/capsule.
+//
+//
+//
+// Modifiche : 22.05.23 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkPoint3d.h"
+
+//----------------------------------------------------------------------------
+// Linea e capsule sono nel medesimo riferimento.
+// Il capsule è definito con centri delle due estremità, e raggio.
+// In caso di intersezione viene restituito true e i parametri in dU1 e dU2.
+//----------------------------------------------------------------------------
+bool IntersLineCaps( const Point3d& ptL, const Vector3d& vtL,
+                     const Point3d& ptCaps1, const Point3d& ptCaps2, double dRad,
+                     double& dU1, double& dU2) ;

IntersLineCone.cpp

@@ -0,0 +1,138 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2023-2023
+//----------------------------------------------------------------------------
+// File : IntersLineCone.cpp        Data : 16.05.23          Versione : 2.5e3
+// Contenuto : Implementazione della intersezione linea/tronco di cono.
+//
+//
+//
+// Modifiche : 16.05.23 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "IntersLineCone.h"
+#include "IntersLineCyl.h"
+#include "/EgtDev/Include/ENkPolynomialRoots.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+// Linea e tronco di cono sono nel medesimo riferimento.
+// Il tronco di cono è centrato sull'asse Z e appoggiato con RMin sul piano XY.
+// In caso di intersezione viene restituito true e i parametri in dU1 e dU2.
+//----------------------------------------------------------------------------
+bool
+IntersLineCone( const Point3d& ptL, const Vector3d& vtL,
+                double dRadMin, double dRadMax, double dHeight,
+                double& dU1, double& dU2)
+{
+  // Verifico il versore
+   if ( vtL.IsSmall())
+      return false ;
+
+  // Verifico il tronco di cono
+   if ( ( dRadMin < EPS_SMALL  &&  dRadMax < EPS_SMALL)  ||  dHeight < EPS_SMALL)
+      return false ;
+
+  // Se è un cilindro, rimando a questo
+   if ( abs( dRadMax - dRadMin) < EPS_SMALL)
+      return IntersLineCyl( ptL, vtL, ( dRadMin + dRadMax) / 2, dHeight, dU1, dU2) ;
+
+  // Se raggi invertiti, li scambio
+   if ( dRadMin > dRadMax)
+      swap( dRadMin, dRadMax) ;
+
+   // Tangente dell'angolo di semi-apertura del cono
+   double dTanTheta = ( dRadMax - dRadMin) / dHeight ;
+   double dSqTanTheta = dTanTheta * dTanTheta ;
+   double dSqCosTheta = 1 / ( 1 + dSqTanTheta) ;
+
+   // Determino le eventuali intersezioni con le due basi a quota minima e massima (solo se linea non giace sul cono)
+   int nBasInt = 0 ;
+   if ( abs( vtL.z) > EPS_ZERO) {
+     // le linee tangenti al cono non sono considerate intersecanti
+      bool bSameHAng = ( abs( abs( vtL.x) - abs( vtL.y)) < EPS_SMALL  &&  abs( dSqCosTheta - vtL.z * vtL.z) < 2 * abs( vtL.z) * EPS_SMALL) ;
+      double EpsRad = ( bSameHAng ? - EPS_SMALL : EPS_SMALL) ;
+      Point3d ptInt1 = ptL + ( ( 0 - ptL.z) / vtL.z) * vtL ;
+      if ( ptInt1.x * ptInt1.x + ptInt1.y * ptInt1.y < dRadMin * dRadMin + 2 * dRadMin * EpsRad) {
+         dU1 = ( ptInt1 - ptL) * vtL ;
+         nBasInt += 1 ;
+      }
+      Point3d ptInt2 = ptL + ( ( dHeight - ptL.z) / vtL.z) * vtL ;  
+      if ( ptInt2.x * ptInt2.x + ptInt2.y * ptInt2.y < dRadMax * dRadMax + 2 * dRadMax * EpsRad) {
+         dU2 = ( ptInt2 - ptL) * vtL ;
+         nBasInt += 2 ;
+      }
+   }
+
+  // Se la linea interseca entrambe le basi, si sono trovate le due intersezioni
+   if ( nBasInt == 3) {
+      if ( dU1 > dU2)
+         swap( dU1, dU2) ;
+     // Trovate intersezioni
+      return true ;
+   }
+
+  // Posizione del vertice del cono
+   double dDeltaH = ( dRadMin < EPS_SMALL ? 0 : dRadMin / dTanTheta) ;
+  // Sposto il punto di passaggio della linea di conseguenza
+   Point3d ptMyL = ptL + Z_AX * dDeltaH ;
+   
+  // Determino le intersezioni con la superficie laterale del cono
+   DBLVECTOR vdCoeff{ ptMyL.x * ptMyL.x + ptMyL.y * ptMyL.y - ptMyL.z * ptMyL.z * dSqTanTheta,
+                      2 * ( ptMyL.x * vtL.x + ptMyL.y * vtL.y - ptMyL.z * vtL.z * dSqTanTheta),
+                      vtL.x * vtL.x + vtL.y * vtL.y - vtL.z * vtL.z * dSqTanTheta} ;
+   DBLVECTOR vdRoots ;
+   int nRoot = PolynomialRoots( 2, vdCoeff, vdRoots) ;
+
+  // Elimino le soluzioni cha danno intersezioni fuori dai limiti in Z del tronco di cono
+   if ( nRoot == 2) {
+      double dIntZ2 = ptL.z + vdRoots[1] * vtL.z ;
+      if ( dIntZ2 < 0 - EPS_SMALL  ||  dIntZ2 > dHeight + EPS_SMALL)
+         -- nRoot ;
+   }
+   if ( nRoot >= 1) {
+      double dIntZ1 = ptL.z + vdRoots[0] * vtL.z ;
+      if ( dIntZ1 < 0 - EPS_SMALL  ||  dIntZ1 > dHeight + EPS_SMALL) {
+         if ( nRoot == 2)
+            vdRoots[0] = vdRoots[1] ;
+         -- nRoot ;
+      }
+   }
+
+  // Due soluzioni: la retta interseca due volte la superficie laterale
+   if ( nRoot == 2) {
+      dU1 = vdRoots[0] ;
+      dU2 = vdRoots[1] ;
+      if ( dU1 > dU2)
+         swap( dU1, dU2) ;
+     // Trovate intersezioni
+      return true ;
+   }
+   
+  // Una soluzione : la retta interseca la superficie laterale e un piano
+   else if ( nRoot == 1) {
+     // Se piano superiore
+      if ( nBasInt == 2) {
+         dU1 = vdRoots[0] ;
+      }
+     // altrimenti piano inferiore
+      else if ( nBasInt == 1) {
+         dU2 = vdRoots[0] ;
+      }
+     // altrimenti niente
+      else
+         return false ;
+      if ( dU1 > dU2)
+         swap( dU1, dU2) ;
+     // Trovate intersezioni
+      return true ;
+   }
+
+  // Nessuna soluzione : nessuna intersezione 
+   else
+      return false ;
+}

IntersLineCone.h

@@ -0,0 +1,35 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2023-2023
+//----------------------------------------------------------------------------
+// File : IntersLineCone.h         Data : 16.05.23         Versione : 2.5e3
+// Contenuto : Dichiarazione funzioni base per intersezione linea/cono tronco.
+//
+//
+//
+// Modifiche : 16.05.23 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkPoint3d.h"
+
+//----------------------------------------------------------------------------
+// Linea e tronco di cono sono nel medesimo riferimento.
+// Il tronco di cono è centrato sull'asse Z e appoggiato con RMin sul piano XY.
+// Con intersezione viene restituito true e i parametri in dU1 e dU2.
+//----------------------------------------------------------------------------
+bool
+IntersLineCone( const Point3d& ptL, const Vector3d& vtL,
+                double dRadMin, double dRadMax, double dHeight,
+                double& dU1, double& dU2) ;
+
+//----------------------------------------------------------------------------
+inline bool
+TestIntersLineCone( const Point3d& ptL, const Vector3d& vtL,
+                    double dRadMin, double dRadMax, double dHeight)
+{
+   double dU1, dU2 ;
+   return IntersLineCone( ptL, vtL, dRadMin, dRadMax, dHeight, dU1, dU2) ;
+}

IntersLineCyl.cpp

@@ -0,0 +1,161 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2023-2023
+//----------------------------------------------------------------------------
+// File : IntersLineCyl.cpp        Data : 16.05.23          Versione : 2.5e3
+// Contenuto : Implementazione della intersezione linea/cilindro.
+//
+//
+//
+// Modifiche : 16.05.23 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "IntersLineCyl.h"
+#include "/EgtDev/Include/EGkFrame3d.h"
+#include "/EgtDev/Include/ENkPolynomialRoots.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+// Linea e cilindro sono nel medesimo riferimento.
+// Il cilindro è centrato sull'asse Z e appoggiato sul piano XY.
+// In caso di intersezione viene restituito true e i parametri in dU1 e dU2.
+//----------------------------------------------------------------------------
+bool
+IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
+               double dRad, double dHeight,
+               double& dU1, double& dU2)
+{
+  // Verifico il versore
+   if ( vtL.IsSmall())
+      return false ;
+
+  // Verifico il cilindro
+   if ( dRad < EPS_SMALL  ||  dHeight < EPS_SMALL)
+      return false ;
+
+  // Determino le eventuali intersezioni con le due basi a quota minima e massima (solo se linea non parallela ad esse)
+   int nBasInt = 0 ;
+   if ( abs( vtL.z) > EPS_ZERO) {
+      // le linee tangenti al cilindro non sono considerate intersecanti
+      double EpsRad = ( vtL.IsZeroXY() ? - EPS_SMALL : EPS_SMALL) ;
+      Point3d ptInt1 = ptL + ( ( 0 - ptL.z) / vtL.z) * vtL ;
+      if ( ptInt1.x * ptInt1.x + ptInt1.y * ptInt1.y < dRad * dRad + 2 * dRad * EpsRad) {
+         dU1 = ( ptInt1 - ptL) * vtL ;
+         nBasInt += 1 ;
+      }
+      Point3d ptInt2 = ptL + ( ( dHeight - ptL.z) / vtL.z) * vtL ;  
+      if ( ptInt2.x * ptInt2.x + ptInt2.y * ptInt2.y < dRad * dRad + 2 * dRad * EpsRad) {
+         dU2 = ( ptInt2 - ptL) * vtL ;
+         nBasInt += 2 ;
+      }
+   }
+
+  // Se la linea interseca entrambe le basi, si sono trovate le due intersezioni
+   if ( nBasInt == 3) {
+      if ( dU1 > dU2)
+         swap( dU1, dU2) ;
+     // Trovate intersezioni
+      return true ;
+   }
+   
+  // Determino le intersezioni con la superficie laterale del cilindro
+   DBLVECTOR vdCoeff{ ptL.x * ptL.x + ptL.y * ptL.y - dRad * dRad,
+                      2 * ( ptL.x * vtL.x + ptL.y * vtL.y),
+                      vtL.x * vtL.x + vtL.y * vtL.y} ;
+   DBLVECTOR vdRoots ;
+   int nRoot = PolynomialRoots( 2, vdCoeff, vdRoots) ;
+
+  // Elimino le soluzioni cha danno intersezioni fuori dai limiti in Z del cilindro
+   if ( nRoot == 2) {
+      double dIntZ2 = ptL.z + vdRoots[1] * vtL.z ;
+      if ( dIntZ2 < 0 - EPS_SMALL  ||  dIntZ2 > dHeight + EPS_SMALL)
+         -- nRoot ;
+   }
+   if ( nRoot >= 1) {
+      double dIntZ1 = ptL.z + vdRoots[0] * vtL.z ;
+      if ( dIntZ1 < 0 - EPS_SMALL  ||  dIntZ1 > dHeight + EPS_SMALL) {
+         if ( nRoot == 2)
+            vdRoots[0] = vdRoots[1] ;
+         -- nRoot ;
+      }
+   }
+
+  // Due soluzioni: la retta interseca due volte la superficie laterale
+   if ( nRoot == 2) {
+      dU1 = vdRoots[0] ;
+      dU2 = vdRoots[1] ;
+      if ( dU1 > dU2)
+         swap( dU1, dU2) ;
+     // Trovate intersezioni
+      return true ;
+   }
+   
+  // Una soluzione : la retta interseca la superficie laterale e un piano
+   else if ( nRoot == 1) {
+     // Se piano superiore
+      if ( nBasInt == 2) {
+         dU1 = vdRoots[0] ;
+      }
+     // altrimenti piano inferiore
+      else if ( nBasInt == 1) {
+         dU2 = vdRoots[0] ;
+      }
+     // altrimenti niente
+      else
+         return false ;
+      if ( dU1 > dU2)
+         swap( dU1, dU2) ;
+     // Trovate intersezioni
+      return true ;
+   }
+
+  // Nessuna soluzione : nessuna intersezione 
+   else
+      return false ;
+}
+
+//----------------------------------------------------------------------------
+// Linea e cilindro sono nel medesimo riferimento.
+// Il cilindro è definito con centro della base, asse, raggio e altezza.
+// In caso di intersezione viene restituito true e i parametri in dU1 e dU2.
+//----------------------------------------------------------------------------
+bool
+IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
+               const Point3d& ptCyl, const Vector3d& vtCyl, double dRad, double dHeight,
+               double& dU1, double& dU2) 
+{
+  // Riferimento intrinseco del cilindro
+   Frame3d frCyl ;
+   if ( ! frCyl.Set( ptCyl, vtCyl))
+      return false ;
+  // Ora eseguo i conti nel riferimento intrinseco
+   return IntersLineCyl( GetToLoc( ptL, frCyl), GetToLoc( vtL, frCyl), dRad, dHeight, dU1, dU2) ;
+}
+
+//----------------------------------------------------------------------------
+// Linea e cilindro sono nel medesimo riferimento.
+// Il cilindro è definito con centri delle due basi, e raggio.
+// In caso di intersezione viene restituito true e i parametri in dU1 e dU2.
+//----------------------------------------------------------------------------
+bool
+IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
+               const Point3d& ptCyl1, const Point3d& ptCyl2, double dRad,
+               double& dU1, double& dU2) 
+{
+  // Determino asse ed altezza del cilindro
+   Vector3d vtCyl = ptCyl2 - ptCyl1 ;
+   double dHeight = vtCyl.Len() ;
+   if ( dHeight < EPS_SMALL)
+      return false ;
+   vtCyl /= dHeight ;
+  // Riferimento intrinseco del cilindro
+   Frame3d frCyl ;
+   if ( ! frCyl.Set( ptCyl1, vtCyl))
+      return false ;
+  // Ora eseguo i conti nel riferimento intrinseco
+   return IntersLineCyl( GetToLoc( ptL, frCyl), GetToLoc( vtL, frCyl), dRad, dHeight, dU1, dU2) ;
+}

IntersLineCyl.h

@@ -0,0 +1,52 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2023-2023
+//----------------------------------------------------------------------------
+// File : IntersLineCyl.h         Data : 16.05.23         Versione : 2.5e3
+// Contenuto : Dichiarazione funzioni base per intersezione linea/cilindro.
+//
+//
+//
+// Modifiche : 16.05.23 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "/EgtDev/Include/EGkPoint3d.h"
+
+//----------------------------------------------------------------------------
+// Linea e cilindro sono nel medesimo riferimento.
+// Il cilindro è centrato sull'asse Z e appoggiato sul piano XY.
+// Con intersezione viene restituito true e i parametri in dU1 e dU2.
+//----------------------------------------------------------------------------
+bool IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
+                    double dRad, double dHeight,
+                    double& dU1, double& dU2) ;
+
+//----------------------------------------------------------------------------
+inline bool
+TestIntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
+                   double dRad, double dHeight)
+{
+   double dU1, dU2 ;
+   return IntersLineCyl( ptL, vtL, dRad, dHeight, dU1, dU2) ;
+}
+
+//----------------------------------------------------------------------------
+// Linea e cilindro sono nel medesimo riferimento.
+// Il cilindro è definito con centro della base, asse raggio e altezza.
+// In caso di intersezione viene restituito true e i parametri in dU1 e dU2.
+//----------------------------------------------------------------------------
+bool IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
+                    const Point3d& ptCyl, const Vector3d& vtCyl, double dRad, double dHeight,
+                    double& dU1, double& dU2) ;
+
+//----------------------------------------------------------------------------
+// Linea e cilindro sono nel medesimo riferimento.
+// Il cilindro è definito con centri delle due basi, e raggio.
+// In caso di intersezione viene restituito true e i parametri in dU1 e dU2.
+//----------------------------------------------------------------------------
+bool IntersLineCyl( const Point3d& ptL, const Vector3d& vtL,
+                    const Point3d& ptCyl1, const Point3d& ptCyl2, double dRad,
+                    double& dU1, double& dU2) ;

IntersLineLine.cpp

@@ -66,7 +66,7 @@ IntersLineLine::IntersInfiniteLines( const ICurveLine& Line1, const ICurveLine&
    double dLen1XY = vtDir1.LenXY() ;
    if ( dLen1XY < EPS_SMALL)
       return ;
-  // linea 2 : Start, Direzione e Lunghezza
+  // linea 2 : Start, End, Direzione e Lunghezza
    Point3d ptS2 = Line2.GetStart() ;
    Point3d ptE2 = Line2.GetEnd() ;
    Vector3d vtDir2 = ptE2 - ptS2 ;

IntersLineSphere.cpp

@@ -26,20 +26,25 @@ IntersLineSphere( const Point3d& ptL, const Vector3d& vtL, const Point3d& ptCen,
       return ILST_NO ;
   // Proiezione del centro della sfera sulla linea
    Point3d ptP = ptL + (( ptCen - ptL) * vtL) * vtL ;
-  // Distanza di questo punto di proiezione dal centro della sfera
-   double dDist = Dist( ptCen, ptP) ;
+  // Quadrato della distanza di questo punto di proiezione dal centro della sfera
+   double dSqDist = SqDist( ptCen, ptP) ;
+  // Differenza tra quadrato del raggio e quadrato della distanza 
+   double dSqDelta = dRad * dRad - dSqDist ;
+
+  // Se distanza superiore al raggio, nessuna intersezione
+   if ( dSqDelta < - 2 * dRad * EPS_SMALL)
+      return ILST_NO ;
+
   // Se distanza uguale al raggio, intersezione tangente
-   if ( abs( dDist - dRad) < EPS_SMALL) {
+   if ( dSqDelta < EPS_SMALL * EPS_SMALL) {
       ptI1 = ptP ;
       ptI2 = ptP ;
       return ILST_TG ;
    }
-  // Se distanza superiore al raggio, nessuna intersezione
-   if ( dDist > dRad)
-      return ILST_NO ;
+
   // Distanza inferiore al raggio, due intersezioni secanti
-   double dDist2 = sqrt( dRad * dRad - dDist * dDist) ;
+   double dDist2 = sqrt( dSqDelta) ;
    ptI1 = ptP - dDist2 * vtL ;
    ptI2 = ptP + dDist2 * vtL ;
    return ILST_SEC ;
-}
+}