From b50b676249d1c501b511dd759a847abc3fbf2384 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Thu, 23 Jan 2014 14:51:47 +0000 Subject: [PATCH] EgtGeomKernel 1.5a8 : sistemata scalatura non uniforme di archi (sono trasformati in curve di Bezier singole o composite). Aggiunte costanti geometriche locali. --- CurveArc.cpp | 12 ++- CurveAux.cpp | 43 ++++++++++- CurveAux.h | 4 + CurveBezier.cpp | 56 +++++++++++--- CurveComposite.cpp | 118 +++++++++++++++++++++++++--- CurveComposite.h | 2 + DistPointArc.cpp | 1 + DistPointCrvAux.cpp | 1 + DistPointCrvBezier.cpp | 1 + EgtGeomKernel.rc | Bin 11710 -> 11710 bytes GdbExecutor.cpp | 169 ++++++++++++++++++++++++++++------------- GdbObj.cpp | 80 +++++++++---------- GeoConst.h | 32 ++++++++ 13 files changed, 403 insertions(+), 116 deletions(-) create mode 100644 GeoConst.h diff --git a/CurveArc.cpp b/CurveArc.cpp index 19f3592..d3f4b8a 100644 --- a/CurveArc.cpp +++ b/CurveArc.cpp @@ -14,6 +14,7 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "CurveArc.h" +#include "GeoConst.h" #include "GeoObjFactory.h" #include "\EgtDev\Include\EGnStringUtils.h" #include @@ -259,10 +260,19 @@ CurveArc::GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const bool CurveArc::Validate( void) { - if ( m_nStatus == TO_VERIFY) + if ( m_nStatus == TO_VERIFY) { + // limito l'angolo al centro a un giro se è piatto ( non è elica) + if ( fabs( m_dDeltaN) < EPS_SMALL) { + if ( m_dAngCenDeg > 360.0) + m_dAngCenDeg = 360.0 ; + else if ( m_dAngCenDeg < - 360.0) + m_dAngCenDeg = - 360.0 ; + } + // eseguo il controllo m_nStatus = ( ( m_VtN.IsNormalized() && m_VtS.IsNormalized() && AreOrthoNear( m_VtN, m_VtS) && m_dRad > EPS_ZERO && fabs( m_dAngCenDeg) > EPS_ANG_ZERO) ? OK : ERR) ; + } return ( m_nStatus == OK) ; } diff --git a/CurveAux.cpp b/CurveAux.cpp index 648f6f9..bd777ae 100644 --- a/CurveAux.cpp +++ b/CurveAux.cpp @@ -14,7 +14,11 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "CurveAux.h" - +#include "GeoConst.h" +#include "/EgtDev/Include/EgkCurveComposite.h" +#include "/EgtDev/Include/EgkCurveBezier.h" +#include "/EgtDev/Include/EgkCurveArc.h" +#include "/EgtDev/Include/EgtPointerOwner.h" //---------------------------------------------------------------------------- bool @@ -89,3 +93,40 @@ GetPointDiffGeom( const ICurve& crvC, double dU, ICurve::Side nS, CrvPointDiffGe return true ; } + +//---------------------------------------------------------------------------- +bool +ArcToBezierCurve( const ICurve* pCrv, ICurve*& pCrvNew) +{ + // verifico sia un arco + const ICurveArc* pArc = GetCurveArc( pCrv) ; + if ( pArc == nullptr) + return false ; + + // se angolo al centro sotto il limite, basta una curva + if ( fabs( pArc->GetAngCenter()) <= BEZARC_ANG_CEN_MAX) { + // creo la curva di Bezier + PtrOwner pCrvBez( CreateCurveBezier()) ; + if ( ! IsValid( pCrvBez)) + return false ; + if ( ! pCrvBez->FromArc( *pArc)) + return false ; + // restituisco la curva + pCrvNew = Release( pCrvBez) ; + } + + // altrimenti curva composita di Bezier + else { + // creo la curva composita + PtrOwner pCrvCompo( CreateCurveComposite()) ; + if ( ! IsValid( pCrvCompo)) + return false ; + if ( ! pCrvCompo->AddCurve( *pArc) || + ! pCrvCompo->ArcsToBezierCurves()) + return false ; + // restituisco la curva + pCrvNew = Release( pCrvCompo) ; + } + + return true ; +} \ No newline at end of file diff --git a/CurveAux.h b/CurveAux.h index 99caa7e..09db63d 100644 --- a/CurveAux.h +++ b/CurveAux.h @@ -19,3 +19,7 @@ bool IsClosed( const ICurve& crvC) ; bool GetPointTang( const ICurve& crvC, double dU, ICurve::Side nS, Point3d& ptPos, Vector3d& vtTang) ; bool GetPointDiffGeom( const ICurve& crvC, double dU, ICurve::Side nS, CrvPointDiffGeom& oDiffG) ; + +//---------------------------------------------------------------------------- +// trasforma un arco in una curva di Bezier semplice o composta +bool ArcToBezierCurve( const ICurve* pArc, ICurve*& pCrvNew) ; diff --git a/CurveBezier.cpp b/CurveBezier.cpp index b0feda6..22779e7 100644 --- a/CurveBezier.cpp +++ b/CurveBezier.cpp @@ -15,6 +15,7 @@ #include "stdafx.h" #include "DllMain.h" #include "CurveBezier.h" +#include "GeoConst.h" #include "DistPointLine.h" #include "GeoObjFactory.h" #include "PolynomialPoint3d.h" @@ -156,10 +157,15 @@ CurveBezier::FromArc( const ICurveArc& crArc) const double MAX_ANG_CEN_DEG = 120 ; double dAngCen ; double dCosAhalf ; + double dW ; Point3d ptStart ; Point3d ptEnd ; + Point3d ptEndNoDN ; Point3d ptMed ; Point3d ptNew ; + Point3d ptNew1 ; + Point3d ptNew2 ; + Vector3d vtDeltaN ; Vector3d vtDir ; @@ -169,16 +175,48 @@ CurveBezier::FromArc( const ICurveArc& crArc) if ( fabs( dAngCen) > MAX_ANG_CEN_DEG) return false ; dCosAhalf = cos( 0.5 * dAngCen * DEGTORAD) ; - crArc.GetStartPoint( ptStart) ; - crArc.GetEndPoint( ptEnd) ; - ptMed = Media( ptStart, ptEnd, 0.5) ; - vtDir = ptMed - crArc.GetCenter() ; - ptNew = crArc.GetCenter() + vtDir / ( dCosAhalf * dCosAhalf) ; - Init( 2, true) ; - SetControlPoint( 0, ptStart, 1) ; - SetControlPoint( 1, ptNew, dCosAhalf) ; - SetControlPoint( 2, ptEnd, 1) ; + // se arco piatto, basta quadrica razionale + // algoritmo di Sederberg (BYU) CAGD cap. 2 pag. 33 + if ( fabs( crArc.GetDeltaN()) < EPS_ZERO) { + // peso del punto di controllo intermedio + dW = dCosAhalf ; + // calcolo dei punti di controllo + crArc.GetStartPoint( ptStart) ; + crArc.GetEndPoint( ptEnd) ; + ptMed = Media( ptStart, ptEnd, 0.5) ; + vtDir = ptMed - crArc.GetCenter() ; + ptNew = crArc.GetCenter() + vtDir / ( dCosAhalf * dCosAhalf) ; + // inserimento nella curva dei punti di controllo con i pesi + Init( 2, true) ; + SetControlPoint( 0, ptStart, 1) ; + SetControlPoint( 1, ptNew, dW) ; + SetControlPoint( 2, ptEnd, 1) ; + } + // altrimenti per elica serve cubica razionale + // algoritmo di Juhasz HelixApproxByCubicBezier CAD 1995 + else { + // peso dei punti di controllo intermedi + dW = ( 1 + 2 * dCosAhalf) / 3 ; + // calcolo dei punti di controllo + crArc.GetStartPoint( ptStart) ; + crArc.GetEndPoint( ptEnd) ; + vtDeltaN = crArc.GetDeltaN() * crArc.GetNormVersor() ; + ptEndNoDN = ptEnd - vtDeltaN ; + ptMed = Media( ptStart, ptEndNoDN, 0.5) ; + vtDir = ptMed - crArc.GetCenter() ; + ptNew = crArc.GetCenter() + vtDir / ( dCosAhalf * dCosAhalf) ; + ptNew1 = ( ptStart + 2 * dCosAhalf * ptNew) / ( 1 + 2 * dCosAhalf) + + 0.5 * ( 1 - dCosAhalf / ( 2 + dCosAhalf)) * vtDeltaN ; + ptNew2 = ( ptEndNoDN + 2 * dCosAhalf * ptNew) / ( 1 + 2 * dCosAhalf) + + 0.5 * ( 1 + ( dCosAhalf / ( 2 + dCosAhalf))) * vtDeltaN ; + // inserimento nella curva dei punti di controllo con i pesi + Init( 3, true) ; + SetControlPoint( 0, ptStart, 1) ; + SetControlPoint( 1, ptNew1, dW) ; + SetControlPoint( 2, ptNew2, dW) ; + SetControlPoint( 3, ptEnd, 1) ; + } return true ; } diff --git a/CurveComposite.cpp b/CurveComposite.cpp index 726977d..182c555 100644 --- a/CurveComposite.cpp +++ b/CurveComposite.cpp @@ -14,8 +14,12 @@ //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "CurveComposite.h" +#include "GeoConst.h" #include "GeoObjFactory.h" -#include "\EgtDev\Include\EGnStringUtils.h" +#include "/EgtDev/Include/EGnStringUtils.h" +#include "/EgtDev/Include/EgtPointerOwner.h" +#include "/EgtDev/Include/EGkCurveArc.h" +#include "/EgtDev/Include/EGkCurveBezier.h" #include using namespace std ; @@ -48,6 +52,7 @@ CurveComposite::Clear( void) m_CrvSmplS.clear() ; + m_nStatus = TO_VERIFY ; m_nCounter = 0 ; m_bClosed = false ; @@ -142,6 +147,46 @@ CurveComposite::AddSimpleCurve( ICurve* pSmplCrv) return true ; } +//---------------------------------------------------------------------------- +bool +CurveComposite::FromSplit( const ICurve& cCrv, int nParts) +{ + // verifico lo stato + if ( m_nCounter != 0 || m_nStatus != TO_VERIFY) + return false ; + + // deve essere valida e semplice + if ( ! cCrv.IsValid() || ! cCrv.IsSimple()) + return false ; + + // se 1 parte o meno, non fa alcunchè + if ( nParts <= 1) + return true ; + + // calcolo la lunghezza della curva + double dTotLen ; + if ( ! cCrv.GetLength( dTotLen)) + return false ; + + // ciclo di inserimento delle parti + double dStartLen = 0 ; + double dEndLen = 0 ; + for ( int i = 1 ; i <= nParts ; ++ i) { + dStartLen = dEndLen ; + dEndLen = dTotLen * i / (double) nParts ; + PtrOwner pSmplCrv( GetCurve( cCrv.Clone())) ; + if ( ! ::IsValid( pSmplCrv)) + return false ; + if ( ! pSmplCrv->TrimEndAtLen( dEndLen) || + ! pSmplCrv->TrimStartAtLen( dStartLen)) + return false ; + if ( ! AddSimpleCurve( Release( pSmplCrv))) + return false ; + } + + return true ; +} + //---------------------------------------------------------------------------- CurveComposite* CurveComposite::Clone( void) const @@ -764,21 +809,26 @@ CurveComposite::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, dou PCRVSMPL_LIST::iterator Iter ; - // ammessa solo scalatura uniforme (per la presenza di archi) - if ( fabs( dCoeffX - dCoeffY) > EPS_SMALL || fabs( dCoeffX - dCoeffZ) > EPS_SMALL) + // verifico non sia nulla + if ( fabs( dCoeffX) < EPS_ZERO && fabs( dCoeffY) < EPS_ZERO && fabs( dCoeffZ) < EPS_ZERO) return false ; - // verifico non sia nulla - if ( fabs( dCoeffX) < EPS_ZERO) - return false ; + // se scalatura non omogenea, devo trasformare tutti gli archi in curve di Bezier + if ( fabs( dCoeffX - dCoeffY) > EPS_SMALL || fabs( dCoeffX - dCoeffZ) > EPS_SMALL) { + if ( ! ArcsToBezierCurves()) + return false ; + } // scalo le singole curve - for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter) - (*Iter)->Scale( frRef, dCoeffX, dCoeffX, dCoeffX) ; + for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter) { + // eseguo la scalatura + if ( ! (*Iter)->Scale( frRef, dCoeffX, dCoeffY, dCoeffZ)) + return false ; + } // scalo i punti estremi - m_PtStart.Scale( frRef, dCoeffX, dCoeffX, dCoeffX) ; - m_PtEnd.Scale( frRef, dCoeffX, dCoeffX, dCoeffX) ; + m_PtStart.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ; + m_PtEnd.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ; return Validate() ; } @@ -897,3 +947,51 @@ CurveComposite::IsParamAtJoint( double dU) const else return true ; } + +//---------------------------------------------------------------------------- +bool +CurveComposite::ArcsToBezierCurves( void) +{ + // verifico le singole curve + PCRVSMPL_LIST::iterator Iter ; + for ( Iter = m_CrvSmplS.begin() ; Iter != m_CrvSmplS.end() ; ++Iter) { + // se arco, devo trasformare in una o più curve di Bezier + if ( (*Iter)->GetType() == CRV_ARC) { + const ICurveArc* pArc = GetCurveArc( (*Iter)) ; + // se angolo al centro sotto il limite, basta una curva + if ( fabs( pArc->GetAngCenter()) <= BEZARC_ANG_CEN_MAX + EPS_ANG_SMALL) { + // creo la curva di Bezier + PtrOwner pCrvBez( CreateCurveBezier()) ; + if ( ! ::IsValid( pCrvBez)) + return false ; + if ( ! pCrvBez->FromArc( *pArc)) + return false ; + // elimino l'arco e lo sostituisco con la curva di Bezier + delete (*Iter) ; + (*Iter) = Release( pCrvBez) ; + } + // altrimenti ne servono diverse + else { + // divido in parti + CurveComposite cCompo ; + int nParts = (int) ceil( fabs( pArc->GetAngCenter()) / BEZARC_ANG_CEN_MAX) ; + if ( ! cCompo.FromSplit( *pArc, nParts)) + return false ; + // trasformo le parti in curve di Bezier + if ( ! cCompo.ArcsToBezierCurves() || cCompo.GetCurveNumber() != nParts) + return false ; + // inserisco le curve prima dell'arco + m_CrvSmplS.splice( Iter, cCompo.m_CrvSmplS) ; + // elimino l'arco (e sposto l'iteratore alla curva precedente) + delete (*Iter) ; + PCRVSMPL_LIST::iterator ToErase = Iter ; + -- Iter ; + m_CrvSmplS.erase( ToErase) ; + // aggiorno il numero di curve + m_nCounter += nParts - 1 ; + } + } + } + + return true ; +} diff --git a/CurveComposite.h b/CurveComposite.h index 18e67fb..b39e978 100644 --- a/CurveComposite.h +++ b/CurveComposite.h @@ -67,10 +67,12 @@ class CurveComposite : public ICurveComposite public : // ICurveComposite virtual bool Clear( void) ; virtual bool AddCurve( const ICurve& cCrv) ; + virtual bool FromSplit( const ICurve& cCrv, int nParts) ; virtual int GetCurveNumber( void) const { return m_nCounter ; } virtual const ICurve* GetFirstCurve( void) const ; virtual const ICurve* GetNextCurve( void) const ; virtual bool IsParamAtJoint( double dU) const ; + virtual bool ArcsToBezierCurves( void) ; public : CurveComposite( void) ; diff --git a/DistPointArc.cpp b/DistPointArc.cpp index d645cd5..d1bc149 100644 --- a/DistPointArc.cpp +++ b/DistPointArc.cpp @@ -15,6 +15,7 @@ #include "stdafx.h" #include "DistPointArc.h" #include "DistPointCrvAux.h" +#include "GeoConst.h" //---------------------------------------------------------------------------- diff --git a/DistPointCrvAux.cpp b/DistPointCrvAux.cpp index 3705082..94edc24 100644 --- a/DistPointCrvAux.cpp +++ b/DistPointCrvAux.cpp @@ -16,6 +16,7 @@ #include "DllMain.h" #include "DistPointCrvAux.h" #include "DistPointLine.h" +#include "GeoConst.h" //---------------------------------------------------------------------------- diff --git a/DistPointCrvBezier.cpp b/DistPointCrvBezier.cpp index 3d3385f..9970e14 100644 --- a/DistPointCrvBezier.cpp +++ b/DistPointCrvBezier.cpp @@ -15,6 +15,7 @@ #include "stdafx.h" #include "DistPointCrvBezier.h" #include "DistPointCrvAux.h" +#include "GeoConst.h" //---------------------------------------------------------------------------- diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc index d8531403940e6f6fd3e2de0e68ed52b120024122..bfa4247586eb731e659a3b5462c384993a145adf 100644 GIT binary patch delta 81 zcmdlNy)SyhH#SC#&FAG5nSsGetGeoObj( nIdArc)) ; - if ( pCrvArc == nullptr) - return false ; - // ne deduco la curva di Bezier - if ( ! pCrvBez->FromArc( *pCrvArc)) - return false ; - // recupero il riferimento dell'arco - Frame3d frSou ; - if ( ! m_pGDB->GetGlobFrame( nIdArc, frSou)) - return false ; - // recupero il riferimento del gruppo destinazione - Frame3d frDest ; - if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest)) - return false ; - // porto la curva di Bezier dal riferimento dell'arco a quello di inserimento - if ( ! AreSameFrame( frSou, frDest)) { - pCrvBez->ToGlob( frSou) ; - pCrvBez->ToLoc( frDest) ; - } + // curva di Bezier ricavata da un arco + else if ( sCmd2 == "FROMARC" || sCmd2 == "A") { + // 3 o 4 parametri + switch ( vsParams.size()) { + case 3 : bErase = false ; break ; + case 4 : bErase = ( vsParams[3] != "0") ; break ; + default : return false ; break ; } - else + // recupero l'arco + nIdArc = GetIdParam( vsParams[2]) ; + const ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( nIdArc)) ; + if ( pCrvArc == nullptr) return false ; + // ne deduco la curva di Bezier + if ( ! pCrvBez->FromArc( *pCrvArc)) + return false ; + // recupero il riferimento dell'arco + Frame3d frSou ; + if ( ! m_pGDB->GetGlobFrame( nIdArc, frSou)) + return false ; + // recupero il riferimento del gruppo destinazione + Frame3d frDest ; + if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest)) + return false ; + // porto la curva di Bezier dal riferimento dell'arco a quello di inserimento + if ( ! AreSameFrame( frSou, frDest)) { + pCrvBez->ToGlob( frSou) ; + pCrvBez->ToLoc( frDest) ; + } } // altrimenti errore else @@ -553,15 +551,17 @@ GdbExecutor::ExecuteCurveBez( const string& sCmd2, const STRVECTOR& vsParams) bool GdbExecutor::ExecuteCurveCompo( const string& sCmd2, const STRVECTOR& vsParams) { + // creo la curva composita + PtrOwner pCrvCompo( CreateCurveComposite()) ; + if ( ! IsValid( pCrvCompo)) + return false ; + // per eventuale cancellazione curve di origine + bool bErase ; + STRVECTOR vsNames ; + STRVECTOR::iterator Iter ; + // curva composita generica if ( sCmd2 == "MAKE" || sCmd2 == "") { - bool bErase ; - STRVECTOR vsNames ; - STRVECTOR::iterator Iter ; - const ICurve* pCrv ; - PtrOwner pCrvCompo( CreateCurveComposite()) ; - if ( ! IsValid( pCrvCompo)) - return false ; // 3 o 4 parametri switch ( vsParams.size()) { case 3 : bErase = false ; break ; @@ -571,32 +571,95 @@ GdbExecutor::ExecuteCurveCompo( const string& sCmd2, const STRVECTOR& vsParams) // recupero lista nomi if ( ! GetNamesParam( vsParams[2], vsNames)) return false ; + // recupero il riferimento del gruppo destinazione + Frame3d frDest ; + if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest)) + return false ; // esecuzione for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { // recupero la curva - pCrv = GetCurve( m_pGDB->GetGeoObj( GetIdParam( *Iter))) ; + int nIdCrv = GetIdParam( *Iter) ; + const ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ; if ( pCrv == nullptr) return false ; - // aggiungo questa curva - if ( ! pCrvCompo->AddCurve( *pCrv)) + // recupero il riferimento della curva + Frame3d frSou ; + if ( ! m_pGDB->GetGlobFrame( nIdCrv, frSou)) return false ; - } - // inserisco la curva composita nel DB - if ( AddGeoObj( vsParams[0], vsParams[1], Release( pCrvCompo))) { - // se richiesto, cancello le curve originali - if ( bErase) { - for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { - if ( ! m_pGDB->Erase( GetIdParam(*Iter))) - 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 (da buttare alla fine) + PtrOwner pModCrv( GetCurve( pCrv->Clone())) ; + if ( ! IsValid( pModCrv)) + return false ; + // eseguo la trasformazione + pModCrv->ToGlob( frSou) ; + pModCrv->ToLoc( frDest) ; + // aggiungo la curva modificata + if ( ! pCrvCompo->AddCurve( *pModCrv)) + return false ; } - return true ; } - else - return false ; } + // da split di curva semplice + else if ( sCmd2 == "FROMSPLIT" || sCmd2 == "S") { + // 4 o 5 parametri + switch ( vsParams.size()) { + case 4 : bErase = false ; break ; + case 5 : bErase = ( vsParams[4] != "0") ; break ; + default : return false ; break ; + } + // salvo nome curva originale per eventuale cancellazione + vsNames.push_back( vsParams[2]) ; + // recupero la curva + int nIdCrv = GetIdParam( vsParams[2]) ; + const ICurve* pCrv = GetCurve( m_pGDB->GetGeoObj( nIdCrv)) ; + if ( pCrv == nullptr) + return false ; + // recupero il numero delle parti in cui spezzare + int nParts ; + if ( ! FromString( vsParams[3], nParts)) + return false ; + // ne deduco la curva composita + if ( ! pCrvCompo->FromSplit( *pCrv, nParts)) + return false ; + // recupero il riferimento della curva + Frame3d frSou ; + if ( ! m_pGDB->GetGlobFrame( nIdCrv, frSou)) + return false ; + // recupero il riferimento del gruppo destinazione + Frame3d frDest ; + if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frDest)) + return false ; + // porto la curva composita dal riferimento della sorgente a quello di inserimento + if ( ! AreSameFrame( frSou, frDest)) { + pCrvCompo->ToGlob( frSou) ; + pCrvCompo->ToLoc( frDest) ; + } + } + // altrimenti errore + else + return false ; - return false ; + // inserisco la curva composita nel DB + if ( AddGeoObj( vsParams[0], vsParams[1], Release( pCrvCompo))) { + // se richiesto, cancello le curve originali + if ( bErase) { + for ( Iter = vsNames.begin() ; Iter != vsNames.end() ; ++Iter) { + if ( ! m_pGDB->Erase( GetIdParam(*Iter))) + return false ; + } + } + return true ; + } + else + return false ; } //---------------------------------------------------------------------------- diff --git a/GdbObj.cpp b/GdbObj.cpp index fcd34a7..62081a5 100644 --- a/GdbObj.cpp +++ b/GdbObj.cpp @@ -15,10 +15,8 @@ #include "stdafx.h" #include "GdbObj.h" #include "GeoObjFactory.h" +#include "CurveAux.h" #include "/EgtDev/Include/EGnStringUtils.h" -#include "/EgtDev/Include/EgtPointerOwner.h" -#include "/EgtDev/Include/EgkCurveBezier.h" -#include "/EgtDev/Include/EgkCurveArc.h" #include using namespace std ; @@ -124,93 +122,91 @@ GdbObj::Load( const std::string& sType, Scanner& TheScanner, int& nParentId) bool GdbObj::GetLocalBBox( BBox3d& b3Loc) const { - if ( m_pGeoObj != nullptr) - return m_pGeoObj->GetLocalBBox( b3Loc) ; - else + if ( m_pGeoObj == nullptr) return false ; + + return m_pGeoObj->GetLocalBBox( b3Loc) ; } //---------------------------------------------------------------------------- bool GdbObj::GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const { - if ( m_pGeoObj != nullptr) - return m_pGeoObj->GetBBox( frRef, b3Ref) ; - else + if ( m_pGeoObj == nullptr) return false ; + + return m_pGeoObj->GetBBox( frRef, b3Ref) ; } //---------------------------------------------------------------------------- bool GdbObj::Translate( const Vector3d& vtMove) { - if ( m_pGeoObj != nullptr) - return m_pGeoObj->Translate( vtMove) ; - else + if ( m_pGeoObj == nullptr) return false ; + + return m_pGeoObj->Translate( vtMove) ; } //---------------------------------------------------------------------------- bool GdbObj::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng) { - if ( m_pGeoObj != nullptr) - return m_pGeoObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ; - else + if ( m_pGeoObj == nullptr) return false ; + + return m_pGeoObj->Rotate( ptAx, vtAx, dCosAng, dSinAng) ; } //---------------------------------------------------------------------------- bool GdbObj::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ) { - if ( m_pGeoObj != nullptr) { - // se scalatura non omogenea e arco, devo trasformare in curva di Bezier - if ( m_pGeoObj->GetType() == CRV_ARC && - (fabs( dCoeffX - dCoeffY) > EPS_SMALL || fabs( dCoeffX - dCoeffZ) > EPS_SMALL)) { - // creo la curva di Bezier - PtrOwner pCrvBez( CreateCurveBezier()) ; - if ( ! IsValid( pCrvBez)) - return false ; - if ( ! pCrvBez->FromArc( *GetCurveArc( m_pGeoObj))) - return false ; - // elimino l'arco e lo sostituisco con la curva di Bezier - delete m_pGeoObj ; - m_pGeoObj = Release( pCrvBez) ; - } - // eseguo scalatura - return m_pGeoObj->Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ; - } - else + if ( m_pGeoObj == nullptr) return false ; + + // se arco e scalatura non omogenea + if ( m_pGeoObj->GetType() == CRV_ARC && + (fabs( dCoeffX - dCoeffY) > EPS_SMALL || fabs( dCoeffX - dCoeffZ) > EPS_SMALL)) { + // trasformo in curva di Bezier (semplice o composta) + ICurve* pCrvNew ; + if ( ! ArcToBezierCurve( GetCurve( m_pGeoObj), pCrvNew)) + return false ; + // elimino l'arco e lo sostituisco con la curva di Bezier + delete m_pGeoObj ; + m_pGeoObj = pCrvNew ; + } + + // eseguo scalatura + return m_pGeoObj->Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ; } //---------------------------------------------------------------------------- bool GdbObj::Mirror( const Point3d& ptOn, const Vector3d& vtNorm) { - if ( m_pGeoObj != nullptr) - return m_pGeoObj->Mirror( ptOn, vtNorm) ; - else + if ( m_pGeoObj == nullptr) return false ; + + return m_pGeoObj->Mirror( ptOn, vtNorm) ; } //---------------------------------------------------------------------------- bool GdbObj::ToGlob( const Frame3d& frRef) { - if ( m_pGeoObj != nullptr) - return m_pGeoObj->ToGlob( frRef) ; - else + if ( m_pGeoObj == nullptr) return false ; + + return m_pGeoObj->ToGlob( frRef) ; } //---------------------------------------------------------------------------- bool GdbObj::ToLoc( const Frame3d& frRef) { - if ( m_pGeoObj != nullptr) - return m_pGeoObj->ToLoc( frRef) ; - else + if ( m_pGeoObj == nullptr) return false ; + + return m_pGeoObj->ToLoc( frRef) ; } diff --git a/GeoConst.h b/GeoConst.h new file mode 100644 index 0000000..35299e7 --- /dev/null +++ b/GeoConst.h @@ -0,0 +1,32 @@ +//---------------------------------------------------------------------------- +// EgalTech 2013-2014 +//---------------------------------------------------------------------------- +// File : GeoConst.h Data : 23.01.14 Versione : 1.5a8 +// Contenuto : Costanti generali per calcoli geometrici. +// +// +// +// Modifiche : 23.01.14 DS Creazione modulo. +// +// +//---------------------------------------------------------------------------- + +#pragma once + + +//----------------- Costanti generali ---------------------------------------- +#include "/EgtDev/Include/EGkGeoConst.h" + +//----------------- Costanti per approssimazioni con polilinee --------------- +// tolleranza lineare minima in approssimazioni lineari +const double LIN_TOL_MIN = 0.01 ; +// deviazione angolare minima (in gradi) in approssimazioni lineari +const double ANG_TOL_MIN_DEG = 0.1 ; +// tolleranza lineare standard in approssimazioni lineari +static const double LIN_TOL_APPROX = 1 ; +// deviazione angolare standard (in gradi) in approssimazioni lineari +static const double ANG_TOL_APPROX_DEG = 45 ; + +//----------------- Costanti per archi come curve di Bezier ------------------ +// massimo angolo al centro di un arco espresso tramite curva di Bezier +static const double BEZARC_ANG_CEN_MAX = 90 ; \ No newline at end of file