diff --git a/EGkExtText.h b/EGkExtText.h
index 581c327..255a25c 100644
--- a/EGkExtText.h
+++ b/EGkExtText.h
@@ -20,7 +20,7 @@
 class __declspec( novtable) IExtText : public IGeoObj
 {
    public :
-      virtual bool Copy( const IGeoObj* pGObjSrc) = 0 ;
+      virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
       virtual bool Set( const std::string& sText, const Point3d& ptP, double dAngDeg, double dH) = 0 ;
       virtual bool Set( const std::string& sText, const Point3d& ptP, double dAngDeg,
                         const std::string& sFont, int nW, bool bItl, double dH, double dRat, double dAddAdv,
diff --git a/EGkGeoConst.h b/EGkGeoConst.h
index f8176ec..849d499 100644
--- a/EGkGeoConst.h
+++ b/EGkGeoConst.h
@@ -23,7 +23,7 @@ const double ONEINCH = 25.4 ;
 const double EPS_SMALL = 1e-3 ;
 const double EPS_ZERO  = 1e-7 ;
 const double EPS_PARAM = 1e-7 ;
-const double HSPAN_PARAM = 0.5 ;   // metà intervallo di curva o superficie semplici
+const double SPAN_PARAM = 1.0 ;    // intervallo di curva o superficie semplici
 
 // infinito per lunghezze
 const double INFINITO = 1e10 ;
diff --git a/EGkGeoFrame3d.h b/EGkGeoFrame3d.h
index 213ff1e..353958c 100644
--- a/EGkGeoFrame3d.h
+++ b/EGkGeoFrame3d.h
@@ -21,7 +21,7 @@ class PolyLine ;
 class __declspec( novtable) IGeoFrame3d : public IGeoObj
 {
    public :
-      virtual bool Copy( const IGeoObj* pGObjSrc) = 0 ;
+      virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
       virtual bool Set( const Point3d& ptOrig, const Vector3d& vtDirX, 
                         const Vector3d& vtDirY, const Vector3d& vtDirZ) = 0 ;
       virtual bool Set( const Point3d& ptOrig, const Point3d& ptOnX, const Point3d& ptNearY) = 0 ;
diff --git a/EGkGeoPoint3d.h b/EGkGeoPoint3d.h
index 708b799..2ca7067 100644
--- a/EGkGeoPoint3d.h
+++ b/EGkGeoPoint3d.h
@@ -19,7 +19,7 @@
 class __declspec( novtable) IGeoPoint3d : public IGeoObj
 {
    public :
-      virtual bool Copy( const IGeoObj* pGObjSrc) = 0 ;
+      virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
       virtual bool Set( const Point3d& ptP) = 0 ;
       virtual const Point3d& GetPoint( void) const = 0 ;
 } ;
diff --git a/EGkGeoVector3d.h b/EGkGeoVector3d.h
index 40c1a78..b7ab079 100644
--- a/EGkGeoVector3d.h
+++ b/EGkGeoVector3d.h
@@ -21,7 +21,7 @@ class PolyLine ;
 class __declspec( novtable) IGeoVector3d : public IGeoObj
 {
    public :
-      virtual bool Copy( const IGeoObj* pGObjSrc) = 0 ;
+      virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
       virtual bool Set( const Vector3d& vtV) = 0 ;
       virtual bool Set( const Vector3d& vtV, const Point3d& ptBase) = 0 ;
       virtual const Vector3d& GetVector( void) const = 0 ;
diff --git a/EGkIntersCurveCurve.h b/EGkIntersCurveCurve.h
index 067c9f1..4382891 100644
--- a/EGkIntersCurveCurve.h
+++ b/EGkIntersCurveCurve.h
@@ -26,8 +26,8 @@
 
 
 //-----------------------------------------------------------------------------
+//! dati di intersezione relativi ad una curva
 struct IntCrvInfo {
-  // dati di intersezione relativi ad una curva
    double  dU ;             //!< parametro
    Point3d ptI ;            //!< punto sulla curva (Z della curva, intersezione a Z=0)
    int     nPrevTy ;        //!< tipo di approccio (precedente l'intersezione)
@@ -36,8 +36,8 @@ struct IntCrvInfo {
    IntCrvInfo( void)
       : dU( 0), ptI(), nPrevTy( 0), nNextTy(0) {}
 } ;
+//! dati di intersezione delle due curve A e B
 struct IntCrvCrvInfo {
-  // dati di intersezione delle due curve A e B
    bool bOverlap ;          //!< intersezione con overlap
    bool bCBOverEq ;         //!< overlap su curva B equiverso o controverso con curva A
    IntCrvInfo IciA[2] ;     //!< IciA[0] intersez. isolata o inizio overlap, IciA[1] fine overlap 
@@ -46,7 +46,8 @@ struct IntCrvCrvInfo {
    IntCrvCrvInfo( void)
       : bOverlap( false) {}
 } ;
-typedef std::vector<IntCrvCrvInfo>  ICCIVECTOR ;   // vettore di IntCrvCrvInfo
+//! vettore di IntCrvCrvInfo
+typedef std::vector<IntCrvCrvInfo>  ICCIVECTOR ;
 
 //-----------------------------------------------------------------------------
 // Tipo di intersezione
@@ -54,11 +55,11 @@ typedef std::vector<IntCrvCrvInfo>  ICCIVECTOR ;   // vettore di IntCrvCrvInfo
 // sovrapposta equiversa         bOverlap = true     bCBOverEq = true
 // sovrapposta controversa       bOverlap = true     bCBOverEq = false
 // Costanti per tipo di approccio/allontanamento dall'intersezione
-const int ICCT_NULL = 0 ;
-const int ICCT_IN = 1 ;
-const int ICCT_ON = 2 ;
-const int ICCT_OUT = 3 ;
-// Calcolo del tipo duale
+const int ICCT_NULL = 0 ;              //!< Approccio/allontanamento non definito
+const int ICCT_IN = 1 ;                //!< Approccio/allontanamento interno
+const int ICCT_OUT = 2 ;               //!< Approccio/allontanamento esterno
+const int ICCT_ON = 3 ;                //!< Approccio/allontanamento sovrapposto
+//! Calcolo del tipo duale
 inline int GetDualIcct( int nType)
              { switch ( nType) {
                case ICCT_IN : return ICCT_OUT ;
@@ -67,22 +68,54 @@ inline int GetDualIcct( int nType)
                }}
 
 //-----------------------------------------------------------------------------
+//! Classificazione di parti di curva rispetto ad altra curva chiusa
+struct CrvClass {
+   double dParS ;
+   double dParE ;
+   int    nClass ;
+  // costruttore
+   CrvClass( void)
+      : dParS( 0), dParE( 0), nClass( 0) {}
+} ;
+//! Vettore di CrvClass
+typedef std::vector<CrvClass>  CRVCVECTOR ;
+
+//-----------------------------------------------------------------------------
+// Costanti per classe parti di curva rispetto a curva chiusa
+const int CRVC_NULL = 0 ;              //!< Parte di curva non classificabile
+const int CRVC_IN = 1 ;                //!< Parte di curva interna
+const int CRVC_OUT = 2 ;               //!< Parte di curva esterna
+const int CRVC_ON_P = 3 ;              //!< Parte di curva sovrapposta equiversa
+const int CRVC_ON_M = 4 ;              //!< Parte di curva sovrapposta controversa
+
+//-----------------------------------------------------------------------------
+//! Classe per calcolo intersezione tra due curve nel piano XY locale
 class IntersCurveCurve
 {
    public :
       //! Le intersezioni sono calcolate nel piano XY locale.<br/>
-      //! Il flag bIsSegment vale solo per le linee.
-      EGK_EXPORT IntersCurveCurve( const ICurve& CurveA, const ICurve& CurveB, bool bIsSegment = true) ;
+      //! Il flag bAreSegments vale solo per intersezione tra due linee e riguarda entrambe.
+      EGK_EXPORT IntersCurveCurve( const ICurve& CurveA, const ICurve& CurveB, bool bAreSegments = true) ;
 
    public :
+      //! Indica la presenza di intersezioni con sovrapposizioni
       EGK_EXPORT bool GetOverlaps( void) ;
+      //! Restituisce il numero di intersezioni (intersezioni doppie coincidenti e sovrapposte contano uno)
       EGK_EXPORT int  GetNumInters( void) ;
+      //! Restituisce informazioni sull'intersezione di indice nInd ( 0 based)
       EGK_EXPORT bool GetIntCrvCrvInfo( int nInd, IntCrvCrvInfo& aInfo) ;
+      //! Restituisce il punto di intersezione più vicino al punto passato
       EGK_EXPORT bool GetIntersPointNearTo( int nCrv, const Point3d& ptNear, Point3d& ptI) ;
+      //! Restituisce la classificazione di una curva rispetto all'altra ( nCrv=0 -> CurvaA, nCrv=1 -> CurvaB)
+      EGK_EXPORT bool GetCurveClassification( int nCrv, CRVCVECTOR& ccClass) ;
 
    private :
-      void LineLineCalculate( const ICurve& CurveA, const ICurve& CurveB, bool bIsSegment) ;
+      void LineLineCalculate( const ICurve& CurveA, const ICurve& CurveB, bool bAreSegments) ;
+      void LineCrvCompoCalculate( const ICurve& CurveA, const ICurve& CurveB) ;
+      void CrvCompoLineCalculate( const ICurve& CurveA, const ICurve& CurveB) ;
       void CrvCompoCrvCompoCalculate( const ICurve& CurveA, const ICurve& CurveB) ;
+      bool CalcCurveClassification( const ICurve* pCurve, const ICCIVECTOR& Info, CRVCVECTOR& ccClass) ;
+      bool CalcCurveInOrOut( const ICurve* pCurveA, const ICurve* pCurveB, CRVCVECTOR& ccClass) ;
 
    private :
       bool          m_bOverlaps ;
diff --git a/EGkPoint3d.h b/EGkPoint3d.h
index 76082c3..b8ddeb2 100644
--- a/EGkPoint3d.h
+++ b/EGkPoint3d.h
@@ -30,60 +30,80 @@ class Frame3d ;
 class EGK_EXPORT Point3d
 {
    public :
+      //! Costruttore del punto con tre componenti X, Y e Z
       Point3d( double dX, double dY, double dZ) : x( dX), y( dY), z( dZ) {}
+      //! Costruttore del punto con due componenti X e Y, Z = 0
       Point3d( double dX, double dY) : x( dX), y( dY), z( 0) {}
+      //! Costruttore del punto origine X = Y = Z = 0
       Point3d( void) : x( 0), y( 0), z( 0) {}
+      //! Assegnazione delle componenti X, Y e Z al punto
       void Set( double dX, double dY, double dZ) { x = dX ; y = dY ; z = dZ ;}
+      //! Copia
       const Point3d& operator =( const Point3d& ptSrc)
                      { if ( &ptSrc != this) {
                           x = ptSrc.x , y = ptSrc.y , z = ptSrc.z ; }
                        return *this ; }
 
    public :
+      //! Verifica se il punto è quasi l'origine
       bool IsSmall( void) const
              { return ( ( x * x + y * y + z * z) < ( EPS_SMALL * EPS_SMALL)) ; }
+      //! Verifica se il punto è esattamente l'origine
       bool IsZero( void) const
              { return ( ( x * x + y * y + z * z) < ( EPS_ZERO * EPS_ZERO)) ; }
+      //! Somma sul posto con un vettore
       const Point3d& operator +=( const Vector3d& vtV)
              { this->x += vtV.x ; this->y += vtV.y ; this->z += vtV.z ; return *this ; }
+      //! Sottrazione sul posto con un vettore
       const Point3d& operator -=( const Vector3d& vtV)
              { this->x -= vtV.x ; this->y -= vtV.y ; this->z -= vtV.z ; return *this ; }
-      // questa somma è valida solo se equivalente ad una combinazione baricentrica
+      //! Somma sul posto con un altro punto (valida solo se equivalente ad una combinazione baricentrica)
       const Point3d& operator +=( const Point3d& ptP)
              { this->x += ptP.x ; this->y += ptP.y ; this->z += ptP.z ; return *this ; }
+      //! Moltiplicazione sul posto con un numero
       const Point3d& operator *=( double dMul)
              { this->x *= dMul ; this->y *= dMul ; this->z *= dMul ; return *this ; }
+      //! Divisione sul posto con un numero
       const Point3d& operator /=( double dDiv)
              { double dMul = 1 / dDiv ; this->x *= dMul ; this->y *= dMul ; this->z *= dMul ; return *this ; }
+      //! Traslazione dato il vettore di movimento
       void Translate( const Vector3d& vtMove) ;
+      //! Rotazione attorno ad un asse per un punto, dato l'angolo in gradi
       bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dAngDeg) ;
+      //! Rotazione attorno ad un asse per un punto, dati coseno e seno dell'angolo di rotazione
       bool Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) ;
+      //! Scalatura non uniforme
       bool Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) ;
+      //! Specchiatura
       bool Mirror( const Point3d& ptOn, const Vector3d& vtNorm) ;
+      //! Scorrimento
       bool Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDir, double dCoeff) ;
+      //! Cambio di riferimento : dal riferimento al globale
       bool ToGlob( const Frame3d& frRef) ;
+      //! Cambio di riferimento : dal globale al riferimento
       bool ToLoc( const Frame3d& frRef) ;
+      //! Cambio di riferimento : dal primo riferimento al secondo
       bool LocToLoc( const Frame3d& frOri, const Frame3d& frDest) ;
 
    public :
       union {
          struct {
-            double x ;
-            double y ;
-            double z ;
+            double x ;      //!< coordinata sull'asse X
+            double y ;      //!< coordinata sull'asse Y
+            double z ;      //!< coordinata sull'asse Z
          } ;
-         double v[3] ;
+         double v[3] ;      //!< equivalente vettoriale delle tre coordinate
       } ;
 } ;
 
 //----------------------------------------------------------------------------
 // Punti notevoli
 //----------------------------------------------------------------------------
+//! Punto origine
 const Point3d ORIG( 0, 0, 0) ;
 
 //----------------------------------------------------------------------------
-// Somma di due punti
-// (valida solo se equivalente ad una combinazione baricentrica).
+//! Somma di due punti (valida solo se equivalente ad una combinazione baricentrica)
 //----------------------------------------------------------------------------
 inline Point3d 
 operator+( const Point3d& ptP1, const Point3d& ptP2)
@@ -92,7 +112,7 @@ operator+( const Point3d& ptP1, const Point3d& ptP2)
 }
 
 //----------------------------------------------------------------------------
-// Somma di un punto e un vettore
+//! Somma di un punto e un vettore
 //----------------------------------------------------------------------------
 inline Point3d 
 operator+( const Point3d& ptP1, const Vector3d& vtV2)
@@ -101,7 +121,7 @@ operator+( const Point3d& ptP1, const Vector3d& vtV2)
 }
 
 //----------------------------------------------------------------------------
-// Opposto di un punto
+//! Opposto di un punto
 //----------------------------------------------------------------------------
 inline Vector3d 
 operator-( const Point3d& ptP)
@@ -110,7 +130,7 @@ operator-( const Point3d& ptP)
 }
 
 //----------------------------------------------------------------------------
