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

EgtGeomKernel :

Browse Source 
- aggiustamenti alla classe ExtDimension
This commit is contained in:
Daniele Bariletti
2023-04-14 09:43:14 +02:00
parent bde7ff1e5c
commit bca419ad63
2 changed files with 219 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ExtDimension.cpp
+215 -240
View File
@@ -50,7 +50,7 @@ GEOOBJ_REGISTER( EXT_DIMENSION, NGE_E_DIM, ExtDimension ) ;
//----------------------------------------------------------------------------
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_bLenIsMM( true), m_nDecDigit( STD_DECDIGIT), m_sFont( STD_FONT), m_dTextHeight( STD_TEXTHEIGHT)
{
m_nTempProp[0] = 0 ;
m_nTempProp[1] = 0 ;
@@ -105,7 +105,7 @@ ExtDimension::SetLinear( const Point3d& ptP1, const Point3d& ptP2, const Point3d
}
if ( ! m_vtDir.Normalize())
return false ;
// punti estremi della linea di misura ed esterni delle linee di estremit�
// punti estremi della linea di misura ed esterni delle linee di estremità
Vector3d vtLine1 = m_vtDir ;
vtLine1.Rotate( m_vtN, 0, 1) ;
Vector3d vtLine2 = vtLine1 ;
@@ -136,48 +136,37 @@ ExtDimension::SetLinear( const Point3d& ptP1, const Point3d& ptP2, const Point3d
//----------------------------------------------------------------------------
bool
ExtDimension::SetAngular( const Point3d& ptP1, const Point3d& ptP0, const Point3d& ptP2, const Point3d& ptPos,
ExtDimension::SetAngular( const Point3d& ptP1, const Point3d& ptCen, const Point3d& ptP2, const Point3d& ptPos,
const Vector3d& vtN, const string& sText)
{ // ptP0 è il vertice dell'angolo e l'ordine di inserimento dei punti nella funzione è: punto1, vertice, punto2
{ // ptCen è il vertice dell'angolo e l'ordine di inserimento dei punti nella funzione è: punto1, vertice, punto2
// il punto m_ptP6 viene utilizzato per il centro anziché come estremo della quotatura, che verrà calcolata come specchiatura di m_ptP5
// dichiaro quota non ancora determinata
m_nType = DT_NONE ;
// verifico la definizione del versore normale
m_vtN = vtN ;
if ( ! m_vtN.Normalize())
return false ;
// porto i punti nel piano definito da ptPos (che è stato proiettato sul piano XY del frLoc) e vtN
m_ptPos = ptPos ;
m_ptP0 = ptP0 - ( ptP0 - m_ptPos) * m_vtN * m_vtN ;
m_ptP1 = ptP1 - ( ptP1 - m_ptPos) * m_vtN * m_vtN ;
m_ptP2 = ptP2 - ( ptP2 - m_ptPos) * m_vtN * m_vtN ;
// porto i punti nel piano definito da ptP1 e vtN
m_ptP1 = ptP1 ;
m_ptP6 = ptCen - ( ptCen - m_ptP1) * m_vtN * m_vtN ;
m_ptPos = ptPos - ( ptPos - m_ptP1) * m_vtN * m_vtN ;
m_ptP2 = ptP2 - ( ptP2 - m_ptP1) * m_vtN * m_vtN ;
// verifico che i punti di misura non siano coincidenti
if ( AreSamePointApprox( m_ptP0, m_ptP1) || AreSamePointApprox( m_ptP0, m_ptP2) || AreSamePointApprox( m_ptP1, m_ptP2))
return false ;
// calcolo le direzioni su cui giacciono i due lati dell'angolo
Vector3d vtLine1 = m_ptP1 - m_ptP0 ;
Vector3d vtLine2 = m_ptP2 - m_ptP0 ;
double dLen1 = vtLine1.Len() ;
double dLen2 = vtLine2.Len() ;
if ( ! vtLine1.Normalize() || ! vtLine2.Normalize())
if ( AreSamePointApprox( m_ptP6, m_ptP1) || AreSamePointApprox( m_ptP6, m_ptP2) || AreSamePointApprox( m_ptP1, m_ptP2))
return false ;
// direzione di riferimento (nel piano perpendicolare a vtN)
m_vtDir = m_ptPos - m_ptP0 ;
m_vtDir = m_ptPos - m_ptP6 ;
double dLenDir = m_vtDir.Len() ;
// controllo se è testo o se è la misura
double dHalfDist ;
double dFactor ;
if ( m_sCalcText.find( IS_MEASURE) != string::npos) {
m_sCalcText = "300.00" ;
dHalfDist = GetTextHalfDist( m_ptPos) ;
double dHalfDist = GetTextHalfDist( m_ptPos) ;
dFactor = 2.5 * dHalfDist ;
m_sCalcText = "" ;
}
else {
dHalfDist = GetTextHalfDist( m_ptPos) ;
double dHalfDist = GetTextHalfDist( m_ptPos) ;
dFactor = 2.5 * dHalfDist ;
}
//allungo m_vtDir se è troppo vicino al centro
@@ -185,25 +174,26 @@ ExtDimension::SetAngular( const Point3d& ptP1, const Point3d& ptP0, const Point3
Vector3d vtDir_n = m_vtDir ;
if ( ! vtDir_n.Normalize())
return false ;
m_ptPos = m_ptP0 + dFactor * vtDir_n ;
m_ptPos = m_ptP6 + dFactor * vtDir_n ;
// ricalcolo m_vtDir
m_vtDir = m_ptPos - m_ptP0 ;
m_vtDir = m_ptPos - m_ptP6 ;
dLenDir = m_vtDir.Len() ;
}
// calcolo le direzioni su cui giacciono i due lati dell'angolo
Vector3d vtLine1 = m_ptP1 - m_ptP6 ;
Vector3d vtLine2 = m_ptP2 - m_ptP6 ;
double dLen1 = vtLine1.Len() ;
double dLen2 = vtLine2.Len() ;
if ( ! vtLine1.Normalize() || ! vtLine2.Normalize())
return false ;
// segnalo se i punti che definiscono i lati sono più lontani dal centro di ptPos
bool bPt1Close = false ;
bool bPt2Close = false ;
if ( dLenDir < dLen1 )
bPt1Close = true ;
if ( dLenDir < dLen2 )
bPt2Close = true ;
m_ptP5 = m_ptP1 + ( dLenDir - dLen1 ) * vtLine1 ;
m_ptP6 = m_ptP2 + ( dLenDir - dLen2 ) * vtLine2 ;
bool bPt1Close = ( dLenDir < dLen1 ? true : false) ;
bool bPt2Close = ( dLenDir < dLen2 ? true : false) ;
m_ptP5 = m_ptP1 + ( dLenDir - dLen1) * vtLine1 ;
Point3d ptP5_bis = m_ptP2 + ( dLenDir - dLen2) * vtLine2 ;
m_ptP3 = m_ptP5 + ( bPt1Close ? - vtLine1 : vtLine1) * m_dExtLineLen ;
m_ptP4 = m_ptP6 + ( bPt2Close ? - vtLine2 : vtLine2) * m_dExtLineLen ;
// assegnazione del testo
m_ptP4 = ptP5_bis + ( bPt2Close ? - vtLine2 : vtLine2) * m_dExtLineLen ;
// assegnazione del testo
m_sText = sText ;
// assegno il tipo
m_nType = DT_ANGULAR ;
@@ -216,36 +206,33 @@ ExtDimension::SetAngular( const Point3d& ptP1, const Point3d& ptP0, const Point3
//----------------------------------------------------------------------------
bool
ExtDimension::SetRadial( const Point3d& ptP0, const Point3d& ptPos, const Vector3d& vtX, const Vector3d& vtN, const string& sText)
{ // ptP0 è il vertice del cerchio e ptPos è un punto sulla circonferenza
ExtDimension::SetRadial( const Point3d& ptCen, const Point3d& ptPos, const Vector3d& vtN, const string& sText)
{ // ptCen è il vertice del cerchio e ptPos è un punto sulla circonferenza
// il punto m_ptP6 viene utilizzato per il centro
// dichiaro quota non ancora determinata
m_nType = DT_NONE ;
// verifico la definizione del versore normale e del versore X
// verifico la definizione del versore normale
m_vtN = vtN ;
m_vtDir = vtX ;
if ( ! m_vtN.Normalize() || ! m_vtDir.Normalize())
if ( ! m_vtN.Normalize())
return false ;
// porto i punti nel piano definito da ptPos (che è stato proiettato sul piano XY del frLoc) e vtN
m_ptPos = ptPos ;
m_ptP0 = ptP0 - ( ptP0 - m_ptPos) * m_vtN * m_vtN ;
m_ptP1 = m_ptP0 ;
m_ptP5 = m_ptP0 ;
m_ptP3 = m_ptP0 ;
// porto i punti nel piano definito da ptCen e vtN
m_ptP6 = ptCen ;
m_ptPos = ptPos - ( ptPos - m_ptP6) * m_vtN * m_vtN ;
m_ptP1 = ptCen ;
m_ptP5 = ptCen ;
m_ptP2 = m_ptPos ;
m_ptP6 = m_ptPos ;
m_ptP4 = m_ptPos ;
// verifico che i punti di misura non siano coincidenti
if ( AreSamePointApprox( m_ptP0, m_ptPos))
// definisco la direzione vtDir
m_vtDir = m_ptPos - m_ptP6 ;
if ( ! m_vtDir.Normalize())
return false ;
// assegnazione del testo
// verifico che i punti di misura non siano coincidenti
if ( AreSamePointApprox( m_ptP6, m_ptPos))
return false ;
// assegnazione del testo
m_sText = sText ;
// assegno il tipo
// assegno il tipo
m_nType = DT_RADIAL ;
// imposto da calcolare
// imposto da calcolare
m_bToCalc = true ;
m_OGrMgr.Reset() ;
@@ -254,40 +241,35 @@ ExtDimension::SetRadial( const Point3d& ptP0, const Point3d& ptPos, const Vector
//----------------------------------------------------------------------------
bool
ExtDimension::SetDiametral( const Point3d& ptP0, const Point3d& ptPos, const Vector3d& vtX, const Vector3d& vtN, const string& sText)
{ // ptP0 è il vertice del cerchio e ptPos è un punto sulla circonferenza
ExtDimension::SetDiametral( const Point3d& ptCen, const Point3d& ptPos, const Vector3d& vtN, const string& sText)
{ // ptCen è il vertice del cerchio e ptPos è un punto sulla circonferenza
// il punto m_ptP6 viene utilizzato per il centro
// dichiaro quota non ancora determinata
m_nType = DT_NONE ;
// verifico la definizione del versore normale e del versore X
// verifico la definizione del versore normale
m_vtN = vtN ;
m_vtDir = vtX ;
if ( ! m_vtN.Normalize() || ! m_vtDir.Normalize())
if ( ! m_vtN.Normalize())
return false ;
// porto i punti nel piano definito da ptPos (che è stato proiettato sul piano XY del frLoc) e vtN
m_ptPos = ptPos ;
m_ptP0 = ptP0 - ( ptP0 - m_ptPos) * m_vtN * m_vtN ;
// porto i punti nel piano definito da ptCen e vtN
m_ptP6 = ptCen ;
m_ptPos = ptPos - ( ptPos - m_ptP6) * m_vtN * m_vtN ;
m_ptP2 = m_ptPos ;
m_ptP6 = m_ptPos ;
m_ptP4 = m_ptPos ;
m_ptP1 = m_ptPos;
//ottengo il punto diametralmente opposto a ptPos
m_ptP1.Mirror( m_ptP0, m_ptPos - m_ptP0) ;
m_ptP1 = m_ptPos ;
m_ptP1.Mirror( m_ptP6, m_ptPos - m_ptP6) ;
m_ptP5 = m_ptP1 ;
m_ptP3 = m_ptP1 ;
// verifico che i punti di misura non siano coincidenti
if ( AreSamePointApprox( m_ptP0, m_ptPos))
// definisco la direzione vtDir
m_vtDir = m_ptPos - m_ptP6 ;
if ( ! m_vtDir.Normalize())
return false ;
// assegnazione del testo
// verifico che i punti di misura non siano coincidenti
if ( AreSamePointApprox( m_ptP6, m_ptPos))
return false ;
// assegnazione del testo
m_sText = sText ;
// assegno il tipo
// assegno il tipo
m_nType = DT_DIAMETRAL ;
// imposto da calcolare
// imposto da calcolare
m_bToCalc = true ;
m_OGrMgr.Reset() ;
@@ -330,7 +312,6 @@ ExtDimension::CopyFrom( const ExtDimension& clSrc)
m_nType = clSrc.m_nType ;
m_vtN = clSrc.m_vtN ;
m_vtDir = clSrc.m_vtDir ;
m_ptP0 = clSrc.m_ptP0 ;
m_ptP1 = clSrc.m_ptP1 ;
m_ptP2 = clSrc.m_ptP2 ;
m_ptP3 = clSrc.m_ptP3 ;
@@ -343,6 +324,7 @@ ExtDimension::CopyFrom( const ExtDimension& clSrc)
m_sCalcText = clSrc.m_sCalcText ;
m_ptCalcPos = clSrc.m_ptCalcPos ;
m_bCalcArrowIn = clSrc.m_bCalcArrowIn ;
m_bCalcTextOn = clSrc.m_bCalcTextOn ;
m_ptCalcP7 = clSrc.m_ptCalcP7 ;
m_ptCalcP8 = clSrc.m_ptCalcP8 ;
m_dExtLineLen = clSrc.m_dExtLineLen ;
@@ -391,7 +373,6 @@ ExtDimension::Dump( string& sOut, bool bMM, const char* szNewLine) const
sOut += GetSubType() + szNewLine ;
sOut += "VN(" + ToString( m_vtN, 3) + ") " + szNewLine ;
sOut += "VD(" + ToString( m_vtDir, 3) + ") " + szNewLine ;
sOut += "P0(" + ToString( GetInUiUnits( m_ptP0, bMM), 3) + ") " + szNewLine ;
sOut += "P1(" + ToString( GetInUiUnits( m_ptP1, bMM), 3) + ") " + szNewLine ;
sOut += "P2(" + ToString( GetInUiUnits( m_ptP2, bMM), 3) + ") " + szNewLine ;
sOut += "P3(" + ToString( GetInUiUnits( m_ptP3, bMM), 3) + ") " + szNewLine ;
@@ -431,8 +412,6 @@ ExtDimension::Save( NgeWriter& ngeOut) const
if ( ! ngeOut.WriteVector( m_vtDir, ";", true))
return false ;
// punti di quotatura
if ( ! ngeOut.WritePoint( m_ptP0, ";"))
return false ;
if ( ! ngeOut.WritePoint( m_ptP1, ";"))
return false ;
if ( ! ngeOut.WritePoint( m_ptP2, ";"))
@@ -485,8 +464,6 @@ ExtDimension::Load( NgeReader& ngeIn)
if ( ! ngeIn.ReadVector( m_vtDir, ";", true))
return false ;
// leggo la prossima linea : punti di quotatura
if ( ! ngeIn.ReadPoint( m_ptP0, ";"))
return false ;
if ( ! ngeIn.ReadPoint( m_ptP1, ";"))
return false ;
if ( ! ngeIn.ReadPoint( m_ptP2, ";"))
@@ -530,7 +507,6 @@ ExtDimension::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
// eventuale ricalcolo
Update() ;
switch ( m_nType) {
// se lineare
case DT_LINEAR: {
b3Loc.Set( m_ptP1) ;
@@ -545,9 +521,10 @@ ExtDimension::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
b3Loc.Add( b3Text) ;
return true;
}
// se radiale
case DT_RADIAL: {
b3Loc.Set(m_ptP0) ;
// se radiale o diametrale
case DT_RADIAL:
case DT_DIAMETRAL: {
b3Loc.Set(m_ptP6) ;
b3Loc.Add(m_ptPos) ;
// ingombro del testo
BBox3d b3Text ;
@@ -557,11 +534,12 @@ ExtDimension::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
}
// se angolare
case DT_ANGULAR: {
b3Loc.Set( m_ptP0) ;
b3Loc.Add( m_ptP1) ;
b3Loc.Add( m_ptP2) ;
b3Loc.Add( m_ptP3) ;
b3Loc.Add( m_ptP4) ;
b3Loc.Add( m_ptP5) ;
b3Loc.Set( m_ptP6) ;
b3Loc.Add( m_ptCalcP7) ;
b3Loc.Add( m_ptCalcP8) ;
// ingombro del testo
@@ -612,24 +590,22 @@ ExtDimension::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
b3Ref.Add( b3Text) ;
return true ;
}
case DT_RADIAL: {
// ingombro dei punti (portati nel riferimento passato)
Point3d ptFrP0 = m_ptP0 ;
ptFrP0.ToGlob( frRef) ;
b3Ref.Set( ptFrP0) ;
case DT_RADIAL:
case DT_DIAMETRAL: {
// ingombro dei punti (portati nel riferimento passato)
Point3d ptFrP6 = m_ptP6 ;
ptFrP6.ToGlob( frRef) ;
b3Ref.Set( ptFrP6) ;
Point3d ptFrPos = m_ptPos ;
ptFrPos.ToGlob( frRef) ;
b3Ref.Set( ptFrPos) ;
// ingombro del testo
// ingombro del testo
BBox3d b3Text ;
if ( GetTextBBox( frRef, b3Text))
b3Ref.Add( b3Text) ;
return true ;
}
case DT_ANGULAR: {
Point3d ptFrP0 = m_ptP0;
ptFrP0.ToGlob( frRef);
b3Ref.Set( ptFrP0);
Point3d ptFrP1 = m_ptP1 ;
ptFrP1.ToGlob( frRef) ;
b3Ref.Add( ptFrP1) ;
@@ -642,6 +618,12 @@ ExtDimension::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
Point3d ptFrP4 = m_ptP4 ;
ptFrP4.ToGlob( frRef) ;
b3Ref.Add( ptFrP4) ;
Point3d ptFrP5 = m_ptP5 ;
ptFrP5.ToGlob( frRef) ;
b3Ref.Add( ptFrP5) ;
Point3d ptFrP6 = m_ptP6;
ptFrP6.ToGlob( frRef);
b3Ref.Set( ptFrP6);
Point3d ptFrP7 = m_ptCalcP7 ;
ptFrP7.ToGlob( frRef) ;
b3Ref.Add( ptFrP7) ;
@@ -668,15 +650,14 @@ ExtDimension::Translate( const Vector3d& vtMove)
m_OGrMgr.Reset() ;
// se valido
if ( m_nType >= DT_LINEAR && m_nType <= DT_ANGULAR) {
m_ptP0.Translate( vtMove) ;
m_ptP1.Translate( vtMove) ;
m_ptP2.Translate( vtMove) ;
m_ptP3.Translate( vtMove) ;
m_ptP4.Translate( vtMove) ;
m_ptP5.Translate( vtMove) ;
m_ptP6.Translate( vtMove) ;
m_ptPos.Translate( vtMove) ;
return true ;
m_ptP1.Translate( vtMove) ;
m_ptP2.Translate( vtMove) ;
m_ptP3.Translate( vtMove) ;
m_ptP4.Translate( vtMove) ;
m_ptP5.Translate( vtMove) ;
m_ptP6.Translate( vtMove) ;
m_ptPos.Translate( vtMove) ;
return true ;
}
else
return false ;
@@ -693,7 +674,6 @@ ExtDimension::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng,
if ( m_nType >= DT_LINEAR && m_nType <= DT_ANGULAR) {
return ( m_vtN.Rotate( vtAx, dCosAng, dSinAng) &&
m_vtDir.Rotate( vtAx, dCosAng, dSinAng) &&
m_ptP0.Rotate( ptAx, vtAx, dCosAng, dSinAng) &&
m_ptP1.Rotate( ptAx, vtAx, dCosAng, dSinAng) &&
m_ptP2.Rotate( ptAx, vtAx, dCosAng, dSinAng) &&
m_ptP3.Rotate( ptAx, vtAx, dCosAng, dSinAng) &&
@@ -728,12 +708,12 @@ ExtDimension::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, doubl
if ( ! m_vtN.Normalize() )
return false ;
// scalo i punti di base
if ( ! m_ptP0.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ))
return false ;
if ( ! m_ptP1.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ))
return false ;
if ( ! m_ptP2.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ))
return false ;
if ( ! m_ptP6.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ))
return false ;
if ( ! m_ptPos.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ))
return false ;
// ricalcolo completamente la quota
@@ -741,12 +721,12 @@ ExtDimension::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, doubl
case DT_LINEAR:
return SetLinear( m_ptP1, m_ptP2, m_ptPos, m_vtN, m_vtDir, m_sText) ;
case DT_RADIAL:
return SetRadial( m_ptP0, m_ptPos, m_vtDir, m_vtN, m_sText) ;
return SetRadial( m_ptP6, m_ptPos, m_vtN, m_sText) ;
case DT_ANGULAR:
return SetAngular( m_ptP1, m_ptP0, m_ptP2, m_ptPos, m_vtN, m_sText) ;
return SetAngular( m_ptP1, m_ptP6, m_ptP2, m_ptPos, m_vtN, m_sText) ;
default:
return false ;
}
}
}
else
return false ;
@@ -764,14 +744,12 @@ ExtDimension::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
m_OGrMgr.Reset() ;
// se valido
if ( m_nType >= DT_LINEAR && m_nType <= DT_ANGULAR) {
// eseguo il mirror dei versori
// eseguo il mirror dei versori
if ( ! m_vtN.Mirror( vtNorm))
return false ;
if ( ! m_vtDir.Mirror( vtNorm))
return false ;
// eseguo il mirror dei punti
if ( ! m_ptP0.Mirror( ptOn, vtNorm))
return false ;
// eseguo il mirror dei punti
if ( ! m_ptP1.Mirror( ptOn, vtNorm))
return false ;
if ( ! m_ptP2.Mirror( ptOn, vtNorm))
@@ -814,12 +792,12 @@ ExtDimension::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d
if ( ! m_vtN.Normalize())
return false ;
// eseguo scorrimento dei punti di base
if ( ! m_ptP0.Shear( ptOn, vtNorm, vtDir, dCoeff))
return false ;
if ( ! m_ptP1.Shear( ptOn, vtNorm, vtDir, dCoeff))
return false ;
if ( ! m_ptP2.Shear( ptOn, vtNorm, vtDir, dCoeff))
return false ;
if ( ! m_ptP6.Shear( ptOn, vtNorm, vtDir, dCoeff))
return false ;
if ( ! m_ptPos.Shear( ptOn, vtNorm, vtDir, dCoeff))
return false ;
// ricalcolo completamente la quota
@@ -827,12 +805,12 @@ ExtDimension::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d
case DT_LINEAR:
return SetLinear( m_ptP1, m_ptP2, m_ptPos, m_vtN, m_vtDir, m_sText) ;
case DT_RADIAL:
return SetRadial(m_ptP0, m_ptPos, m_vtDir, m_vtN, m_sText) ;
return SetRadial(m_ptP6, m_ptPos, m_vtN, m_sText) ;
case DT_ANGULAR:
return SetAngular( m_ptP1, m_ptP0, m_ptP2, m_ptPos, m_vtN, m_sText) ;
return SetAngular( m_ptP1, m_ptP6, m_ptP2, m_ptPos, m_vtN, m_sText) ;
default:
return false ;
}
}
}
else
return false ;
@@ -851,12 +829,11 @@ ExtDimension::ToGlob( const Frame3d& frRef)
// imposto ricalcolo
m_bToCalc = true ;
m_OGrMgr.Reset() ;
// se valido
// se valido
if ( m_nType >= DT_LINEAR && m_nType <= DT_ANGULAR) {
// trasformo punto e versori
// trasformo punto e versori
return ( m_vtN.ToGlob( frRef) &&
m_vtDir.ToGlob( frRef) &&
m_ptP0.ToGlob( frRef) &&
m_ptP1.ToGlob( frRef) &&
m_ptP2.ToGlob( frRef) &&
m_ptP3.ToGlob( frRef) &&
@@ -884,10 +861,9 @@ ExtDimension::ToLoc( const Frame3d& frRef)
m_OGrMgr.Reset() ;
// se valido
if ( m_nType >= DT_LINEAR && m_nType <= DT_ANGULAR) {
// trasformo punto e versori
// trasformo punto e versori
return ( m_vtN.ToLoc( frRef) &&
m_vtDir.ToLoc( frRef) &&
m_ptP0.ToLoc( frRef) &&
m_ptP1.ToLoc( frRef) &&
m_ptP2.ToLoc( frRef) &&
m_ptP3.ToLoc( frRef) &&
@@ -904,10 +880,10 @@ ExtDimension::ToLoc( const Frame3d& frRef)
bool
ExtDimension::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
{
// 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 ;
// imposto ricalcolo
@@ -918,7 +894,6 @@ ExtDimension::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
// trasformo punto e versori
return ( m_vtN.ToGlob( frOri) && m_vtN.ToLoc( frDest) &&
m_vtDir.ToGlob( frOri) && m_vtDir.ToLoc( frDest) &&
m_ptP0.ToGlob( frOri) && m_ptP0.ToLoc( frDest) &&
m_ptP1.ToGlob( frOri) && m_ptP1.ToLoc( frDest) &&
m_ptP2.ToGlob( frOri) && m_ptP2.ToLoc( frDest) &&
m_ptP3.ToGlob( frOri) && m_ptP3.ToLoc( frDest) &&
@@ -937,7 +912,6 @@ ExtDimension::Update( void) const
{// se ricalcolo non richiesto, esco
if ( ! m_bToCalc)
return true ;
switch ( m_nType) {
// se quota lineare, radiale o diametrale
case DT_LINEAR: {
@@ -953,7 +927,7 @@ ExtDimension::Update( void) const
// semidistanza di interruzione
double dHalfDist = GetTextHalfDist( m_ptCalcPos) ;
// lunghezza della linea di misura
double dLen = ( m_ptP6 - m_ptP5 ).Len() ;
double dLen = ( m_ptP6 - m_ptP5).Len() ;
// determino come orientare le frecce e dove mettere il testo
if ( dLen - 2 * m_dArrowLen >= 2 * dHalfDist) {
m_bCalcArrowIn = true ;
@@ -972,12 +946,12 @@ ExtDimension::Update( void) const
m_ptCalcP7 = m_ptP5 - m_vtDir * 2 * m_dArrowLen ;
m_ptCalcP8 = m_ptP6 + m_vtDir * 2 * m_dArrowLen ;
// metto la quotatura dal lato di ptPos
if ( ( m_ptPos - m_ptCalcP7).SqLen() <= ( m_ptPos - m_ptCalcP8).SqLen() )
if ( ( m_ptPos - m_ptCalcP7).SqLen() <= ( m_ptPos - m_ptCalcP8).SqLen())
m_ptCalcPos = m_ptCalcP7 - m_vtDir * dHalfDist ;
else
m_ptCalcPos = m_ptCalcP8 + m_vtDir * dHalfDist ;
}
// dichiaro ricalcolo eseguito
// dichiaro ricalcolo eseguito
m_bToCalc = false ;
return true ;
}
@@ -990,28 +964,33 @@ ExtDimension::Update( void) const
dVal = Dist( m_ptP1, m_ptP2) * ( m_bLenIsMM ? 1 : 1. / ONEINCH ) ;
string sVal = ToString( dVal, m_nDecDigit) ;
if ( m_nType == DT_RADIAL )
sVal = 'R' + sVal ;
sVal = "R " + sVal ;
else if ( m_nType == DT_DIAMETRAL)
sVal = u8"\u00D8" + sVal ;
sVal = u8"\u00D8 " + sVal ;
ReplaceString( m_sCalcText, IS_MEASURE, sVal) ;
}
// punto di inserimento del testo
m_ptCalcPos = ( m_ptP5 + m_ptP6) / 2 ;
m_ptCalcPos = ( m_ptP5 + m_ptP2) / 2 ;
// alzo il testo dalla linea di misura
BBox3d b3Text ;
if ( ! GetTextMyBBox( m_ptCalcPos, b3Text) && ! b3Text.IsEmpty())
return false ;
double dHeight = b3Text.GetMax().y - b3Text.GetMin().y ;
Vector3d vtPerpDir = m_ptPos - m_ptP0 ;
vtPerpDir.Normalize() ;
Vector3d vtPerpDir = m_ptPos - m_ptP6 ;
if ( ! vtPerpDir.Normalize())
return false ;
// calcolo il frame dell'arco per valutare la posizione del testo
Frame3d frRef ;
if ( ! frRef.Set( m_ptP6, m_vtN))
return false ;
double dAngDeg = 0 ;
if ( ! vtPerpDir.GetAngle( m_vtDir,dAngDeg) || ! vtPerpDir.Rotate(m_vtN, ( dAngDeg < 90 ? 90 : - 90)))
if ( ! m_vtDir.GetAngle( frRef.VersX(), dAngDeg) || ! vtPerpDir.Rotate(m_vtN, ( dAngDeg < 90 ? 90 : -90 )) )
return false ;
m_ptCalcPos = m_ptCalcPos + 0.6 * dHeight * vtPerpDir ;
// semidistanza di interruzione
double dHalfDist = GetTextHalfDist( m_ptCalcPos) ;
// lunghezza della linea di misura
double dLen = ( m_ptP6 - m_ptP5).Len() ;
double dLen = ( m_ptP5 - m_ptP2).Len() ;
// determino come orientare le frecce e dove mettere il testo
if ( dLen - 2 * m_dArrowLen >= 2 * dHalfDist) {
m_bCalcArrowIn = true ;
@@ -1024,15 +1003,16 @@ ExtDimension::Update( void) const
m_bCalcArrowIn = false ;
m_bCalcTextOn = true ;
m_ptCalcP7 = m_ptP5 - m_vtDir * 2 * m_dArrowLen ;
m_ptCalcP8 = m_ptP6 + m_vtDir * 2 * m_dArrowLen ;
m_ptCalcP8 = m_ptP2 + m_vtDir * 2 * m_dArrowLen ;
}
// stanno fuori sia le frecce sia il testo
else {
m_bCalcArrowIn = false ;
m_bCalcTextOn = false ;
// metto la quotatura dal lato di ptPos
Vector3d vtRad = m_ptPos - m_ptP0 ;
vtRad.Normalize() ;
Vector3d vtRad = m_ptPos - m_ptP6 ;
if ( ! vtRad.Normalize())
return false ;
m_ptCalcPos = m_ptPos + vtRad * ( dHalfDist + 2 * m_dArrowLen) ;
}
// dichiaro ricalcolo eseguito
@@ -1047,18 +1027,23 @@ ExtDimension::Update( void) const
// calcolo gli angoli tra m_ptPos e i due punti che identificano i lati dell'angolo
// per capire se sto calcolando l'angolo interno o esterno
double dAngDeg, dAngDeg1, dAngDeg2 = 0 ;
Vector3d vtLine1 = m_ptP1 - m_ptP0 ;
Vector3d vtLine2 = m_ptP2 - m_ptP0 ;
Vector3d vtLine3 = m_ptPos - m_ptP0 ;
Vector3d vtLine1 = m_ptP1 - m_ptP6 ;
Vector3d vtLine2 = m_ptP2 - m_ptP6 ;
Vector3d vtLine3 = m_ptPos - m_ptP6 ;
if ( ! vtLine1.GetAngle(vtLine2, dAngDeg) || ! vtLine1.GetAngle(vtLine3, dAngDeg1) || ! vtLine2.GetAngle(vtLine3, dAngDeg2))
return false ;
if ( dAngDeg < dAngDeg1 + dAngDeg2 - EPS_SMALL || dAngDeg > dAngDeg1 + dAngDeg2 + EPS_SMALL)
dAngDeg = 360 - dAngDeg ;
string sAngDeg = ToString( dAngDeg, m_nDecDigit) ;
ReplaceString( m_sCalcText, IS_MEASURE, sAngDeg + "°") ;
// calcolo ptP5_bis
double dLen2 = vtLine2.Len() ;
if ( ! vtLine2.Normalize())
return false ;
Point3d ptP5_bis = m_ptP2 + ( m_vtDir.Len() - dLen2) * vtLine2 ;
//calcolo l'arco su cui metterò la misura
PtrOwner<CurveArc> pCrvPos( CreateBasicCurveArc()) ;
if ( IsNull( pCrvPos) || ! pCrvPos->Set3P(m_ptP6, m_ptPos, m_ptP5, false))
if ( IsNull( pCrvPos) || ! pCrvPos->Set3P(ptP5_bis, m_ptPos, m_ptP5, false))
return false ;
// punto di inserimento del testo
pCrvPos->GetMidPoint( m_ptCalcPos) ;
@@ -1068,31 +1053,16 @@ ExtDimension::Update( void) const
double dLen = 0 ;
if ( ! pCrvPos->GetLength( dLen))
return false ;
// calcolo anche lo spazio ad una distanza dal centro maggiorata
// calcolo lo spazio anche ad una distanza dal centro maggiorata
double dLenPos = 0 ;
double dDist = Dist( m_ptCalcPos, m_ptP0) ;
double dDist = Dist( m_ptCalcPos, m_ptP6) ;
dLenPos = dDist * dAngDeg * DEGTORAD ;
// // Creo la curva per trovare le code delle frecce se fuori
// PtrOwner<CurveArc> pCrvPosExt(pCrvPos->Clone()) ;
//// controllo che l'arco esplementare sia più lungo della somma delle frecce
// double dLenEsp = dDist * ( 360 - dAngDeg) * DEGTORAD;
// if ( dLenEsp > 4 * m_dArrowLen ) {
// pCrvPosExt->ExtendStartByLen( 2 * m_dArrowLen) ;
// pCrvPosExt->ExtendEndByLen( 2 * m_dArrowLen) ;
// }
//// altrimenti mi allungo solo della lunghezza della punta della freccia
// else {
// pCrvPosExt->ExtendStartByLen( m_dArrowLen) ;
// pCrvPosExt->ExtendEndByLen( m_dArrowLen) ;
// }
// determino come orientare le frecce e dove mettere il testo
double dU ;
// determino come orientare le frecce e dove mettere il testo
// frecce e testo dentro
if ( dLen - 2 * m_dArrowLen >= 2 * dHalfDist) {
m_bCalcArrowIn = true ;
m_bCalcTextOn = true ;
double dU ;
pCrvPos->GetParamAtLength( dLen / 2. + dHalfDist, dU) ;
pCrvPos->GetPointD1D2( dU, ICurve::FROM_MINUS, m_ptCalcP7) ;
pCrvPos->GetParamAtLength( dLen / 2. - dHalfDist, dU) ;
@@ -1103,14 +1073,13 @@ ExtDimension::Update( void) const
else if ( dLen > 2 * dHalfDist || ( dLen < 2 * dHalfDist && dLenPos > 2 * dHalfDist)) {
m_bCalcArrowIn = false ;
m_bCalcTextOn = true ;
double dU ;
pCrvPos->GetParamAtLength( dLen / 2. + dHalfDist, dU) ;
pCrvPos->GetPointD1D2( dU, ICurve::FROM_MINUS, m_ptCalcP7) ;
pCrvPos->GetParamAtLength( dLen / 2. - dHalfDist, dU) ;
pCrvPos->GetPointD1D2( dU, ICurve::FROM_MINUS, m_ptCalcP8) ;
//pCrvPosExt->GetStartPoint( m_ptCalcP8) ;
//pCrvPosExt->GetEndPoint( m_ptCalcP7) ;
if ( dLen < 2 * dHalfDist) {
m_ptCalcPos += ( m_ptCalcPos - m_ptP0) ;
m_ptCalcPos += ( m_ptCalcPos - m_ptP6) ;
m_bCalcTextOn = false ;
}
}
@@ -1118,11 +1087,9 @@ ExtDimension::Update( void) const
else {
m_bCalcArrowIn = false ;
m_bCalcTextOn = false ;
//pCrvPosExt->GetStartPoint( m_ptCalcP8) ;
//pCrvPosExt->GetEndPoint( m_ptCalcP7) ;
vtLine1.Normalize() ;
vtLine2.Normalize() ;
if ( Dist( m_ptPos, m_ptP5) < Dist( m_ptPos, m_ptP6)) {
if ( ! vtLine1.Normalize())
return false ;
if ( Dist( m_ptPos, m_ptP5) < Dist( m_ptPos, ptP5_bis)) {
Vector3d vtDirEnd ;
pCrvPos->GetEndDir( vtDirEnd) ;
m_ptCalcPos = m_ptP5 + dHalfDist * ( vtDirEnd + vtLine1) ;
@@ -1130,7 +1097,7 @@ ExtDimension::Update( void) const
else {
Vector3d vtDirStart ;
pCrvPos->GetStartDir( vtDirStart) ;
m_ptCalcPos = m_ptP6 + dHalfDist * ( - vtDirStart + vtLine2) ;
m_ptCalcPos = ptP5_bis + dHalfDist * ( - vtDirStart + vtLine2) ;
}
}
// dichiaro ricalcolo eseguito
@@ -1159,10 +1126,16 @@ ExtDimension::GetMidPoint( Point3d& ptMid) const
}
// se quota angolare
case DT_ANGULAR : {
PtrOwner<CurveArc> pCrvPos( CreateBasicCurveArc()) ;
if ( ! pCrvPos->Set3P( m_ptP6, m_ptPos, m_ptP5, false))
// calcolo ptP5_bis
Vector3d vtLine2 = m_ptP2 - m_ptP6 ;
double dLen2 = vtLine2.Len() ;
if ( ! vtLine2.Normalize())
return false ;
pCrvPos->GetMidPoint( ptMid) ;
Point3d ptP5_bis = m_ptP2 + ( m_vtDir.Len() - dLen2) * vtLine2 ;
Vector3d vtMid = ( ptP5_bis + m_ptP5) / 2 - m_ptP6 ;
if ( ! vtMid.Normalize())
return false ;
ptMid = m_ptP6 + vtMid * m_vtDir.Len() ;
return true;
}
default:
@@ -1185,12 +1158,12 @@ ExtDimension::GetCenterPoint( Point3d& ptCen) const
case DT_RADIAL :
case DT_DIAMETRAL :
case DT_ANGULAR : {
ptCen = m_ptP0 ;
ptCen = m_ptP6 ;
return true ;
}
default:
return false ;
}
}
}
//----------------------------------------------------------------------------
@@ -1204,34 +1177,34 @@ ExtDimension::ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST&
case DT_LINEAR: {
// prima linea di riferimento
lstPL.emplace_back() ;
lstPL.back().AddUPoint(0, m_ptP1) ;
lstPL.back().AddUPoint(1, m_ptP3) ;
lstPL.back().AddUPoint( 0, m_ptP1) ;
lstPL.back().AddUPoint( 1, m_ptP3) ;
// seconda linea di riferimento
lstPL.emplace_back() ;
lstPL.back().AddUPoint(0, m_ptP2) ;
lstPL.back().AddUPoint(1, m_ptP4) ;
lstPL.back().AddUPoint( 0, m_ptP2) ;
lstPL.back().AddUPoint( 1, m_ptP4) ;
// se non c'� testo, linea di misura intera
if ( IsEmptyOrSpaces(m_sCalcText) ) {
lstPL.emplace_back() ;
lstPL.back().AddUPoint(0, m_ptP5) ;
lstPL.back().AddUPoint(1, m_ptP6) ;
lstPL.back().AddUPoint( 0, m_ptP5) ;
lstPL.back().AddUPoint( 1, m_ptP6) ;
}
// altrimenti, linea di misura divisa in due parti
else {
// prima parte
lstPL.emplace_back() ;
lstPL.back().AddUPoint(0, m_ptP5) ;
lstPL.back().AddUPoint(1, m_ptCalcP7) ;
lstPL.back().AddUPoint( 0, m_ptP5) ;
lstPL.back().AddUPoint( 1, m_ptCalcP7) ;
// seconda parte
lstPL.emplace_back() ;
lstPL.back().AddUPoint(0, m_ptP6) ;
lstPL.back().AddUPoint(1, m_ptCalcP8) ;
lstPL.back().AddUPoint( 0, m_ptP6) ;
lstPL.back().AddUPoint( 1, m_ptCalcP8) ;
}
// frecce
lstPL.emplace_back() ;
GetArrowHead(m_ptP5, ( m_bCalcArrowIn ? -m_vtDir : m_vtDir ), lstPL.back()) ;
GetArrowHead( m_ptP5, ( m_bCalcArrowIn ? -m_vtDir : m_vtDir), lstPL.back()) ;
lstPL.emplace_back() ;
GetArrowHead(m_ptP6, ( m_bCalcArrowIn ? m_vtDir : -m_vtDir ), lstPL.back()) ;
GetArrowHead( m_ptP6, ( m_bCalcArrowIn ? m_vtDir : -m_vtDir), lstPL.back()) ;
// testo
POLYLINELIST lstTxt;
if ( ApproxTextWithLines(dLinTol, dAngTolDeg, lstTxt))
@@ -1240,44 +1213,39 @@ ExtDimension::ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST&
}
case DT_RADIAL:
case DT_DIAMETRAL :{
Vector3d vtRad = m_ptPos - m_ptP0;
vtRad.Normalize() ;
// prima linea di riferimento
lstPL.emplace_back() ;
lstPL.back().AddUPoint(0, m_ptP1) ;
lstPL.back().AddUPoint(1, m_ptP2) ;
lstPL.back().AddUPoint( 0, m_ptP1) ;
lstPL.back().AddUPoint( 1, m_ptP2) ;
// freccia
lstPL.emplace_back() ;
GetArrowHead(m_ptP6, ( m_bCalcArrowIn ? vtRad : - vtRad ), lstPL.back()) ;
Point3d ptArrowTail ;
Vector3d vtRad = m_ptPos - m_ptP6;
if ( ! vtRad.Normalize())
return false ;
GetArrowHead(m_ptP2, ( m_bCalcArrowIn ? vtRad : - vtRad), lstPL.back()) ;
if ( ! m_bCalcArrowIn) {
lstPL.emplace_back() ;
ptArrowTail = m_ptP6 + vtRad * m_dArrowLen * 2 ;
lstPL.back().AddUPoint(0, m_ptP6) ;
lstPL.back().AddUPoint(1, ptArrowTail) ;
Point3d ptArrowTail = m_ptP2 + vtRad * m_dArrowLen * 2 ;
lstPL.back().AddUPoint( 0, m_ptP2) ;
lstPL.back().AddUPoint( 1, ptArrowTail) ;
}
if ( m_nType == DT_DIAMETRAL) {
lstPL.emplace_back() ;
GetArrowHead(m_ptP5, ( m_bCalcArrowIn ? - vtRad : vtRad ), lstPL.back()) ;
GetArrowHead(m_ptP5, ( m_bCalcArrowIn ? - vtRad : vtRad), lstPL.back()) ;
if ( ! m_bCalcArrowIn) {
lstPL.emplace_back() ;
ptArrowTail = m_ptP5 - vtRad * m_dArrowLen * 2 ;
lstPL.back().AddUPoint(0, m_ptP5) ;
lstPL.back().AddUPoint(1, ptArrowTail) ;
Point3d ptArrowTail = m_ptP5 - vtRad * m_dArrowLen * 2 ;
lstPL.back().AddUPoint( 0, m_ptP5) ;
lstPL.back().AddUPoint( 1, ptArrowTail) ;
}
}
// testo
POLYLINELIST lstTxt;
if ( ApproxTextWithLines(dLinTol, dAngTolDeg, lstTxt))
lstPL.splice(lstPL.end(), lstTxt) ;
if ( ApproxTextWithLines( dLinTol, dAngTolDeg, lstTxt))
lstPL.splice( lstPL.end(), lstTxt) ;
return true ;
}
case DT_ANGULAR: {
// approssimerò l'arco con una polyline
PolyLine plApprox ;
// cerca nel geom kernel delle tolleranze standard
double dLinTol = 0.01 ;
double dAngTolDeg = 0.01 ;
// prima linea di riferimento
lstPL.emplace_back() ;
lstPL.back().AddUPoint( 0, m_ptP1) ;
@@ -1291,37 +1259,42 @@ ExtDimension::ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST&
if ( IsNull( pCrvPos))
return false ;
double dHalfDist = GetTextHalfDist( m_ptCalcPos) ;
// se non ho testo
if ( IsEmptyOrSpaces( m_sCalcText)) {
if ( ! pCrvPos->SetC2PN( m_ptP0, m_ptP6, m_ptP5, m_vtN) || ! pCrvPos->ApproxWithLines(dLinTol, dAngTolDeg, ICurve::APL_STD, plApprox))
// calcolo ptP5_bis
Vector3d vtLine2 = m_ptP2 - m_ptP6 ;
double dLen2 = vtLine2.Len() ;
if ( ! vtLine2.Normalize())
return false ;
Point3d ptP5_bis = m_ptP2 + ( m_vtDir.Len() - dLen2) * vtLine2 ;
// approssimo l'arco con una polyline
PolyLine plApprox ;
double dLinTol = 0.01 ;
double dAngTolDeg = 0.01 ;
// se non ho testo o se l'ho allontanato
if ( IsEmptyOrSpaces( m_sCalcText) || ! m_bCalcTextOn) {
if ( ! pCrvPos->SetC2PN( m_ptP6, ptP5_bis, m_ptP5, m_vtN) || ! pCrvPos->ApproxWithLines(dLinTol, dAngTolDeg, ICurve::APL_STD, plApprox))
return false ;
lstPL.emplace_back( plApprox) ;
}
// altrimenti, linea di misura divisa in due parti
else {
// prima parte
if ( ! pCrvPos->SetC2PN( m_ptP0, m_ptP5, m_ptCalcP7, m_vtN) || ! pCrvPos->ApproxWithLines(dLinTol, dAngTolDeg, ICurve::APL_STD, plApprox))
if ( ! pCrvPos->SetC2PN( m_ptP6, m_ptP5, m_ptCalcP7, m_vtN) || ! pCrvPos->ApproxWithLines(dLinTol, dAngTolDeg, ICurve::APL_STD, plApprox))
return false ;
lstPL.emplace_back( plApprox) ;
// seconda parte
if ( ! pCrvPos->SetC2PN( m_ptP0, m_ptP6, m_ptCalcP8, m_vtN) || ! pCrvPos->ApproxWithLines(dLinTol, dAngTolDeg, ICurve::APL_STD, plApprox))
if ( ! pCrvPos->SetC2PN( m_ptP6, ptP5_bis, m_ptCalcP8, m_vtN) || ! pCrvPos->ApproxWithLines(dLinTol, dAngTolDeg, ICurve::APL_STD, plApprox))
return false ;
lstPL.emplace_back( plApprox) ;
}
// frecce
if ( ! pCrvPos->Set3P( ptP5_bis, m_ptPos, m_ptP5, false))
return false ;
Vector3d vtStartDir ;
Vector3d vtEndDir ;
if ( ! pCrvPos->Set3P( m_ptP6, m_ptPos, m_ptP5, false))
return false ;
pCrvPos->GetStartDir( vtStartDir) ;
pCrvPos->GetEndDir( vtEndDir) ;
//storto la punta delle frecce su una direzione mediata tra l'arco e la perpendicolare al lato
double dFactor = 1 / ( 0.6 * m_vtDir.Len()) ; // questo fattore dipende direttamente dalla distanza di m_ptPos dal centro e smorza lo scostamento
Vector3d vtLine1 = m_ptP1 - m_ptP0 ;
Vector3d vtLine2 = m_ptP2 - m_ptP0 ;
vtLine1.Normalize() ;
vtLine2.Normalize() ;
// se però le frecce sono fuori non le storto e faccio le code dritte anziché curvilinee
if ( ! m_bCalcArrowIn) {
Point3d ptArrowTail1, ptArrowTail2 ;
@@ -1329,16 +1302,19 @@ ExtDimension::ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST&
lstPL.emplace_back() ;
lstPL.back().AddUPoint( 0, m_ptP5) ;
lstPL.back().AddUPoint( 1, ptArrowTail1) ;
ptArrowTail2 = m_ptP6 - vtStartDir * m_dArrowLen *2 ;
ptArrowTail2 = ptP5_bis - vtStartDir * m_dArrowLen *2 ;
lstPL.emplace_back() ;
lstPL.back().AddUPoint( 0, m_ptP6) ;
lstPL.back().AddUPoint( 0, ptP5_bis) ;
lstPL.back().AddUPoint( 1, ptArrowTail2) ;
dFactor = 0 ;
}
lstPL.emplace_back() ;
Vector3d vtLine1 = m_ptP1 - m_ptP6 ;
if ( ! vtLine1.Normalize())
return false ;
GetArrowHead( m_ptP5, ( m_bCalcArrowIn ? vtEndDir : - vtEndDir) + vtLine1 * dFactor, lstPL.back()) ;
lstPL.emplace_back() ;
GetArrowHead( m_ptP6, ( m_bCalcArrowIn ? - vtStartDir : vtStartDir) + vtLine2 * dFactor, lstPL.back()) ;
GetArrowHead( ptP5_bis, ( m_bCalcArrowIn ? - vtStartDir : vtStartDir) + vtLine2 * dFactor, lstPL.back()) ;
// testo
POLYLINELIST lstTxt ;
if ( ApproxTextWithLines( dLinTol, dAngTolDeg, lstTxt))
@@ -1361,7 +1337,7 @@ ExtDimension::GetTextHalfDist( const Point3d& ptText) const
Vector3d vtDir = m_vtDir ;
if ( m_nType == DT_ANGULAR)
vtDir.Normalize() ;
if ( GetTextMyBBox( ptText, b3Text) && !b3Text.IsEmpty()) {
if ( GetTextMyBBox( ptText, b3Text) && ! b3Text.IsEmpty()) {
double dHalfL = ( b3Text.GetMax().x - b3Text.GetMin().x) / 2 ;
double dHalfH = ( b3Text.GetMax().y - b3Text.GetMin().y) / 2 ;
dHalfDist = sqrt( dHalfL * dHalfL + dHalfH * dHalfH) ;
@@ -1425,12 +1401,11 @@ ExtDimension::ApproxTextWithLines( double dLinTol, double dAngTolDeg, POLYLINELI
Frame3d frRef ;
if ( ! frRef.Set( m_ptCalcPos, m_vtN))
return false ;
// oriento il testo con il raggio/diametro, ma solo se il testo è dentro la circonferenza
if ( ( m_nType == DT_RADIAL || m_nType == DT_DIAMETRAL) && m_bCalcTextOn ) {
double dAngDeg = 0 ;
Vector3d vtRad = m_ptPos - m_ptP0;
m_vtDir.GetAngle( vtRad, dAngDeg);
if ( ! frRef.Set( m_ptCalcPos, m_vtN, ( dAngDeg > 90 ? - vtRad : vtRad )))
m_vtDir.GetAngle( frRef.VersX(), dAngDeg) ;
if ( ! frRef.Set( m_ptCalcPos, m_vtN, ( dAngDeg > 90 ? - m_vtDir : m_vtDir )))
return false ;
}