EgtExecutor/EXE_GdbGetCurve.cpp

//----------------------------------------------------------------------------
//  EgalTech 2020-2022
//----------------------------------------------------------------------------
// File : EXE_GeoSnap.cpp       Data : 11.04.22        Versione : 2.4d1
// Contenuto : Funzioni di interrogazione di curve del DBG per EXE.
//
//
//
// Modifiche : 23.03.20 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "EXE.h"
#include "EXE_Const.h"
#include "EXE_Macro.h"
#include "AuxTools.h"
#include "GeoTools.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkCurve.h"
#include "/EgtDev/Include/EGkCurveArc.h"
#include "/EgtDev/Include/EGkCurveBezier.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EGkCurveAux.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGkIntersCurves.h"
#include "/EgtDev/Include/EGkSurfFlatRegion.h"

using namespace std ;

//----------------------------------------------------------------------------
bool
ExeCurveDomain( int nId, double* pdStart, double* pdEnd)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico i parametri
   if ( pdStart == nullptr  ||  pdEnd == nullptr)
      return false ;
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
  // recupero il dominio
   return ( pCurve != nullptr  &&  pCurve->GetDomain( *pdStart, *pdEnd)) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveLength( int nId, double* pdLen)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pdLen == nullptr)
      return false ;
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
  // recupero la lunghezza
   return ( pCurve != nullptr  &&  pCurve->GetLength( *pdLen)) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveLengthAtParam( int nId, double dPar, double* pdLen)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pdLen == nullptr)
      return false ;
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
  // recupero la lunghezza
   return ( pCurve != nullptr  &&  pCurve->GetLengthAtParam( dPar, *pdLen)) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveParamAtLength( int nId, double dLen, double* pdPar)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pdPar == nullptr)
      return false ;
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
  // recupero il parametro in corrispondenza dLen
   return ( pCurve != nullptr  &&  pCurve->GetParamAtLength( dLen, *pdPar)) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveParamAtPoint( int nId, const Point3d& ptP, double dTol, int nRefType, double* pdPar)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pdPar == nullptr)
      return false ;
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pCurve != nullptr) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId, frLoc) ;
  // porto il punto in locale 
   Point3d ptL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ; 
  // recupero il parametro in corrispondenza ptL
   return ( bOk && pCurve->GetParamAtPoint( ptL, *pdPar, dTol)) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveLengthAtPoint( int nId, const Point3d& ptOn, double dExtend, double* pdLen)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pdLen == nullptr)
      return false ;
  // recupero la curva
   const ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
   if ( pCurve == nullptr)
      return false ;
  // determino la posizione parametrica del punto sulla curva (con tolleranza)
   int nFlag ;
   double dU ;
   if ( ! DistPointCurve( ptOn, *pCurve).GetParamAtMinDistPoint( 0, dU, nFlag)  ||  nFlag != MDPCI_NORMAL)
      return false ;
  // se non richiesta estensione o punto interno alla curva, recupero la lunghezza alla posizione parametrica
   if ( dExtend < EPS_SMALL  ||
        ( ! pCurve->IsStartParam( dU)  &&  ! pCurve->IsEndParam( dU)))
      return ( pCurve->GetLengthAtParam( dU, *pdLen) ? true : false) ;
  // allungo la curva dalla parte del punto
   PtrOwner<ICurve> pCopy( pCurve->Clone()) ;
   if ( IsNull( pCopy))
      return false ;
   double dDeltaIni ;
   if ( pCopy->IsStartParam( dU)) {
      pCopy->ExtendStartByLen( dExtend) ;
      dDeltaIni = dExtend ;
   }
   else {
      pCopy->ExtendEndByLen( dExtend) ;
      dDeltaIni = 0 ;
   }
   if ( ! DistPointCurve( ptOn, *pCopy).GetParamAtMinDistPoint( 0, dU, nFlag)  ||  nFlag != MDPCI_NORMAL)
      return false ;
   if ( pCopy->GetLengthAtParam( dU, *pdLen)) {
      *pdLen -= dDeltaIni ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
ExeCurveIsClosed( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
  // verifico se chiusa
   return ( pCurve != nullptr  &&  pCurve->IsClosed()) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveIsFlat( int nId, Plane3d& Plane, bool bUseExtrusion, double dToler)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( &Plane == nullptr)
      return false ;
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
  // ne verifico la planarit�
   return ( pCurve != nullptr  &&  pCurve->IsFlat( Plane, bUseExtrusion, dToler)) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveIsACircle( int nId, Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW, double dToler)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico i parametri
   if ( &ptCen == nullptr  ||  &vtN == nullptr  ||  &dRad == nullptr  ||  &bCCW == nullptr)
      return false ;
  // recupero l'oggetto
   IGeoObj* pGObj = pGeomDB->GetGeoObj( nId) ;
   if ( pGObj == nullptr)
      return false ;
  // analizzo tipi di curve candidabili
   switch ( pGObj->GetType()) {
   case CRV_ARC :
      {  ICurveArc* pArc = GetCurveArc( pGObj) ;
         if ( pArc->IsACircle()) {
            ptCen = pArc->GetCenter() ;
            vtN = pArc->GetNormVersor() ;
            dRad = pArc->GetRadius() ;
            bCCW = ( pArc->GetAngCenter() > 0) ;
            return true ;
         }
         else
            return false ;
      }
   case CRV_COMPO :
      { ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
        return pCompo->IsACircle( dToler, ptCen, vtN, dRad, bCCW) ;
      }
   case CRV_BEZIER :
      { ICurveBezier* pBezier = GetCurveBezier( pGObj) ;
        PolyArc PA ;
        if ( ! pBezier->ApproxWithArcs( dToler, ANG_TOL_STD_DEG, PA))
           return false ;
        PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
        if ( IsNull( pCompo)  ||  ! pCompo->FromPolyArc( PA))
           return false ;
        return pCompo->IsACircle( dToler, ptCen, vtN, dRad, bCCW) ;
      }
   default :
      return false ;
   }

   return false ;
}

//----------------------------------------------------------------------------
bool
ExeCurveIsARectangle( int nId, Point3d& ptP, Vector3d& vtL1, Vector3d& vtL2, double dToler)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico i parametri
   if ( &ptP == nullptr  ||  &vtL1 == nullptr  ||  &vtL2 == nullptr)
      return false ;
  // recupero l'oggetto
   IGeoObj* pGObj = pGeomDB->GetGeoObj( nId) ;
   if ( pGObj == nullptr)
      return false ;
  // verifico sia una curva composita
   if ( pGObj->GetType() != CRV_COMPO)
      return false ;
  // eseguo
   ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
   return pCompo->IsARectangle( dToler, ptP, vtL1, vtL2) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveIsATrapezoid( int nId, Point3d& ptP, Vector3d& vtB1, Vector3d& vtL1, Vector3d& vtB2, double dToler)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico i parametri
   if ( &ptP == nullptr  ||  &vtB1 == nullptr  ||  &vtL1 == nullptr  ||  &vtB1 == nullptr)
      return false ;
  // recupero l'oggetto
   IGeoObj* pGObj = pGeomDB->GetGeoObj( nId) ;
   if ( pGObj == nullptr)
      return false ;
  // verifico sia una curva composita
   if ( pGObj->GetType() != CRV_COMPO)
      return false ;
  // eseguo
   ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
   return pCompo->IsATrapezoid( dToler, ptP, vtB1, vtL1, vtB2) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveAreaXY( int nId, double& dArea)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( &dArea == nullptr)
      return false ;
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
  // determino l'area nel piano XY
   return ( pCurve != nullptr  &&  pCurve->GetAreaXY( dArea)) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveArea( int nId, Plane3d& Plane, double& dArea)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico i parametri
   if ( &Plane == nullptr  || &dArea == nullptr)
      return false ;
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
  // determino il piano medio della curva e la sua area su di esso (deve essere chiusa)
   return ( pCurve != nullptr  &&  pCurve->GetArea( Plane, dArea)) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveNearestExtremityToPoint( int nId, const Point3d& ptP, bool& bStart)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
  // recupero quale estremo � pi� vicino al punto
   return ( pCurve != nullptr  &&  pCurve->GetNearestExtremityToPoint( ptP, bStart)) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveExtrusion( int nId, int nRefId, Vector3d& vtExtr)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
  // ne ricavo il vettore estrusione
   if ( pCurve == nullptr  ||  ! pCurve->GetExtrusion( vtExtr))
      return false ;
  // gestione trasformazione ( eventuale)
   return TransformVector( pGeomDB, nId, nRefId, vtExtr) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveThickness( int nId, double* pdThick)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pdThick == nullptr)
      return false ;
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
  // recupero lo spessore
   return ( pCurve != nullptr && pCurve->GetThickness( *pdThick)) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveSelfIntersCount( int nId, int* pnCount)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pnCount == nullptr)
      return false ;
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
   if ( pCurve == nullptr)
      return false ;
  // calcolo le auto-intersezioni
   SelfIntersCurve sintC( *pCurve) ;
  // ne recupero il numero
   *pnCount = sintC.GetIntersCount() ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ExeCurveMinAreaRectangleXY( int nId, int nRefId, Frame3d& frRect, double& dDimX, double& dDimY)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva
   ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pCurve != nullptr) ;
  // recupero il riferimento della curva
   Frame3d frCrv ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId, frCrv) ;
  // derivo la polilinea di approssimazione della curva entro la tolleranza standard
   PolyLine PL ;
   bOk = bOk && pCurve->ApproxWithLines( LIN_TOL_FINE, ANG_TOL_STD_DEG, APP_LINES, PL) ;
  // eventuale trasformazione per riferimento di espressione
   if ( bOk  &&  nRefId == GDB_ID_ROOT)
      PL.ToGlob( frCrv) ;
   else if ( bOk  &&  nRefId == GDB_ID_GRID)
      PL.LocToLoc( frCrv, pGeomDB->GetGridFrame()) ;
   else if ( bOk  &&  nRefId != nId) {
      Frame3d frDest ;
     // nRefId pu� essere un gruppo o una entit�
      if ( pGeomDB->GetGroupGlobFrame( nRefId, frDest)  ||
           pGeomDB->GetGlobFrame( nRefId, frDest))
         PL.LocToLoc( frCrv, frDest) ;
      else
         bOk = false ;
   }
  // derivo il rettangolo in XY di area minima di questa
   Point3d ptCen ;
   Vector3d vtAx ;
   bOk = bOk && PL.GetMinAreaRectangleXY( ptCen, vtAx, dDimX, dDimY) &&
                frRect.Set( ptCen, Z_AX, vtAx) ;
   return bOk ;
}

