EgtInterface 1.5k2 :

- aggiunta EgtCreateSurfTriMeshRuled
- aggiunta EgtExplodeText
- aggiunte EgtExtendCurve*ByLen e EgtExplodeCurveBezier
- aggiunte EgtSelectAll, EgtSelectPartObjs, EgtDeselectPartObjs, EgtSelectLayerObjs, EgtDeselectLayerObjs, EgtGetLastSelectedObj, EgtGetPrevSelectedObj
- aggiunte EgtIntersectionPoint, EgtPointToIdGlob.

API_GdbCreateSurf.cpp

@@ -109,6 +109,35 @@ __stdcall EgtCreateSurfTriMeshByScrewing( int nParentId, int nCrvId,
    return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) ;
 }
 
+//-------------------------------------------------------------------------------
+int
+__stdcall EgtCreateSurfTriMeshRuled( int nParentId, int nCrvId1, int nCrvId2, double dLinTol)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+  // recupero il riferimento del gruppo destinazione
+   Frame3d frDest ;
+   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest))
+      return GDB_ID_NULL ;
+  // calcolo la polilinea che approssima la prima curva
+   PolyLine PL1 ;
+   if ( ! GetPolyLineFromCurve( pGeomDB, nCrvId1, frDest, dLinTol, PL1))
+      return GDB_ID_NULL ;
+  // calcolo la polilinea che approssima la seconda curva
+   PolyLine PL2 ;
+   if ( ! GetPolyLineFromCurve( pGeomDB, nCrvId2, frDest, dLinTol, PL2))
+      return GDB_ID_NULL ;
+  // creo la superficie trimesh
+   PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
+   if ( IsNull( pSTM))
+      return GDB_ID_NULL ;
+  // costruisco la rigata tra le due curve
+   if ( ! pSTM->CreateByTwoCurves( PL1, PL2))
+      return GDB_ID_NULL ;
+  // inserisco la superficie trimesh nel DB
+   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) ;
+}
+
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 static bool

API_GdbModify.cpp

@@ -178,6 +178,35 @@ __stdcall EgtTextToOutline( int nId, int nDestGroupId)
    return ( bOk ? TRUE : FALSE) ;
 }
 
+//-------------------------------------------------------------------------------
+BOOL
+__stdcall EgtExplodeText( int nId)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, FALSE)
+  // recupero il testo
+   IExtText* pTXT = GetExtText( pGeomDB->GetGeoObj( nId)) ; 
+   if ( pTXT == nullptr)
+      return FALSE ;
+  // recupero l'outline del testo
+   ICURVEPLIST lstPCRV ;
+   pTXT->GetOutline( lstPCRV) ;
+  // inserisco le curve nella stessa posizione del testo
+   bool bOk = true ;
+   ICURVEPLIST::iterator iIter ;
+   for ( iIter = lstPCRV.begin() ; iIter != lstPCRV.end() ; ++ iIter) {
+     // inserisco la curva nello stesso gruppo e nello stesso posto del GeomDB
+      int nCrvId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, (*iIter)) ;
+      if ( nCrvId == GDB_ID_NULL)
+         return FALSE ;
+     // copio gli attributi
+      if ( ! pGeomDB->CopyAttributes( nId, nCrvId))
+         return FALSE ;
+   }
+  // elimino il testo originale
+   return ( pGeomDB->Erase( nId) ? TRUE : FALSE) ;
+}
+
 //-------------------------------------------------------------------------------
 BOOL
 __stdcall EgtSplitText( int nId, int nDestGroupId)

API_GdbModifyCurve.cpp

@@ -18,8 +18,11 @@
 #include "/EgtDev/Include/EInAPI.h"
 #include "/EgtDev/Include/EgkCurve.h"
 #include "/EgtDev/Include/EgkCurveArc.h"
+#include "/EgtDev/Include/EgkCurveBezier.h"
 #include "/EgtDev/Include/EgkCurveComposite.h"
 #include "/EgtDev/Include/EgkDistPointCurve.h"
+#include "/EgtDev/Include/EgkExtTExt.h"
+#include "/EgtDev/Include/EgtPointerOwner.h"
 
 
 //----------------------------------------------------------------------------
