EgtExecutor 1.6h1 :
- CurveCompoByChain salva in info elenco id curve originali se non deve cancellarle - ExeCreateSurfTmByRegion e ExeCreateSurfTmByExtrusion accettano anche curve da selezione - ExeApproxCurve sostituisce in-place la curva originale - su Part e Layer ora si può iterare all'indietro dalla fine(GetLast e GetPrev) - aggiunta prima versione di import pezzi per nesting.
This commit is contained in:
Dario Sassi
+524
@@ -0,0 +1,524 @@
|
||||
//----------------------------------------------------------------------------
|
||||
// EgalTech 2015-2015
|
||||
//----------------------------------------------------------------------------
|
||||
// File : EXE_Nesting.cpp Data : 20.09.14 Versione : 1.6e1
|
||||
// Contenuto : Funzioni Nesting per EXE.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Modifiche : 20.09.14 DS Creazione modulo.
|
||||
//
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
//--------------------------- Include ----------------------------------------
|
||||
#include "stdafx.h"
|
||||
#include "EXE.h"
|
||||
#include "EXE_Macro.h"
|
||||
#include "/EgtDev/Include/EXeExecutor.h"
|
||||
#include "/EgtDev/Include/EXeConst.h"
|
||||
#include "/EgtDev/Include/EGkCurveComposite.h"
|
||||
#include "/EgtDev/Include/EGkIntersCurves.h"
|
||||
#include "/EgtDev/Include/EGkStmFromCurves.h"
|
||||
#include "/EgtDev/Include/EGkGdbIterator.h"
|
||||
#include "/EgtDev/Include/EGkIntervals.h"
|
||||
#include "/EgtDev/Include/EgtPointerOwner.h"
|
||||
|
||||
using namespace std ;
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
static bool
|
||||
ApproxCurveIfNeeded( IGdbIterator* pEnt)
|
||||
{
|
||||
const double LIN_TOL_STD = 0.25 ;
|
||||
const double ANG_TOL_STD_DEG = 15 ;
|
||||
const double LIN_FEA_STD = 20 ;
|
||||
// deve essere una curva
|
||||
int nGeoType = pEnt->GetGeoType() ;
|
||||
if ( (nGeoType & GEO_CURVE) == 0)
|
||||
return false ;
|
||||
// verifico se da approssimare
|
||||
if ( nGeoType == CRV_LINE || nGeoType == CRV_ARC)
|
||||
return true ;
|
||||
else if ( nGeoType == CRV_COMPO) {
|
||||
ICurveComposite* pCrvCo = GetCurveComposite( pEnt->GetGeoObj()) ;
|
||||
double dLen ;
|
||||
pCrvCo->GetLength( dLen) ;
|
||||
int nCrvs = pCrvCo->GetCurveNumber() ;
|
||||
if ( nCrvs <= 5 && dLen > nCrvs * LIN_FEA_STD)
|
||||
return true ;
|
||||
}
|
||||
// esecuzione dell'approssimazione
|
||||
ICurve* pCrv = GetCurve( pEnt->GetGeoObj()) ;
|
||||
PtrOwner<ICurveComposite> pCC( CreateCurveComposite()) ;
|
||||
PolyArc PA ;
|
||||
bool bOk = pCrv->ApproxWithArcsEx( LIN_TOL_STD, ANG_TOL_STD_DEG, LIN_FEA_STD, PA) && pCC->FromPolyArc( PA) ;
|
||||
bOk = bOk && pEnt->GetGDB()->ReplaceGeoObj( pEnt->GetId(), Release( pCC)) ;
|
||||
return bOk ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
static bool
|
||||
FilterAndApprox( void)
|
||||
{
|
||||
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
||||
VERIFY_GEOMDB( pGeomDB, false)
|
||||
// preparo gli iteratori
|
||||
PtrOwner<IGdbIterator> pPar( CreateGdbIterator( pGeomDB)) ;
|
||||
PtrOwner<IGdbIterator> pLay( CreateGdbIterator( pGeomDB)) ;
|
||||
PtrOwner<IGdbIterator> pEnt( CreateGdbIterator( pGeomDB)) ;
|
||||
if ( IsNull( pPar) || IsNull( pLay) || IsNull( pEnt))
|
||||
return false ;
|
||||
// ciclo su tutti gli oggetti del DB geometrico
|
||||
bool bPok = pPar->GoToFirstInGroup( GDB_ID_ROOT) ;
|
||||
while ( bPok) {
|
||||
// sotto la radice sono ammessi solo gruppi di livello User -> Pezzi
|
||||
int nLev ;
|
||||
if ( pPar->GetGdbType() != GDB_TY_GROUP ||
|
||||
! pPar->GetCalcLevel( nLev) || nLev != GDB_LV_USER) {
|
||||
bPok = pPar->EraseAndGoToNext() ;
|
||||
continue ;
|
||||
}
|
||||
// ciclo su tutti gli oggetti del pezzo
|
||||
bool bLok = pLay->GoToFirstInGroup( *Get( pPar)) ;
|
||||
while ( bLok) {
|
||||
// sotto ogni pezzo sono ammessi solo gruppi di livello User -> Layer
|
||||
int nLev ;
|
||||
if ( pLay->GetGdbType() != GDB_TY_GROUP ||
|
||||
! pLay->GetCalcLevel( nLev) || nLev != GDB_LV_USER) {
|
||||
bLok = pLay->EraseAndGoToNext() ;
|
||||
continue ;
|
||||
}
|
||||
// ciclo su tutti gli oggetti del layer
|
||||
bool bEok = pEnt->GoToFirstInGroup( *Get( pLay)) ;
|
||||
while ( bEok) {
|
||||
// sotto ogni layer sono ammesse solo curve di livello User
|
||||
int nLev ;
|
||||
if ( ( pEnt->GetGeoType() & GEO_CURVE) == 0 ||
|
||||
! pEnt->GetCalcLevel( nLev) || nLev != GDB_LV_USER) {
|
||||
bEok = pEnt->EraseAndGoToNext() ;
|
||||
continue ;
|
||||
}
|
||||
// eventuale approx della curva se Bezier o Composita con molti piccoli segmenti
|
||||
ApproxCurveIfNeeded( Get( pEnt)) ;
|
||||
// passo alla successiva entità
|
||||
bEok = pEnt->GoToNext() ;
|
||||
}
|
||||
// passo al successivo layer
|
||||
bLok = pLay->GoToNext() ;
|
||||
}
|
||||
// passo al successivo pezzo
|
||||
bPok = pPar->GoToNext() ;
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
static bool
|
||||
ChainCurves( int& nLay)
|
||||
{
|
||||
// seleziono tutte le curve
|
||||
bool bOk = ExeSelectAll( false) ;
|
||||
// creo un nuovo pezzo con layer in cui mettere tutti i concatenati
|
||||
int nPart = ExeCreateGroup( GDB_ID_ROOT, Frame3d(), RTY_GLOB) ;
|
||||
nLay = ExeCreateGroup( nPart, Frame3d(), RTY_GLOB) ;
|
||||
bOk = bOk && nLay != GDB_ID_NULL ;
|
||||
// concateno tutte le curve
|
||||
INTVECTOR vIds ;
|
||||
vIds.push_back( GDB_ID_SEL) ;
|
||||
int nCount ;
|
||||
int nFirstId = ( bOk ? ExeCreateCurveCompoByChain( nLay, vIds, ORIG, true, RTY_GLOB, &nCount) : GDB_ID_NULL) ;
|
||||
bOk = bOk && nFirstId != GDB_ID_NULL ;
|
||||
// cancello i gruppi rimasti vuoti
|
||||
ExeEraseEmptyParts() ;
|
||||
return bOk ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CreateFlatPartsByRegions( int nLay)
|
||||
{
|
||||
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
||||
VERIFY_GEOMDB( pGeomDB, false)
|
||||
// recupero il padre del layer
|
||||
int nParentId = pGeomDB->GetParentId( nLay) ;
|
||||
// preparo gli iteratori
|
||||
PtrOwner<IGdbIterator> pEnt( CreateGdbIterator( pGeomDB)) ;
|
||||
if ( IsNull( pEnt))
|
||||
return false ;
|
||||
// separo le curve aperte da quelle chiuse e salvo vettore aree di quest ultime
|
||||
INTVECTOR vOpenIds ;
|
||||
INTVECTOR vClosedIds ;
|
||||
typedef std::pair<int,double> INDAREA ; // coppia indice, area
|
||||
typedef std::vector<INDAREA> INDAREAVECTOR ; // vettore di coppie indice, area
|
||||
INDAREAVECTOR vArea ;
|
||||
bool bEok = pEnt->GoToFirstInGroup( nLay) ;
|
||||
while ( bEok) {
|
||||
ICurve* pCrv = GetCurve( pEnt->GetGeoObj()) ;
|
||||
if ( pCrv == nullptr) {
|
||||
bEok = pEnt->EraseAndGoToNext() ;
|
||||
}
|
||||
else if ( ! pCrv->IsClosed()) {
|
||||
vOpenIds.push_back( pEnt->GetId()) ;
|
||||
bEok = pEnt->GoToNext() ;
|
||||
}
|
||||
else {
|
||||
vClosedIds.push_back( pEnt->GetId()) ;
|
||||
double dArea ;
|
||||
pCrv->GetAreaXY( dArea) ;
|
||||
if ( fabs( dArea) > 1) {
|
||||
if ( dArea < 0) {
|
||||
pCrv->Invert() ;
|
||||
dArea = - dArea ;
|
||||
}
|
||||
vArea.emplace_back( pEnt->GetId(), dArea) ;
|
||||
}
|
||||
else
|
||||
vOpenIds.push_back( pEnt->GetId()) ;
|
||||
bEok = pEnt->GoToNext() ;
|
||||
}
|
||||
}
|
||||
// ordino le aree in senso decrescente
|
||||
sort( vArea.begin(), vArea.end(),
|
||||
[]( const INDAREA& a, const INDAREA&b) { return fabs( a.second) > fabs( b.second) ; }) ;
|
||||
// creo i pezzi a partire dalle curve chiuse più grandi e dalle curve che vi sono contenute
|
||||
for ( int i = 0 ; i < int( vArea.size()) ; ++ i) {
|
||||
if ( vArea[i].first == GDB_ID_NULL)
|
||||
continue ;
|
||||
// creo pezzo con questa geometria
|
||||
int nPartId = pGeomDB->InsertGroup( GDB_ID_NULL, nParentId, GDB_BEFORE, Frame3d()) ;
|
||||
// creo layer nel pezzo
|
||||
int nLayId = pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
|
||||
// sposto il contorno nel pezzo
|
||||
pGeomDB->RelocateGlob( vArea[i].first, nLayId) ;
|
||||
// cerco altri contorni chiusi che siano contenuti completamente o parzialmente
|
||||
ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( vArea[i].first)) ;
|
||||
for ( int j = i + 1 ; j < int( vArea.size()) ; ++ j) {
|
||||
if ( vArea[j].first == GDB_ID_NULL)
|
||||
continue ;
|
||||
ICurve* pCrv2 = GetCurve( pGeomDB->GetGeoObj( vArea[j].first)) ;
|
||||
// intersezione e classificazione
|
||||
CRVCVECTOR ccClass ;
|
||||
IntersCurveCurve intCC( *pCrv2, *pCrv) ;
|
||||
if ( ! intCC.GetCurveClassification( 0, ccClass))
|
||||
continue ;
|
||||
// se completamente interna
|
||||
if ( ccClass.size() == 1 && ccClass[0].nClass == CRVC_IN) {
|
||||
pGeomDB->RelocateGlob( vArea[j].first, nLayId) ;
|
||||
vArea[j].first = GDB_ID_NULL ;
|
||||
}
|
||||
// se più di un tratto
|
||||
else if ( ccClass.size() > 1) {
|
||||
// verifico se parzialmente interna
|
||||
bool bIn = false ;
|
||||
bool bOther = false ;
|
||||
for ( int k = 0 ; k < int( ccClass.size()) ; ++ k) {
|
||||
if ( ccClass[k].nClass == CRVC_IN)
|
||||
bIn = true ;
|
||||
else
|
||||
bOther = true ;
|
||||
}
|
||||
// se parzialmente interna, la sposto negli aperti
|
||||
if ( bIn && bOther) {
|
||||
vOpenIds.push_back( vArea[j].first) ;
|
||||
vArea[j].first = GDB_ID_NULL ;
|
||||
}
|
||||
}
|
||||
}
|
||||
// verifico i contorni aperti che siano contenuti completamente o parzialmente
|
||||
for ( int j = i + 1 ; j < int( vOpenIds.size()) ; ++ j) {
|
||||
if ( vOpenIds[j] == GDB_ID_NULL)
|
||||
continue ;
|
||||
ICurve* pCrv2 = GetCurve( pGeomDB->GetGeoObj( vOpenIds[j])) ;
|
||||
Intervals inCrv ;
|
||||
double dParS, dParE ;
|
||||
pCrv2->GetDomain( dParS, dParE) ;
|
||||
inCrv.Set( dParS, dParE) ;
|
||||
// intersezione e classificazione
|
||||
CRVCVECTOR ccClass ;
|
||||
IntersCurveCurve intCC( *pCrv2, *pCrv) ;
|
||||
if ( ! intCC.GetCurveClassification( 0, ccClass))
|
||||
continue ;
|
||||
// conservo solo le parti interne
|
||||
for ( int k = 0 ; k < int( ccClass.size()) ; ++ k) {
|
||||
if ( ccClass[k].nClass != CRVC_IN)
|
||||
inCrv.Remove( ccClass[k].dParS, ccClass[k].dParE) ;
|
||||
}
|
||||
// tratti di curva rimasti
|
||||
int nNum = inCrv.GetNumbers() ;
|
||||
// se rimangono uno o più tratti
|
||||
if ( nNum >= 1) {
|
||||
double dParS, dParE ;
|
||||
bool bInt = inCrv.GetFirst( dParS, dParE) ;
|
||||
while ( bInt) {
|
||||
// copio la curva e la modifico
|
||||
int nCopyId = pGeomDB->Copy( vOpenIds[j], GDB_ID_NULL, nLayId) ;
|
||||
// modifico l'originale
|
||||
ICurve* pOriCrv = GetCurve( pGeomDB->GetGeoObj( nCopyId)) ;
|
||||
pOriCrv->TrimStartEndAtParam( dParS, dParE) ;
|
||||
// passo al successivo intervallo
|
||||
bInt = inCrv.GetNext( dParS, dParE) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// elimino la geometria originale rimasta
|
||||
pGeomDB->Erase( nParentId) ;
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
static bool
|
||||
CreateFlatPartsByLayers( void)
|
||||
{
|
||||
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
||||
VERIFY_GEOMDB( pGeomDB, false)
|
||||
// preparo gli iteratori
|
||||
PtrOwner<IGdbIterator> pPar( CreateGdbIterator( pGeomDB)) ;
|
||||
PtrOwner<IGdbIterator> pLay( CreateGdbIterator( pGeomDB)) ;
|
||||
if ( IsNull( pPar) || IsNull( pLay))
|
||||
return false ;
|
||||
// ciclo su tutti i gruppi della radice (pezzi)
|
||||
bool bPok = pPar->GoToFirstGroupInGroup( GDB_ID_ROOT) ;
|
||||
int nFirstId = pPar->GetId() ;
|
||||
while ( bPok) {
|
||||
// ciclo su tutti i sottogruppi (layer)
|
||||
bool bLok = pLay->GoToFirstGroupInGroup( *Get( pPar)) ;
|
||||
while ( bLok) {
|
||||
// creo pezzo con questa geometria
|
||||
int nPartId = pGeomDB->InsertGroup( GDB_ID_NULL, nFirstId, GDB_BEFORE, Frame3d()) ;
|
||||
// passo al pezzo l'eventuale nome del layer
|
||||
string sName ;
|
||||
if ( pLay->GetName( sName)) {
|
||||
pGeomDB->SetName( nPartId, sName) ;
|
||||
pLay->RemoveName() ;
|
||||
}
|
||||
// sposto il layer sotto questo pezzo
|
||||
if ( ! pGeomDB->RelocateGlob( pLay->GetId(), nPartId))
|
||||
return false ;
|
||||
// altro layer del gruppo originale
|
||||
bLok = pLay->GoToFirstGroupInGroup( *Get( pPar)) ;
|
||||
}
|
||||
// passo al successivo
|
||||
bPok = pPar->GoToNextGroup() ;
|
||||
}
|
||||
// cancello i gruppi svuotati
|
||||
bPok = pPar->GoTo( nFirstId) ;
|
||||
while ( bPok)
|
||||
bPok = pPar->EraseAndGoToNext() ;
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
static bool
|
||||
VerifyAndAdjustFlatParts( void)
|
||||
{
|
||||
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
||||
VERIFY_GEOMDB( pGeomDB, false)
|
||||
// preparo gli iteratori
|
||||
PtrOwner<IGdbIterator> pPar( CreateGdbIterator( pGeomDB)) ;
|
||||
PtrOwner<IGdbIterator> pEnt( CreateGdbIterator( pGeomDB)) ;
|
||||
if ( IsNull( pPar) || IsNull( pEnt))
|
||||
return false ;
|
||||
// ciclo sui pezzi
|
||||
bool bPok = pPar->GoToFirstGroupInGroup( GDB_ID_ROOT) ;
|
||||
while ( bPok) {
|
||||
// seleziono tutte le curve del pezzo
|
||||
bool bOk = ExeSelectPartObjs( pPar->GetId()) ;
|
||||
// creo un nuovo layer in cui mettere tutti i concatenati
|
||||
int nRegId = ExeCreateGroup( pPar->GetId(), Frame3d(), RTY_GLOB) ;
|
||||
bOk = bOk && nRegId != GDB_ID_NULL ;
|
||||
bOk = bOk && pGeomDB->SetName( nRegId, "Region") ;
|
||||
bOk = bOk && pGeomDB->SetLevel( nRegId, GDB_LV_SYSTEM) ;
|
||||
// concateno tutte le curve
|
||||
INTVECTOR vIds ;
|
||||
vIds.push_back( GDB_ID_SEL) ;
|
||||
int nCount ;
|
||||
int nFirstId = ( bOk ? ExeCreateCurveCompoByChain( nRegId, vIds, ORIG, false, RTY_GLOB, &nCount) : GDB_ID_NULL) ;
|
||||
bOk = bOk && nFirstId != GDB_ID_NULL ;
|
||||
// deseleziono tutto
|
||||
pGeomDB->ClearSelection() ;
|
||||
// elimino le curve non chiuse e salvo i puntatori alle altre
|
||||
INTVECTOR vOpenIds ;
|
||||
ICURVEPVECTOR vCrvP ;
|
||||
bool bEok = pEnt->GoToFirstInGroup( nRegId) ;
|
||||
while ( bEok) {
|
||||
ICurve* pCrv = GetCurve( pEnt->GetGeoObj()) ;
|
||||
if ( pCrv == nullptr) {
|
||||
bEok = pEnt->EraseAndGoToNext() ;
|
||||
}
|
||||
else if ( ! pCrv->IsClosed()) {
|
||||
string sOrig ;
|
||||
INTVECTOR vTmpIds ;
|
||||
if ( pGeomDB->GetInfo( pEnt->GetId(), "ORIG", vTmpIds)) {
|
||||
for ( auto Id : vTmpIds)
|
||||
vOpenIds.push_back( Id) ;
|
||||
}
|
||||
bEok = pEnt->EraseAndGoToNext() ;
|
||||
}
|
||||
else {
|
||||
vCrvP.push_back( pCrv) ;
|
||||
bEok = pEnt->GoToNext() ;
|
||||
}
|
||||
}
|
||||
// ne calcolo le aree, le ordino in senso decrescente
|
||||
typedef std::pair<int,double> INDAREA ; // coppia indice, area
|
||||
typedef std::vector<INDAREA> INDAREAVECTOR ; // vettore di coppie indice, area
|
||||
INDAREAVECTOR vArea ;
|
||||
vArea.reserve( vCrvP.size()) ;
|
||||
for ( int i = 0 ; i < int( vCrvP.size()) ; ++ i) {
|
||||
double dArea ;
|
||||
vCrvP[i]->GetAreaXY( dArea) ;
|
||||
vArea.emplace_back( i, dArea) ;
|
||||
}
|
||||
sort( vArea.begin(), vArea.end(),
|
||||
[]( const INDAREA& a, const INDAREA&b) { return fabs( a.second) > fabs( b.second) ; }) ;
|
||||
// verifico e sistemo il senso di rotazione delle curve
|
||||
for ( int i = 0 ; i < int( vArea.size()) ; ++ i) {
|
||||
if ( ( i == 0 && vArea[i].second < 0) || ( i > 0 && vArea[i].second > 0))
|
||||
vCrvP[vArea[i].first]->Invert() ;
|
||||
}
|
||||
// creo il riempimento
|
||||
ISurfTriMesh* pSTM = ( bOk ? GetSurfTriMeshByRegion( vCrvP, 0.1) : nullptr) ;
|
||||
bOk = bOk && ( pSTM != nullptr) ;
|
||||
// elimino punti ripetuti
|
||||
bOk = bOk && pSTM->DoCompacting() ;
|
||||
// inserisco la superficie nel DB
|
||||
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nRegId, pSTM) : GDB_ID_NULL) ;
|
||||
// assegno il colore
|
||||
Color cCol = AQUA ;
|
||||
cCol.SetAlpha( 0.3) ;
|
||||
bOk = bOk && pGeomDB->SetMaterial( nNewId, cCol) ;
|
||||
// taglio le curve aperte con i contorni
|
||||
for ( int i = 0 ; i < int( vOpenIds.size()) ; ++i) {
|
||||
ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( vOpenIds[i])) ;
|
||||
Intervals inCrv ;
|
||||
double dParS, dParE ;
|
||||
pCrv->GetDomain( dParS, dParE) ;
|
||||
inCrv.Set( dParS, dParE) ;
|
||||
for ( int j = 0 ; j < int( vCrvP.size()) ; ++ j) {
|
||||
// intersezione e classificazione
|
||||
CRVCVECTOR ccClass ;
|
||||
IntersCurveCurve intCC( *pCrv, *vCrvP[j]) ;
|
||||
if ( ! intCC.GetCurveClassification( 0, ccClass))
|
||||
continue ;
|
||||
// conservo solo le parti interne
|
||||
for ( int k = 0 ; k < int( ccClass.size()) ; ++ k) {
|
||||
if ( ccClass[k].nClass != CRVC_IN)
|
||||
inCrv.Remove( ccClass[k].dParS, ccClass[k].dParE) ;
|
||||
}
|
||||
}
|
||||
// tratti di curva rimasti
|
||||
int nNum = inCrv.GetNumbers() ;
|
||||
// se non sono rimasti pezzi, elimino la curva
|
||||
if ( nNum == 0) {
|
||||
pGeomDB->Erase( vOpenIds[i]) ;
|
||||
}
|
||||
// se uno solo, lo adatto
|
||||
else if ( nNum == 1) {
|
||||
double dParS, dParE ;
|
||||
inCrv.GetFirst( dParS, dParE) ;
|
||||
pCrv->TrimStartEndAtParam( dParS, dParE) ;
|
||||
}
|
||||
// altrimenti creo le opportune copie parzializzate
|
||||
else {
|
||||
int nOriId = vOpenIds[i] ;
|
||||
int nCopyId = GDB_ID_NULL ;
|
||||
double dParS, dParE ;
|
||||
bool bInt = inCrv.GetFirst( dParS, dParE) ;
|
||||
while ( bInt) {
|
||||
// copio la curva
|
||||
nCopyId = pGeomDB->Copy( nOriId, GDB_ID_NULL, nOriId, GDB_AFTER) ;
|
||||
// modifico l'originale
|
||||
ICurve* pOriCrv = GetCurve( pGeomDB->GetGeoObj( nOriId)) ;
|
||||
pOriCrv->TrimStartEndAtParam( dParS, dParE) ;
|
||||
// la copia è il nuovo originale
|
||||
nOriId = nCopyId ;
|
||||
// passo al successivo intervallo
|
||||
bInt = inCrv.GetNext( dParS, dParE) ;
|
||||
}
|
||||
// cancello l'ultima copia
|
||||
if ( nCopyId != GDB_ID_NULL)
|
||||
pGeomDB->Erase( nCopyId) ;
|
||||
}
|
||||
}
|
||||
// se errore sul pezzo, lo elimino
|
||||
if ( ! bOk)
|
||||
bPok = pPar->EraseAndGoToNextGroup() ;
|
||||
// passo al pezzo successivo
|
||||
else
|
||||
bPok = pPar->GoToNextGroup() ;
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
ExeCreateFlatParts( int nType)
|
||||
{
|
||||
// disabilito registrazione comandi
|
||||
bool bOldCmdLog = SetCmdLog( false) ;
|
||||
// filtro e approssimo le curve
|
||||
bool bOk = FilterAndApprox() ;
|
||||
// creazione basata sulle regioni
|
||||
if ( nType == FPC_REGION) {
|
||||
int nLay ;
|
||||
// concateno
|
||||
bOk = bOk && ChainCurves( nLay) ;
|
||||
// costruisco i pezzi
|
||||
bOk = bOk && CreateFlatPartsByRegions( nLay) ;
|
||||
}
|
||||
// creazione basata sui layer
|
||||
else if ( nType == FPC_LAYER) {
|
||||
// creazione dei pezzi
|
||||
bOk = bOk && CreateFlatPartsByLayers() ;
|
||||
}
|
||||
// creazione basata sui pezzi NGE
|
||||
// sono già a posto
|
||||
// verifica e aggiustamento dei pezzi
|
||||
bOk = bOk && VerifyAndAdjustFlatParts() ;
|
||||
// ripristino stato registrazione comandi
|
||||
bOldCmdLog = SetCmdLog( bOldCmdLog) ;
|
||||
return bOk ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
ExePackPart( int nId, double dXmax, double dOffs)
|
||||
{
|
||||
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
||||
VERIFY_GEOMDB( pGeomDB, false)
|
||||
// Determino il box del pezzo
|
||||
BBox3d b3Part ;
|
||||
if ( ! pGeomDB->GetGlobalBBox( nId, b3Part))
|
||||
return false ;
|
||||
double dLarPz = b3Part.GetMax().x - b3Part.GetMin().x ;
|
||||
// Cerco prima posizione utile
|
||||
double dXok = 0 ;
|
||||
double dYok = 0 ;
|
||||
double dYtop = 0 ;
|
||||
int nId2 = ExeGetFirstPart( false) ;
|
||||
while ( nId2 != GDB_ID_NULL) {
|
||||
if ( nId2 != nId) {
|
||||
BBox3d b3Part2 ;
|
||||
if ( pGeomDB->GetGlobalBBox( nId2, b3Part2)) {
|
||||
if ( b3Part2.GetMin().y < dYtop + 0.5 * dOffs) {
|
||||
dXok = max( dXok, b3Part2.GetMax().x + dOffs) ;
|
||||
}
|
||||
else {
|
||||
dXok = b3Part2.GetMax().x + dOffs ;
|
||||
dYok = dYtop + dOffs ;
|
||||
}
|
||||
dYtop = max( dYtop, b3Part2.GetMax().y) ;
|
||||
}
|
||||
}
|
||||
nId2 = ExeGetNextPart( nId2, false) ;
|
||||
}
|
||||
if ( dXok + dLarPz > dXmax) {
|
||||
dXok = 0 ;
|
||||
dYok = dYtop + dOffs ;
|
||||
}
|
||||
// Porto il pezzo nella giusta posizione
|
||||
return pGeomDB->TranslateGlob( nId, Point3d( dXok, dYok, 0) - b3Part.GetMin()) ;
|
||||
}
|
||||
Reference in New Issue
Block a user