//----------------------------------------------------------------------------
//  EgalTech 2015-2016
//----------------------------------------------------------------------------
// File : EXE_ModifyVol.cpp        Data : 27.10.16        Versione : 1.6v7
// Contenuto : Funzioni di modifica dei solidi per EXE.
//
//
//
// Modifiche : 27.10.16 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- 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/EGkVolZmap.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"

using namespace std ;

//-------------------------------------------------------------------------------
static int
MyExplodeVolZmap( int nId, int* pnCount)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il solido VolZmap
   const IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
   if ( pVZM == nullptr)
      return GDB_ID_NULL ;
  // recupero il numero di parti connesse
   int nPart = pVZM->GetPartCount() ;
  // se c'è una sola parte o non definibile, non devo fare alcunché
   if ( nPart == 1  ||  nPart == - 1) {
      if ( pnCount != nullptr)
         *pnCount = 1 ;
      return nId ;
   }
  // copio tutti i componenti connessi (parti)
   int nFirstId = GDB_ID_NULL ;
   int nCount = 0 ;
   for ( int i = 0 ; i < nPart ; ++ i) {
      IVolZmap* pPrt = pVZM->ClonePart( i) ;
      if ( pPrt == nullptr)
         continue ;
     // inserisco il solido nello stesso gruppo e nello stesso posto del GeomDB
      int nNewId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pPrt) ;
      if ( nNewId == GDB_ID_NULL)
         return GDB_ID_NULL ;
     // copio gli attributi
     if ( ! pGeomDB->CopyAttributes( nId, nNewId))
         return GDB_ID_NULL ;
     // aggiorno contatori
      if ( nFirstId == GDB_ID_NULL)
         nFirstId = nNewId ;
      ++ nCount ;
   }
  // elimino il solido originale
   pGeomDB->Erase( nId) ;
  // restituisco risultati
   if ( pnCount != nullptr)
      *pnCount = nCount ;
   return nFirstId ;
}

//-------------------------------------------------------------------------------
int
ExeExplodeVolume( int nId, int* pnCount)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il tipo di solido
   int nFirstId = GDB_ID_NULL ;
   int nCount = 0 ;
   switch ( pGeomDB->GetGeoType( nId)) {
   case VOL_ZMAP :
      nFirstId = MyExplodeVolZmap( nId, &nCount) ;
      break ;
   }
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtExplodeVolume(" + ToString( nId) + ")" +
                    " -- Id1=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultati
   if ( pnCount != nullptr)
      *pnCount = nCount ;
   return nFirstId ;
}

//-------------------------------------------------------------------------------
int
ExeCopyVolZmapPart( int nId, int nPart, int nDestGrpId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero lo Zmap e copio la parte indicata
   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
   if ( pVZM == nullptr)
      return GDB_ID_NULL ;
  // recupero il suo riferimento globale
   Frame3d frVZM ;
   if ( ! pGeomDB->GetGlobFrame( nId, frVZM))
      return GDB_ID_NULL ;
  // recupero il riferimento del gruppo di destinazione
   Frame3d frDest ;
   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
      return GDB_ID_NULL ;
  // copio la parte connessa
   PtrOwner<IVolZmap> pPart( pVZM->ClonePart( nPart)) ;
   if ( IsNull( pPart))
      return GDB_ID_NULL ;
   pPart->LocToLoc( frVZM, frDest) ;
  // inserisco nel DB
   int nVZMId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nDestGrpId, GDB_LAST_SON, Release( pPart)) ;
   if ( nVZMId == GDB_ID_NULL)
      return GDB_ID_NULL ;
  // copio gli attributi
   if ( ! pGeomDB->CopyAttributes( nId, nVZMId))
      return GDB_ID_NULL ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "ExeCopyVolZmapPart(" + ToString( nId) + "," +
                                            ToString( nPart) + "," +
                                            ToString( nDestGrpId) + ")" +
                    " -- Id=" + ToString( nVZMId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return nVZMId ;
}