@@ -31,7 +34,7 @@ __stdcall EgtInvertCurve( int nId)
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
    if ( pCurve == nullptr)
-      return false ;
+      return FALSE ;
   // la inverto
    return ( pCurve->Invert() ? TRUE : FALSE) ;
 }
@@ -45,7 +48,7 @@ __stdcall EgtModifyCurveStartPoint( int nId, const double ptP[3])
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
    if ( pCurve == nullptr)
-      return false ;
+      return FALSE ;
   // ne modifico il punto iniziale
    return ( pCurve->ModifyStart( ptP) ? TRUE : FALSE) ;
 }
@@ -59,7 +62,7 @@ __stdcall EgtModifyCurveEndPoint( int nId, const double ptP[3])
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
    if ( pCurve == nullptr)
-      return false ;
+      return FALSE ;
   // ne modifico il punto finale
    return ( pCurve->ModifyEnd( ptP) ? TRUE : FALSE) ;
 }
@@ -73,7 +76,7 @@ __stdcall EgtModifyCurveExtrusion( int nId, const double vtExtr[3])
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
    if ( pCurve == nullptr)
-      return false ;
+      return FALSE ;
   // ne modifico il vettore estrusione
    return ( pCurve->SetExtrusion( Vector3d( vtExtr)) ? TRUE : FALSE) ;
 }
@@ -87,7 +90,7 @@ __stdcall EgtModifyCurveThickness( int nId, double dThick)
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
    if ( pCurve == nullptr)
-      return false ;
+      return FALSE ;
   // ne modifico lo spessore
    return ( pCurve->SetThickness( dThick) ? TRUE : FALSE) ;
 }
@@ -101,7 +104,7 @@ __stdcall EgtTrimCurveStartAtLen( int nId, double dLen)
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
    if ( pCurve == nullptr)
-      return false ;
+      return FALSE ;
   // taglio la curva all'inizio
    return ( pCurve->TrimStartAtLen( dLen) ? TRUE : FALSE) ;
 }
@@ -115,7 +118,7 @@ __stdcall EgtTrimCurveEndAtLen( int nId, double dLen)
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
    if ( pCurve == nullptr)
-      return false ;
+      return FALSE ;
   // taglio la curva alla fine
    return ( pCurve->TrimEndAtLen( dLen) ? TRUE : FALSE) ;
 }
@@ -129,7 +132,7 @@ __stdcall EgtTrimCurveStartAtParam( int nId, double dPar)
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
    if ( pCurve == nullptr)
-      return false ;
+      return FALSE ;
   // taglio la curva all'inizio
    return ( pCurve->TrimStartAtParam( dPar) ? TRUE : FALSE) ;
 }
@@ -143,7 +146,7 @@ __stdcall EgtTrimCurveEndAtParam( int nId, double dPar)
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
    if ( pCurve == nullptr)
-      return false ;
+      return FALSE ;
   // taglio la curva alla fine
    return ( pCurve->TrimEndAtParam( dPar) ? TRUE : FALSE) ;
 }
@@ -157,11 +160,59 @@ __stdcall EgtTrimCurveStartEndAtParam( int nId, double dParS, double dParE)
   // recupero la curva
    ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
    if ( pCurve == nullptr)
-      return false ;
-  // taglio la curva all'inizio
+      return FALSE ;
+  // taglio la curva agli estremi
    return ( pCurve->TrimStartEndAtParam( dParS, dParE) ? TRUE : FALSE) ;
 }
 
