EgtGeomKernel :

- correzione nell'aggiunta di curve a CurveComposite (gestito caso di altra curva che va trasformata in segmento di retta).

CurveComposite.cpp

@@ -224,8 +224,11 @@ CurveComposite::AddSimpleCurve( ICurve* pSmplCrv, bool bEndOrStart, double dLinT
               // lunghezza della curva originale
                double dOldLen ; pCrv->GetLength( dOldLen) ;
               // eseguo modifica
-               if ( ! pCrv->ModifyStart( ptEnd))
-                  return false ;
+               if ( ! pCrv->ModifyStart( ptEnd)) {
+                  CurveLine crvLine ;
+                  if ( ! crvLine.Set( ptEnd, ptCrvEnd)  ||  ! pCrv.Set( crvLine.Clone()))
+                     return false ;
+               }
               // verifico che la lunghezza non sia variata troppo
                double dNewLen ; pCrv->GetLength( dNewLen) ;
                if ( abs( dNewLen - dOldLen) > 10 * dLinTol)
@@ -246,8 +249,11 @@ CurveComposite::AddSimpleCurve( ICurve* pSmplCrv, bool bEndOrStart, double dLinT
               // lunghezza della curva originale
                double dOldLen ; pCrv->GetLength( dOldLen) ;
               // eseguo modifica
-               if ( ! pCrv->ModifyEnd( ptStart))
-                  return false ;
+               if ( ! pCrv->ModifyEnd( ptStart)) {
+                  CurveLine crvLine ;
+                  if ( ! crvLine.Set( ptCrvStart, ptStart)  ||  ! pCrv.Set( crvLine.Clone()))
+                     return false ;
+               }
               // verifico che la lunghezza non sia variata troppo
                double dNewLen ; pCrv->GetLength( dNewLen) ;
                if ( abs( dNewLen - dOldLen) > 10 * dLinTol)

Voronoi.cpp

@@ -25,7 +25,7 @@
 using namespace std ;
 
 //----------------------------------------------------------------------------
-Voronoi::Voronoi( const ICurve* pCrv, bool bAllowAdd) 
+Voronoi::Voronoi( const ICurve* pCrv, bool bAllowAdd)
    : m_vroni( nullptr), m_nBound( VORONOI_STD_BOUND), m_bVDComputed( false), m_bAllowAdd( true)
 {
   // tento di aggiungere la curva 
@@ -35,7 +35,7 @@ Voronoi::Voronoi( const ICurve* pCrv, bool bAllowAdd)
 }
 
 //----------------------------------------------------------------------------
-Voronoi::Voronoi( const ISurfFlatRegion* pSfr, bool bAllowAdd) 
+Voronoi::Voronoi( const ISurfFlatRegion* pSfr, bool bAllowAdd)
    : m_vroni( nullptr), m_nBound( VORONOI_STD_BOUND), m_bVDComputed( false), m_bAllowAdd( true)
 {
   // tento di aggiungere la superficie
@@ -45,16 +45,16 @@ Voronoi::Voronoi( const ISurfFlatRegion* pSfr, bool bAllowAdd)
 }
 
 //----------------------------------------------------------------------------
-Voronoi::~Voronoi( void)   
+Voronoi::~Voronoi( void)
 {
    Clear() ;
 }
 
 //----------------------------------------------------------------------------
 bool 
-Voronoi::Clear( void) 
+Voronoi::Clear( void)
 {
-  // pulizia oggetto vroni 
+  // pulizia oggetto vroni
    if ( m_vroni != nullptr)
       delete m_vroni ;
    m_vroni = nullptr ;
@@ -72,7 +72,7 @@ Voronoi::Clear( void)
 
 //----------------------------------------------------------------------------
 bool
-Voronoi::AddCurve( const ICurve* pCrv) 
+Voronoi::AddCurve( const ICurve* pCrv)
 {
    if ( ! m_bAllowAdd)
       return false ;
@@ -99,21 +99,21 @@ Voronoi::AddCurve( const ICurve* pCrv)
       if ( ! vtExtr.IsSmall())
          plPlane.Set( ptS, vtExtr) ;
       else
-         plPlane.Set( ptS, Z_AX) ;   
+         plPlane.Set( ptS, Z_AX) ;
    }
    else {
       if ( ! pCrv->IsFlat( plPlane, false, 10 * EPS_SMALL))
-         return false ;   
-   }  
-  
+         return false ;
+   }
+
    if ( m_vpCrvs.empty()) {
      // se prima curva considerata assegno il frame al Voronoi
-      m_Frame.Set( plPlane.GetPoint(), plPlane.GetVersN()) ; 
+      m_Frame.Set( plPlane.GetPoint(), plPlane.GetVersN()) ;
    }
    else {
      // altrimenti verifico sia complanare ad eventuali curve già presenti
       if ( ! AreSameOrOppositeVectorApprox( m_Frame.VersZ(), plPlane.GetVersN())  ||  ! PointInPlaneApprox( m_Frame.Orig(), plPlane))
-         return false ;  
+         return false ;
    }
 
   // creo una copia della curva e la porto in locale
@@ -128,8 +128,8 @@ Voronoi::AddCurve( const ICurve* pCrv)
          m_vroni = new( nothrow) vroniObject() ;
          if ( m_vroni == nullptr)
             return false ;
-         m_vroni->apiInitializeProgram() ;   
-      }    
+         m_vroni->apiInitializeProgram() ;
+      }
 
      // aggiungo la curva in locale all'oggetto vroni
       if ( ! AddCurveToVroni( pCrvLoc))
@@ -144,61 +144,61 @@ Voronoi::AddCurve( const ICurve* pCrv)
    BBox3d bBox ;
    pCrvLoc->GetLocalBBox( bBox) ;
    m_bBox.Add( bBox) ;
