Dario Sassi
614 lines
22 KiB
C++
614 lines
22 KiB
C++
//----------------------------------------------------------------------------
|
|
// 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)) ;
|
|
}
|