diff --git a/ArcPntDirTgCurve.cpp b/ArcPntDirTgCurve.cpp
index bb74150..9c2a9ad 100644
--- a/ArcPntDirTgCurve.cpp
+++ b/ArcPntDirTgCurve.cpp
@@ -204,7 +204,7 @@ GetArcPntDirTgArc( const Point3d& ptP, const Vector3d& vtDir, const CurveArc& cr
    if ( bOk1) {
       double dOffset = ( bOutSide ? crvArcL.GetRadius() : - crvArcL.GetRadius()) ;
       if ( pCrv1->GetType() == CRV_ARC)
-         bOk1 = (dynamic_cast<CurveArc*>(Get(pCrv1)))->ExtendedOffset( dOffset) ;
+         bOk1 = (static_cast<CurveArc*>( Get( pCrv1)))->ExtendedOffset( dOffset) ;
       else
          bOk1 = pCrv1->SimpleOffset( dOffset) ;
    }
@@ -235,7 +235,7 @@ GetArcPntDirTgArc( const Point3d& ptP, const Vector3d& vtDir, const CurveArc& cr
    if ( bOk2) {
       double dOffset = ( bOutSide ? - crvArcL.GetRadius() : crvArcL.GetRadius()) ;
       if ( pCrv2->GetType() == CRV_ARC)
-         bOk2 = (dynamic_cast<CurveArc*>(Get(pCrv2)))->ExtendedOffset( dOffset) ;
+         bOk2 = (static_cast<CurveArc*>( Get( pCrv2)))->ExtendedOffset( dOffset) ;
       else
          bOk2 = pCrv2->SimpleOffset( dOffset) ;
    }
diff --git a/CurveArc.cpp b/CurveArc.cpp
index b9f8fb9..04ea46b 100644
--- a/CurveArc.cpp
+++ b/CurveArc.cpp
@@ -567,7 +567,7 @@ CurveArc::Clone( void) const
 bool
 CurveArc::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const CurveArc* pCA = dynamic_cast<const CurveArc*>( pGObjSrc) ;
+   const CurveArc* pCA = GetBasicCurveArc( pGObjSrc) ;
    if ( pCA == nullptr)
       return false ;
    return CopyFrom( *pCA) ;
diff --git a/CurveArc.h b/CurveArc.h
index 69ba383..02eba06 100644
--- a/CurveArc.h
+++ b/CurveArc.h
@@ -217,12 +217,16 @@ class CurveArc : public ICurveArc, public IGeoObjRW
 
 //-----------------------------------------------------------------------------
 inline CurveArc* CreateBasicCurveArc( void)
-               { return (static_cast<CurveArc*>( CreateGeoObj( CRV_ARC))) ; }
+               { return ( static_cast<CurveArc*>( CreateGeoObj( CRV_ARC))) ; }
 inline CurveArc* CloneBasicCurveArc( const IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_ARC)
                    return nullptr ;
-                 return (static_cast<CurveArc*>(pGObj->Clone())) ; }
+                 return ( static_cast<CurveArc*>( pGObj->Clone())) ; }
 inline const CurveArc* GetBasicCurveArc( const IGeoObj* pGObj)
-               { return (dynamic_cast<const CurveArc*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_ARC)
+                   return nullptr ;
+                 return ( static_cast<const CurveArc*>( pGObj)) ; }
 inline CurveArc* GetBasicCurveArc( IGeoObj* pGObj)
-               { return (dynamic_cast<CurveArc*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_ARC)
+                   return nullptr ;
+                 return ( static_cast<CurveArc*>( pGObj)) ; }
diff --git a/CurveBezier.cpp b/CurveBezier.cpp
index 3514473..083ea6b 100644
--- a/CurveBezier.cpp
+++ b/CurveBezier.cpp
@@ -266,7 +266,7 @@ CurveBezier::Clone( void) const
 bool
 CurveBezier::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const CurveBezier* pCB = dynamic_cast<const CurveBezier*>( pGObjSrc) ;
+   const CurveBezier* pCB = GetBasicCurveBezier( pGObjSrc) ;
    if ( pCB == nullptr)
       return false ;
    return CopyFrom( *pCB) ;
diff --git a/CurveBezier.h b/CurveBezier.h
index d5e96ac..ade321d 100644
--- a/CurveBezier.h
+++ b/CurveBezier.h
@@ -195,12 +195,16 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
 
 //-----------------------------------------------------------------------------
 inline CurveBezier* CreateBasicCurveBezier( void)
-               { return (static_cast<CurveBezier*>( CreateGeoObj( CRV_BEZIER))) ; }
+               { return ( static_cast<CurveBezier*>( CreateGeoObj( CRV_BEZIER))) ; }
 inline CurveBezier* CloneBasicCurveBezier( const IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_BEZIER)
                     return nullptr ;
