EgtNumKernel 1.6l4 :

- aggiunta gestione ShortestPath.

ShortestPath.cpp

@@ -0,0 +1,237 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2015-2015
+//----------------------------------------------------------------------------
+// File : ShortestPath.cpp      Data : 22.12.15        Versione : 1.6l3
+// Contenuto : Funzioni per il calcolo del percorso minimo.
+//
+//
+//
+// Modifiche : 22.12.15 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "DllMain.h"
+#include "ShortestPath.h"
+#include "/EgtDev/Include/EGnStringUtils.h"
+#include "/EgtDev/Include/EgtILogger.h"
+#include <new>
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+IShortestPath*
+CreateShortestPath( void)
+{
+   return static_cast<IShortestPath*> ( new(nothrow) ShortestPath) ;  
+}
+
+//----------------------------------------------------------------------------
+ShortestPath::ShortestPath( void)
+{
+   m_nType = SP_NONE ;
+   m_bSolved = false ;
+   m_dAngHAdd = 1000 ;
+   m_dAngHMul = 10 ;
+   m_dAngVAdd = 2000 ;
+   m_dAngVMul = 40 ;
+   m_dStep = 100 ;
+   m_nNumPnts = 0 ;
+   m_ObStart.nF = OB_NONE ;
+   m_ObEnd.nF = OB_NONE ;
+   m_Dists = nullptr ;
+   m_Available = nullptr ;
+   m_pMain = nullptr ;
+   m_pDupl = nullptr ;
+}
+
+//----------------------------------------------------------------------------
+ShortestPath::~ShortestPath( void)
+{
+   if ( m_Dists != nullptr)
+      delete m_Dists ;
+   m_Dists = nullptr ;
+   if ( m_Available != nullptr)
+      delete m_Available ;
+   m_Available = nullptr ;
+   if ( m_pMain != nullptr)
+      delete m_pMain ;
+   m_pMain = nullptr ;
+   if ( m_pDupl != nullptr)
+      delete m_pDupl ;
+   m_pDupl = nullptr ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ShortestPath::AddPoint( double dX, double dY)
+{
+   return AddPoint( dX, dY, 0, 0, 0, dX, dY, 0, 0, 0) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ShortestPath::AddPoint( double dXi, double dYi, double dXf, double dYf)
+{
+   return AddPoint( dXi, dYi, 0, 0, 0, dXf, dYf, 0, 0, 0) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ShortestPath::AddPoint( double dXi, double dYi, double dZi, double dHi, double dVi,
+                        double dXf, double dYf, double dZf, double dHf, double dVf)
+{
+   if ( m_nNumPnts >= MAX_SPPS)
+      return false ;
+   m_Points[m_nNumPnts].dXi = dXi ;
+   m_Points[m_nNumPnts].dYi = dYi ;
+   m_Points[m_nNumPnts].dZi = dZi ;
+   m_Points[m_nNumPnts].dHi = dHi ;
+   m_Points[m_nNumPnts].dVi = dVi ;
+   m_Points[m_nNumPnts].dXf = dXf ;
+   m_Points[m_nNumPnts].dYf = dYf ;
+   m_Points[m_nNumPnts].dZf = dZf ;
+   m_Points[m_nNumPnts].dHf = dHf ;
+   m_Points[m_nNumPnts].dVf = dVf ;
+   ++ m_nNumPnts ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ShortestPath::SetOpenBound( bool bStartVsEnd, int nFlag, double dX, double dY)
+{
+   return SetOpenBound( bStartVsEnd, nFlag, dX, dY, 0, 0, 0) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ShortestPath::SetOpenBound( bool bStartVsEnd, int nFlag, double dX, double dY, double dZ, double dH, double dV)
+{
+  // se inizio
+   if ( bStartVsEnd) {
+      switch ( nFlag) {
+      case OB_NONE :
+         m_ObStart.nF = nFlag ;
+         break ;
+      case OB_NEAR_PNT :
+         m_ObStart.nF = nFlag ;
+         m_ObStart.dX = dX ;
+         m_ObStart.dY = dY ;
+         m_ObStart.dZ = dZ ;
+         m_ObStart.dH = dH ;
+         m_ObStart.dV = dV ;
+         break ;
+      case OB_XMIN :
+      case OB_XMAX :
+      case OB_YMIN :
+      case OB_YMAX :
+         m_ObStart.nF = nFlag ;
+         break ;
+      default :
+         return false ;
+      }
+   }
+  // altrimenti fine
+   else {
+      switch ( nFlag) {
+      case OB_NONE :
+         m_ObEnd.nF = nFlag ;
+         break ;
+      case OB_NEAR_PNT :
+         m_ObEnd.nF = nFlag ;
+         m_ObEnd.dX = dX ;
+         m_ObEnd.dY = dY ;
+         m_ObEnd.dZ = dZ ;
+         m_ObEnd.dH = dH ;
+         m_ObEnd.dV = dV ;
+         break ;
+      case OB_XMIN :
+      case OB_XMAX :
+      case OB_YMIN :
+      case OB_YMAX :
+         m_ObEnd.nF = nFlag ;
+         break ;
+      default :
+         return false ;
+      }
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ShortestPath::SetAngularParams( double dAngHAdd, double dAngHMul, double dAngVAdd, double dAngVMul)
+{
+   m_dAngHAdd = float( abs( dAngHAdd)) ;
+   m_dAngHMul = float( abs( dAngHMul)) ;
+   m_dAngVAdd = float( abs( dAngVAdd)) ;
+   m_dAngVMul = float( abs( dAngVMul)) ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ShortestPath::SetZzOwStep( double dStep)
+{
+   m_dStep = float( abs( dStep)) ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ShortestPath::Calculate( int nType)
+{
+   m_nType = nType ;
+   switch ( m_nType) {
+   case SP_CLOSED :
+   case SP_OPEN :
+      m_bSolved = Tsp() ;
+      break ;
+   case SP_ZIGZAG_X :
+   case SP_ZIGZAG_Y :
+   case SP_ONEWAY_XP :
+   case SP_ONEWAY_XM :
+   case SP_ONEWAY_YP :
+   case SP_ONEWAY_YM :
+      m_bSolved = ZigZag() ;
+      break ;
+   default :
+      m_bSolved = false ;
+      break ;
+   }
+
+   return m_bSolved ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ShortestPath::GetOrder( INTVECTOR& vOrder)
+{
+  // pulisco risultato
+   vOrder.clear() ;
+  // verifico sia stato risolto
+   if ( ! m_bSolved)
+      return false ;
+  // assegno risultato
+   unsigned nTot = ( ( m_nType == SP_OPEN) ? m_nNumPnts - 1 : m_nNumPnts) ;
+   vOrder.reserve( nTot) ;
+   for ( unsigned i = 0 ; i < nTot ; ++ i)
+      vOrder.push_back( m_nOrder[i]) ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ShortestPath::GetMinLength( double& dMinLen)
+{
+  // verifico sia stato risolto
+   if ( ! m_bSolved)
+      return false ;
+  // assegno risultato
+   dMinLen = m_nMinCost ;
+   return true ;
+}