Egalware/EgtInterface
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e23999b6a33f78ab946ba51b5a677b1ff76984aa
EgtInterface/API_GdbModifyCurve.cpp
T
Dario Sassi e23999b6a3 EgtInterface 1.6a2 : 
- numerose modifiche e correzioni
- aggiunta registrazione comandi in formato lua
- aggiunto valutatore di espressioni.
2015-01-14 21:56:57 +00:00

694 lines
24 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : API_ModifyCurve.cpp Data : 03.10.14 Versione : 1.5i5
// Contenuto : Funzioni di modifica delle curve per API.
//
//
//
// Modifiche : 03.10.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/EGkCurveArc.h"
#include "/EgtDev/Include/EGkCurveBezier.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EGkDistPointCurve.h"
#include "/EgtDev/Include/EGkExtTExt.h"
#include "/EgtDev/Include/EGkGdbIterator.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
using namespace std ;
//----------------------------------------------------------------------------
BOOL
__stdcall EgtInvertCurve( int nId)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
bool bOk = true ;
// eseguo inversione singola
if ( nId != GDB_ID_SEL) {
// recupero la curva e la inverto
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCurve != nullptr && ! pCurve->Invert())
bOk = false ;
}
// eseguo inversione dei selezionati
else {
int nI = pGeomDB->GetFirstSelectedObj() ;
while ( nI != GDB_ID_NULL && bOk) {
// recupero la curva e la inverto
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nI)) ;
if ( pCurve != nullptr && ! pCurve->Invert())
bOk = false ;
// passo alla successiva
nI = pGeomDB->GetNextSelectedObj() ;
}
}
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtInvertCurve(" + ( nId != GDB_ID_SEL ? ToString( nId): "GDB_ID_SEL") + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return ( bOk ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtOffsetCurve( int nId, double dDist, int nType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
// eseguo l'offset
bool bOk = ( pCurve != nullptr) && pCurve->SimpleOffset( dDist, nType) ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua ;
if ( nType == ICurve::OFF_FILLET)
sLua = "EgtOffsetCurve(" + ToString( nId) + "," +
ToString( dDist) + ")" +
" -- Ok=" + ToString( bOk) ;
else
sLua = "EgtOffsetCurve(" + ToString( nId) + "," +
ToString( dDist) + "," +
( nType == ICurve::OFF_CHAMFER ? "'CHAMFER'" : "'EXTEND'") + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return ( bOk ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtModifyCurveStartPoint( int nId, const double ptP[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCurve == nullptr)
return FALSE ;
// ne modifico il punto iniziale
return ( pCurve->ModifyStart( ptP) ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtModifyCurveEndPoint( int nId, const double ptP[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCurve == nullptr)
return FALSE ;
// ne modifico il punto finale
return ( pCurve->ModifyEnd( ptP) ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
static bool
__stdcall ModifyOneCurveExtrusion( IGeomDB* pGeomDB, int nId, const Vector3d& vtExtr)
{
// se gruppo, agisco sulle sole curve componenti
if ( pGeomDB->GetGdbType( nId) == GDB_TY_GROUP) {
PtrOwner<IGdbIterator> pIter( CreateGdbIterator( pGeomDB)) ;
if ( IsNull( pIter))
return false ;
bool bOk = true ;
for ( bool bFound = pIter->GoToFirstInGroup( nId) ;
bFound ;
bFound = pIter->GoToNext()) {
// recupero la curva e ne modifico il vettore estrusione
ICurve* pCurve = GetCurve( pIter->GetGeoObj()) ;
if ( pCurve != nullptr && ! pCurve->SetExtrusion( vtExtr))
bOk = false ;
}
return bOk ;
}
// se oggetto geometrico
else {
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
// ne modifico il vettore estrusione
return ( pCurve == nullptr || pCurve->SetExtrusion( vtExtr)) ;
}
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtModifyCurveExtrusion( int nId, const double vtExtr[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
bool bOk = true ;
// eseguo impostazione estrusione singola
if ( nId != GDB_ID_SEL) {
bOk = ModifyOneCurveExtrusion( pGeomDB, nId, vtExtr) ;
}
// eseguo impostazione estrusione dei selezionati
else {
int nI = pGeomDB->GetFirstSelectedObj() ;
while ( nI != GDB_ID_NULL && bOk) {
if ( ! ModifyOneCurveExtrusion( pGeomDB, nI, vtExtr))
bOk = false ;
// passo alla successiva
nI = pGeomDB->GetNextSelectedObj() ;
}
}
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtModifyCurveExtrusion(" + ( nId != GDB_ID_SEL ? ToString( nId) : "GDB_ID_SEL") + ",{" +
ToString( Vector3d( vtExtr)) + "})" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return ( bOk ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
static bool
__stdcall SetOneCurveExtrusionFromGrid( IGeomDB* pGeomDB, int nId, const Vector3d& vtExtrGlob)
{
// se gruppo, agisco sulle sole curve componenti
if ( pGeomDB->GetGdbType( nId) == GDB_TY_GROUP) {
// recupero il riferimento definito dal gruppo
Frame3d frFrame ;
if ( ! pGeomDB->GetGroupGlobFrame( nId, frFrame))
return false ;
// esprimo il versore estrusione in questo riferimento
Vector3d vtExtr = vtExtrGlob ;
vtExtr.ToLoc( frFrame) ;
// ciclo sulle curve del gruppo
PtrOwner<IGdbIterator> pIter( CreateGdbIterator( pGeomDB)) ;
if ( IsNull( pIter))
return false ;
bool bOk = true ;
for ( bool bFound = pIter->GoToFirstInGroup( nId) ;
bFound ;
bFound = pIter->GoToNext()) {
// recupero la curva e ne modifico il vettore estrusione
ICurve* pCurve = GetCurve( pIter->GetGeoObj()) ;
if ( pCurve != nullptr && ! pCurve->SetExtrusion( vtExtr))
bOk = false ;
}
return bOk ;
}
// se oggetto geometrico
else {
// recupero il riferimento definito dal gruppo
Frame3d frFrame ;
if ( ! pGeomDB->GetGlobFrame( nId, frFrame))
return false ;
// esprimo il versore estrusione in questo riferimento
Vector3d vtExtr = vtExtrGlob ;
vtExtr.ToLoc( frFrame) ;
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
// ne modifico il vettore estrusione
return ( pCurve == nullptr || pCurve->SetExtrusion( vtExtr)) ;
}
}
//-------------------------------------------------------------------------------
BOOL
__stdcall EgtSetCurveExtrusionFromGrid( int nId)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
bool bOk = true ;
// recupero il versore Z della griglia corrente (in globale)
Vector3d vtExtrGlob = pGeomDB->GetGridFrame().VersZ() ;
// eseguo impostazione estrusione singola
if ( nId != GDB_ID_SEL) {
bOk = SetOneCurveExtrusionFromGrid( pGeomDB, nId, vtExtrGlob) ;
}
// eseguo impostazione estrusione dei selezionati
else {
int nI = pGeomDB->GetFirstSelectedObj() ;
while ( nI != GDB_ID_NULL && bOk) {
if ( ! SetOneCurveExtrusionFromGrid( pGeomDB, nI, vtExtrGlob))
bOk = false ;
// passo alla successiva
nI = pGeomDB->GetNextSelectedObj() ;
}
}
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSetCurveExtrusionFromGrid(" + ( nId != GDB_ID_SEL ? ToString( nId) : "GDB_ID_SEL") + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return ( bOk ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
static bool
__stdcall ModifyOneCurveThickness( IGeomDB* pGeomDB, int nId, double dThick)
{
// se gruppo, agisco sulle sole curve componenti
if ( pGeomDB->GetGdbType( nId) == GDB_TY_GROUP) {
PtrOwner<IGdbIterator> pIter( CreateGdbIterator( pGeomDB)) ;
if ( IsNull( pIter))
return false ;
bool bOk = true ;
for ( bool bFound = pIter->GoToFirstInGroup( nId) ;
bFound ;
bFound = pIter->GoToNext()) {
// recupero la curva e ne modifico lo spessore
ICurve* pCurve = GetCurve( pIter->GetGeoObj()) ;
if ( pCurve != nullptr && ! pCurve->SetThickness( dThick))
bOk = false ;
}
return bOk ;
}
// se oggetto geometrico
else {
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
// ne modifico lo spessore, se curva
return ( pCurve == nullptr || pCurve->SetThickness( dThick)) ;
}
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtModifyCurveThickness( int nId, double dThick)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
bool bOk = true ;
// eseguo impostazione spessore singola
if ( nId != GDB_ID_SEL) {
bOk = ModifyOneCurveThickness( pGeomDB, nId, dThick) ;
}
// eseguo impostazione spessore dei selezionati
else {
int nI = pGeomDB->GetFirstSelectedObj() ;
while ( nI != GDB_ID_NULL && bOk) {
if ( ! ModifyOneCurveThickness( pGeomDB, nI, dThick))
bOk = false ;
// passo alla successiva
nI = pGeomDB->GetNextSelectedObj() ;
}
}
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtModifyCurveThickness(" + ( nId != GDB_ID_SEL ? ToString( nId) : "GDB_ID_SEL") + "," +
ToString( dThick) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return ( bOk ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtTrimCurveStartAtLen( int nId, double dLen)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCurve == nullptr)
return FALSE ;
// taglio la curva all'inizio
return ( pCurve->TrimStartAtLen( dLen) ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtTrimCurveEndAtLen( int nId, double dLen)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCurve == nullptr)
return FALSE ;
// taglio la curva alla fine
return ( pCurve->TrimEndAtLen( dLen) ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtTrimCurveStartAtParam( int nId, double dPar)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCurve == nullptr)
return FALSE ;
// taglio la curva all'inizio
return ( pCurve->TrimStartAtParam( dPar) ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtTrimCurveEndAtParam( int nId, double dPar)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCurve == nullptr)
return FALSE ;
// taglio la curva alla fine
return ( pCurve->TrimEndAtParam( dPar) ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtTrimCurveStartEndAtParam( int nId, double dParS, double dParE)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCurve == nullptr)
return FALSE ;
// taglio la curva agli estremi
return ( pCurve->TrimStartEndAtParam( dParS, dParE) ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtExtendCurveStartByLen( int nId, double dLen)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCurve == nullptr)
return FALSE ;
// estendo la curva all'inizio
return ( pCurve->ExtendStartByLen( dLen) ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtExtendCurveEndByLen( int nId, double dLen)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
if ( pCurve == nullptr)
return FALSE ;
// estendo la curva alla fine
return ( pCurve->ExtendEndByLen( dLen) ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtTrimExtendCurveByLen( int nId, double dLen, const double ptNear[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
bool bOk = ( pCurve != nullptr) ;
// cerco l'estremo più vicino al punto passato
Point3d ptStart, ptEnd ;
if ( bOk && pCurve->GetStartPoint( ptStart) && pCurve->GetEndPoint( ptEnd)) {
if ( SqDist( ptStart, ptNear) < SqDist( ptEnd, ptNear)) {
if ( dLen < - EPS_SMALL)
bOk = pCurve->TrimStartAtLen( - dLen) ;
else if ( dLen > EPS_SMALL)
bOk = pCurve->ExtendStartByLen( dLen) ;
}
else {
if ( dLen < - EPS_SMALL) {
double dCrvLen ;
bOk = pCurve->GetLength( dCrvLen) && pCurve->TrimEndAtLen( dCrvLen + dLen) ;
}
else if ( dLen > EPS_SMALL)
bOk = pCurve->ExtendEndByLen( dLen) ;
}
}
else
bOk = false ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtTrimExtendCurveByLen(" + ToString( nId) + "," +
ToString( dLen) + ",{" +
ToString( Point3d( ptNear)) + "})" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return ( bOk ? TRUE : FALSE) ;
}
//----------------------------------------------------------------------------
BOOL
__stdcall EgtSplitCurveAtPoint( int nId, double ptOn[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
// recupero la curva
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
bool bOk = ( pCurve != nullptr) ;
// determino la posizione parametrica del punto sulla curva (con tolleranza)
double dU = 0 ;
if ( bOk) {
DistPointCurve dstPC( ptOn, *pCurve) ;
int nFlag ;
if ( ! dstPC.GetParamAtMinDistPoint( 0, dU, nFlag) || nFlag != MDPCI_NORMAL)
bOk = false ;
}
// verifico che il punto di taglio sia interno alla curva
bool bIsInside = false ;
if ( bOk) {
Point3d ptStart ;
Point3d ptEnd ;
Point3d ptBreak ;
if ( pCurve->GetStartPoint( ptStart) &&
pCurve->GetEndPoint( ptEnd) &&
pCurve->GetPointD1D2( dU, ICurve::FROM_MINUS, ptBreak)) {
bIsInside = ! AreSamePointApprox( ptBreak, ptStart) &&
! AreSamePointApprox( ptBreak, ptEnd) ;
}
}
// se il punto di taglio è interno, devo realmente tagliare
if ( bIsInside) {
// copio la curva
int nCopyId = GDB_ID_NULL ;
if ( bOk && ( nCopyId = pGeomDB->Copy( nId, GDB_ID_NULL, nId, GDB_AFTER)) == GDB_ID_NULL)
bOk = false ;
// tengo la prima parte dell'originale e la seconda parte della copia
bOk = bOk && pCurve->TrimEndAtParam( dU) ;
bOk = bOk && ( EgtTrimCurveStartAtParam( nCopyId, dU) != FALSE) ;
}
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtSplitCurveAtPoint(" + ToString( nId) + ",{" +
ToString( Point3d( ptOn)) + "})" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return ( bOk ? TRUE : FALSE) ;
}
//-------------------------------------------------------------------------------
BOOL
__stdcall EgtModifyCurveCircleCPN( int nId, const double ptOn[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
// recupero l'arco e i suoi dati
ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ;
if ( pArc == nullptr)
return FALSE ;
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->Set( ptCen, vtN, dOldRad) ;
return FALSE ;
}
}
//-------------------------------------------------------------------------------
BOOL
__stdcall EgtModifyCurveArcRadius( int nId, double dRad)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
// recupero l'arco e i suoi dati
ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ;
if ( pArc == nullptr)
return FALSE ;
double dOldRad = pArc->GetRadius() ;
// imposto il nuovo raggio
if ( pArc->ChangeRadius( dRad))
return TRUE ;
// in caso di errore, ripristino i vecchi dati
else {
pArc->ChangeRadius( dOldRad) ;
return FALSE ;
}
}
//-------------------------------------------------------------------------------
BOOL
__stdcall EgtModifyCurveArcC2PN( int nId, const double ptEnd[3])
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
// recupero l'arco e i suoi dati
ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ;
if ( pArc == nullptr)
return FALSE ;
Point3d ptCen = pArc->GetCenter() ;
Vector3d vtN = pArc->GetNormVersor() ;
Point3d ptStart, ptOldEnd ;
if ( ! pArc->GetStartPoint( ptStart) || ! pArc->GetEndPoint( ptOldEnd))
return FALSE ;
// imposto il nuovo punto finale
if ( pArc->SetC2PN( ptCen, ptStart, ptEnd, vtN))
return TRUE ;
// in caso di errore, ripristino i vecchi dati
else {
pArc->SetC2PN( ptCen, ptStart, ptOldEnd, vtN) ;
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 EgtExplodeCurveCompo( int nId)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
bool bOk = true ;
// recupero la curva composita
ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
if ( pCompo == nullptr)
bOk = false ;
// estraggo tutte le curve
ICurve* pCrv ;
while ( bOk && ( pCrv = pCompo->RemoveFirstOrLastCurve( false)) != nullptr) {
// inserisco la curva nello stesso gruppo e nello stesso posto del GeomDB
int nCrvId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pCrv) ;
if ( nCrvId == GDB_ID_NULL)
bOk = false ;
// copio gli attributi
if ( ! pGeomDB->CopyAttributes( nId, nCrvId))
bOk = false ;
}
// elimino la curva composita ormai vuota
bOk = bOk && pGeomDB->Erase( nId) ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtExplodeCurveCompo(" + ToString( nId) + ")" +
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return ( bOk ? TRUE : FALSE) ;
}
//-------------------------------------------------------------------------------
BOOL
__stdcall EgtExplodeCurveBezier( int nId, double dLinTol, BOOL bArcsVsLines)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
VERIFY_GEOMDB( pGeomDB, FALSE)
bool bOk = true ;
// recupero la curva di Bezier
ICurveBezier* pCBezier = GetCurveBezier( pGeomDB->GetGeoObj( nId)) ;
if ( pCBezier == nullptr)
bOk = false ;
// eseguo l'approssimazione
const double ANG_TOL_STD_DEG = 15 ;
PtrOwner<ICurveComposite> pCC( CreateCurveComposite()) ;
if ( ! IsNull( pCC)) {
if ( bArcsVsLines) { // con bi-archi
PolyArc PA ;
if ( ! pCBezier->ApproxWithArcs( dLinTol, ANG_TOL_STD_DEG, PA) ||
! pCC->FromPolyArc( PA))
bOk = false ;
}
else { // con linee
PolyLine PL ;
if ( ! pCBezier->ApproxWithLines( dLinTol, ANG_TOL_STD_DEG, PL) ||
! pCC->FromPolyLine( PL))
bOk = false ;
}
}
else
bOk = false ;
// inserisco le curve elementari nel DB
ICurve* pCrv ;
while ( bOk && ( pCrv = pCC->RemoveFirstOrLastCurve( false)) != nullptr) {
// inserisco la curva nello stesso gruppo e nello stesso posto del GeomDB
int nCrvId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, pCrv) ;
if ( nCrvId == GDB_ID_NULL)
bOk = false ;
// copio gli attributi
if ( ! pGeomDB->CopyAttributes( nId, nCrvId))
bOk = false ;
}
// elimino la curva di Bezier
bOk = bOk && pGeomDB->Erase( nId) ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtExplodeCurveBezier(" + ToString( nId) + "," +
ToString( dLinTol) + "," +
( bArcsVsLines ? "true" : "false") + ")"
" -- Ok=" + ToString( bOk) ;
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
}
// restituisco risultato
return ( bOk ? TRUE : FALSE) ;
}
Reference in New Issue View Git Blame Copy Permalink