Egalware/EgtExecutor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
develop
EgtExecutor/EXE_GdbModifySurf.cpp
T
Daniele Bariletti 8dd2972a4b Merge branch '3dm_import+trim&mesh'
2023-11-08 08:48:41 +01:00

1037 lines
40 KiB
C++
Raw Permalink Blame History

//----------------------------------------------------------------------------
// EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : EXE_ModifySurf.cpp Data : 04.05.15 Versione : 1.6e1
// Contenuto : Funzioni di modifica delle superfici per EXE.
//
//
//
// Modifiche : 09.03.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "EXE.h"
#include "EXE_Macro.h"
#include "EXE_Const.h"
#include "AuxTools.h"
#include "GeoTools.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EGkCurveLocal.h"
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EGkSurfBezier.h"
#include "/EgtDev/Include/EGkSurfLocal.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include "/EgtDev/Include/EGkCAvSimpleSurfFrMove.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkSubtractProjectedFacesOnStmFace.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
using namespace std ;
//----------------------------------------------------------------------------
bool
ExeInvertSurface( const INTVECTOR& vIds)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// eseguo inversione
bool bOk = true ;
for ( size_t i = 0 ; i < vIds.size() && bOk ; ++ i) {
int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
while ( nId != GDB_ID_NULL && bOk) {
// recupero la superficie e la inverto
ISurf* pSurf = GetSurf( pGeomDB->GetGeoObj( nId)) ;
if ( pSurf != nullptr && ! pSurf->Invert())
bOk = false ;
// passo alla successiva
nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
}
}
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtInvertSurf({" + IdListToString( vIds) + "})" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return bOk ;
}
//-------------------------------------------------------------------------------
static int
MyExplodeSurfTriMesh( int nId, int& nCount)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la superficie TriMesh
const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
if ( pStm == nullptr)
return GDB_ID_NULL ;
// recupero il numero di componenti connesse
int nParts = pStm->GetPartCount() ;
// se ci sono pi� parti, separo queste
if ( nParts > 1) {
int nFirstId = GDB_ID_NULL ;
nCount = 0 ;
for ( int i = 0 ; i < nParts ; ++ i) {
ISurfTriMesh* pFac = pStm->ClonePart( i) ;
if ( pFac == nullptr)
continue ;
// inserisco la superficie nello stesso gruppo e nello stesso posto del GeomDB
int nNewId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pFac) ;
if ( nNewId == GDB_ID_NULL)
return GDB_ID_NULL ;
// copio gli attributi
if ( ! pGeomDB->CopyAttributes( nId, nNewId))
return GDB_ID_NULL ;
// aggiorno contatori
if ( nFirstId == GDB_ID_NULL)
nFirstId = nNewId ;
++ nCount ;
}
// elimino la superficie originale
pGeomDB->Erase( nId) ;
// restituisco risultati
return nFirstId ;
}
// recupero il numero di facce
int nFacets = pStm->GetFacetCount() ;
// se ci sono pi� facce, separo queste
if ( nFacets > 1) {
// copio tutte le facce
int nFirstId = GDB_ID_NULL ;
nCount = 0 ;
for ( int i = 0 ; i < nFacets ; ++ i) {
ISurfTriMesh* pFac = pStm->CloneFacet( i) ;
if ( pFac == nullptr)
continue ;
// inserisco la superficie nello stesso gruppo e nello stesso posto del GeomDB
int nNewId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pFac) ;
if ( nNewId == GDB_ID_NULL)
return GDB_ID_NULL ;
// copio gli attributi
if ( ! pGeomDB->CopyAttributes( nId, nNewId))
return GDB_ID_NULL ;
// aggiorno contatori
if ( nFirstId == GDB_ID_NULL)
nFirstId = nNewId ;
++ nCount ;
}
// elimino la superficie originale
pGeomDB->Erase( nId) ;
// restituisco risultati
return nFirstId ;
}
// non devo fare alcunch�
nCount = 1 ;
return nId ;
}
//-------------------------------------------------------------------------------
static int
MyExplodeSurfFlatRegion( int nId, int& nCount)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la superficie FlatRegion
const ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
if ( pSfr == nullptr)
return GDB_ID_NULL ;
// recupero il numero di componenti connessi (chunk)
int nChunk = pSfr->GetChunkCount() ;
// se c'� un solo componente, non devo fare alcunch�
if ( nChunk == 1) {
nCount = 1 ;
return nId ;
}
// copio tutti i componenti connessi (chunk)
int nFirstId = GDB_ID_NULL ;
nCount = 0 ;
for ( int i = 0 ; i < nChunk ; ++ i) {
ISurfFlatRegion* pChk = pSfr->CloneChunk( i) ;
if ( pChk == nullptr)
continue ;
// inserisco la superficie nello stesso gruppo e nello stesso posto del GeomDB
int nNewId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pChk) ;
if ( nNewId == GDB_ID_NULL)
return GDB_ID_NULL ;
// copio gli attributi
if ( ! pGeomDB->CopyAttributes( nId, nNewId))
return GDB_ID_NULL ;
// aggiorno contatori
if ( nFirstId == GDB_ID_NULL)
nFirstId = nNewId ;
++ nCount ;
}
// elimino la superficie
pGeomDB->Erase( nId) ;
// restituisco risultati
return nFirstId ;
}
//-------------------------------------------------------------------------------
int
ExeExplodeSurface( int nId, int* pnCount)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero il tipo di superficie
int nFirstId = GDB_ID_NULL ;
int nCount = 0 ;
switch ( pGeomDB->GetGeoType( nId)) {
case SRF_TRIMESH :
nFirstId = MyExplodeSurfTriMesh( nId, nCount) ;
break ;
case SRF_FLATRGN :
nFirstId = MyExplodeSurfFlatRegion( nId, nCount) ;
break ;
}
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtExplodeSurf(" + ToString( nId) + ")" +
" -- Id1=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultati
if ( pnCount != nullptr)
*pnCount = nCount ;
return nFirstId ;
}
//-------------------------------------------------------------------------------
bool
ExeApproxSurface( int nId, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// opero secondo il tipo di superficie
PtrOwner<ISurfTriMesh> pStm ;
int nType = pGeomDB->GetGeoType( nId) ;
if ( nType == SRF_TRIMESH) {
// copio la superficie
const ISurfTriMesh* pStri = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
pStm.Set( pStri != nullptr ? pStri->Clone() : nullptr) ;
}
else if ( nType == SRF_FLATRGN) {
// recupero la superficie ausiliaria della regione
const ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
const ISurfTriMesh* pAuxSurf = ( pSfr != nullptr ? pSfr->GetAuxSurf() : nullptr) ;
pStm.Set( pAuxSurf != nullptr ? pAuxSurf->Clone() : nullptr) ;
}
else if ( nType == SRF_BEZIER) {
// recupero la superficie ausiliaria della Bezier
const ISurfBezier* pSbez = GetSurfBezier( pGeomDB->GetGeoObj( nId)) ;
const ISurfTriMesh* pAuxSurf = ( pSbez != nullptr ? pSbez->GetAuxSurf() : nullptr) ;
pStm.Set( pAuxSurf != nullptr ? pAuxSurf->Clone() : nullptr) ;
}
bool bOk = ( ! IsNull( pStm)) ;
// semplificazione della trimesh
bOk = bOk && pStm->DoCompacting( dLinTol) ;
// sostituisco la vecchia superficie con la nuova
bOk = bOk && pGeomDB->ReplaceGeoObj( nId, Release( pStm)) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtApproxSurf(" + ToString( nId) + "," +
ToString( dLinTol) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
ExeSurfFrAdd( int nId1, int nId2)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la prima superficie FlatRegion
ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
bool bOk = ( pSfr1 != nullptr) ;
// recupero il riferimento della superficie
Frame3d frSurf1 ;
bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
// recupero la seconda superficie FlatRegion in locale alla prima
SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
const ISurfFlatRegion* pSfr2L = GetSurfFlatRegion( Surf2Loc) ;
bOk = bOk && ( pSfr2L != nullptr) ;
// eseguo l'unione tra le due superfici
bOk = bOk && pSfr1->Add( *pSfr2L) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfFrAdd(" + ToString( nId1) + "," +
ToString( nId2) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
ExeSurfFrSubtract( int nId1, int nId2)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la prima superficie FlatRegion
ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
bool bOk = ( pSfr1 != nullptr) ;
// recupero il riferimento della superficie
Frame3d frSurf1 ;
bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
// recupero la seconda superficie FlatRegion in locale alla prima
SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
const ISurfFlatRegion* pSfr2L = GetSurfFlatRegion( Surf2Loc) ;
bOk = bOk && ( pSfr2L != nullptr) ;
// eseguo la sottrazione della seconda superficie dalla prima
bOk = bOk && pSfr1->Subtract( *pSfr2L) ;
// se il risultato � vuoto, cancello la FlatRegion
if ( bOk && ! pSfr1->IsValid())
pGeomDB->Erase( nId1) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfFrSubtract(" + ToString( nId1) + "," +
ToString( nId2) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
ExeSurfFrIntersect( int nId1, int nId2)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la prima superficie FlatRegion
ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
bool bOk = ( pSfr1 != nullptr) ;
// recupero il riferimento della superficie
Frame3d frSurf1 ;
bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
// recupero la seconda superficie FlatRegion in locale alla prima
SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
const ISurfFlatRegion* pSfr2L = GetSurfFlatRegion( Surf2Loc) ;
bOk = bOk && ( pSfr2L != nullptr) ;
// eseguo l'intersezione tra le due superfici
bOk = bOk && pSfr1->Intersect( *pSfr2L) ;
// se il risultato � vuoto, cancello la FlatRegion
if ( bOk && ! pSfr1->IsValid())
pGeomDB->Erase( nId1) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfFrIntersect(" + ToString( nId1) + "," +
ToString( nId2) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
ExeSurfFrOffset( int nId, double dDist, int nType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la superficie FlatRegion
ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId)) ;
bool bOk = ( pSfr != nullptr) ;
// eseguo l'offset
bOk = bOk && pSfr->Offset( dDist, nType) ;
// se il risultato � vuoto, cancello la FlatRegion
if ( bOk && ! pSfr->IsValid())
pGeomDB->Erase( nId) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfFrOffset(" + ToString( nId) + "," +
ToString( dDist) + "," +
ToString( nType) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
ExeSurfFrMoveSimpleNoCollision( int nId1, int nId2, const Vector3d& vtDir, double& dLen, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la prima superficie FlatRegion
ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
bool bOk = ( pSfr1 != nullptr) ;
// recupero il riferimento della superficie
Frame3d frSurf1 ;
bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
// recupero la seconda superficie FlatRegion in locale alla prima
SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
const ISurfFlatRegion* pSfr2L = GetSurfFlatRegion( Surf2Loc) ;
bOk = bOk && ( pSfr2L != nullptr) ;
// porto in locale alla prima superficie il versore di movimento
Vector3d vtDirL = GetVectorLocal( pGeomDB, vtDir, nRefType, frSurf1) ;
// calcolo massima lunghezza di traslazione della prima regione senza semplice collisione con la seconda
return ( bOk && CAvSimpleSurfFrMove( *pSfr1, *pSfr2L).Translate( vtDirL, dLen)) ;
}
//----------------------------------------------------------------------------
bool
ExeSurfFrRotateSimpleNoCollision( int nId1, int nId2, const Point3d& ptCen, double& dAngDeg, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la prima superficie FlatRegion
ISurfFlatRegion* pSfr1 = GetSurfFlatRegion( pGeomDB->GetGeoObj( nId1)) ;
bool bOk = ( pSfr1 != nullptr) ;
// recupero il riferimento della superficie
Frame3d frSurf1 ;
bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
// recupero la seconda superficie FlatRegion in locale alla prima
SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
const ISurfFlatRegion* pSfr2L = GetSurfFlatRegion( Surf2Loc) ;
bOk = bOk && ( pSfr2L != nullptr) ;
// porto in locale alla prima superficie il versore di movimento
Point3d ptCenL = GetPointLocal( pGeomDB, ptCen, nRefType, frSurf1) ;
// calcolo massimo angolo di rotazione della prima regione senza semplice collisione con la seconda
return ( bOk && CAvSimpleSurfFrMove( *pSfr1, *pSfr2L).Rotate(ptCenL, dAngDeg)) ;
}
//-------------------------------------------------------------------------------
bool
ExeSurfTmMoveVertex( int nId, int nVert, const Point3d& ptNewVert, int nRefType, bool bUpdate)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la superficie
ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
bool bOk = ( pStm != nullptr) ;
// recupero il riferimento in cui � immersa la superficie
Frame3d frStm ;
bOk = bOk && pGeomDB->GetGlobFrame( nId, frStm) ;
// eseguo la modifica
if ( bOk) {
// porto il nuovo vertice nel riferimento della superficie
Point3d ptNewVertL = GetPointLocal( pGeomDB, ptNewVert, nRefType, frStm) ;
// eseguo la modifica
bOk = pStm->MoveVertex( nVert, ptNewVertL) ;
// se richiesto, semplificazione della trimesh
if ( bUpdate)
bOk = bOk && pStm->DoCompacting() ;
}
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmMoveVertex(" + IdToString( nId) + "," +
ToString( nVert) + ",{" +
ToString( ptNewVert) + "}," +
RefTypeToString( nRefType) + "," +
( bUpdate ? "true" : "false") + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return bOk ;
}
//-------------------------------------------------------------------------------
static int
MySurfTmToTriangles( int nId, int& nCount)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la superficie TriMesh
const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
if ( pStm == nullptr)
return GDB_ID_NULL ;
// recupero il numero di triangoli
int nTria = pStm->GetTriangleCount() ;
// se ci sono pi� triangoli, li separo
if ( nTria > 1) {
// copio tutti triangoli
int nFirstId = GDB_ID_NULL ;
nCount = 0 ;
for ( int i = 0 ; i < pStm->GetTriangleSize() ; ++ i) {
ISurfTriMesh* pFac = pStm->CloneTriangle( i) ;
if ( pFac == nullptr)
continue ;
// inserisco la superficie nello stesso gruppo e nello stesso posto del GeomDB
int nNewId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pFac) ;
if ( nNewId == GDB_ID_NULL)
return GDB_ID_NULL ;
// copio gli attributi
if ( ! pGeomDB->CopyAttributes( nId, nNewId))
return GDB_ID_NULL ;
// aggiorno contatori
if ( nFirstId == GDB_ID_NULL)
nFirstId = nNewId ;
++ nCount ;
}
// elimino la superficie originale
pGeomDB->Erase( nId) ;
// restituisco risultati
return nFirstId ;
}
// non devo fare alcunch�
nCount = 1 ;
return nId ;
}
//-------------------------------------------------------------------------------
int
ExeSurfTmToTriangles( int nId, int* pnCount)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// verifico sia una superficie trimesh
int nFirstId = GDB_ID_NULL ;
int nCount = 0 ;
if ( pGeomDB->GetGeoType( nId) == SRF_TRIMESH) {
nFirstId = MySurfTmToTriangles( nId, nCount) ;
}
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmToTriangles(" + IdToString( nId) + ")" +
" -- Id1=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultati
if ( pnCount != nullptr)
*pnCount = nCount ;
return nFirstId ;
}
//-------------------------------------------------------------------------------
bool
ExeSurfTmRemoveFacet( int nId, int nFacet)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la superficie TriMesh
ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
bool bOk = ( pStm != nullptr) ;
// eseguo la rimozione
bOk = bOk && pStm->RemoveFacet( nFacet) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmRemoveFacet(" + IdToString( nId) + "," +
ToString( nFacet) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return bOk ;
}
//-------------------------------------------------------------------------------
bool
ExeSurfTmSwapFacets( int nId, int nFacet1, int nFacet2)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la superficie TriMesh
ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
bool bOk = ( pStm != nullptr) ;
// eseguo lo scambio
bOk = bOk && pStm->SwapFacets( nFacet1, nFacet2) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmSwapFacets(" + IdToString( nId) + "," +
ToString( nFacet1) + "," +
ToString( nFacet2) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return bOk ;
}
//-------------------------------------------------------------------------------
bool
ExeSurfTmRemovePart( int nId, int nPart)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la superficie TriMesh
ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
bool bOk = ( pStm != nullptr) ;
// eseguo la rimozione
bOk = bOk && pStm->RemovePart( nPart) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmRemovePart(" + IdToString( nId) + "," +
ToString( nPart) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return bOk ;
}
//-------------------------------------------------------------------------------
bool
ExeCutSurfTmPlane( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la superficie TriMesh
ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
bool bOk = ( pStm != nullptr) ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGlobFrame( nId, frLoc) ;
// porto in locale il punto e la normale del piano
Point3d ptOnL = GetPointLocal( pGeomDB, ptOn, nRefType, frLoc) ;
Vector3d vtNL = GetVectorLocal( pGeomDB, vtN, nRefType, frLoc) ;
// calcolo il piano di taglio
Plane3d plPlane ;
bOk = bOk && plPlane.Set( ptOnL, vtNL) ;
// eseguo il taglio
bOk = bOk && pStm->Cut( plPlane, bSaveOnEq) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtCutSurfTmPlane(" + IdToString( nId) + ",{" +
ToString( ptOn) + "},{" +
ToString( vtN) + "}," +
( bSaveOnEq ? "true" : "false") + "," +
RefTypeToString( nRefType) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return bOk ;
}
//-------------------------------------------------------------------------------
bool
ExeCutSurfTmClosedCurve( int nSurfId, int nCurveId, bool bSaveOnEq)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la superficie TriMesh
ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfId)) ;
bool bOk = ( pStm != nullptr) ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGlobFrame( nSurfId, frLoc) ;
// recupero la curva nel riferimento locale della superficie
CurveLocal CrvCut( pGeomDB, nCurveId, frLoc) ;
bOk = bOk && CrvCut.Get() != nullptr ;
// eseguo il taglio
bOk = bOk && pStm->GeneralizedCut( *CrvCut.Get(), bSaveOnEq) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtCutSurfTmClosedCurve(" + ToString( nSurfId) + ",{" +
ToString( nCurveId) + "},{" +
( bSaveOnEq ? "true" : "false") + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return bOk ;
}
//----------------------------------------------------------------------------
bool
ExeSurfTmAdd( int nId1, int nId2, bool bTwoColors)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la prima superficie TriMesh
ISurfTriMesh* pStm1 = GetSurfTriMesh( pGeomDB->GetGeoObj( nId1)) ;
bool bOk = ( pStm1 != nullptr) ;
// recupero il riferimento della superficie
Frame3d frSurf1 ;
bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
// recupero la seconda superficie TriMesh in locale alla prima
SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
const ISurfTriMesh* pStm2L = GetSurfTriMesh( Surf2Loc) ;
bOk = bOk && ( pStm2L != nullptr) ;
// eseguo l'unione tra le due superfici
bOk = bOk && pStm1->Add( *pStm2L) ;
// se non richiesti due colori
if ( bOk && ! bTwoColors)
pStm1->ResetTFlags() ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmAdd(" + ToString( nId1) + "," +
ToString( nId2) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
ExeSurfTmSubtract( int nId1, int nId2, bool bTwoColors)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la prima superficie TriMesh
ISurfTriMesh* pStm1 = GetSurfTriMesh( pGeomDB->GetGeoObj( nId1)) ;
bool bOk = ( pStm1 != nullptr) ;
// recupero il riferimento della superficie
Frame3d frSurf1 ;
bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
// recupero la seconda superficie TriMesh in locale alla prima
SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
const ISurfTriMesh* pStm2L = GetSurfTriMesh( Surf2Loc) ;
bOk = bOk && ( pStm2L != nullptr) ;
// eseguo la sottrazione tra le due superfici
bOk = bOk && pStm1->Subtract( *pStm2L) ;
// se il risultato � vuoto, cancello la superficie
if ( bOk && ! pStm1->IsValid()) {
pGeomDB->Erase( nId1) ;
pStm1 = nullptr ;
}
// se non richiesti due colori
if ( bOk && ! bTwoColors && pStm1 != nullptr)
pStm1->ResetTFlags() ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmSubtract(" + ToString( nId1) + "," +
ToString( nId2) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
ExeSurfTmIntersect( int nId1, int nId2, bool bTwoColors)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la prima superficie TriMesh
ISurfTriMesh* pStm1 = GetSurfTriMesh( pGeomDB->GetGeoObj( nId1)) ;
bool bOk = ( pStm1 != nullptr) ;
// recupero il riferimento della superficie
Frame3d frSurf1 ;
bOk = bOk && pGeomDB->GetGlobFrame( nId1, frSurf1) ;
// recupero la seconda superficie TriMesh in locale alla prima
SurfLocal Surf2Loc( pGeomDB, nId2, frSurf1) ;
const ISurfTriMesh* pStm2L = GetSurfTriMesh( Surf2Loc) ;
bOk = bOk && ( pStm2L != nullptr) ;
// eseguo l'intersezione tra le due superfici
bOk = bOk && pStm1->Intersect( *pStm2L) ;
// se il risultato � vuoto, cancello la superficie
if ( bOk && ! pStm1->IsValid()) {
pGeomDB->Erase( nId1) ;
pStm1 = nullptr ;
}
// se non richiesti due colori
if ( bOk && ! bTwoColors && pStm1 != nullptr)
pStm1->ResetTFlags() ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmIntersect(" + ToString( nId1) + "," +
ToString( nId2) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
ExeSurfTmResetTwoColors( int nId)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la superficie TriMesh
ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
bool bOk = ( pStm != nullptr) ;
// reset dei flag sui triangoli per i due colori
bOk = bOk && pStm->ResetTFlags() ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmResetTwoColors(" + ToString( nId) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
return bOk ;
}
//----------------------------------------------------------------------------
static ISurfTriMesh*
MyCreateSubSurfTm( const ISurfTriMesh* pStm, const INTVECTOR& vTria, const INTVECTOR& vTria2)
{
StmFromTriangleSoup StmFts ;
if ( ! StmFts.Start())
return nullptr ;
for ( int nT : vTria) {
Triangle3d Tria ;
if ( ! pStm->GetTriangle( nT, Tria) ||
! StmFts.AddTriangle( Tria))
return nullptr ;
}
for ( int nT : vTria2) {
Triangle3d Tria ;
if ( ! pStm->GetTriangle( nT, Tria) ||
! StmFts.AddTriangle( Tria))
return nullptr ;
}
// valido la superficie e calcolo le adiacenze
if ( ! StmFts.End())
return nullptr ;
// restituisco la superficie
return StmFts.GetSurf() ;
}
//----------------------------------------------------------------------------
static ISurfTriMesh*
MyCreateSubSurfTm( const ISurfTriMesh* pStm, const INTVECTOR& vTria)
{
INTVECTOR vNull ;
return MyCreateSubSurfTm( pStm, vTria, vNull) ;
}
//----------------------------------------------------------------------------
static int
MySurfTmSplit( int nId, int nSplitterId, int& nCount)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la superficie TriMesh da dividere in parti
ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
if ( pStm == nullptr)
return GDB_ID_NULL ;
// recupero il riferimento della superficie
Frame3d frSurf ;
if ( ! pGeomDB->GetGlobFrame( nId, frSurf))
return GDB_ID_NULL ;
// recupero la superficie TriMesh divisore in locale alla prima
SurfLocal SurfCLoc( pGeomDB, nSplitterId, frSurf) ;
const ISurfTriMesh* pStmCLoc = GetSurfTriMesh( SurfCLoc) ;
if ( pStmCLoc == nullptr)
return GDB_ID_NULL ;
// eseguo la classificazione
INTVECTOR vTriaIn, vTriaOut, vTriaOnP, vTriaOnM, vTriaIndef ;
if ( ! pStm->GetSurfClassification( *pStmCLoc, vTriaIn, vTriaOut, vTriaOnP, vTriaOnM, vTriaIndef))
return GDB_ID_NULL ;
// costruisco le diverse superfici
PtrOwner<ISurfTriMesh> pStmIn( MyCreateSubSurfTm( pStm, vTriaIn)) ;
PtrOwner<ISurfTriMesh> pStmOut( MyCreateSubSurfTm( pStm, vTriaOut)) ;
PtrOwner<ISurfTriMesh> pStmOnP( MyCreateSubSurfTm( pStm, vTriaOnP)) ;
PtrOwner<ISurfTriMesh> pStmOnM( MyCreateSubSurfTm( pStm, vTriaOnM)) ;
PtrOwner<ISurfTriMesh> pStmIndef( MyCreateSubSurfTm( pStm, vTriaIndef)) ;
if ( IsNull( pStmIn) || IsNull( pStmOut) || IsNull( pStmOnP) || IsNull( pStmOnM) || IsNull( pStmIndef))
return GDB_ID_NULL ;
// le inserisco nel DB geometrico
int nStmIn = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, Release( pStmIn)) ;
int nStmOut = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, Release( pStmOut)) ;
int nStmOnP = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, Release( pStmOnP)) ;
int nStmOnM = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, Release( pStmOnM)) ;
int nStmIndef = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, Release( pStmIndef)) ;
// se tutto ok
if ( nStmIn != GDB_ID_NULL && nStmOut != GDB_ID_NULL && nStmOnP != GDB_ID_NULL && nStmOnM != GDB_ID_NULL && nStmIndef != GDB_ID_NULL) {
pGeomDB->Erase( nId) ;
nCount = 5 ;
return nStmIn ;
}
else {
pGeomDB->Erase( nStmIn) ;
pGeomDB->Erase( nStmOut) ;
pGeomDB->Erase( nStmOnP) ;
pGeomDB->Erase( nStmOnM) ;
pGeomDB->Erase( nStmIndef) ;
nCount = 0 ;
return GDB_ID_NULL ;
}
}
//----------------------------------------------------------------------------
int
ExeSurfTmSplit( int nId, int nSplitterId, int* pnCount)
{
int nCount ;
int nFirstId = MySurfTmSplit( nId, nSplitterId, nCount) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmSplit(" + ToString( nId) + "," +
ToString( nSplitterId) + ")" +
" -- Id1=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
if ( pnCount != nullptr)
*pnCount = nCount ;
return nFirstId ;
}
//----------------------------------------------------------------------------
static bool
MySurfTmCut( int nId, int nSplitterId, bool bInVsOut, bool bSaveOnEq)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la superficie TriMesh da dividere in parti
ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
if ( pStm == nullptr)
return false ;
// recupero il riferimento della superficie
Frame3d frSurf ;
if ( ! pGeomDB->GetGlobFrame( nId, frSurf))
return false ;
// recupero la superficie TriMesh divisore in locale alla prima
SurfLocal SurfCLoc( pGeomDB, nSplitterId, frSurf) ;
const ISurfTriMesh* pStmCLoc = GetSurfTriMesh( SurfCLoc) ;
if ( pStmCLoc == nullptr)
return false ;
// eseguo il taglio
return pStm->CutWithOtherSurf( *pStmCLoc, bInVsOut, bSaveOnEq) ;
}
//----------------------------------------------------------------------------
bool
ExeSurfTmCut( int nId, int nCutterId, bool bInVsOut, bool bSaveOnEq)
{
bool bOk = MySurfTmCut( nId, nCutterId, bInVsOut, bSaveOnEq) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmCut(" + ToString( nId) + "," +
ToString( nCutterId) + "," +
ToString( bInVsOut) + "," +
ToString( bSaveOnEq) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
return bOk ;
}
//----------------------------------------------------------------------------
bool
ExeSurfTmSubtractProjectedFacesOnFace( int nSurfId, int nFaceInd, int nDestGrpId,
INTVECTOR vSurfsId, bool bOCFlag,
bool& bExistProjection, int& nNewId, int& nNewFaceNbr)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la superficie TriMesh su cui proiettare
ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nSurfId)) ;
if ( pStm == nullptr)
return false ;
// recupero il riferimento della superficie
Frame3d frSurf ;
if ( ! pGeomDB->GetGlobFrame( nSurfId, frSurf))
return false ;
// recupero il riferimento del gruppo di destinazione
Frame3d frDest ;
if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest))
return false ;
// costruzione vettori di superfici e indici delle facce per proiezione
ISURFTMPOVECTOR vpStmOthers ;
vector<SurfLocal> vSurfCLoc ;
// recupero le altre superfici e le porto nel sistema di riferimento della prima
for ( int i = 0 ; i < int( vSurfsId.size()) ; ++ i) {
if ( pGeomDB->GetGeoType( vSurfsId[i]) != SRF_TRIMESH)
return false ;
vSurfCLoc.emplace_back( pGeomDB, vSurfsId[i], frSurf) ;
const ISurfTriMesh* pStmCurr = GetSurfTriMesh( vSurfCLoc.back().Get()) ;
vpStmOthers.emplace_back( pStmCurr->Clone()) ;
}
// eseguo la proiezione
ISurfTriMesh* pStmRes = nullptr ;
bool bOk = SubtractProjectedFacesOnStmFace( *pStm, nFaceInd, vpStmOthers, bOCFlag,
bExistProjection, pStmRes, nNewFaceNbr) ;
if ( ! bOk) {
delete( pStmRes) ;
pStmRes = nullptr ;
}
nNewId = GDB_ID_NULL ;
if ( bOk && pStmRes != nullptr) {
// porto nel sistema di riferimento destinazione
pStmRes->LocToLoc( frSurf, frDest) ;
// la inserisco nel DB geometrico
nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pStmRes) ;
if ( nNewId == GDB_ID_NULL)
return false ;
ExeSetModified() ;
}
if ( IsCmdLog()) {
string sLua = "EgtSubtractProjectedFacesOnStmFace(" + ToString( nSurfId) + "," +
ToString( nFaceInd) + "," +
ToString( nDestGrpId) + "," +
ToString( vSurfsId) + "," +
ToString( bOCFlag) + ")" +
" -- Ok=" + ToString( bOk) + " Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
return bOk ;
}
//----------------------------------------------------------------------------
static bool
MySurfBzTrim( int nId, int nTrimmerId)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, false)
// recupero la superficie Bezier da trimmare
ISurfBezier* pSrfBz = GetSurfBezier( pGeomDB->GetGeoObj( nId)) ;
if ( pSrfBz == nullptr)
return false ;
// recupero il riferimento della superficie
Frame3d frSurf ;
if ( ! pGeomDB->GetGlobFrame( nId, frSurf))
return false ;
// recupero la superficie TriMesh divisore in locale alla prima
SurfLocal SurfCLoc( pGeomDB, nTrimmerId, frSurf) ;
//const ISurfTriMesh* pStmCLoc = GetSurfTriMesh( SurfCLoc) ;
const ISurfFlatRegion* pSrfFr = GetSurfFlatRegion( SurfCLoc) ;
if ( pSrfFr == nullptr)
return false ;
PtrOwner<ISurfFlatRegion> pSrfFrCopy( pSrfFr->Clone()) ;
if ( ! pSrfFr->GetNormVersor().IsZplus())
pSrfFrCopy->Invert() ;
// eseguo il taglio
return pSrfBz->SetTrimRegion( *pSrfFrCopy) ;
}
//----------------------------------------------------------------------------
bool
ExeSurfBzTrim( int nId, int nCutterId)
{
bool bOk = MySurfBzTrim( nId, nCutterId) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmCut(" + ToString( nId) + "," +
ToString( nCutterId) + "," +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
return bOk ;
}
Reference in New Issue View Git Blame Copy Permalink