-// Differenza di due punti, genera un vettore
+//! Differenza di due punti, genera un vettore
 //----------------------------------------------------------------------------
 inline Vector3d 
 operator-( const Point3d& ptP1, const Point3d& ptP2)
@@ -119,7 +139,7 @@ operator-( const Point3d& ptP1, const Point3d& ptP2)
 }
 
 //----------------------------------------------------------------------------
-// Sottrazione di un punto e un vettore
+//! Sottrazione di un punto e un vettore
 //----------------------------------------------------------------------------
 inline Point3d 
 operator-( const Point3d& ptP1, const Vector3d& vtV2)
@@ -128,7 +148,7 @@ operator-( const Point3d& ptP1, const Vector3d& vtV2)
 }
 
 //----------------------------------------------------------------------------
-// Prodotto con uno scalare
+//! Prodotto con uno scalare
 //----------------------------------------------------------------------------
 inline Point3d 
 operator*( const Point3d& ptP, double dMul)
@@ -136,6 +156,8 @@ operator*( const Point3d& ptP, double dMul)
    return Point3d( ptP.x * dMul, ptP.y * dMul, ptP.z * dMul) ; 
 }
 
+//----------------------------------------------------------------------------
+//! Prodotto di uno scalare con un punto
 //----------------------------------------------------------------------------
 inline Point3d 
 operator*( double dMul, const Point3d& ptP)