//-------------------------------------------------------------------------------
bool
ExeRemoveVolZmapPart( int nId, int nPart)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero lo Zmap e rimuovo la parte indicata
   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pVZM != nullptr  &&  pVZM->RemovePart( nPart)) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtRemoveVolZmapPart(" + ToString( nId) + "," +
                                              ToString( nPart) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeVolZmapSetStdTool( const INTVECTOR& vIds, const string& sToolName, double dLen, double dDiam, double dCornR, int nFlag)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero gli Zmap e assegno i dati dell'utensile
   bool bOk = true ;
   for ( int i = 0 ; i < int( vIds.size()) ; ++ i) {
      IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( vIds[i])) ;
      bOk = ( pVZM != nullptr  &&  pVZM->SetStdTool( sToolName, dLen, 0.5 * dDiam, dCornR, nFlag)) && bOk ;
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapSetStdTool({" + IdListToString( vIds) + "}," +
                                               sToolName + "," +
                                               ToString( dLen) + "," +
                                               ToString( dDiam) + "," +
                                               ToString( dCornR) + "," +
                                               ToString( nFlag) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeVolZmapSetAdvTool( const INTVECTOR& vIds, const string& sToolName,
                      double dLen, double dDiam, double dTipLen, double dTipDiam, double dCornR, int nFlag)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero gli Zmap e assegno i dati dell'utensile
   bool bOk = true ;
   for ( int i = 0 ; i < int( vIds.size()) ; ++ i) {
      IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( vIds[i])) ;
      bOk = ( pVZM != nullptr  &&  pVZM->SetAdvTool( sToolName, dLen, dDiam / 2, dTipLen, dTipDiam / 2, dCornR, nFlag)) && bOk ;
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapSetAdvTool({" + IdListToString( vIds) + "}," +
                                               sToolName + "," +
                                               ToString( dLen) + "," +
                                               ToString( dDiam) + "," +
                                               ToString( dTipLen) + "," +
                                               ToString( dTipDiam) + "," +
                                               ToString( dCornR) + "," +
                                               ToString( nFlag) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeVolZmapSetSawTool( const INTVECTOR& vIds, const string& sToolName,
                      double dLen, double dDiam, double dThick, double dStemDiam, double dCornR, int nFlag)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero gli Zmap e assegno i dati dell'utensile
   bool bOk = true ;
   for ( int i = 0 ; i < int( vIds.size()) ; ++ i) {
      IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( vIds[i])) ;
      bOk = ( pVZM != nullptr && pVZM->SetSawTool( sToolName, dLen, dDiam / 2, dThick, dStemDiam / 2, dCornR, nFlag)) && bOk ;
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapSetSawTool({" + IdListToString( vIds) + "}," +
                                               sToolName + "," +
                                               ToString( dLen) + "," +
                                               ToString( dDiam) + "," +
                                               ToString( dThick) + "," +
                                               ToString( dStemDiam) + "," +
                                               ToString( dCornR) + "," +
                                               ToString( nFlag) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeVolZmapSetGenTool( const INTVECTOR& vIds, const string& sToolName, int nToolSectId, int nFlag)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero la sezione dell'utensile
   const ICurveComposite* pCC = GetCurveComposite( pGeomDB->GetGeoObj( nToolSectId)) ;
   bool bOk = ( pCC != nullptr) ;
  // recupero gli Zmap e assegno i dati dell'utensile
   for ( int i = 0 ; i < int( vIds.size()) ; ++ i) {
      IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( vIds[i])) ;
      bOk = ( pVZM != nullptr && pVZM->SetGenTool( sToolName, pCC, nFlag) && bOk) ;
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapSetGenTool({" + IdListToString( vIds) + "}," +
                                               sToolName + "," +
                                               IdToString( nToolSectId) + "," +
                                               ToString( nFlag) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeVolZmapSetMortiserTool( const INTVECTOR& vIds, const string& sToolName,
                           double dLen, double dWidth, double dThick, double dCornR, int nFlag)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero gli Zmap e assegno i dati dell'utensile
   bool bOk = true ;
   for ( int i = 0 ; i < int( vIds.size()) ; ++ i) {
      IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( vIds[i])) ;
      bOk = ( pVZM != nullptr && pVZM->SetMortiserTool( sToolName, dLen, dWidth, dThick, dCornR, nFlag) && bOk) ;
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapSetMortiserTool({" + IdListToString( vIds) + "}," +
                                                    sToolName + "," +
                                                    ToString( dLen) + "," +
                                                    ToString( dWidth) + "," +
                                                    ToString( dThick) + "," +
                                                    ToString( dCornR) + "," +
                                                    ToString( nFlag) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeVolZmapSetChiselTool( const INTVECTOR& vIds, const string& sToolName,
                         double dLen, double dWidth, double dThick, int nFlag)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero gli Zmap e assegno i dati dell'utensile
   bool bOk = true ;
   for ( int i = 0 ; i < int( vIds.size()) ; ++ i) {
      IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( vIds[i])) ;
      bOk = ( pVZM != nullptr && pVZM->SetChiselTool( sToolName, dLen, dWidth, dThick, nFlag) && bOk) ;
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapSetChiselTool({" + IdListToString( vIds) + "}," +
                                                  sToolName + "," +
                                                  ToString( dLen) + "," +
                                                  ToString( dWidth) + "," +
                                                  ToString( dThick) + "," +
                                                  ToString( nFlag) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeVolZmapResetTool( const INTVECTOR& vIds)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero gli Zmap e assegno i dati dell'utensile
   bool bOk = true ;
   for ( int i = 0 ; i < int( vIds.size()) ; ++ i) {
      IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( vIds[i])) ;
      bOk = ( pVZM != nullptr && pVZM->ResetTool() && bOk) ;
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapResetTool({" + IdListToString( vIds) + "})" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
int
MyVolZmapGetToolOutline( int nId, int nDestGrpId, bool bApprox)
{
  // verifico DB geometrico
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero lo Zmap e recupero il profilo dell'utensile
   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
   if ( pVZM == nullptr)
      return GDB_ID_NULL ;
  // recupero outline dell'utensile
   const ICurveComposite& CC = pVZM->GetToolOutline( bApprox) ;
   if ( ! CC.IsValid())
      return GDB_ID_NULL ;
  // ne faccio una copia
   PtrOwner<ICurveComposite> pCopy( CC.Clone()) ;
   if ( IsNull( pCopy))
      return GDB_ID_NULL ;
  // inserisco la copia nel DB geometrico
   int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( pCopy)) ;
   return nNewId ;
}

//----------------------------------------------------------------------------
int
ExeVolZmapGetToolOutline( int nId, int nDestGrpId, bool bApprox)
{
   int nNewId = MyVolZmapGetToolOutline( nId, nDestGrpId, bApprox) ;
   if ( nNewId != GDB_ID_NULL)
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapGetToolOutline(" + IdToString( nId) + "," +
                                                  IdToString( nDestGrpId) + "," +
                                                  ( bApprox ? "true" : "false") + ")" +
                    " -- Id=" + IdToString( nNewId) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return nNewId ;
}

//----------------------------------------------------------------------------
bool
ExeVolZmapMillingStep( int nId, const Point3d& ptPs, const Vector3d& vtDs,
                                const Point3d& ptPe, const Vector3d& vtDe, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il riferimento locale
   Frame3d frLoc ;
   bool bOk = pGeomDB->GetGlobFrame( nId, frLoc) ;
  // porto in locale i punti e i vettori
   Point3d ptPsL = GetPointLocal( pGeomDB, ptPs, nRefType, frLoc) ;
   Vector3d vtDsL = GetVectorLocal( pGeomDB, vtDs, nRefType, frLoc) ;
   Point3d ptPeL = GetPointLocal( pGeomDB, ptPe, nRefType, frLoc) ;
   Vector3d vtDeL = GetVectorLocal( pGeomDB, vtDe, nRefType, frLoc) ;
  // recupero lo Zmap e eseguo movimento di fresatura con l'utensile già associato
   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
   bOk = bOk && ( pVZM != nullptr  &&  pVZM->MillingStep( ptPsL, vtDsL, ptPeL, vtDeL)) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapMillingStep(" + IdToString( nId) + ",{" +
                                               ToString( ptPs) + "},{" +
                                               ToString( vtDs) + "},{" +
                                               ToString( ptPe) + "},{" +
                                               ToString( vtDe) + "}," +
                                               RefTypeToString( nRefType) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeVolZmapMillingStep( int nId, const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
                                const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il riferimento locale
   Frame3d frLoc ;
   bool bOk = pGeomDB->GetGlobFrame( nId, frLoc) ;
  // porto in locale i punti e i vettori
   Point3d ptPsL = GetPointLocal( pGeomDB, ptPs, nRefType, frLoc) ;
   Vector3d vtDsL = GetVectorLocal( pGeomDB, vtDs, nRefType, frLoc) ;
   Vector3d vtAsL = GetVectorLocal( pGeomDB, vtAs, nRefType, frLoc) ;
   Point3d ptPeL = GetPointLocal( pGeomDB, ptPe, nRefType, frLoc) ;
   Vector3d vtDeL = GetVectorLocal( pGeomDB, vtDe, nRefType, frLoc) ;
   Vector3d vtAeL = GetVectorLocal( pGeomDB, vtAe, nRefType, frLoc) ;
  // recupero lo Zmap e eseguo movimento di fresatura con l'utensile già associato
   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
   bOk = bOk && ( pVZM != nullptr  &&  pVZM->MillingStep( ptPsL, vtDsL, vtAsL, ptPeL, vtDeL, vtAeL)) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapMillingStep(" + IdToString( nId) + ",{" +
                                               ToString( ptPs) + "},{" +
                                               ToString( vtDs) + "},{" +
                                               ToString( vtAs) + "},{" +
                                               ToString( ptPe) + "},{" +
                                               ToString( vtDe) + "},{" +
                                               ToString( vtAe) + "}," +
                                               RefTypeToString( nRefType) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeVolZmapGetDepth( int nId, const Point3d& ptP, const Vector3d& vtDir, int nRefType, bool bExact,
                    double& dInLen, double& dOutLen)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il riferimento locale
   Frame3d frLoc ;
   bool bOk = pGeomDB->GetGlobFrame( nId, frLoc) ;
  // porto in locale il punto e il vettore
   Point3d ptPL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ;
   Vector3d vtVL = GetVectorLocal( pGeomDB, vtDir, nRefType, frLoc) ;
  // recupero lo Zmap e calcolo profondità
   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
   bOk = bOk && ( pVZM != nullptr  &&  pVZM->GetDepth( ptP, vtDir, dInLen, dOutLen, bExact)) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapGetDepth(" + IdToString( nId) + ",{" +
                                            ToString( ptP) + "},{" +
                                            ToString( vtDir) + "}," +
                                            ( bExact ? "true" : "false") + "," +
                                            RefTypeToString( nRefType) + ")" +
                    " -- Ok=" + ToString( bOk) + "," + ToString( dInLen) + "," + ToString( dOutLen) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeVolZmapAvoidBox( int nId, const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il riferimento locale
   Frame3d frLoc ;
   bool bOk = pGeomDB->GetGlobFrame( nId, frLoc) ;
  // porto in locale il riferimento (il vettore è già in locale a questo stesso riferimento)
   Frame3d frBoxL = GetFrameLocal( pGeomDB, frBox, nRefType, frLoc) ;
  // recupero lo Zmap e calcolo collisione
   const IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
   bOk = bOk && ( pVZM != nullptr  &&  pVZM->AvoidBox( frBoxL, vtDiag, dSafeDist)) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapAvoidBox(" + IdToString( nId) + ",{" +
                                            ToString( frBox.Orig()) + "},{" +
                                            ToString( frBox.VersX()) + "},{" +
                                            ToString( frBox.VersY()) + "},{" +
                                            ToString( frBox.VersZ()) + "}},{" +
                                            ToString( vtDiag) + "}," +
                                            ToString( dSafeDist) + "," +
                                            RefTypeToString( nRefType) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeVolZmapAvoidCylinder( int nId, const Frame3d& frCyl, double dL, double dR, double dSafeDist, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il riferimento locale
   Frame3d frLoc ;
   bool bOk = pGeomDB->GetGlobFrame( nId, frLoc) ;
  // porto in locale il riferimento
   Frame3d frBoxL = GetFrameLocal( pGeomDB, frCyl, nRefType, frLoc) ;
  // recupero lo Zmap e calcolo collisione
   const IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
   bOk = bOk && ( pVZM != nullptr  &&  pVZM->AvoidCylinder( frBoxL, dL, dR, dSafeDist)) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapAvoidCylinder(" + IdToString( nId) + ",{" +
                                                 ToString( frCyl.Orig()) + "},{" +
                                                 ToString( frCyl.VersX()) + "},{" +
                                                 ToString( frCyl.VersY()) + "},{" +
                                                 ToString( frCyl.VersZ()) + "}}," +
                                                 ToString( dL) + "," +
                                                 ToString( dR) + "," +
                                                 ToString( dSafeDist) + "," +
                                                 RefTypeToString( nRefType) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ExeVolZmapAvoidSphere( int nId, const Point3d& ptCen, double dRad, double dSafeDist, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il riferimento locale
   Frame3d frLoc ;
   bool bOk = pGeomDB->GetGlobFrame( nId, frLoc) ;
  // porto in locale il centro della sfera
   Point3d ptCenL = GetPointLocal( pGeomDB, ptCen, nRefType, frLoc) ;
  // recupero lo Zmap e calcolo collisione
   const IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
   bOk = bOk && ( pVZM != nullptr  &&  pVZM->AvoidSphere( ptCenL, dRad, dSafeDist)) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtVolZmapAvoidSphere(" + IdToString( nId) + ",{" +
                                               ToString( ptCen) + "}," +
                                               ToString( dRad) + "," +
                                               ToString( dSafeDist) + "," +
                                               RefTypeToString( nRefType) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-------------------------------------------------------------------------------
bool
ExeCutVolZmapPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero lo Zmap
   IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nId)) ;
   bool bOk = ( pVZM != nullptr) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId, frLoc) ;
  // porto in locale il punto e la normale del piano
   Point3d ptOnL = GetPointLocal( pGeomDB, ptOn, nRefType, frLoc) ;
   Vector3d vtNL = GetVectorLocal( pGeomDB, vtN, nRefType, frLoc) ;
  // calcolo il piano di taglio
   Plane3d plPlane ;
   bOk = bOk && plPlane.Set( ptOnL, vtNL) ;
  // eseguo il taglio
   bOk = bOk &&  pVZM->Cut( plPlane) ;
   ExeSetModified() ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtCutVolZmapPlane(" + ToString( nId) + ",{" +
                                            ToString( ptOn) + "},{" +
                                            ToString( vtN) + "}," +
                                            RefTypeToString( nRefType) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}