//----------------------------------------------------------------------------
//  EgalTech 2014-2015
//----------------------------------------------------------------------------
// File : EXE_GdbCreate.cpp       Data : 04.05.15        Versione : 1.6e1
// Contenuto : Funzioni di creazione oggetti del DB geometrico per EXE.
//
//
//
// Modifiche : 30.09.14 DS Creazione modulo.
//             07.01.15 DS Agg. scrittura comandi Lua.
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "EXE.h"
#include "EXE_Macro.h"
#include "AuxTools.h"
#include "GeoTools.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkGeoVector3d.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EGkExtDimension.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EgtStringConverter.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EGkIntersCurves.h"
#include "/EgtDev/Include/EGkCurveLine.h"
#include "/EgtDev/Include/EGkCurveArc.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGkCurveComposite.h"

using namespace std ;

//-------------------------------------------------------------------------------
int
ExeCreateGroup( int nParentId, const Frame3d& frFrame, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
      nParentId = AdjustId( nParentId) ;
   bool bOk = true ;
 // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc ) ;
  // porto in locale l'origine e i versori
   Point3d ptOrigL = GetPointLocal( pGeomDB, frFrame.Orig(), nRefType, frLoc) ;
   Vector3d vtXL = GetVectorLocal( pGeomDB, frFrame.VersX(), nRefType, frLoc) ;
   Vector3d vtYL = GetVectorLocal( pGeomDB, frFrame.VersY(), nRefType, frLoc) ;
   Vector3d vtZL = GetVectorLocal( pGeomDB, frFrame.VersZ(), nRefType, frLoc) ;
  // costruisco il riferimento
   Frame3d frFrameL ;
   bOk = bOk && frFrameL.Set( ptOrigL, vtXL, vtYL, vtZL) ;
  // creo il gruppo
   int nId = ( bOk ? pGeomDB->AddGroup( GDB_ID_NULL, nParentId, frFrameL) : GDB_ID_NULL) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua ;
      if ( AreSameFrame( frFrame, GLOB_FRM)) {
         if ( nRefType == RTY_LOC)
            sLua = "EgtGroup(" + IdToString( nParentId) + ")" +
                   " -- Id=" + ToString( nId) ;
         else
            sLua = "EgtGroup(" + IdToString( nParentId) + "," +
                                 RefTypeToString( nRefType) + ")" +
                   " -- Id=" + ToString( nId) ;
      }
      else
         sLua = "EgtGroup(" + IdToString( nParentId) + ",{{" +
                              ToString( frFrame.Orig()) + "},{" +
                              ToString( frFrame.VersX()) + "},{" +
                              ToString( frFrame.VersY()) + "},{" +
                              ToString( frFrame.VersZ()) + "}}," +
                              RefTypeToString( nRefType) + ")" +
                " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   // restituisco l'identificativo del nuovo gruppo
   return nId ;
}

//-------------------------------------------------------------------------------
int
ExeCreateGeoPoint( int nParentId, const Point3d& ptP, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
      nParentId = AdjustId( nParentId) ;
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // porto in locale il punto
   Point3d ptPL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ;
  // creo il punto
   PtrOwner<IGeoPoint3d> pGeoPnt( CreateGeoPoint3d()) ;
   bOk = bOk && !IsNull( pGeoPnt) ;
  // setto il punto
   bOk = bOk && pGeoPnt->Set( ptPL) ;
  // inserisco il punto nel DB
   int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pGeoPnt)) : GDB_ID_NULL) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtPoint(" + IdToString( nParentId) + ",{" +
                                  ToString( ptP) + "}," +
                                  RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entit�
   return nId ;
}

//-------------------------------------------------------------------------------
int
ExeCreateGeoVector( int nParentId, const Vector3d& vtV, const Point3d& ptB, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
      nParentId = AdjustId( nParentId) ;
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // porto in locale il vettore e il punto
   Vector3d vtVL = GetVectorLocal( pGeomDB, vtV, nRefType, frLoc) ;
   Point3d ptBL = GetPointLocal( pGeomDB, ptB, nRefType, frLoc) ;
  // creo il vettore
   PtrOwner<IGeoVector3d> pGeoVct( CreateGeoVector3d()) ;
   bOk = bOk && ! IsNull( pGeoVct) ;
  // setto il vettore (con il punto base)
   bOk = bOk && pGeoVct->Set( vtVL, ptBL) ;
  // inserisco il vettore nel DB
   int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pGeoVct)) : GDB_ID_NULL) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua ;
      if ( ptB.IsSmall())
         sLua = "EgtVector(" + IdToString( nParentId) + ",{" +
                               ToString( vtV) + "}," +
                               RefTypeToString( nRefType) + ")" +
                " -- Id=" + ToString( nId) ;
      else
         sLua = "EgtVector(" + IdToString( nParentId) + ",{" +
                               ToString( vtV) + "},{" +
                               ToString( ptB) + "}," +
                               RefTypeToString( nRefType) + ")" +
                " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo della nuova entit�
   return nId ;
}