- 
+
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-Voronoi::AddSurfFlatRegion( const ISurfFlatRegion* pSfr) 
+Voronoi::AddSurfFlatRegion( const ISurfFlatRegion* pSfr)
 {
    if ( ! m_bAllowAdd)
       return false ;
 
    if ( pSfr == nullptr)
       return false ;
- 
+
   // recupero il piano
    Point3d ptCen ; pSfr->GetCentroid( ptCen) ;
-   Vector3d vtN = pSfr->GetNormVersor() ; 
+   Vector3d vtN = pSfr->GetNormVersor() ;
    if ( m_vpCrvs.empty()) {
      // assegno il frame al Voronoi
-      m_Frame.Set( ptCen, vtN) ;   
+      m_Frame.Set( ptCen, vtN) ;
    }
    else {
      // verifico sia complanare ad eventuali curve già presenti
       Plane3d plPlane ;
       plPlane.Set( ptCen, pSfr->GetNormVersor()) ;
       if ( ! AreSameOrOppositeVectorApprox( m_Frame.VersZ(), pSfr->GetNormVersor())  ||  ! PointInPlaneApprox( m_Frame.Orig(), plPlane))
-         return false ;  
+         return false ;
    }
- 
+
    try {
      // verifico se oggetto vroni è stato inizializzato
       if ( m_vroni == nullptr) {
          m_vroni = new( nothrow) vroniObject() ;
          if ( m_vroni == nullptr)
             return false ;
-         m_vroni->apiInitializeProgram() ;   
+         m_vroni->apiInitializeProgram() ;
       }
-     
+
      // aggiungo le curve di loop
       for ( int i = 0 ; i < pSfr->GetChunkCount() ; i ++) {
          for ( int j = 0 ; j < pSfr->GetLoopCount( i) ; j ++) {
             PtrOwner<ICurve> pCrvLoc( pSfr->GetLoop( i, j)) ;
             if ( IsNull( pCrvLoc))
                return false ;
-            pCrvLoc->ToLoc( m_Frame) ;         
+            pCrvLoc->ToLoc( m_Frame) ;
             if ( ! AddCurveToVroni( pCrvLoc))
                return false ;
-         }      
+         }
       }
    }
    catch (...) {
       LOG_ERROR( GetEGkLogger(), m_vroni->GetExceptionMessage())
       return false ;
    }
-  
+
   // aggiorno il box complessivo
    BBox3d bBox ;
    Frame3d frSrf = m_Frame ;
@@ -211,16 +211,16 @@ Voronoi::AddSurfFlatRegion( const ISurfFlatRegion* pSfr)
 
 //----------------------------------------------------------------------------
 bool
