Egalware/EgtInterface
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtInterface 1.5j7 :

Browse Source 
- migliorate API per modifica e snap
This commit is contained in:
Dario Sassi
2014-11-05 17:03:47 +00:00
parent e4d952bf32
commit 0e648470ed
12 changed files with 916 additions and 543 deletions
Download Patch File Download Diff File Expand all files Collapse all files
API.h
+1
View File
@@ -29,6 +29,7 @@ BOOL __stdcall EgtSaveFile( const std::string& sFilePath, int nFlag) ;
int __stdcall EgtCreateCurveBezier( int nParentId, int nDegree, const PNTVECTOR& vPnt) ;
int __stdcall EgtCreateCurveBezierRational( int nParentId, int nDegree, const PNTUVECTOR& vPntW) ;
int __stdcall EgtCreateCurveCompo( int nParentId, const INTVECTOR& vIds, bool bErase) ;
int __stdcall EgtCreateCurveCompoByChain( int nParentId, const INTVECTOR& vIds, const Point3d& ptNear, bool bErase) ;
int __stdcall EgtCreateCurveCompoFromPoints( int nParentId, const PolyLine& PL) ;
int __stdcall EgtCreateCurveCompoFromPointBulges( int nParentId, const PolyArc& PA) ;
int __stdcall EgtCreateText( int nParentId, const std::string& sText,
API_GdbCreate.cpp
-526
View File
@@ -18,21 +18,12 @@
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EgkGeoPoint3d.h"
#include "/EgtDev/Include/EgkGeoVector3d.h"
#include "/EgtDev/Include/EgkCurveLine.h"
#include "/EgtDev/Include/EgkCurveArc.h"
#include "/EgtDev/Include/EgkCurveBezier.h"
#include "/EgtDev/Include/EgkCurveComposite.h"
#include "/EgtDev/Include/EgkSurfTriMesh.h"
#include "/EgtDev/Include/EgkExtText.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGnStringConverter.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
using namespace std ;
//-------------------------------------------------------------------------------
static bool GetPolyLineFromCurve( IGeomDB* pGeomDB, int nId, const Frame3d& frDest, double dLinTol, PolyLine& PL) ;
//-------------------------------------------------------------------------------
int
@@ -101,487 +92,6 @@ __stdcall EgtCreateGeoFrame( int nParentId, const double ptOrig[3],
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pGeoFrm)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveLine( int nParentId, const double ptIni[3], const double ptFin[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo la linea
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
if ( IsNull( pCrvLine))
return GDB_ID_NULL ;
// setto la linea
if ( ! pCrvLine->Set( ptIni, ptFin))
return GDB_ID_NULL ;
// inserisco la linea nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvLine)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveLineMinPointCurve( int nParentId,
const double ptStart[3], int nCrvId, double dNearPar)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero il riferimento del gruppo destinazione
Frame3d frPoint ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frPoint))
return GDB_ID_NULL ;
// recupero il riferimento della curva
Frame3d frCurve ;
if ( ! pGeomDB->GetGlobFrame( nCrvId, frCurve))
return GDB_ID_NULL ;
// recupero la curva
const ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
if ( pCurve == nullptr)
return GDB_ID_NULL ;
// porto il punto nel riferimento della curva
Point3d ptSloc = ptStart ;
ptSloc.LocToLoc( frPoint, frCurve) ;
// calcolo il punto a minima distanza
int nFlag ;
Point3d ptEnd ;
DistPointCurve dstPtCurve( ptSloc, *pCurve) ;
if ( ! dstPtCurve.GetMinDistPoint( dNearPar, ptEnd, nFlag))
return GDB_ID_NULL ;
// porto il punto finale nel riferimento di creazione
ptEnd.LocToLoc( frCurve, frPoint) ;
// creo la linea
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
if ( IsNull( pCrvLine))
return GDB_ID_NULL ;
// setto la linea
if ( ! pCrvLine->Set( ptStart, ptEnd))
return GDB_ID_NULL ;
// inserisco la linea nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvLine)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCircle( int nParentId,
const double ptCen[3], const double vtN[3], double dRad)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto la circonferenza
if ( ! pCrvArc->Set( ptCen, vtN, dRad))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCircleXY( int nParentId,
const double ptCen[3], double dRad)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto la circonferenza
if ( ! pCrvArc->SetXY( ptCen, dRad))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCircle3P( int nParentId,
const double ptP1[3], const double ptP2[3], const double ptP3[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto l'arco
if ( ! pCrvArc->Set3P( ptP1, ptP2, ptP3, true))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveArc( int nParentId,
const double ptCen[3], const double vtN[3], double dRad,
const double vtS[3], double dAngCenDeg, double dDeltaN)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto l'arco
if ( ! pCrvArc->Set( ptCen, vtN, dRad, vtS, dAngCenDeg, dDeltaN))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveArcXY( int nParentId,
const double ptCen[3], double dRad,
double dAngStartDeg, double dAngCenDeg, double dDeltaZ)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto l'arco
if ( ! pCrvArc->SetXY( ptCen, dRad, dAngStartDeg, dAngCenDeg, dDeltaZ))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveArc3P( int nParentId,
const double ptP1[3], const double ptP2[3], const double ptP3[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto l'arco
if ( ! pCrvArc->Set3P( ptP1, ptP2, ptP3, false))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveArcC2PN( int nParentId,
const double ptCen[3], const double ptStart[3], const double ptNearEnd[3], const double vtNorm[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto l'arco
if ( ! pCrvArc->SetC2PN( ptCen, ptStart, ptNearEnd, vtNorm))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezier( int nParentId, int nDegree, const double ptCtrls[])
{
PNTVECTOR vPnt ;
vPnt.reserve( nDegree + 1) ;
for ( int i = 0 ; i <= nDegree ; ++i) {
vPnt.push_back( Point3d( ptCtrls[3*i], ptCtrls[3*i+1], ptCtrls[3*i+2])) ;
}
return EgtCreateCurveBezier( nParentId, nDegree, vPnt) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezier( int nParentId, int nDegree, const PNTVECTOR& vPnt)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// il numero dei punti deve essere pari al grado + 1
if ( vPnt.size() != nDegree + 1)
return GDB_ID_NULL ;
// creo la curva di Bezier
PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
if ( IsNull( pCrvBez))
return GDB_ID_NULL ;
// inizializzo la curva di Bezier
if ( ! pCrvBez->Init( nDegree, false))
return GDB_ID_NULL ;
// setto i punti di controllo
for ( int i = 0 ; i <= nDegree ; ++ i) {
if ( ! pCrvBez->SetControlPoint( i, vPnt[i]))
return GDB_ID_NULL ;
}
// se curva nulla (ovvero ridotta a punto), errore
if ( pCrvBez->IsAPoint())
return GDB_ID_NULL ;
// inserisco la curva nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvBez)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezierRational( int nParentId, int nDegree, const double ptCtrlWs[])
{
PNTUVECTOR vPntW ;
vPntW.reserve( nDegree + 1) ;
for ( int i = 0 ; i <= nDegree ; ++i) {
vPntW.push_back( make_pair( Point3d( ptCtrlWs[4*i], ptCtrlWs[4*i+1], ptCtrlWs[4*i+2]), ptCtrlWs[4*i+3])) ;
}
return EgtCreateCurveBezierRational( nParentId, nDegree, vPntW) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezierRational( int nParentId, int nDegree, const PNTUVECTOR& vPntW)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// il numero dei punti deve essere pari al grado + 1
if ( vPntW.size() != nDegree + 1)
return GDB_ID_NULL ;
// creo la curva di Bezier
PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
if ( IsNull( pCrvBez))
return GDB_ID_NULL ;
// inizializzo la curva di Bezier
if ( ! pCrvBez->Init( nDegree, true))
return GDB_ID_NULL ;
// setto i punti di controllo
for ( int i = 0 ; i <= nDegree ; ++ i) {
if ( ! pCrvBez->SetControlPoint( i, vPntW[i].first, vPntW[i].second))
return GDB_ID_NULL ;
}
// se curva nulla (ovvero ridotta a punto), errore
if ( pCrvBez->IsAPoint())
return GDB_ID_NULL ;
// inserisco la curva nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvBez)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezierFromArc( int nParentId, int nArcId, BOOL bErase)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo la curva di Bezier
PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
if ( IsNull( pCrvBez))
return GDB_ID_NULL ;
// recupero l'arco
const ICurveArc* pCrvArc = GetCurveArc( pGeomDB->GetGeoObj( nArcId)) ;
if ( pCrvArc == nullptr)
return GDB_ID_NULL ;
// ne deduco la curva di Bezier
if ( ! pCrvBez->FromArc( *pCrvArc))
return GDB_ID_NULL ;
// recupero il riferimento dell'arco
Frame3d frSou ;
if ( ! pGeomDB->GetGlobFrame( nArcId, frSou))
return GDB_ID_NULL ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest))
return GDB_ID_NULL ;
// porto la curva di Bezier dal riferimento dell'arco a quello di inserimento
if ( ! AreSameFrame( frSou, frDest)) {
pCrvBez->ToGlob( frSou) ;
pCrvBez->ToLoc( frDest) ;
}
// se curva nulla (ovvero ridotta a punto), errore
if ( pCrvBez->IsAPoint())
return GDB_ID_NULL ;
// inserisco la curva nel DB
int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvBez)) ;
if ( nId != GDB_ID_NULL) {
// se richiesto, cancello l'arco originale
if ( bErase) {
if ( ! pGeomDB->Erase( nArcId))
return GDB_ID_NULL ;
}
}
return nId ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompo( int nParentId, int nNumId, const int nIds[], BOOL bErase)
{
INTVECTOR vIds ;
vIds.reserve( nNumId) ;
for ( int i = 0 ; i < nNumId ; ++i) {
vIds.push_back( nIds[i]) ;
}
return EgtCreateCurveCompo( nParentId, vIds, ( bErase != FALSE)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompo( int nParentId, const INTVECTOR& vIds, bool bErase)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return GDB_ID_NULL ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest))
return false ;
// esecuzione
INTVECTOR::const_iterator Iter ;
for ( Iter = vIds.begin() ; Iter != vIds.end() ; ++Iter) {
// recupero la curva
int nIdCrv = *Iter ;
const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nIdCrv)) ;
if ( pCrv == nullptr)
return false ;
// recupero il riferimento della curva
Frame3d frSou ;
if ( ! pGeomDB->GetGlobFrame( nIdCrv, frSou))
return false ;
// se i riferimenti sono uguali
if ( AreSameFrame( frSou, frDest)) {
// aggiungo direttamente questa curva
if ( ! pCrvCompo->AddCurve( *pCrv))
return false ;
}
// altrimenti devo prima trasformare la curva
else {
// creo una copia della curva
PtrOwner<ICurve> pModCrv( pCrv->Clone()) ;
if ( IsNull( pModCrv))
return false ;
// eseguo la trasformazione
pModCrv->LocToLoc( frSou, frDest) ;
// aggiungo la curva modificata
if ( ! pCrvCompo->AddCurve( Release( pModCrv)))
return false ;
}
}
// inserisco la curva composita nel DB
int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
if ( nId != GDB_ID_NULL) {
// se richiesto, cancello le curve originali
if ( bErase) {
for ( Iter = vIds.begin() ; Iter != vIds.end() ; ++Iter) {
if ( ! pGeomDB->Erase( *Iter))
return GDB_ID_NULL ;
}
}
}
return nId ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPoints( int nParentId, int nP, const double ptPs[])
{
PolyLine PL ;
for ( int i = 0 ; i < nP ; ++i) {
PL.AddUPoint( 0, Point3d( ptPs[3*i], ptPs[3*i+1], ptPs[3*i+2])) ;
}
return EgtCreateCurveCompoFromPoints( nParentId, PL) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPoints( int nParentId, const PolyLine& PL)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return GDB_ID_NULL ;
// inserisco i segmenti che uniscono i punti
if ( ! pCrvCompo->FromPolyLine( PL))
return GDB_ID_NULL ;
// inserisco la curva composita nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPointBulges( int nParentId, int nPB, const double ptPBs[])
{
PolyArc PA ;
for ( int i = 0 ; i < nPB ; ++i) {
PA.AddUPoint( 0, Point3d( ptPBs[4*i], ptPBs[4*i+1], ptPBs[4*i+2]), ptPBs[4*i+3]) ;
}
return EgtCreateCurveCompoFromPointBulges( nParentId, PA) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPointBulges( int nParentId, const PolyArc& PA)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return GDB_ID_NULL ;
// inserisco i segmenti e gli archi che uniscono i punti
if ( ! pCrvCompo->FromPolyArc( PA))
return GDB_ID_NULL ;
// inserisco la curva composita nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPolygonSide( int nParentId, int nNumSides,
const double ptIni[3], const double ptFin[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return GDB_ID_NULL ;
// setto la curva
if ( ! pCrvCompo->PolygonSide( nNumSides, ptIni, ptFin))
return GDB_ID_NULL ;
// inserisco la curva nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTriMeshByContour( int nParentId, int nCrvId, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest))
return GDB_ID_NULL ;
// calcolo la polilinea che approssima la curva
PolyLine PL ;
if ( ! GetPolyLineFromCurve( pGeomDB, nCrvId, frDest, dLinTol, PL))
return GDB_ID_NULL ;
// creo la superficie trimesh
PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
if ( IsNull( pSTM))
return GDB_ID_NULL ;
// setto la superficie
if ( ! pSTM->CreateByFlatContour( PL))
return GDB_ID_NULL ;
// inserisco la superficie nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateText( int nParentId, const wchar_t* wsText,
@@ -636,39 +146,3 @@ __stdcall EgtCreateTextEx( int nParentId, const string& sText,
// inserisco il testo nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTXT)) ;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
static bool
GetPolyLineFromCurve( IGeomDB* pGeomDB, int nId, const Frame3d& frDest, double dLinTol, PolyLine& PL)
{
const double ANG_TOL_STD_DEG = 15 ;
// recupero la curva
const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCrv == nullptr)
return false ;
// recupero il riferimento della curva
Frame3d frCrv ;
if ( ! pGeomDB->GetGlobFrame( nId, frCrv))
return false ;
// calcolo la polilinea che approssima la curva
// se i riferimenti sono uguali
if ( AreSameFrame( frCrv, frDest)) {
// ricavo l'approssimazione
if ( ! pCrv->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, PL))
return false ;
}
// altrimenti devo prima trasformare la curva
else {
// creo una copia della curva (da buttare alla fine)
PtrOwner<ICurve> pModCrv( pCrv->Clone()) ;
if ( IsNull( pModCrv))
return false ;
// eseguo la trasformazione
pModCrv->LocToLoc( frCrv, frDest) ;
// ricavo l'approssimazione
if ( ! pModCrv->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, PL))
return false ;
}
return true ;
}
API_GdbCreateCurve.cpp
+613
View File
@@ -0,0 +1,613 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : API_GdbCreateCurve.cpp Data : 02.11.14 Versione : 1.5j7
// Contenuto : Funzioni di creazione curve del DB geometrico per API.
//
//
//
// Modifiche : 02.11.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "API.h"
#include "API_Macro.h"
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EgkCurveLine.h"
#include "/EgtDev/Include/EgkCurveArc.h"
#include "/EgtDev/Include/EgkCurveBezier.h"
#include "/EgtDev/Include/EgkCurveComposite.h"
#include "/EgtDev/Include/EgkChainCurves.h"
#include "/EgtDev/Include/EgkSurfTriMesh.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
using namespace std ;
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveLine( int nParentId, const double ptIni[3], const double ptFin[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo la linea
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
if ( IsNull( pCrvLine))
return GDB_ID_NULL ;
// setto la linea
if ( ! pCrvLine->Set( ptIni, ptFin))
return GDB_ID_NULL ;
// inserisco la linea nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvLine)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveLineMinPointCurve( int nParentId,
const double ptStart[3], int nCrvId, double dNearPar)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero il riferimento del gruppo destinazione
Frame3d frPoint ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frPoint))
return GDB_ID_NULL ;
// recupero il riferimento della curva
Frame3d frCurve ;
if ( ! pGeomDB->GetGlobFrame( nCrvId, frCurve))
return GDB_ID_NULL ;
// recupero la curva
const ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
if ( pCurve == nullptr)
return GDB_ID_NULL ;
// porto il punto nel riferimento della curva
Point3d ptSloc = ptStart ;
ptSloc.LocToLoc( frPoint, frCurve) ;
// calcolo il punto a minima distanza
int nFlag ;
Point3d ptEnd ;
DistPointCurve dstPtCurve( ptSloc, *pCurve) ;
if ( ! dstPtCurve.GetMinDistPoint( dNearPar, ptEnd, nFlag))
return GDB_ID_NULL ;
// porto il punto finale nel riferimento di creazione
ptEnd.LocToLoc( frCurve, frPoint) ;
// creo la linea
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
if ( IsNull( pCrvLine))
return GDB_ID_NULL ;
// setto la linea
if ( ! pCrvLine->Set( ptStart, ptEnd))
return GDB_ID_NULL ;
// inserisco la linea nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvLine)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCircle( int nParentId,
const double ptCen[3], const double vtN[3], double dRad)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto la circonferenza
if ( ! pCrvArc->Set( ptCen, vtN, dRad))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCircleXY( int nParentId,
const double ptCen[3], double dRad)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto la circonferenza
if ( ! pCrvArc->SetXY( ptCen, dRad))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCircleCPN( int nParentId,
const double ptCen[3], const double ptOn[3], const double vtN[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// calcolo il raggio
double dRad = (( Point3d( ptOn) - Point3d( ptCen)) ^ Vector3d( vtN)).Len() ;
// setto la circonferenza
if ( ! pCrvArc->Set( ptCen, vtN, dRad))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCircle3P( int nParentId,
const double ptP1[3], const double ptP2[3], const double ptP3[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto l'arco
if ( ! pCrvArc->Set3P( ptP1, ptP2, ptP3, true))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveArc( int nParentId,
const double ptCen[3], const double vtN[3], double dRad,
const double vtS[3], double dAngCenDeg, double dDeltaN)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto l'arco
if ( ! pCrvArc->Set( ptCen, vtN, dRad, vtS, dAngCenDeg, dDeltaN))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveArcXY( int nParentId,
const double ptCen[3], double dRad,
double dAngStartDeg, double dAngCenDeg, double dDeltaZ)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto l'arco
if ( ! pCrvArc->SetXY( ptCen, dRad, dAngStartDeg, dAngCenDeg, dDeltaZ))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveArc3P( int nParentId,
const double ptP1[3], const double ptP2[3], const double ptP3[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto l'arco
if ( ! pCrvArc->Set3P( ptP1, ptP2, ptP3, false))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveArcC2PN( int nParentId,
const double ptCen[3], const double ptStart[3], const double ptNearEnd[3], const double vtNorm[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo l'arco
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
if ( IsNull( pCrvArc))
return GDB_ID_NULL ;
// setto l'arco
if ( ! pCrvArc->SetC2PN( ptCen, ptStart, ptNearEnd, vtNorm))
return GDB_ID_NULL ;
// inserisco l'arco nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezier( int nParentId, int nDegree, const double ptCtrls[])
{
PNTVECTOR vPnt ;
vPnt.reserve( nDegree + 1) ;
for ( int i = 0 ; i <= nDegree ; ++i) {
vPnt.push_back( Point3d( ptCtrls[3*i], ptCtrls[3*i+1], ptCtrls[3*i+2])) ;
}
return EgtCreateCurveBezier( nParentId, nDegree, vPnt) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezier( int nParentId, int nDegree, const PNTVECTOR& vPnt)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// il numero dei punti deve essere pari al grado + 1
if ( vPnt.size() != nDegree + 1)
return GDB_ID_NULL ;
// creo la curva di Bezier
PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
if ( IsNull( pCrvBez))
return GDB_ID_NULL ;
// inizializzo la curva di Bezier
if ( ! pCrvBez->Init( nDegree, false))
return GDB_ID_NULL ;
// setto i punti di controllo
for ( int i = 0 ; i <= nDegree ; ++ i) {
if ( ! pCrvBez->SetControlPoint( i, vPnt[i]))
return GDB_ID_NULL ;
}
// se curva nulla (ovvero ridotta a punto), errore
if ( pCrvBez->IsAPoint())
return GDB_ID_NULL ;
// inserisco la curva nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvBez)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezierRational( int nParentId, int nDegree, const double ptCtrlWs[])
{
PNTUVECTOR vPntW ;
vPntW.reserve( nDegree + 1) ;
for ( int i = 0 ; i <= nDegree ; ++i) {
vPntW.push_back( make_pair( Point3d( ptCtrlWs[4*i], ptCtrlWs[4*i+1], ptCtrlWs[4*i+2]), ptCtrlWs[4*i+3])) ;
}
return EgtCreateCurveBezierRational( nParentId, nDegree, vPntW) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezierRational( int nParentId, int nDegree, const PNTUVECTOR& vPntW)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// il numero dei punti deve essere pari al grado + 1
if ( vPntW.size() != nDegree + 1)
return GDB_ID_NULL ;
// creo la curva di Bezier
PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
if ( IsNull( pCrvBez))
return GDB_ID_NULL ;
// inizializzo la curva di Bezier
if ( ! pCrvBez->Init( nDegree, true))
return GDB_ID_NULL ;
// setto i punti di controllo
for ( int i = 0 ; i <= nDegree ; ++ i) {
if ( ! pCrvBez->SetControlPoint( i, vPntW[i].first, vPntW[i].second))
return GDB_ID_NULL ;
}
// se curva nulla (ovvero ridotta a punto), errore
if ( pCrvBez->IsAPoint())
return GDB_ID_NULL ;
// inserisco la curva nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvBez)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveBezierFromArc( int nParentId, int nArcId, BOOL bErase)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo la curva di Bezier
PtrOwner<ICurveBezier> pCrvBez( CreateCurveBezier()) ;
if ( IsNull( pCrvBez))
return GDB_ID_NULL ;
// recupero l'arco
const ICurveArc* pCrvArc = GetCurveArc( pGeomDB->GetGeoObj( nArcId)) ;
if ( pCrvArc == nullptr)
return GDB_ID_NULL ;
// ne deduco la curva di Bezier
if ( ! pCrvBez->FromArc( *pCrvArc))
return GDB_ID_NULL ;
// recupero il riferimento dell'arco
Frame3d frSou ;
if ( ! pGeomDB->GetGlobFrame( nArcId, frSou))
return GDB_ID_NULL ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest))
return GDB_ID_NULL ;
// porto la curva di Bezier dal riferimento dell'arco a quello di inserimento
if ( ! AreSameFrame( frSou, frDest)) {
pCrvBez->ToGlob( frSou) ;
pCrvBez->ToLoc( frDest) ;
}
// se curva nulla (ovvero ridotta a punto), errore
if ( pCrvBez->IsAPoint())
return GDB_ID_NULL ;
// inserisco la curva nel DB
int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvBez)) ;
if ( nId != GDB_ID_NULL) {
// se richiesto, cancello l'arco originale
if ( bErase) {
if ( ! pGeomDB->Erase( nArcId))
return GDB_ID_NULL ;
}
}
return nId ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompo( int nParentId, int nNumId, const int nIds[], BOOL bErase)
{
INTVECTOR vIds ;
vIds.reserve( nNumId) ;
for ( int i = 0 ; i < nNumId ; ++i) {
vIds.push_back( nIds[i]) ;
}
return EgtCreateCurveCompo( nParentId, vIds, ( bErase != FALSE)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompo( int nParentId, const INTVECTOR& vIds, bool bErase)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return GDB_ID_NULL ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest))
return false ;
// esecuzione
INTVECTOR::const_iterator Iter ;
for ( Iter = vIds.begin() ; Iter != vIds.end() ; ++Iter) {
// recupero la curva
int nIdCrv = *Iter ;
const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nIdCrv)) ;
if ( pCrv == nullptr)
return false ;
// recupero il riferimento della curva
Frame3d frSou ;
if ( ! pGeomDB->GetGlobFrame( nIdCrv, frSou))
return false ;
// se i riferimenti sono uguali
if ( AreSameFrame( frSou, frDest)) {
// aggiungo direttamente questa curva
if ( ! pCrvCompo->AddCurve( *pCrv))
return false ;
}
// altrimenti devo prima trasformare la curva
else {
// creo una copia della curva
PtrOwner<ICurve> pModCrv( pCrv->Clone()) ;
if ( IsNull( pModCrv))
return false ;
// eseguo la trasformazione
pModCrv->LocToLoc( frSou, frDest) ;
// aggiungo la curva modificata
if ( ! pCrvCompo->AddCurve( Release( pModCrv)))
return false ;
}
}
// inserisco la curva composita nel DB
int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
if ( nId != GDB_ID_NULL) {
// se richiesto, cancello le curve originali
if ( bErase) {
for ( Iter = vIds.begin() ; Iter != vIds.end() ; ++Iter) {
if ( ! pGeomDB->Erase( *Iter))
return GDB_ID_NULL ;
}
}
}
return nId ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoByChain( int nParentId, int nNumId, const int nIds[], const double ptNear[3], BOOL bErase)
{
INTVECTOR vIds ;
vIds.reserve( nNumId) ;
for ( int i = 0 ; i < nNumId ; ++i) {
vIds.push_back( nIds[i]) ;
}
return EgtCreateCurveCompoByChain( nParentId, vIds, ptNear, ( bErase != FALSE)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoByChain( int nParentId, const INTVECTOR& vIds, const Point3d& ptNear, bool bErase)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return GDB_ID_NULL ;
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest))
return GDB_ID_NULL ;
// preparo i dati per il concatenamento
double dToler = 10 * EPS_SMALL ;
ChainCurves chainC ;
chainC.Init( true, dToler, int( vIds.size())) ;
INTVECTOR::const_iterator Iter ;
for ( Iter = vIds.begin() ; Iter != vIds.end() ; ++Iter) {
// recupero la curva e il suo riferimento
ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( *Iter)) ;
if ( pCrv == nullptr)
return GDB_ID_NULL ;
Frame3d frCrv ;
if ( ! pGeomDB->GetGlobFrame( *Iter, frCrv))
return GDB_ID_NULL ;
// recupero i dati della curva necessari al concatenamento e li assegno
Point3d ptStart, ptEnd ;
Vector3d vtStart, vtEnd ;
if ( ! pCrv->GetStartPoint( ptStart) || ! pCrv->GetStartDir( vtStart) ||
! pCrv->GetEndPoint( ptEnd) || ! pCrv->GetEndDir( vtEnd))
return GDB_ID_NULL ;
ptStart.LocToLoc( frCrv, frDest) ;
vtStart.LocToLoc( frCrv, frDest) ;
ptEnd.LocToLoc( frCrv, frDest) ;
vtEnd.LocToLoc( frCrv, frDest) ;
if ( ! chainC.AddCurve( *Iter, ptStart, vtStart, ptEnd, vtEnd))
return GDB_ID_NULL ;
}
// recupero i percorsi concatenati
int nFirstId = GDB_ID_NULL ;
Point3d ptNearStart( ptNear) ;
INTVECTOR vId2s ;
while ( chainC.GetChainFromNear( ptNearStart, vId2s)) {
// creo una curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return GDB_ID_NULL ;
// recupero le curve semplici e le inserisco nella curva composita
INTVECTOR::iterator Iter ;
for ( Iter = vId2s.begin() ; Iter != vId2s.end() ; ++Iter) {
int nId = abs( *Iter) ;
bool bInvert = ( *Iter < 0) ;
// recupero la curva e il suo riferimento
ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCrv == nullptr)
return GDB_ID_NULL ;
Frame3d frCrv ;
if ( ! pGeomDB->GetGlobFrame( nId, frCrv))
return GDB_ID_NULL ;
// copio la curva
PtrOwner<ICurve> pCopCrv( pCrv->Clone()) ;
if ( IsNull( pCopCrv))
return GDB_ID_NULL ;
// se necessario, la inverto
if ( bInvert)
pCopCrv->Invert() ;
// la sistemo per i riferimenti
pCopCrv->LocToLoc( frCrv, frDest) ;
// la aggiungo alla curva composta
if ( ! pCrvCompo->AddCurve( ::Release( pCopCrv), true, dToler))
return GDB_ID_NULL ;
}
// aggiorno il nuovo punto vicino
if ( pCrvCompo->GetCurveNumber() > 0)
pCrvCompo->GetEndPoint( ptNearStart) ;
// inserisco la curva composita nel gruppo destinazione
if ( pCrvCompo->GetCurveNumber() > 0) {
int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, ::Release( pCrvCompo)) ;
if ( nNewId == GDB_ID_NULL)
return GDB_ID_NULL ;
if ( nFirstId == GDB_ID_NULL)
nFirstId = nNewId ;
}
}
// se richiesto, cancello le curve originali
if ( bErase) {
for ( Iter = vIds.begin() ; Iter != vIds.end() ; ++Iter) {
if ( ! pGeomDB->Erase( *Iter))
return GDB_ID_NULL ;
}
}
return nFirstId ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPoints( int nParentId, int nP, const double ptPs[])
{
PolyLine PL ;
for ( int i = 0 ; i < nP ; ++i) {
PL.AddUPoint( 0, Point3d( ptPs[3*i], ptPs[3*i+1], ptPs[3*i+2])) ;
}
return EgtCreateCurveCompoFromPoints( nParentId, PL) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPoints( int nParentId, const PolyLine& PL)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return GDB_ID_NULL ;
// inserisco i segmenti che uniscono i punti
if ( ! pCrvCompo->FromPolyLine( PL))
return GDB_ID_NULL ;
// inserisco la curva composita nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPointBulges( int nParentId, int nPB, const double ptPBs[])
{
PolyArc PA ;
for ( int i = 0 ; i < nPB ; ++i) {
PA.AddUPoint( 0, Point3d( ptPBs[4*i], ptPBs[4*i+1], ptPBs[4*i+2]), ptPBs[4*i+3]) ;
}
return EgtCreateCurveCompoFromPointBulges( nParentId, PA) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPointBulges( int nParentId, const PolyArc& PA)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return GDB_ID_NULL ;
// inserisco i segmenti e gli archi che uniscono i punti
if ( ! pCrvCompo->FromPolyArc( PA))
return GDB_ID_NULL ;
// inserisco la curva composita nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateCurveCompoFromPolygonSide( int nParentId, int nNumSides,
const double ptIni[3], const double ptFin[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// creo la curva composita
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return GDB_ID_NULL ;
// setto la curva
if ( ! pCrvCompo->PolygonSide( nNumSides, ptIni, ptFin))
return GDB_ID_NULL ;
// inserisco la curva nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvCompo)) ;
}
API_GdbCreateSurf.cpp
+146
View File
@@ -0,0 +1,146 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : API_GdbCreateSurf.cpp Data : 02.11.14 Versione : 1.5j7
// Contenuto : Funzioni di creazione superfici del DB geometrico per API.
//
//
//
// Modifiche : 02.11.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "API.h"
#include "API_Macro.h"
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EgkCurve.h"
#include "/EgtDev/Include/EgkSurfTriMesh.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
using namespace std ;
//-------------------------------------------------------------------------------
static bool GetPolyLineFromCurve( IGeomDB* pGeomDB, int nId, const Frame3d& frDest, double dLinTol, PolyLine& PL) ;
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTriMeshByContour( int nParentId, int nCrvId, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest))
return GDB_ID_NULL ;
// calcolo la polilinea che approssima la curva
PolyLine PL ;
if ( ! GetPolyLineFromCurve( pGeomDB, nCrvId, frDest, dLinTol, PL))
return GDB_ID_NULL ;
// creo la superficie trimesh
PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
if ( IsNull( pSTM))
return GDB_ID_NULL ;
// setto la superficie
if ( ! pSTM->CreateByFlatContour( PL))
return GDB_ID_NULL ;
// inserisco la superficie nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTriMeshByExtrusion( int nParentId, int nCrvId, const double vtExtr[3], double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest))
return GDB_ID_NULL ;
// calcolo la polilinea che approssima la curva
PolyLine PL ;
if ( ! GetPolyLineFromCurve( pGeomDB, nCrvId, frDest, dLinTol, PL))
return GDB_ID_NULL ;
// creo la superficie trimesh
PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
if ( IsNull( pSTM))
return GDB_ID_NULL ;
// setto la superficie
if ( ! pSTM->CreateByExtrusion( PL, vtExtr))
return GDB_ID_NULL ;
// inserisco la superficie nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) ;
}
//-------------------------------------------------------------------------------
int
__stdcall EgtCreateSurfTriMeshByScrewing( int nParentId, int nCrvId,
const double ptAx[3], const double vtAx[3],
double dAngRotDeg, double dMove, double dLinTol)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero il riferimento del gruppo destinazione
Frame3d frDest ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest))
return GDB_ID_NULL ;
// calcolo la polilinea che approssima la curva
PolyLine PL ;
if ( ! GetPolyLineFromCurve( pGeomDB, nCrvId, frDest, dLinTol, PL))
return GDB_ID_NULL ;
// calcolo lo step di rotazione
double dMaxRad = 0 ;
PL.GetMaxDistanceFromLine( dMaxRad, ptAx, vtAx, 1, false) ;
if ( dMaxRad < EPS_SMALL)
return false ;
double dStepRotDeg = sqrt( 8 * dLinTol / dMaxRad) * RADTODEG ;
// creo la superficie trimesh
PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
if ( IsNull( pSTM))
return GDB_ID_NULL ;
// setto la superficie
if ( ! pSTM->CreateByScrewing( PL, ptAx, vtAx, dAngRotDeg, dStepRotDeg, dMove))
return GDB_ID_NULL ;
// inserisco la superficie nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pSTM)) ;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
static bool
GetPolyLineFromCurve( IGeomDB* pGeomDB, int nId, const Frame3d& frDest, double dLinTol, PolyLine& PL)
{
const double ANG_TOL_STD_DEG = 15 ;
// recupero la curva
const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCrv == nullptr)
return false ;
// recupero il riferimento della curva
Frame3d frCrv ;
if ( ! pGeomDB->GetGlobFrame( nId, frCrv))
return false ;
// calcolo la polilinea che approssima la curva
// se i riferimenti sono uguali
if ( AreSameFrame( frCrv, frDest)) {
// ricavo l'approssimazione
if ( ! pCrv->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, PL))
return false ;
}
// altrimenti devo prima trasformare la curva
else {
// creo una copia della curva (da buttare alla fine)
PtrOwner<ICurve> pModCrv( pCrv->Clone()) ;
if ( IsNull( pModCrv))
return false ;
// eseguo la trasformazione
pModCrv->LocToLoc( frCrv, frDest) ;
// ricavo l'approssimazione
if ( ! pModCrv->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, PL))
return false ;
}
return true ;
}
API_GdbModify.cpp
+14
View File
@@ -60,6 +60,20 @@ __stdcall EgtChangeVectorBase( int nId, const double ptB[3])
return ( pGVect->ChangeBase( ptB) ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtInvertSurface( int nId)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la superficie
ISurf* pSurf = GetSurf( pGeomDB->GetGeoObj( nId)) ;
if ( pSurf == nullptr)
return false ;
// la inverto
return ( pSurf->Invert() ? TRUE : FALSE) ;
}
//-------------------------------------------------------------------------------
BOOL
__stdcall EgtModifyText( int nId, const wchar_t* wsNewText)
API_CurveModif.cpp → API_GdbModifyCurve.cpp
+64 -9
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : API_CurveModif.cpp Data : 03.10.14 Versione : 1.5i5
// File : API_ModifyCurve.cpp Data : 03.10.14 Versione : 1.5i5
// Contenuto : Funzioni di modifica delle curve per API.
//
//
@@ -18,6 +18,7 @@
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EgkCurve.h"
#include "/EgtDev/Include/EgkCurveArc.h"
#include "/EgtDev/Include/EgkCurveComposite.h"
//----------------------------------------------------------------------------
@@ -162,23 +163,25 @@ __stdcall EgtTrimCurveStartEndAtParam( int nId, double dParS, double dParE)
//-------------------------------------------------------------------------------
BOOL
__stdcall EgtModifyCurveArc3P( int nId, const double ptMid[3])
__stdcall EgtModifyCurveCircleCPN( int nId, const double ptOn[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
// recupero l'arco e i suoi punti notevoli
// recupero l'arco e i suoi dati
ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ;
if ( pArc == nullptr)
return FALSE ;
Point3d ptStart, ptOldMid, ptEnd ;
if ( ! pArc->GetStartPoint( ptStart) || ! pArc->GetMidPoint( ptOldMid) || ! pArc->GetEndPoint( ptEnd))
return false ;
// imposto il nuovo punto medio
if ( pArc->Set3P( ptStart, ptMid, ptEnd))
Point3d ptCen = pArc->GetCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
double dOldRad = pArc->GetRadius() ;
// calcolo il nuovo raggio
double dRad = (( Point3d( ptOn) - ptCen) ^ vtN).Len() ;
// imposto il nuovo raggio
if ( pArc->Set( ptCen, vtN, dRad))
return TRUE ;
// in caso di errore, ripristino i vecchi dati
else {
pArc->Set3P( ptStart, ptOldMid, ptEnd) ;
pArc->Set( ptCen, vtN, dOldRad) ;
return FALSE ;
}
}
@@ -207,3 +210,55 @@ __stdcall EgtModifyCurveArcC2PN( int nId, const double ptEnd[3])
return FALSE ;
}
}
//-------------------------------------------------------------------------------
BOOL
__stdcall EgtModifyCurveArc3P( int nId, const double ptMid[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
// recupero l'arco e i suoi punti notevoli
ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ;
if ( pArc == nullptr)
return FALSE ;
Point3d ptStart, ptOldMid, ptEnd ;
if ( ! pArc->GetStartPoint( ptStart) || ! pArc->GetMidPoint( ptOldMid) || ! pArc->GetEndPoint( ptEnd))
return false ;
// imposto il nuovo punto medio
if ( pArc->Set3P( ptStart, ptMid, ptEnd))
return TRUE ;
// in caso di errore, ripristino i vecchi dati
else {
pArc->Set3P( ptStart, ptOldMid, ptEnd) ;
return FALSE ;
}
}
//-------------------------------------------------------------------------------
BOOL
__stdcall EgtSplitCurveCompo( int nId)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
// recupero la curva composita
ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
if ( pCompo == nullptr)
return FALSE ;
// ne recupero il padre
int nParentId = pGeomDB->GetParentId( nId) ;
if ( nParentId == GDB_ID_NULL)
return FALSE ;
// estraggo tutte le curve
ICurve* pCrv ;
while ( ( pCrv = pCompo->RemoveFirstOrLastCurve( false)) != nullptr) {
// inserisco la curva nello stesso gruppo del GeomDB
int nCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, pCrv) ;
if ( nCrvId == GDB_ID_NULL)
return FALSE ;
// copio gli attributi
if ( ! pGeomDB->CopyAttributes( nId, nCrvId))
return FALSE ;
}
// elimino la curva composita ormai vuota
return ( pGeomDB->Erase( nId) ? TRUE : FALSE) ;
}
API_GdbObjAttribs.cpp
+39 -2
View File
@@ -236,9 +236,46 @@ __stdcall EgtSetColor( int nId, const int ObjCol[4])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
// assegno il colore
// sistemo il colore
Color cCol( ObjCol) ;
return ( pGeomDB->SetMaterial( nId, cCol) ? TRUE : FALSE) ;
// assegno il colore a un singolo oggetto
if ( nId != GDB_ID_SEL) {
return ( pGeomDB->SetMaterial( nId, cCol) ? TRUE : FALSE) ;
}
// assegno il colore ai selezionati
else {
bool bOk = true ;
int nI = pGeomDB->GetFirstSelectedObj() ;
while ( nI != GDB_ID_NULL && bOk) {
if ( ! pGeomDB->SetMaterial( nI, cCol))
bOk = false ;
nI = pGeomDB->GetNextSelectedObj() ;
}
return ( bOk ? TRUE : FALSE) ;
}
}
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtResetColor( int nId)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
// tolgo il colore a un singolo oggetto
if ( nId != GDB_ID_SEL) {
return ( pGeomDB->SetMaterial( nId, GDB_MT_PARENT) ? TRUE : FALSE) ;
}
// tolgo il colore ai selezionati
else {
bool bOk = true ;
int nI = pGeomDB->GetFirstSelectedObj() ;
while ( nI != GDB_ID_NULL && bOk) {
if ( ! pGeomDB->SetMaterial( nI, GDB_MT_PARENT))
bOk = false ;
nI = pGeomDB->GetNextSelectedObj() ;
}
return ( bOk ? TRUE : FALSE) ;
}
}
//-----------------------------------------------------------------------------
API_GdbObjSelection.cpp
+12 -2
View File
@@ -63,12 +63,22 @@ BOOL
return ( pGeomDB->IsSelectedObj( nId) ? TRUE : FALSE) ;
}
//-----------------------------------------------------------------------------
int
__stdcall EgtGetSelectedObjNbr( void)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, 0)
// restituisco il numero di oggetti selezionati
return pGeomDB->GetSelectedObjNbr() ;
}
//-----------------------------------------------------------------------------
int
__stdcall EgtGetFirstSelectedObj( void)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero il primo oggetto selezionato
return pGeomDB->GetFirstSelectedObj() ;
}
@@ -78,7 +88,7 @@ int
__stdcall EgtGetNextSelectedObj( void)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero il successivo oggetto selezionato
return pGeomDB->GetNextSelectedObj() ;
}
API_Scene.cpp
+15
View File
@@ -286,6 +286,21 @@ __stdcall EgtGetGraphicSnapPoint( int nSnap, int nWinX, int nWinY, int nSelW, in
return TRUE ;
}
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetGridSnapPointZ( BOOL bSketch, int nWinX, int nWinY, const double ptGrid[3],
double ptP[3])
{
GseContext* pGseCtx = GetCurrGseContext() ;
VERIFY_CTX_SCENE( pGseCtx, FALSE)
// trovo il punto snap da selezione
Point3d ptSnap ;
if ( ! pGseCtx->m_pScene->GetGridSnapPointZ( ( bSketch != FALSE), Point3d( nWinX, nWinY), ptGrid, ptSnap))
return FALSE ;
VEC_FROM_3D( ptP, ptSnap)
return TRUE ;
}
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSetShowMode( int nShowMode, BOOL bRedraw)
EgtInterface.rc
BIN
View File
Binary file not shown.
EgtInterface.vcxproj
+3 -1
View File
@@ -202,7 +202,9 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClInclude Include="stdafx.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="API_CurveModif.cpp" />
<ClCompile Include="API_GdbCreateCurve.cpp" />
<ClCompile Include="API_GdbCreateSurf.cpp" />
<ClCompile Include="API_GdbModifyCurve.cpp" />
<ClCompile Include="API_Exchange.cpp" />
<ClCompile Include="API_GdbModify.cpp" />
<ClCompile Include="API_GdbObjAttribs.cpp" />
EgtInterface.vcxproj.filters
+9 -3
View File
@@ -119,9 +119,6 @@
<ClCompile Include="LUA_CurveModif.cpp">
<Filter>File di origine</Filter>
</ClCompile>
<ClCompile Include="API_CurveModif.cpp">
<Filter>File di origine</Filter>
</ClCompile>
<ClCompile Include="API_GdbModify.cpp">
<Filter>File di origine</Filter>
</ClCompile>
@@ -134,6 +131,15 @@
<ClCompile Include="API_GeoBase.cpp">
<Filter>File di origine</Filter>
</ClCompile>
<ClCompile Include="API_GdbCreateCurve.cpp">
<Filter>File di origine</Filter>
</ClCompile>
<ClCompile Include="API_GdbModifyCurve.cpp">
<Filter>File di origine</Filter>
</ClCompile>
<ClCompile Include="API_GdbCreateSurf.cpp">
<Filter>File di origine</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="EgtInterface.rc">