+//----------------------------------------------------------------------------
+BOOL
+__stdcall EgtExtendCurveStartByLen( int nId, double dLen)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+  // recupero la curva
+   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
+   if ( pCurve == nullptr)
+      return FALSE ;
+  // estendo la curva all'inizio
+   return ( pCurve->ExtendStartByLen( dLen) ? TRUE : FALSE) ;
+}
+
+//----------------------------------------------------------------------------
+BOOL
+__stdcall EgtExtendCurveEndByLen( int nId, double dLen)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+  // recupero la curva
+   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
+   if ( pCurve == nullptr)
+      return FALSE ;
+  // estendo la curva alla fine
+   return ( pCurve->ExtendEndByLen( dLen) ? TRUE : FALSE) ;
+}
+
+//----------------------------------------------------------------------------
+BOOL
+__stdcall EgtExtendCurveByLen( int nId, double dLen, const double ptNear[3])
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+  // recupero la curva
+   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
+   if ( pCurve == nullptr)
+      return FALSE ;
+  // cerco l'estremo più vicino al punto passato
+   Point3d ptStart, ptEnd ;
+   if ( ! pCurve->GetStartPoint( ptStart)  ||  ! pCurve->GetEndPoint( ptEnd))
+      return FALSE ;
+   if ( SqDist( ptStart, ptNear) < SqDist( ptEnd, ptNear))
+      return ( pCurve->ExtendStartByLen( dLen) ? TRUE : FALSE) ;
+   else
+      return ( pCurve->ExtendEndByLen( dLen) ? TRUE : FALSE) ;
+}
+
 //----------------------------------------------------------------------------
 BOOL
 __stdcall EgtSplitCurveAtPoint( int nId, double ptOn[3])
@@ -271,15 +322,11 @@ __stdcall EgtSeparateCurveCompo( int nId)
    ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
    if ( pCompo == nullptr)
       return FALSE ;
-  // ne recupero il padre
-   int nParentId = pGeomDB->GetParentId( nId) ;
-   if ( nParentId == GDB_ID_NULL)
-      return FALSE ;
   // estraggo tutte le curve
    ICurve* pCrv ;
    while ( ( pCrv = pCompo->RemoveFirstOrLastCurve( false)) != nullptr) {
-     // inserisco la curva nello stesso gruppo del GeomDB
-      int nCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pCrv) ;
+     // inserisco la curva nello stesso gruppo e nello stesso posto del GeomDB
+      int nCrvId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pCrv) ;
       if ( nCrvId == GDB_ID_NULL)
          return FALSE ;
      // copio gli attributi
@@ -288,4 +335,46 @@ __stdcall EgtSeparateCurveCompo( int nId)
    }
   // elimino la curva composita ormai vuota
    return ( pGeomDB->Erase( nId) ? TRUE : FALSE) ;
+}
+
+//-------------------------------------------------------------------------------
+BOOL
+__stdcall EgtExplodeCurveBezier( int nId, double dLinTol, BOOL bArcsVsLines)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, FALSE)
+  // recupero la curva di Bezier
+   ICurveBezier* pCBezier = GetCurveBezier( pGeomDB->GetGeoObj( nId)) ;
+   if ( pCBezier == nullptr)
+      return FALSE ;
+  // eseguo l'approssimazione
+   const double ANG_TOL_STD_DEG = 15 ;
+   PtrOwner<ICurveComposite> pCC( CreateCurveComposite()) ;
+   if ( IsNull( pCC))
+      return FALSE ;
+   if ( bArcsVsLines) {       // con bi-archi
+      PolyArc PA ;
+      if ( ! pCBezier->ApproxWithArcs( dLinTol, ANG_TOL_STD_DEG, PA)  ||
+           ! pCC->FromPolyArc( PA))
+         return FALSE ;
+   }
+   else {                     // con linee
+      PolyLine PL ;
+      if ( ! pCBezier->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, PL)  ||
+           ! pCC->FromPolyLine( PL))
+         return FALSE ;
+   }
+  // inserisco le curve elementari nel DB
+   ICurve* pCrv ;
+   while ( ( pCrv = pCC->RemoveFirstOrLastCurve( false)) != nullptr) {
+     // inserisco la curva nello stesso gruppo e nello stesso posto del GeomDB
+      int nCrvId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pCrv) ;
+      if ( nCrvId == GDB_ID_NULL)
+         return FALSE ;
+     // copio gli attributi
+      if ( ! pGeomDB->CopyAttributes( nId, nCrvId))
+         return FALSE ;
+   }
+  // elimino la curva di Bezier
+   return ( pGeomDB->Erase( nId) ? TRUE : FALSE) ;
 }

API_GdbObjSelection.cpp