//-------------------------------------------------------------------------------
int
ExeCreateGeoFrame( int nParentId, const Frame3d& frFrame, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
      nParentId = AdjustId( nParentId) ;
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc ) ;
  // porto in locale l'origine e i versori
   Point3d ptOrigL = GetPointLocal( pGeomDB, frFrame.Orig(), nRefType, frLoc) ;
   Vector3d vtXL = GetVectorLocal( pGeomDB, frFrame.VersX(), nRefType, frLoc) ;
   Vector3d vtYL = GetVectorLocal( pGeomDB, frFrame.VersY(), nRefType, frLoc) ;
   Vector3d vtZL = GetVectorLocal( pGeomDB, frFrame.VersZ(), nRefType, frLoc) ;
  // creo e setto il riferimento
   PtrOwner<IGeoFrame3d> pGeoFrm( CreateGeoFrame3d()) ;
   bOk = bOk && !IsNull( pGeoFrm) ;
   bOk = bOk && pGeoFrm->Set( ptOrigL, vtXL, vtYL, vtZL) ;
  // inserisco il riferimento nel DB
   int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pGeoFrm)) : GDB_ID_NULL) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtFrame(" + IdToString( nParentId) + ",{{" +
                                  ToString( frFrame.Orig()) + "},{" +
                                  ToString( frFrame.VersX()) + "},{" +
                                  ToString( frFrame.VersY()) + "},{" +
                                  ToString( frFrame.VersZ()) + "}}," +
                                  RefTypeToString( nRefType) + ")" +
                     " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo del nuovo gruppo
   return nId ;
}

//-------------------------------------------------------------------------------
int
ExeCreateText( int nParentId, const Point3d& ptP,
               const string& sText, double dH, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
      nParentId = AdjustId( nParentId) ;
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // porto in locale l'origine e i versori
   Point3d ptPL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ;
   Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
   Vector3d vtDL = GetVectorLocal( pGeomDB, X_AX, nRefType, frLoc) ;
  // creo il testo e lo riempio
   PtrOwner<IExtText> pTXT( CreateExtText()) ;
   bOk = bOk && !IsNull( pTXT) ;
   bOk = bOk && pTXT->Set( ptPL, vtNL, vtDL, sText, "", false, dH) ;
  // inserisco il testo nel DB
   int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTXT)) : GDB_ID_NULL) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtText(" + IdToString( nParentId) + ",{" +
                                 ToString( ptP) + "},'" +
                                 StringToLuaString( sText) + "'," +
                                 ToString( dH) + "," +
                                 RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo del oggetto
   return nId ;
}

//-------------------------------------------------------------------------------
int
ExeCreateTextEx( int nParentId, const Point3d& ptP, double dAngRotDeg,
                 const string& sText, const string& sFont, bool bItalic, double dH, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
      nParentId = AdjustId( nParentId) ;
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // porto in locale l'origine e i versori
   Point3d ptPL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ;
   Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
   Vector3d vtDL = GetVectorLocal( pGeomDB, FromPolar( 1, dAngRotDeg), nRefType, frLoc) ;
  // creo il testo e lo riempio
   PtrOwner<IExtText> pTXT( CreateExtText()) ;
   bOk = bOk && !IsNull( pTXT) ;
   bOk = bOk && pTXT->Set( ptPL, vtNL, vtDL, sText, sFont, bItalic, dH) ;
  // inserisco il testo nel DB
   int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTXT)) : GDB_ID_NULL) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtTextEx(" + IdToString( nParentId) + ",{" +
                                   ToString( ptP) + "}," +
                                   ToString( dAngRotDeg) + ",'" +
                                   StringToLuaString( sText) + "','" +
                                   StringToLuaString( sFont) + "'," +
                                   ( bItalic ? "'I'" : "'S'") + "," +
                                   ToString( dH) + "," +
                                   RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   // restituisco l'identificativo del oggetto
   return nId ;
}

//-------------------------------------------------------------------------------
int
ExeCreateTextAdv( int nParentId, const Point3d& ptP, double dAngRotDeg,
                  const string& sText, const string& sFont,
                  int nW, bool bItalic, double dH, double dRat, double dAddAdv, int nInsPos, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
      nParentId = AdjustId( nParentId) ;
   bool bOk = true ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
  // porto in locale l'origine e i versori
   Point3d ptPL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ;
   Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
   Vector3d vtDL = GetVectorLocal( pGeomDB, FromPolar( 1, dAngRotDeg), nRefType, frLoc) ;
  // creo il testo e lo imposto
   PtrOwner<IExtText> pTXT( CreateExtText()) ;
   bOk = bOk && !IsNull( pTXT) ;
   bOk = bOk && pTXT->Set( ptPL, vtNL, vtDL, sText, sFont, nW, bItalic, dH, dRat, dAddAdv, nInsPos) ;
  // inserisco il testo nel DB
   int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTXT)) : GDB_ID_NULL) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtTextAdv(" + IdToString( nParentId) + ",{" +
                                    ToString( ptP) + "}," +
                                    ToString( dAngRotDeg) + ",'" +
                                    StringToLuaString( sText) + "','" +
                                    StringToLuaString( sFont) + "'," +
                                    ToString( nW) + "," +
                                    ( bItalic ? "'I'" : "'S'") + "," +
                                    ToString( dH) + "," +
                                    ToString( dRat) + "," +
                                    ToString( dAddAdv) + "," +
                                    ETxtInsPosToString( nInsPos) + "," +
                                    RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo del oggetto
   return nId ;
}

//-------------------------------------------------------------------------------
bool
ExeSetCurrDimensionStyle( double dExtLineLen, double dArrowLen, double dTextDist,
   int nLenIsMM, int nDecDigit, const string& sFont, double dTextHeight)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX( pGseCtx, false)
     // aggiorno lo stile di quotatura corrente
      pGseCtx->m_dsCurr.Set( dExtLineLen, dArrowLen, dTextDist, nLenIsMM, nDecDigit, sFont, dTextHeight) ;
   return true ;
}