-                 return (static_cast<CurveBezier*>(pGObj->Clone())) ; }
+                 return ( static_cast<CurveBezier*>( pGObj->Clone())) ; }
 inline const CurveBezier* GetBasicCurveBezier( const IGeoObj* pGObj)
-               { return (dynamic_cast<const CurveBezier*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_BEZIER)
+                    return nullptr ;
+                 return ( static_cast<const CurveBezier*>( pGObj)) ; }
 inline CurveBezier* GetBasicCurveBezier( IGeoObj* pGObj)
-               { return (dynamic_cast<CurveBezier*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_BEZIER)
+                    return nullptr ;
+                 return ( static_cast<CurveBezier*>( pGObj)) ; }
diff --git a/CurveComposite.h b/CurveComposite.h
index eac578d..2028084 100644
--- a/CurveComposite.h
+++ b/CurveComposite.h
@@ -215,12 +215,16 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
 
 //-----------------------------------------------------------------------------
 inline CurveComposite* CreateBasicCurveComposite( void)
-               { return (static_cast<CurveComposite*>( CreateGeoObj( CRV_COMPO))) ; }
+               { return ( static_cast<CurveComposite*>( CreateGeoObj( CRV_COMPO))) ; }
 inline CurveComposite* CloneBasicCurveComposite( const IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_COMPO)
                     return nullptr ;
-                 return (static_cast<CurveComposite*>(pGObj->Clone())) ; }
+                 return ( static_cast<CurveComposite*>( pGObj->Clone())) ; }
 inline const CurveComposite* GetBasicCurveComposite( const IGeoObj* pGObj)
-               { return (dynamic_cast<const CurveComposite*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_COMPO)
+                    return nullptr ;
+                 return ( static_cast<const CurveComposite*>( pGObj)) ; }
 inline CurveComposite* GetBasicCurveComposite( IGeoObj* pGObj)
-               { return (dynamic_cast<CurveComposite*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_COMPO)
+                    return nullptr ;
+                 return ( static_cast<CurveComposite*>( pGObj)) ; }
diff --git a/CurveLine.cpp b/CurveLine.cpp
index 79ce9e5..c7bd8db 100644
--- a/CurveLine.cpp
+++ b/CurveLine.cpp
@@ -111,7 +111,7 @@ CurveLine::Clone( void) const
 bool
 CurveLine::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const CurveLine* pCL = dynamic_cast<const CurveLine*>( pGObjSrc) ;
+   const CurveLine* pCL = GetBasicCurveLine( pGObjSrc) ;
    if ( pCL == nullptr)
       return false ;
    return CopyFrom( *pCL) ;
diff --git a/CurveLine.h b/CurveLine.h
index a3179d6..53d4fd6 100644
--- a/CurveLine.h
+++ b/CurveLine.h
@@ -170,12 +170,16 @@ class CurveLine : public ICurveLine, public IGeoObjRW
 
 //-----------------------------------------------------------------------------
 inline CurveLine* CreateBasicCurveLine( void)
-               { return (static_cast<CurveLine*>( CreateGeoObj( CRV_LINE))) ; }
+               { return ( static_cast<CurveLine*>( CreateGeoObj( CRV_LINE))) ; }
 inline CurveLine* CloneBasicCurveLine( const IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_LINE)
                     return nullptr ;
-                 return (static_cast<CurveLine*>(pGObj->Clone())) ; }
+                 return ( static_cast<CurveLine*>( pGObj->Clone())) ; }
 inline const CurveLine* GetBasicCurveLine( const IGeoObj* pGObj)
-               { return (dynamic_cast<const CurveLine*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_LINE)
+                    return nullptr ;
+                 return ( static_cast<const CurveLine*>( pGObj)) ; }
 inline CurveLine* GetBasicCurveLine( IGeoObj* pGObj)
-               { return (dynamic_cast<CurveLine*>(pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != CRV_LINE)
+                    return nullptr ;
+                 return ( static_cast<CurveLine*>( pGObj)) ; }
diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc
index 822b74a..b932cbf 100644
Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ
diff --git a/ExtDimension.cpp b/ExtDimension.cpp
index c5af800..0e1025f 100644
--- a/ExtDimension.cpp
+++ b/ExtDimension.cpp
@@ -305,7 +305,7 @@ ExtDimension::Clone( void) const
 bool
 ExtDimension::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const ExtDimension* pDim = dynamic_cast<const ExtDimension*>( pGObjSrc) ;
+   const ExtDimension* pDim = GetBasicExtDimension( pGObjSrc) ;
    if ( pDim == nullptr)
       return false ;
    return CopyFrom( *pDim) ;
diff --git a/ExtDimension.h b/ExtDimension.h
index 688244e..f8ccc70 100644
--- a/ExtDimension.h
+++ b/ExtDimension.h
@@ -159,3 +159,19 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
       double              m_dTextHeight ;   // altezza del testo
       int                 m_nTempProp[2] ;  // vettore proprietà temporanee 
 } ;