//----------------------------------------------------------------------------
int
ExeClosedCurveClassify( int nId1, int nId2)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, 0)
  // recupero la prima curva
   const ICurve* pCrv1 = GetCurve( pGeomDB->GetGeoObj( nId1)) ;
   if ( pCrv1 == nullptr  ||  ! pCrv1->IsClosed())
      return CCREGC_NULL ;
  // recupero il riferimento della curva
   Frame3d frCrv1 ;
   if ( ! pGeomDB->GetGlobFrame( nId1, frCrv1))
      return CCREGC_NULL ;
  // recupero la seconda curva
   const ICurve* pCrv2 = GetCurve( pGeomDB->GetGeoObj( nId2)) ;
   if ( pCrv2 == nullptr  ||  ! pCrv2->IsClosed())
      return CCREGC_NULL ;
  // recupero il riferimento della curva
   Frame3d frCrv2 ;
   if ( ! pGeomDB->GetGlobFrame( nId2, frCrv2))
      return CCREGC_NULL ;
  // se riferimenti diversi, porto una copia della seconda nel riferimento della prima
   const ICurve* pCrv2L = pCrv2 ;
   PtrOwner<ICurve> pTmp ;
   if ( ! AreSameFrame( frCrv1, frCrv2)) {
      pTmp.Set( pCrv2->Clone()) ;
      if ( IsNull( pTmp)  ||  ! pTmp->LocToLoc( frCrv2, frCrv1))
         return CCREGC_NULL ;
      pCrv2L = pTmp ;
   }

  // classifico la prima curva rispetto alla seconda
   IntersCurveCurve ccInt( *pCrv1, *pCrv2L) ;
   return ccInt.GetRegionCurveClassification() ;
}

