From 2b0b6800cb99742a691988bd2d4599dfc4315f3f Mon Sep 17 00:00:00 2001
From: Dario Sassi <dario.s@egaltech.com>
Date: Wed, 14 May 2014 07:11:19 +0000
Subject: [PATCH] =?UTF-8?q?EgtGeomKernel=201.5e4=20:=20-=20aggiunte=20dive?=
 =?UTF-8?q?rse=20modalit=C3=A0=20di=20costruzione=20e=20modifica=20degli?=
 =?UTF-8?q?=20archi=20-=20i=20comandi=20TSC=20sono=20stati=20ampliati=20co?=
 =?UTF-8?q?n=20queste=20nuove=20modalit=C3=A0.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CurveArc.cpp       | 414 +++++++++++++++++++---
 CurveArc.h         |  18 +-
 CurveComposite.cpp |   2 +-
 CurveLine.cpp      |   4 +-
 CurveLine.h        |   4 +-
 EgtGeomKernel.rc   | Bin 11710 -> 11710 bytes
 GdbExecutor.cpp    | 852 ++++++++++++++++++++++++++++++++-------------
 GdbExecutor.h      |  17 +
 8 files changed, 1012 insertions(+), 299 deletions(-)

diff --git a/CurveArc.cpp b/CurveArc.cpp
index 245241c..b603f78 100644
--- a/CurveArc.cpp
+++ b/CurveArc.cpp
@@ -86,12 +86,144 @@ CurveArc::Set( const Point3d& ptCen, const Vector3d& vtN, double dRad,
    return Validate() ;
 }
 
+//----------------------------------------------------------------------------
+// Set per circonferenza completa
+//----------------------------------------------------------------------------
+bool
+CurveArc::Set( const Point3d& ptCen, const Vector3d& vtN, double dRad)
+{
+  // assegno e calcolo i dati
+   m_PtCen = ptCen ;
+   m_VtN = vtN ;
+   Frame3d frF ;
+   if ( ! frF.Set( ORIG, vtN))
+      return false ;
+   m_VtS = frF.VersX() ;
+   m_dRad = dRad ;
+   m_dAngCenDeg = 360 ;
+   m_dDeltaN = 0 ;
+   m_nStatus = TO_VERIFY ;
+
+  // imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+
+   return Validate() ;
+}
+
+//----------------------------------------------------------------------------
+// Set per arco di circonferenza nel piano XY
+//----------------------------------------------------------------------------
+bool
+CurveArc::SetXY( const Point3d& ptCen, double dRad, double dAngIniDeg, double dAngCenDeg, double dDeltaZ)
+{
+  // assegno e calcolo i dati
+   m_PtCen = ptCen ;
+   m_VtN = Z_AX ;
+   m_VtS.FromPolar( 1, dAngIniDeg) ;
+   m_dRad = dRad ;
+   m_dAngCenDeg = dAngCenDeg ;
+   m_dDeltaN = dDeltaZ ;
+   m_nStatus = TO_VERIFY ;
+
+  // imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+
+   return Validate() ;
+}
+
+//----------------------------------------------------------------------------
+// Set per circonferenza completa nel piano XY
+//----------------------------------------------------------------------------
+bool
+CurveArc::SetXY( const Point3d& ptCen, double dRad)
+{
+  // assegno e calcolo i dati
+   m_PtCen = ptCen ;
+   m_VtN = Z_AX ;
+   m_VtS = X_AX ;
+   m_dRad = dRad ;
+   m_dAngCenDeg = 360 ;
+   m_dDeltaN = 0 ;
+   m_nStatus = TO_VERIFY ;
+
+  // imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+
+   return Validate() ;
+}
+
+//----------------------------------------------------------------------------
+// Set per arco di circonf. o circonferenza completa per 3 Punti
+// ( algoritmo da Comp. Geom. di Faux e Pratt pagg. 67 e 68 )
+//----------------------------------------------------------------------------
+bool
+CurveArc::Set3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d& ptEnd, bool bCirc)
+{
+  // arco non ancora definito correttamente
+   m_nStatus = ERR ;
+
+  // vettori dal primo punto agli altri due
+   Vector3d vtA = ptOther - ptStart ;
+   Vector3d vtB = ptEnd - ptStart ;
+  // calcolo del versore normale
+   m_VtN = vtA ^ vtB ;
+   double dNSqLen = m_VtN.SqLen() ;
+   // se i punti sono praticamente allineati non si può calcolare la circonferenza
+   if ( ! m_VtN.Normalize( EPS_ZERO))
+      return false ;
+  // calcolo del centro
+   m_PtCen = ptStart + ( vtB.SqLen() * ( vtA.SqLen() - vtA * vtB) * vtA +  
+                         vtA.SqLen() * ( vtB.SqLen() - vtA * vtB) * vtB) / ( 2 * dNSqLen) ;
+  // calcolo del versore start e del raggio
+   m_VtS = ptStart - m_PtCen ;
+   m_dRad = m_VtS.Len() ;
+   if ( m_dRad < EPS_SMALL)
+      return false ;
+   m_VtS /= m_dRad ;
+  // calcolo dell'angolo al centro
+   if ( bCirc)
+      m_dAngCenDeg = 360 ;
+   else {
+     // calcolo dell'angolo di rotazione attorno al centro dal primo al secondo punto
+      bool bDet1 ;
+      double dAng1Deg ;
+      if ( ! m_VtS.GetRotation( ( ptOther - m_PtCen), m_VtN, dAng1Deg, bDet1)  ||  ! bDet1)
+         return false ;
+     // calcolo dell'angolo di rotazione attorno al centro dal primo al terzo punto
+      bool bDet2 ;
+      double dAng2Deg ;
+      if ( ! m_VtS.GetRotation( ( ptEnd - m_PtCen), m_VtN, dAng2Deg, bDet2)  ||  ! bDet2)
+         return false ;
+     // deduzione dell'angolo al centro
+      // se uno dei due angoli è nullo, errore
+      if ( fabs( dAng1Deg) < EPS_ANG_SMALL  ||  fabs( dAng2Deg) < EPS_ANG_SMALL)
+         return false ;
+      // se i due angoli hanno lo stesso segno e Ang1 è minore di Ang2 in modulo
+      else if ( dAng1Deg * dAng2Deg > 0  &&  fabs( dAng1Deg) < fabs( dAng2Deg))
+         m_dAngCenDeg = dAng2Deg ;
+     // altrimenti hanno segno opposto oppure Ang1 è maggiore di Ang2 in modulo
+      else
+         m_dAngCenDeg = - _copysign( 360, dAng2Deg) + dAng2Deg ;
+   }
+  // non c'è DeltaN
+   m_dDeltaN = 0 ;
+
+  // imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+
+   m_nStatus = TO_VERIFY ;
+   return Validate() ;
+}
+
 //----------------------------------------------------------------------------
 // Set per arco di circonf. definito dagli estremi, versore normale e bulge
 //----------------------------------------------------------------------------
 bool
