EgtGeomKernel : Sistemazione distanza Punto-CurvaComposita.

DistPointCrvComposite.cpp

@@ -25,47 +25,96 @@ DistPointCrvComposite::DistPointCrvComposite( const Point3d& ptP, const ICurveCo
 
    if ( ! CrvCompo.IsValid())
       return ;
-#if 0
-  // creo una polilinea di approssimazione
-   PolyLine PL ;
-   if ( ! CrvBez.ApproxWithLines( LIN_TOL_APPROX, ANG_TOL_APPROX_DEG, PL))
-      return ;
 
-  // cerco la minima distanza per la polilinea
-   MDCVECTOR vApproxMin ;
-   MDCVECTOR::iterator Iter ;
-   if ( ! CalcMinDistPointPolyLine( ptP, PL, vApproxMin))
-      return ;
-
-  // verifico presenza singolarità agli estremi degli intervalli trovati
-   double dSingP ;
-   if ( CrvBez.GetSingularParam( dSingP) == 0)
-      dSingP = - 1 ;
-   for ( Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
-     // imposto flag per singolarità agli estremi
-      (*Iter).bParMinSing = fabs( (*Iter).dParMin - dSingP) < EPS_SMALL ; 
-      (*Iter).bParMaxSing = fabs( (*Iter).dParMax - dSingP) < EPS_SMALL ; 
-   }
-
-  // raffino i punti trovati
-   double dPolishedPar ;
-   Point3d ptPolishedQ ;
-   for ( Iter = vApproxMin.begin() ; Iter != vApproxMin.end() ; ++Iter) {
-     // eseguo raffinamento
-      if ( PolishMinDistPointCurve( ptP, CrvBez, *Iter, dPolishedPar, ptPolishedQ)) {
-         (*Iter).dDist = Dist( ptP, ptPolishedQ) ;
-         (*Iter).dPar = dPolishedPar ;
-         (*Iter).ptQ = ptPolishedQ ;
+  // ciclo su ogni curva
+   double dIniCrvPar = 0 ;
+   const ICurve* pCrvSmpl ;
+   pCrvSmpl = CrvCompo.GetFirstCurve() ;
+   while ( pCrvSmpl != nullptr) {
+     // se prima curva
+      if ( m_dDist < 0) {
+        // calcolo distanza minima dal punto alla curva
+         DistPointCurve dstPC( ptP, *pCrvSmpl) ;
+         double dCurrDist ;
+         if ( ! dstPC.GetDist( dCurrDist))
+            return ;
+        // assegno i risultati
+         m_dDist = dCurrDist ;
+         int i = 0 ;
+         MinDistPCInfo aInfo ;
+         while ( dstPC.GetMinDistInfo( i, aInfo)) {
+            aInfo.dPar += dIniCrvPar ;
+            m_Info.push_back( aInfo) ;
+            ++ i ;
+         }
       }
-      else
-         (*Iter).dDist = INFINITO ;
+     // altrimenti, per curve successive
+      else {
+        // verifico se la distanza minima dal box è superiore al minimo già trovato
+         BBox3d b3B ;
+         if ( pCrvSmpl->GetLocalBBox( b3B)  &&
+              b3B.SqDistFromPoint( ptP) <= m_dDist * m_dDist) {
+           // calcolo distanza minima dal punto alla curva
+            DistPointCurve dstPC( ptP, *pCrvSmpl) ;
+            double dCurrDist ;
+            if ( ! dstPC.GetDist( dCurrDist))
+               return ;
+           // con la stessa minima distanza
+            if ( fabs( dCurrDist - m_dDist) < EPS_SMALL) {
+              // aggiungo
+               int i = 0 ;
+               MinDistPCInfo aInfo ;
+               while ( dstPC.GetMinDistInfo( i, aInfo)) {
+                 // porto la parametrizzazione da locale a globale
+                  aInfo.dPar += dIniCrvPar ;
+                 // se il primo nuovo punto coincide con l'ultimo dei precedenti
+                  if ( i == 0  &&  fabs( m_Info.back().dPar - aInfo.dPar) < EPS_SMALL  &&
+                       AreSamePointNear( m_Info.back().ptQ, aInfo.ptQ)) {
+                     if ( m_Info.back().nFlag == MDPCI_NORMAL) {
+                       // START deve sostituire il vecchio
+                        if ( aInfo.nFlag == MDPCI_START_CONT)
+                           m_Info.back() = aInfo ;
+                       // negli altri casi non devo inserire il nuovo
+                     }
+                     else if ( m_Info.back().nFlag == MDPCI_END_CONT) {
+                       // START fa eliminare il precedente e non va inserito (continua)
+                        if ( aInfo.nFlag == MDPCI_START_CONT)
+                           m_Info.pop_back() ;
+                       // negli altri casi non devo inserire il nuovo
+                     }
+                     else if ( m_Info.back().nFlag == MDPCI_START_CONT) {
+                       // non dovrebbe mai capitare, va rimosso il precedente e inserito il nuovo
+                        m_Info.pop_back() ;
+                        m_Info.push_back( aInfo) ;
+                     }
+                  }
+                 // altrimenti aggiungo
+                  else
+                     m_Info.push_back( aInfo) ;
+                 // passo al successivo
+                  ++ i ;
+               }
+            }
+           // con minima distanza più bassa
+            else if ( dCurrDist < m_dDist) {
+              // aggiorno i minimi
+               m_dDist = dCurrDist ;
+              // il nuovo vettore deve contenere solo quest'ultimo minimo
+               m_Info.clear() ;
+               int i = 0 ;
+               MinDistPCInfo aInfo ;
+               while ( dstPC.GetMinDistInfo( i, aInfo)) { 
+                  aInfo.dPar += dIniCrvPar ;
+                  m_Info.push_back( aInfo) ;
+                  ++ i ;
+               }
+            }
+         }
+      }
+     // passo alla successiva
+      ++ dIniCrvPar ;
+      pCrvSmpl = CrvCompo.GetNextCurve() ;
    }
-
-  // determino i minimi raffinati da tenere
-   double dMinDist ;
-   if ( FilterMinDistPointCurve( ptP, CrvBez, vApproxMin, dMinDist, m_Info))
-      m_dDist = dMinDist ;
-#endif
 }
 
 //----------------------------------------------------------------------------

DistPointCurve.cpp

@@ -214,3 +214,17 @@ DistPointCurve::GetParamAtMinDistPoint( double dNearParam, double& dParam, int&
 
    return true ;
 }
+
+//----------------------------------------------------------------------------
+bool
+DistPointCurve::GetMinDistInfo( int nInd, MinDistPCInfo& aInfo)
+{
+   if ( m_dDist < 0)
+      return false ;
+
+   if ( nInd < 0  ||  nInd >= (int) m_Info.size())
+      return false ;
+
+   aInfo = m_Info[nInd] ;
+   return true ;
+}

OutScl.cpp

@@ -397,7 +397,7 @@ OutScl::PutCurve( const IGeoObj* pGeoObj, int nFlag)
            // se ci sono delle discontinuità
             if ( ThereIsDiscontinuity( oDiffG, oDiffGs))
               // normale o niente
-               NormalOrNone( oDiffG) ;
+               NormalOrNone( oDiffGs) ;
          }
       }
    }