@@ -144,7 +166,7 @@ operator*( double dMul, const Point3d& ptP)
 }
 
 //----------------------------------------------------------------------------
-// Divisione per uno scalare
+//! Divisione per uno scalare
 //----------------------------------------------------------------------------
 inline Point3d 
 operator/( const Point3d& ptP, double dDiv)
@@ -156,7 +178,7 @@ operator/( const Point3d& ptP, double dDiv)
 }
 
 //----------------------------------------------------------------------------
-// Somma mediata di due punti (baricentrica)
+//! Somma mediata di due punti (baricentrica)
 //----------------------------------------------------------------------------
 inline Point3d 
 Media( const Point3d& ptP1, const Point3d& ptP2, double dCoeff)
@@ -167,7 +189,7 @@ Media( const Point3d& ptP1, const Point3d& ptP2, double dCoeff)
 }
 
 //----------------------------------------------------------------------------
-// Quadrato della distanza tra due punti
+//! Quadrato della distanza tra due punti
 //----------------------------------------------------------------------------
 inline double 
 SqDist( const Point3d& ptP1, const Point3d& ptP2)
@@ -180,7 +202,7 @@ SqDist( const Point3d& ptP1, const Point3d& ptP2)
 }
 
 //----------------------------------------------------------------------------
-// Quadrato della distanza tra due punti nel piano XY
+//! Quadrato della distanza tra due punti nel piano XY
 //----------------------------------------------------------------------------
 inline double 
 SqDistXY( const Point3d& ptP1, const Point3d& ptP2)
