EgtNumKernel/ShortestPath.cpp

//----------------------------------------------------------------------------
//  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 ;
   m_pCheckDep = nullptr ;
   m_vOrderConstr.clear() ;
   m_vOrderSugg.clear() ;
   m_vOrderSuggRowMap.clear() ;
   m_nMaxDistSuggDep = 0 ;
   m_ExtDistMat.clear() ;
}

//----------------------------------------------------------------------------
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 ;
   if ( m_pCheckDep != nullptr)
      delete m_pCheckDep ;
   m_pCheckDep = 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 = ( double)m_nMinCost ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ShortestPath::SetDistMatrix( const INTMATRIX& mDistMatrix)
{
  // Assegno la matrice suggerita
   m_ExtDistMat = mDistMatrix ;
   return true ;
}

/* Funzioni per _dubug_ */
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
void
ShortestPath::_printPath( NODE* pPath, string sFun)
{
   #if ENABLE_DEBUG
   {
      LOG_INFO( GetENkLogger(), sFun.c_str()) ;
      NODE* pCurr = pPath ;
      string sText = "" ;
      for ( unsigned i = 0 ; i < m_nNumPnts ; ++ i) {
         sText += ( ( i == 0 ? "" : " - ") + ToString( pCurr->nPos)) ;
         pCurr = pCurr->pNext ;
      }
      LOG_INFO( GetENkLogger(), sText.c_str()) ;
   }
   #else
      return ;
   #endif
}