+
+//-----------------------------------------------------------------------------
+inline ExtDimension* CreateBasicExtDimension( void)
+               { return ( static_cast<ExtDimension*>( CreateGeoObj( EXT_DIMENSION))) ; }
+inline ExtDimension* CloneBasicExtDimension( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != EXT_DIMENSION)
+                    return nullptr ;
+                 return ( static_cast<ExtDimension*>( pGObj->Clone())) ; }
+inline const ExtDimension* GetBasicExtDimension( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != EXT_DIMENSION)
+                    return nullptr ;
+                 return ( static_cast<const ExtDimension*>( pGObj)) ; }
+inline ExtDimension* GetBasicExtDimension( IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != EXT_DIMENSION)
+                    return nullptr ;
+                 return ( static_cast<ExtDimension*>( pGObj)) ; }
diff --git a/ExtText.cpp b/ExtText.cpp
index 6662878..a751847 100644
--- a/ExtText.cpp
+++ b/ExtText.cpp
@@ -161,7 +161,7 @@ ExtText::Clone( void) const
 bool
 ExtText::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const ExtText* pTxt = dynamic_cast<const ExtText*>( pGObjSrc) ;
+   const ExtText* pTxt = GetBasicExtText( pGObjSrc) ;
    if ( pTxt == nullptr)
       return false ;
    return CopyFrom( *pTxt) ;
diff --git a/ExtText.h b/ExtText.h
index 053ed4a..4b56bff 100644
--- a/ExtText.h
+++ b/ExtText.h
@@ -146,3 +146,19 @@ class ExtText : public IExtText, public IGeoObjRW
       int            m_nInsPos ;       // posizione del punto di inserimento rispetto al testo
       int            m_nTempProp[2] ;  // vettore proprietà temporanee 
 } ;
+
+//-----------------------------------------------------------------------------
+inline ExtText* CreateBasicExtText( void)
+               { return ( static_cast<ExtText*>( CreateGeoObj( EXT_TEXT))) ; }
+inline ExtText* CloneBasicExtText( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != EXT_TEXT)
+                    return nullptr ;
+                 return ( static_cast<ExtText*>( pGObj->Clone())) ; }
+inline const ExtText* GetBasicExtText( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != EXT_TEXT)
+                    return nullptr ;
+                 return ( static_cast<const ExtText*>( pGObj)) ; }
+inline ExtText* GetBasicExtText( IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != EXT_TEXT)
+                    return nullptr ;
+                 return ( static_cast<ExtText*>( pGObj)) ; }
diff --git a/GdbGeo.h b/GdbGeo.h
index cdc5c0d..acb42d4 100644
--- a/GdbGeo.h
+++ b/GdbGeo.h
@@ -54,6 +54,10 @@ class GdbGeo : public GdbObj
 
 //----------------------------------------------------------------------------
 inline const GdbGeo* GetGdbGeo( const GdbObj* pGObj)
-               { return dynamic_cast<const GdbGeo*>(pGObj) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetGdbType() != GDB_TY_GEO)
+                    return nullptr ;
+                 return static_cast<const GdbGeo*>( pGObj) ; }
 inline GdbGeo* GetGdbGeo( GdbObj* pGObj)
-               { return dynamic_cast<GdbGeo*>(pGObj) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetGdbType() != GDB_TY_GEO)
+                    return nullptr ;
+                 return static_cast<GdbGeo*>( pGObj) ; }
diff --git a/GdbGroup.h b/GdbGroup.h
index 45981a2..b7d38f5 100644
--- a/GdbGroup.h
+++ b/GdbGroup.h
@@ -91,6 +91,10 @@ class GdbGroup : public GdbObj
 
 //----------------------------------------------------------------------------
 inline const GdbGroup* GetGdbGroup( const GdbObj* pGObj)
-               { return dynamic_cast<const GdbGroup*>(pGObj) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetGdbType() != GDB_TY_GROUP)
+                    return nullptr ;
+                 return static_cast<const GdbGroup*>( pGObj) ; }
 inline GdbGroup* GetGdbGroup( GdbObj* pGObj)