@@ -192,7 +214,7 @@ SqDistXY( const Point3d& ptP1, const Point3d& ptP2)
 }
 
 //----------------------------------------------------------------------------
-// Distanza tra due punti
+//! Distanza tra due punti
 //----------------------------------------------------------------------------
 inline double 
 Dist( const Point3d& ptP1, const Point3d& ptP2)
@@ -212,7 +234,7 @@ Dist( const Point3d& ptP1, const Point3d& ptP2)
 }
 
 //----------------------------------------------------------------------------
-// Distanza tra due punti nel piano XY
+//! Distanza tra due punti nel piano XY
 //----------------------------------------------------------------------------
 inline double 
 DistXY( const Point3d& ptP1, const Point3d& ptP2)
@@ -229,7 +251,7 @@ DistXY( const Point3d& ptP1, const Point3d& ptP2)
 }
 
 //----------------------------------------------------------------------------
-// Direzione e distanza tra due punti ( P1 -> P2)
+//! Direzione e distanza tra due punti ( P1 -> P2)
 //----------------------------------------------------------------------------
 inline bool
 DirDist( const Point3d& ptP1, const Point3d& ptP2, Vector3d& vtDir, double& dDist)
@@ -248,7 +270,7 @@ DirDist( const Point3d& ptP1, const Point3d& ptP2, Vector3d& vtDir, double& dDis
 }
 
 //----------------------------------------------------------------------------
