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

Merge commit '038142a6d78d7d16086a7ea604e0c0a94dc221f5' into LorenzoM

Browse Source
This commit is contained in:
LorenzoM
2021-07-23 11:03:04 +02:00
parent 9c4118209e 038142a6d7
commit e1bfa954ff
27 changed files with 231 additions and 175 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CurveArc.cpp
+5 -2
View File
@@ -59,8 +59,10 @@ class ArcApproxer
//----------------------------------------------------------------------------
CurveArc::CurveArc( void)
: m_nStatus( TO_VERIFY), m_PtCen(), m_VtN(), m_VtS(), m_dRad(),
m_dAngCenDeg(), m_dDeltaN(), m_VtExtr(), m_dThick(), m_nTempProp()
m_dAngCenDeg(), m_dDeltaN(), m_VtExtr(), m_dThick()
{
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
}
//----------------------------------------------------------------------------
@@ -578,7 +580,8 @@ CurveArc::CopyFrom( const CurveArc& caSrc)
return true ;
m_VtExtr = caSrc.m_VtExtr ;
m_dThick = caSrc.m_dThick ;
m_nTempProp = caSrc.m_nTempProp ;
m_nTempProp[0] = caSrc.m_nTempProp[0] ;
m_nTempProp[1] = caSrc.m_nTempProp[1] ;
return Set( caSrc.m_PtCen, caSrc.m_VtN, caSrc.m_dRad,
caSrc.m_VtS, caSrc.m_dAngCenDeg, caSrc.m_dDeltaN) ;
}
CurveArc.h
+6 -5
View File
@@ -49,10 +49,11 @@ class CurveArc : public ICurveArc, public IGeoObjRW
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp) override
{ m_nTempProp = nProp ; }
int GetTempProp( void) const override
{ return m_nTempProp ; }
void SetTempProp( int nProp, int nPropInd = 0) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd = 0) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
public : // ICurve
bool IsSimple( void) const override
@@ -211,7 +212,7 @@ class CurveArc : public ICurveArc, public IGeoObjRW
double m_dDeltaN ; // variazione di quota lungo VtN della fine rispetto all'inizio
Vector3d m_VtExtr ; // vettore estrusione (normalmente coincide con m_VtN)
double m_dThick ; // spessore
int m_nTempProp ; // proprietà temporanea
int m_nTempProp[2] ; // vettore proprietà temporanee
} ;
//-----------------------------------------------------------------------------
CurveBezier.cpp
+5 -2
View File
@@ -45,8 +45,10 @@ GEOOBJ_REGISTER( CRV_BEZIER, NGE_C_BEZ, CurveBezier) ;
//----------------------------------------------------------------------------
CurveBezier::CurveBezier( void)
: m_nStatus( TO_VERIFY), m_nDeg(), m_bRat( false), m_dParSing( -2),
m_VtExtr(), m_dThick(), m_nTempProp()
m_VtExtr(), m_dThick()
{
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
}
//----------------------------------------------------------------------------
@@ -283,7 +285,8 @@ CurveBezier::CopyFrom( const CurveBezier& cbSrc)
m_vWeCtrl = cbSrc.m_vWeCtrl ;
m_VtExtr = cbSrc.m_VtExtr ;
m_dThick = cbSrc.m_dThick ;
m_nTempProp = cbSrc.m_nTempProp ;
m_nTempProp[0] = cbSrc.m_nTempProp[0] ;
m_nTempProp[1] = cbSrc.m_nTempProp[1] ;
return true ;
}
CurveBezier.h
+6 -5
View File
@@ -51,10 +51,11 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp) override
{ m_nTempProp = nProp ; }
int GetTempProp( void) const override
{ return m_nTempProp ; }
void SetTempProp( int nProp, int nPropInd = 0) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd = 0) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
public : // ICurve
bool IsSimple( void) const override { return true ; }
@@ -189,7 +190,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
DBLVECTOR m_vWeCtrl ; // vettore dei pesi di controllo
Vector3d m_VtExtr ; // vettore estrusione (normalmente coincide con m_VtN)
double m_dThick ; // spessore
int m_nTempProp ; // proprietà temporanea
int m_nTempProp[2] ; // vettore proprietà temporanee
} ;
//-----------------------------------------------------------------------------
CurveComposite.cpp
+13 -8
View File
@@ -40,8 +40,10 @@ GEOOBJ_REGISTER( CRV_COMPO, NGE_C_CMP, CurveComposite) ;
//----------------------------------------------------------------------------
CurveComposite::CurveComposite( void)
: m_nStatus( TO_VERIFY), m_VtExtr(), m_dThick(), m_ptStart(), m_nTempProp(), m_Iter( m_CrvSmplS.end())
: m_nStatus( TO_VERIFY), m_VtExtr(), m_dThick(), m_ptStart(), m_Iter( m_CrvSmplS.end())
{
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
}
//----------------------------------------------------------------------------
@@ -63,7 +65,8 @@ CurveComposite::Clear( void)
m_VtExtr = V_NULL ;
m_dThick = 0 ;
m_ptStart = ORIG ;
m_nTempProp = 0 ;
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
m_Iter = m_CrvSmplS.end() ;
// imposto ricalcolo della grafica
@@ -541,7 +544,8 @@ CurveComposite::CopyFrom( const CurveComposite& ccSrc)
Clear() ;
m_VtExtr = ccSrc.m_VtExtr ;
m_dThick = ccSrc.m_dThick ;
m_nTempProp = ccSrc.m_nTempProp ;
m_nTempProp[0] = ccSrc.m_nTempProp[0] ;
m_nTempProp[1] = ccSrc.m_nTempProp[1] ;
for ( auto& pCrv : ccSrc.m_CrvSmplS) {
if ( ! AddCurve( *pCrv))
return false ;
@@ -558,7 +562,8 @@ CurveComposite::RelocateFrom( CurveComposite& ccSrc)
Clear() ;
m_VtExtr = ccSrc.m_VtExtr ;
m_dThick = ccSrc.m_dThick ;
m_nTempProp = ccSrc.m_nTempProp ;
m_nTempProp[0] = ccSrc.m_nTempProp[0] ;
m_nTempProp[1] = ccSrc.m_nTempProp[1] ;
for ( ICurve* pCrv = ccSrc.RemoveFirstOrLastCurve( false) ;
pCrv != nullptr ;
pCrv = ccSrc.RemoveFirstOrLastCurve( false)) {
@@ -3243,7 +3248,7 @@ CurveComposite::IsACircle( double dLinTol, Point3d& ptCen, Vector3d& vtN, double
//----------------------------------------------------------------------------
bool
CurveComposite::SetCurveTempProp( int nCrv, int nProp)
CurveComposite::SetCurveTempProp( int nCrv, int nProp, int nPropNum)
{
// la curva deve essere validata
if ( m_nStatus != OK)
@@ -3252,13 +3257,13 @@ CurveComposite::SetCurveTempProp( int nCrv, int nProp)
if ( nCrv < 0 || nCrv >= int( m_CrvSmplS.size()))
return false ;
// eseguo assegnazione
m_CrvSmplS[nCrv]->SetTempProp( nProp) ;
m_CrvSmplS[nCrv]->SetTempProp( nProp, nPropNum) ;
return true ;
}
//----------------------------------------------------------------------------
bool
CurveComposite::GetCurveTempProp( int nCrv, int& nProp) const
CurveComposite::GetCurveTempProp( int nCrv, int& nProp, int nPropNum) const
{
// la curva deve essere validata
if ( m_nStatus != OK)
@@ -3267,6 +3272,6 @@ CurveComposite::GetCurveTempProp( int nCrv, int& nProp) const
if ( nCrv < 0 || nCrv >= int( m_CrvSmplS.size()))
return false ;
// eseguo recupero
nProp = m_CrvSmplS[nCrv]->GetTempProp() ;
nProp = m_CrvSmplS[nCrv]->GetTempProp( nPropNum) ;
return true ;
}
CurveComposite.h
+8 -7
View File
@@ -50,10 +50,11 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp) override
{ m_nTempProp = nProp ; }
int GetTempProp( void) const override
{ return m_nTempProp ; }
void SetTempProp( int nProp, int nPropInd = 0) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd = 0) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
public : // ICurve
bool IsSimple( void) const override
@@ -158,8 +159,8 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
bool IsAPoint( void) const override ;
bool IsALine( double dLinTol, Point3d& ptStart, Point3d& ptEnd) const override ;
bool IsACircle( double dLinTol, Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW) const override ;
bool SetCurveTempProp( int nCrv, int nProp) override ;
bool GetCurveTempProp( int nCrv, int& nProp) const override ;
bool SetCurveTempProp( int nCrv, int nProp, int nPropNum = 0) override ;
bool GetCurveTempProp( int nCrv, int& nProp, int nPropNum = 0) const override ;
public : // IGeoObjRW
int GetNgeId( void) const override ;
@@ -202,7 +203,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
Vector3d m_VtExtr ; // vettore estrusione (normalmente coincide con m_VtN)
double m_dThick ; // spessore
Point3d m_ptStart ; // punto iniziale per composita vuota per Add di linee o archi
int m_nTempProp ; // proprietà temporanea
int m_nTempProp[2] ; // vettore proprietà temporanee
mutable PCSD_CONST_ITER m_Iter ; // iteratore
} ;
CurveLine.cpp
+5 -2
View File
@@ -29,8 +29,10 @@ GEOOBJ_REGISTER( CRV_LINE, NGE_C_LIN, CurveLine) ;
//----------------------------------------------------------------------------
CurveLine::CurveLine( void)
: m_nStatus( TO_VERIFY), m_PtStart(), m_PtEnd(), m_VtExtr(), m_dThick(), m_nTempProp()
: m_nStatus( TO_VERIFY), m_PtStart(), m_PtEnd(), m_VtExtr(), m_dThick()
{
m_nTempProp[0] = 0 ;
m_nTempProp[0] = 0 ;
}
//----------------------------------------------------------------------------
@@ -123,7 +125,8 @@ CurveLine::CopyFrom( const CurveLine& clSrc)
return true ;
m_VtExtr = clSrc.m_VtExtr ;
m_dThick = clSrc.m_dThick ;
m_nTempProp = clSrc.m_nTempProp ;
m_nTempProp[0] = clSrc.m_nTempProp[0] ;
m_nTempProp[1] = clSrc.m_nTempProp[1] ;
return Set( clSrc.m_PtStart, clSrc.m_PtEnd) ;
}
CurveLine.h
+6 -5
View File
@@ -49,10 +49,11 @@ class CurveLine : public ICurveLine, public IGeoObjRW
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp) override
{ m_nTempProp = nProp ; }
int GetTempProp( void) const override
{ return m_nTempProp ; }
void SetTempProp( int nProp, int nPropInd = 0) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd = 0) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
public : // ICurve
bool IsSimple( void) const override
@@ -164,7 +165,7 @@ class CurveLine : public ICurveLine, public IGeoObjRW
Point3d m_PtEnd ; // punto finale
Vector3d m_VtExtr ; // vettore estrusione
double m_dThick ; // spessore
int m_nTempProp ; // proprietà temporanea
int m_nTempProp[2] ; // vettore proprietà temporanee
} ;
//-----------------------------------------------------------------------------
EgtGeomKernel.rc
BIN
View File
Binary file not shown.
ExtDimension.cpp
+4 -1
View File
@@ -49,6 +49,8 @@ ExtDimension::ExtDimension( void)
: m_dExtLineLen( STD_EXTLINELEN), m_dArrowLen( STD_ARROWLEN), m_dTextDist( STD_TEXTDIST),
m_bLenIsMM( true), m_nDecDigit( STD_DECDIGIT), m_sFont( STD_FONT), m_dTextHeight( STD_TEXTHEIGHT)
{
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
}
//----------------------------------------------------------------------------
@@ -186,7 +188,8 @@ ExtDimension::CopyFrom( const ExtDimension& clSrc)
m_nDecDigit = clSrc.m_nDecDigit ;
m_sFont = clSrc.m_sFont ;
m_dTextHeight = clSrc.m_dTextHeight ;
m_nTempProp = clSrc.m_nTempProp ;
m_nTempProp[0] = clSrc.m_nTempProp[0] ;
m_nTempProp[1] = clSrc.m_nTempProp[1] ;
return true ;
}
ExtDimension.h
+6 -5
View File
@@ -50,10 +50,11 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp) override
{ m_nTempProp = nProp ; }
int GetTempProp( void) const override
{ return m_nTempProp ; }
void SetTempProp( int nProp, int nPropInd = 0) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd = 0) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
public : // IExtDimension
bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -148,5 +149,5 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
int m_nDecDigit ; // numero di cifre decimali
std::string m_sFont ; // font del testo
double m_dTextHeight ; // altezza del testo
int m_nTempProp ; // proprietà temporanea
int m_nTempProp[2] ; // vettore proprietà temporanee
} ;
ExtText.cpp
+5 -2
View File
@@ -35,8 +35,10 @@ GEOOBJ_REGISTER( EXT_TEXT, NGE_E_TXT, ExtText) ;
//----------------------------------------------------------------------------
ExtText::ExtText( void)
: m_pSTM( nullptr), m_bNoSTM( false), m_ptP(), m_vtN( 0, 0, 1), m_vtD( 1, 0, 0), m_sFont(),
m_nWeight( 400), m_bItalic( false), m_dHeight( 10), m_dRatio( 1), m_dAddAdvance( 0), m_nTempProp()
m_nWeight( 400), m_bItalic( false), m_dHeight( 10), m_dRatio( 1), m_dAddAdvance( 0)
{
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
}
//----------------------------------------------------------------------------
@@ -184,7 +186,8 @@ ExtText::CopyFrom( const ExtText& clSrc)
m_dRatio = clSrc.m_dRatio ;
m_dAddAdvance = clSrc.m_dAddAdvance ;
m_nInsPos = clSrc.m_nInsPos ;
m_nTempProp = clSrc.m_nTempProp ;
m_nTempProp[0] = clSrc.m_nTempProp[0] ;
m_nTempProp[1] = clSrc.m_nTempProp[1] ;
return true ;
}
ExtText.h
+6 -5
View File
@@ -50,10 +50,11 @@ class ExtText : public IExtText, public IGeoObjRW
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp) override
{ m_nTempProp = nProp ; }
int GetTempProp( void) const override
{ return m_nTempProp ; }
void SetTempProp( int nProp, int nPropInd = 0) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd = 0) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
public : // IExtText
bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -143,5 +144,5 @@ class ExtText : public IExtText, public IGeoObjRW
double m_dRatio ; // rapporto tra larghezza e altezza
double m_dAddAdvance ; // avanzamento addizionale tra caratteri
int m_nInsPos ; // posizione del punto di inserimento rispetto al testo
int m_nTempProp ; // proprietà temporanea
int m_nTempProp[2] ; // vettore proprietà temporanee
} ;
GeoFrame3d.cpp
+5 -2
View File
@@ -29,8 +29,10 @@ GEOOBJ_REGISTER( GEO_FRAME3D, NGE_G_FRM, GeoFrame3d) ;
//----------------------------------------------------------------------------
GeoFrame3d::GeoFrame3d( void)
: m_frF(), m_nTempProp()
: m_frF()
{
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
}
//----------------------------------------------------------------------------
@@ -114,7 +116,8 @@ GeoFrame3d::CopyFrom( const GeoFrame3d& gfSrc)
{
if ( &gfSrc == this)
return true ;
m_nTempProp = gfSrc.m_nTempProp ;
m_nTempProp[0] = gfSrc.m_nTempProp[0] ;
m_nTempProp[1] = gfSrc.m_nTempProp[1] ;
return Set( gfSrc.m_frF) ;
}
GeoFrame3d.h
+6 -5
View File
@@ -57,10 +57,11 @@ class GeoFrame3d : public IGeoFrame3d, public IGeoObjRW
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp) override
{ m_nTempProp = nProp ; }
int GetTempProp( void) const override
{ return m_nTempProp ; }
void SetTempProp( int nProp, int nPropInd = 0) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd = 0) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
public : // IGeoFrame3d
bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -95,5 +96,5 @@ class GeoFrame3d : public IGeoFrame3d, public IGeoObjRW
private :
ObjGraphicsMgr m_OGrMgr ; // gestore grafica dell'oggetto
Frame3d m_frF ; // oggetto
int m_nTempProp ; // proprietà temporanea
int m_nTempProp[2] ; // vettore proprietà temporanee
} ;
GeoPoint3d.cpp
+5 -2
View File
@@ -28,8 +28,10 @@ GEOOBJ_REGISTER( GEO_PNT3D, NGE_G_PNT, GeoPoint3d) ;
//----------------------------------------------------------------------------
GeoPoint3d::GeoPoint3d( void)
: m_ptP(), m_nTempProp()
: m_ptP()
{
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
}
//----------------------------------------------------------------------------
@@ -82,7 +84,8 @@ GeoPoint3d::CopyFrom( const GeoPoint3d& clSrc)
{
if ( &clSrc == this)
return true ;
m_nTempProp = clSrc.m_nTempProp ;
m_nTempProp[0] = clSrc.m_nTempProp[0] ;
m_nTempProp[1] = clSrc.m_nTempProp[1] ;
return Set( clSrc.m_ptP) ;
}
GeoPoint3d.h
+6 -5
View File
@@ -57,10 +57,11 @@ class GeoPoint3d : public IGeoPoint3d, public IGeoObjRW
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp) override
{ m_nTempProp = nProp ; }
int GetTempProp( void) const override
{ return m_nTempProp ; }
void SetTempProp( int nProp, int nPropInd = 0) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd = 0) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
public : // IGeoPoint3d
bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -89,5 +90,5 @@ class GeoPoint3d : public IGeoPoint3d, public IGeoObjRW
private :
ObjGraphicsMgr m_OGrMgr ; // gestore grafica dell'oggetto
Point3d m_ptP ; // oggetto
int m_nTempProp ; // proprietà temporanea
int m_nTempProp[2] ; // vettore proprietà temporanee
} ;
GeoVector3d.cpp
+5 -2
View File
@@ -29,8 +29,10 @@ GEOOBJ_REGISTER( GEO_VECT3D, NGE_G_VEC, GeoVector3d) ;
//----------------------------------------------------------------------------
GeoVector3d::GeoVector3d( void)
: m_vtV(), m_nTempProp()
: m_vtV()
{
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
}
//----------------------------------------------------------------------------
@@ -98,7 +100,8 @@ GeoVector3d::CopyFrom( const GeoVector3d& clSrc)
{
if ( &clSrc == this)
return true ;
m_nTempProp = clSrc.m_nTempProp ;
m_nTempProp[0] = clSrc.m_nTempProp[0] ;
m_nTempProp[1] = clSrc.m_nTempProp[1] ;
return Set( clSrc.m_vtV, clSrc.m_ptBase) ;
}
GeoVector3d.h
+6 -5
View File
@@ -65,10 +65,11 @@ class GeoVector3d : public IGeoVector3d, public IGeoObjRW
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp) override
{ m_nTempProp = nProp ; }
int GetTempProp( void) const override
{ return m_nTempProp ; }
void SetTempProp( int nProp, int nPropInd = 0) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd = 0) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
public : // IGeoVector3d
bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -104,5 +105,5 @@ class GeoVector3d : public IGeoVector3d, public IGeoObjRW
ObjGraphicsMgr m_OGrMgr ; // gestore grafica dell'oggetto
Vector3d m_vtV ; // oggetto
Point3d m_ptBase ; // punto base da cui tracciare il vettore
int m_nTempProp ; // proprietà temporanea
int m_nTempProp[2] ; // vettore proprietà temporanee
} ;
SurfBezier.cpp
+5 -2
View File
@@ -35,8 +35,10 @@ GEOOBJ_REGISTER( SRF_BEZIER, NGE_S_BEZ, SurfBezier) ;
//----------------------------------------------------------------------------
SurfBezier::SurfBezier(void)
: m_pSTM( nullptr), m_nStatus( TO_VERIFY), m_nDegU(), m_nDegV(), m_nSpanU(), m_nSpanV(), m_bRat( false),
m_bTrimmed( false), m_pTrimReg( nullptr), m_nTempProp( 0)
m_bTrimmed( false), m_pTrimReg( nullptr)
{
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
}
//----------------------------------------------------------------------------
@@ -566,7 +568,8 @@ SurfBezier::CopyFrom( const SurfBezier& sbSrc)
m_vPtCtrl = sbSrc.m_vPtCtrl ;
if ( sbSrc.m_bRat)
m_vWeCtrl = sbSrc.m_vWeCtrl ;
m_nTempProp = sbSrc.m_nTempProp ;
m_nTempProp[0] = sbSrc.m_nTempProp[0] ;
m_nTempProp[1] = sbSrc.m_nTempProp[1] ;
return true ;
}
SurfBezier.h
+6 -5
View File
@@ -53,10 +53,11 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp) override
{ m_nTempProp = nProp ; }
int GetTempProp( void) const override
{ return m_nTempProp ; }
void SetTempProp( int nProp, int nPropInd) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
public : // ISurf
bool IsSimple( void) const override
@@ -165,7 +166,7 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
PNTVECTOR m_vPtCtrl ; // vettore dei punti di controllo
DBLVECTOR m_vWeCtrl ; // vettore dei pesi di controllo
SurfFlatRegion* m_pTrimReg ; // eventuale regione di trim
int m_nTempProp ; // proprietà temporanea
int m_nTempProp[2] ; // vettore proprietà temporanee
} ;
//-----------------------------------------------------------------------------
SurfFlatRegion.cpp
+7 -3
View File
@@ -33,8 +33,10 @@ GEOOBJ_REGISTER( SRF_FLATRGN, NGE_S_FRG, SurfFlatRegion) ;
//----------------------------------------------------------------------------
SurfFlatRegion::SurfFlatRegion( void)
: m_pSTM( nullptr), m_nStatus( TO_VERIFY), m_nTempProp()
: m_pSTM( nullptr), m_nStatus( TO_VERIFY)
{
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
}
//----------------------------------------------------------------------------
@@ -55,7 +57,8 @@ SurfFlatRegion::Clear( void)
delete pLoop ;
m_vpLoop.clear() ;
m_nTempProp = 0 ;
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
// imposto ricalcolo della grafica
m_OGrMgr.Reset() ;
@@ -397,7 +400,8 @@ SurfFlatRegion::CopyFrom( const SurfFlatRegion& sfrSrc)
m_vpLoop.push_back( pCrv) ;
}
m_vExtInd = sfrSrc.m_vExtInd ;
m_nTempProp = sfrSrc.m_nTempProp ;
m_nTempProp[0] = sfrSrc.m_nTempProp[0] ;
m_nTempProp[1] = sfrSrc.m_nTempProp[1] ;
m_nStatus = sfrSrc.m_nStatus ;
return ( m_nStatus == OK && ! m_vpLoop.empty()) ;
}
SurfFlatRegion.h
+6 -5
View File
@@ -51,10 +51,11 @@ class SurfFlatRegion : public ISurfFlatRegion, public IGeoObjRW
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp) override
{ m_nTempProp = nProp ; }
int GetTempProp( void) const override
{ return m_nTempProp ; }
void SetTempProp( int nProp, int nPropInd = 0) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd = 0) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
public : // ISurf
bool IsSimple( void) const override
@@ -144,7 +145,7 @@ class SurfFlatRegion : public ISurfFlatRegion, public IGeoObjRW
Frame3d m_frF ; // riferimento intrinseco
PCRV_DEQUE m_vpLoop ; // deque delle curve che formano i loop
INTVECTOR m_vExtInd ; // indice dei loop esterni nel precedente vettore
int m_nTempProp ; // proprietà temporanea
int m_nTempProp[2] ; // vettore proprietà temporanee
} ;
//-----------------------------------------------------------------------------
SurfTriMesh.cpp
+80 -77
View File
@@ -41,10 +41,12 @@ GEOOBJ_REGISTER( SRF_TRIMESH, NGE_S_TRM, SurfTriMesh) ;
SurfTriMesh::SurfTriMesh( void)
: m_nStatus( TO_VERIFY), m_dLinTol( STM_STD_LIN_TOL), m_dBoundaryAng( STM_STD_BOUNDARY_ANG),
m_dSmoothAng( STM_STD_SMOOTH_ANG), m_bOriented( false), m_bClosed( false), m_bFaceted( false),
m_nTimeStamp( 0), m_nTempProp( 0), m_nMaxTFlag( 0), m_nParts( -1), m_pHGrd3d( nullptr), m_pPGrd3d( nullptr)
m_nTimeStamp( 0), m_nMaxTFlag( 0), m_nParts( -1), m_pHGrd3d( nullptr), m_pPGrd3d( nullptr)
{
m_dCosBndAng = cos( m_dBoundaryAng * DEGTORAD) ;
m_dCosSmAng = cos( m_dSmoothAng * DEGTORAD) ;
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
}
//----------------------------------------------------------------------------
@@ -65,7 +67,7 @@ SurfTriMesh::Init( int nNumVert, int nNumTria, int nNumFacet)
// se superficie vuota
if ( nNumVert == 0 && nNumTria == 0 && nNumFacet == 0)
return true ;
// verifico validità parametri
// verifico validit� parametri
if ( nNumVert < 3 || nNumTria < 1)
return false ;
// prealloco la memoria
@@ -113,7 +115,7 @@ SurfTriMesh::AddVertex( const Point3d& ptVert)
m_nStatus = TO_VERIFY ;
m_nParts = - 1 ;
m_OGrMgr.Reset() ;
// Verifico che il punto non sia distante meno di epsilon da un altro già esistente.
// Verifico che il punto non sia distante meno di epsilon da un altro gi� esistente.
Point3d ptAddingPoint ;
VerifyPointGrid3d() ;
int nNearestId ;
@@ -243,14 +245,14 @@ SurfTriMesh::RemoveTriangle( int nId)
// verifico esistenza del triangolo
if ( nId < 0 || nId >= GetTriangleSize())
return false ;
// verifico se già cancellato
// verifico se gi� cancellato
if ( m_vTria[nId].nIdVert[0] == SVT_DEL)
return true ;
// aggiorno eventuali riferimenti dei vertici
for ( int i = 0 ; i < 3 ; ++ i) {
// indice vertice
int nV = m_vTria[nId].nIdVert[i] ;
// se vertice non c'è passo al prossimo
// se vertice non c'� passo al prossimo
if ( nV < 0 || nV >= int( m_vTria.size()))
continue ;
if ( m_vVert[nV].nIdTria == nId) {
@@ -268,7 +270,7 @@ SurfTriMesh::RemoveTriangle( int nId)
for ( int i = 0 ; i < 3 ; ++ i) {
// indice triangolo adiacente
int nAdjT = m_vTria[nId].nIdAdjac[i] ;
// se triangolo adiacente non c'è passo al prossimo
// se triangolo adiacente non c'� passo al prossimo
if ( nAdjT == SVT_NULL || m_vTria[nAdjT].nIdVert[0] == SVT_DEL)
continue ;
// ne sistemo la contro-adiacenza
@@ -281,7 +283,7 @@ SurfTriMesh::RemoveTriangle( int nId)
m_vTria[nId].nIdVert[0] = SVT_DEL ;
// invalido calcolo facce
m_bFaceted = false ;
// invalido calcolo connettività
// invalido calcolo connettivit�
m_nParts = - 1 ;
return true ;
}
@@ -347,7 +349,7 @@ SurfTriMesh::GetCentroid( Point3d& ptCen) const
// la superficie deve essere validata
if ( m_nStatus != OK)
return false ;
// se la superficie è chiusa, calcolo il centroide del solido
// se la superficie � chiusa, calcolo il centroide del solido
if ( IsClosed()) {
// applico le formule di R. Nurnberg Imperial College London ad ogni faccia
Triangle3d Tria ;
@@ -700,13 +702,13 @@ SurfTriMesh::GetTriangleBoundaryEdges( int nId, TriFlags3d& TFlags) const
for ( int i = 0 ; i < 3 ; ++ i) {
// indice triangolo adiacente al lato
int nT = m_vTria[nId].nIdAdjac[i] ;
// se già definite le facce, verifico indice faccia
// se gi� definite le facce, verifico indice faccia
if ( m_bFaceted) {
TFlags.bFlag[i] = ( nT == SVT_NULL || m_vTria[nId].nIdFacet != m_vTria[nT].nIdFacet) ;
}
// altrimenti verifico con le normali
else
// se non c'è triangolo adiacente o se forma un angolo oltre il limite, il lato è un contorno
// se non c'� triangolo adiacente o se forma un angolo oltre il limite, il lato � un contorno
TFlags.bFlag[i] = ( nT == SVT_NULL || m_vTria[nId].vtN * m_vTria[nT].vtN < m_dCosBndAng) ;
}
@@ -790,7 +792,7 @@ SurfTriMesh::GetTriangleSmoothNormal( int nT, int nV, Vector3d& vtN) const
if ( nPos == -1)
return false ;
// medio le normali, finché non incontro degli spigoli
// medio le normali, finch� non incontro degli spigoli
vtN = m_vTria[nT].vtN ;
// parto dal triangolo e vado in direzione positiva
int nLim = nPos ;
@@ -893,7 +895,7 @@ SurfTriMesh::GetLoops( POLYLINEVECTOR& vPL) const
if ( ! MarchAlongLoop( nT, 1, m_nTimeStamp, vPL.back()))
return false ;
}
// se il lato 0 è di contorno
// se il lato 0 � di contorno
else if ( nAdjT[0] == SVT_NULL) {
// ho trovato l'inizio di un loop
vPL.emplace_back() ;
@@ -905,7 +907,7 @@ SurfTriMesh::GetLoops( POLYLINEVECTOR& vPL) const
if ( ! MarchAlongLoop( nT, 1, m_nTimeStamp, vPL.back()))
return false ;
}
// se il lato 1 è di contorno
// se il lato 1 � di contorno
else if ( nAdjT[1] == SVT_NULL) {
// ho trovato l'inizio di un loop
vPL.emplace_back() ;
@@ -917,7 +919,7 @@ SurfTriMesh::GetLoops( POLYLINEVECTOR& vPL) const
if ( ! MarchAlongLoop( nT, 2, m_nTimeStamp, vPL.back()))
return false ;
}
// se il lato 2 è di contorno
// se il lato 2 � di contorno
else if ( nAdjT[2] == SVT_NULL) {
// ho trovato l'inizio di un loop
vPL.emplace_back() ;
@@ -929,7 +931,7 @@ SurfTriMesh::GetLoops( POLYLINEVECTOR& vPL) const
if ( ! MarchAlongLoop( nT, 0, m_nTimeStamp, vPL.back()))
return false ;
}
// altrimenti non c'è contorno
// altrimenti non c'� contorno
else {
// marco il triangolo come verificato
m_vTria[nT].nTemp = m_nTimeStamp ;
@@ -974,10 +976,10 @@ SurfTriMesh::MarchOneTria( int& nT, int& nV, int nTimeStamp,
return false ;
// vertice di fine adiacenza e indice del successivo lato
int nAdjV = Next( nAdjS) ;
// verifico se il lato successivo è un bordo
// verifico se il lato successivo � un bordo
int nNextT = m_vTria[nAdjT].nIdAdjac[nAdjV] ;
if ( nNextT == SVT_NULL) {
// se già recuperato
// se gi� recuperato
if ( m_vTria[nAdjT].nTemp == nTimeStamp) {
bEnd = true ;
return true ;
@@ -1021,7 +1023,7 @@ SurfTriMesh::GetSilhouette( const Vector3d& vtDir, POLYLINEVECTOR& vPL) const
// Elimino i triangoli con normale non equiversa alla direzione scelta
for ( int i = 0 ; i < int( pStm->m_vTria.size()) ; ++ i) {
// se già cancellato, passo oltre
// se gi� cancellato, passo oltre
if ( pStm->m_vTria[i].nIdVert[0] == SVT_DEL)
continue ;
// verifico la normale
@@ -1082,7 +1084,8 @@ SurfTriMesh::CopyFrom( const SurfTriMesh& stmSrc)
m_vTria = stmSrc.m_vTria ;
m_vFacet = stmSrc.m_vFacet ;
m_nTimeStamp = stmSrc.m_nTimeStamp ;
m_nTempProp = stmSrc.m_nTempProp ;
m_nTempProp[0] = stmSrc.m_nTempProp[0] ;
m_nTempProp[1] = stmSrc.m_nTempProp[1] ;
m_nMaxTFlag = stmSrc.m_nMaxTFlag ;
m_nParts = stmSrc.m_nParts ;
return true ;
@@ -1120,7 +1123,7 @@ SurfTriMesh::Dump( string& sOut, bool bMM, const char* szNewLine) const
// segnalo eventuale incongruenza di orientamento
if ( ! m_bOriented)
sOut += string( "Inconsistent Orientation") + szNewLine ;
// segnalo numero di parti se più di una
// segnalo numero di parti se pi� di una
int nParts = GetPartCount() ;
if ( nParts > 1)
sOut += string( "Parts =") + ToString( nParts) + szNewLine ;
@@ -1351,7 +1354,7 @@ SurfTriMesh::Validate( bool bCorrect)
// Verifico che i triangoli riferiti dalle facce esistano
for ( int i = 0 ; i < GetFacetSize() && m_nStatus == OK && m_bFaceted ; ++ i) {
// verifico validità triangolo riferito
// verifico validit� triangolo riferito
if ( m_vFacet[i] <= SVT_NULL ||
m_vFacet[i] >= GetTriangleSize() ||
m_vTria[ m_vFacet[i]].nIdVert[0] == SVT_DEL)
@@ -1506,7 +1509,7 @@ SurfTriMesh::AdjustAdjacencies( void)
bool
SurfTriMesh::AdjustOrientations( void)
{
// se non ci sono almeno 2 triangoli è inutile fare test
// se non ci sono almeno 2 triangoli � inutile fare test
if ( m_vTria.size() < 2) {
m_bOriented = true ;
return true ;
@@ -1550,7 +1553,7 @@ SurfTriMesh::AdjustTriaOrientation( TRINTDEQUE& S3iQ)
S3iQ.pop_front() ;
// assegno time stamp al triangolo
m_vTria[nT].nTemp = m_nTimeStamp ;
// se c'è triangolo di riferimento, devo verificare se da invertire
// se c'� triangolo di riferimento, devo verificare se da invertire
if ( nRefT != SVT_NULL) {
// cerco indice half-edge in comune
int nE = 0 ;
@@ -1568,7 +1571,7 @@ SurfTriMesh::AdjustTriaOrientation( TRINTDEQUE& S3iQ)
bool bOk = true ;
for ( int j = 0 ; j < 3 ; ++ j) {
int nAdjT = m_vTria[nT].nIdAdjac[j] ;
// se non c'è adiacenza o va sul triangolo di provenienza
// se non c'� adiacenza o va sul triangolo di provenienza
if ( nAdjT == SVT_NULL || nAdjT == nRefT)
;
// la verifico
@@ -1621,7 +1624,7 @@ SurfTriMesh::TestSealing( void)
bool
SurfTriMesh::AdjustTopology( void)
{
// se non è rimasto alcunché di valido, pulisco tutto ed esco
// se non � rimasto alcunch� di valido, pulisco tutto ed esco
if ( GetVertexCount() < 3 || GetTriangleCount() < 1) {
Clear() ;
m_bOriented = true ;
@@ -1638,7 +1641,7 @@ SurfTriMesh::AdjustTopology( void)
// verifica adiacenze
if ( ! AdjustAdjacencies())
return false ;
// verifica continuità orientazione
// verifica continuit� orientazione
if ( ! AdjustOrientations())
return false ;
// verifica chiusura
@@ -1676,7 +1679,7 @@ SurfTriMesh::PackVertices( void)
vVId.push_back( SVT_DEL) ;
}
}
// se non c'è stata compattazione, esco
// se non c'� stata compattazione, esco
if ( nFirstFree == SVT_NULL)
return true ;
// lunghezza vettore indici vertici
@@ -1691,7 +1694,7 @@ SurfTriMesh::PackVertices( void)
// salto i triangoli cancellati
if ( vOId[0] == SVT_DEL)
continue ;
// verifico la validità degli indici
// verifico la validit� degli indici
if ( vOId[0] < 0 || vOId[0] >= nVIdSize ||
vOId[1] < 0 || vOId[1] >= nVIdSize ||
vOId[2] < 0 || vOId[2] >= nVIdSize)
@@ -1731,7 +1734,7 @@ SurfTriMesh::PackTriangles( void)
vTId.push_back( SVT_DEL) ;
}
}
// se non c'è stata compattazione, esco
// se non c'� stata compattazione, esco
if ( nFirstFree == SVT_NULL)
return true ;
// Invalido HashGrid e Pointgrid
@@ -1746,7 +1749,7 @@ SurfTriMesh::PackTriangles( void)
// salto vertice cancellato
if ( nOId == SVT_DEL)
continue ;
// verifico la validità dell'indice
// verifico la validit� dell'indice
if ( nOId < 0 || nOId >= nTIdSize)
return false ;
// aggiorno
@@ -1776,7 +1779,7 @@ SurfTriMesh::PackTriangles( void)
// salto le facets non valide
if ( m_vFacet[nId] == SVT_DEL)
continue ;
// verifico validità indice a triangolo
// verifico validit� indice a triangolo
if ( m_vFacet[nId] < 0 || m_vFacet[nId] >= nTIdSize)
return false ;
// aggiorno
@@ -1879,7 +1882,7 @@ SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
ResetHashGrids3d() ;
ResetPointGrid3d() ;
// verifico se la polilinea è chiusa
// verifico se la polilinea � chiusa
bool bClosed = PL.IsClosed() ;
// costruisco la mesh
@@ -1912,7 +1915,7 @@ SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
}
// se curva chiusa, aggiungo gli ultimi due triangoli
if ( bClosed) {
// non devo aggiungere i vertici, perchè coincidono con quelli iniziali
// non devo aggiungere i vertici, perch� coincidono con quelli iniziali
// aggiungo i due triangoli relativi
nIdV[0] = nV ;
nIdV[1] = nV - 1 ;
@@ -1931,7 +1934,7 @@ SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
bool
SurfTriMesh::CreateByPointCurve( const Point3d& ptP, const PolyLine& PL)
{
// verifico validità punto/polilinea
// verifico validit� punto/polilinea
bool bClosed = PL.IsClosed() ;
// se chiusa, la polilinea deve avere almeno 3 punti
if ( bClosed) {
@@ -1976,7 +1979,7 @@ SurfTriMesh::CreateByPointCurve( const Point3d& ptP, const PolyLine& PL)
// aggiorno indice punto precedente su curva
nIdV[1] = nIdV[2] ;
}
// se chiusa aggiungo l'ultimo triangolo (non il vertice perchè è il primo della curva)
// se chiusa aggiungo l'ultimo triangolo (non il vertice perch� � il primo della curva)
if ( bClosed) {
nIdV[2] = 1 ;
// inserisco il triangolo A2p -> A1p -> A1s
@@ -2122,7 +2125,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
}
// ciclo sui punti
while ( bNext1 || bNext2) {
// se c'è nuovo V1s e la diagonale più corta è V2p -> V1s oppure non c'è V2s
// se c'� nuovo V1s e la diagonale pi� corta � V2p -> V1s oppure non c'� V2s
if ( ! bNext2 || ( bNext1 && ( nP1s == vPnt2[nP2p].second || vPnt1[nP1s].second == nP2p))) {
// inserisco il vertice V1s (se ultimo e curve chiuse, prendo il primo)
if ( nP1s == nTotP1 - 1 && bClosed)
@@ -2144,7 +2147,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
nV1p = nV1s ; nP1p = nP1s ; ++ nP1s ;
bNext1 = ( nP1s < nTotP1) ;
}
// altrimenti è V1p -> V2s
// altrimenti � V1p -> V2s
else {
// inserisco il vertice V2s (se ultimo e curve chiuse, prendo il primo)
if ( nP2s == nTotP2 - 1 && bClosed)
@@ -2171,7 +2174,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
// altrimenti rigata con parametrizzazione sincrona sulle due curve
else {
// verifico validità polilinee (devono avere almeno 2 punti e non coincidere se non agli estremi aperti)
// verifico validit� polilinee (devono avere almeno 2 punti e non coincidere se non agli estremi aperti)
if ( ! VerifyPolylinesForTwoCurves( PL1, PL2))
return false ;
@@ -2246,7 +2249,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
}
// ciclo sui punti
while ( bNext1 || bNext2) {
// se c'è nuovo dA1s e la diagonale più corta è dA2p -> dA1s oppure non c'è dA2s
// se c'� nuovo dA1s e la diagonale pi� corta � dA2p -> dA1s oppure non c'� dA2s
if ( ( bNext1 && ( dA1s - dA2p) <= ( dA2s - dA1p) + EPS_PARAM) || ! bNext2) {
// inserisco il vertice A1s
if ( ( nV1s = AddVertex( ptP1s)) == SVT_NULL)
@@ -2270,7 +2273,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
if ( bNext1)
dA1s = ( dU1s - dU1F) / dDeltaU1 ;
}
// altrimenti è dA1p -> dA2s
// altrimenti � dA1p -> dA2s
else {
// inserisco il vertice A2s
if ( ( nV2s = AddVertex( ptP2s)) == SVT_NULL)
@@ -2299,7 +2302,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
if ( bClosed) {
dA1s = 1 ;
dA2s = 1 ;
// se la diagonale più corta è dA2p -> dA1s = 0
// se la diagonale pi� corta � dA2p -> dA1s = 0
if ( ( dA1s - dA2p) <= ( dA2s - dA1p) + EPS_PARAM) {
// inserisco il triangolo A2p -> A1p -> A1s = 0
nIdV[0] = nV2p ;
@@ -2314,7 +2317,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
if ( AddTriangle( nIdV) == SVT_NULL)
return false ;
}
// altrimenti è dA1p -> dA2s = 1
// altrimenti � dA1p -> dA2s = 1
else {
// inserisco il triangolo A2p -> A1p -> A2s = 1
nIdV[0] = nV2p ;
@@ -2386,7 +2389,7 @@ SurfTriMesh::VerifyPolylinesForTwoCurves( const PolyLine& PL1, const PolyLine& P
return false ;
// verifiche sui punti successivi (non sugli ultimi)
while ( bNext1 || bNext2) {
// se c'è nuovo dA1s e la diagonale più corta è dA2p -> dA1s oppure non c'è dA2s
// se c'� nuovo dA1s e la diagonale pi� corta � dA2p -> dA1s oppure non c'� dA2s
if ( ( bNext1 && ( dA1s - dA2p) <= ( dA2s - dA1p) + EPS_PARAM) || ! bNext2) {
// verifico se coincidono
if ( AreSamePointApprox( ptP2p, ptP1s))
@@ -2397,7 +2400,7 @@ SurfTriMesh::VerifyPolylinesForTwoCurves( const PolyLine& PL1, const PolyLine& P
if ( bNext1)
dA1s = ( dU1s - dU1F) / dDeltaU1 ;
}
// altrimenti è dA1p -> dA2s = 1
// altrimenti � dA1p -> dA2s = 1
else {
// verifico se coincidono
if ( AreSamePointApprox( ptP1p, ptP2s))
@@ -2501,7 +2504,7 @@ AdjustPolylineForRevolution( PolyLine& PL, const Point3d& ptAx, const Vector3d&
plTrim.Translate( DIST_SIC * vtTrN) ;
PL.Trim( plTrim, false) ;
// Se polilinea risultante è aperta con estremità molto vicine all'asse le porto su questo
// Se polilinea risultante � aperta con estremit� molto vicine all'asse le porto su questo
if ( ! PL.IsClosed()) {
// verifico l'inizio
double dUStart ;
@@ -2580,7 +2583,7 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
ResetHashGrids3d() ;
ResetPointGrid3d() ;
// verifico se la polilinea è chiusa
// verifico se la polilinea � chiusa
bool bClosed = MyPL.IsClosed() ;
// costruisco la mesh
@@ -2601,7 +2604,7 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
// verifico se il punto giace sull'asse e vi sta fisso
bool bPrevOnAx = bOnlyRev && DistPointLine( ptP, ptAx, vtAx, 1, false).IsSmall() ;
int nVPrevOnAx = nV ;
// se non è fisso sull'asse, inserisco le copie ruotate
// se non � fisso sull'asse, inserisco le copie ruotate
if ( ! bPrevOnAx) {
for ( int i = 1 ; i <= nStep ; ++i) {
ptP.Rotate( ptAx, vtAx, dCosStepRot, dSinStepRot) ;
@@ -2623,7 +2626,7 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
bool bOnAx = bOnlyRev && DistPointLine( ptP, ptAx, vtAx, 1, false).IsSmall() ;
// ciclo sugli step
for ( int i = 1 ; i <= nStep ; ++i) {
// se non è fisso sull'asse, inserisco le copie ruotate
// se non � fisso sull'asse, inserisco le copie ruotate
if ( ! bOnAx) {
ptP.Rotate( ptAx, vtAx, dCosStepRot, dSinStepRot) ;
if ( ! bOnlyRev)
@@ -2632,8 +2635,8 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
return false ;
++ nV ;
}
// per i controlli già fatti non è possibile avere contemp. prec e corr su asse
// se il precedente è sull'asse, aggiungo un solo triangolo
// per i controlli gi� fatti non � possibile avere contemp. prec e corr su asse
// se il precedente � sull'asse, aggiungo un solo triangolo
if ( bPrevOnAx) {
nIdV[0] = nVPrevOnAx ;
nIdV[1] = nV ;
@@ -2641,7 +2644,7 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
if ( AddTriangle( nIdV) == SVT_NULL)
return false ;
}
// se il corrente è sull'asse, aggiungo un solo triangolo
// se il corrente � sull'asse, aggiungo un solo triangolo
else if ( bOnAx) {
nIdV[0] = nV - ( nStep + 2) + i ;
nIdV[1] = nIdV[0] + 1 ;
@@ -2661,8 +2664,8 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
}
// se rivoluzione completa, aggiungo i due triangoli di chiusura
if ( bFullRev) {
// per i controlli già fatti non è possibile avere contemp. prec e corr su asse
// se il precedente è sull'asse, aggiungo un solo triangolo
// per i controlli gi� fatti non � possibile avere contemp. prec e corr su asse
// se il precedente � sull'asse, aggiungo un solo triangolo
if ( bPrevOnAx) {
nIdV[0] = nVPrevOnAx ;
nIdV[1] = nV - nStep ;
@@ -2670,7 +2673,7 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
if ( AddTriangle( nIdV) == SVT_NULL)
return false ;
}
// se il corrente è sull'asse, aggiungo un solo triangolo
// se il corrente � sull'asse, aggiungo un solo triangolo
else if ( bOnAx) {
nIdV[0] = nV - 1 ;
nIdV[1] = nV - ( nStep + 1) ;
@@ -2693,7 +2696,7 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
// altrimenti ultimo punto di polilinea chiusa
if ( bClosed) {
for ( int i = 1 ; i <= nStep ; ++i) {
// non devo aggiungere i vertici, perchè coincidono con quelli iniziali
// non devo aggiungere i vertici, perch� coincidono con quelli iniziali
// aggiungo triangolo in basso a sinistra
nIdV[0] = nV - nStep + i - 1 ; nIdV[1] = nV - nStep + i ; nIdV[2] = i ;
if ( AddTriangle( nIdV) == SVT_NULL)
@@ -2729,7 +2732,7 @@ SurfTriMesh::AddBiTriangle( const int nIdVert[4])
// | |
// 1 -> 2
int nIdV[3] ;
// se la diagonale 0->2 è uguale o più corta della 1->3
// se la diagonale 0->2 � uguale o pi� corta della 1->3
if ( SqDist( m_vVert[nIdVert[0]].ptP, m_vVert[nIdVert[2]].ptP) <=
SqDist( m_vVert[nIdVert[1]].ptP, m_vVert[nIdVert[3]].ptP) + EPS_SMALL) {
// triangolo 0->1->2
@@ -2791,14 +2794,14 @@ SurfTriMesh::DoCompacting( double dTol)
}
// recupero la posizione geometrica del vertice
Point3d ptP = m_vVert[nId].ptP ;
// se non c'è già un vertice con la stessa posizione lo inserisco nel grid
// se non c'� gi� un vertice con la stessa posizione lo inserisco nel grid
int nAliasId ;
if ( ! VertGrid.Find( ptP, dTol, nAliasId)) {
VertGrid.InsertPoint( ptP, nId) ;
// salvo l'Id nel vettore di reindirizzo
vVId.push_back( nId) ;
}
// c'è un vertice coincidente
// c'� un vertice coincidente
else {
// salvo l'Id alias nel vettore di reindirizzo
vVId.push_back( nAliasId) ;
@@ -2818,7 +2821,7 @@ SurfTriMesh::DoCompacting( double dTol)
// salto i triangoli cancellati
if ( vOId[0] == SVT_DEL)
continue ;
// verifico la validità degli indici
// verifico la validit� degli indici
if ( vOId[0] < 0 || vOId[0] >= nVIdSize ||
vOId[1] < 0 || vOId[1] >= nVIdSize ||
vOId[2] < 0 || vOId[2] >= nVIdSize)
@@ -2890,7 +2893,7 @@ SurfTriMesh::DoSewing( const ISurfTriMesh& stmOther, const Frame3d& frOther)
Point3d ptOP = pOther->m_vVert[nOId].ptP ;
// la porto nel riferimento della prima superficie
ptOP.ToGlob( frOther) ;
// se non c'è già un vertice con la stessa posizione lo inserisco
// se non c'� gi� un vertice con la stessa posizione lo inserisco
int nNewId ;
if ( ! VertGrid.Find( ptOP, 2 * EPS_SMALL, nNewId)) {
if ( ( nNewId = AddVertex( ptOP)) == SVT_NULL)
@@ -2912,7 +2915,7 @@ SurfTriMesh::DoSewing( const ISurfTriMesh& stmOther, const Frame3d& frOther)
// salto i triangoli cancellati
if ( vOId[0] == SVT_DEL)
continue ;
// verifico la validità degli indici
// verifico la validit� degli indici
if ( vOId[0] < 0 || vOId[0] >= nVIdSize ||
vOId[1] < 0 || vOId[1] >= nVIdSize ||
vOId[2] < 0 || vOId[2] >= nVIdSize)
@@ -2964,7 +2967,7 @@ SurfTriMesh::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
// verifico lo stato
if ( m_nStatus != OK)
return false ;
// verifico validità del frame
// verifico validit� del frame
if ( frRef.GetType() == Frame3d::ERR)
return false ;
// assegno il box nel riferimento
@@ -3010,7 +3013,7 @@ SurfTriMesh::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng,
if ( m_nStatus != OK)
return false ;
// verifico validità dell'asse di rotazione
// verifico validit� dell'asse di rotazione
if ( vtAx.IsSmall())
return false ;
@@ -3077,7 +3080,7 @@ SurfTriMesh::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double
bool bRecalc = ( abs( dCoeffX) < EPS_ZERO || abs( dCoeffY) < EPS_ZERO || abs( dCoeffZ) < EPS_ZERO) ;
for ( int i = 0 ; i < GetTriangleSize() ; ++ i) {
if ( m_vTria[i].nIdVert[0] != SVT_DEL) {
// se c'è mirror, devo invertire la faccia
// se c'� mirror, devo invertire la faccia
if ( bMirror)
InvertTriangle( i) ;
// aggiorno la normale
@@ -3099,7 +3102,7 @@ SurfTriMesh::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double
bool
SurfTriMesh::InvertTriangle( int nT)
{
// controllo validità triangolo
// controllo validit� triangolo
if ( m_vTria[nT].nIdVert[0] == SVT_DEL)
return true ;
// scambio di due vertici
@@ -3115,10 +3118,10 @@ SurfTriMesh::InvertTriangle( int nT)
bool
SurfTriMesh::CalcTriangleNormal( int nT)
{
// controllo validità triangolo
// controllo validit� triangolo
if ( m_vTria[nT].nIdVert[0] == SVT_DEL)
return true ;
// controllo validità vertici riferiti dal triangolo
// controllo validit� vertici riferiti dal triangolo
if ( m_vTria[nT].nIdVert[0] < 0 ||
m_vTria[nT].nIdVert[0] >= GetVertexSize() ||
m_vVert[m_vTria[nT].nIdVert[0]].nIdTria == SVT_DEL ||
@@ -3148,7 +3151,7 @@ SurfTriMesh::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
if ( m_nStatus != OK)
return false ;
// verifico validità del piano di specchiatura
// verifico validit� del piano di specchiatura
if ( vtNorm.IsSmall())
return false ;
@@ -3182,7 +3185,7 @@ SurfTriMesh::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d&
if ( m_nStatus != OK)
return false ;
// verifico validità dei parametri
// verifico validit� dei parametri
if ( vtNorm.IsSmall() || vtDir.IsSmall())
return false ;
@@ -3215,7 +3218,7 @@ SurfTriMesh::ToGlob( const Frame3d& frRef)
if ( m_nStatus != OK)
return false ;
// verifico validità del frame
// verifico validit� del frame
if ( frRef.GetType() == Frame3d::ERR)
return false ;
@@ -3247,7 +3250,7 @@ SurfTriMesh::ToLoc( const Frame3d& frRef)
if ( m_nStatus != OK)
return false ;
// verifico validità del frame
// verifico validit� del frame
if ( frRef.GetType() == Frame3d::ERR)
return false ;
@@ -3279,11 +3282,11 @@ SurfTriMesh::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
if ( m_nStatus != OK)
return false ;
// verifico validità dei frame
// verifico validit� dei frame
if ( frOri.GetType() == Frame3d::ERR || frDest.GetType() == Frame3d::ERR)
return false ;
// se i due riferimenti coincidono, non devo fare alcunché
// se i due riferimenti coincidono, non devo fare alcunch�
if ( AreSameFrame( frOri, frDest))
return true ;
@@ -3550,7 +3553,7 @@ SurfTriMesh::Cut( const Plane3d& plPlane, bool bSaveOnEq)
bool bModif = false ;
// Setto i triangoli come né fuori né dentro.
// Setto i triangoli come n� fuori n� dentro.
int nTriaNum = GetTriangleSize() ;
for ( int nT = 0 ; nT < nTriaNum ; ++ nT) {
m_vTria[nT].nTempPart = 0 ;
@@ -3644,7 +3647,7 @@ SurfTriMesh::ResetHashGrids3d( void) const
bool
SurfTriMesh::VerifyHashGrids3d( void) const
{
// se già calcolato, non devo fare altro
// se gi� calcolato, non devo fare altro
if ( m_pHGrd3d != nullptr)
return true ;
// alloco
@@ -3688,7 +3691,7 @@ SurfTriMesh::ResetPointGrid3d( void) const
bool
SurfTriMesh::VerifyPointGrid3d( void) const
{
// Se già calcolato, non devo fare altro
// Se gi� calcolato, non devo fare altro
if ( m_pPGrd3d != nullptr)
return true ;
// Alloco
@@ -3754,7 +3757,7 @@ SurfTriMesh::VerifyConnection( void) const
// ciclo sui triangoli
m_nParts = 0 ;
for ( int i = 0 ; i < int( m_vTria.size()) ; ++ i) {
// salto triangoli cancellati o già assegnati
// salto triangoli cancellati o gi� assegnati
if ( m_vTria[i].nIdVert[0] == SVT_DEL ||
m_vTria[i].nPart != SVT_NULL)
continue ;
SurfTriMesh.h
+6 -5
View File
@@ -211,10 +211,11 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp) override
{ m_nTempProp = nProp ; }
int GetTempProp( void) const override
{ return m_nTempProp ; }
void SetTempProp( int nProp, int nPropInd = 0) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd = 0) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
public : // ISurf
bool IsSimple( void) const override
@@ -431,7 +432,7 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
TRIAVECTOR m_vTria ; // vettore dei triangoli
INTVECTOR m_vFacet ; // vettore delle sfaccettature
mutable int m_nTimeStamp ; // orologio locale
int m_nTempProp ; // propriet� temporanea
int m_nTempProp[2] ; // vettore propriet� temporanee
int m_nMaxTFlag ; // massimo valore dei TFlag dei triangoli
mutable int m_nParts ; // numero di parti connesse (-1 se da calcolare)
mutable HashGrids3d* m_pHGrd3d ; // Hash Grid 3d nel suo riferimento
VolZmap.cpp
+7 -3
View File
@@ -35,7 +35,7 @@ GEOOBJ_REGISTER( VOL_ZMAP, NGE_V_ZMP, VolZmap) ;
//----------------------------------------------------------------------------
VolZmap::VolZmap(void)
: m_nStatus( TO_VERIFY), m_nMapNum( 0), m_nNumBlock( 0), m_nConnectedCompoCount( 0), m_dStep( 10.0),
m_nVoxNumPerBlock( N_VOXBLOCK), m_nDexVoxRatio( 1), m_nShape( GENERIC), m_nTempProp( 0), m_Tool( true)
m_nVoxNumPerBlock( N_VOXBLOCK), m_nDexVoxRatio( 1), m_nShape( GENERIC), m_Tool( true)
{
for ( int i = 0 ; i < N_MAPS ; ++ i) {
m_nNx[i] = 0 ;
@@ -45,6 +45,8 @@ VolZmap::VolZmap(void)
m_dMaxZ[i] = 0 ;
m_nFracLin[i] = 0 ;
}
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
m_Tool.SetTolerances( LIN_TOL_STD, ANG_TOL_APPROX_DEG) ;
}
@@ -72,7 +74,8 @@ VolZmap::Clear( void)
m_Values[i].clear() ;
}
m_dStep = EPS_SMALL ;
m_nTempProp = 0 ;
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
m_Tool.Clear() ;
// imposto ricalcolo della grafica
m_OGrMgr.Reset() ;
@@ -138,7 +141,8 @@ VolZmap::CopyFrom( const VolZmap& vzmSrc)
m_dStep = vzmSrc.m_dStep ;
m_nStatus = vzmSrc.m_nStatus ;
m_nTempProp = vzmSrc.m_nTempProp ;
m_nTempProp[0] = vzmSrc.m_nTempProp[0] ;
m_nTempProp[1] = vzmSrc.m_nTempProp[1] ;
// dimensiono membri legati ai blocchi
m_BlockToUpdate = vzmSrc.m_BlockToUpdate ;
VolZmap.h
+6 -5
View File
@@ -60,10 +60,11 @@ class VolZmap : public IVolZmap, public IGeoObjRW
{ return m_OGrMgr.GetObjGraphics() ; }
const IObjGraphics* GetObjGraphics( void) const override
{ return m_OGrMgr.GetObjGraphics() ; }
void SetTempProp( int nProp) override
{ m_nTempProp = nProp ; }
int GetTempProp( void) const override
{ return m_nTempProp ; }
void SetTempProp( int nProp, int nPropInd = 0) override
{ if ( nPropInd >= 0 && nPropInd < 2)
m_nTempProp[nPropInd] = nProp ; }
int GetTempProp( int nPropInd = 0) const override
{ return (( nPropInd >= 0 && nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
public : // IVolZmap
bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -445,7 +446,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
private :
ObjGraphicsMgr m_OGrMgr ; // gestore grafica dell'oggetto
Status m_nStatus ; // stato
int m_nTempProp ; // proprietà temporanea
int m_nTempProp[2] ; // vettore proprietà temporanee
double m_dStep ; // passo delle griglie
int m_nMapNum ; // numero di griglie ( 1 o 3)
Frame3d m_MapFrame ; // riferimento intrinseco dello Zmap