//-------------------------------------------------------------------------------
bool
ExeResetCurrDimensionStyle( void)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX( pGseCtx, false)
     // aggiorno lo stile di quotatura corrente
      pGseCtx->m_dsCurr.Reset() ;
   return true ;
}

//-------------------------------------------------------------------------------
static bool
MySetDimensionStyle( IExtDimension* pDim)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX( pGseCtx, false)
     // verifico validit� quotatura
      if ( pDim == nullptr)
         return false ;
  // recupero lo stile di quotatura
   const DimensionStyle& DimSt = pGseCtx->m_dsCurr ;
  // recupero l'unit� di misura lineare per la quotatura
   bool bLenIsMM = ( DimSt.nLenIsMM == 2 ? ExeUiUnitsAreMM() : ( DimSt.nLenIsMM != 0 )) ;
  // imposto lo stile
   return pDim->SetStyle( DimSt.dExtLineLen, DimSt.dArrowLen, DimSt.dTextDist,
      bLenIsMM, DimSt.nDecDigit, DimSt.sFont, DimSt.dTextHeight) ;
}

//-------------------------------------------------------------------------------
static int
MyCreateLinearDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP2,
                         const Point3d& ptDim, const Vector3d& vtDir, const string& sText, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
      nParentId = AdjustId( nParentId) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc ))
      return GDB_ID_NULL ;
  // porto in locale i punti e assegno i versori
   Point3d ptP1L = GetPointLocal( pGeomDB, ptP1, nRefType, frLoc) ;
   Point3d ptP2L = GetPointLocal( pGeomDB, ptP2, nRefType, frLoc) ;
   Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
   Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
   Vector3d vtDL = GetVectorLocal( pGeomDB, vtDir, nRefType, frLoc) ;
  // creo la quota
   PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
   if ( IsNull( pDim )  ||
        ! MySetDimensionStyle( pDim )  ||
        ! pDim->SetLinear( ptP1L, ptP2L, ptDimL, vtNL, vtDL, sText ))
      return GDB_ID_NULL ;
  // inserisco la quota nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
}

