//---------------------------------------------------------------------------- // 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/EInConst.h" #include "/EgtDev/Include/EgkCurveLine.h" #include "/EgtDev/Include/EGkLinePntTgCurve.h" #include "/EgtDev/Include/EGkLinePntPerpCurve.h" #include "/EgtDev/Include/EGkLinePntMinDistCurve.h" #include "/EgtDev/Include/EGkLineTgTwoCurves.h" #include "/EgtDev/Include/EGkLinePerpTwoCurves.h" #include "/EgtDev/Include/EGkLineTgCurvePerpCurve.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 ; //------------------------------------------------------------------------------- static ICurveLine* __stdcall CreateLinePointTgCurve( IGeomDB* pGeomDB, int nParentId, const Point3d& ptIni, const Point3d& ptFin, int nIdF) ; static ICurveLine* __stdcall CreateLinePointPerpCurve( IGeomDB* pGeomDB, int nParentId, const Point3d& ptIni, const Point3d& ptFin, int nIdF) ; static ICurveLine* __stdcall CreateLinePointMinDistCurve( IGeomDB* pGeomDB, int nParentId, const Point3d& ptIni, const Point3d& ptFin, int nIdF) ; static ICurveLine* __stdcall CreateLineTgTwoCurves( IGeomDB* pGeomDB, int nParentId, const Point3d& ptIni, int nIdI, const Point3d& ptFin, int nIdF) ; static ICurveLine* __stdcall CreateLinePerpTwoCurves( IGeomDB* pGeomDB, int nParentId, const Point3d& ptIni, int nIdI, const Point3d& ptFin, int nIdF) ; static ICurveLine* __stdcall CreateLineTgCurvePerpCurve( IGeomDB* pGeomDB, int nParentId, const Point3d& ptIni, int nIdI, const Point3d& ptFin, int nIdF) ; //------------------------------------------------------------------------------- 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 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 EgtCreateCurveLineEx( int nParentId, const double ptIni[3], int nSepI, int nIdI, const double ptFin[3], int nSepF, int nIdF) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL) // puntatore alla linea PtrOwner pCrvLine ; // 1 - se punti entrambi definiti if ( nSepI == SEP_STD && nSepF == SEP_STD) { pCrvLine.Set( CreateCurveLine()) ; if ( IsNull( pCrvLine)) return GDB_ID_NULL ; if ( ! pCrvLine->Set( ptIni, ptFin)) return GDB_ID_NULL ; } // 2 - se primo punto definito e secondo a minima distanza else if ( nSepI == SEP_STD && nSepF == SEP_MINDIST) { pCrvLine.Set( CreateLinePointMinDistCurve( pGeomDB, nParentId, ptIni, ptFin, nIdF)) ; if ( IsNull( pCrvLine)) return GDB_ID_NULL ; } // 3 - se primo punto a minima distanza e secondo definito else if ( nSepI == SEP_MINDIST && nSepF == SEP_STD) { pCrvLine.Set( CreateLinePointMinDistCurve( pGeomDB, nParentId, ptFin, ptIni, nIdI)) ; if ( IsNull( pCrvLine)) return GDB_ID_NULL ; pCrvLine->Invert() ; } // 4 - se primo punto definito e secondo tangente else if ( nSepI == SEP_STD && nSepF == SEP_TG) { pCrvLine.Set( CreateLinePointTgCurve( pGeomDB, nParentId, ptIni, ptFin, nIdF)) ; if ( IsNull( pCrvLine)) return GDB_ID_NULL ; } // 5 - se primo punto tangente e secondo definito else if ( nSepI == SEP_TG && nSepF == SEP_STD) { // costruisco la curva al contrario e poi la inverto pCrvLine.Set( CreateLinePointTgCurve( pGeomDB, nParentId, ptFin, ptIni, nIdI)) ; if ( IsNull( pCrvLine)) return GDB_ID_NULL ; pCrvLine->Invert() ; } // 6 - se entrambi i punti tangenti else if ( nSepI == SEP_TG && nSepF == SEP_TG) { pCrvLine.Set( CreateLineTgTwoCurves( pGeomDB, nParentId, ptIni, nIdI, ptFin, nIdF)) ; if ( IsNull( pCrvLine)) return GDB_ID_NULL ; } // 7 - se primo punto definito e secondo perpendicolare else if ( nSepI == SEP_STD && nSepF == SEP_PERP) { pCrvLine.Set( CreateLinePointPerpCurve( pGeomDB, nParentId, ptIni, ptFin, nIdF)) ; if ( IsNull( pCrvLine)) return GDB_ID_NULL ; } // 8 - se primo punto perpendicolare e secondo definito else if ( nSepI == SEP_PERP && nSepF == SEP_STD) { // costruisco la curva al contrario e poi la inverto pCrvLine.Set( CreateLinePointPerpCurve( pGeomDB, nParentId, ptFin, ptIni, nIdI)) ; if ( IsNull( pCrvLine)) return GDB_ID_NULL ; pCrvLine->Invert() ; } // 9 - se entrambi i punti perpendicolari else if ( nSepI == SEP_PERP && nSepF == SEP_PERP) { pCrvLine.Set( CreateLinePerpTwoCurves( pGeomDB, nParentId, ptIni, nIdI, ptFin, nIdF)) ; if ( IsNull( pCrvLine)) return GDB_ID_NULL ; } // 10 - se primo punto tangente e secondo perpendicolare else if ( nSepI == SEP_TG && nSepF == SEP_PERP) { pCrvLine.Set( CreateLineTgCurvePerpCurve( pGeomDB, nParentId, ptIni, nIdI, ptFin, nIdF)) ; if ( IsNull( pCrvLine)) return GDB_ID_NULL ; } // 11 - se primo punto perpendicolare e secondo tangente else if ( nSepI == SEP_PERP && nSepF == SEP_TG) { // costruisco la curva al contrario e poi la inverto pCrvLine.Set( CreateLineTgCurvePerpCurve( pGeomDB, nParentId, ptFin, nIdF, ptIni, nIdI)) ; if ( IsNull( pCrvLine)) return GDB_ID_NULL ; pCrvLine->Invert() ; } // errore else { return GDB_ID_NULL ; } // inserisco la linea nel DB return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvLine)) ; } //------------------------------------------------------------------------------- ICurveLine* __stdcall CreateLinePointTgCurve( IGeomDB* pGeomDB, int nParentId, const Point3d& ptIni, const Point3d& ptFin, int nIdF) { // verifica preliminare Id curva if ( nIdF == GDB_ID_NULL) return nullptr ; // recupero il riferimento del gruppo destinazione Frame3d frDest ; if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest)) return nullptr ; // recupero il riferimento della curva Frame3d frCurve ; if ( ! pGeomDB->GetGlobFrame( nIdF, frCurve)) return nullptr ; // porto il punto iniziale nel riferimento della curva Point3d ptSloc( ptIni) ; ptSloc.LocToLoc( frDest, frCurve) ; // porto il punto vicino al finale nel riferimento della curva Point3d ptNloc( ptFin) ; ptNloc.LocToLoc( frDest, frCurve) ; // recupero la curva const ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nIdF)) ; if ( pCurve == nullptr) return false ; // calcolo la retta tangente alla curva PtrOwner pCrvLine ; pCrvLine.Set( GetLinePointTgCurve( ptSloc, *pCurve, ptNloc)) ; if ( IsNull( pCrvLine)) return nullptr ; // porto la linea nel riferimento del gruppo destinazione pCrvLine->LocToLoc( frCurve, frDest) ; // restituisco la linea return Release( pCrvLine) ; } //------------------------------------------------------------------------------- ICurveLine* __stdcall CreateLinePointPerpCurve( IGeomDB* pGeomDB, int nParentId, const Point3d& ptIni, const Point3d& ptFin, int nIdF) { // verifica preliminare Id curva if ( nIdF == GDB_ID_NULL) return nullptr ; // recupero il riferimento del gruppo destinazione Frame3d frDest ; if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest)) return nullptr ; // recupero il riferimento della curva Frame3d frCurve ; if ( ! pGeomDB->GetGlobFrame( nIdF, frCurve)) return nullptr ; // porto il punto iniziale nel riferimento della curva Point3d ptSloc( ptIni) ; ptSloc.LocToLoc( frDest, frCurve) ; // porto il punto vicino al finale nel riferimento della curva Point3d ptNloc( ptFin) ; ptNloc.LocToLoc( frDest, frCurve) ; // recupero la curva const ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nIdF)) ; if ( pCurve == nullptr) return nullptr ; // calcolo la retta perpendicolare alla curva PtrOwner pCrvLine ; pCrvLine.Set( GetLinePointPerpCurve( ptSloc, *pCurve, ptNloc)) ; if ( IsNull( pCrvLine)) return nullptr ; // porto la linea nel riferimento del gruppo destinazione pCrvLine->LocToLoc( frCurve, frDest) ; // restituisco la linea return Release( pCrvLine) ; } //------------------------------------------------------------------------------- ICurveLine* __stdcall CreateLinePointMinDistCurve( IGeomDB* pGeomDB, int nParentId, const Point3d& ptIni, const Point3d& ptFin, int nIdF) { // verifica preliminare Id curva if ( nIdF == GDB_ID_NULL) return nullptr ; // recupero il riferimento del gruppo destinazione Frame3d frDest ; if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest)) return nullptr ; // recupero il riferimento della curva Frame3d frCurve ; if ( ! pGeomDB->GetGlobFrame( nIdF, frCurve)) return nullptr ; // porto il punto iniziale nel riferimento della curva Point3d ptSloc( ptIni) ; ptSloc.LocToLoc( frDest, frCurve) ; // porto il punto vicino al finale nel riferimento della curva Point3d ptNloc( ptFin) ; ptNloc.LocToLoc( frDest, frCurve) ; // recupero la curva const ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nIdF)) ; if ( pCurve == nullptr) return nullptr ; // calcolo la retta perpendicolare alla curva PtrOwner pCrvLine ; pCrvLine.Set( GetLinePointMinDistCurve( ptSloc, *pCurve, ptNloc)) ; if ( IsNull( pCrvLine)) return nullptr ; // porto la linea nel riferimento del gruppo destinazione pCrvLine->LocToLoc( frCurve, frDest) ; // restituisco la linea return Release( pCrvLine) ; } //------------------------------------------------------------------------------- ICurveLine* __stdcall CreateLineTgTwoCurves( IGeomDB* pGeomDB, int nParentId, const Point3d& ptIni, int nIdI, const Point3d& ptFin, int nIdF) { // verifica preliminare Id curve if ( nIdF == GDB_ID_NULL || nIdI == GDB_ID_NULL) return nullptr ; // recupero il riferimento del gruppo destinazione Frame3d frDest ; if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest)) return nullptr ; // recupero il riferimento della prima curva Frame3d frCrv1 ; if ( ! pGeomDB->GetGlobFrame( nIdI, frCrv1)) return nullptr ; // recupero la prima curva const ICurve* pCrv1 = GetCurve( pGeomDB->GetGeoObj( nIdI)) ; if ( pCrv1 == nullptr) return nullptr ; // porto il punto vicino a iniziale nel riferimento della prima curva Point3d ptN1loc( ptIni) ; ptN1loc.LocToLoc( frDest, frCrv1) ; // recupero il riferimento della seconda curva Frame3d frCrv2 ; if ( ! pGeomDB->GetGlobFrame( nIdF, frCrv2)) return nullptr ; // recupero la seconda curva const ICurve* pCrv2 = GetCurve( pGeomDB->GetGeoObj( nIdF)) ; if ( pCrv2 == nullptr) return false ; // porto la seconda curva nel riferimento della prima PtrOwner pCrv2Loc( pCrv2->Clone()) ; if ( IsNull( pCrv2Loc)) return nullptr ; pCrv2Loc->LocToLoc( frCrv2, frCrv1) ; // porto il punto vicino al finale nel riferimento della prima curva Point3d ptN2loc( ptFin) ; ptN2loc.LocToLoc( frDest, frCrv1) ; // calcolo la retta tangente alle due curve PtrOwner pCrvLine ; pCrvLine.Set( GetLineTgTwoCurves( *pCrv1, ptN1loc, *pCrv2, ptN2loc)) ; if ( IsNull( pCrvLine)) return nullptr ; // porto la linea nel riferimento del gruppo destinazione pCrvLine->LocToLoc( frCrv1, frDest) ; // restituisco la linea return Release( pCrvLine) ; } //------------------------------------------------------------------------------- ICurveLine* __stdcall CreateLinePerpTwoCurves( IGeomDB* pGeomDB, int nParentId, const Point3d& ptIni, int nIdI, const Point3d& ptFin, int nIdF) { // verifica preliminare Id curve if ( nIdI == GDB_ID_NULL || nIdF == GDB_ID_NULL) return nullptr ; // recupero il riferimento del gruppo destinazione Frame3d frDest ; if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest)) return nullptr ; // recupero il riferimento della prima curva Frame3d frCrv1 ; if ( ! pGeomDB->GetGlobFrame( nIdI, frCrv1)) return nullptr ; // recupero la prima curva const ICurve* pCrv1 = GetCurve( pGeomDB->GetGeoObj( nIdI)) ; if ( pCrv1 == nullptr) return nullptr ; // porto il punto vicino a iniziale nel riferimento della prima curva Point3d ptN1loc( ptIni) ; ptN1loc.LocToLoc( frDest, frCrv1) ; // recupero il riferimento della seconda curva Frame3d frCrv2 ; if ( ! pGeomDB->GetGlobFrame( nIdF, frCrv2)) return nullptr ; // recupero la seconda curva const ICurve* pCrv2 = GetCurve( pGeomDB->GetGeoObj( nIdF)) ; if ( pCrv2 == nullptr) return nullptr ; // porto la seconda curva nel riferimento della prima PtrOwner pCrv2Loc( pCrv2->Clone()) ; if ( IsNull( pCrv2Loc)) return nullptr ; pCrv2Loc->LocToLoc( frCrv2, frCrv1) ; // porto il punto vicino al finale nel riferimento della prima curva Point3d ptN2loc( ptFin) ; ptN2loc.LocToLoc( frDest, frCrv1) ; // calcolo la retta perpendicolare alle due curve PtrOwner pCrvLine ; pCrvLine.Set( GetLinePerpTwoCurves( *pCrv1, ptN1loc, *pCrv2, ptN2loc)) ; if ( IsNull( pCrvLine)) return nullptr ; // porto la linea nel riferimento del gruppo destinazione pCrvLine->LocToLoc( frCrv1, frDest) ; // restituisco la linea return Release( pCrvLine) ; } //------------------------------------------------------------------------------- ICurveLine* __stdcall CreateLineTgCurvePerpCurve( IGeomDB* pGeomDB, int nParentId, const Point3d& ptIni, int nIdI, const Point3d& ptFin, int nIdF) { // verifica preliminare Id curve if ( nIdI == GDB_ID_NULL || nIdF == GDB_ID_NULL) return nullptr ; // recupero il riferimento del gruppo destinazione Frame3d frDest ; if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frDest)) return nullptr ; // recupero il riferimento della prima curva Frame3d frCrv1 ; if ( ! pGeomDB->GetGlobFrame( nIdI, frCrv1)) return nullptr ; // recupero la prima curva const ICurve* pCrv1 = GetCurve( pGeomDB->GetGeoObj( nIdI)) ; if ( pCrv1 == nullptr) return nullptr ; // porto il punto vicino a iniziale nel riferimento della prima curva Point3d ptN1loc( ptIni) ; ptN1loc.LocToLoc( frDest, frCrv1) ; // recupero il riferimento della seconda curva Frame3d frCrv2 ; if ( ! pGeomDB->GetGlobFrame( nIdF, frCrv2)) return nullptr ; // recupero la seconda curva const ICurve* pCrv2 = GetCurve( pGeomDB->GetGeoObj( nIdF)) ; if ( pCrv2 == nullptr) return nullptr ; // porto la seconda curva nel riferimento della prima PtrOwner pCrv2Loc( pCrv2->Clone()) ; if ( IsNull( pCrv2Loc)) return nullptr ; pCrv2Loc->LocToLoc( frCrv2, frCrv1) ; // porto il punto vicino al finale nel riferimento della prima curva Point3d ptN2loc( ptFin) ; ptN2loc.LocToLoc( frDest, frCrv1) ; // calcolo la retta perpendicolare alle due curve PtrOwner pCrvLine ; pCrvLine.Set( GetLineTgCurvePerpCurve( *pCrv1, ptN1loc, *pCrv2, ptN2loc)) ; if ( IsNull( pCrvLine)) return nullptr ; // porto la linea nel riferimento del gruppo destinazione pCrvLine->LocToLoc( frCrv1, frDest) ; // restituisco la linea return Release( pCrvLine) ; } //------------------------------------------------------------------------------- int __stdcall EgtCreateCurveLinePVL( int nParentId, const double ptIni[3], const double vtDir[3], double dLen) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL) // creo la linea PtrOwner pCrvLine( CreateCurveLine()) ; if ( IsNull( pCrvLine)) return GDB_ID_NULL ; // setto la linea if ( ! pCrvLine->SetPVL( ptIni, vtDir, dLen)) 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 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 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 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 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 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 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 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 pCrvArc( CreateCurveArc()) ; if ( IsNull( pCrvArc)) return GDB_ID_NULL ; // setto l'arco if ( pCrvArc->Set3P( ptP1, ptP2, ptP3, false)) // inserisco l'arco nel DB return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ; // se risulta essere una retta if ( ( Point3d( ptP2) - Point3d( ptP1)) * ( Point3d( ptP3) - Point3d( ptP2)) > EPS_ZERO) return EgtCreateCurveLine( nParentId, ptP1, ptP3) ; // errore return GDB_ID_NULL ; } //------------------------------------------------------------------------------- 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 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 EgtCreateCurveArc2PVN( int nParentId, const double ptStart[3], const double ptEnd[3], const double vtDirS[3], const double vtNorm[3]) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL) // creo l'arco PtrOwner pCrvArc( CreateCurveArc()) ; if ( IsNull( pCrvArc)) return GDB_ID_NULL ; // setto l'arco if ( pCrvArc->Set2PVN( ptStart, ptEnd, vtDirS, vtNorm)) // inserisco l'arco nel DB return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pCrvArc)) ; // se risulta essere una retta if ( ( Point3d( ptEnd) - Point3d( ptStart)) * Vector3d( vtDirS) > EPS_ZERO) return EgtCreateCurveLine( nParentId, ptStart, ptEnd) ; // errore return GDB_ID_NULL ; } //------------------------------------------------------------------------------- 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 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 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 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 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 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 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 pCrvCompo( CreateCurveComposite()) ; if ( IsNull( pCrvCompo)) return GDB_ID_NULL ; // eventuali estrusione e spessore bool bExtr = false ; Vector3d vtExtr ; double dThick = 0 ; // 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 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) ; // recupero eventuali estrusione (già nel riferimento destinazione) e spessore if ( pCopCrv->GetExtrusion( vtExtr)) { bExtr = true ; double dTemp ; if ( pCopCrv->GetThickness( dTemp) && fabs( dTemp) > fabs( dThick)) dThick = dTemp ; } // la aggiungo alla curva composta if ( ! pCrvCompo->AddCurve( ::Release( pCopCrv), true, dToler)) return GDB_ID_NULL ; } // se non sono state inserite curve, vado oltre if ( pCrvCompo->GetCurveNumber() == 0) continue ; // se necessario, imposto estrusione e spessore if ( bExtr) { pCrvCompo->SetExtrusion( vtExtr) ; pCrvCompo->SetThickness( dThick) ; } // aggiorno il nuovo punto vicino pCrvCompo->GetEndPoint( ptNearStart) ; // inserisco la curva composita nel gruppo destinazione 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 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 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 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)) ; }