//----------------------------------------------------------------------------
int
ExeCurveWithRegionClassify( int nCurveId, int nRegionId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, 0)
  // recupero la curva e il suo riferimento
   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCurveId)) ;
   if ( pCrv == nullptr)
      return CRC_NULL ;
  // recupero il riferimento della curva
   Frame3d frCrv ;
   if ( ! pGeomDB->GetGlobFrame( nCurveId, frCrv))
      return CRC_NULL ;
  // recupero la superficie FlatRegion e il suo riferimento
   ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nRegionId)) ;
   if ( pSfr == nullptr)
      return CRC_NULL ;
  // recupero il riferimento della superficie
   Frame3d frSurf ;
   if ( ! pGeomDB->GetGlobFrame( nRegionId, frSurf))
      return CRC_NULL ;
  // se riferimenti diversi, porto una copia della curva nel riferimento della superficie
   const ICurve* pCrvL = pCrv ;
   PtrOwner<ICurve> pTmp ;
   if ( ! AreSameFrame( frCrv, frSurf)) {
      pTmp.Set( pCrv->Clone()) ;
      if ( IsNull( pTmp))
         return CRC_NULL ;
      pTmp->LocToLoc( frCrv, frSurf) ;
      pCrvL = pTmp ;
   }
  // classifico la curva rispetto alla regione
   CRVCVECTOR vcClass ;
   if ( ! pSfr->GetCurveClassification( *pCrvL, EPS_SMALL, vcClass))
      return CRC_NULL ;
   int nRes = CRC_NULL ;
   for ( auto& cClass : vcClass) {
      switch ( cClass.nClass) {
      case CRVC_NULL :
         return CRC_NULL ;
         break ;
      case CRVC_IN :
         if ( nRes == CRC_NULL  ||  nRes == CRC_IN  ||  nRes == CRC_ON)
            nRes = CRC_IN ;
         else
            nRes = CRC_INTERS ;
         break ;
      case CRVC_OUT :
         if ( nRes == CRC_NULL  ||  nRes == CRC_OUT  ||  nRes == CRC_ON)
            nRes = CRC_OUT ;
         else
            nRes = CRC_INTERS ;
         break ;
      case CRVC_ON_P :
      case CRVC_ON_M :
         if ( nRes == CRC_NULL)
            nRes = CRC_ON ;
         break ;
      }
   }

   return nRes ;
}