-Voronoi::AddCurveToVroni( const ICurve* pCrv) 
+Voronoi::AddCurveToVroni( const ICurve* pCrv)
 {
    int nLoopId = m_vpCrvs.size() ;
 
   // aggiungo il punto iniziale
-   Point3d ptStart ; 
+   Point3d ptStart ;
    if ( ! pCrv->GetStartPoint( ptStart))
       return false ;
    int nCrv = m_vroni->HandlePnt( ptStart.x, ptStart.y, {nLoopId, 0}) ;
-   
+
   // aggiungo la parte rimanente della curva
    switch ( pCrv->GetType()) {
    case CRV_LINE :
@@ -229,7 +229,7 @@ Voronoi::AddCurveToVroni( const ICurve* pCrv)
    case CRV_ARC :
       m_vpCrvs.emplace_back( pCrv->Clone()) ;
       return AddArcToVroni( GetCurveArc( pCrv), nCrv, nLoopId) ;
-   case CRV_COMPO :    
+   case CRV_COMPO :
       return AddCompoToVroni( GetCurveComposite( pCrv), nCrv, nLoopId) ;
    case CRV_BEZIER :
       return AddBezierToVroni( GetCurveBezier( pCrv), nCrv, nLoopId) ;
@@ -242,7 +242,7 @@ Voronoi::AddCurveToVroni( const ICurve* pCrv)
 
 //----------------------------------------------------------------------------
 bool
-Voronoi::AddLineToVroni( const ICurveLine* pLine, int& nVroniCrv, int nLoopId, int nCrvId, Point3d ptEnd) 
+Voronoi::AddLineToVroni( const ICurveLine* pLine, int& nVroniCrv, int nLoopId, int nCrvId, Point3d ptEnd)
 {
    if ( pLine == nullptr)
       return false ;
@@ -250,7 +250,7 @@ Voronoi::AddLineToVroni( const ICurveLine* pLine, int& nVroniCrv, int nLoopId, i
   // verifico se il punto finale viene forzato oppure deve essere ricavato dalla pLine
    if ( ! ptEnd.IsValid()) {
       if ( ! pLine->GetEndPoint( ptEnd))
-         return false ; 
+         return false ;
    }
 
    m_vroni->AddSeg( &nVroniCrv, ptEnd.x, ptEnd.y, {nLoopId, nCrvId}) ;
@@ -259,7 +259,7 @@ Voronoi::AddLineToVroni( const ICurveLine* pLine, int& nVroniCrv, int nLoopId, i
 
 //----------------------------------------------------------------------------
 bool
-Voronoi::AddArcToVroni( const ICurveArc* pArc, int& nVroniCrv, int nLoopId, int nCrvId, Point3d ptEnd) 
+Voronoi::AddArcToVroni( const ICurveArc* pArc, int& nVroniCrv, int nLoopId, int nCrvId, Point3d ptEnd)
 {
    if ( pArc == nullptr)
       return false ;
@@ -285,7 +285,7 @@ Voronoi::AddArcToVroni( const ICurveArc* pArc, int& nVroniCrv, int nLoopId, int
      // verifico se il punto finale viene forzato oppure deve essere ricavato dal pArc
       if ( ! ptEnd.IsValid()) {
          if ( ! pArc->GetEndPoint( ptEnd))
-            return false ; 
+            return false ;
       }
       m_vroni->AddArc( &nVroniCrv, ptEnd.x, ptEnd.y, ptCen.x, ptCen.y, nArcSiteType, {nLoopId, nCrvId}) ;
    }
@@ -295,7 +295,7 @@ Voronoi::AddArcToVroni( const ICurveArc* pArc, int& nVroniCrv, int nLoopId, int
 
 //----------------------------------------------------------------------------
 bool
-Voronoi::AddCompoToVroni( const ICurveComposite* pCompo, int& nVroniCrv, int nLoopId) 
+Voronoi::AddCompoToVroni( const ICurveComposite* pCompo, int& nVroniCrv, int nLoopId)
 {
    if ( pCompo == nullptr)
       return false ;
@@ -315,18 +315,18 @@ Voronoi::AddCompoToVroni( const ICurveComposite* pCompo, int& nVroniCrv, int nLo
    bool bClosed = pCopy->IsClosed() ;
    for ( int i = 0 ; i < pCopy->GetCurveCount() ; i++) {
       Point3d ptForcedEnd = P_INVALID ;
-   
+
      // se curva è chiusa, forzo l'end point a coincidere con lo start ( per le tolleranze di vroni)
       if ( i == pCopy->GetCurveCount() - 1  &&  bClosed)
          pCompo->GetStartPoint( ptForcedEnd) ;
-   
+
      // aggiungo
       const ICurve* pCrv = pCopy->GetCurve( i) ;
       int nType = pCrv->GetType() ;
       if ( nType == CRV_LINE)
          AddLineToVroni( GetCurveLine( pCrv), nVroniCrv, nLoopId, i, ptForcedEnd) ;
       else if ( nType == CRV_ARC) 
-         AddArcToVroni( GetCurveArc( pCrv), nVroniCrv, nLoopId, i, ptForcedEnd) ;        
+         AddArcToVroni( GetCurveArc( pCrv), nVroniCrv, nLoopId, i, ptForcedEnd) ;
    }
 
   // aggiungo al vettore di curve
@@ -341,7 +341,7 @@ Voronoi::AddBezierToVroni( const ICurveBezier* pBezier, int& nVroniCrv, int nLoo
 {
    if ( pBezier == nullptr)
       return false ;
- 
+
   // riconduco al caso di curva composita
    PtrOwner<CurveComposite> pCompo( CreateBasicCurveComposite()) ;
    if ( IsNull( pCompo))
@@ -352,28 +352,28 @@ Voronoi::AddBezierToVroni( const ICurveBezier* pBezier, int& nVroniCrv, int nLoo
 
    Vector3d vtExtr ; pBezier->GetExtrusion( vtExtr) ;
    pCompo->SetExtrusion( vtExtr) ;
- 
+
    return AddCompoToVroni( pCompo, nVroniCrv, nLoopId) ;
 }
 
 //----------------------------------------------------------------------------
-ICurve* 
+ICurve*
 Voronoi::GetCurve( int nId) const
 {
   // verifico validità indice
    if ( nId < 0  ||  nId > ( int)m_vpCrvs.size() - 1)
-      return nullptr ; 
+      return nullptr ;
   // ne faccio una copia
    ICurve* pCrv = m_vpCrvs[nId]->Clone() ;
    if ( pCrv == nullptr)
-      return nullptr ; 
+      return nullptr ;
   // la porto nel riferimento globale
    pCrv->ToGlob( m_Frame) ;
    return pCrv ;
 }
 
 //----------------------------------------------------------------------------
-bool 
+bool
 Voronoi::GetVroniPlane( Plane3d& plPlane) const
 {
    if ( ! IsValid())
@@ -383,13 +383,13 @@ Voronoi::GetVroniPlane( Plane3d& plPlane) const
 }
 
 //----------------------------------------------------------------------------
-bool 
+bool
 Voronoi::CalcVoronoi( int nBound)
-{ 
+{
   // se già stato calcolato con lo stesso bound non devo fare nulla
    if ( m_bVDComputed  &&  nBound == m_nBound)
       return true ;
- 
+
   // se già stato calcolato reset dei dati
    if ( m_bVDComputed)
       m_vroni->ResetVoronoiDiagram() ;
@@ -398,9 +398,9 @@ Voronoi::CalcVoronoi( int nBound)
    m_nBound = max( nBound, VORONOI_STD_BOUND) ;
 
   // calcolo
-   m_bVDComputed = true ; 
+   m_bVDComputed = true ;
    string sTmp = "" ;
-   m_vroni->apiComputeVD( false, true, false, m_nBound, 0, 0, &sTmp[0], false, false, false, &sTmp[0], true) ;  
+   m_vroni->apiComputeVD( false, true, false, m_nBound, 0, 0, &sTmp[0], false, false, false, &sTmp[0], true) ;
 
    return true ;
 }
@@ -416,7 +416,7 @@ Voronoi::GetBisectorCurve( int i)
    int nType = m_vroni->GetBisectorType( i) ;
 
   // linea
-   if ( nType == BisectorType::LINE) {     
+   if ( nType == BisectorType::LINE) {
      // recupero i dati del bisettore da vroni
       Point3d ptS, ptE ;
       double dParS, dParE ;
@@ -434,7 +434,7 @@ Voronoi::GetBisectorCurve( int i)
       pLine->SetTempParam( dParS, 0) ;
       pLine->SetTempParam( dParE, 1) ;
       pLine->ToGlob( m_Frame) ;
-      return pLine ;  
+      return pLine ;
    }
 
   // degenerate hyperellipse ( arco)
@@ -454,20 +454,20 @@ Voronoi::GetBisectorCurve( int i)
       pArc->SetTempParam( dParS, 0) ;
       pArc->SetTempParam( dParS, 1) ; // dParE = dParS
       pArc->ToGlob( m_Frame) ;
-      return pArc ;   
+      return pArc ;
    }
- 
+
   // bisettore generico
    else if ( nType != BisectorType::NONE) {
      // approssimo linearmente il bisettore
       int nPoints = m_vroni->GetApproxedBisectorPointsNbr( i) ;
       if ( nPoints < 2)
          return nullptr ;
-      
+
       CurveComposite* pCompo = CreateBasicCurveComposite() ;
       if ( pCompo == nullptr)
          return nullptr ;
-   
+
      // verifico se devo leggere i punti del bisettore al contrario per averlo orientato dal parametro minore al maggiore
       bool bInvert = false ;
       double dPar1, dPar2 ;
@@ -481,13 +481,13 @@ Voronoi::GetBisectorCurve( int i)
       m_vroni->GetApproxedBisectorPoint( i, bInvert ? nPoints - 1 : 0, pt.v, dParS) ;
       pCompo->AddPoint( pt) ;
       int nCrvCount = 0 ;
-   
+
       double dParPrev = dParS ;
       int j = bInvert ? nPoints - 2 : 1 ;
       while ( ( bInvert  &&  j >= 0)  ||  ( ! bInvert  &&  j < nPoints)) {
          double dPar ;
          m_vroni->GetApproxedBisectorPoint( i, j, pt.v, dPar) ;
-         if ( pCompo->AddLine( pt)) {           
+         if ( pCompo->AddLine( pt)) {
            // setto i parametri sulla sottocurva
             pCompo->SetCurveTempParam( nCrvCount, dParPrev, 0) ;
             pCompo->SetCurveTempParam( nCrvCount, dPar, 1) ;
@@ -501,7 +501,7 @@ Voronoi::GetBisectorCurve( int i)
          else
             j ++ ;
       }
-   
+
      // setto parametri sulla curva
       pCompo->SetTempParam( dParS, 0) ;
       pCompo->SetTempParam( dParPrev, 1) ;
@@ -521,12 +521,12 @@ Voronoi::CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound)
 
    if ( ! IsValid())
       return false ;
- 
+
    try {
      // verifico se necessario calcolo Voronoi
       if ( ! m_bVDComputed  ||  nBound != m_nBound)
          CalcVoronoi( nBound) ;
-     
+
       for ( int i = 4 ; i < m_vroni->GetNumberOfEdges() ; i ++) {
         // recupero la curva del bisettore
          PtrOwner<ICurve> pCrv( GetBisectorCurve( i)) ;
@@ -546,7 +546,7 @@ Voronoi::CalcVoronoiDiagram( ICURVEPOVECTOR& vCrvs, int nBound)
 }
 
 //----------------------------------------------------------------------------
-bool 
+bool
 Voronoi::CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide)
 {
    vCrvs.clear() ;
@@ -561,21 +561,21 @@ Voronoi::CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide)
       bRight = false ;
    else if ( nSide == WMAT_RIGHT)
       bLeft = false ;
- 
-   try {   
+
+   try {
       if ( ! m_bVDComputed)
          CalcVoronoi() ;
 
      // calcolo medial axis
       m_vroni->apiComputeWMAT( false, 0.0, 0.0, false, bLeft, bRight) ;
-    
+
       for ( int i = 4 ; i < m_vroni->GetNumberOfEdges() ; i ++) {
         // verifico se il lato appartiene al medial axis
          if ( m_vroni->IsWMATEdge( i)) {
             PtrOwner<ICurve> pCrv( GetBisectorCurve( i)) ;
-            if ( ! IsNull( pCrv) && pCrv->IsValid()) 
-               vCrvs.emplace_back( Release( pCrv)) ; 
-         }         
+            if ( ! IsNull( pCrv) && pCrv->IsValid())
+               vCrvs.emplace_back( Release( pCrv)) ;
+         }
       }
 
      // libero la memoria di vroni utilizzata per calcolare bisettore
@@ -590,7 +590,7 @@ Voronoi::CalcMedialAxis( ICURVEPOVECTOR& vCrvs, int nSide)
 }
 
 //----------------------------------------------------------------------------
-bool 
+bool
 Voronoi::CalcOffset( ICURVEPOVECTOR& vOffs, double dOffs, int nType)
 {
    vOffs.clear() ;
@@ -603,32 +603,32 @@ Voronoi::CalcOffset( ICURVEPOVECTOR& vOffs, double dOffs, int nType)
       for ( auto pCrv : m_vpCrvs)
          vOffs.emplace_back( pCrv->Clone()) ;
    }
- 
+
   // calcolo offset
    ICRVCOMPOPLIST OffsList ;
    if ( ! CalcVroniOffset( OffsList, abs( dOffs)))
-      return false ;  
- 
+      return false ;
+
   // sistemo le curve di offset calcolate con vroni
-   for ( auto pCrv : OffsList) {     
+   for ( auto pCrv : OffsList) {
 
      // seleziono le porzioni dell'offset che si trovano dal lato richiesto
       ICRVCOMPOPOVECTOR vResult = AdjustOffsetCurves( pCrv, dOffs) ;
-      
-      for ( int i = 0 ; i < int( vResult.size()) ; ++ i) {     
-      
+
+      for ( int i = 0 ; i < int( vResult.size()) ; ++ i) {
+
         // eventuale inversione
          if ( dOffs > EPS_SMALL)
             vResult[i]->Invert() ;
-     
+
         // sistemo il punto di inizio
-         if ( vResult[i]->IsClosed())           
+         if ( vResult[i]->IsClosed())
             AdjustOffsetStart( vResult[i]) ;
-     
-        // identifico i raccordi 
+
+        // identifico i raccordi
          if ( ( nType & ICurve::OFF_CHAMFER) != 0  ||  ( nType & ICurve::OFF_EXTEND) != 0)
             IdentifyFillets( vResult[i], dOffs) ;
-     
+
         // unisco le parti allineate
          vResult[i]->MergeCurves( LIN_TOL_MIN, ANG_TOL_STD_DEG, true, true) ;
         // aggiungo al vettore finale
@@ -643,17 +643,17 @@ Voronoi::CalcOffset( ICURVEPOVECTOR& vOffs, double dOffs, int nType)
       if ( ! AdjustCurveFillets( vOffs, dOffs, nType)) {
          vOffs.clear() ;
          return false ;
-      }        
+      }
 
   // porto nel frame globale
    for ( int i = 0 ; i < int( vOffs.size()) ; i++)
-      vOffs[i]->ToGlob( m_Frame) ;    
+      vOffs[i]->ToGlob( m_Frame) ;
 
    return true ;
 }
 
 //----------------------------------------------------------------------------
-bool 
+bool
 Voronoi::CalcSingleCurvesOffset( ICURVEPOVECTOR& vOffs, double dOffs)
 {
   // calcola, se possibile, le curve di offset del valore richiesto come curve singole, andando a recuperare i tratti del
@@ -667,22 +667,22 @@ Voronoi::CalcSingleCurvesOffset( ICURVEPOVECTOR& vOffs, double dOffs)
    if ( ! IsValid())
       return false ;
 
-   try {   
+   try {
       if ( ! m_bVDComputed)
          CalcVoronoi() ;
 
-     // individuo il lato richiesto 
+     // individuo il lato richiesto
       bool bLeft = ( dOffs < 0) ;
-      bool bRight = ! bLeft ;     
+      bool bRight = ! bLeft ;
       for ( int i = 0 ; i < int( m_vpCrvs.size()) ; i++) {
          if ( ! m_vpCrvs[i]->IsClosed()) {
            // se è presente una curva aperta il medial axis deve essere fatto sia a destra sia a sinistra
             bLeft = true ;
             bRight = true ;
-            break ;         
+            break ;
          }
       }
-      int nSideRef = ( dOffs < 0 ? MDS_LEFT : MDS_RIGHT) ; 
+      int nSideRef = ( dOffs < 0 ? MDS_LEFT : MDS_RIGHT) ;
 
      // seleziono le curve del medial axis aventi parametro costante pari all'offset richiesto
       m_vroni->apiComputeWMAT( false, 0.0, 0.0, false, bLeft, bRight) ;
@@ -695,7 +695,7 @@ Voronoi::CalcSingleCurvesOffset( ICURVEPOVECTOR& vOffs, double dOffs)
             m_vroni->GetBisectorParams( i, dParS, dParE) ;
             if ( abs( dParS - abs( dOffs)) < EPS_SMALL  &&  abs( dParE - abs( dOffs)) < EPS_SMALL) {
                PtrOwner<ICurve> pCrv( GetBisectorCurve( i)) ;
-               if ( ! IsNull( pCrv) && pCrv->IsValid()) {               
+               if ( ! IsNull( pCrv) && pCrv->IsValid()) {
                  // se necessario verifico se dal lato corretto rispetto ai siti di riferimento
                   if ( bLeft  &&  bRight) {
                     // recupero i siti di riferimento
@@ -707,7 +707,7 @@ Voronoi::CalcSingleCurvesOffset( ICURVEPOVECTOR& vOffs, double dOffs)
                         pCrv->SetTempProp( nOrigCrv1, 1) ;
                         int nSide = GetOffsetCurveSide( pCrv) ;
                         if ( nSide != nSideRef)
-                           continue ;                    
+                           continue ;
                      }
                      if ( nOrigCrv2 != -1) {
                        // verifico il lato rispetto al secondo sito
@@ -716,18 +716,18 @@ Voronoi::CalcSingleCurvesOffset( ICURVEPOVECTOR& vOffs, double dOffs)
                         int nSide = GetOffsetCurveSide( pCrv) ;
                         if ( nSide != nSideRef)
                            continue ;
-                     }                   
+                     }
                   }
-                  vCrvs.emplace_back( Release( pCrv)) ; 
-               }                         
-            }                     
-         }         
+                  vCrvs.emplace_back( Release( pCrv)) ;
+               }
+            }
+         }
       }
 
      // concateno le curve ottenute
       if ( vCrvs.size() == 1)
          vOffs.emplace_back( Release( vCrvs[0])) ;
-      else if ( ! vCrvs.empty()) {       
+      else if ( ! vCrvs.empty()) {
          ChainCurves chainC ;
          chainC.Init( true, 10 * EPS_SMALL, int( vCrvs.size())) ;
          for ( int i = 0 ; i < int( vCrvs.size()) ; ++ i) {
@@ -754,14 +754,14 @@ Voronoi::CalcSingleCurvesOffset( ICURVEPOVECTOR& vOffs, double dOffs)
                   vCrvs[nInd]->Invert() ;
               // aggiungo alla composita
                if ( ! pCrvCompo->AddCurve( Release( vCrvs[nInd])))
-                  return false ; 
+                  return false ;
             }
             if ( pCrvCompo->IsValid()) {
                pCrvCompo->MergeCurves( LIN_TOL_MIN, ANG_TOL_STD_DEG) ;
                vOffs.emplace_back( Release( pCrvCompo)) ;
-            }                     
+            }
          }
-      }         
+      }
 
      // libero la memoria di vroni utilizzata per calcolare bisettore
       m_vroni->apiFreeBisectorBuffer() ;
@@ -775,11 +775,11 @@ Voronoi::CalcSingleCurvesOffset( ICURVEPOVECTOR& vOffs, double dOffs)
 }
 
 //----------------------------------------------------------------------------
-bool 
+bool
 Voronoi::CalcSpecialPointOffset( PNTVECTVECTOR& vResult, double dOffs)
 {
   // calcola i punti e le tangenti sui bisettori del medial axis in corrispondenza del valore di offset richiesto
- 
+
    vResult.clear() ;
 
    if ( abs( dOffs) < EPS_SMALL)
@@ -792,12 +792,12 @@ Voronoi::CalcSpecialPointOffset( PNTVECTVECTOR& vResult, double dOffs)
      // verifico se necessario ricalcolo Voronoi
       UpdateVoronoi( dOffs) ;
 
-     // indivudio lato medial axis per curve chiuse ( suppongo di chiamare la funzione dalla singola curva, quindi vale controllare 
+     // indivudio lato medial axis per curve chiuse ( suppongo di chiamare la funzione dalla singola curva, quindi vale controllare
      // la chiusura solo sulla prima curva. Eventualmente da estendere)
       bool bLeft = true, bRight = true ;
       if ( m_vpCrvs[0]->IsClosed()) {
          bLeft = dOffs < 0 ;
-         bRight = ! bLeft ;      
+         bRight = ! bLeft ;
       }
 
      // calcolo medial axis
@@ -826,12 +826,12 @@ Voronoi::CalcSpecialPointOffset( PNTVECTVECTOR& vResult, double dOffs)
             double dPar ;
             Point3d ptTemp ;
             Vector3d vtDir ;
-            if ( ! pCrv->GetParamAtPoint( pt, dPar, 100 * EPS_SMALL)  ||  ! pCrv->GetPointD1D2( dPar, ICurve::FROM_MINUS, ptTemp, &vtDir))  
+            if ( ! pCrv->GetParamAtPoint( pt, dPar, 100 * EPS_SMALL)  ||  ! pCrv->GetPointD1D2( dPar, ICurve::FROM_MINUS, ptTemp, &vtDir))
                return false ;
             vtDir.Normalize() ;
 
             vResult.emplace_back( pt, vtDir) ;
-         }         
+         }
       }
 
      // libero la memoria di vroni utilizzata per calcolare bisettori
@@ -846,23 +846,23 @@ Voronoi::CalcSpecialPointOffset( PNTVECTVECTOR& vResult, double dOffs)
 }
 
 //----------------------------------------------------------------------------
-bool 
+bool
 Voronoi::CalcFatCurve( ICURVEPOVECTOR& vCrvs, double dOffs, bool bSquareEnds, bool bSquareMids,
                        bool bMergeOnlySameProps)
 {
    vCrvs.clear() ;
- 
+
    if ( ! IsValid())
       return false ;
- 
+
   // se offset nullo errore
    if ( abs( dOffs) < EPS_SMALL)
       return false ;
- 
+
    ICRVCOMPOPLIST OffsList ;
    if ( ! CalcVroniOffset( OffsList, abs( dOffs)))
       return false ;
-  
+
   // sistemo le curve di offset calcolate con vroni
    bool bClosed = m_vpCrvs[0]->IsClosed() ;
    for ( auto pCrvOffs : OffsList) {
@@ -910,7 +910,7 @@ Voronoi::CalcFatCurve( ICURVEPOVECTOR& vCrvs, double dOffs, bool bSquareEnds, bo
 }
 
 //----------------------------------------------------------------------------
-bool 
+bool
 Voronoi::CalcVroniOffset( ICRVCOMPOPLIST& OffsList, double dOffs)
 {
    OffsList.clear() ;
@@ -931,21 +931,21 @@ Voronoi::CalcVroniOffset( ICRVCOMPOPLIST& OffsList, double dOffs)
       m_vroni->apiComputeOff( false, &sTmp[0], false, false, dOffs, 0.0, false, true, true) ;
 
      // recupero le curve di offset da vroni
-      int nOffsCnt = m_vroni->GetOffsetCount() ;      
+      int nOffsCnt = m_vroni->GetOffsetCount() ;
       for ( int i = 0 ; i < nOffsCnt ; i++) {
          Point3d ptSChain = P_INVALID ;
          PtrOwner<CurveComposite> pCrvOffs ( CreateBasicCurveComposite()) ;
          int nCrvCnt = m_vroni->GetOffsetCurveCount( i) ;    // numero di sottocurve
 
          for ( int j = 0 ; j < nCrvCnt ; j ++) {
-           // recupero la sottocurva da vroni         
+           // recupero la sottocurva da vroni
             Point3d ptS, ptE, ptC ;
             int nType ;
             int nOrigCrv, nOrigLoop, nOrigPnt ;   // sito
             m_vroni->GetOffsetCurve( i, j, nType, ptS.v, ptE.v, ptC.v, nOrigLoop, nOrigCrv, nOrigPnt) ;
 
             if ( j == 0)
-               pCrvOffs->AddPoint( ptS) ; 
+               pCrvOffs->AddPoint( ptS) ;
 
            // se estremi coincidenti la curva va ignorata ( da vroni non possono arrivare circonferenze)
            // ma controllo se appartiene ad una catena di tratti infinitesimi
@@ -954,7 +954,7 @@ Voronoi::CalcVroniOffset( ICRVCOMPOPLIST& OffsList, double dOffs)
                   if ( ! AreSamePointApprox( ptSChain, ptE)) {
                      if ( ! pCrvOffs->AddLine( ptE))
                         return false ;
-                     ptSChain = P_INVALID ;              
+                     ptSChain = P_INVALID ;
                   }
                }
                else {
@@ -970,52 +970,43 @@ Voronoi::CalcVroniOffset( ICRVCOMPOPLIST& OffsList, double dOffs)
                if ( ! pCrvOffs->AddLine( ptE))
                   return false ;
             }
-            else {              
+            else {
                PtrOwner<CurveArc> pArc( CreateBasicCurveArc()) ;
                if ( ! pArc->SetC2P( ptC, ptS, ptE)) {
                  // se raggio minore di EPS_SMALL approssimo con linea
                   if ( AreSamePointApprox( ptC, ptS)) {
                      if ( ! pCrvOffs->AddLine( ptE))
-                        return false ;                  
+                        return false ;
                   }
                   else
-                     return false ;               
+                     return false ;
                }
                else {
                  // verifico orientamento
                   double dAng = pArc->GetAngCenter() ;
                   if ( ( nType == CCW  &&  dAng < - EPS_ANG_SMALL)  ||  ( nType == CW  &&  dAng > EPS_ANG_SMALL))
                      pArc->ToExplementary() ;
-                 // verifico se l'arco degenera in segmento
-                  Point3d ptMLine = Media( ptS, ptE) ;
-                  Point3d ptMArc ; pArc->GetMidPoint( ptMArc) ;
-                  if ( Dist( ptMLine, ptMArc) < EPS_SMALL) {
-                     if ( ! pCrvOffs->AddLine( ptE))
-                        return false ;
-                  }
-                  else {
-                    // aggiungo alla composita
-                     if ( ! pCrvOffs->AddCurve( Release( pArc)))
-                        return false ;                   
-                  } 
-               }              
+                 // aggiungo alla composita
+                  if ( ! pCrvOffs->AddCurve( Release( pArc)))
+                     return false ;
+               }
             }
 
            // setto come info la sottocurva da cui si è generata
             int nCurrCrvId = pCrvOffs->GetCurveCount() - 1 ;
             pCrvOffs->SetCurveTempProp( nCurrCrvId, nOrigCrv + 1, 0) ;
             pCrvOffs->SetCurveTempProp( nCurrCrvId, nOrigLoop, 1) ;
-           // verifico se è una giunzione, ovvero un raccordo relativo agli estremi di una curva ( con distinzione fra curva 
+           // verifico se è una giunzione, ovvero un raccordo relativo agli estremi di una curva ( con distinzione fra curva
            // aperta e chiusa)
             if ( nOrigCrv == -1) {
                int nOrigCrvCnt = 1 ;
                if ( m_vpCrvs[nOrigLoop]->GetType() == CRV_COMPO)
                   nOrigCrvCnt = GetBasicCurveComposite( m_vpCrvs[nOrigLoop])->GetCurveCount() ;
                if ( nOrigPnt == 0  ||  nOrigPnt == nOrigCrvCnt) {
-                  double dParam = m_vpCrvs[nOrigLoop]->IsClosed() ? VRONI_JUNCTION_CLOSED : VRONI_JUNCTION_OPEN ;            
+                  double dParam = m_vpCrvs[nOrigLoop]->IsClosed() ? VRONI_JUNCTION_CLOSED : VRONI_JUNCTION_OPEN ;
                   pCrvOffs->SetCurveTempParam( nCurrCrvId, dParam, 0) ;
                }
-            }             
+            }
          }
 
         // rimuovo tratti di lunghezza inferiore a 5 * EPS_SMALL
@@ -1023,8 +1014,8 @@ Voronoi::CalcVroniOffset( ICRVCOMPOPLIST& OffsList, double dOffs)
 
         // aggiungo la curva alla lista degli offset
          if ( ! IsNull( pCrvOffs) &&  pCrvOffs->IsValid()  &&  pCrvOffs->GetCurveCount() > 0)
-            OffsList.push_back( Release( pCrvOffs)) ;        
-      } 
+            OffsList.push_back( Release( pCrvOffs)) ;
+      }
 
      // libero la memoria di vroni dedicata agli offset
       m_vroni->apiFreeOffsetData() ;
@@ -1038,11 +1029,11 @@ Voronoi::CalcVroniOffset( ICRVCOMPOPLIST& OffsList, double dOffs)
 }
 
 //----------------------------------------------------------------------------
-bool 
+bool
 Voronoi::UpdateVoronoi( double dOffs)
 {
   // calcolo il bound necessario per l'offset desiderato
-   double dNeededBound = abs( dOffs) / 0.49 / sqrt( m_bBox.GetDimX() * m_bBox.GetDimX() + m_bBox.GetDimY() * m_bBox.GetDimY()) ;   
+   double dNeededBound = abs( dOffs) / 0.49 / sqrt( m_bBox.GetDimX() * m_bBox.GetDimX() + m_bBox.GetDimY() * m_bBox.GetDimY()) ;
    if ( ! m_bVDComputed  ||  dNeededBound > m_nBound) { 
      // aggiorno il valore del bound
       int nBound = ( int)( ceil( dNeededBound) + 0.5) ;
@@ -1054,9 +1045,9 @@ Voronoi::UpdateVoronoi( double dOffs)
 }
 
 //----------------------------------------------------------------------------
-ICRVCOMPOPOVECTOR 
-Voronoi::AdjustOffsetCurves( const ICurveComposite* pCompo, double dOffs) const 
-{  
+ICRVCOMPOPOVECTOR
+Voronoi::AdjustOffsetCurves( const ICurveComposite* pCompo, double dOffs) const
+{
    ICRVCOMPOPOVECTOR vResult ;
    int nSideRef = dOffs < EPS_SMALL ? MDS_LEFT : MDS_RIGHT ;
 
@@ -1074,13 +1065,13 @@ Voronoi::AdjustOffsetCurves( const ICurveComposite* pCompo, double dOffs) const
      // controllo la curva complessiva
       int nSide = GetOffsetCurveSide( pCompo->GetCurve( 0)) ;
       if ( nSide == nSideRef) 
-         vResult.emplace_back( pCompo->Clone()) ;   
+         vResult.emplace_back( pCompo->Clone()) ;
    }
-   else {   
+   else {
      // scorro la curva eliminando le giunzioni relative a curve aperte e le sottocurve che si trovano dal lato sbagliato
       PtrOwner<CurveComposite> pCompoCurr( CreateBasicCurveComposite()) ;
       for ( int i = 0 ; i < pCompo->GetCurveCount() ; i ++) {
-         bool bKeep = true ;         
+         bool bKeep = true ;
          double dParTmp ; pCompo->GetCurveTempParam( i, dParTmp) ;
          if ( abs( dParTmp - VRONI_JUNCTION_OPEN) < EPS_SMALL)
             bKeep = false ;
@@ -1096,8 +1087,8 @@ Voronoi::AdjustOffsetCurves( const ICurveComposite* pCompo, double dOffs) const
             if ( pCompoCurr->IsValid()) {
                vResult.emplace_back( Release( pCompoCurr)) ;
                pCompoCurr.Set( CreateBasicCurveComposite()) ;
-            } 
-         }       
+            }
+         }
       }
      // salvo eventuale ultima curva
       if ( pCompoCurr->IsValid())
@@ -1111,17 +1102,17 @@ Voronoi::AdjustOffsetCurves( const ICurveComposite* pCompo, double dOffs) const
             vResult.pop_back() ;
       }
    }
- 
+
    return vResult ;
 }
 
 //---------------------------------------------------------------------------
-int 
-Voronoi::GetOffsetCurveSide( const ICurve* pCrv) const 
-{  
+int
+Voronoi::GetOffsetCurveSide( const ICurve* pCrv) const
+{
    if ( pCrv == nullptr)
       return -1 ;
-   
+
    Point3d ptM ; pCrv->GetMidPoint( ptM) ;
 
   // recupero curva e sottocurva di riferimento dalle temp prop
@@ -1130,8 +1121,8 @@ Voronoi::GetOffsetCurveSide( const ICurve* pCrv) const
    const ICurve* pCrvRef = m_vpCrvs[nOrigCrv] ;
    if ( nOrigSubCrv != 0 && m_vpCrvs[nOrigCrv]->GetType() == CRV_COMPO) {
       const CurveComposite* pCompoOrig = GetBasicCurveComposite( m_vpCrvs[nOrigCrv]) ;
-      if ( pCompoOrig != nullptr) 
-         pCrvRef = pCompoOrig->GetCurve( nOrigSubCrv - 1) ;           
+      if ( pCompoOrig != nullptr)
+         pCrvRef = pCompoOrig->GetCurve( nOrigSubCrv - 1) ;
    }
 
    DistPointCurve distPC( ptM, *pCrvRef) ;
@@ -1141,9 +1132,9 @@ Voronoi::GetOffsetCurveSide( const ICurve* pCrv) const
 }
 
 //---------------------------------------------------------------------------
-bool 
-Voronoi::AdjustOffsetStart( ICurveComposite* pCrv) const 
-{ 
+bool
+Voronoi::AdjustOffsetStart( ICurveComposite* pCrv) const
+{
    for ( int i = 0 ; i < pCrv->GetCurveCount() ; i++) {
      // cerco il tratto associato alla prima sottocurva originale
       int nOrigCrv ; pCrv->GetCurveTempProp( i, nOrigCrv) ;
@@ -1163,15 +1154,15 @@ Voronoi::AdjustOffsetStart( ICurveComposite* pCrv) const
 
 //---------------------------------------------------------------------------
 bool
-Voronoi::Translate( const Vector3d & vtMove) 
-{  
+Voronoi::Translate( const Vector3d & vtMove)
+{
    if ( ! IsValid())
       return false ;
    return m_Frame.Translate( vtMove) ;
 }
 
 //---------------------------------------------------------------------------
-bool 
+bool
 Voronoi::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg)
 {
    if ( ! IsValid())
@@ -1180,7 +1171,7 @@ Voronoi::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg)
 }
 
 //---------------------------------------------------------------------------
-bool 
+bool
 Voronoi::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
 {
    if ( ! IsValid())
@@ -1189,7 +1180,7 @@ Voronoi::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, doub
 }
 
 //---------------------------------------------------------------------------
-bool 
+bool
 Voronoi::ToGlob( const Frame3d& frRef)
 {
    if ( ! IsValid())
@@ -1198,7 +1189,7 @@ Voronoi::ToGlob( const Frame3d& frRef)
 }
 
 //---------------------------------------------------------------------------
-bool 
+bool
 Voronoi::ToLoc( const Frame3d& frRef)
 {
    if ( ! IsValid())
@@ -1207,7 +1198,7 @@ Voronoi::ToLoc( const Frame3d& frRef)
 }
 
 //---------------------------------------------------------------------------
-bool 
+bool
 Voronoi::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
 {
    if ( ! IsValid())
@@ -1216,7 +1207,7 @@ Voronoi::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
 }
 
 //---------------------------------------------------------------------------
-bool 
+bool
 Voronoi::CalcLimitOffset( int nCrv, bool bLeft, double& dOffs)
 {
    if ( nCrv < 0  ||  nCrv > int( m_vpCrvs.size()) - 1)
@@ -1230,14 +1221,14 @@ Voronoi::CalcLimitOffset( int nCrv, bool bLeft, double& dOffs)
      // verifico se necessario calcolo Voronoi
       if ( ! m_bVDComputed)
          CalcVoronoi() ;
-     
+
       for ( int i = 4 ; i < m_vroni->GetNumberOfEdges() ; i ++) {
         // verifico se è un bisettore relativo alla curva richiesta e dal lato opportuno
          if ( m_vroni->IsRelatedEdge( i, nCrv, bLeft)) {
            // calcolo i parametri del bisettore
             double dParS, dParE ;
             m_vroni->GetBisectorParams( i, dParS, dParE) ;
-            dOffs = max( { dParS, dParE, dOffs}) ;  
+            dOffs = max( { dParS, dParE, dOffs}) ;
          }
       }