-CurveArc::Set( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& vtN, double dBulge)
+CurveArc::Set2PNB( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& vtN, double dBulge)
 {
+  // arco non ancora definito correttamente
+   m_nStatus = ERR ;
+
   // versore normale
    m_VtN = vtN ;
    if ( ! m_VtN.Normalize())
@@ -132,68 +264,146 @@ CurveArc::Set( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& vtN,
 }
 
 //----------------------------------------------------------------------------
-// Set per arco di circonferenza nel piano XY
+// Set per arco di circonferenza nel piano XY con ptStart, ptEnd, dirStart
 //----------------------------------------------------------------------------
 bool
-CurveArc::Set( const Point3d& ptCen, double dRad, double dAngIniDeg, double dAngCenDeg, double dDeltaZ)
+CurveArc::Set2PD( const Point3d& ptStart, const Point3d& ptEnd, double dDirStartDeg)
 {
-  // assegno e calcolo i dati
-   m_PtCen = ptCen ;
-   m_VtN = Z_AX ;
-   m_VtS.FromPolar( 1, dAngIniDeg) ;
-   m_dRad = dRad ;
-   m_dAngCenDeg = dAngCenDeg ;
-   m_dDeltaN = dDeltaZ ;
-   m_nStatus = TO_VERIFY ;
+  // arco non ancora definito correttamente
+   m_nStatus = ERR ;
 
-  // imposto ricalcolo della grafica
-   m_OGrMgr.Reset() ;
-
-   return Validate() ;
-}
-
-//----------------------------------------------------------------------------
-// Set per circonferenza completa
-//----------------------------------------------------------------------------
-bool
-CurveArc::Set( const Point3d& ptCen, const Vector3d& vtN, double dRad)
-{
-  // assegno e calcolo i dati
-   m_PtCen = ptCen ;
-   m_VtN = vtN ;
-   Frame3d frF ;
-   if ( ! frF.Set( ORIG, vtN))
+  // vettore tangente iniziale ( nel piano XY)
+   Vector3d vtA ;
+   vtA.FromPolar( 1, dDirStartDeg) ;
+  // vettore da inizio a fine ( nel piano XY)  
+   Vector3d vtB = ptEnd - ptStart ;
+   vtB.z = 0 ;
+  // calcolo del versore normale
+   m_VtN = vtA ^ vtB ;
+   double dNSqLen = m_VtN.SqLen() ;
+   // se tangente e punti sono praticamente allineati non si può calcolare la circonferenza
+   if ( ! m_VtN.Normalize( EPS_ZERO))
       return false ;
-   m_VtS = frF.VersX() ;
-   m_dRad = dRad ;
-   m_dAngCenDeg = 360 ;
-   m_dDeltaN = 0 ;
-   m_nStatus = TO_VERIFY ;
+  // calcolo del centro
+   m_PtCen = ptStart + vtB.SqLen() * ( vtB - ( vtA * vtB) * vtA) / ( 2 * dNSqLen) ;  
+  // calcolo del versore start e del raggio
+   m_VtS = ptStart - m_PtCen ;
+   m_dRad = m_VtS.Len() ;
+   if ( m_dRad < EPS_SMALL)
+      return false ;
+   m_VtS /= m_dRad ;
+  // calcolo dell'angolo al centro
+   // angolo di rotazione da start a end
+   bool bDet1 ;
+   double dAng1Deg ;
+   if ( ! m_VtS.GetRotation( ( ptEnd - m_PtCen), m_VtN, dAng1Deg, bDet1)  ||  ! bDet1)
+      return false ;
+   // poichè il senso di rotazione è sempre CCW, se l'angolo è negativo prendo il suo complemento al giro
+    if ( dAng1Deg < 0)
+       m_dAngCenDeg = ANG_FULL + dAng1Deg ;
+    else
+       m_dAngCenDeg = dAng1Deg ;
+  // DeltaN
+   m_dDeltaN = ( ptEnd.z - ptStart.z) * m_VtN.z ;
+
+  // se normale con Z negativa, inverto senza modificare la geometria
+   if ( m_VtN.z < 0) {
+      m_VtN *= - 1 ;
+      m_dAngCenDeg *= - 1 ;
+      m_dDeltaN *= - 1 ;
+   }
 
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
+   m_nStatus = TO_VERIFY ;
    return Validate() ;
 }
 
 //----------------------------------------------------------------------------
-// Set per circonferenza completa nel piano XY
+// Set per arco di circonferenza nel piano XY con ptStart, ptEnd, dRad, bCCW
+// ( si suppone |dAngCenDeg| <= 180deg)
 //----------------------------------------------------------------------------
 bool
-CurveArc::Set( const Point3d& ptCen, double dRad)
+CurveArc::Set2PRS( const Point3d& ptStart, const Point3d& ptEnd, double dRad, bool bCCW)
 {
-  // assegno e calcolo i dati
-   m_PtCen = ptCen ;
+  // arco non ancora definito correttamente
+   m_nStatus = ERR ;
+
+  // il piano dell'arco coincide con XY
    m_VtN = Z_AX ;
-   m_VtS = X_AX ;
+   m_dDeltaN = ptEnd.z - ptStart.z ;
+  // semi-vettore da inizio a fine
+   Vector3d vtA = 0.5 * ( ptEnd - ptStart) ;
+   vtA.z = 0 ;
+   double dLenA = vtA.Len() ;
+   if ( dLenA < EPS_ZERO  ||  dLenA > ( dRad + EPS_ZERO))
+      return false ;
+  // distanza del centro dalla corda tra inizio e fine
+   double dLenH ;
+   if ( dLenA > ( dRad - EPS_ZERO))
+      dLenH = 0 ;
+   else
+      dLenH= sqrt( dRad * dRad - dLenA * dLenA) ;
+  // versore dal punto medio della corda al centro
+   Vector3d vtH = vtA / dLenA ;
+   vtH.Rotate( Z_AX, 0, ( bCCW ? 1 : -1)) ;
+  // calcolo del centro
+   m_PtCen = ptStart + vtA + vtH * dLenH ;
+  // assegno il raggio
+   if ( dRad < EPS_ZERO)
+      return false ;
    m_dRad = dRad ;
-   m_dAngCenDeg = 360 ;
-   m_dDeltaN = 0 ;
-   m_nStatus = TO_VERIFY ;
+  // calcolo il versore di start
+   m_VtS = ( ptStart - m_PtCen) / m_dRad ;
+  // calcolo l'angolo al centro
+   bool bDet ;
+   if ( ! m_VtS.GetRotation( ( ptEnd - m_PtCen), m_VtN, m_dAngCenDeg, bDet)  ||  ! bDet)
+      return false ;
+   // quando è 180deg il segno è determinato solo dal senso
+   if ( fabs( m_dAngCenDeg - ANG_STRAIGHT) < 10 * EPS_ANG_SMALL  &&
+        ( ( bCCW  &&  m_dAngCenDeg < 0)  ||
+          ( ! bCCW  &&  m_dAngCenDeg > 0)))
+      m_dAngCenDeg = - m_dAngCenDeg ;
 
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
 
+   m_nStatus = TO_VERIFY ;
+   return Validate() ;
+}
+
+//----------------------------------------------------------------------------
+// Set per arco di circonferenza nel piano XY con ptCen, ptStart, ptNearEnd
+// ( si suppone |dAngCenDeg| <= 180deg)
+//----------------------------------------------------------------------------
+bool
+CurveArc::SetC2P( const Point3d& ptCen, const Point3d& ptStart, const Point3d& ptNearEnd)
+{
+  // arco non ancora definito correttamente
+   m_nStatus = ERR ;
+
+  // il piano dell'arco coincide con XY
+   m_VtN = Z_AX ;
+   m_dDeltaN = ptNearEnd.z - ptStart.z ;
+  // assegno il centro
+   m_PtCen = ptCen ;
+   m_PtCen.z = ptStart.z ;
+  // assegno il versore iniziale e il raggio
+   m_VtS = ptStart - m_PtCen ;
+   m_dRad = m_VtS.Len() ;
+   if ( m_dRad < EPS_ZERO)
+      return false ;
+   m_VtS /= m_dRad ;
+  // calcolo l'angolo al centro (la funzione trova sempre il più piccolo)
+   bool bDet ;
+   if ( ! m_VtS.GetRotation( ( ptNearEnd - m_PtCen), m_VtN, m_dAngCenDeg, bDet)  ||  ! bDet)
+      return false ;
+
+  // imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+
+   m_nStatus = TO_VERIFY ;
    return Validate() ;
 }
 
@@ -253,17 +463,16 @@ bool
 CurveArc::Dump( string& sOut, const char* szNewLine) const
 {
   // parametri : punti iniziale e finale
-   sOut += "C(" + ToString( m_PtCen, 3) + ") " ;
-   sOut += "VN(" + ToString( m_VtN, 6) + ") " ;
-   sOut += "R=" + ToString( m_dRad, 3) + szNewLine ;
-   sOut += "VS(" + ToString( m_VtS, 6) + ") " ;
-   sOut += "Ac=" + ToString( m_dAngCenDeg, 3) + " " ;
-   sOut += "Dn=" + ToString( m_dDeltaN, 3) + szNewLine ;
+   sOut += "C(" + ToString( m_PtCen, 3) + ") " + szNewLine ;
+   sOut += "VN(" + ToString( m_VtN, 6) + ") " + szNewLine ;
+   sOut += "VS(" + ToString( m_VtS, 6) + ") " + szNewLine ;
+   sOut += "R=" + ToString( m_dRad, 3) ;
+   sOut += " Ac=" + ToString( m_dAngCenDeg, 3) ;
+   sOut += " Dn=" + ToString( m_dDeltaN, 3) + szNewLine ;
 
    return true ;
 }
 
-
 //----------------------------------------------------------------------------
 int
 CurveArc::GetNgeId( void) const
@@ -554,7 +763,7 @@ CurveArc::Invert( void)
       return false ;
 
   // il centro va spostato di DeltaN
-   if ( m_dDeltaN > EPS_ZERO)
+   if ( fabs( m_dDeltaN) > EPS_ZERO)
       m_PtCen += m_dDeltaN * m_VtN ;
   // il versore normale rimane inalterato
   // il versore iniziale diventa quello finale
@@ -809,6 +1018,113 @@ CurveArc::ToLoc( const Frame3d& frRef)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+CurveArc::InvertN( void)
+{
+  // la curva deve essere validata
+   if ( m_nStatus != OK)
+      return false ;
+
+  // si inverte il verso della normale senza modificare la geometria dell'arco
+   m_VtN *= - 1 ;
+   m_dAngCenDeg *= - 1 ;
+   m_dDeltaN *= - 1 ;
+
+  // imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool 
+CurveArc::ChangeRadius( double dNewRadius)
+{
+  // la curva deve essere validata
+   if ( m_nStatus != OK)
+      return false ;
+
+  // cambio il raggio
+   m_dRad = dNewRadius ;
+
+  // imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+
+  // eseguo validazione
+   m_nStatus = TO_VERIFY ;
+   return Validate() ;
+}
+
+//----------------------------------------------------------------------------
+bool
+CurveArc::ChangeDeltaN( double dNewDeltaN)
+{
+  // la curva deve essere validata
+   if ( m_nStatus != OK)
+      return false ;
+
+  // cambio il parametro
+   m_dDeltaN = dNewDeltaN ;
+
+  // imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+
+  // eseguo validazione
+   m_nStatus = TO_VERIFY ;
+   return Validate() ;
+}
+
+//----------------------------------------------------------------------------
+bool 
+CurveArc::ToAdditional( void)
+{
+  // la curva deve essere validata
+   if ( m_nStatus != OK)
+      return false ;
+  // l'angolo al centro deve essere minore di un giro
+   if ( fabs( m_dAngCenDeg) > ( ANG_FULL - EPS_ANG_SMALL))
+      return false ;
+
+  // basta prendere l'angolo al centro che completa il giro
+   m_dAngCenDeg = - _copysign( 360, m_dAngCenDeg) + m_dAngCenDeg ;
+
+  // imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool 
+CurveArc::Flip( void)
+{
+  // la curva deve essere validata
+   if ( m_nStatus != OK)
+      return false ;
+  // l'angolo al centro deve essere minore di un giro
+   if ( fabs( m_dAngCenDeg) > ( ANG_FULL - EPS_ANG_SMALL))
+      return false ;
+
+  // si calcola l'arco simmetrico rispetto alla linea che unisce gli estremi
+   Point3d ptStart, ptEnd ;
+   if ( ! GetStartPoint( ptStart)  ||  ! GetEndPoint( ptEnd))
+      return false ;
+   // il punto finale mi interessa nel piano dell'arco
+   if ( fabs( m_dDeltaN) > EPS_ZERO)
+      ptEnd -= m_dDeltaN * m_VtN  ;
+   m_PtCen = ptStart + ( ptEnd - m_PtCen) ;
+   m_VtS = ptStart - m_PtCen ;
+   m_VtS.Normalize() ;
+   m_dAngCenDeg = - m_dAngCenDeg ;
+
+  // imposto ricalcolo della grafica
+   m_OGrMgr.Reset() ;
+
+   m_nStatus = TO_VERIFY ;
+   return Validate() ;
+}
+
 //----------------------------------------------------------------------------
 // Oggetto locale per approssimazione di archi
 // Approx interna è quella cordale standard.
diff --git a/CurveArc.h b/CurveArc.h
index 6f5f0eb..2b743cc 100644
--- a/CurveArc.h
+++ b/CurveArc.h
@@ -83,15 +83,18 @@ class CurveArc : public ICurveArc, public IGeoObjRW
       virtual bool Copy( const IGeoObj* pGObjSrc) ;
       virtual bool Set( const Point3d& ptCen, const Vector3d& vtN, double dRad,
                         const Vector3d& vtS, double dAngCenDeg, double dDeltaN) ;
-      virtual bool Set( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& vtN, double dBulge) ;
-      virtual bool Set( const Point3d& ptCen, double dRad, double dAngIniDeg, double dAngCenDeg, double dDeltaZ) ;
       virtual bool Set( const Point3d& ptCen, const Vector3d& vtN, double dRad) ;
-      virtual bool Set( const Point3d& ptCen, double dRad) ;
+      virtual bool SetXY( const Point3d& ptCen, double dRad, double dAngIniDeg, double dAngCenDeg, double dDeltaZ) ;
+      virtual bool SetXY( const Point3d& ptCen, double dRad) ;
+      virtual bool Set3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d& ptEnd, bool bCirc = false) ;
+      virtual bool Set2PNB( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtN, double dBulge) ;
+      virtual bool Set2PD( const Point3d& ptStart, const Point3d& ptEnd, double dDirStartDeg) ;
+      virtual bool Set2PRS( const Point3d& ptStart, const Point3d& ptEnd, double dRad, bool bCCW = true) ;
+      virtual bool SetC2P( const Point3d& ptCen, const Point3d& ptStart, const Point3d& ptNearEnd) ;
       virtual bool IsFlat( void) const
                         { return ( fabs( m_dDeltaN) < EPS_SMALL) ; }
       virtual bool IsACircle( void) const
-                        { return ( fabs( fabs( m_dAngCenDeg) - 360) < EPS_ANG_SMALL  &&
-                                   IsFlat()  &&  IsClosed()) ; }
+                        { return ( IsFlat()  &&  IsClosed()) ; }
       virtual bool IsInPlaneXY( void) const
                         { return ( m_VtN.IsZplus()) ; }
       virtual const Point3d& GetCenter( void) const
@@ -106,6 +109,11 @@ class CurveArc : public ICurveArc, public IGeoObjRW
                         { return m_dAngCenDeg ; } 
       virtual double GetDeltaN( void) const
                         { return m_dDeltaN ; } 
+      virtual bool InvertN( void) ;
+      virtual bool ChangeRadius( double dNewRadius) ;
+      virtual bool ChangeDeltaN( double dNewDeltaN) ;
+      virtual bool ToAdditional( void) ;
+      virtual bool Flip( void) ;
 
    public :                      // IGeoObjRW
       virtual int GetNgeId( void) const ;
diff --git a/CurveComposite.cpp b/CurveComposite.cpp
index 6de2262..4dc5251 100644
--- a/CurveComposite.cpp
+++ b/CurveComposite.cpp
@@ -304,7 +304,7 @@ CurveComposite::FromPointBulgeVector( const UPNTVECTOR& vUPnt, const Vector3d& v
          if ( ! ::IsValid( pCrvArc))
             return false ;
          // setto l'arco
-         if ( ! pCrvArc->Set( vUPnt[i-1].second, vUPnt[i].second, vtN, vUPnt[i-1].first))
+         if ( ! pCrvArc->Set2PNB( vUPnt[i-1].second, vUPnt[i].second, vtN, vUPnt[i-1].first))
             return false ;
         // inserisco l'arco nella curva composta
          if ( ! AddSimpleCurve( Release( pCrvArc)))
diff --git a/CurveLine.cpp b/CurveLine.cpp
index 716b443..8733ff8 100644
--- a/CurveLine.cpp
+++ b/CurveLine.cpp
@@ -53,7 +53,7 @@ CurveLine::Set( const Point3d& ptStart, const Point3d& ptEnd)
 
 //----------------------------------------------------------------------------
 bool
-CurveLine::Set( const Point3d& ptStart, const Vector3d& vtDir, double dLen)
+CurveLine::SetPVL( const Point3d& ptStart, const Vector3d& vtDir, double dLen)
 {
   // assegno i dati
    m_PtStart = ptStart ;
@@ -72,7 +72,7 @@ CurveLine::Set( const Point3d& ptStart, const Vector3d& vtDir, double dLen)
 
 //----------------------------------------------------------------------------
 bool
-CurveLine::Set( const Point3d& ptStart, double dDirAngDeg, double dLen)
+CurveLine::SetPDL( const Point3d& ptStart, double dDirAngDeg, double dLen)
 {
   // assegno i dati
    m_PtStart = ptStart ;
diff --git a/CurveLine.h b/CurveLine.h
index 2556799..e19d2cf 100644
--- a/CurveLine.h
+++ b/CurveLine.h
@@ -82,8 +82,8 @@ class CurveLine : public ICurveLine, public IGeoObjRW
    public :                      // ICurveLine
       virtual bool Copy( const IGeoObj* pGObjSrc) ;
       virtual bool Set( const Point3d& ptStart, const Point3d& ptEnd) ;
-      virtual bool Set( const Point3d& ptStart, const Vector3d& vtDir, double dLen) ;
-      virtual bool Set( const Point3d& ptStart, double dDirAngDeg, double dLen) ;
+      virtual bool SetPVL( const Point3d& ptStart, const Vector3d& vtDir, double dLen) ;
+      virtual bool SetPDL( const Point3d& ptStart, double dDirAngDeg, double dLen) ;
       virtual const Point3d& GetStart( void) const
                        { return m_PtStart ; } 
       virtual const Point3d& GetEnd( void) const
diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc
index 7dc06ef133e7b66db1660348a388a7d7dd4699b7..2977fe3349808b947bef5f13f15cde9fe64b197e 100644
GIT binary patch
delta 81
zcmdlNy)SyhH#SC-&FAG5nSs<t#Zt!2ecT=(_IbJUOp})h<^h?4Qb6G@VNBt@EXaD#
GasvRqrW{@X

delta 81
zcmdlNy)SyhH#SD&&FAG5nSs<t#Zt!2ecT=(_IbJUOp})h<^h?4Qb6G@VNBt@EXaD#
GasvRpbR1Ry

diff --git a/GdbExecutor.cpp b/GdbExecutor.cpp
index f64f594..6d7bddf 100644
--- a/GdbExecutor.cpp
+++ b/GdbExecutor.cpp
@@ -419,269 +419,617 @@ GdbExecutor::ExecuteFrame( const string& sCmd2, const STRVECTOR& vsParams)
 bool
 GdbExecutor::ExecuteCurveLine( const string& sCmd2, const STRVECTOR& vsParams) 
 {
+  // creazione linea da : ptStart, ptEnd
+   if ( sCmd2 == ""  ||  sCmd2 == "MAKE")
+      return CurveLineMake( vsParams) ;
+  // creazione linea da : ptStart, vtDir, dLen
+   else if ( sCmd2 == "VL"  ||  sCmd2 == "VersorLength")
+      return CurveLineVersorLength( vsParams) ;
+  // creazione linea da : ptStart, dDirAngDeg, dLen
+   else if ( sCmd2 == "DL"  ||  sCmd2 == "DirLength")
+      return CurveLineDirLength( vsParams) ;
+  // creazione linea di minima distanza tra punto e curva
+   else if ( sCmd2 == "MPC"  ||  sCmd2 == "MINPOINTCURVE")
+      return CurveLineMinPointCurve( vsParams) ;
+  // altrimenti errore
+   else
+      return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveLineMake( const STRVECTOR& vsParams) 
+{
+  // 4 parametri : Id, IdParent, ptStart, ptEnd
+   if ( vsParams.size() != 4)
+      return false ;
+  // recupero il riferimento in cui è immerso
+   Frame3d frRef ;
+   if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
+      return false ;
+  // recupero punto iniziale
+   Point3d ptStart ;
+   if ( ! GetPointParam( vsParams[2], frRef, ptStart))
+      return false ;
+  // recupero punto finale
+   Point3d ptEnd ;
+   if ( ! GetPointParam( vsParams[3], frRef, ptEnd))
+      return false ;
   // creo la linea
    PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
    if ( ! IsValid( pCrvLine))
       return false ;
-
-  // creazione linea da : ptStart, ptEnd
-   if ( sCmd2 == ""  ||  sCmd2 == "MAKE") {
-     // 4 parametri : Id, IdParent, ptStart, ptEnd
-      if ( vsParams.size() != 4)
-         return false ;
-     // recupero il riferimento in cui è immerso
-      Frame3d frRef ;
-      if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
-         return false ;
-     // recupero punto iniziale
-      Point3d ptStart ;
-      if ( ! GetPointParam( vsParams[2], frRef, ptStart))
-         return false ;
-     // recupero punto finale
-      Point3d ptEnd ;
-      if ( ! GetPointParam( vsParams[3], frRef, ptEnd))
-         return false ;
-     // setto la linea
-      if ( ! pCrvLine->Set( ptStart, ptEnd))
-         return false ;
-   }
-  // creazione linea da : ptStart, vtDir, dLen
-   else if ( sCmd2 == "VL"  ||  sCmd2 == "VersorLength") {
-     // 5 parametri : Id, IdParent, ptStart, vtDir, dLen
-      if ( vsParams.size() != 5)
-         return false ;
-     // recupero il riferimento in cui è immerso
-      Frame3d frRef ;
-      if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
-         return false ;
-     // recupero punto iniziale
-      Point3d ptStart ;
-      if ( ! GetPointParam( vsParams[2], frRef, ptStart))
-         return false ;
-     // recupero vettore direzione
-      Vector3d vtDir ;
-      if ( ! GetVectorParam( vsParams[3], frRef, vtDir))
-         return false ;
-     // recupero lunghezza
-      double dLen ;
-      if ( ! GetLengthParam( vsParams[4], dLen))
-         return false ;
-     // setto la linea
-      if ( ! pCrvLine->Set( ptStart, vtDir, dLen))
-         return false ;
-   }
-  // creazione linea da : ptStart, dDirAngDeg, dLen
-   else if ( sCmd2 == "DL"  ||  sCmd2 == "DirLength") {
-     // 5 parametri : Id, IdParent, ptStart, dAngDeg, dLen
-      if ( vsParams.size() != 5)
-         return false ;
-     // recupero il riferimento in cui è immerso
-      Frame3d frRef ;
-      if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
-         return false ;
-     // recupero punto iniziale
-      Point3d ptStart ;
-      if ( ! GetPointParam( vsParams[2], frRef, ptStart))
-         return false ;
-     // recupero direzione in gradi
-      double dDirAngDeg ;
-      if ( ! GetDirParam( vsParams[3], frRef, dDirAngDeg))
-         return false ;
-     // recupero lunghezza
-      double dLen ;
-      if ( ! GetLengthParam( vsParams[4], dLen))
-         return false ;
-     // setto la linea
-      if ( ! pCrvLine->Set( ptStart, dDirAngDeg, dLen))
-         return false ;
-   }
-  // creazione linea di minima distanza tra punto e curva
-   else if ( sCmd2 == "MPC"  ||  sCmd2 == "MINPOINTCURVE") {
-     // almeno 4 parametri
-      if ( vsParams.size() < 4)
-         return false ;
-     // recupero il riferimento del gruppo destinazione
-      Frame3d frPoint ;
-      if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frPoint))
-         return false ;
-     // recupero il punto
-      Point3d ptStart ;
-      if ( ! GetPointParam( vsParams[2], frPoint, ptStart))
-         return false ;
-     // recupero l'identificativo della curva
-      int nId ;
-      if ( ( nId = GetIdParam( vsParams[3])) == CMD_ID_ERROR)
-         return false ;
-     // recupero il riferimento della curva
-      Frame3d frCurve ;
-      if ( ! m_pGDB->GetGlobFrame( nId, frCurve))
-         return false ;
-     // recupero la curva
-      const ICurve* pCurve =  GetCurve( m_pGDB->GetGeoObj( nId)) ;
-      if ( pCurve == nullptr)
-         return false ;
-     // porto il punto nel riferimento della curva
-      Point3d ptSloc = ptStart ;
-      ptSloc.LocToLoc( frPoint, frCurve) ;
-     // recupero eventuale parametro per discriminare tra più soluzioni
-      double dNearParam ;
-      if ( vsParams.size() < 5  ||  ! FromString( vsParams[4], dNearParam))
-         dNearParam = 0 ;
-     // calcolo il punto a minima distanza
-      int nFlag ;
-      Point3d ptEnd ;
-      DistPointCurve dstPtCurve( ptSloc, *pCurve) ;
-      if ( ! dstPtCurve.GetMinDistPoint( dNearParam, ptEnd, nFlag))
-         return false ;
-     // porto il punto finale nel riferimento di creazione
-      ptEnd.LocToLoc( frCurve, frPoint) ;
-     // setto la linea
-      if ( ! pCrvLine->Set( ptStart, ptEnd))
-         return false ;
-   }
-  // altrimenti errore
-   else
+  // setto la linea
+   if ( ! pCrvLine->Set( ptStart, ptEnd))
       return false ;
-
   // inserisco la linea nel DB
    return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
+}
 
-   return false ;
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveLineVersorLength( const STRVECTOR& vsParams) 
+{
+  // 5 parametri : Id, IdParent, ptStart, vtDir, dLen
+   if ( vsParams.size() != 5)
+      return false ;
+  // recupero il riferimento in cui è immerso
+   Frame3d frRef ;
+   if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
+      return false ;
+  // recupero punto iniziale
+   Point3d ptStart ;
+   if ( ! GetPointParam( vsParams[2], frRef, ptStart))
+      return false ;
+  // recupero vettore direzione
+   Vector3d vtDir ;
+   if ( ! GetVectorParam( vsParams[3], frRef, vtDir))
+      return false ;
+  // recupero lunghezza
+   double dLen ;
+   if ( ! GetLengthParam( vsParams[4], dLen))
+      return false ;
+  // creo la linea
+   PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
+   if ( ! IsValid( pCrvLine))
+      return false ;
+  // setto la linea
+   if ( ! pCrvLine->SetPVL( ptStart, vtDir, dLen))
+      return false ;
+  // inserisco la linea nel DB
+   return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveLineDirLength( const STRVECTOR& vsParams) 
+{
+  // 5 parametri : Id, IdParent, ptStart, dAngDeg, dLen
+   if ( vsParams.size() != 5)
+      return false ;
+  // recupero il riferimento in cui è immerso
+   Frame3d frRef ;
+   if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
+      return false ;
+  // recupero punto iniziale
+   Point3d ptStart ;
+   if ( ! GetPointParam( vsParams[2], frRef, ptStart))
+      return false ;
+  // recupero direzione in gradi
+   double dDirAngDeg ;
+   if ( ! GetDirParam( vsParams[3], frRef, dDirAngDeg))
+      return false ;
+  // recupero lunghezza
+   double dLen ;
+   if ( ! GetLengthParam( vsParams[4], dLen))
+      return false ;
+  // creo la linea
+   PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
+   if ( ! IsValid( pCrvLine))
+      return false ;
+  // setto la linea
+   if ( ! pCrvLine->SetPDL( ptStart, dDirAngDeg, dLen))
+      return false ;
+  // inserisco la linea nel DB
+   return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveLineMinPointCurve( const STRVECTOR& vsParams) 
+{
+  // almeno 4 parametri : Id, IdParent, ptP, IdCrv[, NearParam]
+   if ( vsParams.size() < 4)
+      return false ;
+  // recupero il riferimento del gruppo destinazione
+   Frame3d frPoint ;
+   if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frPoint))
+      return false ;
+  // recupero il punto
+   Point3d ptStart ;
+   if ( ! GetPointParam( vsParams[2], frPoint, ptStart))
+      return false ;
+  // recupero l'identificativo della curva
+   int nId ;
+   if ( ( nId = GetIdParam( vsParams[3])) == CMD_ID_ERROR)
+      return false ;
+  // recupero il riferimento della curva
+   Frame3d frCurve ;
+   if ( ! m_pGDB->GetGlobFrame( nId, frCurve))
+      return false ;
+  // recupero la curva
+   const ICurve* pCurve =  GetCurve( m_pGDB->GetGeoObj( nId)) ;
+   if ( pCurve == nullptr)
+      return false ;
+  // porto il punto nel riferimento della curva
+   Point3d ptSloc = ptStart ;
+   ptSloc.LocToLoc( frPoint, frCurve) ;
+  // recupero eventuale parametro per discriminare tra più soluzioni
+   double dNearParam ;
+   if ( vsParams.size() < 5  ||  ! FromString( vsParams[4], dNearParam))
+      dNearParam = 0 ;
+  // calcolo il punto a minima distanza
+   int nFlag ;
+   Point3d ptEnd ;
+   DistPointCurve dstPtCurve( ptSloc, *pCurve) ;
+   if ( ! dstPtCurve.GetMinDistPoint( dNearParam, ptEnd, nFlag))
+      return false ;
+  // porto il punto finale nel riferimento di creazione
+   ptEnd.LocToLoc( frCurve, frPoint) ;
+  // creo la linea
+   PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
+   if ( ! IsValid( pCrvLine))
+      return false ;
+  // setto la linea
+   if ( ! pCrvLine->Set( ptStart, ptEnd))
+      return false ;
+  // inserisco la linea nel DB
+   return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
 }
 
 //----------------------------------------------------------------------------
 bool
 GdbExecutor::ExecuteCurveArc( const string& sCmd2, const STRVECTOR& vsParams) 
 {
+  // creo arco generico
+   if ( sCmd2 == ""  ||  sCmd2 == "MAKE")
+      return CurveArcMake( vsParams) ;
+  // creo circonferenza
+   else if ( sCmd2 == "C"  ||  sCmd2 == "CIRCLE")
+      return CurveArcCircle( vsParams) ;
+  // creo arco nel piano XY
+   else if ( sCmd2 == "XY"  ||  sCmd2 == "PLANEXY")
+      return CurveArcPlaneXY( vsParams) ;
+  // creo circonferenza nel piano XY
+   else if ( sCmd2 == "CXY"  ||  sCmd2 == "CIRCLEXY")
+      return CurveArcCircleXY( vsParams) ;
+  // creo arco o circonferenza passante per 3 punti
+   else if ( sCmd2 == "3P"  ||  sCmd2 == "C3P")
+      return CurveArc3P( vsParams, ( sCmd2 == "C3P")) ;
+  // creo arco per 2 punti e direzione iniziale
+   else if ( sCmd2 == "2PDI")
+      return CurveArc2PDi( vsParams) ;
+  // creo arco per 2 punti, raggio e senso di rotazione
+   else if ( sCmd2 == "2PRS")
+      return CurveArc2PRS( vsParams) ;
+  // creo arco dato centro, per primo punto e vicino al secondo
+   else if ( sCmd2 == "C2P")
+      return CurveArcC2P( vsParams) ;
+  // inversione della normale
+   else if ( sCmd2 == "INVN"  ||  sCmd2 == "INVERTNORMAL")
+      return CurveArcInvertNormal( vsParams) ;
+  // cambio del raggio
+   else if ( sCmd2 == "CHR"  ||  sCmd2 == "CHANGERADIUS")
+      return CurveArcChangeRadius( vsParams) ;
+  // cambio del deltaN
+   else if ( sCmd2 == "CHDN"  ||  sCmd2 == "CHANGEDELTAN")
+      return CurveArcChangeDeltaN( vsParams) ;
+  // trasformazione nell'arco complementare
+   else if ( sCmd2 == "TA"  ||  sCmd2 == "TOADDITIONAL")
+      return CurveArcToAdditional( vsParams) ;
+  // flip dell'arco
+   else if ( sCmd2 == "F"  ||  sCmd2 == "FLIP")
+      return CurveArcFlip( vsParams) ;
+  // altrimenti errore
+   else
+      return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveArcMake( const STRVECTOR& vsParams)
+{
+  // 8 parametri
+   if ( vsParams.size() != 8)
+      return false ;
+  // recupero il riferimento in cui è immerso
+   Frame3d frRef ;
+   if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
+      return false ;
+  // centro
+   Point3d ptCen ;
+   if ( ! GetPointParam( vsParams[2], frRef, ptCen))
+      return false ;
+  // versore ortogonale al piano della circonferenza
+   Vector3d vtN ;
+   if ( ! GetVectorParam( vsParams[3], frRef, vtN))
+      return false ;
+  // raggio
+   double dRad ;
+   if ( ! GetLengthParam( vsParams[4], dRad))
+      return false ;
+  // versore iniziale
+   Vector3d vtS ;
+   if ( ! GetVectorParam( vsParams[5], frRef, vtS))
+      return false ;
+  // angolo al centro
+   double dAngCenDeg ;
+   if ( ! FromString( vsParams[6], dAngCenDeg))
+      return false ;
+  // deltaZ
+   double dDeltaZ ;
+   if ( ! GetLengthParam( vsParams[7], dDeltaZ))
+      return false ;
   // creo l'arco
    PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
    if ( ! IsValid( pCrvArc))
       return false ;
-
-  // arco generico
-   if ( sCmd2 == ""  ||  sCmd2 == "MAKE") {
-     // 8 parametri
-      if ( vsParams.size() != 8)
-         return false ;
-     // recupero il riferimento in cui è immerso
-      Frame3d frRef ;
-      if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
-         return false ;
-     // centro
-      Point3d ptCen ;
-      if ( ! GetPointParam( vsParams[2], frRef, ptCen))
-         return false ;
-     // versore ortogonale al piano della circonferenza
-      Vector3d vtN ;
-      if ( ! GetVectorParam( vsParams[3], frRef, vtN))
-         return false ;
-     // raggio
-      double dRad ;
-      if ( ! FromString( vsParams[4], dRad))
-         return false ;
-     // versore iniziale
-      Vector3d vtS ;
-      if ( ! GetVectorParam( vsParams[5], frRef, vtS))
-         return false ;
-     // angolo al centro
-      double dAngCenDeg ;
-      if ( ! FromString( vsParams[6], dAngCenDeg))
-         return false ;
-     // deltaZ
-      double dDeltaZ ;
-      if ( ! FromString( vsParams[7], dDeltaZ))
-         return false ;
-     // setto l'arco
-      if ( ! pCrvArc->Set( ptCen, vtN, dRad, vtS, dAngCenDeg, dDeltaZ))
-         return false ;
-   }
-  // arco nel piano XY
-   else if ( sCmd2 == "XY"  ||  sCmd2 == "PLANEXY") {
-     // 7 parametri
-      if ( vsParams.size() != 7)
-         return false ;
-     // recupero il riferimento in cui è immerso
-      Frame3d frRef ;
-      if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
-         return false ;
-     // centro
-      Point3d ptCen ;
-      if ( ! GetPointParam( vsParams[2], frRef, ptCen))
-         return false ;
-     // raggio
-      double dRad ;
-      if ( ! FromString( vsParams[3], dRad))
-         return false ;
-     // angolo iniziale
-      double dAngIniDeg ;
-      if ( ! FromString( vsParams[4], dAngIniDeg))
-         return false ;
-     // angolo al centro
-      double dAngCenDeg ;
-      if ( ! FromString( vsParams[5], dAngCenDeg))
-         return false ;
-     // deltaZ
-      double dDeltaZ ;
-      if ( ! FromString( vsParams[6], dDeltaZ))
-         return false ;
-     // setto l'arco
-      if ( ! pCrvArc->Set( ptCen, dRad, dAngIniDeg, dAngCenDeg, dDeltaZ))
-         return false ;
-   }
-  // circonferenza
-   else if ( sCmd2 == "C"  ||  sCmd2 == "CIRCLE") {
-     // 5 parametri
-      if ( vsParams.size() != 5)
-         return false ;
-     // recupero il riferimento in cui è immerso
-      Frame3d frRef ;
-      if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
-         return false ;
-     // centro
-      Point3d ptCen ;
-      if ( ! GetPointParam( vsParams[2], frRef, ptCen))
-         return false ;
-     // versore ortogonale al piano della circonferenza
-      Vector3d vtN ;
-      if ( ! GetVectorParam( vsParams[3], frRef, vtN))
-         return false ;
-     // raggio
-      double dRad ;
-      if ( ! FromString( vsParams[4], dRad))
-         return false ;
-     // setto l'arco
-      if ( ! pCrvArc->Set( ptCen, vtN, dRad))
-         return false ;
-   }
-  // circonferenza nel piano XY
-   else if ( sCmd2 == "CXY"  ||  sCmd2 == "CIRCLEXY") {
-     // 4 parametri
-      if ( vsParams.size() != 4)
-         return false ;
-     // recupero il riferimento in cui è immerso
-      Frame3d frRef ;
-      if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
-         return false ;
-     // centro
-      Point3d ptCen ;
-      if ( ! GetPointParam( vsParams[2], frRef, ptCen))
-         return false ;
-     // raggio
-      double dRad ;
-      if ( ! FromString( vsParams[3], dRad))
-         return false ;
-     // setto l'arco
-      if ( ! pCrvArc->Set( ptCen, dRad))
-         return false ;
-   }
-  // altrimenti errore
-   else
+  // setto l'arco
+   if ( ! pCrvArc->Set( ptCen, vtN, dRad, vtS, dAngCenDeg, dDeltaZ))
       return false ;
-
   // inserisco l'arco nel DB
    return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
 }
 
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveArcPlaneXY( const STRVECTOR& vsParams)
+{
+  // 7 parametri
+   if ( vsParams.size() != 7)
+      return false ;
+  // recupero il riferimento in cui è immerso
+   Frame3d frRef ;
+   if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
+      return false ;
+  // centro
+   Point3d ptCen ;
+   if ( ! GetPointParam( vsParams[2], frRef, ptCen))
+      return false ;
+  // raggio
+   double dRad ;
+   if ( ! GetLengthParam( vsParams[3], dRad))
+      return false ;
+  // angolo iniziale
+   double dAngIniDeg ;
+   if ( ! GetDirParam( vsParams[4], frRef, dAngIniDeg))
+      return false ;
+  // angolo al centro
+   double dAngCenDeg ;
+   if ( ! FromString( vsParams[5], dAngCenDeg))
+      return false ;
+  // deltaZ
+   double dDeltaZ ;
+   if ( ! GetLengthParam( vsParams[6], dDeltaZ))
+      return false ;
+  // creo l'arco
+   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
+   if ( ! IsValid( pCrvArc))
+      return false ;
+  // setto l'arco
+   if ( ! pCrvArc->SetXY( ptCen, dRad, dAngIniDeg, dAngCenDeg, dDeltaZ))
+      return false ;
+  // inserisco l'arco nel DB
+   return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveArcCircle( const STRVECTOR& vsParams)
+{
+  // 5 parametri
+   if ( vsParams.size() != 5)
+      return false ;
+  // recupero il riferimento in cui è immerso
+   Frame3d frRef ;
+   if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
+      return false ;
+  // centro
+   Point3d ptCen ;
+   if ( ! GetPointParam( vsParams[2], frRef, ptCen))
+      return false ;
+  // versore ortogonale al piano della circonferenza
+   Vector3d vtN ;
+   if ( ! GetVectorParam( vsParams[3], frRef, vtN))
+      return false ;
+  // raggio
+   double dRad ;
+   if ( ! GetLengthParam( vsParams[4], dRad))
+      return false ;
+  // creo l'arco
+   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
+   if ( ! IsValid( pCrvArc))
+      return false ;
+  // setto l'arco
+   if ( ! pCrvArc->Set( ptCen, vtN, dRad))
+      return false ;
+  // inserisco l'arco nel DB
+   return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveArcCircleXY( const STRVECTOR& vsParams)
+{
+  // 4 parametri
+   if ( vsParams.size() != 4)
+      return false ;
+  // recupero il riferimento in cui è immerso
+   Frame3d frRef ;
+   if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
+      return false ;
+  // centro
+   Point3d ptCen ;
+   if ( ! GetPointParam( vsParams[2], frRef, ptCen))
+      return false ;
+  // raggio
+   double dRad ;
+   if ( ! GetLengthParam( vsParams[3], dRad))
+      return false ;
+  // creo l'arco
+   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
+   if ( ! IsValid( pCrvArc))
+      return false ;
+  // setto l'arco
+   if ( ! pCrvArc->SetXY( ptCen, dRad))
+      return false ;
+  // inserisco l'arco nel DB
+   return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveArc3P( const STRVECTOR& vsParams, bool bCirc)
+{
+  // 5 parametri : Id, ParentId, ptP0, ptP1, ptP2
+   if ( vsParams.size() != 5)
+      return false ;
+  // recupero il riferimento in cui è immerso
+   Frame3d frRef ;
+   if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
+      return false ;
+  // primo punto
+   Point3d ptP0 ;
+   if ( ! GetPointParam( vsParams[2], frRef, ptP0))
+      return false ;
+  // secondo punto
+   Point3d ptP1 ;
+   if ( ! GetPointParam( vsParams[3], frRef, ptP1))
+      return false ;
+  // terzo punto
+   Point3d ptP2 ;
+   if ( ! GetPointParam( vsParams[4], frRef, ptP2))
+      return false ;
+  // creo l'arco
+   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
+   if ( ! IsValid( pCrvArc))
+      return false ;
+  // setto l'arco
+   if ( ! pCrvArc->Set3P( ptP0, ptP1, ptP2, bCirc))
+      return false ;
+  // inserisco l'arco nel DB
+   return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveArc2PDi( const STRVECTOR& vsParams)
+{
+  // 5 parametri : Id, ParentId, ptPi, ptPf, dDiri
+   if ( vsParams.size() != 5)
+      return false ;
+  // recupero il riferimento in cui è immerso
+   Frame3d frRef ;
+   if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
+      return false ;
+  // punto iniziale
+   Point3d ptPi ;
+   if ( ! GetPointParam( vsParams[2], frRef, ptPi))
+      return false ;
+  // punto finale
+   Point3d ptPf ;
+   if ( ! GetPointParam( vsParams[3], frRef, ptPf))
+      return false ;
+  // direzione iniziale
+   double dDirI ;
+   if ( ! GetDirParam( vsParams[4], frRef, dDirI))
+      return false ;
+  // creo l'arco
+   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
+   if ( ! IsValid( pCrvArc))
+      return false ;
+  // setto l'arco
+   if ( ! pCrvArc->Set2PD( ptPi, ptPf, dDirI))
+      return false ;
+  // inserisco l'arco nel DB
+   return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveArc2PRS( const STRVECTOR& vsParams)
+{
+  // 5 o 6 parametri : Id, ParentId, ptPi, ptPf, dRad[, CCW/CW]
+   if ( vsParams.size() != 5  &&  vsParams.size() != 6)
+      return false ;
+  // recupero il riferimento in cui è immerso
+   Frame3d frRef ;
+   if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
+      return false ;
+  // punto iniziale
+   Point3d ptPi ;
+   if ( ! GetPointParam( vsParams[2], frRef, ptPi))
+      return false ;
+  // punto finale
+   Point3d ptPf ;
+   if ( ! GetPointParam( vsParams[3], frRef, ptPf))
+      return false ;
+  // raggio
+   double dRad ;
+   if ( ! GetLengthParam( vsParams[4], dRad))
+      return false ;
+  // senso di rotazione
+   bool bCCW = true ;
+   if ( vsParams.size() >= 6  &&  vsParams[5] == "CW")
+      bCCW = false ;
+  // creo l'arco
+   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
+   if ( ! IsValid( pCrvArc))
+      return false ;
+  // setto l'arco
+   if ( ! pCrvArc->Set2PRS( ptPi, ptPf, dRad, bCCW))
+      return false ;
+  // inserisco l'arco nel DB
+   return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveArcC2P( const STRVECTOR& vsParams)
+{
+  // 5 parametri : Id, ParentId, ptCen, ptPi, ptNearPf
+   if ( vsParams.size() != 5)
+      return false ;
+  // recupero il riferimento in cui è immerso
+   Frame3d frRef ;
+   if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
+      return false ;
+  // centro
+   Point3d ptCen ;
+   if ( ! GetPointParam( vsParams[2], frRef, ptCen))
+      return false ;
+  // punto iniziale
+   Point3d ptPi ;
+   if ( ! GetPointParam( vsParams[3], frRef, ptPi))
+      return false ;
+  // punto vicino al finale (direzione da centro esatta)
+   Point3d ptNearPf ;
+   if ( ! GetPointParam( vsParams[4], frRef, ptNearPf))
+      return false ;
+  // creo l'arco
+   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
+   if ( ! IsValid( pCrvArc))
+      return false ;
+  // setto l'arco
+   if ( ! pCrvArc->SetC2P( ptCen, ptPi, ptNearPf))
+      return false ;
+  // inserisco l'arco nel DB
+   return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveArcInvertNormal( const STRVECTOR& vsParams)
+{
+  // 1 parametro : Id
+   if ( vsParams.size() != 1)
+      return false ;
+  // recupero l'arco
+   ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ; 
+   if ( pCrvArc == nullptr)
+      return false ;
+  // eseguo l'operazione
+   return pCrvArc->InvertN() ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveArcChangeRadius( const STRVECTOR& vsParams)
+{
+  // 2 parametrio : Id, dNewRad
+   if ( vsParams.size() != 2)
+      return false ;
+  // recupero lista Id
+   INTVECTOR vnNames ;
+   if ( ! GetNamesParam( vsParams[0], vnNames))
+      return false ;
+  // leggo il nuovo raggio
+   double dNewRad ;
+   if ( ! GetLengthParam( vsParams[1], dNewRad))
+      return false ;
+  // esecuzione
+   INTVECTOR::iterator Iter ;
+   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+     // recupero l'arco
+      ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( *Iter)) ; 
+      if ( pCrvArc == nullptr)
+         return false ;
+     // eseguo l'operazione
+      if ( ! pCrvArc->ChangeRadius( dNewRad))
+         return false ;
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveArcChangeDeltaN( const STRVECTOR& vsParams)
+{
+  // 2 parametro : Id, dNewDeltaN
+   if ( vsParams.size() != 2)
+      return false ;
+  // recupero lista Id
+   INTVECTOR vnNames ;
+   if ( ! GetNamesParam( vsParams[0], vnNames))
+      return false ;
+  // leggo il nuovo delta
+   double dNewDeltaN ;
+   if ( ! GetLengthParam( vsParams[1], dNewDeltaN))
+      return false ;
+  // esecuzione
+   INTVECTOR::iterator Iter ;
+   for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
+     // recupero l'arco
+      ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( *Iter)) ; 
+      if ( pCrvArc == nullptr)
+         return false ;
+     // eseguo l'operazione
+      if ( ! pCrvArc->ChangeDeltaN( dNewDeltaN))
+         return false ;
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveArcToAdditional( const STRVECTOR& vsParams)
+{
+  // 1 parametro : Id
+   if ( vsParams.size() != 1)
+      return false ;
+  // recupero l'arco
+   ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ; 
+   if ( pCrvArc == nullptr)
+      return false ;
+  // eseguo l'operazione
+   return pCrvArc->ToAdditional() ;
+}
+
+//----------------------------------------------------------------------------
+bool
+GdbExecutor::CurveArcFlip( const STRVECTOR& vsParams)
+{
+  // 1 parametro : Id
+   if ( vsParams.size() != 1)
+      return false ;
+  // recupero l'arco
+   ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ; 
+   if ( pCrvArc == nullptr)
+      return false ;
+  // eseguo l'operazione
+   return pCrvArc->Flip() ;
+}
+
 //----------------------------------------------------------------------------
 bool
 GdbExecutor::ExecuteCurveBez( const string& sCmd2, const STRVECTOR& vsParams) 
@@ -1704,6 +2052,30 @@ GdbExecutor::GetLengthParam( const string& sParam, double& dLen)
       }
       return false ;
    }
+  // se raggio notevole
+   else if ( sParam[0] == 'R') {
+     // recupero i parametri associati
+      STRVECTOR vsParams ;
+      Tokenize( sParam.substr( 1), ",", vsParams) ;
+      STRVECTOR::iterator Iter ;
+      for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
+         Trim( (*Iter), " \t\r\n()") ;
+     // ci deve essere almeno un parametro
+      if ( vsParams.size() < 1)
+         return false ;
+     // recupero l'entità indicata dal primo parametro
+      const IGeoObj* pGObj ;
+      if ( ( pGObj = m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) == nullptr)
+         return false ;
+     // se arco
+      if ( pGObj->GetType() == CRV_ARC) {
+        // recupero l'arco
+         const ICurveArc* pCrvArc = GetCurveArc( pGObj) ;
+         dLen = pCrvArc->GetRadius() ;
+         return true ;
+      }
+      return false ;
+   }
   // altrimenti valore numerico
    else {
       return FromString( sParam, dLen) ;
diff --git a/GdbExecutor.h b/GdbExecutor.h
index 3b75a50..5993c4b 100644
--- a/GdbExecutor.h
+++ b/GdbExecutor.h
@@ -53,7 +53,24 @@ class GdbExecutor : public IGdbExecutor
       bool ExecuteVector( const std::string& sCmd2, const STRVECTOR& vsParams) ;
       bool ExecuteFrame( const std::string& sCmd2, const STRVECTOR& vsParams) ;
       bool ExecuteCurveLine( const std::string& sCmd2, const STRVECTOR& vsParams) ;
+      bool CurveLineMake( const STRVECTOR& vsParams) ;
+      bool CurveLineVersorLength( const STRVECTOR& vsParams) ;
+      bool CurveLineDirLength( const STRVECTOR& vsParams) ;
+      bool CurveLineMinPointCurve( const STRVECTOR& vsParams) ;
       bool ExecuteCurveArc( const std::string& sCmd2, const STRVECTOR& vsParams) ;
+      bool CurveArcMake( const STRVECTOR& vsParams) ;
+      bool CurveArcPlaneXY( const STRVECTOR& vsParams) ;
+      bool CurveArcCircle( const STRVECTOR& vsParams) ;
+      bool CurveArcCircleXY( const STRVECTOR& vsParams) ;
+      bool CurveArc3P( const STRVECTOR& vsParams, bool bCirc) ;
+      bool CurveArc2PDi( const STRVECTOR& vsParams) ;
+      bool CurveArc2PRS( const STRVECTOR& vsParams) ;
+      bool CurveArcC2P( const STRVECTOR& vsParams) ;
+      bool CurveArcInvertNormal( const STRVECTOR& vsParams) ;
+      bool CurveArcChangeRadius( const STRVECTOR& vsParams) ;
+      bool CurveArcChangeDeltaN( const STRVECTOR& vsParams) ;
+      bool CurveArcToAdditional( const STRVECTOR& vsParams) ;
+      bool CurveArcFlip( const STRVECTOR& vsParams) ;
       bool ExecuteCurveBez( const std::string& sCmd2, const STRVECTOR& vsParams) ;
       bool ExecuteCurveCompo( const std::string& sCmd2, const STRVECTOR& vsParams) ;
       bool CurveCompoMake( const STRVECTOR& vsParams) ;