@@ -25,70 +25,215 @@ using namespace std ;
 
 //-----------------------------------------------------------------------------
 BOOL
- __stdcall EgtSelectObj( int nId)
- {
+__stdcall EgtSelectObj( int nId)
+{
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, FALSE)
   // seleziono l'oggetto
    return ( pGeomDB->SelectObj( nId) ? TRUE : FALSE) ;
- }
+}
 
 //-----------------------------------------------------------------------------
 BOOL
- __stdcall EgtDeselectObj( int nId)
- {
+__stdcall EgtDeselectObj( int nId)
+{
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, FALSE)
   // deseleziono l'oggetto
    return ( pGeomDB->DeselectObj( nId) ? TRUE : FALSE) ;
- }
+}
 
 //-----------------------------------------------------------------------------
 BOOL
- __stdcall EgtDeselectAll( void)
- {
+__stdcall EgtSelectAll( bool bOnlyIfVisible)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, FALSE)
+  // seleziono tutto
+   int nId1 = pGeomDB->GetFirstInGroup( GDB_ID_ROOT) ;
+   while ( nId1 != GDB_ID_NULL) {
+     // ciclo sugli oggetti del pezzo
+      int nId2 = pGeomDB->GetFirstInGroup( nId1) ;
+      while ( nId2 != GDB_ID_NULL) {
+        // se è gruppo seleziono i suoi componenti
+         if ( pGeomDB->GetGdbType( nId2) == GDB_TY_GROUP)
+            pGeomDB->SelectGroupObjs( nId2, 0, bOnlyIfVisible) ;
+        // altrimenti lo seleziono direttamente
+         else
+            pGeomDB->SelectObj( nId2, bOnlyIfVisible) ;
+        // passo al successivo
+         nId2 = pGeomDB->GetNext( nId2) ;
+      }
+     // passo al successivo
+      nId1 = pGeomDB->GetNext( nId1) ;
+   }
+   return TRUE ;
+}
+
+//-----------------------------------------------------------------------------
+BOOL
+__stdcall EgtDeselectAll( void)
+{
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, FALSE)
   // deseleziono tutto
    return ( pGeomDB->ClearSelection() ? TRUE : FALSE) ;
- }
+}
 
 //-----------------------------------------------------------------------------
 BOOL
