Dario Sassi
9577795c73
- per BTL aggiunta possibilità di gestione geometrica del PARTOFFSET (controllata da flag).
1247 lines
41 KiB
C++
1247 lines
41 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2015
|
|
//----------------------------------------------------------------------------
|
|
// File : BtlGeom.cpp Data : 26.08.15 Versione : 1.6h5
|
|
// Contenuto : Implementazione della classe BtlGeom.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 26.08.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "BtlGeom.h"
|
|
#include "DllMain.h"
|
|
#include "/EgtDev/Include/EGkCurveLine.h"
|
|
#include "/EgtDev/Include/EGkCurveArc.h"
|
|
#include "/EgtDev/Include/EGkCurveComposite.h"
|
|
#include "/EgtDev/Include/EGkSfrCreate.h"
|
|
#include "/EgtDev/Include/EGkStmStandard.h"
|
|
#include "/EgtDev/Include/EGkStmFromCurves.h"
|
|
#include "/EgtDev/Include/EGkExtText.h"
|
|
#include "/EgtDev/Include/EXeExecutor.h"
|
|
#include "/EgtDev/Include/EGnStringUtils.h"
|
|
#include "/EgtDev/Include/EgtPointerOwner.h"
|
|
#include <unordered_map>
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
string BtlGeom::m_sBtlAuxDir ;
|
|
string BtlGeom::m_sBtlLuaLibsDir ;
|
|
string BtlGeom::m_sBtlLuaLastRequire ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
BtlGeom::BtlGeom( void)
|
|
{
|
|
m_pGDB = nullptr ;
|
|
m_nFlatVertPos = 0 ;
|
|
m_bSpecialTrim = false ;
|
|
m_bTrimWithOutline = false ;
|
|
m_bUseUAttr = false ;
|
|
m_bPartOffset = false ;
|
|
m_BoxCol = Color( 255, 128, 0, 15) ;
|
|
m_OffsCol = Color( 255, 0, 0, 15) ;
|
|
m_OutsCol = Color( 224, 128, 0, 50) ;
|
|
m_ProcsCol = Color( 80, 160, 160, 100) ;
|
|
m_ProcsOffCol = Color( 160, 160, 160, 30) ;
|
|
m_MarkCol = Color( 96, 192, 192, 100) ;
|
|
m_SolidCol = Color(255, 160, 32, 100) ;
|
|
m_nInfoId = GDB_ID_NULL ;
|
|
m_nAsseId = GDB_ID_NULL ;
|
|
m_nRawPartsId = GDB_ID_NULL ;
|
|
m_nCompositesId = GDB_ID_NULL ;
|
|
m_ptOrig = ORIG ;
|
|
m_nPartId = GDB_ID_NULL ;
|
|
m_nAuxId = GDB_ID_NULL ;
|
|
m_nBoxId = GDB_ID_NULL ;
|
|
m_nOutsId = GDB_ID_NULL ;
|
|
m_nProcsId = GDB_ID_NULL ;
|
|
m_nSolidsId = GDB_ID_NULL ;
|
|
m_vtDim = V_NULL ;
|
|
m_nCount = 0 ;
|
|
m_nProcId = GDB_ID_NULL ;
|
|
m_nBtlLine = 0 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BtlGeom::~BtlGeom( void)
|
|
{
|
|
// chiudo lua ( se era aperto)
|
|
if ( m_LuaMgr.Exit()) {
|
|
string sLua = "Lua BtlGeom interpreter closed" ;
|
|
LOG_INFO( GetEExLogger(), sLua.data())
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::Init( IGeomDB* pGDB, int nFlatVertPos, bool bSpecialTrim,
|
|
bool bTrimWithOutline, bool bUseUAttr, bool bPartOffset, bool bIsAdding)
|
|
{
|
|
// salvo puntatore a DB geometrico
|
|
m_pGDB = pGDB ;
|
|
if ( m_pGDB == nullptr)
|
|
return false ;
|
|
// salvo i flag
|
|
m_nFlatVertPos = nFlatVertPos ;
|
|
m_bSpecialTrim = bSpecialTrim ;
|
|
m_bTrimWithOutline = bTrimWithOutline ;
|
|
m_bUseUAttr = bUseUAttr ;
|
|
m_bPartOffset = bPartOffset ;
|
|
// gruppo per informazioni varie, se in aggiunta lo creo sempre
|
|
m_nInfoId = ( bIsAdding ? GDB_ID_NULL : m_pGDB->GetFirstNameInGroup( GDB_ID_ROOT, INFO_GROUP_NAME)) ;
|
|
if ( bIsAdding && ! CreateInfoGroup())
|
|
return false ;
|
|
// gruppo per assemblaggio, se in aggiunta lo creo sempre
|
|
m_nAsseId = ( bIsAdding ? GDB_ID_NULL : m_pGDB->GetFirstNameInGroup( GDB_ID_ROOT, ASSEMBLY_GROUP_NAME)) ;
|
|
if ( bIsAdding && ! CreateAssemblyGroup())
|
|
return false ;
|
|
// recupero eventuali riferimenti a gruppi per grezzi e compositi
|
|
m_nRawPartsId = m_pGDB->GetFirstNameInGroup( GDB_ID_ROOT, RAWPARTS_GROUP_NAME) ;
|
|
m_nCompositesId = m_pGDB->GetFirstNameInGroup( GDB_ID_ROOT, COMPOSITES_GROUP_NAME) ;
|
|
// inizializzo interprete lua
|
|
if ( ! m_LuaMgr.Init())
|
|
return false ;
|
|
// carico le funzioni speciali
|
|
if ( ! LuaInstallEgtFunctions( m_LuaMgr))
|
|
return false ;
|
|
// recupero la versione di Lua
|
|
string sLua ;
|
|
if ( m_LuaMgr.GetVersion( sLua))
|
|
sLua += " BtlGeom interpreter started" ;
|
|
else
|
|
sLua = "Lua *.* BtlGeom interpreter started" ;
|
|
LOG_INFO( GetEExLogger(), sLua.data())
|
|
// imposto il direttorio delle librerie
|
|
m_LuaMgr.SetLuaLibsDir( m_sBtlLuaLibsDir) ;
|
|
// carico la libreria standard
|
|
m_LuaMgr.Require( m_sBtlLuaLastRequire) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::CreateInfoGroup( void)
|
|
{
|
|
// creo il gruppo sotto la radice
|
|
m_nInfoId = m_pGDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
|
|
if ( m_nInfoId == GDB_ID_NULL)
|
|
return false ;
|
|
// assegno livello di sistema
|
|
m_pGDB->SetLevel( m_nInfoId, GDB_LV_SYSTEM) ;
|
|
// assegno nome
|
|
m_pGDB->SetName( m_nInfoId, INFO_GROUP_NAME) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::CreateAssemblyGroup( void)
|
|
{
|
|
// creo il gruppo sotto la radice
|
|
m_nAsseId = m_pGDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
|
|
if ( m_nAsseId == GDB_ID_NULL)
|
|
return false ;
|
|
// assegno livello di sistema
|
|
m_pGDB->SetLevel( m_nAsseId, GDB_LV_SYSTEM) ;
|
|
// assegno nome
|
|
m_pGDB->SetName( m_nAsseId, ASSEMBLY_GROUP_NAME) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::CreatePart( void)
|
|
{
|
|
// reset identificativi del pezzo precedente
|
|
m_nPartId = GDB_ID_NULL ;
|
|
m_nAuxId = GDB_ID_NULL ;
|
|
m_nBoxId = GDB_ID_NULL ;
|
|
m_nOutsId = GDB_ID_NULL ;
|
|
m_nProcsId = GDB_ID_NULL ;
|
|
m_nSolidsId = GDB_ID_NULL ;
|
|
// default
|
|
m_vtDim = V_NULL ;
|
|
m_nCount = 1 ;
|
|
// creazione nuovo pezzo
|
|
int nPartId = m_pGDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d( m_ptOrig)) ;
|
|
if ( nPartId == GDB_ID_NULL)
|
|
return false ;
|
|
// creo il layer ausiliario (per nome)
|
|
int nAuxId = m_pGDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
|
|
if ( nAuxId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGDB->SetName( nAuxId, AUX_LAYER_NAME) ;
|
|
m_pGDB->SetMaterial( nAuxId, BLACK) ;
|
|
// creo il layer per il box (parallelepipedo)
|
|
int nBoxId = m_pGDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
|
|
if ( nBoxId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGDB->SetName( nBoxId, BOX_LAYER_NAME) ;
|
|
m_pGDB->SetMaterial( nBoxId, m_BoxCol) ;
|
|
// creo il layer per l'outline (eventuali contorni)
|
|
int nOutsId = m_pGDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
|
|
if ( nOutsId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGDB->SetName( nOutsId, OUTLINE_LAYER_NAME) ;
|
|
m_pGDB->SetMaterial( nOutsId, m_OutsCol) ;
|
|
// creo il layer per le lavorazioni (features o processings)
|
|
int nProcsId = m_pGDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
|
|
if ( nProcsId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGDB->SetName( nProcsId, PROCESSINGS_LAYER_NAME) ;
|
|
m_pGDB->SetMaterial( nProcsId, m_ProcsCol) ;
|
|
// creo il layer per il solido
|
|
int nSolidsId = m_pGDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
|
|
if ( nSolidsId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGDB->SetName( nSolidsId, SOLID_LAYER_NAME) ;
|
|
m_pGDB->SetMaterial( nSolidsId, m_SolidCol) ;
|
|
// assegnazione identificativi
|
|
m_nPartId = nPartId ;
|
|
m_nAuxId = nAuxId ;
|
|
m_nBoxId = nBoxId ;
|
|
m_nOutsId = nOutsId ;
|
|
m_nProcsId = nProcsId ;
|
|
m_nSolidsId = nSolidsId ;
|
|
// sistemazioni finali per il solido
|
|
return ResetPartSolid() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::SetPart( int nPartId)
|
|
{
|
|
// se non c'è il DB geometrico, errore
|
|
if ( m_pGDB == nullptr)
|
|
return false ;
|
|
// verifico sia un pezzo valido
|
|
if ( m_pGDB->GetGdbType( nPartId) != GDB_TY_GROUP)
|
|
return false ;
|
|
int nParentId = m_pGDB->GetParentId( nPartId) ;
|
|
if ( nParentId != GDB_ID_ROOT) {
|
|
int nParentLev ;
|
|
if ( ! m_pGDB->GetCalcLevel( nParentId, nParentLev) || nParentLev != GDB_LV_SYSTEM)
|
|
return false ;
|
|
}
|
|
int nAuxId = m_pGDB->GetFirstNameInGroup( nPartId, AUX_LAYER_NAME) ;
|
|
if ( nAuxId == GDB_ID_NULL)
|
|
return false ;
|
|
int nBoxId = m_pGDB->GetFirstNameInGroup( nPartId, BOX_LAYER_NAME) ;
|
|
if ( nBoxId == GDB_ID_NULL)
|
|
return false ;
|
|
int nOutsId = m_pGDB->GetFirstNameInGroup( nPartId, OUTLINE_LAYER_NAME) ;
|
|
if ( nOutsId == GDB_ID_NULL)
|
|
return false ;
|
|
int nProcsId = m_pGDB->GetFirstNameInGroup( nPartId, PROCESSINGS_LAYER_NAME) ;
|
|
if ( nProcsId == GDB_ID_NULL)
|
|
return false ;
|
|
int nSolidsId = m_pGDB->GetFirstNameInGroup( nPartId, SOLID_LAYER_NAME) ;
|
|
if ( nSolidsId == GDB_ID_NULL) {
|
|
// nei vecchi progetti può non esserci, quindi lo creo
|
|
int nOldPartId = m_nPartId ;
|
|
int nOldSolidsId = m_nSolidsId ;
|
|
m_nPartId = nPartId ;
|
|
if ( ! ResetPartSolid()) {
|
|
m_nPartId = nOldPartId ;
|
|
m_nSolidsId = nOldSolidsId ;
|
|
return false ;
|
|
}
|
|
nSolidsId = m_nSolidsId ;
|
|
}
|
|
// assegnazione identificativi
|
|
m_nPartId = nPartId ;
|
|
m_nAuxId = nAuxId ;
|
|
m_nBoxId = nBoxId ;
|
|
m_nOutsId = nOutsId ;
|
|
m_nProcsId = nProcsId ;
|
|
m_nSolidsId = nSolidsId ;
|
|
// recupero dati
|
|
double dLength, dHeight, dWidth ;
|
|
if ( m_pGDB->GetInfo( m_nPartId, IKEY_LENGTH, dLength) &&
|
|
m_pGDB->GetInfo( m_nPartId, IKEY_HEIGHT, dHeight) &&
|
|
m_pGDB->GetInfo( m_nPartId, IKEY_WIDTH, dWidth))
|
|
m_vtDim.Set( dLength, dHeight, dWidth) ;
|
|
else
|
|
m_vtDim = V_NULL ;
|
|
int nCount ;
|
|
if ( m_pGDB->GetInfo( m_nPartId, IKEY_COUNT, nCount))
|
|
m_nCount = nCount ;
|
|
else
|
|
m_nCount = 1 ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::ErasePart( void)
|
|
{
|
|
// se non c'è il DB geometrico o il pezzo corrente, errore
|
|
if ( m_pGDB == nullptr || m_nPartId == GDB_ID_NULL)
|
|
return false ;
|
|
// rimuovo eventuali riferimenti e copie nell'assemblato
|
|
int nAsseBaseRefId = GDB_ID_NULL ;
|
|
if ( m_pGDB->GetInfo( m_nPartId, GDB_SI_LIST, nAsseBaseRefId)) {
|
|
m_pGDB->Erase( nAsseBaseRefId) ;
|
|
int nInd = 1 ;
|
|
int nSouPartId = GDB_ID_NULL ;
|
|
while ( m_pGDB->GetInfo( nAsseBaseRefId + nInd, GDB_SI_SOURCE, nSouPartId) && nSouPartId == m_nPartId) {
|
|
m_pGDB->Erase( nAsseBaseRefId + nInd) ;
|
|
++ nInd ;
|
|
}
|
|
}
|
|
// cancello il pezzo
|
|
m_pGDB->Erase( m_nPartId) ;
|
|
// annullo tutti gli identificativi del pezzo
|
|
m_nPartId = GDB_ID_NULL ;
|
|
m_nAuxId = GDB_ID_NULL ;
|
|
m_nBoxId = GDB_ID_NULL ;
|
|
m_nOutsId = GDB_ID_NULL ;
|
|
m_nProcsId = GDB_ID_NULL ;
|
|
m_nSolidsId = GDB_ID_NULL ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::VerifyNewPartProdNbr( int nProdNbr)
|
|
{
|
|
// se non c'è il DB geometrico, errore
|
|
if ( m_pGDB == nullptr)
|
|
return false ;
|
|
// ciclo su tutti i pezzi
|
|
int nPartId = m_pGDB->GetFirstGroupInGroup( GDB_ID_ROOT) ;
|
|
while ( nPartId != GDB_ID_NULL) {
|
|
int nLev ;
|
|
if ( m_pGDB->GetCalcLevel( nPartId, nLev) && nLev == GDB_LV_USER) {
|
|
int nSN = -1 ;
|
|
// se SN richiesto già esiste, esco con errore
|
|
if ( m_pGDB->GetInfo( nPartId, IKEY_PROD_NBR, nSN) && nSN >= 0 && nProdNbr == nSN)
|
|
return false ;
|
|
}
|
|
nPartId = m_pGDB->GetNextGroup( nPartId) ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::SetPartProdNbr( int nProdNbr, int nPdnErr)
|
|
{
|
|
// se non c'è il DB geometrico o il pezzo corrente, errore
|
|
if ( m_pGDB == nullptr || m_nPartId == GDB_ID_NULL)
|
|
return false ;
|
|
// assegno il numero di produzione del pezzo
|
|
if ( ! m_pGDB->SetInfo( m_nPartId, IKEY_PROD_NBR, nProdNbr))
|
|
return false ;
|
|
// se è correzione
|
|
if ( nPdnErr >= 0)
|
|
m_pGDB->SetInfo( m_nPartId, IKEY_PDN_ERR, nPdnErr) ;
|
|
// costruisco il nome del pezzo
|
|
string sName = ToString( nProdNbr) ;
|
|
if ( nPdnErr >= 0)
|
|
sName += "-X" ;
|
|
string sDes ;
|
|
if ( m_pGDB->GetInfo( m_nPartId, IKEY_NAME, sDes))
|
|
sName += "-" + sDes ;
|
|
// assegnazione del nome al pezzo
|
|
return m_pGDB->SetName( m_nPartId, sName) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::SetPartName( const string& sDes)
|
|
{
|
|
// se non c'è il DB geometrico o il pezzo corrente, errore
|
|
if ( m_pGDB == nullptr || m_nPartId == GDB_ID_NULL)
|
|
return false ;
|
|
// assegno la descrizione
|
|
if ( ! m_pGDB->SetInfo( m_nPartId, IKEY_NAME, sDes))
|
|
return false ;
|
|
// costruisco il nome del pezzo
|
|
int nPdnErr = -1 ;
|
|
m_pGDB->GetInfo( m_nPartId, IKEY_PDN_ERR, nPdnErr) ;
|
|
int nProdNbr = 0 ;
|
|
m_pGDB->GetInfo( m_nPartId, IKEY_PROD_NBR, nProdNbr) ;
|
|
string sName = ToString( nProdNbr) ;
|
|
if ( nPdnErr >= 0)
|
|
sName += "-X" ;
|
|
if ( ! sDes.empty())
|
|
sName += "-" + sDes ;
|
|
// assegnazione del nome al pezzo
|
|
return m_pGDB->SetName( m_nPartId, sName) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
string
|
|
BtlGeom::GetPartName( void)
|
|
{
|
|
// se non c'è il DB geometrico o il pezzo corrente, errore
|
|
if ( m_pGDB == nullptr || m_nPartId == GDB_ID_NULL)
|
|
return "" ;
|
|
string sName ;
|
|
m_pGDB->GetName( m_nPartId, sName) ;
|
|
return sName ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::SetPartCount( int nCount)
|
|
{
|
|
// se non c'è il DB geometrico o il pezzo corrente, errore
|
|
if ( m_pGDB == nullptr || m_nPartId == GDB_ID_NULL)
|
|
return false ;
|
|
m_nCount = nCount ;
|
|
return ( m_pGDB != nullptr && m_pGDB->SetInfo( m_nPartId, IKEY_COUNT, nCount)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::AddPartBox( double dLength, double dHeight, double dWidth)
|
|
{
|
|
// se non c'è il DB geometrico o il pezzo corrente, errore
|
|
if ( m_pGDB == nullptr || m_nPartId == GDB_ID_NULL)
|
|
return false ;
|
|
// creo il solido (parallelepipedo)
|
|
PtrOwner<ISurfTriMesh> pStm( GetSurfTriMeshBox( dLength, dHeight, dWidth)) ;
|
|
if ( IsNull( pStm))
|
|
return false ;
|
|
// recupero eventuale box già presente
|
|
int nOldId = m_pGDB->GetFirstNameInGroup( m_nBoxId, BOX_BOX_NAME) ;
|
|
// se gia presente, lo rimpiazzo
|
|
if ( nOldId != GDB_ID_NULL) {
|
|
if ( ! m_pGDB->ReplaceGeoObj( nOldId, Release( pStm)))
|
|
return false ;
|
|
m_pGDB->SetMaterial( nOldId, m_BoxCol) ;
|
|
}
|
|
// altrimenti, lo inserisco nel layer box del pezzo
|
|
else {
|
|
int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, m_nBoxId, Release( pStm)) ;
|
|
if ( nId == GDB_ID_NULL)
|
|
return false ;
|
|
// assegno nome
|
|
m_pGDB->SetName( nId, BOX_BOX_NAME) ;
|
|
// assegno colore
|
|
m_pGDB->SetMaterial( nId, m_BoxCol) ;
|
|
}
|
|
// salvo in info pezzo le sue dimensioni
|
|
m_pGDB->SetInfo( m_nPartId, IKEY_LENGTH, dLength) ;
|
|
m_pGDB->SetInfo( m_nPartId, IKEY_HEIGHT, dHeight) ;
|
|
m_pGDB->SetInfo( m_nPartId, IKEY_WIDTH, dWidth) ;
|
|
// imposto dimensioni pezzo corrente
|
|
m_vtDim.Set( dLength, dHeight, dWidth) ;
|
|
// se pezzo nuovo
|
|
if ( nOldId == GDB_ID_NULL) {
|
|
// imposto origine
|
|
Frame3d* pRefGrp = m_pGDB->GetGroupFrame( m_nPartId) ;
|
|
if ( pRefGrp != nullptr)
|
|
*pRefGrp = Frame3d( m_ptOrig) ;
|
|
// sistemo il posizionamento
|
|
AdjustPartFlatOrVertPos() ;
|
|
// aggiorno origine per prossimo pezzo
|
|
switch ( m_nFlatVertPos) {
|
|
case 0 :
|
|
m_ptOrig.y += dHeight + PART_OFFSET ;
|
|
break ;
|
|
case 1 :
|
|
case 4 :
|
|
m_ptOrig.y += max( dHeight, dWidth) + PART_OFFSET ;
|
|
break ;
|
|
case 2 :
|
|
m_ptOrig.y += min( dHeight, dWidth) + PART_OFFSET ;
|
|
break ;
|
|
case 3 :
|
|
m_ptOrig.y += dWidth + PART_OFFSET ;
|
|
break ;
|
|
}
|
|
}
|
|
// scrittura del nome sulla superficie del box come testo del layer ausiliario
|
|
string sName ;
|
|
if ( ! m_pGDB->GetName( m_nPartId, sName) || sName.empty())
|
|
sName = "..." ;
|
|
// aggiungo numero di pezzi da produrre
|
|
sName += " - #" + ToString( m_nCount) ;
|
|
// aggiungo dimensioni
|
|
double dDim1 = dLength ;
|
|
double dDim2 = max( dWidth, dHeight) ;
|
|
double dDim3 = min( dWidth, dHeight) ;
|
|
sName += "<br/> (" + ToString( dDim1, 0) + "x" + ToString( dDim2, 0) + "x" + ToString( dDim3, 0) +")" ;
|
|
PtrOwner<IExtText> pText( CreateExtText()) ;
|
|
if ( IsNull( pText))
|
|
return false ;
|
|
int nSide = BTL_SIDE_TOP ;
|
|
if (( m_nFlatVertPos == 1 || m_nFlatVertPos == 4) && m_vtDim.z > m_vtDim.y + EPS_SMALL)
|
|
nSide = BTL_SIDE_FRONT ;
|
|
else if ( m_nFlatVertPos == 2 && m_vtDim.y < m_vtDim.z + EPS_SMALL)
|
|
nSide = BTL_SIDE_FRONT ;
|
|
else if ( m_nFlatVertPos == 3)
|
|
nSide = BTL_SIDE_BACK ;
|
|
double dSideLen = GetSideLength( nSide) ;
|
|
double dSideWidth = GetSideWidth( nSide) ;
|
|
double dTextHeight = 0.1 * min( dSideLen, dSideWidth) ;
|
|
Point3d ptCen( 0.5 * dSideLen, 0.5 * dSideWidth, 0) ;
|
|
if ( ! pText->Set( ptCen, Z_AX, X_AX, sName, "", 100, false, dTextHeight, 1, 0, ETXT_IPMC))
|
|
return false ;
|
|
// eventuale scalatura del testo, se troppo grande
|
|
BBox3d b3Text ;
|
|
if ( pText->GetLocalBBox( b3Text)) {
|
|
double dTextLen = b3Text.GetMax().x - b3Text.GetMin().x ;
|
|
double dTextWidth = b3Text.GetMax().y - b3Text.GetMin().y ;
|
|
if ( dTextLen > 0.5 * dSideLen || dTextWidth > 0.5 * dSideWidth) {
|
|
double dCoeff = min( 0.5 * dSideLen / dTextLen, 0.5 * dSideWidth / dTextWidth) ;
|
|
pText->Scale( Frame3d( ptCen), dCoeff, dCoeff, dCoeff) ;
|
|
}
|
|
}
|
|
// porto il testo nel piano della faccia
|
|
Frame3d frRef = GetSideFrame( nSide) ;
|
|
pText->ToGlob( frRef) ;
|
|
// recupero eventuale nome già presente
|
|
int nOldTextId = m_pGDB->GetFirstNameInGroup( m_nAuxId, AUX_PART_NAME) ;
|
|
// 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, m_nAuxId, Release( pText)) ;
|
|
if ( nTextId == GDB_ID_NULL)
|
|
return false ;
|
|
// assegno nome
|
|
m_pGDB->SetName( nTextId, AUX_PART_NAME) ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::AdjustPartFlatOrVertPos( void)
|
|
{
|
|
// determino come modificare la posizione
|
|
if ( m_nFlatVertPos == 0)
|
|
return true ;
|
|
// recupero il box del pezzo
|
|
BBox3d b3Part ;
|
|
int nBoxId = m_pGDB->GetFirstNameInGroup( m_nPartId, BOX_LAYER_NAME) ;
|
|
if ( nBoxId == GDB_ID_NULL ||
|
|
! m_pGDB->GetGlobalBBox( nBoxId, b3Part))
|
|
return false ;
|
|
// dimensioni pezzo
|
|
Vector3d vtDim = b3Part.GetMax() - b3Part.GetMin() ;
|
|
// se richiesto piatto ed è in verticale, ruoto
|
|
if (( m_nFlatVertPos == 1 || m_nFlatVertPos == 4) && vtDim.z > vtDim.y + EPS_SMALL) {
|
|
Point3d ptAx = b3Part.GetMin() + 0.5 * Vector3d( 0, vtDim.y, vtDim.y) ;
|
|
m_pGDB->RotateGlob( m_nPartId, ptAx, X_AX, 0, -1) ;
|
|
}
|
|
// se richiesto in verticale ed è piatto, ruoto
|
|
else if ( m_nFlatVertPos == 2 && vtDim.y > vtDim.z + EPS_SMALL) {
|
|
Point3d ptAx = b3Part.GetMin() + 0.5 * Vector3d( 0, vtDim.z, vtDim.z) ;
|
|
m_pGDB->RotateGlob( m_nPartId, ptAx, X_AX, 0, 1) ;
|
|
}
|
|
// se richiesto come TechnoEssetre devo sempre ruotare di 90deg
|
|
else if (m_nFlatVertPos == 3) {
|
|
Point3d ptAx = b3Part.GetMin() + 0.5 * Vector3d( 0, vtDim.z, vtDim.z) ;
|
|
m_pGDB->RotateGlob( m_nPartId, ptAx, X_AX, 0, 1) ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::ReadUserAttribute( const string& sString, string& sKey, string& sVal)
|
|
{
|
|
// recupero chiave e valore
|
|
SplitFirst( sString, ":", sKey, sVal) ;
|
|
// elimino i doppi apici
|
|
Trim( sKey, " \"") ;
|
|
Trim( sVal, " \"") ;
|
|
// verifico
|
|
return ( ! IsEmptyOrSpaces( sKey)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::SetUserAttribute( int nUAttrDest, const string& sString)
|
|
{
|
|
// se non c'è il DB geometrico, errore
|
|
if ( m_pGDB == nullptr)
|
|
return false ;
|
|
// recupero chiave e valore
|
|
string sKey, sVal ;
|
|
if ( ! ReadUserAttribute( sString, sKey, sVal))
|
|
return false ;
|
|
// li assegno
|
|
if ( nUAttrDest == UATD_PART)
|
|
return ( m_pGDB->SetInfo( m_nPartId, sKey, sVal)) ;
|
|
else
|
|
return ( m_pGDB->SetInfo( m_nInfoId, sKey, sVal)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::SetUserAttribute( int nUAttrDest, const string& sKey, const string& sVal)
|
|
{
|
|
// se non c'è il DB geometrico, errore
|
|
if ( m_pGDB == nullptr)
|
|
return false ;
|
|
// li assegno
|
|
if ( nUAttrDest == UATD_PART)
|
|
return ( m_pGDB->SetInfo( m_nPartId, sKey, sVal)) ;
|
|
else
|
|
return ( m_pGDB->SetInfo( m_nInfoId, sKey, sVal)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::AddPartTransformation( const string& sUID, const Frame3d& frRef)
|
|
{
|
|
// creo un nuovo gruppo nell'assemblaggio
|
|
int nId = m_pGDB->AddGroup( GDB_ID_NULL, m_nAsseId, frRef) ;
|
|
if ( nId == GDB_ID_NULL)
|
|
return false ;
|
|
// assegno Nome con UID
|
|
m_pGDB->SetName( nId, "UID-" + sUID) ;
|
|
// assegno Id pezzo istanziato
|
|
m_pGDB->SetInfo( nId, GDB_SI_SOURCE, m_nPartId) ;
|
|
// nascondo e blocco
|
|
m_pGDB->SetStatus( nId, GDB_ST_OFF) ;
|
|
m_pGDB->SetMode( nId, GDB_MD_LOCKED) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::AddObjectRef( const string& sUID, const Frame3d& frRef)
|
|
{
|
|
// creo un nuovo gruppo nel pezzo
|
|
int nId = m_pGDB->AddGroup( GDB_ID_NULL, m_nPartId, frRef) ;
|
|
if ( nId == GDB_ID_NULL)
|
|
return false ;
|
|
// assegno Nome con UID
|
|
m_pGDB->SetName( nId, "UID-" + sUID) ;
|
|
// non posso ancora assegnare Id pezzo istanziato
|
|
// nascondo e blocco
|
|
m_pGDB->SetStatus( nId, GDB_ST_OFF) ;
|
|
m_pGDB->SetMode( nId, GDB_MD_LOCKED) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::AddPartOffset( const DBLVECTOR& vdPar)
|
|
{
|
|
// se non c'è il DB geometrico o il pezzo corrente, errore
|
|
if ( m_pGDB == nullptr || m_nPartId == GDB_ID_NULL)
|
|
return false ;
|
|
// recupero le dimensioni del pezzo corrente
|
|
if ( m_vtDim.IsSmall())
|
|
return false ;
|
|
// se non abilitato, esco
|
|
if ( ! m_bPartOffset)
|
|
return true ;
|
|
// aggiusto i solidi di rappresentazione dell'offset
|
|
for ( int i = 1 ; i <= 4 ; ++ i) {
|
|
string sOffsName = BOX_OFFSX_NAME + ToString( i) ;
|
|
int nOffsId = m_pGDB->GetFirstNameInGroup( m_nBoxId, sOffsName) ;
|
|
// se valore offset significativo, modifico o aggiungo nuovo solido
|
|
if ( vdPar[i] > EPS_SMALL) {
|
|
double dDimX = m_vtDim.x ;
|
|
double dDimY = (( i == 1 || i == 3) ? vdPar[i] : m_vtDim.y) ;
|
|
double dDimZ = (( i == 1 || i == 3) ? m_vtDim.z : vdPar[i]) ;
|
|
// creo il solido (parallelepipedo)
|
|
PtrOwner<ISurfTriMesh> pStm( GetSurfTriMeshBox( dDimX, dDimY, dDimZ)) ;
|
|
if ( IsNull( pStm))
|
|
return false ;
|
|
// lo traslo opportunamente
|
|
Vector3d vtMove ;
|
|
if ( i == 1)
|
|
vtMove = Vector3d( 0, -vdPar[i], 0) ;
|
|
else if ( i == 2)
|
|
vtMove = Vector3d( 0, 0, -vdPar[i]) ;
|
|
else if ( i == 3)
|
|
vtMove = Vector3d( 0, m_vtDim.y, 0) ;
|
|
else
|
|
vtMove = Vector3d( 0, 0, m_vtDim.z) ;
|
|
pStm->Translate( vtMove) ;
|
|
// se gia presente, lo rimpiazzo
|
|
if ( nOffsId != GDB_ID_NULL) {
|
|
if ( ! m_pGDB->ReplaceGeoObj( nOffsId, Release( pStm)))
|
|
return false ;
|
|
}
|
|
// altrimenti, lo inserisco nel layer box del pezzo
|
|
else {
|
|
nOffsId = m_pGDB->AddGeoObj( GDB_ID_NULL, m_nBoxId, Release( pStm)) ;
|
|
if ( nOffsId == GDB_ID_NULL)
|
|
return false ;
|
|
// assegno nome
|
|
m_pGDB->SetName( nOffsId, sOffsName) ;
|
|
}
|
|
// assegno il colore
|
|
m_pGDB->SetMaterial( nOffsId, m_OffsCol) ;
|
|
}
|
|
// elimino eventuale vecchio solido
|
|
else {
|
|
m_pGDB->Erase( nOffsId) ;
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::ResetPartSolid( void)
|
|
{
|
|
if ( m_pGDB == nullptr)
|
|
return false ;
|
|
if ( m_nPartId == GDB_ID_NULL)
|
|
return false ;
|
|
if ( ! m_pGDB->ExistsObj( m_nSolidsId)) {
|
|
int nSolidsId = m_pGDB->AddGroup( GDB_ID_NULL, m_nPartId, Frame3d()) ;
|
|
if ( nSolidsId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGDB->SetName( nSolidsId, SOLID_LAYER_NAME) ;
|
|
m_pGDB->SetMaterial( nSolidsId, m_SolidCol) ;
|
|
m_nSolidsId = nSolidsId ;
|
|
}
|
|
int nSolidId = m_pGDB->GetFirstNameInGroup( m_nSolidsId, SOLID_SOLID_NAME) ;
|
|
PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
|
|
if ( IsNull( pStm) || ! pStm->Init( 3, 1) || ! pStm->AdjustTopology())
|
|
return false ;
|
|
if ( nSolidId != GDB_ID_NULL) {
|
|
if ( ! m_pGDB->ReplaceGeoObj( nSolidId, Release( pStm)))
|
|
return false ;
|
|
m_pGDB->RemoveInfo( nSolidId, IKEY_VALID) ;
|
|
}
|
|
else {
|
|
int nNewId = m_pGDB->AddGeoObj( GDB_ID_NULL, m_nSolidsId, Release( pStm)) ;
|
|
if ( nNewId == GDB_ID_NULL)
|
|
return false ;
|
|
m_pGDB->SetName( nNewId, SOLID_SOLID_NAME) ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::IsTrueSide( int nSide) const
|
|
{
|
|
return ( nSide >= BTL_SIDE_FRONT && nSide <= BTL_SIDE_TOP) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
string
|
|
BtlGeom::GetOutlineOutName( int nSide) const
|
|
{
|
|
return ( ToString( nSide) + "-" + OL_OUTSTM_NAME) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
string
|
|
BtlGeom::GetOutlineApertureName( int nSide) const
|
|
{
|
|
return ( ToString( nSide) + "-" + OL_APERTURESTM_NAME) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
string
|
|
BtlGeom::GetOutlineTopName( int nSide) const
|
|
{
|
|
return ( ToString( nSide) + "-" + OL_TOPREGION_NAME) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
string
|
|
BtlGeom::GetOutlineBottomName( int nSide) const
|
|
{
|
|
return ( ToString( nSide) + "-" + OL_BOTTOMREGION_NAME) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
double
|
|
BtlGeom::GetSideLength( int nSide) const
|
|
{
|
|
switch ( nSide) {
|
|
case BTL_SIDE_FRONT :
|
|
case BTL_SIDE_BACK :
|
|
case BTL_SIDE_TOP :
|
|
case BTL_SIDE_BOTTOM :
|
|
return m_vtDim.x ;
|
|
case BTL_SIDE_LEFT :
|
|
case BTL_SIDE_RIGHT :
|
|
return m_vtDim.z ;
|
|
}
|
|
return 0 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
double
|
|
BtlGeom::GetSideWidth( int nSide) const
|
|
{
|
|
switch ( nSide) {
|
|
case BTL_SIDE_FRONT :
|
|
case BTL_SIDE_BACK :
|
|
return m_vtDim.z ;
|
|
case BTL_SIDE_TOP :
|
|
case BTL_SIDE_BOTTOM :
|
|
case BTL_SIDE_LEFT :
|
|
case BTL_SIDE_RIGHT :
|
|
return m_vtDim.y ;
|
|
}
|
|
return 0 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
double
|
|
BtlGeom::GetSideHeight( int nSide) const
|
|
{
|
|
switch ( nSide) {
|
|
case BTL_SIDE_FRONT :
|
|
case BTL_SIDE_BACK :
|
|
return m_vtDim.y ;
|
|
case BTL_SIDE_TOP :
|
|
case BTL_SIDE_BOTTOM :
|
|
return m_vtDim.z ;
|
|
case BTL_SIDE_LEFT :
|
|
case BTL_SIDE_RIGHT :
|
|
return m_vtDim.x ;
|
|
}
|
|
return 0 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Frame3d
|
|
BtlGeom::GetSideFrame( int nSide) const
|
|
{
|
|
Frame3d frRef ;
|
|
switch ( nSide) {
|
|
case BTL_SIDE_FRONT :
|
|
frRef.Set( Point3d( 0, 0, 0), X_AX, Z_AX, -Y_AX) ;
|
|
break ;
|
|
case BTL_SIDE_BOTTOM :
|
|
frRef.Set( Point3d( 0, m_vtDim.y, 0), X_AX, -Y_AX, -Z_AX) ;
|
|
break ;
|
|
case BTL_SIDE_BACK :
|
|
frRef.Set( Point3d( 0, m_vtDim.y, m_vtDim.z), X_AX, -Z_AX, Y_AX) ;
|
|
break ;
|
|
case BTL_SIDE_TOP :
|
|
frRef.Set( Point3d( 0, 0, m_vtDim.z), X_AX, Y_AX, Z_AX) ;
|
|
break ;
|
|
case BTL_SIDE_LEFT :
|
|
frRef.Set( Point3d( 0, 0, 0), Z_AX, Y_AX, -X_AX) ;
|
|
break ;
|
|
case BTL_SIDE_RIGHT :
|
|
frRef.Set( Point3d( m_vtDim.x, m_vtDim.y, 0), Z_AX, -Y_AX, X_AX) ;
|
|
break ;
|
|
}
|
|
return frRef ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Plane3d
|
|
BtlGeom::GetSidePlane( int nSide) const
|
|
{
|
|
Plane3d plPlane ;
|
|
switch ( nSide) {
|
|
case BTL_SIDE_FRONT :
|
|
plPlane.Set( 0, -Y_AX) ;
|
|
break ;
|
|
case BTL_SIDE_BOTTOM :
|
|
plPlane.Set( 0, -Z_AX) ;
|
|
break ;
|
|
case BTL_SIDE_BACK :
|
|
plPlane.Set( m_vtDim.y, Y_AX) ;
|
|
break ;
|
|
case BTL_SIDE_TOP :
|
|
plPlane.Set( m_vtDim.z, Z_AX) ;
|
|
break ;
|
|
case BTL_SIDE_LEFT :
|
|
plPlane.Set( 0, -X_AX) ;
|
|
break ;
|
|
case BTL_SIDE_RIGHT :
|
|
plPlane.Set( m_vtDim.x, X_AX) ;
|
|
break ;
|
|
default :
|
|
plPlane.Reset() ;
|
|
break ;
|
|
}
|
|
return plPlane ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
Vector3d
|
|
BtlGeom::GetSideVersN( int nSide) const
|
|
{
|
|
switch ( nSide) {
|
|
case BTL_SIDE_FRONT :
|
|
return - Y_AX ;
|
|
case BTL_SIDE_BOTTOM :
|
|
return - Z_AX ;
|
|
case BTL_SIDE_BACK :
|
|
return Y_AX ;
|
|
case BTL_SIDE_TOP :
|
|
return Z_AX ;
|
|
case BTL_SIDE_LEFT :
|
|
return - X_AX ;
|
|
case BTL_SIDE_RIGHT :
|
|
return X_AX ;
|
|
}
|
|
return V_NULL ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
BtlGeom::GetOppositeSide( int nSide) const
|
|
{
|
|
switch ( nSide) {
|
|
case BTL_SIDE_FRONT :
|
|
return BTL_SIDE_BACK ;
|
|
case BTL_SIDE_TOP :
|
|
return BTL_SIDE_BOTTOM ;
|
|
case BTL_SIDE_BACK :
|
|
return BTL_SIDE_FRONT ;
|
|
case BTL_SIDE_BOTTOM :
|
|
return BTL_SIDE_TOP ;
|
|
case BTL_SIDE_LEFT :
|
|
return BTL_SIDE_RIGHT ;
|
|
case BTL_SIDE_RIGHT :
|
|
return BTL_SIDE_LEFT ;
|
|
}
|
|
return BTL_SIDE_NONE ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::SetAlpha( int nId, int nAlpha)
|
|
{
|
|
Color cCol ;
|
|
if ( ! m_pGDB->GetCalcMaterial( nId, cCol))
|
|
return false ;
|
|
if ( nAlpha < ALPHA_LIM)
|
|
m_pGDB->SetInfo( nId, IKEY_COL_A, nAlpha) ;
|
|
else
|
|
m_pGDB->RemoveInfo( nId, IKEY_COL_A) ;
|
|
cCol.SetAlpha( nAlpha) ;
|
|
return m_pGDB->SetMaterial( nId, cCol) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::AdjustSnForParts( void)
|
|
{
|
|
// tabella Id-SN dei pezzi e massimo SN trovato
|
|
INTINTVECTOR vIdSN ;
|
|
int nMaxSN = 0 ;
|
|
|
|
// recupero il numero di serie di ogni singolo pezzo
|
|
int nPartId = m_pGDB->GetFirstGroupInGroup( GDB_ID_ROOT) ;
|
|
while ( nPartId != GDB_ID_NULL) {
|
|
int nLev ;
|
|
if ( m_pGDB->GetCalcLevel( nPartId, nLev) && nLev == GDB_LV_USER) {
|
|
int nSN = 0 ;
|
|
m_pGDB->GetInfo( nPartId, IKEY_PROD_NBR, nSN) ;
|
|
if ( nSN <= 0)
|
|
nSN = 0 ;
|
|
else if ( find_if( vIdSN.begin(), vIdSN.end(),
|
|
[&]( const INTINT& Data) { return Data.second == nSN ; }) != vIdSN.end())
|
|
nSN = -abs( nSN) ;
|
|
vIdSN.emplace_back( nPartId, nSN) ;
|
|
nMaxSN = max( nMaxSN, nSN) ;
|
|
}
|
|
nPartId = m_pGDB->GetNextGroup( nPartId) ;
|
|
}
|
|
|
|
// aggiusto tutti gli SN nulli o negativi (derivano da mancanti o ripetuti)
|
|
for ( auto& Data : vIdSN) {
|
|
if ( Data.second <= 0) {
|
|
SetPart( Data.first) ;
|
|
SetPartProdNbr( ++ nMaxSN, -Data.second) ;
|
|
AddPartBox( GetCurrPartLength(), GetCurrPartHeight(), GetCurrPartWidth()) ;
|
|
Data.second = nMaxSN ;
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::SortObjects( int nGroupId, Point3d& ptIns)
|
|
{
|
|
// verifico gruppo
|
|
if ( nGroupId == GDB_ID_NULL || ! m_pGDB->ExistsObj( nGroupId))
|
|
return true ;
|
|
|
|
// tabella Id-SN dei pezzi
|
|
INTINTVECTOR vIdSN ;
|
|
|
|
// recupero il numero di serie di ogni singolo pezzo
|
|
int nPartId = m_pGDB->GetFirstGroupInGroup( nGroupId) ;
|
|
while ( nPartId != GDB_ID_NULL) {
|
|
int nLev ;
|
|
if ( m_pGDB->GetCalcLevel( nPartId, nLev) && ( nLev == GDB_LV_USER || nGroupId != GDB_ID_ROOT)) {
|
|
int nSN = 0 ;
|
|
m_pGDB->GetInfo( nPartId, IKEY_PROD_NBR, nSN) ;
|
|
vIdSN.emplace_back( nPartId, nSN) ;
|
|
}
|
|
nPartId = m_pGDB->GetNextGroup( nPartId) ;
|
|
}
|
|
|
|
// ordino la tabella secondo SN
|
|
sort( vIdSN.begin(), vIdSN.end(), []( const INTINT& a, const INTINT& b)
|
|
{ return a.second < b.second ; }) ;
|
|
|
|
// cambio posizione dei pezzi nel DB come da ordine in tabella
|
|
for ( int i = 0 ; i < int( vIdSN.size()) ; ++ i) {
|
|
m_pGDB->Relocate( vIdSN[i].first, nGroupId, GDB_LAST_SON) ;
|
|
BBox3d b3Part ;
|
|
int nBoxId = m_pGDB->GetFirstNameInGroup( vIdSN[i].first, BOX_LAYER_NAME) ;
|
|
m_pGDB->GetGlobalBBox( nBoxId, b3Part) ;
|
|
m_pGDB->Translate( vIdSN[i].first, ptIns - b3Part.GetMin()) ;
|
|
ptIns += Vector3d( 0, b3Part.GetMax().y - b3Part.GetMin().y + PART_OFFSET, 0) ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::UpdateNextOrigin( void)
|
|
{
|
|
// ricerco il pezzo più lontano
|
|
double dMaxY = 0 ;
|
|
int nMaxPartId = GDB_ID_NULL ;
|
|
int nPartId = m_pGDB->GetFirstGroupInGroup( GDB_ID_ROOT) ;
|
|
while ( nPartId != GDB_ID_NULL) {
|
|
int nLev ;
|
|
if ( m_pGDB->GetCalcLevel( nPartId, nLev) && nLev == GDB_LV_USER) {
|
|
// recupero il box del pezzo
|
|
BBox3d b3Part ;
|
|
int nBoxId = m_pGDB->GetFirstNameInGroup( m_pGDB->GetFirstNameInGroup( nPartId, BOX_LAYER_NAME), BOX_BOX_NAME) ;
|
|
if ( nBoxId != GDB_ID_NULL)
|
|
m_pGDB->GetGlobalBBox( nBoxId, b3Part, BBF_STANDARD) ;
|
|
else
|
|
m_pGDB->GetGlobalBBox( nPartId, b3Part, BBF_STANDARD) ;
|
|
if ( ! b3Part.IsEmpty()) {
|
|
if ( nMaxPartId == GDB_ID_NULL || b3Part.GetMax().y > dMaxY) {
|
|
dMaxY = b3Part.GetMax().y ;
|
|
nMaxPartId = nPartId ;
|
|
}
|
|
}
|
|
}
|
|
nPartId = m_pGDB->GetNextGroup( nPartId) ;
|
|
}
|
|
|
|
// aggiorno l'origine per il prossimo inserimento
|
|
if ( nMaxPartId != GDB_ID_NULL) {
|
|
// assegno la nuova origine
|
|
m_ptOrig = ORIG ;
|
|
m_ptOrig.y = dMaxY + PART_OFFSET ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
BtlGeom::GetRawPartsGroup( bool bCreate)
|
|
{
|
|
// se non necessaria creazione ritorno quello che trovo
|
|
if ( ! bCreate || m_nRawPartsId != GDB_ID_NULL)
|
|
return m_nRawPartsId ;
|
|
// creo il gruppo
|
|
CreateRawPartsGroup() ;
|
|
return m_nRawPartsId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::CreateRawPartsGroup( void)
|
|
{
|
|
// se già definito, non faccio alcunchè
|
|
m_nRawPartsId = m_pGDB->GetFirstNameInGroup( GDB_ID_ROOT, RAWPARTS_GROUP_NAME) ;
|
|
if ( m_nRawPartsId != GDB_ID_NULL)
|
|
return true ;
|
|
// creo il gruppo sotto la radice
|
|
m_nRawPartsId = m_pGDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
|
|
if ( m_nRawPartsId == GDB_ID_NULL)
|
|
return false ;
|
|
// assegno livello di sistema
|
|
m_pGDB->SetLevel( m_nRawPartsId, GDB_LV_SYSTEM) ;
|
|
// assegno nome
|
|
m_pGDB->SetName( m_nRawPartsId, RAWPARTS_GROUP_NAME) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::AdjustRawPart( int nRawPartId)
|
|
{
|
|
// verifico validità pezzo
|
|
if ( nRawPartId == GDB_ID_NULL || ! m_pGDB->ExistsObj( nRawPartId))
|
|
return false ;
|
|
// cerco il gruppo dei grezzi in cui spostarlo
|
|
int nRpsGroupId = GetRawPartsGroup( true) ;
|
|
if ( nRpsGroupId == GDB_ID_NULL)
|
|
return false ;
|
|
// lo sposto e lo nascondo
|
|
return m_pGDB->Relocate( nRawPartId, nRpsGroupId) && m_pGDB->SetStatus( nRawPartId, GDB_ST_OFF) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::AdjustRefForRawParts( void)
|
|
{
|
|
// verifico esistenza gruppo dei grezzi
|
|
int nRpsGroupId = GetRawPartsGroup() ;
|
|
if ( nRpsGroupId == GDB_ID_NULL)
|
|
return true ;
|
|
|
|
// tabella Id-UID dei pezzi
|
|
std::unordered_map< int, int> umUIDId ;
|
|
int nPartId = m_pGDB->GetFirstGroupInGroup( GDB_ID_ROOT) ;
|
|
while ( nPartId != GDB_ID_NULL) {
|
|
int nLev ;
|
|
if ( m_pGDB->GetCalcLevel( nPartId, nLev) && nLev == GDB_LV_USER) {
|
|
for ( int i = 1 ; ; ++ i) {
|
|
int nUID ;
|
|
string sUIDKey = "UID" + ToString( i) ;
|
|
if ( ! m_pGDB->GetInfo( nPartId, sUIDKey, nUID))
|
|
break ;
|
|
umUIDId.emplace( nUID, nPartId) ;
|
|
}
|
|
}
|
|
nPartId = m_pGDB->GetNextGroup( nPartId) ;
|
|
}
|
|
|
|
// assegno riferimenti nei grezzi
|
|
int nRawPartId = m_pGDB->GetFirstGroupInGroup( nRpsGroupId) ;
|
|
while ( nRawPartId != GDB_ID_NULL) {
|
|
int nRefId = m_pGDB->GetFirstNameInGroup( nRawPartId, "UID-*") ;
|
|
while ( nRefId != GDB_ID_NULL) {
|
|
string sName ; m_pGDB->GetName( nRefId, sName) ;
|
|
int nUID ;
|
|
if ( FromString( sName.substr( 4), nUID)) {
|
|
auto Iter = umUIDId.find( nUID) ;
|
|
if ( Iter != umUIDId.end())
|
|
m_pGDB->SetInfo( nRefId, GDB_SI_SOURCE, Iter->second) ;
|
|
}
|
|
nRefId = m_pGDB->GetNextName( nRefId, "UID-*") ;
|
|
}
|
|
nRawPartId = m_pGDB->GetNextGroup( nRawPartId) ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
BtlGeom::GetCompositesGroup( bool bCreate)
|
|
{
|
|
// se non necessaria creazione ritorno quello che trovo
|
|
if ( ! bCreate || m_nCompositesId != GDB_ID_NULL)
|
|
return m_nCompositesId ;
|
|
// creo il gruppo
|
|
CreateCompositesGroup() ;
|
|
return m_nCompositesId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::CreateCompositesGroup( void)
|
|
{
|
|
// se già definito, non faccio alcunchè
|
|
m_nCompositesId = m_pGDB->GetFirstNameInGroup( GDB_ID_ROOT, COMPOSITES_GROUP_NAME) ;
|
|
if ( m_nCompositesId != GDB_ID_NULL)
|
|
return true ;
|
|
// creo il gruppo sotto la radice
|
|
m_nCompositesId = m_pGDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
|
|
if ( m_nCompositesId == GDB_ID_NULL)
|
|
return false ;
|
|
// assegno livello di sistema
|
|
m_pGDB->SetLevel( m_nCompositesId, GDB_LV_SYSTEM) ;
|
|
// assegno nome
|
|
m_pGDB->SetName( m_nCompositesId, COMPOSITES_GROUP_NAME) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::AdjustComposite( int nCompositeId)
|
|
{
|
|
// verifico validità pezzo
|
|
if ( nCompositeId == GDB_ID_NULL || ! m_pGDB->ExistsObj( nCompositeId))
|
|
return false ;
|
|
// cerco il gruppo dei compositi in cui spostarlo
|
|
int nCmpGroupId = GetCompositesGroup( true) ;
|
|
if ( nCmpGroupId == GDB_ID_NULL)
|
|
return false ;
|
|
// lo sposto e lo nascondo
|
|
return m_pGDB->Relocate( nCompositeId, nCmpGroupId) && m_pGDB->SetStatus( nCompositeId, GDB_ST_OFF) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
BtlGeom::AdjustRefForComposites( void)
|
|
{
|
|
// verifico esistenza gruppo dei compositi
|
|
int nCmpsGroupId = GetCompositesGroup() ;
|
|
if ( nCmpsGroupId == GDB_ID_NULL)
|
|
return true ;
|
|
|
|
// tabella Id-UID dei pezzi e dei compositi
|
|
std::unordered_map< int, int> umUIDId ;
|
|
int nPartId = m_pGDB->GetFirstGroupInGroup( GDB_ID_ROOT) ;
|
|
while ( nPartId != GDB_ID_NULL) {
|
|
int nLev ;
|
|
if ( m_pGDB->GetCalcLevel( nPartId, nLev) && nLev == GDB_LV_USER) {
|
|
for ( int i = 1 ; ; ++ i) {
|
|
int nUID ;
|
|
string sUIDKey = "UID" + ToString( i) ;
|
|
if ( ! m_pGDB->GetInfo( nPartId, sUIDKey, nUID))
|
|
break ;
|
|
umUIDId.emplace( nUID, nPartId) ;
|
|
}
|
|
}
|
|
nPartId = m_pGDB->GetNextGroup( nPartId) ;
|
|
}
|
|
int nCompoId = m_pGDB->GetFirstGroupInGroup( nCmpsGroupId) ;
|
|
while ( nCompoId != GDB_ID_NULL) {
|
|
int nLev ;
|
|
if ( m_pGDB->GetCalcLevel( nCompoId, nLev) && nLev != GDB_LV_USER) {
|
|
for ( int i = 1 ; ; ++ i) {
|
|
int nUID ;
|
|
string sUIDKey = "UID" + ToString( i) ;
|
|
if ( ! m_pGDB->GetInfo( nCompoId, sUIDKey, nUID))
|
|
break ;
|
|
umUIDId.emplace( nUID, nCompoId) ;
|
|
}
|
|
}
|
|
nCompoId = m_pGDB->GetNextGroup( nCompoId) ;
|
|
}
|
|
|
|
// assegno riferimenti nei compositi
|
|
int nCompositeId = m_pGDB->GetFirstGroupInGroup( nCmpsGroupId) ;
|
|
while ( nCompositeId != GDB_ID_NULL) {
|
|
int nRefId = m_pGDB->GetFirstNameInGroup( nCompositeId, "UID-*") ;
|
|
while ( nRefId != GDB_ID_NULL) {
|
|
string sName ; m_pGDB->GetName( nRefId, sName) ;
|
|
int nUID ;
|
|
if ( FromString( sName.substr( 4), nUID)) {
|
|
auto Iter = umUIDId.find( nUID) ;
|
|
if ( Iter != umUIDId.end())
|
|
m_pGDB->SetInfo( nRefId, GDB_SI_SOURCE, Iter->second) ;
|
|
}
|
|
nRefId = m_pGDB->GetNextName( nRefId, "UID-*") ;
|
|
}
|
|
nCompositeId = m_pGDB->GetNextGroup( nCompositeId) ;
|
|
}
|
|
|
|
return true ;
|
|
}
|