EgtGeomKernel :

- modifiche e correzioni varie a dimensioni angolari, diametrali e radiali.

ExtDimension.cpp

@@ -21,6 +21,7 @@
 #include "FontManager.h"
 #include "FontAux.h"
 #include "CurveArc.h"
+#include "IntersLineLine.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkExtText.h"
 #include "/EgtDev/Include/EGkUiUnits.h"
@@ -63,7 +64,7 @@ ExtDimension::~ExtDimension( void)
 //----------------------------------------------------------------------------
 bool
 ExtDimension::SetStyle( double dExtLineLen, double dArrowLen, double dTextDist, bool bLenIsMM,
-   int nDecDigit, const string& sFont, double dTextHeight)
+                        int nDecDigit, const string& sFont, double dTextHeight)
 {
    m_dExtLineLen = max( dExtLineLen, MIN_EXTLINELEN) ;
    m_dArrowLen = max( dArrowLen, MIN_ARROWLEN) ;
@@ -200,7 +201,7 @@ ExtDimension::SetDiametral( const Point3d& ptCen, const Point3d& ptPos,
 
 //----------------------------------------------------------------------------
 bool
-ExtDimension::SetAngular( const Point3d& ptP1, const Point3d& ptV, const Point3d& ptP2, const Point3d& ptPos,
+ExtDimension::SetAngular( const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptPos,
                           const Vector3d& vtN, const string& sText)
 {
   // dichiaro quota non ancora determinata
@@ -209,17 +210,16 @@ ExtDimension::SetAngular( const Point3d& ptP1, const Point3d& ptV, const Point3d
    m_vtN = vtN ;
    if ( ! m_vtN.Normalize())
       return false ;
-  // porto i punti nel piano definito da P1 e N
-   m_ptP1 = ptP1 ;
-   m_ptP2 = ptP2 - ( ptP2 - m_ptP1) * m_vtN * m_vtN ;
-   m_ptP6 = ptV - ( ptV - m_ptP1) * m_vtN * m_vtN ;
-   m_ptPos = ptPos - ( ptPos - m_ptP1) * m_vtN * m_vtN ;
-  // verifico che i punti di misura non siano coincidenti
-   if ( AreSamePointApprox( m_ptP1, m_ptP2)  ||  AreSamePointApprox( m_ptP1, m_ptP6)  ||  AreSamePointApprox( m_ptP2, m_ptP5))
-      return false ;
-  // direzione di riferimento ( nel piano perpendicolare a vtN)
+  // porto i punti e le direzioni nel piano definito da V e N
+   m_ptP6 = ptV ;
+   m_ptPos = ptPos - ( ptPos - m_ptP6) * m_vtN * m_vtN ;
    m_vtDir = m_ptPos - m_ptP6 ;
    double dLenDir = m_vtDir.Len() ;
+   Vector3d vtLine1 = OrthoCompo( ptP1 - m_ptP6, m_vtN) ;
+   Vector3d vtLine2 = OrthoCompo( ptP2 - m_ptP6, m_vtN) ;
+  // verifico che i punti di misura non siano coincidenti
+   if ( ! vtLine1.Normalize()  ||  ! vtLine2.Normalize()  ||  dLenDir < EPS_SMALL)
+      return false ;
 
   // controllo se è testo o se è la misura
    double dFactor ;
@@ -243,20 +243,12 @@ ExtDimension::SetAngular( const Point3d& ptP1, const Point3d& ptV, const Point3d
       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 = ( 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 = ptP5_bis + ( bPt2Close ? - vtLine2 : vtLine2) * m_dExtLineLen ;
+  // assegno gli altri punti notevoli della quotatura
+   m_ptP1 = m_ptP6 ;
+   m_ptP2 = m_ptP6 ;
+   m_ptP5 = m_ptP6 + vtLine1 * dLenDir ;
+   m_ptP3 = m_ptP6 + vtLine1 * ( dLenDir + m_dExtLineLen) ;
+   m_ptP4 = m_ptP6 + vtLine2 * ( dLenDir + m_dExtLineLen) ;
 
   // assegnazione del testo
    m_sText = sText ;
@@ -266,7 +258,84 @@ ExtDimension::SetAngular( const Point3d& ptP1, const Point3d& ptV, const Point3d
    m_bToCalc = true ;
    m_OGrMgr.Reset() ;
 
-   return true;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ExtDimension::SetAngularEx( const Point3d& ptV1, const Point3d& ptP1,
+                            const Point3d& ptV2, const Point3d& ptP2, const Point3d& ptPos,
+                            const Vector3d& vtN, const string& sText)
+{
+  // dichiaro quota non ancora determinata
+   m_nType = DT_NONE ;
+  // verifico la definizione del versore normale
+   m_vtN = vtN ;
+   if ( ! m_vtN.Normalize())
+      return false ;
+  // calcolo l'intersezione tra le due linee
+   CurveLine Line1 ;
+   if ( ! Line1.Set( ptV1, ptP1)  ||  ! Line1.SetExtrusion( m_vtN))
+      return false ;
+   CurveLine Line2 ;
+   if ( ! Line2.Set( ptV2, ptP2)  ||  ! Line2.SetExtrusion( m_vtN))
+      return false ;
+   IntersLineLine IntLL( Line1, Line2, false) ;
+   IntCrvCrvInfo Info ;
+   if ( ! IntLL.GetIntCrvCrvInfo( Info)  ||  Info.bOverlap)
+      return false ;
+   Point3d ptV = Media( Info.IciA[0].ptI, Info.IciB[0].ptI) ;
+  // porto i punti e le direzioni nel piano definito da V1 e N
+   m_ptP6 = ptV ;
+   m_ptPos = ptPos - ( ptPos - m_ptP6) * m_vtN * m_vtN ;
+   m_vtDir = m_ptPos - m_ptP6 ;
+   double dLenDir = m_vtDir.Len() ;
+   Vector3d vtLine1 = OrthoCompo( ptP1 - m_ptP6, m_vtN) ;
+   Vector3d vtLine2 = OrthoCompo( ptP2 - m_ptP6, m_vtN) ;
+  // verifico che i punti di misura non siano coincidenti
+   if ( ! vtLine1.Normalize()  ||  ! vtLine2.Normalize()  ||  dLenDir < EPS_SMALL)
+      return false ;
+
+  // controllo se è testo o se è la misura
+   double dFactor ;
+   if ( m_sCalcText.find( IS_MEASURE) != string::npos) {
+      m_sCalcText = "300.00" ;
+      double dHalfDist = GetTextHalfDist( m_ptPos) ;
+      dFactor = 2.5 * dHalfDist ;
+      m_sCalcText = "" ;
+   }
+   else {
+      double dHalfDist = GetTextHalfDist( m_ptPos) ;
+      dFactor = 2.5 * dHalfDist ;
+   }
+  // allungo m_vtDir se è troppo vicino al centro
+   if ( m_vtDir.Len() < dFactor) {
+      Vector3d vtDir_n = m_vtDir ;
+      if ( ! vtDir_n.Normalize())
+         return false ;
+      m_ptPos = m_ptP6 + dFactor * vtDir_n ;
+     // ricalcolo m_vtDir
+      m_vtDir = m_ptPos - m_ptP6 ;
+      dLenDir = m_vtDir.Len() ;
+   }
+  // assegno gli altri punti notevoli della quotatura
+   m_ptP1 = ptV1 - ( ptV1 - m_ptP6) * m_vtN * m_vtN ;
+   m_ptP2 = ptV2 - ( ptV2 - m_ptP6) * m_vtN * m_vtN ;
+   m_ptP5 = m_ptP6 + vtLine1 * dLenDir ;
+   double dLen1 = Dist( m_ptP6, m_ptP1) ;
+   m_ptP3 = m_ptP6 + vtLine1 * ( dLenDir + m_dExtLineLen * ( dLen1 < dLenDir ? 1 : -1)) ;
+   double dLen2 = Dist( m_ptP6, m_ptP2) ;
+   m_ptP4 = m_ptP6 + vtLine2 * ( dLenDir + m_dExtLineLen * ( dLen2 < dLenDir ? 1 : -1)) ;
+
+  // assegnazione del testo
+   m_sText = sText ;
+  // assegno il tipo
+   m_nType = DT_ANGULAR ;
+  // imposto da calcolare
+   m_bToCalc = true ;
+   m_OGrMgr.Reset() ;
+
+   return true ;
 }
 
 //----------------------------------------------------------------------------
@@ -1012,6 +1081,7 @@ ExtDimension::Update( void) const
       if ( ! GetTextMyBBox( b3Text)  &&  ! b3Text.IsEmpty())
          return false ;
       double dHeight = b3Text.GetMax().y - b3Text.GetMin().y ;
+      double dLength = b3Text.GetMax().x - b3Text.GetMin().x ;
       Vector3d vtPerpDir = m_ptPos - m_ptP6 ;
       if ( ! vtPerpDir.Normalize())
          return false ;
@@ -1020,11 +1090,11 @@ ExtDimension::Update( void) const
       if ( ! frRef.Set( m_ptP6, m_vtN))
          return false ;
       double dAngDeg = 0 ;
-      if ( ! m_vtDir.GetAngle( frRef.VersX(), 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) ;
+      double dHalfDist = GetTextHalfDist( m_ptCalcPos, false) ;
      // lunghezza della linea di misura
       double dLen = Dist( m_ptP1, m_ptP2) ;
      // determino come orientare le frecce e dove mettere il testo
@@ -1049,7 +1119,16 @@ ExtDimension::Update( void) const
          Vector3d vtRad = m_ptPos - m_ptP5 ;
          if ( ! vtRad.Normalize())
             return false ;
-         m_ptCalcPos = m_ptPos + vtRad * ( dHalfDist + 2 * m_dArrowLen) ;
+         m_ptCalcPos = m_ptPos + vtRad * ( 2 * m_dArrowLen + m_dTextDist) ;
+         const double COMP_LIM = 0.1 ; // circa 5.7deg
+         if ( vtRad.x > COMP_LIM)
+            m_ptCalcPos += dLength / 2 * X_AX ;
+         else if ( vtRad.x < -COMP_LIM)
+            m_ptCalcPos -= dLength / 2 * X_AX ;
+         if ( vtRad.y > COMP_LIM)
+            m_ptCalcPos += dHeight / 2 * Y_AX ;
+         else if ( vtRad.y < -COMP_LIM)
+            m_ptCalcPos -= dHeight / 2 * Y_AX ;
       }
      // dichiaro ricalcolo eseguito
       m_bToCalc = false ;
@@ -1058,8 +1137,8 @@ ExtDimension::Update( void) const
    case DT_ANGULAR : {
      // angolo
       double dAngDeg, dAngDeg1, dAngDeg2 = 0 ;
-      Vector3d vtLine1 = m_ptP1 - m_ptP6 ;
-      Vector3d vtLine2 = m_ptP2 - m_ptP6 ;
+      Vector3d vtLine1 = m_ptP3 - m_ptP6 ;
+      Vector3d vtLine2 = m_ptP4 - m_ptP6 ;
       Vector3d vtLine3 = m_ptPos - m_ptP6 ;
      // 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
@@ -1074,10 +1153,9 @@ ExtDimension::Update( void) const
          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 ;
+      Point3d ptP5_bis = m_ptP6 + m_vtDir.Len() * vtLine2 ;
      // calcolo l'arco su cui metterò la misura
       PtrOwner<CurveArc> pCrvPos( CreateBasicCurveArc()) ;
       if ( IsNull( pCrvPos)  ||  ! pCrvPos->Set3P( ptP5_bis, m_ptPos, m_ptP5, false))
@@ -1288,15 +1366,12 @@ ExtDimension::ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST&
       if ( IsNull( pCrvPos))
          return false ;
      // calcolo ptP5_bis
-      Vector3d vtLine2 = m_ptP2 - m_ptP6 ;
-      double dLen2 = vtLine2.Len() ;
+      Vector3d vtLine2 = m_ptP4 - m_ptP6 ;
       if ( ! vtLine2.Normalize())
          return false ;
-      Point3d ptP5_bis = m_ptP2 + ( m_vtDir.Len() - dLen2) * vtLine2 ;
+      Point3d ptP5_bis = m_ptP6 + m_vtDir.Len() * vtLine2 ;
      // approssimerò l'arco con una polyline
       PolyLine plApprox ;
-      double dLinTol = 0.01 ;
-      double dAngTolDeg = 0.01 ;
      // se non ho testo 
       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))
@@ -1337,7 +1412,7 @@ ExtDimension::ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST&
          dFactor = 0 ;
       }
       lstPL.emplace_back() ;
-      Vector3d vtLine1 = m_ptP1 - m_ptP6 ;
+      Vector3d vtLine1 = m_ptP3 - m_ptP6 ;
       if ( ! vtLine1.Normalize())
          return false ;
       GetArrowHead( m_ptP5, ( m_bCalcArrowIn ? vtEndDir : - vtEndDir) + vtLine1 * dFactor, lstPL.back()) ;
@@ -1356,23 +1431,25 @@ ExtDimension::ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST&
 
 //----------------------------------------------------------------------------
 double
-ExtDimension::GetTextHalfDist( const Point3d& ptText) const
+ExtDimension::GetTextHalfDist( const Point3d& ptText, bool bUseRot) const
 {
   // semi distanza di interruzione
    double dHalfDist = m_dTextHeight / 2 + m_dTextDist ;
   // recupero il box di ingombro del testo
    BBox3d b3Text ;
-   Vector3d vtDir = m_vtDir ;
-   if ( m_nType == DT_ANGULAR)
-      vtDir.Normalize() ;
    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) ;
-      if ( abs( vtDir.x) > EPS_ZERO)
-         dHalfDist = min( dHalfDist, dHalfL / abs( vtDir.x)) ;
-      if ( abs( vtDir.y) > EPS_ZERO)
-         dHalfDist = min( dHalfDist, dHalfH / abs( vtDir.y)) ;
+      if ( bUseRot) {
+         Vector3d vtDir = m_vtDir ;
+         vtDir.Normalize() ;
+         double dCoeff = ( dHalfH > 1 ? dHalfL / dHalfH : 0) ;
+         if ( abs( vtDir.x) > dCoeff * abs( vtDir.y))
+            dHalfDist = min( dHalfDist, dHalfL / abs( vtDir.x)) ;
+         else
+            dHalfDist = min( dHalfDist, dHalfH / abs( vtDir.y)) ;
+      }
       dHalfDist += m_dTextDist ;
    }
    return dHalfDist ;

ExtDimension.h

@@ -28,7 +28,7 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
       ExtDimension* Clone( void) const override ;
       GeoObjType GetType( void) const override ;
       bool IsValid( void) const override
-        { return ( m_nType != DT_NONE) ; }
+               { return ( m_nType != DT_NONE) ; }
       const std::string& GetTitle( void) const override ;
       bool Dump( std::string& sOut, bool bMM = true, const char* szNewLine = "\n") const override ;
       bool GetLocalBBox( BBox3d& b3Loc, int nFlag = BBF_STANDARD) const override ;
@@ -71,8 +71,11 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
                       const Vector3d& vtN, const std::string& sText) override ;
       bool SetDiametral( const Point3d& ptCen, const Point3d& ptPos,
                          const Vector3d& vtN, const std::string& sText) override ;
-      bool SetAngular( const Point3d& ptP1, const Point3d& ptV, const Point3d& ptP2, const Point3d& ptPos,
+      bool SetAngular( const Point3d& ptV, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptPos,
                        const Vector3d& vtN, const std::string& sText) override ;
+      bool SetAngularEx( const Point3d& ptV1, const Point3d& ptP1,
+                         const Point3d& ptV2, const Point3d& ptP2, const Point3d& ptPos,
+                         const Vector3d& vtN, const std::string& sText) override ;
       const Vector3d& GetNormVersor( void) const override
                         { return m_vtN ; } 
       const Vector3d& GetDirVersor( void) const override
@@ -129,7 +132,7 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
       bool CopyFrom( const ExtDimension& gpSrc) ;
       const std::string& GetSubType( void) const ;
       bool Update( void) const ;
-      double GetTextHalfDist( const Point3d& ptText) const ;
+      double GetTextHalfDist( const Point3d& ptText, bool bUseRot = true) const ;
       bool GetArrowHead( const Point3d& ptTip, const Vector3d& vtDir, PolyLine& PL) const ;
       bool SetCurrFont( FontManager& fntMgr) const ;
       bool ApproxTextWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST& lstPL) const ;

IntersLineLine.cpp

@@ -57,7 +57,7 @@ IntersLineLine::IntersLineLine( const CurveLine& Line1, const CurveLine& Line2,
 
 //----------------------------------------------------------------------------
 void
-IntersLineLine::IntersInfiniteLines( const ICurveLine& Line1, const ICurveLine& Line2)
+IntersLineLine::IntersInfiniteLines( const CurveLine& Line1, const CurveLine& Line2)
 {
   // linea 1 : Start, End, Direzione e Lunghezza
    Point3d ptS1 = Line1.GetStart() ;
@@ -118,7 +118,7 @@ IntersLineLine::IntersInfiniteLines( const ICurveLine& Line1, const ICurveLine&
 
 //----------------------------------------------------------------------------
 void
-IntersLineLine::IntersFiniteLines( const ICurveLine& Line1, const ICurveLine& Line2)
+IntersLineLine::IntersFiniteLines( const CurveLine& Line1, const CurveLine& Line2)
 {
   // verifico sovrapposizione box
    BBox3d boxL1 ;

IntersLineLine.h

@@ -38,8 +38,8 @@ class IntersLineLine
 
    private :
       IntersLineLine( void) ;
-      void IntersInfiniteLines( const ICurveLine& Line1, const ICurveLine& Line2) ;
-      void IntersFiniteLines( const ICurveLine& Line1, const ICurveLine& Line2) ;
+      void IntersInfiniteLines( const CurveLine& Line1, const CurveLine& Line2) ;
+      void IntersFiniteLines( const CurveLine& Line1, const CurveLine& Line2) ;
 
    private :
       bool          m_bOverlaps ;