EgtExecutor/EXE_GdbGetPocketing.cpp

//----------------------------------------------------------------------------
//  EgalTech 2023-2024
//----------------------------------------------------------------------------
// File : Exe_GdbGetPocketing.cpp     Data : 02.02.24      Versione : 2.6b1
// Contenuto : Funzioni di interrogazione di regioni piane del DBG per EXE.
//
//
//
// Modifiche : 29.11.23 RE Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "EXE.h"
#include "EXE_Macro.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EGkCalcPocketing.h"

using namespace std ;

//----------------------------------------------------------------------------
bool
ExePocketing( const int nId, double dRad, double dStep, double dAngle, int nType, bool bSmooth, int nDestGrpId,
              int& nFirstId, int& nCrvCount)
{
  // database geometrico
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false) ;

  // recupero la FlatRegion da svuotare
   PtrOwner<ISurfFlatRegion> pMySfr ;
   const ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
   if ( pSfr == nullptr) {
     // verifico se è una curva chiusa e piana che permette di definire una regione
      const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
      Plane3d plPlane ;
      if ( pCrv == nullptr  ||  ! pCrv->IsFlat( plPlane, true, 10 * EPS_SMALL))
         return false ;
      SurfFlatRegionByContours SfrCntr ;
      SfrCntr.AddCurve( pCrv->Clone()) ;
      pMySfr.Set( SfrCntr.GetSurf()) ;
      if ( IsNull( pMySfr))
         return false ;
      pSfr = pMySfr ;
   }

  // recupero il suo frame
   Frame3d frSfr ;
   if ( ! pGeomDB->GetGlobFrame( nId, frSfr))
      return false ;

  // recupero il riferimento del gruppo di destinazione
   Frame3d frDest ;
   if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
      return false ;

  // eseguo Pocketing
   ICRVCOMPOPOVECTOR vCrvCompoRes ;
   bool bOk = CalcPocketing( pSfr, dRad, dStep, dAngle, nType, bSmooth, vCrvCompoRes) ;
   nFirstId = GDB_ID_NULL ;
   nCrvCount = int( vCrvCompoRes.size()) ;
   if ( bOk  &&  nCrvCount > 0) {
     // scorro le curve di Pocketing ottenute
      for ( int nI = 0 ; nI < nCrvCount ; ++ nI) {
         vCrvCompoRes[nI]->LocToLoc( frSfr, frDest) ;
        // inserisco la curva nel DB Geometrico
         int nCurrId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vCrvCompoRes[nI])) ;
         if ( nCurrId == GDB_ID_NULL)
            return false ;
         if ( nI == 0)
            nFirstId = nCurrId ;
      }
      ExeSetModified() ;
   }

   if ( IsCmdLog()) {
      string sLua = "EgtPocketing(" + ToString( nId) + "," +
                                      ToString( dRad) + "," +
                                      ToString( dStep) + "," +
                                      ToString( dAngle) + "," +
                                      ToString( nType) + "," +
                                      ToString( bSmooth) + "," +
                                      ToString( nDestGrpId) + ")" +
                    " FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCrvCount) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
int
ExeSurfFrGetZigZagInfill( int nId, int nDestGrpId, double dStep, double dAng, bool bSmooth, bool bRemoveOverlapLink,
                          int* pnCount)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)

  // recupero la superficie FlatRegion
   ISurfFlatRegion* pOrigSrf = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
   if ( pOrigSrf == nullptr)
      return GDB_ID_NULL ;
   PtrOwner<ISurfFlatRegion> pSfr( pOrigSrf->Clone()) ;
   bool bOk = ( ! IsNull( pSfr)) ;

  // recupero il riferimento della superficie
   Frame3d frSurf ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId, frSurf) ;
  // recupero il riferimento di destinazione
   Frame3d frDest ;
   bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;

  // creo il riferimento per il calcolo del percorso a zigzag
   Vector3d vtN ;
   if ( bOk) 
      vtN = pSfr->GetNormVersor() ;
   bOk = bOk && vtN.ToGlob( frSurf) ;
   Frame3d frRef ; 
   bOk = bOk && frRef.Set( ORIG, vtN) ;
   bOk = bOk && frRef.Rotate( ORIG, vtN, dAng) ;

  // calcolo il percorso a zigzag
   bOk = bOk && pSfr->LocToLoc( frSurf, frRef) ;
   ICRVCOMPOPOVECTOR vpCrvs ;
   bOk = bOk  &&  CalcZigZagInfill( pSfr, dStep, bSmooth, bRemoveOverlapLink, vpCrvs) ;

  // inserisco le curve risultanti nel DB
   int nFirstId = GDB_ID_NULL ;
   int nCount = 0 ;
   for ( int i = 0 ; bOk  &&  i < ( int) vpCrvs.size() ; i ++) {
     // porto la curva nel riferimento di destinazione
      bOk = bOk  &&  vpCrvs[i]->LocToLoc( frRef, frDest) ;
     // la inserisco nel DB geometrico
      int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( vpCrvs[i])) : GDB_ID_NULL) ;
      bOk = bOk && ( nNewId != GDB_ID_NULL) ;
     // aggiorno contatori
      if ( bOk  &&  nFirstId == GDB_ID_NULL)
         nFirstId = nNewId ;
      if ( bOk)
         ++ nCount ;
   } 
   ExeSetModified() ;

  // restituisco risultati
   if ( pnCount != nullptr)
      *pnCount = nCount ;

   if ( IsCmdLog()) {
      string sLua = "EgtGetSurfFrZigZagInfill(" + ToString( nId) + "," +
                                                  ToString( dStep) + "," +
                                                  ToString( dAng) + "," +
                                                  ToString( bSmooth) + "," +
                                                  ToString( bRemoveOverlapLink) + "," +
                    " -- Ok=" + ToString( bOk) + " FirstId=" + ToString( nFirstId) + " CurveCount=" + ToString( nCount) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }

   return nFirstId ;
}