Egalware/EgtExchange
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ecdc49a305e1eaa3ca566ef0c591b202cf59afda
EgtExchange/BeamMgr.cpp
T
Dario Sassi ecdc49a305 EgtExchange 2.2k3 : 
- corrette CreateBeamMgr, CreateExport*, CreateImport*  in caso di errore ora restituiscono nullptr.
2020-11-19 15:22:05 +00:00

253 lines
9.5 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2020-2020
//----------------------------------------------------------------------------
// File : BeamMgr.cpp Data : 30.08.20 Versione : 2.2h
// Contenuto : Implementazione della classe per l'importazione BTL.
//
//
//
// Modifiche : 22.08.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "BeamMgr.h"
#include "DllMain.h"
#include "/EgtDev/Include/EExDllMain.h"
#include "/EgtDev/Include/EGkStmStandard.h"
#include "/EgtDev/Include/EGkStmFromCurves.h"
#include "/EgtDev/Include/EgtKeyCodes.h"
#include "/EgtDev/Include/EgtStringEncoder.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
using namespace std ;
//----------------------------------------------------------------------------
IBeamMgr*
CreateBeamMgr( void)
{
// verifico la chiave e le opzioni
if ( ! TestKeyForEEx( GetEExKey(), KEYOPT_EEX_INPADV, GetEExLogger()))
return nullptr ;
// creo l'oggetto
return static_cast<IBeamMgr*> ( new(nothrow) BeamMgr) ;
}
//----------------------------------------------------------------------------
BeamMgr::BeamMgr( void)
{
;
}
//----------------------------------------------------------------------------
bool
BeamMgr::Init( IGeomDB* pGDB, int nFlag)
{
// assegno il gestore di DB geometrico
if ( pGDB == nullptr)
return false ;
m_pGDB = pGDB ;
// inizializzo il gestore geometria pezzi Btl
int nFlatVertPos = 0 ;
if (( nFlag & EIBFLAG_TS3_POS) != 0)
nFlatVertPos = 3 ;
else if (( nFlag & EIBFLAG_FLAT_POS) != 0)
nFlatVertPos = 1 ;
else if (( nFlag & EIBFLAG_VERT_POS) != 0)
nFlatVertPos = 2 ;
bool bSpecialTrim = (( nFlag & EIBFLAG_SPECIAL_TRIM) != 0) ;
bool bUseUAttr = (( nFlag & EIBFLAG_USEUATTR) != 0) ;
if ( ! m_BtlGeom.Init( pGDB, nFlatVertPos, bSpecialTrim, bUseUAttr)) {
LOG_ERROR( GetEExLogger(), " Error on BtlGeom.Init")
return false ;
}
return true ;
}
//----------------------------------------------------------------------------
static int
RegularizeTriMesh( IGeomDB* pGDB, int nSurfId, int DestGrpId, double dStep)
{
// recupero la superficie trimesh
const ISurfTriMesh* pStm = GetSurfTriMesh( pGDB->GetGeoObj( nSurfId)) ;
if ( pStm == nullptr)
return GDB_ID_NULL ;
// solo per superfici trimesh con poche facce (max4)
int nFacetCnt = pStm->GetFacetCount() ;
if ( nFacetCnt > 4)
return nSurfId ;
// box della superficie
BBox3d b3Surf ;
pStm->GetLocalBBox( b3Surf, BBF_STANDARD) ;
if ( b3Surf.IsEmpty() || ( b3Surf.GetMax().x - b3Surf.GetMin().x) < 2 * dStep)
return nSurfId ;
// recupero le facce e le divido in X
double dXmin = b3Surf.GetMin().x - 1 ;
double dXmax = b3Surf.GetMax().x + 1 ;
int nStep = int( floor( ( dXmax - dXmin) / dStep + 0.9)) ;
dStep = ( dXmax - dXmin) / nStep ;
PtrOwner<ISurfTriMesh> pStmNew ;
for ( int nF = 0 ; nF < nFacetCnt ; ++ nF) {
// copio la faccia
PtrOwner<ISurfTriMesh> pFac( pStm->CloneFacet( nF)) ;
if ( IsNull( pFac))
return nSurfId ;
BBox3d b3Fac ;
pFac->GetLocalBBox( b3Fac, BBF_STANDARD) ;
// la taglio a fette
double dX2 = dXmin ;
for ( int nI = 1 ; nI <= nStep ; ++ nI) {
double dX1 = dX2 ;
dX2 = dX2 + dStep ;
if ( b3Fac.GetMin().x < dX2 && b3Fac.GetMax().x > dX1) {
// eseguo taglio
Plane3d plMin ; plMin.Set( Point3d( dX1, 0, 0), -X_AX) ;
pFac->Cut( plMin, true) ;
Plane3d plMax ; plMax.Set( Point3d( dX2, 0, 0), X_AX) ;
pFac->Cut( plMax, false) ;
// recupero il nuovo contorno
POLYLINEVECTOR vPL ;
pFac->GetFacetLoops( 0, vPL) ;
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo) || vPL.size() == 0 || ! pCrvCompo->FromPolyLine( vPL[0]))
return nSurfId ;
// lo compatto
pCrvCompo->MergeCurves( EPS_SMALL, ANG_RIGHT / 6, true) ;
// creo la nuova faccia
PtrOwner<ISurfTriMesh> pStmTmp( GetSurfTriMeshByFlatContour( pCrvCompo, EPS_SMALL)) ;
if ( IsNull( pStmTmp))
return nSurfId ;
if ( IsNull( pStmNew))
pStmNew.Set( Release( pStmTmp)) ;
else
pStmNew->DoSewing( *pStmTmp) ;
// recupero una nuova copia della faccetta originale
pFac.Set( pStm->CloneFacet( nF)) ;
if ( IsNull( pFac))
return nSurfId ;
}
}
}
// inserisco la nuova superficie nel DB geometrico
int nNewSurfId = GDB_ID_NULL ;
if ( ! IsNull( pStmNew))
nNewSurfId = pGDB->AddGeoObj( GDB_ID_NULL, DestGrpId, Release( pStmNew)) ;
return ( nNewSurfId != GDB_ID_NULL ? nNewSurfId : nSurfId) ;
}
//----------------------------------------------------------------------------
bool
BeamMgr::CalcSolid( int nPartId, bool bRecalc)
{
// Verifico validità DBG
if ( m_pGDB == nullptr)
return false ;
// Verifico esistenza del pezzo
if ( ! m_pGDB->ExistsObj( nPartId))
return false ;
// Recupero identificativo del Box
int nBoxId = m_pGDB->GetFirstNameInGroup( m_pGDB->GetFirstNameInGroup( nPartId, BOX_LAYER_NAME), BOX_BOX_NAME) ;
if ( nBoxId == GDB_ID_NULL)
return false ;
// Verifico esistenza del solido
int nSolLayId = m_pGDB->GetFirstNameInGroup( nPartId, SOLID_LAYER_NAME) ;
if ( nSolLayId == GDB_ID_NULL) {
nSolLayId = m_pGDB->AddGroup( GDB_ID_NULL, nPartId, GLOB_FRM) ;
m_pGDB->SetName( nSolLayId, SOLID_LAYER_NAME) ;
}
int nSolidId = m_pGDB->GetFirstNameInGroup( nSolLayId, SOLID_SOLID_NAME) ;
if ( bRecalc && nSolidId != GDB_ID_NULL) {
m_pGDB->Erase( nSolidId) ;
nSolidId = GDB_ID_NULL ;
}
if ( nSolidId == GDB_ID_NULL) {
BBox3d b3Box ;
m_pGDB->GetLocalBBox( nBoxId, b3Box, BBF_STANDARD) ;
Point3d ptMin ; double dDimX, dDimY, dDimz ;
if ( ! b3Box.GetMinDim( ptMin, dDimX, dDimY, dDimz))
return false ;
PtrOwner<ISurfTriMesh> pSTM( GetSurfTriMeshBox( dDimX, dDimY, dDimz, true)) ;
if ( IsNull( pSTM))
return false ;
pSTM->Translate( ptMin - ORIG) ;
nSolidId = m_pGDB->AddGeoObj( GDB_ID_NULL, nSolLayId, Release( pSTM)) ;
if ( nSolidId == GDB_ID_NULL)
return false ;
m_pGDB->SetName( nSolidId, SOLID_SOLID_NAME) ;
m_pGDB->SetMaterial( nSolidId, Color(255, 160, 32)) ;
}
else {
return true ;
}
BBox3d b3Solid ;
m_pGDB->GetLocalBBox( nSolidId, b3Solid, BBF_STANDARD) ;
double dSolidDimY = b3Solid.GetMax().y - b3Solid.GetMin().y ;
double dSolidDimZ = b3Solid.GetMax().z - b3Solid.GetMin().z ;
double dStep = 1.23 * min( max( dSolidDimY, dSolidDimZ), 2 * min( dSolidDimY, dSolidDimZ)) ;
// Esecuzione intersezioni
ISurfTriMesh* pStm = GetSurfTriMesh( m_pGDB->GetGeoObj( nSolidId)) ;
if ( pStm == nullptr)
return false ;
// ciclo sulle features
int nProcLayId = m_pGDB->GetFirstNameInGroup( nPartId, PROCESSINGS_LAYER_NAME) ;
int nProcId = m_pGDB->GetFirstInGroup( nProcLayId) ;
while ( nProcId != GDB_ID_NULL) {
int nDO = 1 ;
int nTrim = 1 ;
m_pGDB->GetInfo( nProcId, IKEY_DO, nDO) ;
m_pGDB->GetInfo( nProcId, IKEY_TRIM, nTrim) ;
if ( nDO != 0 && nTrim != 0 && m_pGDB->GetGeoType( nProcId) == SRF_TRIMESH) {
int nNewSurfId = RegularizeTriMesh( m_pGDB, nProcId, nSolLayId, dStep) ;
const ISurfTriMesh* pStmProc = GetSurfTriMesh( m_pGDB->GetGeoObj( nNewSurfId)) ;
if ( pStmProc == nullptr || ! pStm->Intersect( *pStmProc))
return false ;
if ( nNewSurfId != nProcId)
m_pGDB->Erase( nNewSurfId) ;
}
nProcId = m_pGDB->GetNext( nProcId) ;
}
return true ;
}
//----------------------------------------------------------------------------
int
BeamMgr::GetSolid( int nPartId)
{
// Verifico validità DBG
if ( m_pGDB == nullptr)
return false ;
// Recupero layer del solido e Id del solido
int nSolLayId = m_pGDB->GetFirstNameInGroup( nPartId, SOLID_LAYER_NAME) ;
int nSolidId = m_pGDB->GetFirstNameInGroup( nSolLayId, SOLID_SOLID_NAME) ;
return nSolidId ;
}
//----------------------------------------------------------------------------
bool
BeamMgr::ShowSolid( int nPartId, bool bShow)
{
// Verifico validità DBG
if ( m_pGDB == nullptr)
return false ;
// Verifico esistenza del pezzo
if ( ! m_pGDB->ExistsObj( nPartId))
return false ;
// visualizzo il solido e nascondo le geometrie complementari e viceversa
int nSolLayId = m_pGDB->GetFirstNameInGroup( nPartId, SOLID_LAYER_NAME) ;
m_pGDB->SetStatus( nSolLayId, ( bShow ? GDB_ST_ON : GDB_ST_OFF)) ;
int nBoxLayId = m_pGDB->GetFirstNameInGroup( nPartId, BOX_LAYER_NAME) ;
m_pGDB->SetStatus( nBoxLayId, ( bShow ? GDB_ST_OFF : GDB_ST_ON)) ;
int nOutlLayId = m_pGDB->GetFirstNameInGroup( nPartId, OUTLINE_LAYER_NAME) ;
m_pGDB->SetStatus( nOutlLayId, ( bShow ? GDB_ST_OFF : GDB_ST_ON)) ;
int nProcsLayId = m_pGDB->GetFirstNameInGroup( nPartId, PROCESSINGS_LAYER_NAME) ;
m_pGDB->SetStatus( nProcsLayId, ( bShow ? GDB_ST_OFF : GDB_ST_ON)) ;
return true ;
}
Reference in New Issue View Git Blame Copy Permalink