-               { return dynamic_cast<GdbGroup*>(pGObj) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetGdbType() != GDB_TY_GROUP)
+                    return nullptr ;
+                 return static_cast<GdbGroup*>( pGObj) ; }
diff --git a/GdbIterator.cpp b/GdbIterator.cpp
index ddf3b8a..a71ff1e 100644
--- a/GdbIterator.cpp
+++ b/GdbIterator.cpp
@@ -24,7 +24,7 @@ using namespace std ;
 IGdbIterator*
 CreateGdbIterator( IGeomDB* pGDB)
 {
-   if ( dynamic_cast<GeomDB*>( pGDB) == nullptr)
+   if ( static_cast<GeomDB*>( pGDB) == nullptr)
       return nullptr ;
    return static_cast<IGdbIterator*> ( new( nothrow) GdbIterator( pGDB)) ;
 }
@@ -53,7 +53,7 @@ GdbIterator::~GdbIterator( void)
 bool
 GdbIterator::SetGDB( IGeomDB* pGDB)
 {
-   m_pGDB = dynamic_cast<GeomDB*>( pGDB) ;
+   m_pGDB = static_cast<GeomDB*>( pGDB) ;
    if ( m_pGDB == nullptr)
       return false ;
 
@@ -105,7 +105,7 @@ GdbIterator::GoToFirstInGroup( const IGdbIterator& iIter)
       return false ;
    }
 
-   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB) {
       m_pCurrObj = nullptr ;
       return false ;
@@ -167,7 +167,7 @@ GdbIterator::GoToLastInGroup( const IGdbIterator& iIter)
       return false ;
    }
 
-   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB) {
       m_pCurrObj = nullptr ;
       return false ;
@@ -263,7 +263,7 @@ GdbIterator::GoToFirstNameInGroup( const IGdbIterator& iIter, const string& sNam
       return false ;
    }
   // converto in oggetto iteratore di base
-   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB) {
       m_pCurrObj = nullptr ;
       return false ;
@@ -345,7 +345,7 @@ GdbIterator::GoToLastNameInGroup( const IGdbIterator& iIter, const string& sName
       return false ;
    }
   // converto in oggetto iteratore di base
-   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB) {
       m_pCurrObj = nullptr ;
       return false ;
@@ -474,7 +474,7 @@ GdbIterator::GoToFirstGroupInGroup( const IGdbIterator& iIter)
       return false ;
    }
   // converto in oggetto iteratore di base
-   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB) {
       m_pCurrObj = nullptr ;
       return false ;
@@ -553,7 +553,7 @@ GdbIterator::GoToLastGroupInGroup( const IGdbIterator& iIter)
       return false ;
    }
   // converto in oggetto iteratore di base
-   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB) {
       m_pCurrObj = nullptr ;
       return false ;
@@ -1637,7 +1637,7 @@ GdbIterator::CopyAllInfoFrom( const IGdbIterator& iIter)
       return false ;
 
   // recupero l'oggetto sorgente
-   const GdbIterator* pIter = dynamic_cast<const GdbIterator*> (&iIter) ;
+   const GdbIterator* pIter = static_cast<const GdbIterator*> (&iIter) ;
    if ( pIter == nullptr  ||  pIter->m_pGDB != m_pGDB  ||  pIter->m_pCurrObj == nullptr)
       return false ;
    const GdbObj* pGdbObjSou = pIter->m_pCurrObj ;
diff --git a/GeoFrame3d.cpp b/GeoFrame3d.cpp
index 54d2be4..e3ca1f0 100644
--- a/GeoFrame3d.cpp
+++ b/GeoFrame3d.cpp
@@ -104,7 +104,7 @@ GeoFrame3d::Clone( void) const
 bool
 GeoFrame3d::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const GeoFrame3d* pGFr = dynamic_cast<const GeoFrame3d*>( pGObjSrc) ;
+   const GeoFrame3d* pGFr = GetBasicGeoFrame3d( pGObjSrc) ;
    if ( pGFr == nullptr)
       return false ;
    return CopyFrom( *pGFr) ;
diff --git a/GeoFrame3d.h b/GeoFrame3d.h
index 728c1b0..850a0a1 100644
--- a/GeoFrame3d.h
+++ b/GeoFrame3d.h
@@ -98,3 +98,19 @@ class GeoFrame3d : public IGeoFrame3d, public IGeoObjRW
       Frame3d        m_frF ;           // oggetto
       int            m_nTempProp[2] ;  // vettore proprietà temporanee 
 } ;