//----------------------------------------------------------------------------
bool
ExeArcRadius( int nId, double* pdRad)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pdRad == nullptr)
      return false ;
  // recupero l'arco
   const ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ;
   if ( pArc == nullptr)
      return false ;
   *pdRad = pArc->GetRadius() ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ExeArcAngCenter( int nId, double* pdAngDeg)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pdAngDeg == nullptr)
      return false ;
  // recupero l'arco
   const ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ;
   if ( pArc == nullptr)
      return false ;
   *pdAngDeg = pArc->GetAngCenter() ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ExeArcDeltaN( int nId, double* pdDeltaN)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( pdDeltaN == nullptr)
      return false ;
  // recupero l'arco
   const ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ;
   if ( pArc == nullptr)
      return false ;
   *pdDeltaN = pArc->GetDeltaN() ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ExeArcNormVersor( int nId, int nRefId, Vector3d& vtNorm)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero l'arco
   const ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ;
   if ( pArc == nullptr)
      return false ;
  // recupero la normale
   vtNorm = pArc->GetNormVersor() ;
  // gestione trasformazione ( eventuale)
   return TransformVector( pGeomDB, nId, nRefId, vtNorm) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveCompoLength( int nId, int nSimpCrv, double& dLen)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva composita
   const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
   if ( pCompoCrv == nullptr)
      return false ;
  // recupero la curva semplice di indice richiesto
   const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ;
   if ( pSimpCrv == nullptr)
      return false ;
  // recupero la sua lunghezza
   return pSimpCrv->GetLength( dLen) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveCompoCenter( int nId, int nSimpCrv, int nRefId, Point3d& ptCen)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva composita
   const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
   if ( pCompoCrv == nullptr)
      return false ;
  // recupero la curva semplice di indice richiesto
   const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ;
   if ( pSimpCrv == nullptr)
      return false ;
  // recupero il centro
   if ( ! pSimpCrv->GetCenterPoint( ptCen))
      return false ;
  // gestione trasformazione ( eventuale)
   return TransformPoint( pGeomDB, nId, nRefId, ptCen) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveCompoRadius( int nId, int nSimpCrv, double& dRad)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva composita
   const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
   if ( pCompoCrv == nullptr)
      return false ;
  // recupero la curva semplice di indice richiesto
   const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ;
   if ( pSimpCrv == nullptr)
      return false ;
  // a seconda del tipo di curva
   switch ( pSimpCrv->GetType()) {
   case CRV_LINE :
      dRad = -1 ;
      break ;
   case CRV_ARC :
      dRad = GetCurveArc( pSimpCrv)->GetRadius() ;
      break ;
   case CRV_BEZIER :
      dRad = -2 ;
      break ;
   default :
      dRad = -3 ;
      break ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
ExeCurveCompoAngCenter( int nId, int nSimpCrv, double& dAngCen)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva composita
   const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
   if ( pCompoCrv == nullptr)
      return false ;
  // recupero la curva semplice di indice richiesto
   const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ;
   if ( pSimpCrv == nullptr)
      return false ;
  // a seconda del tipo di curva
   switch ( pSimpCrv->GetType()) {
   case CRV_LINE :
      dAngCen = 0 ;
      break ;
   case CRV_ARC :
      dAngCen = GetCurveArc( pSimpCrv)->GetAngCenter() ;
      break ;
   case CRV_BEZIER :
      dAngCen = 0 ;
      break ;
   default :
      dAngCen = 0 ;
      break ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
ExeCurveCompoNormVersor( int nId, int nSimpCrv, int nRefId, Vector3d& vtNorm)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva composita
   const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
   if ( pCompoCrv == nullptr)
      return false ;
  // recupero la curva semplice di indice richiesto
   const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ;
   if ( pSimpCrv == nullptr)
      return false ;
  // a seconda del tipo di curva
   switch ( pSimpCrv->GetType()) {
   case CRV_LINE :
      vtNorm = V_NULL ;
      break ;
   case CRV_ARC :
      vtNorm = GetCurveArc( pSimpCrv)->GetNormVersor() ;
      break ;
   case CRV_BEZIER :
      vtNorm = V_NULL ;
      break ;
   default :
      vtNorm = V_NULL ;
      break ;
   }
  // gestione trasformazione ( eventuale)
   return TransformVector( pGeomDB, nId, nRefId, vtNorm) ;
}

//----------------------------------------------------------------------------
bool
ExeCurveCompoGetTempProp( int nId, INTVECTOR& vProp, int nPropInd) 
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva composita
   const ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
   if ( pCompo == nullptr)
      return false ;
  // recupero i valori
   vProp.clear() ;
   vProp.reserve( pCompo->GetCurveCount()) ;
   const ICurve* pSmplCrv = pCompo->GetFirstCurve() ;
   while ( pSmplCrv != nullptr) {
      vProp.push_back( pSmplCrv->GetTempProp( nPropInd)) ;
      pSmplCrv = pCompo->GetNextCurve() ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
ExeCurveCompoGetTempParam( int nId, DBLVECTOR& vParam, int nParamInd) 
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva composita
   const ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
   if ( pCompo == nullptr)
      return false ;
  // recupero i valori
   vParam.clear() ;
   vParam.reserve( pCompo->GetCurveCount()) ;
   const ICurve* pSmplCrv = pCompo->GetFirstCurve() ;
   while ( pSmplCrv != nullptr) {
      vParam.push_back( pSmplCrv->GetTempParam( nParamInd)) ;
      pSmplCrv = pCompo->GetNextCurve() ;
   }
   return true ;
}

//----------------------------------------------------------------------------
int
ExeShowCurveBezierControlPoints( int nCrvId, int nDestGrpId, int* pnCount)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva di Bezier
   IGeoObj* pGeoObj = pGeomDB->GetGeoObj( nCrvId) ;
   if ( pGeoObj->GetType() != CRV_BEZIER  &&  pGeoObj->GetType() != CRV_COMPO)
      return GDB_ID_NULL ;
  // recupero il riferimento della curva
   Frame3d frCrv ;
   bool bOk = true ;
   bOk = bOk && pGeomDB->GetGlobFrame( nCrvId, frCrv) ;
  // recupero il riferimento di destinazione
   Frame3d frDest ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
   if ( ! bOk)
      return GDB_ID_NULL ;
   int nType = pGeoObj->GetType() ;
   if ( nType == CRV_COMPO) {
      const ICurveComposite* pCrvCompo = GetCurveComposite( pGeoObj) ;
      if ( pCrvCompo == nullptr)
         return false ;
      int nFirstId = -1 ;
      int nCount = 0 ;
      for ( int i = 0 ; i < pCrvCompo->GetCurveCount() ; ++i) {
         const ICurveBezier* pCrvBezier = GetCurveBezier( pCrvCompo->GetCurve(i)) ;
         if ( pCrvBezier == nullptr) {
            if ( pnCount != nullptr)
               *pnCount = nCount ;
            return nFirstId ;
         }
         int nDeg = pCrvBezier->GetDegree() ;
         //bool bRat = pCrvBezier->IsRational() ;
         for ( int i = 0 ; i < nDeg + 1 ; ++i) {
            IGeoPoint3d* pGeoPt( CreateGeoPoint3d()) ;
            //if ( ! bRat)
            //   pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ;
            //else
            //   pGeoPt->Set( pCrvBezier->GetControlPoint( i) * pCrvBezier->GetControlWeight( i)) ;
            pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ;
            pGeoPt->LocToLoc( frCrv, frDest) ;
            int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pGeoPt) ;
            if ( nFirstId == GDB_ID_NULL)
               nFirstId = nId ;
            if ( nId != GDB_ID_NULL)
               ++nCount ;
         }
      }
     // restituisco i risultati
      if ( pnCount != nullptr)
         *pnCount = nCount ;
      return nFirstId ;
   }
   else if ( nType == CRV_BEZIER) {
      const ICurveBezier* pCrvBezier = GetCurveBezier( pGeoObj) ;
      if ( pCrvBezier == nullptr)
         return false ;
      int nDeg = pCrvBezier->GetDegree() ;
      //bool bRat = pCrvBezier->IsRational() ;
      int nFirstId = -1 ;
      int nCount = 0 ;
      for ( int i = 0 ; i < nDeg + 1 ; ++i) {
         IGeoPoint3d* pGeoPt( CreateGeoPoint3d()) ;
         //if ( ! bRat)
         //   pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ;
         //else
         //   pGeoPt->Set( pCrvBezier->GetControlPoint( i) * pCrvBezier->GetControlWeight( i)) ;
         pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ;
         pGeoPt->LocToLoc( frCrv, frDest) ;
         int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pGeoPt) ;
         if ( nFirstId == GDB_ID_NULL)
            nFirstId = nId ;
         if ( nId != GDB_ID_NULL)
            ++nCount ;
      }
     // restituisco i risultati
      if ( pnCount != nullptr)
         *pnCount = nCount ;
      return nFirstId ;
   }
   else
      return GDB_ID_NULL ;
}