//-------------------------------------------------------------------------------
int
ExeCreateHorizontalDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP2,
                              const Point3d& ptDim, const string& sText, int nRefType)
{
  // eseguo
   int nId = MyCreateLinearDimension( nParentId, ptP1, ptP2, ptDim, X_AX, sText, nRefType) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtHorizontalDimension(" + IdToString( nParentId) + ",{" +
                                                ToString( ptP1) + "},{" +
                                                ToString( ptP2) + "},{" +
                                                ToString( ptDim) + "},'" +
                                                StringToLuaString( sText) + "'," +
                                                RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo del oggetto
   return nId ;
}

//-------------------------------------------------------------------------------
int
ExeCreateVerticalDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP2,
                            const Point3d& ptDim, const string& sText, int nRefType)
{
  // eseguo
   int nId = MyCreateLinearDimension( nParentId, ptP1, ptP2, ptDim, Y_AX, sText, nRefType) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVerticalDimension(" + IdToString( nParentId ) + ",{" +
                                              ToString( ptP1) + "},{" +
                                              ToString( ptP2) + "},{" +
                                              ToString( ptDim) + "},'" +
                                              StringToLuaString( sText) + "'," +
                                              RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo del oggetto
   return nId ;
}

//-------------------------------------------------------------------------------
int
ExeCreateAlignedDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP2,
                           const Point3d& ptDim, const string& sText, int nRefType)
{
  // eseguo
   int nId = MyCreateLinearDimension( nParentId, ptP1, ptP2, ptDim, V_NULL, sText, nRefType) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtAlignedDimension(" + IdToString( nParentId) + ",{" +
                                             ToString( ptP1) + "},{" +
                                             ToString( ptP2) + "},{" +
                                             ToString( ptDim) + "},'" +
                                             StringToLuaString( sText) + "'," +
                                             RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo del oggetto
   return nId ;
}

//-------------------------------------------------------------------------------
static int
MyCreateRadialDimension( int nParentId, int nCrvId, const Point3d& ptDim,
                         const string& sText, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   nParentId = AdjustId( nParentId) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
      return GDB_ID_NULL ;
  // recupero l'arco di circonferenza e il suo frame
   ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nCrvId)) ;
   if ( pArc == nullptr)
      return GDB_ID_NULL ;
   Frame3d frArc ;
   if ( ! pGeomDB->GetGlobFrame( nCrvId, frArc))
      return GDB_ID_NULL ;
  // porto il punto nel riferimento locale
   Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
  // recupero il centro e la normale e li porto nel riferimento locale
   Point3d ptCenL = pArc->GetCenter() ;
   ptCenL.LocToLoc( frArc, frLoc) ;
   Vector3d vtNL = pArc->GetNormVersor() ;
   vtNL.LocToLoc( frArc, frLoc) ;
  // porto ptDimL sulla circonferenza cui appartiene l'arco
   Vector3d vtDir = ptDimL - ptCenL ;
   if ( ! vtDir.Normalize())
      return GDB_ID_NULL ;
   ptDimL = ptCenL + pArc->GetRadius() * vtDir ;
  // creo la quota
   PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
   if ( IsNull( pDim)  ||
        ! MySetDimensionStyle( pDim)  ||
        ! pDim->SetRadial( ptCenL, ptDimL, vtNL, sText))
      return GDB_ID_NULL ;
  // inserisco la quota nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
}

//-------------------------------------------------------------------------------
int
ExeCreateRadialDimension( int nParentId, int nCrvId, const Point3d& ptDim,
                          const string& sText, int nRefType)
{
  // eseguo
   int nId = MyCreateRadialDimension( nParentId, nCrvId, ptDim, sText, nRefType) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtRadialDimension(" + IdToString( nParentId) + "," +
                                            IdToString( nCrvId) + ",{" +
                                            ToString( ptDim) + "},'" +
                                            StringToLuaString( sText) + "'," +
                                            RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo del oggetto
   return nId ;
}

//-------------------------------------------------------------------------------
static int
MyCreateDiametralDimension( int nParentId, int nCrvId, const Point3d& ptDim,
                            const string& sText, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   nParentId = AdjustId( nParentId) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
      return GDB_ID_NULL ;
  // recupero l'arco e il suo frame
   ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nCrvId)) ;
   if ( pArc == nullptr)
      return GDB_ID_NULL ;
   Frame3d frArc ;
   if ( ! pGeomDB->GetGlobFrame( nCrvId, frArc))
      return GDB_ID_NULL ;
  // porto il punto nel riferimento locale
   Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
  // recupero il centro e la normale e li porto nel riferimento locale
   Point3d ptCenL = pArc->GetCenter() ;
   ptCenL.LocToLoc( frArc, frLoc) ;
   Vector3d vtNL = pArc->GetNormVersor() ;
   vtNL.LocToLoc( frArc, frLoc) ;
  // porto ptDimL sulla circonferenza
   Vector3d vtDir = ptDimL - ptCenL ;
   if ( ! vtDir.Normalize())
      return GDB_ID_NULL ;
   ptDimL = ptCenL + pArc->GetRadius() * vtDir ;
  // creo la quota
   PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
   if ( IsNull( pDim)  ||
        ! MySetDimensionStyle( pDim)  ||
        ! pDim->SetDiametral( ptCenL, ptDimL, vtNL, sText))
      return GDB_ID_NULL ;
  // inserisco la quota nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
}

//-------------------------------------------------------------------------------
int
ExeCreateDiametralDimension( int nParentId, int nCrvId, const Point3d& ptDim,
                             const string& sText, int nRefType)
{
  // eseguo
   int nId = MyCreateDiametralDimension( nParentId, nCrvId, ptDim, sText, nRefType) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtDiametralDimension(" + IdToString( nParentId) + "," +
                                               IdToString( nCrvId) + ",{" +
                                               ToString( ptDim) + "},'" +
                                               StringToLuaString( sText) + "'," +
                                               RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo del oggetto
   return nId ;
}

//-------------------------------------------------------------------------------
static int
MyCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptV, const Point3d& ptP2,
                          const Point3d& ptDim, const string& sText, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
      nParentId = AdjustId( nParentId) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
      return GDB_ID_NULL ;
  // porto in locale i punti e assegno i versori
   Point3d ptVL = GetPointLocal( pGeomDB, ptV, nRefType, frLoc) ;
   Point3d ptP1L = GetPointLocal( pGeomDB, ptP1, nRefType, frLoc) ;
   Point3d ptP2L = GetPointLocal( pGeomDB, ptP2, nRefType, frLoc) ;
   Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
   Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
  // creo la quota
   PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
   if ( IsNull( pDim)  ||
        ! MySetDimensionStyle( pDim )  ||
        ! pDim->SetAngular( ptP1L, ptVL, ptP2L, ptDimL, vtNL, sText))
      return GDB_ID_NULL ;
  // inserisco la quota nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
}

//-------------------------------------------------------------------------------
int
ExeCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptV, const Point3d& ptP2,
                           const Point3d& ptDim, const string& sText, int nRefType)
{
  // eseguo
   int nId = MyCreateAngularDimension( nParentId, ptP1, ptV, ptP2, ptDim, sText, nRefType) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtAngularDimension(" + IdToString( nParentId) + ",{" +
                                             ToString( ptV) + "},{" +
                                             ToString( ptP1) + "},{" +
                                             ToString( ptP2) + "},{" +
                                             ToString( ptDim) + "},'" +
                                             StringToLuaString( sText) + "'," +
                                             RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo del oggetto
   return nId ;
}

//-------------------------------------------------------------------------------
static int
MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Point3d& ptDim,
                                   const string& sText, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
      nParentId = AdjustId( nParentId) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
      return GDB_ID_NULL ;
  // recupero le linee
   ICurveLine* pCrv1 = GetCurveLine( pGeomDB->GetGeoObj( vLineIds[0])) ;
   ICurveLine* pCrv2 = GetCurveLine( pGeomDB->GetGeoObj( vLineIds[1])) ;
   if ( pCrv1 == nullptr  ||  pCrv2 == nullptr)
      return GDB_ID_NULL ;
   PtrOwner<ICurveLine> pL1( pCrv1->Clone()) ;
   PtrOwner<ICurveLine> pL2( pCrv2->Clone()) ;
   if ( IsNull( pL1 )  ||  ! pL1->IsValid()  ||  IsNull( pL2)  ||  ! pL2->IsValid())
      return GDB_ID_NULL ;
  // porto tutto nel frLoc
   Frame3d frL1, frL2 ;
   if ( ! pGeomDB->GetGlobFrame( vLineIds[0], frL1)  ||  ! pGeomDB->GetGlobFrame( vLineIds[1], frL2))
      return GDB_ID_NULL ;
   pL1->LocToLoc( frL1, frLoc) ;
   pL2->LocToLoc( frL2, frLoc) ;
  // recupero il punto lo porto nel riferimento locale
   Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
  // recupero i punti e le direzioni
   Point3d ptP1L, ptP2L, ptP3L, ptP4L ;
   Vector3d vtL1, vtL2 ;
   pL1->GetStartPoint( ptP1L) ;
   pL1->GetEndPoint( ptP2L) ;
   pL2->GetStartPoint( ptP3L) ;
   pL2->GetEndPoint( ptP4L) ;
   pL1->GetStartDir( vtL1) ;
   pL2->GetStartDir( vtL2) ;
  // controllo se le rette sono coincidenti o parallele
   if ( AreSameOrOppositeVectorApprox( vtL1, vtL2))
      return GDB_ID_NULL ;
  // verifico se le rette si intersecano già
   Point3d ptCenL ;
   IntersCurveCurve pInters( *pL1, *pL2) ;
   int nNumeroInters = pInters.GetIntersCount() ;
  // se non ho intersezioni estendo
   if ( nNumeroInters == 0) {
      double dLen = pow( 10, 5) ;
      pL1->ExtendStartByLen( dLen) ;
      pL2->ExtendStartByLen( dLen) ;
      pL1->ExtendEndByLen( dLen) ;
      pL2->ExtendEndByLen( dLen) ;
     // faccio intersezione
      IntersCurveCurve pIntersExt( *pL1, *pL2) ;
      nNumeroInters = pIntersExt.GetIntersCount() ;
     // le linee estese non si intersecano, quindi vuol dire che sono quasi parallele e lontanissime
      if ( nNumeroInters == 0 )
         return GDB_ID_NULL ;
      else {
         IntCrvCrvInfo Info ;
         pIntersExt.GetIntCrvCrvInfo( 0, Info) ;
        // controllo che non siano coincidenti
         if ( Info.bOverlap)
            return false ;
         else
            ptCenL = Info.IciA->ptI ;
      }
     // seleziono i punti necessari
     // se ptDimL è più vicino a ptCenL rispetto agli estremi esterni delle linee, allora tengo gli estremi interni
      double dP1Cen = ( ptP1L - ptCenL).Len() ;
      double dP2Cen = ( ptP2L - ptCenL).Len() ;
      double dDimCen = ( ptDimL - ptCenL).Len() ;
      if ( ( dDimCen < dP1Cen  ||  dDimCen < dP2Cen))
        // se uno dei due punti è più vicino a ptCenL rispetto a ptDimL, allora tengo il punto più vicino a ptDimL
         ptP1L = ( ( ptDimL - ptP1L ).Len() < ( ptDimL - ptP2L ).Len() ? ptP1L : ptP2L) ;
      else
         ptP1L = ( dP1Cen < dP2Cen ? ptP2L : ptP1L ) ;
     // rifaccio anche per l'altro lato
      double dP3Cen = ( ptP3L - ptCenL).Len() ;
      double dP4Cen = ( ptP4L - ptCenL).Len() ;
      if ( dDimCen < dP3Cen  ||  dDimCen < dP4Cen)
         ptP3L = ( ( ptDimL - ptP3L).Len() < ( ptDimL - ptP4L).Len() ? ptP3L : ptP4L) ;
      else
         ptP3L = ( dP3Cen < dP4Cen ? ptP4L : ptP3L) ;
   }
  // se ho già intesezioni devo capire in quale quadrante si trova ptDim
   else {
     // recupero l'intersezione
      IntCrvCrvInfo Info ;
      pInters.GetIntCrvCrvInfo( 0, Info) ;
     // controllo che non siano coincidenti
      if ( Info.bOverlap)
         return false ;
     // se non coincidono restituisco l'intersezione
      else
         ptCenL = Info.IciA->ptI ;
     // se le due linee hanno un estremo in comune, estendo le linee da quel lato
      if ( ( AreSamePointApprox( ptCenL, ptP1L)  ||  AreSamePointApprox( ptCenL, ptP2L))  &&  
         ( AreSamePointApprox( ptCenL, ptP3L)  ||  AreSamePointApprox( ptCenL, ptP4L))) {
         if ( AreSamePointApprox( ptCenL, ptP1L)) {
            pL1->ExtendStartByLen(Dist( ptP1L, ptP2L) / 2) ;
            pL1->GetStartPoint( ptP1L) ;
         }
         else {
            pL1->ExtendEndByLen(Dist( ptP1L, ptP2L) / 2) ;
            pL1->GetEndPoint( ptP2L) ;
         }
         if ( AreSamePointApprox( ptCenL, ptP3L)) {
            pL2->ExtendStartByLen( Dist( ptP3L, ptP4L) / 2);
            pL2->GetStartPoint( ptP3L) ;
         }
         else {
            pL2->ExtendEndByLen(Dist( ptP3L, ptP4L) / 2);
            pL2->GetEndPoint( ptP4L) ;
         }
      }
     // seleziono i punti necessari
     // proietto pdDim su vtLine1 e su vtLine2
      Point3d ptDim1, ptDim2 ;
      DistPointCurve distPL1( ptDimL, *pL1, true) ;
      DistPointCurve distPL2( ptDimL, *pL2, true) ;
      int nFlag1, nFlag2 ;
      if ( ! distPL1.GetMinDistPoint( 0, ptDim1, nFlag1)  ||  ! distPL2.GetMinDistPoint( 0, ptDim2, nFlag2) )
         return false ;
      if ( abs(( ptDim1 - ptP1L).Len() + ( ptCenL - ptDim1).Len() - ( ptCenL - ptP1L).Len()) < EPS_SMALL  ||
           abs(( ptDim1 - ptP1L).Len() + ( ptCenL - ptP1L ).Len() - ( ptDim1 - ptCenL).Len()) < EPS_SMALL)
           // ptDim è dal lato di ptP1L, quindi tengo ptP1L
         ;
      else
        // ptDim è dal lato di ptP2L
         ptP1L = ptP2L ;
      if ( abs(( ptDim2 - ptP3L).Len() + ( ptCenL - ptDim2).Len() - ( ptCenL - ptP3L).Len()) < EPS_SMALL  ||
           abs(( ptDim2 - ptP3L).Len() + ( ptCenL - ptP3L).Len() - ( ptDim2 - ptCenL).Len()) < EPS_SMALL)
        // ptDim è dal lato di ptP1L
        ;
      else
        // ptDim è dal lato di ptP2L
         ptP3L = ptP4L ;
   }
  // recupero la normale al piano dell'angolo da quotare
   Frame3d frArc;
   frArc.Set(ptCenL, ptP1L, ptP3L);
   Vector3d vtNL = frArc.VersZ() ;
   if ( vtNL * Z_AX < - EPS_SMALL) {
      frArc.Set(ptCenL, ptP3L, ptP1L);
      vtNL = frArc.VersZ() ;
   }
  // creo la quota
   PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
   if ( IsNull( pDim )  ||
        ! MySetDimensionStyle( pDim )  ||
        ! pDim->SetAngular( ptP1L, ptCenL, ptP3L, ptDimL, vtNL, sText))
      return GDB_ID_NULL ;
  // inserisco la quota nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
}

//-------------------------------------------------------------------------------
int
ExeCreateAngularDimensionFromLines( int nParentId, const INTVECTOR vLineIds, const Point3d& ptDim,
                                    const string& sText, int nRefType)
{
  // eseguo
   int nId = MyCreateAngularDimensionFromLines( nParentId, vLineIds, ptDim, sText, nRefType) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtAngularDimensionFromLines(" + IdToString( nParentId) + "," +
                                                      ToString( vLineIds[0]) + "," +
                                                      ToString( vLineIds[1]) + ",{" +
                                                      ToString( ptDim) + "},'" +
                                                      StringToLuaString( sText) + "'," +
                                                      RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   // restituisco l'identificativo del oggetto
   return nId ;
}

//-------------------------------------------------------------------------------
static int
MyCreateAngularDimensionFromArc( int nParentId, int nCrvId, const Point3d& ptDim,
                                 const string& sText, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   nParentId = AdjustId( nParentId) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
      return GDB_ID_NULL ;
  // recupero l'arco e il suo frame
   ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nCrvId)) ;
   if ( pArc == nullptr)
      return GDB_ID_NULL ;
   Frame3d frArc ;
   if ( ! pGeomDB->GetGlobFrame( nCrvId, frArc))
      return GDB_ID_NULL ;
  // recupero i punti e la normale e li porto nel frame locale
   Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
   Vector3d vtNL = pArc->GetNormVersor() ;
   vtNL.LocToLoc( frArc, frLoc) ;
   Point3d ptCenL, ptP1L, ptP2L ;
   pArc->GetStartPoint( ptP1L) ;
   ptP1L.LocToLoc( frArc, frLoc) ;
   pArc->GetEndPoint( ptP2L) ;
   ptP2L.LocToLoc( frArc, frLoc) ;
   pArc->GetCenterPoint( ptCenL) ;
   ptCenL.LocToLoc( frArc, frLoc) ;
  // porto ptDimL nell'area di influenza dell'arco
   Point3d ptMid ;
   pArc->GetMidPoint( ptMid) ;
   Vector3d vtDir = ( ptMid - ptCenL) ;
   if ( ! vtDir.Normalize())
      return GDB_ID_NULL ;
   ptDimL = ptCenL + Dist( ptDimL, ptCenL) * vtDir ;
  // creo la quota
   PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
   if ( IsNull( pDim )  ||
        ! MySetDimensionStyle( pDim)  ||
        ! pDim->SetAngular( ptP1L, ptCenL, ptP2L, ptDimL, vtNL, sText))
      return GDB_ID_NULL ;
  // inserisco la quota nel DB
   return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
}

//-------------------------------------------------------------------------------
int
ExeCreateAngularDimensionFromArc( int nParentId, int nCrvId, const Point3d& ptDim,
                                  const string& sText, int nRefType)
{
  // eseguo
   int nId = MyCreateAngularDimensionFromArc( nParentId, nCrvId, ptDim, sText, nRefType) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtAngularDimensionFromArc(" + IdToString( nParentId) + "," +
                                                    IdToString( nCrvId) + ",{" +
                                                    ToString( ptDim) + "},'" +
                                                    StringToLuaString( sText) + "'," +
                                                    RefTypeToString( nRefType) + ")" +
                    " -- Id=" + ToString( nId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco l'identificativo del oggetto
   return nId ;
}