+
+//-----------------------------------------------------------------------------
+inline GeoFrame3d* CreateBasicGeoFrame3d( void)
+               { return ( static_cast<GeoFrame3d*>( CreateGeoObj( GEO_FRAME3D))) ; }
+inline GeoFrame3d* CloneBasicGeoFrame3d( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_FRAME3D)
+                    return nullptr ;
+                 return ( static_cast<GeoFrame3d*>( pGObj->Clone())) ; }
+inline const GeoFrame3d* GetBasicGeoFrame3d( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_FRAME3D)
+                    return nullptr ;
+                 return ( static_cast<const GeoFrame3d*>( pGObj)) ; }
+inline GeoFrame3d* GetBasicGeoFrame3d( IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_FRAME3D)
+                    return nullptr ;
+                 return ( static_cast<GeoFrame3d*>( pGObj)) ; }
diff --git a/GeoPoint3d.cpp b/GeoPoint3d.cpp
index 0f53b5d..6f02969 100644
--- a/GeoPoint3d.cpp
+++ b/GeoPoint3d.cpp
@@ -72,7 +72,7 @@ GeoPoint3d::Clone( void) const
 bool
 GeoPoint3d::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const GeoPoint3d* pGP = dynamic_cast<const GeoPoint3d*>( pGObjSrc) ;
+   const GeoPoint3d* pGP = GetBasicGeoPoint3d( pGObjSrc) ;
    if ( pGP == nullptr)
       return false ;
    return CopyFrom( *pGP) ;
diff --git a/GeoPoint3d.h b/GeoPoint3d.h
index 59f08a0..532d6a4 100644
--- a/GeoPoint3d.h
+++ b/GeoPoint3d.h
@@ -92,3 +92,19 @@ class GeoPoint3d : public IGeoPoint3d, public IGeoObjRW
       Point3d        m_ptP ;           // oggetto
       int            m_nTempProp[2] ;  // vettore proprietà temporanee 
 } ;
+
+//-----------------------------------------------------------------------------
+inline GeoPoint3d* CreateBasicGeoPoint3d( void)
+               { return ( static_cast<GeoPoint3d*>( CreateGeoObj( GEO_PNT3D))) ; }
+inline GeoPoint3d* CloneBasicGeoPoint3d( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_PNT3D)
+                    return nullptr ;
+                 return ( static_cast<GeoPoint3d*>( pGObj->Clone())) ; }
+inline const GeoPoint3d* GetBasicGeoPoint3d( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_PNT3D)
+                    return nullptr ;
+                 return ( static_cast<const GeoPoint3d*>( pGObj)) ; }
+inline GeoPoint3d* GetBasicGeoPoint3d( IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_PNT3D)
+                    return nullptr ;
+                 return ( static_cast<GeoPoint3d*>( pGObj)) ; }
diff --git a/GeoVector3d.cpp b/GeoVector3d.cpp
index eef867a..b93875a 100644
--- a/GeoVector3d.cpp
+++ b/GeoVector3d.cpp
@@ -88,7 +88,7 @@ GeoVector3d::Clone( void) const
 bool
 GeoVector3d::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const GeoVector3d* pGV = dynamic_cast<const GeoVector3d*>( pGObjSrc) ;
+   const GeoVector3d* pGV = GetBasicGeoVector3d( pGObjSrc) ;
    if ( pGV == nullptr)
       return false ;
    return CopyFrom( *pGV) ;
diff --git a/GeoVector3d.h b/GeoVector3d.h
index aaeac07..b824f2e 100644
--- a/GeoVector3d.h
+++ b/GeoVector3d.h
@@ -107,3 +107,19 @@ class GeoVector3d : public IGeoVector3d, public IGeoObjRW
       Point3d        m_ptBase ;        // punto base da cui tracciare il vettore
       int            m_nTempProp[2] ;  // vettore proprietà temporanee 
 } ;