//----------------------------------------------------------------------------
bool
ExeCurveMaxOffset( int nId, double& dMaxOffset)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // verifico il parametro
   if ( &dMaxOffset == nullptr)
      return false ;
  // recupero la curva
   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
   if ( pCrv == nullptr)
      return false ;
   return CalcCurveLimitOffset( *pCrv, dMaxOffset) ;
}

//----------------------------------------------------------------------------
int
ExeCopyCompoSubCurve( int nCrvId, int nSubCrvToCopy, int nDestGrpId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva compo
   const ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nCrvId)) ;
   if ( pCompo == nullptr)
      return GDB_ID_NULL ;
  // recupero il riferimento della curva
   Frame3d frCrv ;
   bool bOk = true ;
   bOk = bOk && pGeomDB->GetGlobFrame( nCrvId, frCrv) ;
  // recupero il riferimento di destinazione
   Frame3d frDest ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
   if ( ! bOk)
      return GDB_ID_NULL ;

  // creo una copia e la porto nel frame della destinazione
   const ICurve* pSubCrv = pCompo->GetCurve( nSubCrvToCopy) ;
   if ( pSubCrv == nullptr)
      return GDB_ID_NULL ;
   ICurve* pSubCrvCopy = pSubCrv->Clone() ;
   if ( pSubCrvCopy == nullptr)
      return GDB_ID_NULL ;
   pSubCrvCopy->LocToLoc( frCrv, frDest) ;
   int nSubCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pSubCrvCopy) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtCopyCompoSubCurve(" + IdToString( nCrvId) + "," +
                                              ToString( nSubCrvToCopy) + "," +
                                              IdToString( nDestGrpId) + ")" +
                    " -- Id=" + ToString( nSubCrvId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entità
   return nSubCrvId ;
}

//----------------------------------------------------------------------------
int
ExeCopyParamRange( int nCrvId, double dUStart, double dUEnd, int nDestGrpId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la curva
   const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
  // recupero il riferimento della curva
   Frame3d frCrv ;
   bool bOk = true ;
   bOk = bOk && pGeomDB->GetGlobFrame( nCrvId, frCrv) ;
  // recupero il riferimento di destinazione
   Frame3d frDest ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
   if ( ! bOk)
      return GDB_ID_NULL ;

  // creo una copia e la porto nel frame della destinazione
   ICurve* pSubCrvCopy = pCrv->CopyParamRange( dUStart, dUEnd) ;
   if ( pSubCrvCopy == nullptr)
      return GDB_ID_NULL ;
   pSubCrvCopy->LocToLoc( frCrv, frDest) ;
   int nSubCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pSubCrvCopy) ;
   ExeSetModified() ;

   return nSubCrvId ;
}