-// Verifica che due punti sono quasi coincidenti (Small error -> Approx)
+//! Verifica se due punti sono quasi coincidenti (Small error -> Approx)
 //----------------------------------------------------------------------------
 inline bool
 AreSamePointApprox( const Point3d& ptP1, const Point3d& ptP2)
@@ -257,7 +279,7 @@ AreSamePointApprox( const Point3d& ptP1, const Point3d& ptP2)
 }
 
 //----------------------------------------------------------------------------
-// Verifica che due punti sono esattamente coincidenti (Zero error -> Exact)
+//! Verifica se due punti sono esattamente coincidenti (Zero error -> Exact)
 //----------------------------------------------------------------------------
 inline bool
 AreSamePointExact( const Point3d& ptP1, const Point3d& ptP2)
diff --git a/EGkVector3d.h b/EGkVector3d.h
index a366345..6002c35 100644
--- a/EGkVector3d.h
+++ b/EGkVector3d.h
@@ -35,7 +35,7 @@ class EGK_EXPORT Vector3d
       Vector3d( double dX, double dY, double dZ) : x( dX), y( dY), z( dZ) {}
       //! Costruttore del vettore con due componenti X e Y, Z = 0
       Vector3d( double dX, double dY) : x( dX), y( dY), z( 0) {}