- __stdcall EgtIsSelectedObj( int nId)
- {
+__stdcall EgtSelectPartObjs( int nPartId)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+  // verifico sia veramente un pezzo (gruppo sotto la radice)
+   if ( pGeomDB->GetGdbType( nPartId) != GDB_TY_GROUP  ||
+        pGeomDB->GetParentId( nPartId) != GDB_ID_ROOT)
+      return FALSE ;
+  // ciclo sugli oggetti del pezzo
+   int nId = pGeomDB->GetFirstInGroup( nPartId) ;
+   while ( nId != GDB_ID_NULL) {
+     // se è gruppo seleziono i suoi componenti
+      if ( pGeomDB->GetGdbType( nId) == GDB_TY_GROUP)
+         pGeomDB->SelectGroupObjs( nId) ;
+     // altrimenti lo seleziono direttamente
+      else
+         pGeomDB->SelectObj( nId) ;
+     // passo al successivo
+      nId = pGeomDB->GetNext( nId) ;
+   }
+   return TRUE ;
+}
+
+//-----------------------------------------------------------------------------
+BOOL
+__stdcall EgtDeselectPartObjs( int nPartId)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+  // verifico sia veramente un pezzo (gruppo sotto la radice)
+   if ( pGeomDB->GetGdbType( nPartId) != GDB_TY_GROUP  ||
+        pGeomDB->GetParentId( nPartId) != GDB_ID_ROOT)
+      return FALSE ;
+  // ciclo sugli oggetti del pezzo
+   int nId = pGeomDB->GetFirstInGroup( nPartId) ;
+   while ( nId != GDB_ID_NULL) {
+     // se è gruppo deseleziono i suoi componenti
+      if ( pGeomDB->GetGdbType( nId) == GDB_TY_GROUP)
+         pGeomDB->DeselectGroupObjs( nId) ;
+     // altrimenti lo deseleziono direttamente
+      else
+         pGeomDB->DeselectObj( nId) ;
+     // passo al successivo
+      nId = pGeomDB->GetNext( nId) ;
+   }
+   return TRUE ;
+}
+
+//-----------------------------------------------------------------------------
+BOOL
+__stdcall EgtSelectLayerObjs( int nLayerId)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+  // verifico sia veramente un layer (gruppo senza sottogruppi)
+   if ( pGeomDB->GetGdbType( nLayerId) != GDB_TY_GROUP)
+      return FALSE ;
+  // ciclo sugli oggetti del layer
+   int nId = pGeomDB->GetFirstInGroup( nLayerId) ;
+   while ( nId != GDB_ID_NULL) {
+     // se è gruppo errore
+      if ( pGeomDB->GetGdbType( nId) == GDB_TY_GROUP)
+         return FALSE ;
+     // altrimenti lo seleziono direttamente
+      else
+         pGeomDB->SelectObj( nId) ;
+     // passo al successivo
+      nId = pGeomDB->GetNext( nId) ;
+   }
+   return TRUE ;
+}
+
+//-----------------------------------------------------------------------------
+BOOL
+__stdcall EgtDeselectLayerObjs( int nLayerId)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+  // verifico sia veramente un layer (gruppo senza sottogruppi)
+   if ( pGeomDB->GetGdbType( nLayerId) != GDB_TY_GROUP)
+      return FALSE ;
+  // ciclo sugli oggetti del layer
+   int nId = pGeomDB->GetFirstInGroup( nLayerId) ;
+   while ( nId != GDB_ID_NULL) {
+     // se è gruppo errore
+      if ( pGeomDB->GetGdbType( nId) == GDB_TY_GROUP)
+         return FALSE ;
+     // altrimenti lo deseleziono direttamente
+      else
+         pGeomDB->DeselectObj( nId) ;
+     // passo al successivo
+      nId = pGeomDB->GetNext( nId) ;
+   }
+   return TRUE ;
+}
+
+//-----------------------------------------------------------------------------
+BOOL
+__stdcall EgtIsSelectedObj( int nId)
+{
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, FALSE)
   // verifico se l'oggetto è selezionato
    return ( pGeomDB->IsSelectedObj( nId) ? TRUE : FALSE) ;
- }
+}
 
 //-----------------------------------------------------------------------------
 int
- __stdcall EgtGetSelectedObjNbr( void)
- {
+__stdcall EgtGetSelectedObjNbr( void)
+{
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, 0)
   // restituisco il numero di oggetti selezionati
    return pGeomDB->GetSelectedObjNbr() ;
- }
+}
 
 //-----------------------------------------------------------------------------
 int
- __stdcall EgtGetFirstSelectedObj( void)
- {
+__stdcall EgtGetFirstSelectedObj( void)
+{
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   // recupero il primo oggetto selezionato
    return pGeomDB->GetFirstSelectedObj() ;
- }
+}
 
 //-----------------------------------------------------------------------------
 int
- __stdcall EgtGetNextSelectedObj( void)
- {
+__stdcall EgtGetNextSelectedObj( void)
+{
    IGeomDB* pGeomDB = GetCurrGeomDB() ;
    VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   // recupero il successivo oggetto selezionato
    return pGeomDB->GetNextSelectedObj() ;
- }
+}
+
+//-----------------------------------------------------------------------------
+int
+__stdcall EgtGetLastSelectedObj( void)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+  // recupero l'ultimo oggetto selezionato
+   return pGeomDB->GetLastSelectedObj() ;
+}
+
+//-----------------------------------------------------------------------------
+int
+__stdcall EgtGetPrevSelectedObj( void)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
+  // recupero il precedente oggetto selezionato
+   return pGeomDB->GetPrevSelectedObj() ;
+}

API_GeoSnap.cpp

@@ -20,6 +20,8 @@
 #include "/EgtDev/Include/EgkGeoVector3d.h"
 #include "/EgtDev/Include/EgkCurve.h"
 #include "/EgtDev/Include/EgkExtText.h"
