//---------------------------------------------------------------------------- // 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/EGkExtText.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 ( ! VerifyKey( KEYOPT_EEX_INPADV)) return nullptr ; // creo l'oggetto return static_cast ( new(nothrow) BeamMgr) ; } //---------------------------------------------------------------------------- BeamMgr::BeamMgr( void) { ; } //---------------------------------------------------------------------------- bool BeamMgr::Init( IGeomDB* pGDB, int nFlag) { m_pGDB = pGDB ; return SetFlag( nFlag) ; } //---------------------------------------------------------------------------- bool BeamMgr::SetFlag( int nFlag) { // verifico il gestore di DB geometrico if ( m_pGDB == nullptr) return false ; // inizializzo il gestore geometria pezzi Btl int nFlatVertPos = 0 ; if (( nFlag & EIBFLAG_OUTL_FLAT_POS) != 0) nFlatVertPos = 4 ; else 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 bTrimWithOutline = (( nFlag & EIBFLAG_TRIM_WITH_OUTLINE) != 0) ; bool bUseUAttr = (( nFlag & EIBFLAG_USEUATTR) != 0) ; if ( ! m_BtlGeom.Init( m_pGDB, nFlatVertPos, bSpecialTrim, bTrimWithOutline, bUseUAttr)) { LOG_ERROR( GetEExLogger(), " Error on BtlGeom.Init") return false ; } return true ; } //---------------------------------------------------------------------------- int BeamMgr::CreatePart( void) { // Verifico validità GDB if ( m_pGDB == nullptr) return GDB_ID_NULL ; // Aggiorno posizione m_BtlGeom.UpdateNextOrigin() ; // Creo il pezzo return ( m_BtlGeom.CreatePart() ? m_BtlGeom.GetCurrPartId() : GDB_ID_NULL) ; } //---------------------------------------------------------------------------- bool BeamMgr::SetPart( int nPartId) { // Verifico validità GDB if ( m_pGDB == nullptr) return false ; // Imposto il pezzo come corrente return m_BtlGeom.SetPart( nPartId) ; } //---------------------------------------------------------------------------- bool BeamMgr::ErasePart( void) { // Verifico validità GDB if ( m_pGDB == nullptr) return false ; // Cancello il pezzo corrente return m_BtlGeom.ErasePart() ; } //---------------------------------------------------------------------------- bool BeamMgr::UpdatePart( void) { // Verifico validità GDB if ( m_pGDB == nullptr) return false ; // Forzo aggiornamento del pezzo corrente return ( m_BtlGeom.UpdateOutLine() && m_BtlGeom.ResetPartSolid()) ; } //---------------------------------------------------------------------------- bool BeamMgr::SetPartProdNbr( int nProdNbr) { // Verifico validità GDB if ( m_pGDB == nullptr) return false ; // Verifico validità nuovo PDN if ( ! m_BtlGeom.VerifyNewPartProdNbr( nProdNbr)) return false ; // Imposto il numero di produzione sul pezzo corrente return m_BtlGeom.SetPartProdNbr( nProdNbr) ; } //---------------------------------------------------------------------------- bool BeamMgr::SetPartName( const string& sName) { // Verifico validità GDB if ( m_pGDB == nullptr) return false ; // Imposto il nome sul pezzo corrente return m_BtlGeom.SetPartName( sName) ; } //---------------------------------------------------------------------------- bool BeamMgr::SetPartCount( int nCount) { // Verifico validità GDB if ( m_pGDB == nullptr) return false ; // Imposto il numero delle parti da produrre sul pezzo corrente return m_BtlGeom.SetPartCount( nCount) ; } //---------------------------------------------------------------------------- bool BeamMgr::SetPartBox( double dLength, double dHeight, double dWidth, bool bUpdate) { // Verifico validità GDB if ( m_pGDB == nullptr) return false ; // Imposto le dimensioni sul pezzo corrente if ( ! m_BtlGeom.AddPartBox( dLength, dHeight, dWidth)) return false ; // Eventuale aggiornamento nomi facce e lato di carico UpdateFacesName() ; UpdateLoadingSide() ; // Se richiesto, aggiorno Outline e cancello Solido if ( bUpdate) { m_BtlGeom.UpdateOutLine() ; m_BtlGeom.ResetPartSolid() ; } return true ; } //---------------------------------------------------------------------------- bool BeamMgr::GetSideData( int nSide, Frame3d& frRef, double& dLength, double& dWidth, double& dHeight) { // Verifico validità GDB if ( m_pGDB == nullptr) return false ; // Verifico validità identificativo di faccia if ( nSide < BTL_SIDE_FRONT || nSide > BTL_SIDE_RIGHT) return false ; // Recupero riferimento del pezzo corrente int nPartId = m_BtlGeom.GetCurrPartId() ; Frame3d frPart ; if ( ! m_pGDB->GetGroupGlobFrame( nPartId, frPart)) return false ; // Recupero i dati frRef = m_BtlGeom.GetSideFrame( nSide) ; frRef.ToGlob( frPart) ; dLength = m_BtlGeom.GetSideLength( nSide) ; dWidth = m_BtlGeom.GetSideWidth( nSide) ; dHeight = m_BtlGeom.GetSideHeight( nSide) ; return true ; } //---------------------------------------------------------------------------- bool BeamMgr::ShowFacesName( bool bShow) { // Verifico validità GDB if ( m_pGDB == nullptr) return false ; // Verifico esistenza del pezzo corrente int nPartId = m_BtlGeom.GetCurrPartId() ; if ( nPartId == GDB_ID_NULL) return false ; // Verifico esistenza del gruppo nomi facce int nFcsNameLayId = m_pGDB->GetFirstNameInGroup( nPartId, FCSNAME_LAYER_NAME) ; // Se da visualizzare e non esiste il gruppo if ( bShow && nFcsNameLayId == GDB_ID_NULL) { // Creazione del gruppo nFcsNameLayId = m_pGDB->AddGroup( GDB_ID_NULL, nPartId, GLOB_FRM) ; m_pGDB->SetLevel( nFcsNameLayId, GDB_LV_TEMP) ; m_pGDB->SetName( nFcsNameLayId, FCSNAME_LAYER_NAME) ; m_pGDB->SetMaterial( nFcsNameLayId, NAVY) ; // Scrittura del nome delle facce come testi del layer ausiliario for ( int nS = BTL_SIDE_FRONT ; nS <= BTL_SIDE_RIGHT ; ++ nS) { string sFace ; if ( nS == BTL_SIDE_LEFT) sFace = "o" ; else if ( nS == BTL_SIDE_RIGHT) sFace = "+" ; else sFace = "F" + ToString( nS) ; PtrOwner pText( CreateExtText()) ; if ( IsNull( pText)) return false ; double dSLen = m_BtlGeom.GetSideLength( nS) ; double dSWid = m_BtlGeom.GetSideWidth( nS) ; Point3d ptPos( 0.5 * dSLen, ( m_BtlGeom.IsTrueSide( nS) ? 10 : 0.5 * dSWid), 1) ; Vector3d vtDir = ( nS != BTL_SIDE_RIGHT ? X_AX : -X_AX) ; int nInsPos = ( m_BtlGeom.IsTrueSide( nS) ? ETXT_IPBC : ETXT_IPMC) ; double dPLen = m_BtlGeom.GetCurrPartLength() ; double dPHei = m_BtlGeom.GetCurrPartHeight() ; double dPWid = m_BtlGeom.GetCurrPartWidth() ; double dCoeff = ( abs( dPHei - dPWid) / abs( dPHei + dPWid) < 0.51 ? 0.1 : 0.2) ; double dTextHeight = dCoeff * min( { dPLen, dPHei, dPWid}) ; if ( ! pText->Set( ptPos, Z_AX, vtDir, sFace, "Arial", 100, false, 2 * dTextHeight, 1, 0, nInsPos)) return false ; // porto il testo nel piano della faccia Frame3d frRef = m_BtlGeom.GetSideFrame( nS) ; pText->ToGlob( frRef) ; // recupero eventuale nome già presente int nOldTextId = m_pGDB->GetFirstNameInGroup( nFcsNameLayId, sFace) ; // se gia presente, lo rimpiazzo if ( nOldTextId != GDB_ID_NULL) { if ( ! m_pGDB->ReplaceGeoObj( nOldTextId, Release( pText))) return false ; } // altrimenti, lo inserisco else { int nTextId = m_pGDB->AddGeoObj( GDB_ID_NULL, nFcsNameLayId, Release( pText)) ; if ( nTextId == GDB_ID_NULL) return false ; // assegno nome m_pGDB->SetName( nTextId, sFace) ; } } } // se altrimenti da eliminare ed esiste else if ( ! bShow && nFcsNameLayId != GDB_ID_NULL) { m_pGDB->Erase( nFcsNameLayId) ; } return true ; } //---------------------------------------------------------------------------- bool BeamMgr::UpdateFacesName( void) { int nFcsNameLayId = m_pGDB->GetFirstNameInGroup( m_BtlGeom.GetCurrPartId(), FCSNAME_LAYER_NAME) ; if ( nFcsNameLayId == GDB_ID_NULL) return true ; m_pGDB->Erase( nFcsNameLayId) ; return ShowFacesName( true) ; } //---------------------------------------------------------------------------- bool BeamMgr::ShowLoadingSide( bool bShow, bool bFromLeft) { // Verifico validità GDB if ( m_pGDB == nullptr) return false ; // Verifico esistenza del pezzo corrente int nPartId = m_BtlGeom.GetCurrPartId() ; if ( nPartId == GDB_ID_NULL) return false ; // Verifico esistenza del gruppo temporaneo lato di carico int nLsideGrpId = m_pGDB->GetFirstNameInGroup( GDB_ID_ROOT, LOADINGSIDE_GROUP_NAME) ; // Se da visualizzare e non esiste il gruppo if ( bShow && nLsideGrpId == GDB_ID_NULL) { // Creazione del gruppo nLsideGrpId = m_pGDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, GLOB_FRM) ; m_pGDB->SetLevel( nLsideGrpId, GDB_LV_TEMP) ; m_pGDB->SetName( nLsideGrpId, LOADINGSIDE_GROUP_NAME) ; m_pGDB->SetMaterial( nLsideGrpId, NAVY) ; m_pGDB->SetInfo( nLsideGrpId, IKEY_LSIDE, bFromLeft) ; // Recupero dati del pezzo Frame3d frPart ; if ( ! m_pGDB->GetGroupGlobFrame( nPartId, frPart)) return false ; BBox3d b3Part( 0, 0, 0, m_BtlGeom.GetCurrPartLength(), m_BtlGeom.GetCurrPartHeight(), m_BtlGeom.GetCurrPartWidth()) ; b3Part.ToGlob( frPart) ; // Disegno della freccia PolyLine PL ; PL.AddUPoint( 0, Point3d( 140, 0, 0)) ; PL.AddUPoint( 0, Point3d( 100, -40, 0)) ; PL.AddUPoint( 0, Point3d( 100, -20, 0)) ; PL.AddUPoint( 0, Point3d( 0, -20, 0)) ; PL.AddUPoint( 0, Point3d( 0, 20, 0)) ; PL.AddUPoint( 0, Point3d( 100, 20, 0)) ; PL.AddUPoint( 0, Point3d( 100, 40, 0)) ; PL.AddUPoint( 0, Point3d( 140, 0, 0)) ; Vector3d vtMove = b3Part.GetMin() + ( b3Part.GetDimX() + 50) * X_AX + b3Part.GetDimY() / 2 * Y_AX - ORIG ; PL.Translate( vtMove) ; PtrOwner pStm( CreateSurfTriMesh()) ; if ( IsNull( pStm) || ! pStm->CreateByFlatContour( PL)) return false ; int nStmId = m_pGDB->AddGeoObj( GDB_ID_NULL, nLsideGrpId, Release( pStm)) ; if ( nStmId == GDB_ID_NULL) return false ; } // se altrimenti da eliminare ed esiste else if ( ! bShow && nLsideGrpId != GDB_ID_NULL) { m_pGDB->Erase( nLsideGrpId) ; } return true ; } //---------------------------------------------------------------------------- bool BeamMgr::UpdateLoadingSide( void) { int nLsideGrpId = m_pGDB->GetFirstNameInGroup( GDB_ID_ROOT, LOADINGSIDE_GROUP_NAME) ; if ( nLsideGrpId == GDB_ID_NULL) return true ; bool bFromLeft = true ; m_pGDB->GetInfo( nLsideGrpId, IKEY_LSIDE, bFromLeft) ; m_pGDB->Erase( nLsideGrpId) ; return ShowLoadingSide( true, bFromLeft) ; } //---------------------------------------------------------------------------- int BeamMgr::AddProcess( int nGroup, int nProc, int nSide, const string& sDes, int nProcId, const Frame3d& frRef, const DBLVECTOR& vdPar, const string& sPar, const STRVECTOR& vsUAtt, int nCrvId, int nCrv2Id, bool bUpdate) { // Verifico validità GDB if ( m_pGDB == nullptr) return GDB_ID_NULL ; // Recupero i dati di default della feature INTVECTOR vnDPar ; int nSPar ; DBLVECTOR vdBtlPar ; string sBtlPar ; if ( ! m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdBtlPar, sBtlPar)) return GDB_ID_NULL ; // Imposto i dati della feature for ( int i = 0 ; i < int( vnDPar.size()) ; ++ i) { int j = vnDPar[i] ; if ( j > 0 && j - 1 < int( vdPar.size())) vdBtlPar[i] = vdPar[j-1] ; } sBtlPar = sPar ; // Gestione speciale per FreeContour if ( nProc == 250) { if ( ! m_BtlGeom.AddOneFreeContour( nGroup, nProc, nSide, sDes, nProcId, frRef, vnDPar, vdBtlPar, vsUAtt, nCrvId, nCrv2Id)) return GDB_ID_NULL ; } // gestione speciale per Outline else if ( nProc == 251) { if ( ! m_BtlGeom.AddPartOutline( nSide, nCrvId, vdBtlPar, vsUAtt)) return GDB_ID_NULL ; } // gestione speciale per Aperture else if ( nProc == 252) { if ( ! m_BtlGeom.AddPartAperture( nSide, nCrvId, vdBtlPar, vsUAtt)) return GDB_ID_NULL ; } // altrimenti Add standard else { if ( ! m_BtlGeom.AddProcess( nGroup, nProc, nSide, sDes, nProcId, frRef, vnDPar, nSPar, vdBtlPar, sBtlPar, vsUAtt, 0)) return GDB_ID_NULL ; } // Se richiesto, aggiorno Outline e cancello Solido if ( bUpdate) { m_BtlGeom.UpdateOutLine() ; m_BtlGeom.ResetPartSolid() ; } // ritorno Id return m_BtlGeom.GetLastProcessId() ; } //---------------------------------------------------------------------------- int BeamMgr::ModifyProcess( int nGeomId, int nGroup, int nProc, int nSide, const string& sDes, int nProcId, const Frame3d& frRef, const DBLVECTOR& vdPar, const string& sPar, const STRVECTOR& vsUAtt, int nCrvId, int nCrv2Id, bool bUpdate) { // Verifico validità GDB if ( m_pGDB == nullptr) return GDB_ID_NULL ; // Recupero il pezzo di appartenenza int nLayId = m_pGDB->GetParentId( nGeomId) ; int nPartId = m_pGDB->GetParentId( nLayId) ; // accetto feature normali e Outline/Aperture if ( ! m_BtlGeom.SetPart( nPartId) || ( m_BtlGeom.GetCurrProcsLayId() != nLayId && m_BtlGeom.GetCurrOutsLayId() != nLayId)) return GDB_ID_NULL ; // Aggiungo il nuovo processo modificato int nNewId = AddProcess( nGroup, nProc, nSide, sDes, nProcId, frRef, vdPar, sPar, vsUAtt, nCrvId, nCrv2Id, false) ; if ( nNewId == GDB_ID_NULL) return GDB_ID_NULL ; // Sposto le geometrie inserite appena sopra le vecchie (mantenendo l'ordine relativo nel gruppo) INTVECTOR vIds = { nNewId} ; if ( m_pGDB->ExistsInfo( nNewId, IKEY_AUXID)) { INTVECTOR vAux ; m_pGDB->GetInfo( nNewId, IKEY_AUXID, vAux) ; for ( auto nAux : vAux) vIds.emplace_back( nNewId + nAux) ; } if ( m_pGDB->ExistsInfo( nNewId, IKEY_ADJID)) { INTVECTOR vAdj ; m_pGDB->GetInfo( nNewId, IKEY_ADJID, vAdj) ; for ( auto nAdj : vAdj) { // aggiunto vIds.emplace_back( nNewId + nAdj) ; // eventuali ausiliari dell'aggiunto if ( m_pGDB->ExistsInfo( nNewId + nAdj, IKEY_AUXID)) { INTVECTOR vAux ; m_pGDB->GetInfo( nNewId + nAdj, IKEY_AUXID, vAux) ; for ( auto nAux : vAux) vIds.emplace_back( nNewId + nAdj + nAux) ; } } } sort( vIds.begin(), vIds.end()) ; for ( auto nId : vIds) m_pGDB->Relocate( nId, nGeomId, GDB_BEFORE) ; // Cancello il vecchio processo EraseProcess( nGeomId, bUpdate) ; // Restituisco nuovo Id return nNewId ; } //---------------------------------------------------------------------------- bool BeamMgr::EraseProcess( int nGeomId, bool bUpdate) { // Verifico validità GDB if ( m_pGDB == nullptr) return false ; // Recupero il pezzo di appartenenza int nLayId = m_pGDB->GetParentId( nGeomId) ; int nPartId = m_pGDB->GetParentId( nLayId) ; // accetto feature normali e Outline/Aperture if ( ! m_BtlGeom.SetPart( nPartId) || ( m_BtlGeom.GetCurrProcsLayId() != nLayId && m_BtlGeom.GetCurrOutsLayId() != nLayId)) return false ; // Cancello eventuali geometrie aggiuntive INTVECTOR vAdj ; if ( m_pGDB->GetInfo( nGeomId, IKEY_ADJID, vAdj) && ! vAdj.empty()) { for ( auto nAdj : vAdj) EraseProcess( nGeomId + nAdj, false) ; } // Cancello eventuali geometrie ausiliarie INTVECTOR vAux ; if ( m_pGDB->GetInfo( nGeomId, IKEY_AUXID, vAux) && ! vAux.empty()) { for ( auto nAux : vAux) m_pGDB->Erase( nGeomId + nAux) ; } // Cancello eventuali geometrie originali INTVECTOR vOrig ; if ( m_pGDB->GetInfo( nGeomId, IKEY_ORIGID, vOrig) && ! vOrig.empty()) { for ( auto nOrig : vOrig) { INTVECTOR vAux ; if ( m_pGDB->GetInfo( nOrig, IKEY_AUXID, vAux) && ! vAux.empty()) { for ( auto nAux : vAux) m_pGDB->Erase( nOrig + nAux) ; } m_pGDB->Erase( nGeomId + nOrig) ; } } m_pGDB->Erase( nGeomId) ; // Se richiesto, aggiorno Outline e cancello Solido if ( bUpdate) { m_BtlGeom.UpdateOutLine() ; m_BtlGeom.ResetPartSolid() ; } return true ; } //---------------------------------------------------------------------------- static bool MyEnableProcess( IGeomDB* pGDB, BtlGeom& BtlG, int nGeomId, bool bEnable) { // Recupero lo stato corrente bool bDo = true ; pGDB->GetInfo( nGeomId, IKEY_DO, bDo) ; // Se lo stato non cambia, esco if ( bEnable == bDo) return true ; // Imposto il nuovo stato e il colore if ( bEnable) pGDB->RemoveInfo( nGeomId, IKEY_DO) ; else pGDB->SetInfo( nGeomId, IKEY_DO, 0) ; return BtlG.SetProcessColor( nGeomId, bEnable) ; } //---------------------------------------------------------------------------- bool BeamMgr::EnableProcess( int nGeomId, bool bEnable, bool bUpdate) { // Verifico validità GDB if ( m_pGDB == nullptr) return false ; // Recupero il pezzo di appartenenza int nLayId = m_pGDB->GetParentId( nGeomId) ; int nPartId = m_pGDB->GetParentId( nLayId) ; if ( ! m_BtlGeom.SetPart( nPartId) || ( m_BtlGeom.GetCurrOutsLayId() != nLayId && m_BtlGeom.GetCurrProcsLayId() != nLayId)) return false ; // Aggiorno il processo MyEnableProcess( m_pGDB, m_BtlGeom, nGeomId, bEnable) ; // Aggiorno eventuali geometrie aggiuntive INTVECTOR vAdj ; if ( m_pGDB->GetInfo( nGeomId, IKEY_ADJID, vAdj) && ! vAdj.empty()) { for ( auto nAdj : vAdj) MyEnableProcess( m_pGDB, m_BtlGeom, nGeomId + nAdj, bEnable) ; } // Aggiorno eventuali geometrie originali INTVECTOR vOrig ; if ( m_pGDB->GetInfo( nGeomId, IKEY_ORIGID, vOrig) && ! vOrig.empty()) { for ( auto nOrig : vOrig) { MyEnableProcess( m_pGDB, m_BtlGeom, nGeomId + nOrig, bEnable) ; } } // Se richiesto, aggiorno Outline e cancello Solido if ( bUpdate) { m_BtlGeom.UpdateOutLine() ; m_BtlGeom.ResetPartSolid() ; } return true ; } //---------------------------------------------------------------------------- static ISurfTriMesh* RegularizeTriMesh( const ISurfTriMesh* pStm, double dStep) { // verifico la superficie if ( pStm == nullptr) return nullptr ; // solo per superfici trimesh con poche facce (max4) int nFacetCnt = pStm->GetFacetCount() ; if ( nFacetCnt > 4) return nullptr ; // box della superficie BBox3d b3Surf ; pStm->GetLocalBBox( b3Surf, BBF_STANDARD) ; if ( b3Surf.IsEmpty() || ( b3Surf.GetMax().x - b3Surf.GetMin().x) < 2 * dStep) return nullptr ; // 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 pStmNew ; for ( int nF = 0 ; nF < nFacetCnt ; ++ nF) { // copio la faccia PtrOwner pFac( pStm->CloneFacet( nF)) ; if ( IsNull( pFac)) return nullptr ; 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 pCrvCompo( CreateCurveComposite()) ; if ( IsNull( pCrvCompo) || vPL.size() == 0 || ! pCrvCompo->FromPolyLine( vPL[0])) return nullptr ; // lo compatto pCrvCompo->MergeCurves( EPS_SMALL, ANG_RIGHT / 6, true) ; // creo la nuova faccia PtrOwner pStmTmp( GetSurfTriMeshByFlatContour( pCrvCompo, EPS_SMALL)) ; if ( IsNull( pStmTmp)) return nullptr ; if ( IsNull( pStmNew)) pStmNew.Set( pStmTmp) ; else pStmNew->DoSewing( *pStmTmp) ; // recupero una nuova copia della faccetta originale pFac.Set( pStm->CloneFacet( nF)) ; if ( IsNull( pFac)) return nullptr ; } } } return Release( pStmNew) ; } //---------------------------------------------------------------------------- bool BeamMgr::CalcSolid( int nPartId, bool bRecalc) { // Verifico validità GDB 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) ; m_pGDB->SetMaterial( nSolLayId, Color(255, 160, 32)) ; } int nSolidId = m_pGDB->GetFirstNameInGroup( nSolLayId, SOLID_SOLID_NAME) ; const ISurfTriMesh* pOldStm = GetSurfTriMesh( m_pGDB->GetGeoObj( nSolidId)) ; if ( pOldStm == nullptr || pOldStm->GetFacetCount() == 0) bRecalc = true ; if ( bRecalc) { 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 pSTM( GetSurfTriMeshBox( dDimX, dDimY, dDimz, false)) ; if ( IsNull( pSTM)) return false ; pSTM->Translate( ptMin - ORIG) ; if ( nSolidId != GDB_ID_NULL) { if ( ! m_pGDB->ReplaceGeoObj( nSolidId, Release( pSTM))) return false ; } else { nSolidId = m_pGDB->AddGeoObj( GDB_ID_NULL, nSolLayId, Release( pSTM)) ; if ( nSolidId == GDB_ID_NULL) return false ; m_pGDB->SetName( nSolidId, SOLID_SOLID_NAME) ; } } 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 su outline e aperture int nOutLayId = m_pGDB->GetFirstNameInGroup( nPartId, OUTLINE_LAYER_NAME) ; int nOutId = m_pGDB->GetFirstInGroup( nOutLayId) ; while ( nOutId != GDB_ID_NULL) { int nDO = 1 ; m_pGDB->GetInfo( nOutId, IKEY_DO, nDO) ; if ( nDO != 0 && m_pGDB->GetGeoType( nOutId) == SRF_TRIMESH) { const ISurfTriMesh* pStmOut = GetSurfTriMesh( m_pGDB->GetGeoObj( nOutId)) ; PtrOwner pStmTmp( RegularizeTriMesh( pStmOut, dStep)) ; if ( ! IsNull( pStmTmp)) pStmOut = Get( pStmTmp) ; if ( pStmOut == nullptr || ! pStm->Intersect( *pStmOut)) return false ; } nOutId = m_pGDB->GetNext( nOutId) ; } // 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) { // recupero eventuale superficie originale int nProcSurfId = nProcId ; int nOrigId = 0 ; if ( m_pGDB->GetInfo( nProcSurfId, IKEY_ORIGID, nOrigId)) nProcSurfId += nOrigId ; // se da utilizzare anche suerfici ausiliarie if ( nTrim == 2) { int nAux ; if ( m_pGDB->GetInfo( nProcSurfId, IKEY_AUXID, nAux)) { const ISurfTriMesh* pStmProc = GetSurfTriMesh( m_pGDB->GetGeoObj( nProcSurfId)) ; const ISurfTriMesh* pAux = GetSurfTriMesh( m_pGDB->GetGeoObj( nProcSurfId + nAux)) ; if ( pStmProc != nullptr && pAux != nullptr) { PtrOwner pTrim ; pTrim.Set( pAux->Clone()) ; if ( IsNull( pTrim) || ! pTrim->DoSewing( *pStmProc)) return false ; PtrOwner pStmTmp( RegularizeTriMesh( pTrim, dStep)) ; const ISurfTriMesh* pStmTool = ( ! IsNull( pStmTmp) ? Get( pStmTmp) : Get( pTrim)) ; if ( pStmTool == nullptr || ! pStm->Intersect( *pStmTool)) return false ; } } } // caso standard else { const ISurfTriMesh* pStmProc = GetSurfTriMesh( m_pGDB->GetGeoObj( nProcSurfId)) ; PtrOwner pStmTmp( RegularizeTriMesh( pStmProc, dStep)) ; if ( ! IsNull( pStmTmp)) pStmProc = Get( pStmTmp) ; if ( pStmProc == nullptr || ! pStm->Intersect( *pStmProc)) return false ; } } nProcId = m_pGDB->GetNext( nProcId) ; } m_pGDB->SetInfo( nSolidId, IKEY_VALID, 1) ; return true ; } //---------------------------------------------------------------------------- int BeamMgr::GetSolid( int nPartId) const { // Verifico validità GDB 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à GDB 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)) ; int nFcsNameLayId = m_pGDB->GetFirstNameInGroup( nPartId, FCSNAME_LAYER_NAME) ; m_pGDB->SetStatus( nFcsNameLayId, ( bShow ? GDB_ST_OFF : GDB_ST_ON)) ; return true ; } //---------------------------------------------------------------------------- bool BeamMgr::GetBuildingIsOn( void) const { // verifico esistenza gruppo di assemblaggio int nAssGrpId = m_pGDB->GetFirstNameInGroup( GDB_ID_ROOT, ASSEMBLY_GROUP_NAME) ; if ( nAssGrpId == GDB_ID_NULL) return false ; // recupero il primo oggetto nel gruppo int nAssId = m_pGDB->GetFirstInGroup( nAssGrpId) ; if ( nAssId == GDB_ID_NULL) return false ; // se contiene oggetti, assemblaggio è On return ( m_pGDB->GetGroupObjs( nAssId) > 0) ; } //---------------------------------------------------------------------------- bool BeamMgr::ShowBuilding( bool bShow) { // verifico esistenza gruppo di assemblaggio int nAssGrpId = m_pGDB->GetFirstNameInGroup( GDB_ID_ROOT, ASSEMBLY_GROUP_NAME) ; if ( nAssGrpId == GDB_ID_NULL) return false ; // ciclo sul gruppo di assemblaggio int nAssId = m_pGDB->GetFirstInGroup( nAssGrpId) ; while ( nAssId != GDB_ID_NULL) { // recupero il successivo int nNextId = m_pGDB->GetNext( nAssId) ; // se richiesta visualizzazione assemblato if ( bShow) { // recupero il pezzo sorgente int nSouId ; if ( m_pGDB->GetInfo( nAssId, GDB_SI_SOURCE, nSouId)) { m_pGDB->SetMode( nSouId, GDB_MD_STD) ; m_pGDB->SetStatus( nSouId, GDB_ST_ON) ; // se già utilizzato, ne faccio una copia if ( m_pGDB->GetParentId( nSouId) != GDB_ID_ROOT) { int nCopyId = m_pGDB->Copy( nSouId, GDB_ID_NULL, GDB_ID_ROOT) ; if ( nCopyId != GDB_ID_NULL) { m_pGDB->RemoveInfo( nCopyId, GDB_SI_BASE) ; m_pGDB->RemoveInfo( nCopyId, GDB_SI_LIST) ; m_pGDB->SetInfo( nCopyId, GDB_SI_COPY, nSouId) ; nSouId = nCopyId ; m_pGDB->SetInfo( nAssId, GDB_SI_SOURCE, nSouId) ; } } m_pGDB->SetStatus( m_pGDB->GetFirstNameInGroup( nSouId, BOX_LAYER_NAME), GDB_ST_OFF) ; m_pGDB->GroupSwap( nSouId, nAssId, true, true) ; } } // altrimenti visualizzo insieme dei pezzi else { int nBaseId ; if ( m_pGDB->GetInfo( nAssId, GDB_SI_BASE, nBaseId)) { m_pGDB->GroupSwap( nAssId, nBaseId, true, true) ; int nCopyId ; if ( m_pGDB->GetInfo( nAssId, GDB_SI_COPY, nCopyId)) { m_pGDB->Erase( nAssId) ; m_pGDB->SetInfo( nBaseId, GDB_SI_SOURCE, nCopyId) ; } else { m_pGDB->SetStatus( m_pGDB->GetFirstNameInGroup( nAssId, BOX_LAYER_NAME), GDB_ST_ON) ; } } } // passo al successivo nAssId = nNextId ; } return true ; }