-      //! Costruttore del vettore nullo X= Y = Z = 0
+      //! Costruttore del vettore nullo X = Y = Z = 0
       Vector3d( void) : x( 0), y( 0), z( 0) {}
       //! Assegnazione delle componenti X, Y e Z al vettore
       void Set( double dX, double dY, double dZ) { x = dX ; y = dY ; z = dZ ;}
@@ -103,9 +103,9 @@ class EGK_EXPORT Vector3d
       void ToSpherical( double* pdLen, double* pdAngVertDeg, double* pdAngOrizzDeg) const ;
       //! Normalizzazione di un vettore (trasformazione in versore)
       bool Normalize( double dEps = EPS_SMALL) ;
-      //! Rotazione
+      //! Rotazione attorno ad un asse, dato l'angolo in gradi
       bool Rotate( const Vector3d& vtAx, double dAngDeg) ;
-      //! Rotazione da coseno e seno dell'angolo di rotazione
+      //! Rotazione attorno ad un asse, dati coseno e seno dell'angolo di rotazione
       bool Rotate( const Vector3d& vtAx, double dCosAng, double dSinAng) ;
       //! Scalatura non uniforme
       bool Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) ;
@@ -130,11 +130,11 @@ class EGK_EXPORT Vector3d
    public :
       union {
          struct {
-            double x ;
-            double y ;
-            double z ;
+            double x ;      //!< componente sull'asse X
+            double y ;      //!< componente sull'asse Y
+            double z ;      //!< componente sull'asse Z
          } ;
-         double v[3] ;
+         double v[3] ;      //!< equivalente vettoriale delle tre componenti
       } ;
 } ;
 
diff --git a/EgkCurve.h b/EgkCurve.h
index 24a74be..9057da7 100644
--- a/EgkCurve.h
+++ b/EgkCurve.h
@@ -52,6 +52,7 @@ class __declspec( novtable) ICurve : public IGeoObj
       virtual bool GetPointDiffGeom( double dU, Side nS, CrvPointDiffGeom& oDiffG) const = 0 ;
       virtual bool IsPointOn( const Point3d& ptP, double dTol = EPS_SMALL) const = 0 ;
       virtual bool ApproxWithLines( double dLinTol, double dAngTolDeg, PolyLine& PL) const = 0 ;
