Dario Sassi
537 lines
21 KiB
C++
537 lines
21 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2015
|
|
//----------------------------------------------------------------------------
|
|
// File : EXE_NstCreateFlatParts.cpp Data : 28.12.15 Versione : 1.6l5
|
|
// Contenuto : Funzioni di creazione pezzi piani per EXE.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 28.12.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "EXE.h"
|
|
#include "EXE_Const.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/EGkSfrCreate.h"
|
|
#include "/EgtDev/Include/EGkExtText.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->GetCurveCount() ;
|
|
if ( nCrvs <= 5 && dLen > nCrvs * LIN_FEA_STD) {
|
|
// controllo non ci siano curve di Bezier
|
|
bool bSomeBezier = false ;
|
|
const ICurve* pCrv = pCrvCo->GetFirstCurve() ;
|
|
while ( pCrv != nullptr) {
|
|
if ( pCrv->GetType() == CRV_BEZ)
|
|
bSomeBezier = true ;
|
|
pCrv = pCrvCo->GetNextCurve() ;
|
|
}
|
|
if ( ! bSomeBezier)
|
|
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 queste 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.Subtract( ccClass[k].dParS, ccClass[k].dParE) ;
|
|
}
|
|
// tratti di curva rimasti
|
|
int nNum = inCrv.GetCount() ;
|
|
// 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, NST_PART_REG) ;
|
|
// 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 aperte del nuovo layer e uso le chiuse per creare la regione
|
|
INTVECTOR vOpenIds ;
|
|
STRVECTOR vClosedIds ;
|
|
SurfFlatRegionByContours SfrCntr( false, false) ;
|
|
bool bEok = pEnt->GoToFirstInGroup( nRegId) ;
|
|
while ( bEok) {
|
|
ICurve* pCrv = GetCurve( pEnt->GetGeoObj()) ;
|
|
if ( pCrv == nullptr) {
|
|
bEok = pEnt->EraseAndGoToNext() ;
|
|
}
|
|
else if ( ! pCrv->IsClosed()) {
|
|
// salvo Id di origine nell'elenco curve aperte da controllare
|
|
INTVECTOR vTmpIds ;
|
|
if ( pGeomDB->GetInfo( pEnt->GetId(), CRV_ORIG, vTmpIds))
|
|
vOpenIds.insert( vOpenIds.end(), vTmpIds.begin(), vTmpIds.end()) ;
|
|
bEok = pEnt->EraseAndGoToNext() ;
|
|
}
|
|
else {
|
|
// salvo Id entità corrente e preparo passaggio a prossima
|
|
int nEntId = pEnt->GetId() ;
|
|
bEok = pEnt->GoToNext() ;
|
|
// salvo stringa con elenco Id di origine
|
|
string sInfo ;
|
|
if ( pGeomDB->GetInfo( nEntId, CRV_ORIG, sInfo)) {
|
|
vClosedIds.emplace_back( sInfo) ;
|
|
pCrv->SetTempProp( int( vClosedIds.size())) ;
|
|
}
|
|
// estraggo curva da entità che viene cancellata
|
|
SfrCntr.AddCurve( pCrv) ;
|
|
pGeomDB->RemoveGeoObjAndErase( nEntId) ;
|
|
}
|
|
}
|
|
// creo la regione
|
|
ISurfFlatRegion* pSfr = SfrCntr.GetSurf() ;
|
|
bOk = bOk && ( pSfr != nullptr) ;
|
|
// inserisco eventuali curve chiuse non usate nell'elenco delle aperte
|
|
if ( ! SfrCntr.AllCurvesUsed()) {
|
|
// recupero indice da proprietà temporanea di curve non usate
|
|
INTVECTOR vUnId ;
|
|
SfrCntr.GetUnusedCurveTempProps( vUnId) ;
|
|
// recupero Id originali associati
|
|
for ( auto nUnId : vUnId) {
|
|
if ( nUnId > 0 && nUnId <= int( vClosedIds.size())) {
|
|
INTVECTOR vTmpIds ;
|
|
if ( FromString( vClosedIds[nUnId - 1], vTmpIds))
|
|
vOpenIds.insert( vOpenIds.end(), vTmpIds.begin(), vTmpIds.end()) ;
|
|
}
|
|
}
|
|
}
|
|
// inserisco la superficie nel DB
|
|
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nRegId, pSfr) : GDB_ID_NULL) ;
|
|
bOk = bOk && nNewId != GDB_ID_NULL ;
|
|
// assegno il colore
|
|
Color cCol = AQUA ;
|
|
cCol.SetAlpha( 0.3) ;
|
|
bOk = bOk && pGeomDB->SetMaterial( nNewId, cCol) ;
|
|
// scrittura delle dimensioni nel layer della regione
|
|
if ( bOk) {
|
|
BBox3d b3Reg ;
|
|
pGeomDB->GetGlobalBBox( nNewId, b3Reg) ;
|
|
Point3d ptMin, ptMax ;
|
|
b3Reg.GetMinMax( ptMin, ptMax) ;
|
|
double dDimX = ptMax.x - ptMin.x ;
|
|
double dDimY = ptMax.y - ptMin.y ;
|
|
string sOut = ToString( ExeToUiUnits( dDimX), 2) + "x" + ToString( ExeToUiUnits( dDimY), 2) ;
|
|
Point3d ptCen = Media( ptMin, ptMax, 0.5) ;
|
|
Vector3d vtDir = ( dDimX >= dDimY ? X_AX : Y_AX) ;
|
|
double dDimT = min( 0.05 * max( dDimX, dDimY), 0.5 * min( dDimX, dDimY)) ;
|
|
PtrOwner<IExtText> pText( CreateExtText()) ;
|
|
if ( ! IsNull( pText) &&
|
|
pText->Set( ptCen, Z_AX, vtDir, sOut, "", 100, false, dDimT, 1, 0, ETXT_IPMC)) {
|
|
int nTextId = pGeomDB->AddGeoObj( GDB_ID_NULL, nRegId, Release( pText)) ;
|
|
pGeomDB->SetMaterial( nTextId, BLACK) ;
|
|
}
|
|
}
|
|
// creo un nuovo layer in cui copiare il contorno esterno
|
|
PtrOwner<ICurve> pOutCrv( bOk ? pSfr->GetLoop( 0, 0) : nullptr) ;
|
|
if ( ! IsNull( pOutCrv)) {
|
|
int nOutLoopId = ExeCreateGroup( pPar->GetId(), Frame3d(), RTY_GLOB) ;
|
|
bOk = bOk && nOutLoopId != GDB_ID_NULL ;
|
|
bOk = bOk && pGeomDB->SetName( nOutLoopId, NST_EXT_LAYER) ;
|
|
pGeomDB->AddGeoObj( GDB_ID_NULL, nOutLoopId, Release( pOutCrv)) ;
|
|
}
|
|
// creo nuovi layer in cui copiare gli eventuali contorni interni
|
|
if ( bOk && pSfr->GetLoopCount( 0) > 1) {
|
|
int i = 1 ;
|
|
PtrOwner<ICurve> pInCrv( bOk ? pSfr->GetLoop( 0, i) : nullptr) ;
|
|
while ( ! IsNull( pInCrv)) {
|
|
int nInLoopId = ExeCreateGroup( pPar->GetId(), Frame3d(), RTY_GLOB) ;
|
|
bOk = bOk && nInLoopId != GDB_ID_NULL ;
|
|
bOk = bOk && pGeomDB->SetName( nInLoopId, NST_IN_LAYER) ;
|
|
pGeomDB->AddGeoObj( GDB_ID_NULL, nInLoopId, Release( pInCrv)) ;
|
|
++ i ;
|
|
pInCrv.Set( bOk ? pSfr->GetLoop( 0, i) : nullptr) ;
|
|
}
|
|
}
|
|
// creo nuovi layer in cui mettere le curve aperte
|
|
if ( bOk && vOpenIds.size() > 0) {
|
|
for ( int i = 0 ; bOk && i < int( vOpenIds.size()) ; ++i) {
|
|
int nOnPathId = ExeCreateGroup( pPar->GetId(), Frame3d(), RTY_GLOB) ;
|
|
bOk = bOk && nOnPathId != GDB_ID_NULL ;
|
|
bOk = bOk && pGeomDB->SetName( nOnPathId, NST_ON_LAYER) ;
|
|
pGeomDB->RelocateGlob( vOpenIds[i], nOnPathId) ;
|
|
}
|
|
}
|
|
// taglio le curve aperte con la regione
|
|
for ( int i = 0 ; bOk && i < int( vOpenIds.size()) ; ++i) {
|
|
ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( vOpenIds[i])) ;
|
|
// calcolo la classificazione della curva rispetto alla regione
|
|
CRVCVECTOR ccClass ;
|
|
if ( ! pSfr->GetCurveClassification( *pCrv, ccClass))
|
|
continue ;
|
|
// conservo solo gli intervalli di curva interni
|
|
Intervals inOk ;
|
|
for ( auto& ccOne : ccClass) {
|
|
if ( ccOne.nClass == CRVC_IN)
|
|
inOk.Add( ccOne.dParE, ccOne.dParS) ;
|
|
}
|
|
// recupero un intervallo di id contigui per tutte le parti
|
|
int nFirstId = pGeomDB->GetNewId() ;
|
|
pGeomDB->ChangeId( vOpenIds[i], nFirstId) ;
|
|
int nCurrId = nFirstId ;
|
|
// eseguo la divisione
|
|
nCount = 0 ;
|
|
double dParS, dParE ;
|
|
bool bFound = inOk.GetFirst( dParS, dParE) ;
|
|
while ( bFound) {
|
|
// copio la curva
|
|
int nCopyId = pGeomDB->Copy( nCurrId, GDB_ID_NULL, nCurrId, GDB_AFTER) ;
|
|
ICurve* pCopyCrv = GetCurve( pGeomDB->GetGeoObj( nCopyId)) ;
|
|
if ( pCopyCrv == nullptr)
|
|
break ;
|
|
++ nCount ;
|
|
// modifico l'originale
|
|
bOk = bOk && pCrv->TrimStartEndAtParam( dParS, dParE) ;
|
|
// la copia diventa il nuovo corrente
|
|
nCurrId = nCopyId ;
|
|
pCrv = pCopyCrv ;
|
|
// passo alla successiva divisione
|
|
bFound = inOk.GetNext( dParS, dParE) ;
|
|
}
|
|
// cancello l'ultima copia (se non c'erano intervalli validi è l'originale)
|
|
if ( nCurrId != GDB_ID_NULL)
|
|
pGeomDB->Erase( nCurrId) ;
|
|
}
|
|
// 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 ;
|
|
}
|