Egalware/EgtExecutor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
6214ff5926b1c9e32ac000b7d55f34ae3f8365c7
EgtExecutor/EXE_GdbCreateSurf.cpp
T
Daniele Bariletti 6214ff5926 EgtExecutor : 
- cambio della funzione CalcRegionPolyLines.
2024-08-29 09:17:39 +02:00

2344 lines
103 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2014-2015
//----------------------------------------------------------------------------
// File : EXE_GdbCreateSurf.cpp Data : 04.05.15 Versione : 1.6e1
// Contenuto : Funzioni di creazione superfici del DB geometrico per EXE.
//
//
//
// Modifiche : 02.11.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "EXE.h"
#include "EXE_Macro.h"
#include "AuxTools.h"
#include "GeoTools.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EGkStmStandard.h"
#include "/EgtDev/Include/EGkStmFromCurves.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include "/EgtDev/Include/EGkSurfBezier.h"
#include "/EgtDev/Include/EGkPolygon3d.h"
#include "/EgtDev/Include/EGkVolZmap.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkCurveLocal.h"
#include "/EgtDev/Include/EGkSurfLocal.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EGkSbzStandard.h"
#include "/EgtDev/Include/EGkSbzFromCurves.h"
using namespace std ;
//-------------------------------------------------------------------------------
int
ExeCreateSurfFrRectangle( int nParentId, const Point3d& ptIni, const Point3d& ptCross, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// recupero il riferimento locale
Frame3d frLoc ;
bool bOk = pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// porto in locale il punto e calcolo la normale in locale
Point3d ptIniL = GetPointLocal( pGeomDB, ptIni, nRefType, frLoc) ;
Point3d ptCrossL = GetPointLocal( pGeomDB, ptCross, nRefType, frLoc) ;
Point3d ptDirL = GetPointLocal( pGeomDB, ptIni + 100 * X_AX, nRefType, frLoc) ;
Vector3d vtZL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
// ne ricavo un riferimento intrinseco
Frame3d frEnt ;
bOk = bOk && frEnt.Set( ptIniL, ptDirL, ptCrossL) ;
if ( ( frEnt.VersZ() * vtZL) < 0)
frEnt.PseudoMirror( frEnt.Orig(), frEnt.VersZ()) ;
// ricavo le dimensioni della base
Point3d ptCrossI = GetToLoc( ptCrossL, frEnt) ;
double dWidth = ptCrossI.x ;
double dLen = ptCrossI.y ;
// creo il rettangolo nel suo riferimento intrinseco
PtrOwner<ISurfFlatRegion> pSfr( GetSurfFlatRegionRectangle( abs( dWidth), dLen)) ;
bOk = bOk && ! IsNull( pSfr) ;
// eventuale traslazione per larghezza negativa
if ( bOk && dWidth < 0)
pSfr->Translate( Vector3d( dWidth, 0, 0)) ;
// porto il rettangolo nel riferimento locale
bOk = bOk && pSfr->ToGlob( frEnt) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSfr)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfFrRectangle(" + IdToString( nParentId) + ",{" +
ToString( ptIni) + "}," +
ToString( ptCross) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfFrRectangle3P( int nParentId, const Point3d& ptIni,
const Point3d& ptCross, const Point3d& ptDir, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// recupero il riferimento locale
Frame3d frLoc ;
bool bOk = pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// porto in locale il punto e calcolo la normale in locale
Point3d ptIniL = GetPointLocal( pGeomDB, ptIni, nRefType, frLoc) ;
Point3d ptCrossL = GetPointLocal( pGeomDB, ptCross, nRefType, frLoc) ;
Point3d ptDirL = GetPointLocal( pGeomDB, ptDir, nRefType, frLoc) ;
Vector3d vtZL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
// ne ricavo un riferimento intrinseco
Frame3d frEnt ;
bOk = bOk && frEnt.Set( ptIniL, ptDirL, ptCrossL) ;
if ( ( frEnt.VersZ() * vtZL) < 0)
frEnt.PseudoMirror( frEnt.Orig(), frEnt.VersZ()) ;
// ricavo le dimensioni della base
Point3d ptCrossI = ptCrossL ;
ptCrossI.ToLoc( frEnt) ;
double dWidth = ptCrossI.x ;
double dLen = ptCrossI.y ;
// creo il rettangolo nel suo riferimento intrinseco
PtrOwner<ISurfFlatRegion> pSfr( GetSurfFlatRegionRectangle( abs( dWidth), dLen)) ;
bOk = bOk && ! IsNull( pSfr) ;
// eventuale traslazione per larghezza negativa
if ( bOk && dWidth < 0)
pSfr->Translate( Vector3d( dWidth, 0, 0)) ;
// porto il rettangolo nel riferimento locale
bOk = bOk && pSfr->ToGlob( frEnt) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSfr)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfFrRectangle3P(" + IdToString( nParentId) + ",{" +
ToString( ptIni) + "},{" +
ToString( ptCross) + "},{" +
ToString( ptDir) + "}," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfFrStadium( int nParentId, const Point3d& ptIni, const Point3d& ptCross, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// recupero il riferimento locale
Frame3d frLoc ;
bool bOk = pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// porto in locale il punto e calcolo la normale in locale
Point3d ptIniL = GetPointLocal( pGeomDB, ptIni, nRefType, frLoc) ;
Point3d ptCrossL = GetPointLocal( pGeomDB, ptCross, nRefType, frLoc) ;
Point3d ptDirL = GetPointLocal( pGeomDB, ptIni + 100 * X_AX, nRefType, frLoc) ;
Vector3d vtZL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
// ne ricavo un riferimento intrinseco
Frame3d frEnt ;
bOk = bOk && frEnt.Set( ptIniL, ptDirL, ptCrossL) ;
if ( ( frEnt.VersZ() * vtZL) < 0)
frEnt.PseudoMirror( frEnt.Orig(), frEnt.VersZ()) ;
// ricavo le dimensioni della base
Point3d ptCrossI = ptCrossL ;
ptCrossI.ToLoc( frEnt) ;
double dWidth = ptCrossI.x ;
double dLen = ptCrossI.y ;
// creo lo stadium nel suo riferimento intrinseco
PtrOwner<ISurfFlatRegion> pSfr( GetSurfFlatRegionStadium( abs( dWidth), dLen)) ;
bOk = bOk && ! IsNull( pSfr) ;
// eventuale traslazione per larghezza negativa
if ( bOk && dWidth < 0)
pSfr->Translate( Vector3d( dWidth, 0, 0)) ;
// porto lo stadium nel riferimento locale
bOk = bOk && pSfr->ToGlob( frEnt) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSfr)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfFrStadium(" + IdToString( nParentId) + ",{" +
ToString( ptIni) + "}," +
ToString( ptCross) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfFrDisk( int nParentId, const Point3d& ptOrig, double dRad, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// recupero il riferimento locale
Frame3d frLoc ;
bool bOk = pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// porto in locale il punto e calcolo la normale in locale
Point3d ptOrigL = GetPointLocal( pGeomDB, ptOrig, nRefType, frLoc) ;
Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
// calcolo riferimento per l'entità
Frame3d frEnt ;
bOk = bOk && frEnt.Set( ptOrigL, vtNL) ;
// creo il disco nel suo riferimento intrinseco
PtrOwner<ISurfFlatRegion> pSfr( GetSurfFlatRegionDisk( dRad)) ;
bOk = bOk && ! IsNull( pSfr) ;
// porto il disco nel riferimento locale
bOk = bOk && pSfr->ToGlob( frEnt) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSfr)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfFrDisk(" + IdToString( nParentId) + ",{" +
ToString( ptOrig) + "}," +
ToString( dRad) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfFrFatCurve( int nParentId, int nCrvId, double dRad, bool bSquaredEnds, bool bSquaredMids, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// recupero il riferimento locale
Frame3d frLoc ;
bool bOk = pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero riferimento della curva
Frame3d frCrv ;
if ( ! pGeomDB->GetGlobFrame( nCrvId, frCrv))
return GDB_ID_NULL ;
// recupero la curva
ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
if ( pCrv == nullptr)
return GDB_ID_NULL ;
// ne faccio una copia
PtrOwner<ICurve> pCopCrv( pCrv->Clone()) ;
if ( IsNull( pCopCrv))
return GDB_ID_NULL ;
// eseguo la trasformazione (viene eseguita solo se i riferimenti sono diversi
pCopCrv->LocToLoc( frCrv, frLoc) ;
// creo la regione
PtrOwner<ISurfFlatRegion> pSfr( GetSurfFlatRegionFromFatCurve( Release( pCopCrv), dRad, bSquaredEnds, bSquaredMids, dLinTol)) ;
bOk = bOk && ! IsNull( pSfr) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSfr)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfFrFatCurve(" + IdToString( nParentId) + "," +
ToString( nCrvId) + "," +
ToString( dRad) + "," +
ToString( bSquaredEnds) + "," +
ToString( bSquaredMids) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
static int
MyCreateSurfFlatRegion( int nParentId, const INTVECTOR& vCrvIds, int* pnCount)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// recupero il riferimento locale
Frame3d frLoc ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
return GDB_ID_NULL ;
// costruisco la regione piana
SurfFlatRegionByContours SfrCntr ;
// creo le copie locali delle curve
for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
int nId = (( vCrvIds[i] != GDB_ID_SEL) ? vCrvIds[i] : pGeomDB->GetFirstSelectedObj()) ;
while ( nId != GDB_ID_NULL) {
// recupero riferimento della curva
Frame3d frCrv ;
if ( ! pGeomDB->GetGlobFrame( nId, frCrv))
return GDB_ID_NULL ;
// recupero la curva
ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCrv == nullptr)
return GDB_ID_NULL ;
// ne faccio una copia
PtrOwner<ICurve> pCopCrv( pCrv->Clone()) ;
if ( IsNull( pCopCrv))
return GDB_ID_NULL ;
// eseguo la trasformazione (viene eseguita solo se i riferimenti sono diversi
pCopCrv->LocToLoc( frCrv, frLoc) ;
// la assegno al costruttore della regione
SfrCntr.AddCurve( Release( pCopCrv)) ;
// passo al successivo
nId = (( vCrvIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
}
}
// recupero le regioni
int nFirstId = GDB_ID_NULL ;
int nCount = 0 ;
ISurfFlatRegion* pSfr = SfrCntr.GetSurf() ;
while ( pSfr != nullptr) {
// inserisco la superficie nel DB
int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSfr) ;
if ( nNewId == GDB_ID_NULL)
return GDB_ID_NULL ;
if ( nFirstId == GDB_ID_NULL)
nFirstId = nNewId ;
++ nCount ;
// recupero la prossima superficie
pSfr = SfrCntr.GetSurf() ;
}
// restituisco l'identificativo della prima nuova entità
if ( pnCount != nullptr)
*pnCount = nCount ;
return nFirstId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfFlatRegion( int nParentId, const INTVECTOR& vCrvIds, int* pnCount)
{
// eseguo
int nCount = 0 ;
int nFirstId = MyCreateSurfFlatRegion( nParentId, vCrvIds, &nCount) ;
if ( pnCount != nullptr)
*pnCount = nCount ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfFlatRegion(" + IdToString( nParentId) + ",{" +
IdListToString( vCrvIds) + "})" +
" -- Id=" + ToString( nFirstId) + ",Nbr=" + ToString( nCount) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nFirstId ;
}
//-------------------------------------------------------------------------------
static int
MyCreateSurfTmPlaneInBBox( int nParentId, const Point3d& ptP, const Vector3d& vtN, const BBox3d& b3Box, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// costruisco il piano nel box
Plane3d plPlane ;
plPlane.Set( ptP, vtN) ;
PtrOwner<ISurfTriMesh> pStm( GetSurfTriMeshPlaneInBox( plPlane, b3Box, true, false)) ;
if ( IsNull( pStm))
return GDB_ID_NULL ;
// recupero il riferimento locale del gruppo destinazione
Frame3d frLoc ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
return GDB_ID_NULL ;
// se necessario, porto la superficie piano trimmato nel riferimento locale
if ( nRefType == RTY_GLOB)
pStm->ToLoc( frLoc) ;
else if ( nRefType == RTY_GRID)
pStm->LocToLoc( pGeomDB->GetGridFrame(), frLoc) ;
// inserisco la superficie nel DB
int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) ;
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmPlaneInBBox( int nParentId, const Point3d& ptP, const Vector3d& vtN, const BBox3d& b3Box, int nRefType)
{
// creo il piano
int nNewId = MyCreateSurfTmPlaneInBBox( nParentId, ptP, vtN, b3Box, nRefType) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmPlaneInBBox(" + IdToString( nParentId) + ",{" +
ToString( ptP) + "},{" +
ToString( vtN) + "},{{" +
ToString( b3Box.GetMin()) + "},{" +
ToString( b3Box.GetMax()) + "}}," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
static Triangle3d
MyCreateSidePlaneHull( const PNTVECTOR& vVert, bool bNXp, const BBox3d& b3Box, int nFace)
{
// determino i vertici della superficie sui bordi della faccia Z+ del BBox
Triangle3d Tria ;
for ( int i = 0 ; i < int( vVert.size()) ; ++ i) {
if ( ( nFace == +2 && abs( vVert[i].y - b3Box.GetMax().y) > 100 * EPS_SMALL) ||
( nFace == -2 && abs( vVert[i].y - b3Box.GetMin().y) > 100 * EPS_SMALL) ||
( nFace == +3 && abs( vVert[i].z - b3Box.GetMax().z) > 100 * EPS_SMALL) ||
( nFace == -3 && abs( vVert[i].z - b3Box.GetMin().z) > 100 * EPS_SMALL))
continue ;
if ( ( nFace == +2 && abs( vVert[i].z - b3Box.GetMin().z) < 10 * EPS_SMALL) ||
( nFace == -2 && abs( vVert[i].z - b3Box.GetMax().z) < 10 * EPS_SMALL) ||
( nFace == +3 && abs( vVert[i].y - b3Box.GetMax().y) < 10 * EPS_SMALL) ||
( nFace == -3 && abs( vVert[i].y - b3Box.GetMin().y) < 10 * EPS_SMALL)) {
int nI = ( bNXp ? 0 : 1) ;
Tria.SetP( nI, vVert[i]) ;
Tria.SetAttrib( nI, i) ;
Tria.SetGrade( Tria.GetGrade() + 2) ;
continue ;
}
if ( ( nFace == +2 && abs( vVert[i].z - b3Box.GetMax().z) < 10 * EPS_SMALL) ||
( nFace == -2 && abs( vVert[i].z - b3Box.GetMin().z) < 10 * EPS_SMALL) ||
( nFace == +3 && abs( vVert[i].y - b3Box.GetMin().y) < 10 * EPS_SMALL) ||
( nFace == -3 && abs( vVert[i].y - b3Box.GetMax().y) < 10 * EPS_SMALL)) {
int nI = ( bNXp ? 1 : 0) ;
Tria.SetP( nI, vVert[i]) ;
Tria.SetAttrib( nI, i) ;
Tria.SetGrade( Tria.GetGrade() + 1) ;
continue ;
}
}
Tria.SetAttrib( 2, -1) ;
if ( Tria.GetGrade() != 3)
return Tria ;
// determino il piano passante per questa linea che racchiude tutti i punti
for ( int i = 0 ; i < int( vVert.size()) ; ++ i) {
if ( i != Tria.GetAttrib( 0) && i != Tria.GetAttrib( 1)) {
if ( Tria.GetAttrib( 2) == -1 ||
( ( vVert[i] - Tria.GetP( 0)) * Tria.GetN() > EPS_ZERO)) {
Tria.SetP( 2, vVert[i]) ;
Tria.Validate( true) ;
Tria.SetAttrib( 2, i) ;
}
}
}
return Tria ;
}
//----------------------------------------------------------------------------
static bool
MyCreateSewPolygon( ISurfTriMesh* pStm, const Polygon3d& Polyg)
{
// verifico esistenza superficie
if ( pStm == nullptr)
return false ;
// se poligono vuoto, non devo fare alcunché
if ( Polyg.GetSideCount() == 0)
return true ;
// creo la superficie trimesh del poligono
PtrOwner<ISurfTriMesh> pStm2( CreateSurfTriMesh()) ;
if ( IsNull( pStm2) || ! pStm2->CreateByFlatContour( Polyg.GetPolyLine()))
return false ;
// le unisco
return pStm->DoSewing( *pStm2) ;
}
//-------------------------------------------------------------------------------
static int
MyCreateSurfTmConvexHullInBBox( int nParentId, int nId, const BBox3d& b3Box, int nRefType)
{
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 suo riferimento e lo porto in quello indicato
Frame3d frStm ;
if ( ! pGeomDB->GetGlobFrame( nId, frStm))
return GDB_ID_NULL ;
frStm = GetFrameInRef( pGeomDB, frStm, GLOB_FRM, nRefType) ;
// ne calcolo la normale media
Vector3d vtN ;
Triangle3d Tria ;
int nT = pStm->GetFirstTriangle( Tria) ;
while ( nT != SVT_NULL) {
// sommo la normale moltiplicata per l'area del triangolo
vtN += Tria.GetArea() * Tria.GetN() ;
// passo al triangolo successivo
nT = pStm->GetNextTriangle( nT, Tria) ;
}
if ( ! vtN.Normalize())
return GDB_ID_NULL ;
vtN.ToGlob( frStm) ;
bool bNXp = ( vtN.x >= 0) ;
// recupero i vertici e li porto nel riferimento indicato
PNTVECTOR vVert ;
for ( int i = 0 ; i < pStm->GetVertexSize() ; ++ i) {
Point3d ptP ;
if ( pStm->GetVertex( i, ptP)) {
ptP.ToGlob( frStm) ;
vVert.emplace_back( ptP) ;
}
}
// determino i piani che racchiudono tutta la superficie dalle tracce sulla facce laterali della stessa
Triangle3d vTria[4] ;
vTria[0] = MyCreateSidePlaneHull( vVert, bNXp, b3Box, +3) ;
vTria[1] = MyCreateSidePlaneHull( vVert, bNXp, b3Box, -3) ;
vTria[2] = MyCreateSidePlaneHull( vVert, bNXp, b3Box, +2) ;
vTria[3] = MyCreateSidePlaneHull( vVert, bNXp, b3Box, -2) ;
// invalido i triangoli con normale opposta alla direzione attesa
for ( int i = 0 ; i < 4 ; ++ i) {
if ( abs( vTria[i].GetN().x) < 0.1 || ( vTria[i].GetN().x > 0) != bNXp)
vTria[i].Set( vTria[i].GetP( 0), vTria[i].GetP( 1), vTria[i].GetP( 2)) ;
}
// cerco uno o due piani validi
int nPlane1 = -1 ;
int nPlane2 = -1 ;
for ( int i = 0 ; i < 4 ; ++ i) {
if ( ! vTria[i].IsValid())
continue ;
nPlane1 = i ;
for ( int j = i + 1 ; j < 4 ; ++ j) {
if ( vTria[j].IsValid() &&
abs( vTria[i].GetN() * vTria[j].GetN()) < 0.94) {
nPlane2 = j ;
break ;
}
}
break ;
}
// se nessun piano valido
if ( nPlane1 == -1)
return GDB_ID_NULL ;
// se un solo piano valido
if ( nPlane2 == -1)
return MyCreateSurfTmPlaneInBBox( nParentId, vTria[nPlane1].GetP( 0), vTria[nPlane1].GetN(), b3Box, nRefType) ;
// altrimenti due piani validi
Polygon3d Polyg1 ;
if ( ! Polyg1.FromPlaneTrimmedWithBox( vTria[nPlane1].GetPlane(), b3Box.GetMin(), b3Box.GetMax(), true, false))
return GDB_ID_NULL ;
Polygon3d Polyg2 ;
if ( ! Polyg2.FromPlaneTrimmedWithBox( vTria[nPlane2].GetPlane(), b3Box.GetMin(), b3Box.GetMax(), true, false))
return GDB_ID_NULL ;
if ( ! Polyg1.Trim( Polyg2, true, true, false) || ! Polyg2.Trim( Polyg1, true, false, false))
return GDB_ID_NULL ;
// creo la trimesh dalle due facce
PtrOwner<ISurfTriMesh> pChStm( CreateSurfTriMesh()) ;
if ( IsNull( pChStm))
return GDB_ID_NULL ;
if ( ! MyCreateSewPolygon( pChStm, Polyg1) ||
! MyCreateSewPolygon( pChStm, Polyg2))
return GDB_ID_NULL ;
pChStm->DoCompacting() ;
// recupero il riferimento locale del gruppo destinazione
Frame3d frLoc ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
return GDB_ID_NULL ;
// se necessario, porto la superficie piano trimmato nel riferimento locale
if ( nRefType == RTY_GLOB)
pChStm->ToLoc( frLoc) ;
else if ( nRefType == RTY_GRID)
pChStm->LocToLoc( pGeomDB->GetGridFrame(), frLoc) ;
// inserisco la superficie nel DB
int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pChStm)) ;
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmConvexHullInBBox( int nParentId, int nId, const BBox3d& b3Box, int nRefType)
{
// creo il piano
int nNewId = MyCreateSurfTmConvexHullInBBox( nParentId, nId, b3Box, nRefType) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmConvexHullInBBox(" + IdToString( nParentId) + "," +
IdToString( nId) + ",{" +
ToString( b3Box.GetMin()) + "},{" +
ToString( b3Box.GetMax()) + "}}," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmBBox( int nParentId, const BBox3d& b3Box, bool bRegular, int nRefType)
{
// bounding box orientato come gli assi del riferimento
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// recupero il riferimento locale
Frame3d frLoc ;
bool bOk = pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// ricavo i punti standard e le dimensioni
Point3d ptIni ;
double dWidth = 0, dLen = 0, dHeight = 0 ;
bOk = bOk && b3Box.GetMinDim( ptIni, dWidth, dLen, dHeight) ;
dWidth = max( dWidth, 10 * EPS_SMALL) ;
dLen = max( dLen, 10 * EPS_SMALL) ;
dHeight = max( dHeight, 10 * EPS_SMALL) ;
Point3d ptCross = ptIni + Vector3d( dWidth, dLen) ;
Point3d ptDir = ptIni + Vector3d( dWidth, 0) ;
// porto in locale i punti
Point3d ptIniL = GetPointLocal( pGeomDB, ptIni, nRefType, frLoc) ;
Point3d ptCrossL = GetPointLocal( pGeomDB, ptCross, nRefType, frLoc) ;
Point3d ptDirL = GetPointLocal( pGeomDB, ptDir, nRefType, frLoc) ;
// ne ricavo un riferimento intrinseco
Frame3d frBox ;
bOk = bOk && frBox.Set( ptIniL, ptDirL, ptCrossL) ;
// creo il box nel suo riferimento intrinseco
PtrOwner<ISurfTriMesh> pSTM( GetSurfTriMeshBox( dWidth, dLen, dHeight, bRegular)) ;
bOk = bOk && ! IsNull( pSTM) ;
// porto il box nel riferimento locale
bOk = bOk && pSTM->ToGlob( frBox) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmBBox(" + IdToString( nParentId) + ",{{" +
ToString( b3Box.GetMin()) + "},{" +
ToString( b3Box.GetMax()) + "}}," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmBox( int nParentId, const Point3d& ptIni, const Point3d& ptCross,
const Point3d& ptDir, double dHeight, bool bRegular, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// recupero il riferimento locale
Frame3d frLoc ;
bool bOk = pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// porto in locale i punti
Point3d ptIniL = GetPointLocal( pGeomDB, ptIni, nRefType, frLoc) ;
Point3d ptCrossL = GetPointLocal( pGeomDB, ptCross, nRefType, frLoc) ;
Point3d ptDirL = GetPointLocal( pGeomDB, ptDir, nRefType, frLoc) ;
Vector3d vtZL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
// vettore Cross e Dir non possono formare una angolo superiore o uguale al retto
if ( ( ptCrossL - ptIniL) * ( ptDirL - ptIniL) < 0)
ptDirL = ptIniL -( ptDirL - ptIniL) ;
// ne ricavo un riferimento intrinseco
Frame3d frBox ;
bOk = bOk && frBox.Set( ptIniL, ptDirL, ptCrossL) ;
if ( ( frBox.VersZ() * vtZL) < - EPS_SMALL)
frBox.PseudoMirror( frBox.Orig(), frBox.VersZ()) ;
// ricavo le dimensioni della base
Point3d ptCrossI = ptCrossL ;
ptCrossI.ToLoc( frBox) ;
double dWidth = ptCrossI.x ;
double dLen = ptCrossI.y ;
// creo il box nel suo riferimento intrinseco
PtrOwner<ISurfTriMesh> pSTM( GetSurfTriMeshBox( abs( dWidth), dLen, dHeight, bRegular)) ;
bOk = bOk && ! IsNull( pSTM) ;
// eventuale traslazione per larghezza negativa
if ( bOk && dWidth < 0)
pSTM->Translate( Vector3d( dWidth, 0, 0)) ;
// porto il box nel riferimento locale
bOk = bOk && pSTM->ToGlob( frBox) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmBox(" + IdToString( nParentId) + ",{" +
ToString( ptIni) + "},{" +
ToString( ptCross) + "},{" +
ToString( ptDir) + "}," +
ToString( dHeight) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmPyramid( int nParentId, const Point3d& ptIni, const Point3d& ptCross,
const Point3d& ptDir, double dHeight, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
return GDB_ID_NULL ;
// porto in locale i punti
Point3d ptIniL = GetPointLocal( pGeomDB, ptIni, nRefType, frLoc) ;
Point3d ptCrossL = GetPointLocal( pGeomDB, ptCross, nRefType, frLoc) ;
Point3d ptDirL = GetPointLocal( pGeomDB, ptDir, nRefType, frLoc) ;
Vector3d vtZL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
// vettore Cross e Dir non possono formare una angolo superiore o uguale al retto
if ( ( ptCrossL - ptIniL) * ( ptDirL - ptIniL) < 0)
ptDirL = ptIniL -( ptDirL - ptIniL) ;
// ne ricavo un riferimento intrinseco
Frame3d frBox ;
bOk = bOk && frBox.Set( ptIniL, ptDirL, ptCrossL) ;
if ( ( frBox.VersZ() * vtZL) < - EPS_SMALL)
frBox.PseudoMirror( frBox.Orig(), frBox.VersZ()) ;
// ricavo le dimensioni della base
Point3d ptCrossI = ptCrossL ;
ptCrossI.ToLoc( frBox) ;
double dWidth = ptCrossI.x ;
double dLen = ptCrossI.y ;
// creo la piramide nel suo riferimento intrinseco
PtrOwner<ISurfTriMesh> pSTM( GetSurfTriMeshPyramid( abs( dWidth), dLen, dHeight)) ;
bOk = bOk && ! IsNull( pSTM) ;
// eventuale traslazione per larghezza negativa
if ( bOk && dWidth < 0)
pSTM->Translate( Vector3d( dWidth, 0, 0)) ;
// porto la piramide nel riferimento locale
bOk = bOk && pSTM->ToGlob( frBox) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmPyramid(" + IdToString( nParentId) + ",{" +
ToString( ptIni) + "},{" +
ToString( ptCross) + "},{" +
ToString( ptDir) + "}," +
ToString( dHeight) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmCylinder( int nParentId, const Point3d& ptOrig, const Vector3d& vtN,
double dRad, double dHeight, double dLinTol, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// porto in locale il punto e il versore
Point3d ptOrigL = GetPointLocal( pGeomDB, ptOrig, nRefType, frLoc) ;
Vector3d vtNL = GetVectorLocal( pGeomDB, vtN, nRefType, frLoc) ;
// calcolo riferimento OCS a partire da questo punto e versore
Frame3d frCyl ;
bOk = bOk && frCyl.Set( ptOrigL, vtNL) ;
// creo il cilindro nel suo riferimento intrinseco
PtrOwner<ISurfTriMesh> pSTM( GetSurfTriMeshCylinder( dRad, dHeight, dLinTol)) ;
bOk = bOk && ! IsNull( pSTM) ;
// porto il cilindro nel riferimento locale
bOk = bOk && pSTM->ToGlob( frCyl) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmCylinder(" + IdToString( nParentId) + ",{" +
ToString( ptOrig) + "},{" +
ToString( vtN) + "}," +
ToString( dRad) + "," +
ToString( dHeight) + "," +
ToString( dLinTol) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmCone( int nParentId, const Point3d& ptOrig, const Vector3d& vtN,
double dRad, double dHeight, double dLinTol, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// porto in locale il punto e il versore
Point3d ptOrigL = GetPointLocal( pGeomDB, ptOrig, nRefType, frLoc) ;
Vector3d vtNL = GetVectorLocal( pGeomDB, vtN, nRefType, frLoc) ;
// calcolo riferimento OCS a partire da questo punto e versore
Frame3d frCyl ;
bOk = bOk && frCyl.Set( ptOrigL, vtNL) ;
// creo il cono nel suo riferimento intrinseco
PtrOwner<ISurfTriMesh> pSTM( GetSurfTriMeshCone( dRad, dHeight, dLinTol)) ;
bOk = bOk && ! IsNull( pSTM) ;
// porto il cono nel riferimento locale
bOk = bOk && pSTM->ToGlob( frCyl) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmCone(" + IdToString( nParentId) + ",{" +
ToString( ptOrig) + "},{" +
ToString( vtN) + "}," +
ToString( dRad) + "," +
ToString( dHeight) + "," +
ToString( dLinTol) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmSphere( int nParentId, const Point3d& ptOrig,
double dRad, double dLinTol, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// porto in locale il punto
Point3d ptOrigL = GetPointLocal( pGeomDB, ptOrig, nRefType, frLoc) ;
// creo la sfera
PtrOwner<ISurfTriMesh> pSTM( GetSurfTriMeshSphere( dRad, dLinTol)) ;
bOk = bOk && ! IsNull( pSTM) ;
// porto la sfera nella sua origine
bOk = bOk && pSTM->Translate( ptOrigL - ORIG) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmSphere(" + IdToString( nParentId) + ",{" +
ToString( ptOrig) + "}," +
ToString( dRad) + "," +
ToString( dLinTol) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmTriangle( int nParentId, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptP3, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// recupero il riferimento locale
Frame3d frLoc ;
bool bOk = pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// porto in locale i punti
Point3d ptP1L = GetPointLocal( pGeomDB, ptP1, nRefType, frLoc) ;
Point3d ptP2L = GetPointLocal( pGeomDB, ptP2, nRefType, frLoc) ;
Point3d ptP3L = GetPointLocal( pGeomDB, ptP3, nRefType, frLoc) ;
// creo la superficie trimesh
PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
bOk = bOk && ! IsNull( pStm) ;
// assegno il triangolo
if ( bOk) {
pStm->Init( 3, 1, 1) ;
int vV[3]{ pStm->AddVertex( ptP1L),
pStm->AddVertex( ptP2L),
pStm->AddVertex( ptP3L)} ;
bOk = ( pStm->AddTriangle( vV) != SVT_NULL) && pStm->AdjustTopology() ;
}
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmTriangle(" + IdToString( nParentId) + ",{" +
ToString( ptP1) + "},{" +
ToString( ptP2) + "},{" +
ToString( ptP3) + "}," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmRectangle( int nParentId, const Point3d& ptO, const Point3d& ptL, const Point3d& ptT, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// recupero il riferimento locale
Frame3d frLoc ;
bool bOk = pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// porto in locale i punti
Point3d ptOL = GetPointLocal( pGeomDB, ptO, nRefType, frLoc) ;
Point3d ptLL = GetPointLocal( pGeomDB, ptL, nRefType, frLoc) ;
Point3d ptTL = GetPointLocal( pGeomDB, ptT, nRefType, frLoc) ;
// modifico il punto trasversale per metterlo perpendicolare al lato Lungo
ptTL -= ParallCompo( ptTL - ptOL, ptLL - ptOL) ;
// calcolo il quarto punto
Point3d ptVL = ptTL + ( ptLL - ptOL) ;
// creo la superficie trimesh
PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
bOk = bOk && ! IsNull( pStm) ;
// assegno il triangolo
if ( bOk) {
pStm->Init( 4, 2, 1) ;
int vV[4]{ pStm->AddVertex( ptOL),
pStm->AddVertex( ptLL),
pStm->AddVertex( ptTL),
pStm->AddVertex( ptVL)} ;
int vV1[3]{ vV[0], vV[1], vV[2] } ;
int vV2[3]{ vV[2], vV[1], vV[3] } ;
bOk = ( pStm->AddTriangle( vV1) != SVT_NULL) && ( pStm->AddTriangle( vV2) != SVT_NULL) && pStm->AdjustTopology() ;
}
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmRectangle(" + IdToString( nParentId) + ",{" +
ToString( ptO) + "},{" +
ToString( ptL) + "},{" +
ToString( ptT) + "}," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmByFlatContour( int nParentId, int nCrvId, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero la curva in locale
CurveLocal CrvLoc( pGeomDB, nCrvId, frLoc) ;
bOk = bOk && ( CrvLoc.Get() != nullptr) ;
// calcolo la superficie
ISurfTriMesh* pSTM = ( bOk ? GetSurfTriMeshByFlatContour( CrvLoc, dLinTol) : nullptr) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmByFlatContour(" + IdToString( nParentId) + "," +
ToString( nCrvId) + "," +
ToString( dLinTol) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmByRegion( int nParentId, const INTVECTOR& vCrvIds, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero le curve in locale
CURVELOCALVECTOR vCrvLoc ;
vCrvLoc.reserve( vCrvIds.size()) ;
CICURVEPVECTOR vCrvP ;
vCrvP.reserve( vCrvIds.size()) ;
for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
int nId = (( vCrvIds[i] != GDB_ID_SEL) ? vCrvIds[i] : pGeomDB->GetFirstSelectedObj()) ;
while ( nId != GDB_ID_NULL) {
vCrvLoc.emplace_back( pGeomDB, nId, frLoc) ;
vCrvP.push_back( vCrvLoc.back().Get()) ;
bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
// passo al successivo
nId = (( vCrvIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
}
}
// calcolo la superficie
ISurfTriMesh* pSTM = ( bOk ? GetSurfTriMeshByRegion( vCrvP, dLinTol) : 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, nParentId, pSTM) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmByRegion(" + IdToString( nParentId) + ",{" +
IdListToString( vCrvIds) + "}," +
ToString( dLinTol) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmByExtrusion( int nParentId, const INTVECTOR& vCrvIds, const Vector3d& vtExtr,
double dLinTol, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero le curve in locale
CURVELOCALVECTOR vCrvLoc ;
vCrvLoc.reserve( vCrvIds.size()) ;
ICURVEPVECTOR vCrvP ;
vCrvP.reserve( vCrvIds.size()) ;
for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
int nId = (( vCrvIds[i] != GDB_ID_SEL) ? vCrvIds[i] : pGeomDB->GetFirstSelectedObj()) ;
while ( nId != GDB_ID_NULL) {
vCrvLoc.emplace_back( pGeomDB, nId, frLoc) ;
vCrvP.push_back( const_cast<ICurve*>( vCrvLoc.back().Get())) ;
bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
// passo al successivo
nId = (( vCrvIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
}
}
// porto in locale il vettore estrusione
Vector3d vtExtrL = GetVectorLocal( pGeomDB, vtExtr, nRefType, frLoc) ;
// creo le superfici e le inserisco nel DB
int nFirstId = GDB_ID_NULL ;
for ( int i = 0 ; i < int( vCrvP.size()) ; ++ i) {
// calcolo la superficie
ISurfTriMesh* pSTM = ( bOk ? GetSurfTriMeshByExtrusion( vCrvP[i], vtExtrL, false, dLinTol) : nullptr) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
bOk = bOk && ( nNewId != GDB_ID_NULL) ;
if ( bOk && nFirstId == GDB_ID_NULL)
nFirstId = nNewId ;
}
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmByExtrusion(" + IdToString( nParentId) + ",{" +
IdListToString( vCrvIds) + "},{" +
ToString( vtExtr) + "}," +
ToString( dLinTol) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nFirstId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nFirstId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmByRegionExtrusion( int nParentId, const INTVECTOR& vCrvIds, const Vector3d& vtExtr,
double dLinTol, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero le curve in locale
CURVELOCALVECTOR vCrvLoc ;
vCrvLoc.reserve( vCrvIds.size()) ;
CICURVEPVECTOR vCrvP ;
vCrvP.reserve( vCrvIds.size()) ;
for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
vCrvLoc.emplace_back( pGeomDB, vCrvIds[i], frLoc) ;
vCrvP.push_back( vCrvLoc[i].Get()) ;
bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
}
// porto in locale il vettore estrusione
Vector3d vtExtrL = GetVectorLocal( pGeomDB, vtExtr, nRefType, frLoc) ;
int nNewId = GDB_ID_NULL ;
// creo la superficie
ISurfTriMesh* pSTM = ( bOk ? GetSurfTriMeshByRegionExtrusion( vCrvP, vtExtrL, dLinTol) : nullptr) ;
// inserisco la superficie nel DB
nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmByRegionExtrusion(" + IdToString( nParentId) + ",{" +
IdListToString( vCrvIds) + "},{" +
ToString( vtExtr) + "}," +
ToString( dLinTol) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmByRevolve( int nParentId, int nCrvId,
const Point3d& ptAx, const Vector3d& vtAx,
bool bCapEnds, double dLinTol, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero la curva in locale
CurveLocal CrvLoc( pGeomDB, nCrvId, frLoc) ;
bOk = bOk && ( CrvLoc.Get() != nullptr) ;
// porto in locale punto e vettore asse
Point3d ptAxL = GetPointLocal( pGeomDB, ptAx, nRefType, frLoc) ;
Vector3d vtAxL = GetVectorLocal( pGeomDB, vtAx, nRefType, frLoc) ;
// calcolo la superficie
ISurfTriMesh* pSTM = ( bOk ? GetSurfTriMeshByRevolve( CrvLoc, ptAxL, vtAxL, bCapEnds, dLinTol) : nullptr) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmByRevolve(" + IdToString( nParentId) + "," +
ToString( nCrvId) + ",{" +
ToString( ptAx) + "},{" +
ToString( vtAx) + "}," +
( bCapEnds ? "true" : "false") + "," +
ToString( dLinTol) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfBzByPointCurve( int nParentId, int nCrvId, const Point3d& ptTop,
bool bCapEnds, double dLinTol, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero la curva in locale
CurveLocal CrvLoc( pGeomDB, nCrvId, frLoc) ;
bOk = bOk && ( CrvLoc.Get() != nullptr) ;
// porto in locale punto e vettore asse
Point3d ptTopL = GetPointLocal( pGeomDB, ptTop, nRefType, frLoc) ;
// calcolo la superficie
ISurfBezier* pSTM = ( bOk ? GetSurfBezierRuled( ptTopL, CrvLoc, dLinTol) : nullptr) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfBzByPointCurve(" + IdToString( nParentId) + "," +
ToString( nCrvId) + ",{" +
ToString( ptTop) + "},{" +
( bCapEnds ? "true" : "false") + "," +
ToString( dLinTol) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmByScrewing( int nParentId, int nCrvId,
const Point3d& ptAx, const Vector3d& vtAx,
double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero la curva in locale
CurveLocal CrvLoc( pGeomDB, nCrvId, frLoc) ;
bOk = bOk && ( CrvLoc.Get() != nullptr) ;
// porto in locale punto e vettore asse
Point3d ptAxL = GetPointLocal( pGeomDB, ptAx, nRefType, frLoc) ;
Vector3d vtAxL = GetVectorLocal( pGeomDB, vtAx, nRefType, frLoc) ;
// calcolo la superficie
ISurfTriMesh* pSTM = ( bOk ? GetSurfTriMeshByScrewing( CrvLoc, ptAxL, vtAxL, dAngRotDeg, dMove, bCapEnds, dLinTol) : nullptr) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmByScrewing(" + IdToString( nParentId) + "," +
ToString( nCrvId) + ",{" +
ToString( ptAx) + "},{" +
ToString( vtAx) + "}," +
ToString( dAngRotDeg) + "," +
ToString( dMove) + "," +
( bCapEnds ? "true" : "false") + "," +
ToString( dLinTol) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmRectSwept( int nParentId, double dDimH, double dDimV, double dBevelH, double dBevelV,
int nGuideId, int nCapType, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero la guida in locale
CurveLocal CrvGuide( pGeomDB, nGuideId, frLoc) ;
bOk = bOk && ( CrvGuide.Get() != nullptr) ;
// creo la superficie trimesh
ISurfTriMesh* pSTM = nullptr ;
pSTM = ( bOk ? GetSurfTriMeshRectSwept( dDimH, dDimV, dBevelH, dBevelV, CrvGuide, nCapType, dLinTol) : nullptr) ;
// inserisco la superficie trimesh nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmRectSwept(" + IdToString( nParentId) + "," +
ToString( dDimH) + "," +
ToString( dDimV) + "," +
ToString( dBevelH) + "," +
ToString( dBevelV) + "," +
ToString( nGuideId) + "," +
ToString( nCapType) + "," +
ToString( dLinTol) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmSwept( int nParentId, int nSectId, int nGuideId, const Vector3d& vtAx,
bool bCapEnds, double dLinTol, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero la guida in locale
CurveLocal CrvGuide( pGeomDB, nGuideId, frLoc) ;
bOk = bOk && ( CrvGuide.Get() != nullptr) ;
// porto in locale vettore asse
Vector3d vtAxL = GetVectorLocal( pGeomDB, vtAx, nRefType, frLoc) ;
// inizializzazione superficie e suo Id
ISurfTriMesh* pSTM = nullptr ;
int nNewId = GDB_ID_NULL ;
// recupero il tipo di entità della sezione
int nSecType = pGeomDB->GetGeoType( nSectId) ;
// controllo se la sezione è definita da una curva
if ( ( nSecType & GEO_CURVE) != 0) {
// recupero la sezione in locale
CurveLocal CrvSect( pGeomDB, nSectId, frLoc) ;
bOk = bOk && ( CrvSect.Get() != nullptr) ;
// calcolo la Swept
pSTM = ( bOk ? GetSurfTriMeshSwept( CrvSect, CrvGuide, vtAxL, bCapEnds, dLinTol) : nullptr) ;
// inserisco la superficie trimesh nel DB
nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
}
// controllo se la sezione è definita da una regione piana
else if ( nSecType == SRF_FLATRGN) {
// recupero la regione sezion in locale
SurfLocal SrfSect( pGeomDB, nSectId, frLoc) ;
const ISurfFlatRegion* pSFrSect = GetSurfFlatRegion( SrfSect.Get()) ;
bOk = bOk && ( pSFrSect != nullptr) ;
// calcolo la Swept
pSTM = ( bOk ? GetSurfTriMeshSwept( pSFrSect, CrvGuide, vtAxL, bCapEnds, dLinTol) : nullptr) ;
// inserisco la superficie trimesh nel DB
nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
}
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmSwept(" + IdToString( nParentId) + "," +
ToString( nSectId) + "," +
ToString( nGuideId) + ",{" +
ToString( vtAx) + "}," +
( bCapEnds ? "true" : "false") + "," +
ToString( dLinTol) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmTransSwept( int nParentId, int nSectId, int nGuideId, bool bCapEnds, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero la sezione in locale
CurveLocal CrvSect( pGeomDB, nSectId, frLoc) ;
bOk = bOk && ( CrvSect.Get() != nullptr) ;
// recupero la guida in locale
CurveLocal CrvGuide( pGeomDB, nGuideId, frLoc) ;
bOk = bOk && ( CrvGuide.Get() != nullptr) ;
// creo la superficie trimesh
ISurfTriMesh* pSTM = nullptr ;
pSTM = ( bOk ? GetSurfTriMeshTransSwept( CrvSect, CrvGuide, bCapEnds, dLinTol) : nullptr) ;
// inserisco la superficie trimesh nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmTransSwept(" + IdToString( nParentId) + "," +
ToString( nSectId) + "," +
ToString( nGuideId) + "," +
( bCapEnds ? "true" : "false") + "," +
ToString( dLinTol) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfTmRuled( int nParentId, int nPtOrCrvId1, int nPtOrCrvId2, int nType, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// creo la superficie trimesh
ISurfTriMesh* pSTM = nullptr ;
// se la prima entità è un punto e la seconda una curva
if ( pGeomDB->GetGeoType( nPtOrCrvId1) == GEO_PNT3D &&
( pGeomDB->GetGeoType( nPtOrCrvId2) & GEO_CURVE) != 0) {
// recupero il punto in locale
// recupero riferimento del punto
Frame3d frPnt ;
bOk = bOk && pGeomDB->GetGlobFrame( nPtOrCrvId1, frPnt) ;
// porto il punto in locale
Point3d ptP = GetGeoPoint3d( pGeomDB->GetGeoObj( nPtOrCrvId1))->GetPoint() ;
bOk = bOk && ptP.LocToLoc( frPnt, frLoc) ;
// recupero la curva in locale
CurveLocal CrvLoc( pGeomDB, nPtOrCrvId2, frLoc) ;
bOk = bOk && ( CrvLoc.Get() != nullptr) ;
// calcolo la superficie
pSTM = ( bOk ? GetSurfTriMeshRuled( ptP, CrvLoc, dLinTol) : nullptr) ;
}
// se la prima entità è una curva e la seconda un punto
else if ( ( pGeomDB->GetGeoType( nPtOrCrvId1) & GEO_CURVE) != 0 &&
pGeomDB->GetGeoType( nPtOrCrvId2) == GEO_PNT3D) {
// recupero la curva in locale
CurveLocal CrvLoc( pGeomDB, nPtOrCrvId1, frLoc) ;
bOk = bOk && ( CrvLoc.Get() != nullptr) ;
// recupero il punto in locale
// recupero riferimento del punto
Frame3d frPnt ;
bOk = bOk && pGeomDB->GetGlobFrame( nPtOrCrvId2, frPnt) ;
// porto il punto in locale
Point3d ptP = GetGeoPoint3d( pGeomDB->GetGeoObj( nPtOrCrvId2))->GetPoint() ;
bOk = bOk && ptP.LocToLoc( frPnt, frLoc) ;
// calcolo la superficie
pSTM = ( bOk ? GetSurfTriMeshRuled( ptP, CrvLoc, dLinTol) : nullptr) ;
}
// se entrambe curve
else if ( ( pGeomDB->GetGeoType( nPtOrCrvId1) & GEO_CURVE) != 0 &&
( pGeomDB->GetGeoType( nPtOrCrvId2) & GEO_CURVE) != 0) {
// recupero la prima curva in locale
CurveLocal CrvLoc1( pGeomDB, nPtOrCrvId1, frLoc) ;
bOk = bOk && ( CrvLoc1.Get() != nullptr) ;
// recupero la seconda curva in locale
CurveLocal CrvLoc2( pGeomDB, nPtOrCrvId2, frLoc) ;
bOk = bOk && ( CrvLoc2.Get() != nullptr) ;
// calcolo la superficie
pSTM = ( bOk ? GetSurfTriMeshRuled( CrvLoc1, CrvLoc2, nType, dLinTol) : nullptr) ;
}
// altrimenti errore
else
bOk = false ;
// inserisco la superficie trimesh nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSTM) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmRuled(" + IdToString( nParentId) + "," +
ToString( nPtOrCrvId1) + "," +
ToString( nPtOrCrvId2) + "," +
( nType == ISurfTriMesh::RLT_MINDIST ? "'MD'" : "'IP'") + "," +
ToString( dLinTol) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//----------------------------------------------------------------------------
int
ExeCreateSurfTmByTriangles( int nParentId, const INTVECTOR& vIds, bool bErase)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// almeno un oggetto nell'elenco
bool bOk = ( vIds.size() > 0) ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// Costruttore di trimesh da insieme disordinato di triangoli
StmFromTriangleSoup StmFts ;
bOk = bOk && StmFts.Start() ;
// Recupero tutti i triangoli delle superfici sorgenti e li inserisco nella nuova
INTVECTOR vMyIds ;
for ( size_t i = 0 ; bOk && i < vIds.size() ; ++ i) {
int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
while ( nId != GDB_ID_NULL) {
// salvo Id nel mio elenco
vMyIds.emplace_back( nId) ;
// recupero la superficie sorgente
const ISurfTriMesh* pStmS = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
bOk = bOk && ( pStmS != nullptr) ;
// recupero il riferimento della superficie sorgente
Frame3d frSou ;
bOk = bOk && pGeomDB->GetGlobFrame( nId, frSou) ;
// recupero tutti i triangoli
Triangle3d Tria ;
int nT = ( bOk ? pStmS->GetFirstTriangle( Tria) : SVT_NULL) ;
while ( nT != SVT_NULL) {
// aggiusto per i sistemi di riferimento
Tria.LocToLoc( frSou, frLoc) ;
// inserisco il triangolo nella nuova superficie
bOk = bOk && StmFts.AddTriangle( Tria) ;
// passo al triangolo successivo
nT = pStmS->GetNextTriangle( nT, Tria) ;
}
// passo al successivo
nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
}
}
// valido la superficie e calcolo le adiacenze
bOk = bOk && StmFts.End() ;
// chiudo eventuali fessure tra i triangoli
PtrOwner<ISurfTriMesh> pStm( StmFts.GetSurf()) ;
bOk = bOk && pStm->Repair() ;
// inserisco la superficie trimesh nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) : GDB_ID_NULL) ;
// se richiesto, cancello le superfici originali
if ( nNewId != GDB_ID_NULL && bErase) {
// cancello le superfici originali e determino Id minimo
int nMinId = INT_MAX ;
for ( auto nId : vMyIds) {
pGeomDB->Erase( nId) ;
if ( nId < nMinId)
nMinId = nId ;
}
// assegno alla superficie composita l'Id minimo appena trovato
if ( pGeomDB->ChangeId( nNewId, nMinId))
nNewId = nMinId ;
}
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmByTriangles(" + IdToString( nParentId) + ",{" +
IdListToString( vIds) + "}," +
( bErase ? "true" : "false") + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco il risultato
return nNewId ;
}
//----------------------------------------------------------------------------
int
ExeCreateSurfTmBySewing( int nParentId, const INTVECTOR& vIds, bool bErase)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// almeno un oggetto nell'elenco
bool bOk = ( vIds.size() > 0) ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// puntatore alla nuova superficie
PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
bOk = bOk && ! IsNull( pStm) ;
// esecuzione
bool bFirst = true ;
INTVECTOR vMyIds ;
for ( size_t i = 0 ; bOk && i < vIds.size() ; ++ i) {
int nId = (( vIds[i] != GDB_ID_SEL) ? vIds[i] : pGeomDB->GetFirstSelectedObj()) ;
while ( nId != GDB_ID_NULL) {
// salvo Id nel mio elenco
vMyIds.emplace_back( nId) ;
// recupero la superficie da cucire
const ISurfTriMesh* pStmS = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ;
bOk = bOk && ( pStmS != nullptr) ;
// recupero il riferimento
Frame3d frStmS ;
bOk = bOk && pGeomDB->GetGlobFrame( nId, frStmS) ;
// lo esprimo rispetto a quello della prima superficie
frStmS.ToLoc( frLoc) ;
// se è la prima, copio
if ( bFirst) {
bOk = bOk && pStm->CopyFrom( pStmS) ;
bOk = bOk && pStm->ToGlob( frStmS) ;
bFirst = false ;
}
// altrimenti eseguo la cucitura
else
bOk = bOk && pStm->DoSewing( *pStmS, frStmS) ;
// passo alla successiva
nId = (( vIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
}
}
// compatto
bOk = bOk && pStm->DoCompacting() ;
// chiudo eventuali fessure tra i triangoli
bOk = bOk && pStm->Repair() ;
// inserisco la superficie trimesh nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) : GDB_ID_NULL) ;
// se richiesto, cancello le superfici originali
if ( nNewId != GDB_ID_NULL && bErase) {
// cancello le superfici originali e determino Id minimo
int nMinId = INT_MAX ;
for ( auto nId : vMyIds) {
pGeomDB->Erase( nId) ;
if ( nId < nMinId)
nMinId = nId ;
}
// assegno alla superficie composita l'Id minimo appena trovato
if ( pGeomDB->ChangeId( nNewId, nMinId))
nNewId = nMinId ;
}
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmBySewing(" + IdToString( nParentId) + ",{" +
IdListToString( vIds) + "}," +
( bErase ? "true" : "false") + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco il risultato
return nNewId ;
}
//----------------------------------------------------------------------------
int
ExeCreateSurfTmByVolZmap( int nParentId, int nZmapId, int nPart)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// recupero il solido VolZmap
const IVolZmap* pVZM = GetVolZmap( pGeomDB->GetGeoObj( nZmapId)) ;
bool bOk = ( pVZM != nullptr) ;
// se richiesta superficie di una sola parte
PtrOwner<IVolZmap> pPart ;
if ( bOk && nPart >= 0) {
pPart.Set( pVZM->ClonePart( nPart)) ;
bOk = ! IsNull( pPart) ;
pVZM = pPart ;
}
// recupero il riferimento del solido sorgente
Frame3d frSou ;
bOk = bOk && pGeomDB->GetGlobFrame( nZmapId, frSou) ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// Costruttore di trimesh da insieme disordinato di triangoli
StmFromTriangleSoup StmFts ;
bOk = bOk && StmFts.Start() ;
// recupero i triangoli del bordo dello Zmap
int nCount = ( bOk ? pVZM->GetBlockCount() : 0) ;
for ( int i = 0 ; i < nCount && bOk ; ++ i) {
// recupero i triangoli del blocco
TRIA3DEXVECTOR vTria ;
pVZM->GetBlockTriangles( i, vTria) ;
for ( auto& Tria : vTria) {
// aggiusto per i sistemi di riferimento
Tria.LocToLoc( frSou, frLoc) ;
// inserisco il triangolo nella nuova superficie
if ( ! StmFts.AddTriangle( Tria))
bOk = false ;
}
}
// valido la superficie e calcolo le adiacenze
bOk = bOk && StmFts.End() ;
// chiudo eventuali fessure tra i triangoli
PtrOwner<ISurfTriMesh> pStm( StmFts.GetSurf()) ;
bOk = bOk && pStm->Repair() ;
// inserisco la superficie trimesh nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfTmByVolZmap(" + IdToString( nParentId) + "," +
IdToString( nZmapId) + "," +
IdToString( nPart) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco il risultato
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfBezier( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTVECTOR& vPnt, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// il numero dei punti deve essere pari al prodotto dei gradi per gli span + 1
int nDim = ( nDegU * nSpanU + 1) * ( nDegV * nSpanV + 1) ;
bOk = bOk && ( vPnt.size() == nDim) ;
// recupero il riferimento di immersione della superficie
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// creo la superficie di Bezier
PtrOwner<ISurfBezier> pSurfBez( CreateSurfBezier()) ;
bOk = bOk && ! IsNull( pSurfBez) ;
// inizializzo la superficie di Bezier
bOk = bOk && pSurfBez->Init( nDegU, nDegV, nSpanU, nSpanV, false) ;
// setto i punti di controllo
for ( int i = 0 ; i < nDim && bOk ; ++ i) {
// eventuale trasformazione del punto nel riferimento locale
Point3d ptCtrl = GetPointLocal( pGeomDB, vPnt[i], nRefType, frLoc) ;
// inserimento del punto di controllo
if ( ! pSurfBez->SetControlPoint( i, ptCtrl))
bOk = false ;
}
// se superficie nulla (ovvero ridotta a punto), errore
bOk = bOk && ! pSurfBez->IsAPoint() ;
// inserisco la superficie nel DB
int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSurfBez)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sPC ;
for ( size_t i = 0 ; i < vPnt.size() ; ++ i) {
sPC += ( i == 0 ? "{" : ",{") + ToString( vPnt[i]) + "}" ;
}
string sLua = "EgtSurfBezier(" + IdToString( nParentId) + "," +
ToString( nDegU) + "," +
ToString( nDegV) + "," +
ToString( nSpanU) + "," +
ToString( nSpanV) + ",{" +
sPC + "}," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfBezierRational( int nParentId, int nDegU, int nDegV, int nSpanU, int nSpanV, const PNTUVECTOR& vPntW, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// il numero dei punti deve essere pari al prodotto dei gradi per gli span + 1
int nDim = ( nDegU * nSpanU + 1) * ( nDegV * nSpanV + 1) ;
bOk = bOk && ( vPntW.size() == nDim) ;
// recupero il riferimento di immersione della superficie
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// creo la superficie di Bezier
PtrOwner<ISurfBezier> pSurfBez( CreateSurfBezier()) ;
bOk = bOk && ! IsNull( pSurfBez) ;
// inizializzo la superficie di Bezier
bOk = bOk && pSurfBez->Init( nDegU, nDegV, nSpanU, nSpanV, true) ;
// setto i punti di controllo
for ( int i = 0 ; i < nDim && bOk ; ++ i) {
// eventuale trasformazione del punto nel riferimento locale
Point3d ptCtrl = GetPointLocal( pGeomDB, vPntW[i].first, nRefType, frLoc) ;
// inserimento del punto di controllo
if ( ! pSurfBez->SetControlPoint( i, ptCtrl, vPntW[i].second))
bOk = false ;
}
// se superficie nulla (ovvero ridotta a punto), errore
bOk = bOk && ! pSurfBez->IsAPoint() ;
// inserisco la superficie nel DB
int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSurfBez)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sPC ;
for ( size_t i = 0 ; i < vPntW.size() ; ++ i) {
sPC += ( i == 0 ? "{" : ",{") + ToString( vPntW[i].first, vPntW[i].second) + "}" ;
}
string sLua = "EgtSurfBezierRat(" + IdToString( nParentId) + "," +
ToString( nDegU) + "," +
ToString( nDegV) + "," +
ToString( nSpanU) + "," +
ToString( nSpanV) + ",{" +
sPC + "}," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfBezierLeaves( int nParentId, int nSurfBzId, int nTextHeight, bool bShowTrim, int* pnCount)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// recupero la superficie
const ISurfBezier* pSurfBez = GetSurfBezier( pGeomDB->GetGeoObj( nSurfBzId)) ;
if ( pSurfBez == nullptr)
return GDB_ID_NULL ;
// disegno le foglie
vector<tuple<int,Point3d,Point3d>> vLeaves ;
pSurfBez->GetLeaves( vLeaves) ;
double dFactor = 1 ;
int nFirstId = GDB_ID_NULL ;
int nCount = 0 ;
for ( int k = 0 ; k < (int)vLeaves.size() ; ++ k) {
Point3d ptBL = get<1>( vLeaves[k]) * dFactor ;
Point3d ptTR = get<2>( vLeaves[k]) * dFactor ;
Point3d ptBR( ptTR.x, ptBL.y) ;
Point3d ptTL( ptBL.x, ptTR.y) ;
PolyLine PL ;
PL.AddUPoint( 0, ptBL) ;
PL.AddUPoint( 1, ptBR) ;
PL.AddUPoint( 2, ptTR) ;
PL.AddUPoint( 3, ptTL) ;
PL.Close() ;
// creo la curva e la inserisco nel GDB
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo) || ! pCrvCompo->FromPolyLine( PL) || ! pCrvCompo->SetExtrusion( Z_AX))
return GDB_ID_NULL ;
// inserisco la curva composita nel DB
int nCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
if ( nCrvId == GDB_ID_NULL)
return GDB_ID_NULL ;
++ nCount ;
if ( nFirstId == GDB_ID_NULL)
nFirstId = nCrvId ;
// creo il testo e lo riempio
string sText = ToString( get<0>( vLeaves[k])) ;
Point3d ptCenter( ( ptBL + ptTR) / 2) ;
PtrOwner<IExtText> pTXT( CreateExtText()) ;
if ( IsNull( pTXT) || ! pTXT->Set( ptCenter, Z_AX, X_AX, sText, "", false, nTextHeight))
return GDB_ID_NULL ;
// inserisco il testo nel DB
int nTxtId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTXT)) ;
if ( nTxtId == GDB_ID_NULL)
return GDB_ID_NULL ;
++ nCount ;
}
// se richiesto disegno la regione di trim
const ISurfFlatRegion* pSfr = pSurfBez->GetTrimRegion() ;
if ( bShowTrim && pSfr != nullptr) {
PtrOwner<ISurfFlatRegion> pTrimReg( pSfr->Clone()) ;
if ( ! IsNull( pTrimReg)) {
int nTrimId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTrimReg)) ;
if ( nTrimId == GDB_ID_NULL)
return GDB_ID_NULL ;
++ nCount ;
}
}
// restituisco i risultati
if ( pnCount != nullptr)
*pnCount = nCount ;
return nFirstId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfBezierTria2D( int nParentId, int nSurfBzId, int nTextHeight, bool bShowTrim, int* pnCount)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
// recupero la superficie
const ISurfBezier* pSurfBez = GetSurfBezier( pGeomDB->GetGeoObj( nSurfBzId)) ;
if ( pSurfBez == nullptr)
return GDB_ID_NULL ;
// disegno i triangoli
vector<tuple<int,Point3d,Point3d,Point3d>> vTria2D ;
pSurfBez->GetTriangles2D( vTria2D) ;
int nFirstId = GDB_ID_NULL ;
int nCount = 0 ;
bool bOk = true ;
for ( int k = 0 ; k < (int)vTria2D.size() ; ++ k) {
PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
bOk = bOk && ! IsNull( pStm) ;
Point3d ptP1L = get<1>(vTria2D[k]) ;
Point3d ptP2L = get<2>(vTria2D[k]) ;
Point3d ptP3L = get<3>(vTria2D[k]) ;
// assegno il triangolo
if ( bOk) {
pStm->Init( 3, 1, 1) ;
int vV[3]{ pStm->AddVertex( ptP1L),
pStm->AddVertex( ptP2L),
pStm->AddVertex( ptP3L)} ;
bOk = ( pStm->AddTriangle( vV) != SVT_NULL) && pStm->AdjustTopology() ;
}
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) : GDB_ID_NULL) ;
if ( nNewId == GDB_ID_NULL)
return GDB_ID_NULL ;
if ( nFirstId == GDB_ID_NULL)
nFirstId = nNewId ;
++ nCount ;
// creo il testo e lo riempio
string sText = ToString( get<0>( vTria2D[k])) ;
Point3d ptCenter( ( ptP1L + ptP2L + ptP3L) / 3) ;
PtrOwner<IExtText> pTXT( CreateExtText()) ;
if ( IsNull( pTXT) || ! pTXT->Set( ptCenter, Z_AX, X_AX, sText, "", false, nTextHeight))
return GDB_ID_NULL ;
// inserisco il testo nel DB
int nTxtId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTXT)) ;
if ( nTxtId == GDB_ID_NULL)
return GDB_ID_NULL ;
++ nCount ;
}
// se richiesto disegno la regione di trim
const ISurfFlatRegion* pSfr = pSurfBez->GetTrimRegion() ;
if ( bShowTrim && pSfr != nullptr) {
PtrOwner<ISurfFlatRegion> pTrimReg( pSfr->Clone()) ;
if ( ! IsNull( pTrimReg)) {
int nTrimId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTrimReg)) ;
if ( nTrimId == GDB_ID_NULL)
return GDB_ID_NULL ;
++ nCount ;
}
}
// restituisco i risultati
if ( pnCount != nullptr)
*pnCount = nCount ;
return nFirstId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateBezierSphere( int nParentId, const Point3d& ptCenter, double dR, int nRefType) {
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento di immersione della superficie
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// reucpero il punto in locale
Point3d ptCenterLoc = GetPointLocal( pGeomDB, ptCenter, nRefType, frLoc) ;
// Creo la superficie
PtrOwner<ISurfBezier> pSurfBez( GetSurfBezierSphere( ptCenterLoc, dR)) ;
int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSurfBez)) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtCreateBezierSphere(" + IdToString( nParentId) + "," +
ToString( ptCenter) + "," +
ToString( dR) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// resituisco l'identificativo dell'entit� creata
return nId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfBzByFlatContour( int nParentId, int nCrvId, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero la curva in locale
CurveLocal CrvLoc( pGeomDB, nCrvId, frLoc) ;
bOk = bOk && ( CrvLoc.Get() != nullptr) ;
// calcolo la superficie
ISurfBezier* pSbz = ( bOk ? GetSurfBezierByFlatContour( CrvLoc, dLinTol) : nullptr) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfBzByFlatContour(" + IdToString( nParentId) + "," +
ToString( nCrvId) + "," +
ToString( dLinTol) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfBzByRegion( int nParentId, const INTVECTOR& vCrvIds, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero le curve in locale
CURVELOCALVECTOR vCrvLoc ;
vCrvLoc.reserve( vCrvIds.size()) ;
CICURVEPVECTOR vCrvP ;
vCrvP.reserve( vCrvIds.size()) ;
for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
int nId = (( vCrvIds[i] != GDB_ID_SEL) ? vCrvIds[i] : pGeomDB->GetFirstSelectedObj()) ;
while ( nId != GDB_ID_NULL) {
vCrvLoc.emplace_back( pGeomDB, nId, frLoc) ;
vCrvP.push_back( vCrvLoc.back().Get()) ;
bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
// passo al successivo
nId = (( vCrvIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
}
}
// calcolo la superficie
ISurfBezier* pSbz = ( bOk ? GetSurfBezierByRegion( vCrvP, dLinTol) : nullptr) ;
bOk = bOk && ( pSbz != nullptr) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfBzByRegion(" + IdToString( nParentId) + ",{" +
IdListToString( vCrvIds) + "}," +
ToString( dLinTol) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfBzByExtrusion( int nParentId, const INTVECTOR& vCrvIds, const Vector3d& vtExtr, bool bCapEnds,
double dLinTol, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero le curve in locale
CURVELOCALVECTOR vCrvLoc ;
vCrvLoc.reserve( vCrvIds.size()) ;
CICURVEPVECTOR vCrvP ;
vCrvP.reserve( vCrvIds.size()) ;
for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
int nId = (( vCrvIds[i] != GDB_ID_SEL) ? vCrvIds[i] : pGeomDB->GetFirstSelectedObj()) ;
while ( nId != GDB_ID_NULL) {
vCrvLoc.emplace_back( pGeomDB, nId, frLoc) ;
vCrvP.push_back( const_cast<ICurve*>( vCrvLoc.back().Get())) ;
bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
// passo al successivo
nId = (( vCrvIds[i] != GDB_ID_SEL) ? GDB_ID_NULL : pGeomDB->GetNextSelectedObj()) ;
}
}
// porto in locale il vettore estrusione
Vector3d vtExtrL = GetVectorLocal( pGeomDB, vtExtr, nRefType, frLoc) ;
// creo le superfici e le inserisco nel DB
int nFirstId = GDB_ID_NULL ;
double dAndTolStdDeg = 15 ;
for ( int i = 0 ; i < int( vCrvP.size()) ; ++ i) {
Plane3d plPlane ;
double dArea ;
PolyLine plApprox ;
vCrvP[i]->ApproxWithLines( dLinTol, dAndTolStdDeg, ICurve::APL_STD, plApprox) ;
plApprox.IsClosedAndFlat( plPlane, dArea, 50 * EPS_SMALL) ;
PtrOwner<ICurve> pCrvToExtrude( vCrvP[i]->Clone()) ;
if( plPlane.GetVersN() * vtExtrL < 0)
pCrvToExtrude->Invert() ;
// calcolo la superficie
ISurfBezier* pSbz = ( bOk ? GetSurfBezierByExtrusion( pCrvToExtrude, vtExtrL, false, dLinTol) : nullptr) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
bOk = bOk && ( nNewId != GDB_ID_NULL) ;
if ( bOk && nFirstId == GDB_ID_NULL)
nFirstId = nNewId ;
}
// se richiesta chiusura agli estremi
if ( bCapEnds) {
// verifico che la curva sia chiusa e piatta
Plane3d plPlane ;
double dArea ;
PolyLine plApprox ;
vCrvP[0]->ApproxWithLines( dLinTol, dAndTolStdDeg, ICurve::APL_STD, plApprox) ;
if ( plApprox.IsClosedAndFlat( plPlane, dArea, 50 * EPS_SMALL)) {
// componente dell'estrusione perpendicolare al piano della curva
double dOrthoExtr = plPlane.GetVersN() * vtExtr ;
if ( ( abs( dOrthoExtr) > EPS_SMALL)) {
if( vCrvIds.size() == 1) {
PtrOwner<ISurfBezier> pSrfBzTop( CreateSurfBezier()) ;
pSrfBzTop->CreateByFlatContour( plApprox) ;
pSrfBzTop->Translate( vtExtrL) ;
pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBzTop)) ;
PtrOwner<ISurfBezier> pSrfBzBottom( CreateSurfBezier()) ;
pSrfBzBottom->CreateByFlatContour( plApprox) ;
pSrfBzBottom->Invert() ;
pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBzBottom)) ;
}
else {
// riordino le curve in modo che la prima sia quella esterna e tutte le altre dopo
POLYLINEVECTOR vPLOrd ;
POLYLINEVECTOR vPL ;
for ( int i = 0 ; i < int( vCrvP.size()) ; ++ i) {
if ( ! vCrvP[i]->ApproxWithLines( dLinTol, dAndTolStdDeg, ICurve::APL_SPECIAL, vPL[i]))
return false ;
}
Vector3d vtN ;
INTMATRIX vnPLIndMat ;
if ( ! CalcRegionPolyLines( vPL, vPLOrd, vtN, vnPLIndMat))
return nFirstId ;
// se componente estrusione negativa, inverto tutti i percorsi
if ( dOrthoExtr < 0) {
for ( int i = 0 ; i < int( vPL.size()) ; ++ i)
vPL[i].Invert() ;
}
PtrOwner<ISurfBezier> pSrfBzTop( CreateSurfBezier()) ;
pSrfBzTop->CreateByRegion( vPL) ;
pSrfBzTop->Translate( vtExtrL) ;
pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBzTop)) ;
PtrOwner<ISurfBezier> pSrfBzBottom( CreateSurfBezier()) ;
pSrfBzBottom->CreateByRegion( vPL) ;
pSrfBzBottom->Invert() ;
pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBzBottom)) ;
}
}
}
}
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfBzByExtrusion(" + IdToString( nParentId) + ",{" +
IdListToString( vCrvIds) + "},{" +
ToString( vtExtr) + "}," +
ToString( dLinTol) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nFirstId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nFirstId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfBzByScrewing( int nParentId, int nCrvId,
const Point3d& ptAx, const Vector3d& vtAx,
double dAngRotDeg, double dMove, bool bCapEnds, double dLinTol, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero la curva in locale
CurveLocal CrvLoc( pGeomDB, nCrvId, frLoc) ;
bOk = bOk && ( CrvLoc.Get() != nullptr) ;
// porto in locale punto e vettore asse
Point3d ptAxL = GetPointLocal( pGeomDB, ptAx, nRefType, frLoc) ;
Vector3d vtAxL = GetVectorLocal( pGeomDB, vtAx, nRefType, frLoc) ;
// calcolo la superficie
ISurfBezier* pSbz = ( bOk ? GetSurfBezierByScrewing( CrvLoc, ptAxL, vtAxL, dAngRotDeg, dMove, bCapEnds, dLinTol) : nullptr) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfbzByScrewing(" + IdToString( nParentId) + "," +
ToString( nCrvId) + ",{" +
ToString( ptAx) + "},{" +
ToString( vtAx) + "}," +
ToString( dAngRotDeg) + "," +
ToString( dMove) + "," +
( bCapEnds ? "true" : "false") + "," +
ToString( dLinTol) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfBzByRevolve( int nParentId, int nCrvId,
const Point3d& ptAx, const Vector3d& vtAx,
bool bCapEnds, double dLinTol, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero la curva in locale
CurveLocal CrvLoc( pGeomDB, nCrvId, frLoc) ;
bOk = bOk && ( CrvLoc.Get() != nullptr) ;
// porto in locale punto e vettore asse
Point3d ptAxL = GetPointLocal( pGeomDB, ptAx, nRefType, frLoc) ;
Vector3d vtAxL = GetVectorLocal( pGeomDB, vtAx, nRefType, frLoc) ;
// calcolo la superficie
ISurfBezier* pSbz = ( bOk ? GetSurfBezierByRevolve( CrvLoc, ptAxL, vtAxL, bCapEnds, dLinTol) : nullptr) ;
// finché non ho le SurfCompo creo qui i cap
if ( bCapEnds) {
// calcola la bbox della superficie
BBox3d bbox3dSurf ;
int nDegU, nDegV, nSpanU, nSpanV ;
bool bTrim, bRat ;
pSbz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bTrim, bRat) ;
int nPointCount = ( nDegU * nSpanU + 1) * ( nDegV * nSpanV + 1) ;
for ( int p = 0 ; p < nPointCount ; ++p) {
bool bPointOk = true ;
Point3d ptCtrl = pSbz->GetControlPoint( p, &bPointOk) ;
bbox3dSurf.Add( ptCtrl) ;
}
// recupero i loop
ICRVCOMPOPOVECTOR vCCLoop ;
pSbz->GetLoops( vCCLoop, true) ;
// il getLoops per superfici non trimmate restituisce 1 elemento per ogni lato dello spazio parametrico.
// in questo caso la superficie è chiusa lungo il parametro V, quindi i lati 0 e 2 saranno null.
double dAngTolDeg = 5 ;
PolyLine plEdge1 ; vCCLoop[1]->ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, plEdge1) ;
PolyLine plEdge3 ; vCCLoop[3]->ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, plEdge3) ;
plEdge3.Invert() ;
//// devo distinguere tra il loop superiore e quello inferiore
//PolyLine plEdge0 ; vCCLoop[0]->ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, plEdge0) ;
//Plane3d plPlane ; double dArea ;
//bOk = bOk && ! plEdge0.IsClosedAndFlat( plPlane, dArea, 50 * EPS_SMALL) ;
//Vector3d vtN = plPlane.GetVersN() ;
//// vedo come questa normale è orientata rispetto alla bbox della superficie
//Point3d ptCen ; vCCLoop[0]->GetCentroid( ptCen) ;
//ptCen += vtN ;
//PolyLine plEdge1 ; vCCLoop[1]->ApproxWithLines( dLinTol, dAngTolDeg, ICurve::APL_STD, plEdge1) ;
//// inverto uno dei due bordi
//if ( bbox3dSurf.Encloses( ptCen))
// plEdge0.Invert() ;
//else
// plEdge1.Invert() ;
// creo le superfici e le inserisco nel DB
PtrOwner<ISurfBezier> pSrfBzCap1( CreateSurfBezier()) ;
pSrfBzCap1->CreateByFlatContour( plEdge1) ;
pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBzCap1)) ;
PtrOwner<ISurfBezier> pSrfBzCap3( CreateSurfBezier()) ;
pSrfBzCap3->CreateByFlatContour( plEdge3) ;
pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSrfBzCap3)) ;
}
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfbzByScrewing(" + IdToString( nParentId) + "," +
ToString( nCrvId) + ",{" +
ToString( ptAx) + "},{" +
ToString( vtAx) + "}," +
( bCapEnds ? "true" : "false") + "," +
ToString( dLinTol) + "," +
RefTypeToString( nRefType) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfBzRuled( int nParentId, int nCrvId1, int nCrvId2, int nRuledType, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero le curve in locale
CurveLocal CrvLoc1( pGeomDB, nCrvId1, frLoc) ;
bOk = bOk && ( CrvLoc1.Get() != nullptr) ;
CurveLocal CrvLoc2( pGeomDB, nCrvId2, frLoc) ;
bOk = bOk && ( CrvLoc2.Get() != nullptr) ;
// calcolo la superficie
ISurfBezier* pSbz = ( bOk ? GetSurfBezierRuled( CrvLoc1, CrvLoc2, nRuledType, dLinTol) : nullptr) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfbzByScrewing(" + IdToString( nParentId) + "," +
ToString( nCrvId1) + "," +
ToString( nCrvId2) + "," +
ToString( nRuledType) + "," +
ToString( dLinTol) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
//-------------------------------------------------------------------------------
int
ExeCreateSurfBzSkinned( int nParentId, const INTVECTOR& vCrvIds, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
nParentId = AdjustId( nParentId) ;
bool bOk = true ;
// recupero il riferimento locale
Frame3d frLoc ;
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
// recupero le curve in locale
CURVELOCALVECTOR vCrvLoc ;
vCrvLoc.reserve( vCrvIds.size()) ;
CICURVEPVECTOR vCrvP ;
vCrvP.reserve( vCrvIds.size()) ;
for ( size_t i = 0 ; i < vCrvIds.size() ; ++ i) {
int nId = vCrvIds[i] ;
vCrvLoc.emplace_back( pGeomDB, nId, frLoc) ;
vCrvP.push_back( vCrvLoc.back().Get()) ;
bOk = bOk && ( vCrvLoc[i].Get() != nullptr) ;
}
// calcolo la superficie
ISurfBezier* pSbz = ( bOk ? GetSurfBezierSkinned( vCrvP, dLinTol) : nullptr ) ;
// inserisco la superficie nel DB
int nNewId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pSbz) : GDB_ID_NULL) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSurfbzByScrewing(" + IdToString( nParentId) + ",{" +
IdListToString( vCrvIds) + "}," +
ToString( dLinTol) + ")" +
" -- Id=" + ToString( nNewId) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco l'identificativo della nuova entità
return nNewId ;
}
Reference in New Issue View Git Blame Copy Permalink