+      virtual ICurve* CopyParamRange( double dUStart, double dUEnd) const = 0 ;
       virtual bool Invert( void) = 0 ;
       virtual bool Offset( double dDist, int nSide, int nType = OFF_FILLET) = 0 ;
       virtual bool TrimStartAtParam( double dUTrim) = 0 ;
diff --git a/EgkCurveArc.h b/EgkCurveArc.h
index 4ffc9da..2054229 100644
--- a/EgkCurveArc.h
+++ b/EgkCurveArc.h
@@ -19,7 +19,7 @@
 class __declspec( novtable) ICurveArc : public ICurve
 {
    public :
-      virtual bool Copy( const IGeoObj* pGObjSrc) = 0 ;
+      virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
       virtual bool Set( const Point3d& ptCen, const Vector3d& vtN, double dRad,
                         const Vector3d& vtS, double dAngCenDeg, double dDeltaN) = 0 ;
       virtual bool Set( const Point3d& ptCen, const Vector3d& vtN, double dRad) = 0 ;
diff --git a/EgkCurveBezier.h b/EgkCurveBezier.h
index 5e2a3ae..71fb356 100644
--- a/EgkCurveBezier.h
+++ b/EgkCurveBezier.h
@@ -21,7 +21,7 @@ class ICurveArc ;
 class __declspec( novtable) ICurveBezier : public ICurve
 {
    public :
-      virtual bool Copy( const IGeoObj* pGObjSrc) = 0 ;
+      virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
       virtual bool Init( int nDeg, bool bIsRational) = 0 ;
       virtual bool SetControlPoint( int nInd, const Point3d& ptCtrl) = 0 ;
       virtual bool SetControlPoint( int nInd, const Point3d& ptCtrl, double dW) = 0 ;
diff --git a/EgkCurveComposite.h b/EgkCurveComposite.h
index 8d358ed..8399dd3 100644
--- a/EgkCurveComposite.h
+++ b/EgkCurveComposite.h
@@ -19,7 +19,7 @@
 class __declspec( novtable) ICurveComposite : public ICurve
 {
    public :
-      virtual bool Copy( const IGeoObj* pGObjSrc) = 0 ;
+      virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
       virtual bool Clear( void) = 0 ;
       virtual bool AddCurve( const ICurve& cCrv, bool bEndOrStart = true) = 0 ;
       virtual bool AddCurve( ICurve* pCrv, bool bEndOrStart = true) = 0 ;
diff --git a/EgkCurveLine.h b/EgkCurveLine.h
index 73d0155..e6ac2e7 100644
--- a/EgkCurveLine.h
+++ b/EgkCurveLine.h
@@ -19,7 +19,7 @@
 class __declspec( novtable) ICurveLine : public ICurve
 {
    public :
-      virtual bool Copy( const IGeoObj* pGObjSrc) = 0 ;
+      virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
       virtual bool Set( const Point3d& ptStart, const Point3d& ptEnd) = 0 ;
       virtual bool SetPVL( const Point3d& ptStart, const Vector3d& vtDir, double dLen) = 0 ;
       virtual bool SetPDL( const Point3d& ptStart, double dDirAngDeg, double dLen) = 0 ;
diff --git a/EgkSurfTriMesh.h b/EgkSurfTriMesh.h
index af82759..a35e2d2 100644
--- a/EgkSurfTriMesh.h
+++ b/EgkSurfTriMesh.h
@@ -26,7 +26,7 @@ const int SVT_DEL = - 2 ;            // vertice o triangolo cancellato
 class __declspec( novtable) ISurfTriMesh : public ISurf
 {
    public :
-      virtual bool Copy( const IGeoObj* pGObjSrc) = 0 ;
+      virtual bool CopyFrom( const IGeoObj* pGObjSrc) = 0 ;
       virtual bool Init( int nNumVert, int nNumTria) = 0 ;
       virtual void SetLinearTolerance( double dLinTol) = 0 ;
       virtual void SetSmoothAngle( double dSmoothAngDeg) = 0 ;