+#include "/EgtDev/Include/EgkIntersCurveCurve.h"
+#include "/EgtDev/Include/EgtPointerOwner.h"
 
 
 //----------------------------------------------------------------------------
@@ -237,6 +239,57 @@ __stdcall EgtAtParamPoint( int nId, double dU, double ptP[3])
    return FALSE ;
 }
 
+//----------------------------------------------------------------------------
+BOOL
+__stdcall EgtIntersectionPoint( int nId1, int nId2, const double ptNear[3], double ptP[3])
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, FALSE)
+  // devono essere entità geometriche
+   const IGeoObj* pGObj1 ;
+   if ( ( pGObj1 = pGeomDB->GetGeoObj( nId1)) == nullptr)
+      return FALSE ;
+   const IGeoObj* pGObj2 ;
+   if ( ( pGObj2 = pGeomDB->GetGeoObj( nId2)) == nullptr)
+      return FALSE ;
+  // se curve
+   if ( ( pGObj1->GetType() & GEO_CURVE) != 0  &&  ( pGObj2->GetType() & GEO_CURVE) != 0) {
+     // recupero le curve
+      const ICurve* pCrv1 = GetCurve( pGObj1) ;
+      const ICurve* pCrv2 = GetCurve( pGObj2) ;
+     // recupero i riferimenti in cui sono immerse
+      Frame3d frEnt1 ;
+      if ( ! pGeomDB->GetGlobFrame( nId1, frEnt1))
+         return FALSE ;
+      Frame3d frEnt2 ;
+      if ( ! pGeomDB->GetGlobFrame( nId2, frEnt2))
+         return FALSE ;
+     // se il riferimento della seconda curva è diverso da quello della prima entità, devo trasformarla
+      PtrOwner<ICurve> crvTrans( nullptr) ;
+      if ( ! AreSameFrame( frEnt1, frEnt2)) {
+         crvTrans.Set( pCrv2->Clone()) ;
+         if ( IsNull( crvTrans))
+            return FALSE ;
+         crvTrans->LocToLoc( frEnt2, frEnt1) ;
+         pCrv2 = ::Get( crvTrans) ;
+      }
+     // porto il punto vicino nel riferimento della prima curva
+      Point3d ptN( ptNear) ;
+      ptN.ToLoc( frEnt1) ;
+     // calcolo il punto di intersezione sulla prima curva più vicino al punto di riferimento
+      IntersCurveCurve intCC( *pCrv1, *pCrv2, true) ;
+      Point3d ptI ;
+      if ( ! intCC.GetIntersPointNearTo( 0, ptN, ptI))
+         return FALSE ;
+     // assegno il punto
+      ptP[0] = ptI.x ;
+      ptP[1] = ptI.y ;
+      ptP[2] = ptI.z ;
+      return TRUE ;
+   }
+   return FALSE ;
+}
+
 //----------------------------------------------------------------------------
 BOOL
 __stdcall EgtStartVector( int nId, double vtV[3])
@@ -449,6 +502,27 @@ __stdcall EgtVectorToIdLoc( double vtV[3], int nId)
    return TRUE ;   
 }
 
+//-------------------------------------------------------------------------------
+BOOL
+__stdcall EgtPointToIdGlob( double ptP[3], int nId)
+{
+   IGeomDB* pGeomDB = GetCurrGeomDB() ;
+   VERIFY_GEOMDB( pGeomDB, FALSE)
+  // recupero il riferimento
+  // se gruppo -> il suo proprio espresso in globale
+  // se oggetto -> quello del gruppo cui appartiene in globale
+   Frame3d frRef ;
+   if ( ! pGeomDB->GetGroupGlobFrame( nId, frRef)  &&
+        ! pGeomDB->GetGlobFrame( nId, frRef))
+      return FALSE ;
+  // eseguo la trasformazione
+   Point3d ptPL( ptP) ;
+   ptPL.ToGlob( frRef) ;
+  // aggiorno il parametro punto
+   VEC_FROM_3D( ptP, ptPL)
+   return TRUE ;   
+}
+
 //-------------------------------------------------------------------------------
 BOOL
 __stdcall EgtPointToIdLoc( double ptP[3], int nId)