+
+//-----------------------------------------------------------------------------
+inline GeoVector3d* CreateBasicGeoVector3d( void)
+               { return ( static_cast<GeoVector3d*>( CreateGeoObj( GEO_VECT3D))) ; }
+inline GeoVector3d* CloneBasicGeoVector3d( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_VECT3D)
+                    return nullptr ;
+                 return ( static_cast<GeoVector3d*>( pGObj->Clone())) ; }
+inline const GeoVector3d* GetBasicGeoVector3d( const IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_VECT3D)
+                    return nullptr ;
+                 return ( static_cast<const GeoVector3d*>( pGObj)) ; }
+inline GeoVector3d* GetBasicGeoVector3d( IGeoObj* pGObj)
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != GEO_VECT3D)
+                    return nullptr ;
+                 return ( static_cast<GeoVector3d*>( pGObj)) ; }
diff --git a/GeomDB.cpp b/GeomDB.cpp
index 101749f..4dcb7d4 100644
--- a/GeomDB.cpp
+++ b/GeomDB.cpp
@@ -659,7 +659,7 @@ GeomDB::InsertInGeomDB( GdbObj* pGObj, int nRefId, int nSonBeforeAfter, bool bLo
    }
   // inserisco come figlio, in testa alla lista del padre
    else if ( nSonBeforeAfter == GDB_FIRST_SON){
-      GdbGroup* pGroup = dynamic_cast<GdbGroup*> ( pGRef) ;
+      GdbGroup* pGroup = ::GetGdbGroup( pGRef) ;
       if ( pGroup == nullptr)
          return false ;
      // inserisco in testa alla lista del padre
@@ -668,7 +668,7 @@ GeomDB::InsertInGeomDB( GdbObj* pGObj, int nRefId, int nSonBeforeAfter, bool bLo
    }
   // inserisco come figlio, in coda alla lista del padre
    else {
-      GdbGroup* pGroup = dynamic_cast<GdbGroup*> ( pGRef) ;
+      GdbGroup* pGroup = ::GetGdbGroup( pGRef) ;
       if ( pGroup == nullptr)
          return false ;
      // inserisco in coda alla lista del padre
diff --git a/GeomDB.h b/GeomDB.h
index dd83216..ae68f4e 100644
--- a/GeomDB.h
+++ b/GeomDB.h
@@ -223,13 +223,13 @@ class GeomDB : public IGeomDB
       GdbObj* GetGdbObj( int nId) ;
       const GdbObj* GetGdbObj( int nId) const ;
       GdbGeo* GetGdbGeo( int nId)
-                 { return dynamic_cast<GdbGeo*>( GetGdbObj( nId)) ; }
+                 { return ::GetGdbGeo( GetGdbObj( nId)) ; }
       const GdbGeo* GetGdbGeo( int nId) const
-                 { return dynamic_cast<const GdbGeo*>( GetGdbObj( nId)) ; }
+                 { return ::GetGdbGeo( GetGdbObj( nId)) ; }
       GdbGroup* GetGdbGroup( int nId)
-                 { return dynamic_cast<GdbGroup*>( GetGdbObj( nId)) ; }
+                 { return ::GetGdbGroup( GetGdbObj( nId)) ; }
       const GdbGroup* GetGdbGroup( int nId) const
-                 { return dynamic_cast<const GdbGroup*>( GetGdbObj( nId)) ; }
+                 { return ::GetGdbGroup( GetGdbObj( nId)) ; }
       bool InsertInGeomDB( GdbObj* pGObj, int nRefId, int nSonBeforeAfter, bool bLockAddErase = true, bool bTestId = true) ;
       int  Copy( int nIdSou, int nIdDest, int nRefId, int nSonBeforeAfter, bool bGlob) ;
       bool Relocate( int nId, int nRefId, int nSonBeforeAfter, bool bGlob) ;
diff --git a/LineTgTwoCurves.cpp b/LineTgTwoCurves.cpp
index 48fd0d6..16cb6e4 100644
--- a/LineTgTwoCurves.cpp
+++ b/LineTgTwoCurves.cpp
@@ -171,7 +171,7 @@ GetLineTgTwoArcs( const CurveArc& crvArc1, const Point3d& ptNear1,
       return nullptr ;
 
   // porto il secondo arco nel riferimento intrinseco del primo
-   CurveArc crvArc2Loc = dynamic_cast<const CurveArc&>( crvArc2) ;
+   CurveArc crvArc2Loc = crvArc2 ;
    crvArc2Loc.ToLoc( frIntr) ;
 
   // calcolo le linee di tangenza alle due circonferenze
diff --git a/SurfBezier.cpp b/SurfBezier.cpp
index ef96e0d..3a3d0c0 100644
--- a/SurfBezier.cpp
+++ b/SurfBezier.cpp
@@ -550,7 +550,7 @@ SurfBezier::Clone( void) const
 bool
 SurfBezier::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const SurfBezier* pSbz = dynamic_cast<const SurfBezier*>( pGObjSrc) ;
+   const SurfBezier* pSbz = GetBasicSurfBezier( pGObjSrc) ;
    if ( pSbz == nullptr)
       return false ;
    return CopyFrom( *pSbz) ;
diff --git a/SurfBezier.h b/SurfBezier.h
index f64e5a1..d4d929d 100644
--- a/SurfBezier.h
+++ b/SurfBezier.h
@@ -177,6 +177,10 @@ inline SurfBezier* CloneBasicSurfBezier( const IGeoObj* pGObj)
                     return nullptr ;
                  return ( static_cast<SurfBezier*>( pGObj->Clone())) ; }
 inline const SurfBezier* GetBasicSurfBezier( const IGeoObj* pGObj)
-               { return ( dynamic_cast<const SurfBezier*>( pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != SRF_BEZIER)
+                    return nullptr ;
+                 return ( static_cast<const SurfBezier*>( pGObj)) ; }
 inline SurfBezier* GetBasicSurfBezier( IGeoObj* pGObj)
-               { return ( dynamic_cast<SurfBezier*>( pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != SRF_BEZIER)
+                    return nullptr ;
+                 return ( static_cast<SurfBezier*>( pGObj)) ; }
diff --git a/SurfFlatRegion.cpp b/SurfFlatRegion.cpp
index 0fdb481..328384a 100644
--- a/SurfFlatRegion.cpp
+++ b/SurfFlatRegion.cpp
@@ -378,7 +378,7 @@ SurfFlatRegion::Clone( void) const
 bool
 SurfFlatRegion::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const SurfFlatRegion* pSfr = dynamic_cast<const SurfFlatRegion*>( pGObjSrc) ;
+   const SurfFlatRegion* pSfr = GetBasicSurfFlatRegion( pGObjSrc) ;
    if ( pSfr == nullptr)
       return false ;
    return CopyFrom( *pSfr) ;
diff --git a/SurfFlatRegion.h b/SurfFlatRegion.h
index 37d8195..eb29c2d 100644
--- a/SurfFlatRegion.h
+++ b/SurfFlatRegion.h
@@ -152,12 +152,16 @@ class SurfFlatRegion : public ISurfFlatRegion, public IGeoObjRW
 
 //-----------------------------------------------------------------------------
 inline SurfFlatRegion* CreateBasicSurfFlatRegion( void)
-               { return (static_cast<SurfFlatRegion*>( CreateGeoObj( SRF_FLATRGN))) ; }
+               { return ( static_cast<SurfFlatRegion*>( CreateGeoObj( SRF_FLATRGN))) ; }
 inline SurfFlatRegion* CloneBasicSurfFlatRegion( const IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != SRF_FLATRGN)
                     return nullptr ;
-                 return (static_cast<SurfFlatRegion*>(pGObj->Clone())) ; }
+                 return ( static_cast<SurfFlatRegion*>( pGObj->Clone())) ; }
 inline const SurfFlatRegion* GetBasicSurfFlatRegion( const IGeoObj* pGObj)
-               { return (dynamic_cast<const SurfFlatRegion*>( pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != SRF_FLATRGN)
+                    return nullptr ;
+                 return ( static_cast<const SurfFlatRegion*>( pGObj)) ; }
 inline SurfFlatRegion* GetBasicSurfFlatRegion( IGeoObj* pGObj)
-               { return (dynamic_cast<SurfFlatRegion*>( pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != SRF_FLATRGN)
+                    return nullptr ;
+                 return ( static_cast<SurfFlatRegion*>( pGObj)) ; }
diff --git a/SurfFlatRegionBooleans.cpp b/SurfFlatRegionBooleans.cpp
index 233916a..a06921e 100644
--- a/SurfFlatRegionBooleans.cpp
+++ b/SurfFlatRegionBooleans.cpp
@@ -27,9 +27,10 @@ bool
 SurfFlatRegion::Add( const ISurfFlatRegion& Other)
 {
   // converto l'altra regione nell'oggetto base
-   const SurfFlatRegion& SfrOther = dynamic_cast<const SurfFlatRegion&>( Other) ;
-   if ( &SfrOther == nullptr)
+   const SurfFlatRegion* pSfrOther = GetBasicSurfFlatRegion( &Other) ;
+   if ( pSfrOther == nullptr)
       return false ;
+   const SurfFlatRegion& SfrOther = *pSfrOther ;
 
   // verifico che le due regioni giacciano in piani paralleli
    if ( ! AreSameVectorApprox( m_frF.VersZ(), SfrOther.m_frF.VersZ()))
@@ -110,9 +111,10 @@ bool
 SurfFlatRegion::Subtract( const ISurfFlatRegion& Other)
 {
   // converto l'altra regione nell'oggetto base
-   const SurfFlatRegion& SfrOther = dynamic_cast<const SurfFlatRegion&>( Other) ;
-   if ( &SfrOther == nullptr)
+   const SurfFlatRegion* pSfrOther = GetBasicSurfFlatRegion( &Other) ;
+   if ( pSfrOther == nullptr)
       return false ;
+   const SurfFlatRegion& SfrOther = *pSfrOther ;
 
   // verifico che le due regioni giacciano in piani paralleli
    if ( ! AreSameVectorApprox( m_frF.VersZ(), SfrOther.m_frF.VersZ()))
@@ -197,9 +199,10 @@ bool
 SurfFlatRegion::Intersect( const ISurfFlatRegion& Other)
 {
   // converto l'altra regione nell'oggetto base
-   const SurfFlatRegion& SfrOther = dynamic_cast<const SurfFlatRegion&>( Other) ;
-   if ( &SfrOther == nullptr)
+   const SurfFlatRegion* pSfrOther = GetBasicSurfFlatRegion( &Other) ;
+   if ( pSfrOther == nullptr)
       return false ;
+   const SurfFlatRegion& SfrOther = *pSfrOther ;
 
   // verifico che le due regioni giacciano in piani paralleli
    if ( ! AreSameVectorApprox( m_frF.VersZ(), SfrOther.m_frF.VersZ()))
diff --git a/SurfTriMesh.cpp b/SurfTriMesh.cpp
index dbf19d5..ae834c0 100644
--- a/SurfTriMesh.cpp
+++ b/SurfTriMesh.cpp
@@ -1199,7 +1199,7 @@ SurfTriMesh::Clone( void) const
 bool
 SurfTriMesh::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const SurfTriMesh* pStm = dynamic_cast<const SurfTriMesh*>( pGObjSrc) ;
+   const SurfTriMesh* pStm = GetBasicSurfTriMesh( pGObjSrc) ;
    if ( pStm == nullptr)
       return false ;
    return CopyFrom( *pStm) ;
@@ -2992,7 +2992,7 @@ bool
 SurfTriMesh::DoSewing( const ISurfTriMesh& stmOther, const Frame3d& frOther, double dTol)
 {
   // recupero l'altra superficie
-   const SurfTriMesh* pOther = dynamic_cast<const SurfTriMesh*>( &stmOther) ;
+   const SurfTriMesh* pOther = GetBasicSurfTriMesh( &stmOther) ;
    if ( pOther == nullptr)
       return false ;
 
diff --git a/SurfTriMesh.h b/SurfTriMesh.h
index 2082811..0ae775c 100644
--- a/SurfTriMesh.h
+++ b/SurfTriMesh.h
@@ -412,6 +412,10 @@ inline SurfTriMesh* CloneBasicSurfTriMesh( const IGeoObj* pGObj)
                     return nullptr ;
                  return ( static_cast<SurfTriMesh*>( pGObj->Clone())) ; }
 inline const SurfTriMesh* GetBasicSurfTriMesh( const IGeoObj* pGObj)
-               { return ( dynamic_cast<const SurfTriMesh*>( pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != SRF_TRIMESH)
+                    return nullptr ;
+                 return ( static_cast<const SurfTriMesh*>( pGObj)) ; }
 inline SurfTriMesh* GetBasicSurfTriMesh( IGeoObj* pGObj)
-               { return ( dynamic_cast<SurfTriMesh*>( pGObj)) ; }
+               { if ( pGObj == nullptr  ||  pGObj->GetType() != SRF_TRIMESH)
+                    return nullptr ;
+                 return ( static_cast<SurfTriMesh*>( pGObj)) ; }
diff --git a/VolZmap.cpp b/VolZmap.cpp
index 7630931..9c3b33c 100644
--- a/VolZmap.cpp
+++ b/VolZmap.cpp
@@ -108,7 +108,7 @@ VolZmap::Clone( void) const
 bool
 VolZmap::CopyFrom( const IGeoObj* pGObjSrc)
 {
-   const VolZmap* pVzm = dynamic_cast<const VolZmap*>( pGObjSrc) ;
+   const VolZmap* pVzm = GetBasicVolZmap( pGObjSrc) ;
    if ( pVzm == nullptr)
       return false ;
    return CopyFrom( *pVzm) ;
diff --git a/VolZmap.h b/VolZmap.h
index ee11252..146c3d5 100644
--- a/VolZmap.h
+++ b/VolZmap.h
@@ -466,16 +466,16 @@ class VolZmap : public IVolZmap, public IGeoObjRW
 
 //-----------------------------------------------------------------------------
 inline VolZmap* CreateBasicVolZmap( void)
-               { return (static_cast<VolZmap*>( CreateGeoObj( VOL_ZMAP))) ; }
+               { return ( static_cast<VolZmap*>( CreateGeoObj( VOL_ZMAP))) ; }
 inline VolZmap* CloneBasicVolZmap( const IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != VOL_ZMAP)
                     return nullptr ;
-                 return (static_cast<VolZmap*>(pGObj->Clone())) ; }
+                 return ( static_cast<VolZmap*>( pGObj->Clone())) ; }
 inline const VolZmap* GetBasicVolZmap( const IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != VOL_ZMAP)
                     return nullptr ;
-                 return (static_cast<const VolZmap*>(pGObj)) ; }
+                 return ( static_cast<const VolZmap*>( pGObj)) ; }
 inline VolZmap* GetBasicVolZmap( IGeoObj* pGObj)
                { if ( pGObj == nullptr  ||  pGObj->GetType() != VOL_ZMAP)
                     return nullptr ;
-                 return (static_cast<VolZmap*>(pGObj)) ; }
+                 return ( static_cast<VolZmap*>( pGObj)) ; }