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

EgtGeomKernel 1.5a8 : sistemata scalatura non uniforme di archi (sono trasformati in curve di Bezier singole o composite).

Browse Source 
Aggiunte costanti geometriche locali.
This commit is contained in:
Dario Sassi
2014-01-23 14:51:47 +00:00
parent 72350a0688
commit b50b676249
13 changed files with 403 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CurveArc.cpp
+11 -1
View File
@@ -14,6 +14,7 @@
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "CurveArc.h"
#include "GeoConst.h"
#include "GeoObjFactory.h"
#include "\EgtDev\Include\EGnStringUtils.h"
#include <new>
@@ -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) ;
}
CurveAux.cpp
+42 -1
View File
@@ -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<ICurveBezier> 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<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( ! IsValid( pCrvCompo))
return false ;
if ( ! pCrvCompo->AddCurve( *pArc) ||
! pCrvCompo->ArcsToBezierCurves())
return false ;
// restituisco la curva
pCrvNew = Release( pCrvCompo) ;
}
return true ;
}
CurveAux.h
+4
View File
@@ -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) ;
CurveBezier.cpp
+47 -9
View File
@@ -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 ;
}
CurveComposite.cpp
+108 -10
View File
@@ -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 <algorithm>
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<ICurve> 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<ICurveBezier> 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 ;
}
CurveComposite.h
+2
View File
@@ -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) ;
DistPointArc.cpp
+1
View File
@@ -15,6 +15,7 @@
#include "stdafx.h"
#include "DistPointArc.h"
#include "DistPointCrvAux.h"
#include "GeoConst.h"
//----------------------------------------------------------------------------
DistPointCrvAux.cpp
+1
View File
@@ -16,6 +16,7 @@
#include "DllMain.h"
#include "DistPointCrvAux.h"
#include "DistPointLine.h"
#include "GeoConst.h"
//----------------------------------------------------------------------------
DistPointCrvBezier.cpp
+1
View File
@@ -15,6 +15,7 @@
#include "stdafx.h"
#include "DistPointCrvBezier.h"
#include "DistPointCrvAux.h"
#include "GeoConst.h"
//----------------------------------------------------------------------------
EgtGeomKernel.rc
BIN
View File
Binary file not shown.
GdbExecutor.cpp
+116 -53
View File
@@ -458,7 +458,7 @@ GdbExecutor::ExecuteCurveBez( const string& sCmd2, const STRVECTOR& vsParams)
bool bErase = false ;
int nIdArc = ID_ERROR ;
// curva di Bezier intera (non razionale)
// curva di Bezier intera (polinomiale)
if ( sCmd2 == "INTEG" || sCmd2 == "I") {
int i ;
int nDeg ;
@@ -501,37 +501,35 @@ GdbExecutor::ExecuteCurveBez( const string& sCmd2, const STRVECTOR& vsParams)
return false ;
}
}
// curva di Bezier equivalente ad un arco
else if ( sCmd2 == "ARC" || sCmd2 == "A") {
// ricavata da un arco
if ( vsParams.size() == 3 || vsParams.size() == 4) {
// recupero flag cancellazione arco
if ( vsParams.size() == 4)
bErase = ( vsParams[3] != "0") ;
// 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) ;
}
// 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<ICurveComposite> 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<ICurveComposite> 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<ICurve> 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 ;
}
//----------------------------------------------------------------------------
GdbObj.cpp
+38 -42
View File
@@ -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 <new>
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<ICurveBezier> 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) ;
}
GeoConst.h
+32
View File
@@ -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 ;