QGIS » QGIS Application

/***************************************************************************

 *   Copyright (C) 2009 by Sergey Yakushev                                 *

 *   yakushevs <at> list.ru                                                *

 *                                                                         *

 *   This is a plugin generated from the QGIS plugin template              *

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 ***************************************************************************/

/**

 * \file utils.cpp

 * \brief implementation of Road-graph plugins utils

 */

#include "utils.h"

//qt includes

// Qgis includes

#include <qgspoint.h>

// standart includes

#include <set>

#include <cmath>

double infinity()

{

  return 1e12;

}

// return distance between line of two points and center

double distance( const QgsPoint& p1, const QgsPoint& p2, const QgsPoint& p, QgsPoint& center )

{

  // first line

  double A1,B1,C1;

  A1 = p1.y() - p2.y();

  B1 = p2.x() - p1.x();

  C1 = p1.x()*(-A1) + p1.y()*(-B1);

  // second line. First and second line is perpendicular.

  double A2,B2,C2;

  A2 = B1;

  B2 = -A1;

  C2 = -p.x()*A2 - p.y()*B2;

  // union point

  double x,y,det;

  det = A1*B2 - B1*A2;

  x = (C2*B1 - B2*C1)/det;

  y = (-A1*C2 + C1*A2)/det;

  center = QgsPoint(x,y);

  det = sqrt(A1*A1+B1*B1);

  A1 /= det;

  B1 /= det;

  C1 /= det;

  if ( std::min( p1.x(), p2.x() ) <= x && std::max( p1.x(), p2.x() ) >= x &&

    std::min( p1.y(), p2.y() ) <= y && std::max( p1.y(), p2.y() ) >= y )

    return std::abs( A1*p.x()+B1*p.y()+C1 );

  return infinity();

}// RoadGraphPlugin::distance()

bool QgsPointCompare::operator()( const QgsPoint& a, const QgsPoint& b ) const

{

  return a.x() == b.x() ? a.y() < b.y() : a.x() < b.x();

}

ArcAttributes::ArcAttributes()

{

  mCost = infinity();

  mTime = infinity();

}

ArcAttributes::ArcAttributes( double cost, double time, int featureId ) :

  mCost( cost ), mTime( time ), mFeatureId( featureId )

{

}

DijkstraFinder::DijkstraFinder( const AdjacencyMatrix& m, DijkstraFinder::OptimizationCriterion c ):

  mAdjacencyMatrix (m), mCriterion(c)

{

}

std::map< QgsPoint , DijkstraFinder::DijkstraIterator, QgsPointCompare> DijkstraFinder::find( const QgsPoint& p )

{

  CompareDijkstraIterator ci( mCriterion );

  std::set< DijkstraIterator, CompareDijkstraIterator > not_begin( ci );

  std::set< DijkstraIterator, CompareDijkstraIterator >::iterator it;

  std::map< QgsPoint, DijkstraIterator, QgsPointCompare> res;

  if (mAdjacencyMatrix.find( p ) == mAdjacencyMatrix.end() )

  {

    return res;

  }

  AdjacencyMatrixString::const_iterator arcIt;

  AdjacencyMatrixString::const_iterator end = mAdjacencyMatrix.find( p )->second.end();

  DijkstraIterator f;

  f.mCost = 0;

  f.mTime = 0;

  f.mFrontPoint = p;

  f.mBackPoint = p;

  res[ p ] = f;

  not_begin.insert( f );

  while ( !not_begin.empty() )

  {

    it = not_begin.begin();

    DijkstraIterator i = *it;

    not_begin.erase( it );

    if ( mAdjacencyMatrix.find( i.mBackPoint ) == mAdjacencyMatrix.end() )

    {

      continue;

    }

    end = mAdjacencyMatrix.find( i.mBackPoint )->second.end();

    for (arcIt = mAdjacencyMatrix.find( i.mBackPoint )->second.begin(); arcIt != end; ++arcIt)

    {

      DijkstraIterator di = i;

      di.mCost += arcIt->second.mCost;

      di.mTime += arcIt->second.mTime;

      if ( ci(di, res[ arcIt->first ] ) ) 

      {

        di.mFrontPoint = di.mBackPoint;

        di.mBackPoint = arcIt->first;

        not_begin.insert( di );

        res[ arcIt->first ] = di;

      }

    }

  }

  return res;

} // DijkstraFinder::find( const QgsPoint& p )

AdjacencyMatrix DijkstraFinder::find( const QgsPoint& frontPoint, const QgsPoint& backPoint )

{

  std::map< QgsPoint , DijkstraFinder::DijkstraIterator, QgsPointCompare> r = find( frontPoint );

  std::map< QgsPoint , DijkstraFinder::DijkstraIterator, QgsPointCompare>::iterator it;

  if ( r.find( backPoint ) == r.end() )

  {

    return AdjacencyMatrix();

  }

  AdjacencyMatrix m;

  QgsPoint nextPoint = backPoint;

  QgsPoint firstPoint = backPoint; 

  while ( true )

  {

    if ( firstPoint != nextPoint )

      m[ nextPoint ][ firstPoint ] = mAdjacencyMatrix.find( nextPoint )->second.find( firstPoint )->second;

    if ( r[ nextPoint ].mFrontPoint == r[ nextPoint ].mBackPoint )

      break;

    firstPoint = nextPoint;

    nextPoint = r[ nextPoint ].mFrontPoint;

  }

  return m;

} // DijkstraFinder::find( const QgsPoint& frontPoint, const QgsPoint& backPoint )

/***************************************************************************

 *   Copyright (C) 2009 by Sergey Yakushev                                 *

 *   yakushevs<at>list.ru                                                  *

 *                                                                         *

 *   This is file define vrp plugins settings                              *

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 ***************************************************************************/

#ifndef ROADGRAPHPLUGIN_SHORTESTPATHDLG_H

#define ROADGRAPHPLUGIN_SHORTESTPATHDLG_H

#include "utils.h"

// QT includes

#include <QDockWidget>

// Qgis includes

#include <qgspoint.h>

// standart includes

// forward declaration 

class QComboBox;

class QLineEdit;

class QPushButton;

class QgsRubberBand;

class QgsMapToolEmitPoint;

class QgsMapCanvas;

class RoadGraphPlugin;

/**

@author Sergey Yakushev

*/

/**

 * \class VrpPluginShortestPathDlg

 * \brief This class implement user interface for finding shortest path between two points.

 */

class RgShortestPathWidget : public QDockWidget

{

  Q_OBJECT

public:

  /**

   * Standart construct

   */

  RgShortestPathWidget( QWidget * , RoadGraphPlugin *);

  /**

   * destructor

   */

  ~RgShortestPathWidget();

private slots:

  /**

   * export path

   */

  void exportPath();

  /**

   * update rubberbands where extents changed

   */

  void mapCanvasExtentsChanged();

  /**

   * on canvas click mouse button

   */

  void setFrontPoint( const QgsPoint& );

  /**

   * on canvas click mouse button

   */

  void setBackPoint( const QgsPoint& );

  /**

   * Activate map tool for coordinate capture

   */

  void onSelectFrontPoint();

  /**

   * Activate map tool for coordinate capture

   */

  void onSelectBackPoint();

  /**

   * finding path

   */

  void findingPath();

  /**

   * clear

   */

  void clear(); 

  /**

   * retrun path as a graph

   */

  bool getPath(AdjacencyMatrix &m, QgsPoint& p1, QgsPoint& p2);

private:

  /**

   * This line edit show front points coordinates

   */

  QLineEdit *mFrontPointLineEdit;

  /**

   * This line edit show back points coordinates

   */

  QLineEdit *mBackPointLineEdit;

  /**

   * This combobox conteined criterion name

   */

  QComboBox *mCriterionName;

  /**

   * This line edit show length calculated path

   */

  QLineEdit *mPathCostLineEdit;

  /**

   * This line edit show time calculated path

   */

  QLineEdit *mPathTimeLineEdit;

  /**

   * this button called to find shortest path

   */

  QPushButton *mCalculate;

  /**

   * this button called to clear line edits and clar current path

   */

  QPushButton *mClear;

  /**

   * this map tool use for select coordinates

   */

  QgsMapToolEmitPoint *mFrontPointMapTool;

  /**

   * this map tool use for select coordinates

   */

  QgsMapToolEmitPoint *mBackPointMapTool;

  /**

   * pointer to Plugin

   */

  RoadGraphPlugin *mPlugin;

  /**

   * Front point

   */

  QgsPoint mFrontPoint;

  /**

   * Back point

   */

  QgsPoint mBackPoint;

  /**

   * show front point

   */

  QgsRubberBand *mrbFrontPoint;

  /**

   * show back point

   */

  QgsRubberBand *mrbBackPoint;

  /**

   * show shortest path

   */

  QgsRubberBand *mrbPath;

};

#endif

/***************************************************************************

  graphdirector.h

  --------------------------------------

  Date                 : 2010-10-18

  Copyright            : (C) 2010 by Yakushev Sergey

  Email                : YakushevS <at> list.ru

****************************************************************************

*                                                                          *

*   This program is free software; you can redistribute it and/or modify   *

*   it under the terms of the GNU General Public License as published by   *

*   the Free Software Foundation; either version 2 of the License, or      *

*   (at your option) any later version.                                    *

*                                                                          *

***************************************************************************/

#ifndef ROADGRAPH_GRAPHDIRECTOR

#define ROADGRAPH_GRAPHDIRECTOR

//QT4 includes

//QGIS includes

#include <qgsrectangle.h>

//forward declarations

class RgSettings;

class RgGraphBuilder;

/**

* \class RgGraphDirector

* \brief Determine making the graph

* contained the settings

*/

class RgGraphDirector

{

public:

  //! Destructor

  virtual ~RgGraphDirector() { };

  /**

   * get adjacency matrix

   */

  virtual void makeGraph( RgGraphBuilder * ) const = 0;

  /**

   * return pointer to my Settings

   */

  virtual RgSettings* settings() = 0;

  /**

   * return Director name

   */

  virtual QString name() const = 0;

};

#endif //GRAPHDIRECTOR

/***************************************************************************

 *   Copyright (C) 2009 by Sergey Yakushev                                 *

 *   [email protected]                                                     *

 *                                                                         *

 *   This is file implements Units classes                 *

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 ***************************************************************************/

/**

 * \file units.cpp

 * \brief implementation of VRP plugins utils

 */

#include "units.h"

Unit::Unit()

{

  mMultipler = 1.0;

}

Unit::Unit(const QString& name, double multipler) :

  mName(name), mMultipler(multipler)

{

}

QString Unit::name() const

{

  return mName;

}

double Unit::multipler() const

{

  return mMultipler;

}

Unit Unit::byName( const QString& name)

{

  if ( name == "h" )

    return Unit( name, 60*60 );

  else if ( name == "km" )

    return Unit( name, 1000 );

  else if ( name == "s" )

    return Unit( name, 1 );

  else if ( name == "m" )

    return Unit( name, 1 );

  return Unit();

}

SpeedUnit::SpeedUnit() :

  mTimeUnit("",1), mDistanceUnit("",1)

{

}

SpeedUnit::SpeedUnit( const Unit& distanceUnit, const Unit& timeUnit) :

  mTimeUnit( timeUnit ), mDistanceUnit( distanceUnit )

{

}

QString SpeedUnit::name() const

{ 

  if ( mDistanceUnit.name().isNull() || mTimeUnit.name().isNull() )

    return QString();

  return mDistanceUnit.name() + QString("/") + mTimeUnit.name(); 

}

SpeedUnit SpeedUnit::byName( const QString& name )

{

  if ( name=="km/h" )

    return SpeedUnit( Unit::byName("km"), Unit::byName("h") );

  else if ( name=="m/s" )

    return SpeedUnit( Unit::byName("m"), Unit::byName("s") );

  return SpeedUnit();

}

double SpeedUnit::multipler() const

{ 

  return mDistanceUnit.multipler()/mTimeUnit.multipler(); 

}

Unit SpeedUnit::timeUnit() const

{ 

  return mTimeUnit; 

}

Unit SpeedUnit::distanceUnit() const

{  

  return mDistanceUnit; 

}

/***************************************************************************

 *   Copyright (C) 2010 by Sergey Yakushev                                 *

 *   yakushevs <at> list.ru                                                *

 *                                                                         *

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 ***************************************************************************/

/**

 * \file linevectorlayersettins.cpp

 * \brief implementation of RgLineVectorLayerDirector

 */

#include "linevectorlayersettings.h"

#include "linevectorlayerdirector.h"

#include "graphbuilder.h"

#include "units.h"

// Qgis includes

#include <qgsvectorlayer.h>

#include <qgsmaplayerregistry.h>

#include <qgsvectordataprovider.h>

#include <qgspoint.h>

#include <qgsgeometry.h>

// QT includes

#include <QString>

//standard includes

#include <iostream>

RgLineVectorLayerDirector::RgLineVectorLayerDirector()

{

}

RgLineVectorLayerDirector::~RgLineVectorLayerDirector()

{

}

RgSettings* RgLineVectorLayerDirector::settings()

{

  return &mSettings;

}

QString RgLineVectorLayerDirector::name() const 

{

  return QString( "Vector line" );

}

void RgLineVectorLayerDirector::makeGraph( RgGraphBuilder *builder ) const

{

  QgsVectorLayer *vl = NULL;

  QMap< QString, QgsMapLayer*> m = QgsMapLayerRegistry::instance()->mapLayers();

  QMap< QString, QgsMapLayer*>::const_iterator it;

  for ( it = m.constBegin(); it != m.constEnd(); ++it )

  {

    if ( it.value()->name() == mSettings.mLayer )

    {

      vl = dynamic_cast<QgsVectorLayer*>( it.value() );

      break;

    }

  }

  if ( vl == NULL )

    return;

  QgsVectorDataProvider *provider = dynamic_cast<QgsVectorDataProvider*>( vl->dataProvider() );

  if ( provider == NULL )

    return;

  int directionFieldId = provider->fieldNameIndex( mSettings.mDirection );

  int speedFieldId     = provider->fieldNameIndex( mSettings.mSpeed     );

  builder->setSourceCrs( vl->crs() );

  QgsAttributeList la;

  if ( directionFieldId > -1 )

    la.push_back( directionFieldId );

  if ( speedFieldId > -1 )

    la.push_back( speedFieldId );

  SpeedUnit su = SpeedUnit::byName( mSettings.mSpeedUnitName );

  vl->select( la );

  QgsFeature feature;

  while ( vl->nextFeature(feature) )

  {

    QgsAttributeMap attr = feature.attributeMap();

    RgLineVectorLayerSettings::DirectionType directionType = mSettings.mDefaultDirection;

    QgsAttributeMap::const_iterator it;

    // What direction have feature?   

    for ( it = attr.constBegin(); it != attr.constEnd(); ++it )

    {

      if ( it.key() != directionFieldId )

      {

        continue;

      }

      QString str = it.value().toString();

      if ( str == mSettings.mBothDirectionVal )

      {

        directionType = RgLineVectorLayerSettings::Both;

      }

      else if ( str == mSettings.mFirstPointToLastPointDirectionVal )

      {

        directionType = RgLineVectorLayerSettings::FirstPointToLastPoint;

      }

      else if ( str == mSettings.mLastPointToFirstPointDirectionVal )

      {

        directionType = RgLineVectorLayerSettings::LastPointToFirstPoint;

      }

    }

    // What speed have feature?

    double speed = 0.0;

    for (it = attr.constBegin(); it != attr.constEnd(); ++it)

    {

      if ( it.key() != speedFieldId ) 

      {

        continue;

      }

      speed = it.value().toDouble();

    }

    if (speed <= 0.0)

    {

      speed = mSettings.mDefaultSpeed;

    }

    // begin features segments and add arc to the Graph;

    QgsPoint pt1, pt2;

    bool isFirstPoint=true;

    QgsPolyline pl = feature.geometry()->asPolyline();

    QgsPolyline::iterator pointIt;

    for ( pointIt = pl.begin(); pointIt != pl.end(); ++pointIt )

    {

      pt2 = *pointIt;

      if ( !isFirstPoint )

      {

        if ( directionType == RgLineVectorLayerSettings::FirstPointToLastPoint ||

            directionType  == RgLineVectorLayerSettings::Both )

        {

          builder->addArc(pt1, pt2, speed*su.multipler() );

        }

        if (directionType == RgLineVectorLayerSettings::LastPointToFirstPoint ||

            directionType == RgLineVectorLayerSettings::Both )

        {

          builder->addArc( pt2, pt1, speed*su.multipler() );

        }

      }

      pt1 = pt2;

      isFirstPoint=false;

    } // for (it = pl.begin(); it != pl.end(); ++it)

  } // while( vl->nextFeature(feature) )

} // makeGraph( RgGraphBuilder *builder, const QgsRectangle& rt )

/***************************************************************************

  settings.h

  --------------------------------------

  Date                 : 2010-10-18

  Copyright            : (C) 2010 by Yakushev Sergey

  Email                : YakushevS <at> list.ru

****************************************************************************

*                                                                          *

*   This program is free software; you can redistribute it and/or modify   *

*   it under the terms of the GNU General Public License as published by   *

*   the Free Software Foundation; either version 2 of the License, or      *

*   (at your option) any later version.                                    *

*                                                                          *

***************************************************************************/

#ifndef ROADGRAPH_SETTINGS

#define ROADGRAPH_SETTINGS

//QT4 includes

//QGIS includes

//forward declarations

class QWidget;

class QgsProject;

/**

* \class RgGraphDirector

* \brief Determine making the graph

* contained the settings

*/

class RgSettings

{

public:

  //! Destructor

  virtual ~RgSettings() { };

  /**

   * write settings to the poject file

   */

  virtual void write( QgsProject * ) = 0;

  /**

   * read settings form project file

   */

  virtual void read( const QgsProject * ) = 0;

  /**

   * This function test settings and return true if setting correct

   */

  virtual bool test() = 0;

  /**

   * Make settings widget

   * use it for GUI setting

   */

  virtual QWidget* getGui( QWidget* parent ) = 0;

  /**

   * Load settings from widget

   */

  virtual void setFromGui( QWidget * ) = 0;

};

#endif //ROADGRAPH_SETTIGNS

/***************************************************************************

 *   Copyright (C) 2009 by Sergey Yakushev                                 *

 *   yakushevs <at> list.ru                                                *

 *                                                                         *

 *   This is file define road-graph plugins utils                          *

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 ***************************************************************************/

#ifndef ROADGRAPHPLUGIN_UTILS_H

#define ROADGRAPHPLUGIN_UTILS_H

//  QT includes

#include <qlist.h>

// Qgis includes

#include "qgspoint.h"

// standart includes

#include <map>

#include <set>

// forward declaration Qgis-classes

/**

@author Sergey Yakushev

*/

/**

 * \function infinity()

 * \brief return big const double value

 */

double infinity();

/**

 * return distance from lenght <x1,y1><x2,y2> to point <x,y> or infinity() value

 * in union point

 */

double distance( const QgsPoint& p1, const QgsPoint& p2, const QgsPoint& p, QgsPoint& center );

/**

 * \class QgsPointCompare

 * \brief This class implement operation "<", ">", "==" and etc. for use QgsPoint type in STL containers

 *

 */

class QgsPointCompare

{

public:

  bool operator()( const QgsPoint& a, const QgsPoint& b ) const;

};

/**

 * \class ArcAttributes

 * \brief This class contained arcs attributes.

 */

class ArcAttributes

{

public:

  ArcAttributes();

  ArcAttributes( double cost, double time, int mFeatureId );

public:

  double mCost;

  double mTime;

  int mFeatureId;

};

typedef std::map< QgsPoint, ArcAttributes, QgsPointCompare > AdjacencyMatrixString;

typedef std::map< QgsPoint, AdjacencyMatrixString,  QgsPointCompare > AdjacencyMatrix;

/**

 * \class DijkstraFinder

 * \brief This class find shortest path via two points using Dijkstra's algorithm

 */

class DijkstraFinder 

{

public:

  enum OptimizationCriterion { byTime=1, byCost=2 };

private:

  class DijkstraIterator {

  public:

    DijkstraIterator()

    {

      mCost = infinity();

      mTime = infinity();

    }

    double mCost;

    double mTime;

    QgsPoint mBackPoint;

    QgsPoint mFrontPoint;

  };

  class CompareDijkstraIterator {

  public:

    CompareDijkstraIterator( OptimizationCriterion criterion = byCost ) :

      mCriterion( criterion )

    { }

    bool operator()( const DijkstraIterator& a, const DijkstraIterator& b ) const

    {

      if ( mCriterion == byCost )

      {

        return a.mCost < b.mCost;

      }

      return a.mTime < b.mTime;

    }

    bool operator==( const CompareDijkstraIterator& a ) const

    {

      return mCriterion == a.mCriterion;

    }

  private:

    OptimizationCriterion mCriterion;

  };

public:

  /**

   * constructor.

   * m is adjacency matrix of graph, criterion is a citerion of shortest path

   */

  DijkstraFinder( const AdjacencyMatrix &m, OptimizationCriterion criterion );

  /**

   * find all shortest path from point frontPoint to all points of graph.

   * return tree.

   */

  std::map< QgsPoint , DijkstraIterator, QgsPointCompare > find( const QgsPoint& p );

  /**

   * return shortest path form point frontPoint to endPoint

   */

  AdjacencyMatrix find( const QgsPoint& frontPoint, const QgsPoint& endPoint );

private:

  const AdjacencyMatrix& mAdjacencyMatrix;

  OptimizationCriterion mCriterion;

};

#endif

/***************************************************************************

 *   Copyright (C) 2010 by Sergey Yakushev                                 *

 *   [email protected]                                                     *

 *                                                                         *

 *   This is file define vrp plugins time, distance and speed units        *

 *   classes                                                               *

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 ***************************************************************************/

#ifndef ROADGRAPH_UNITS_H

#define ROADGRAPH_UNITS_H

//#include <vrpguibase.h>

//  QT includes

#include <qstring.h>

// Qgis includes

// forward declaration Qgis-classes

/**

@author Sergey Yakushev

*/

/**

 * \class Unit

 * \brief This class provide interface to access unit name and multipler.

 * You can use it for convert units to metric system

 */

class Unit

{

public:

  /**

   * default constructor

   */

  Unit();

  /**

   * constructor

   */

  Unit( const QString& name, double multipler );

  /**

   * return unit name

   */

  QString name() const;

  /**

   * return unit multipler. You can use multipler to conver unit to metric system

   */

  double multipler() const;

  /**

   * return unit by name

   */

  static Unit byName( const QString& name );

private:

  /**

   * units name

   */

  QString mName;

  /**

   * units multipler

   */

  double mMultipler;

};

class SpeedUnit

{

public:

  SpeedUnit();

  SpeedUnit( const Unit& distanceUnit, const Unit& timeUnit );

  QString name() const;

  double multipler() const;

  Unit timeUnit() const;

  Unit distanceUnit() const;

  static SpeedUnit byName( const QString& name );

protected:

  Unit mTimeUnit;

  Unit mDistanceUnit;

};

#endif

/***************************************************************************

  linevectorlayerdirector.h

  --------------------------------------

  Date                 : 2010-10-20

  Copyright            : (C) 2010 by Yakushev Sergey

  Email                : YakushevS <at> list.ru

****************************************************************************

*                                                                          *

*   This program is free software; you can redistribute it and/or modify   *

*   it under the terms of the GNU General Public License as published by   *

*   the Free Software Foundation; either version 2 of the License, or      *

*   (at your option) any later version.                                    *

*                                                                          *

***************************************************************************/

#ifndef ROADGRAPH_LINEVECTORLAYERDIRECTOR

#define ROADGRAPH_LINEVECTORLAYERDIRECTOR

//QT4 includes

//QGIS includes

// Road-graph plugin includes

#include "graphdirector.h"

#include "linevectorlayersettings.h"

//forward declarations

class RgGraphBuilder;

/**

* \class RgLineVectorLayerDirector

* \brief Determine making the graph from vector line layer

*/

class RgLineVectorLayerDirector : public RgGraphDirector

{

public:

  RgLineVectorLayerDirector();

  //! Destructor

  virtual ~RgLineVectorLayerDirector();

  /**

   * MANDATORY DIRECTOR PROPERTY DECLARATION

   */

  void makeGraph( RgGraphBuilder * ) const;

  RgSettings* settings();

  QString name() const;

private:

  /**

   * settings of this director

   */

  RgLineVectorLayerSettings mSettings;

};

#endif //GRAPHDIRECTOR

/***************************************************************************

 *   Copyright (C) 2010 by Sergey Yakushev                                 *

 *   [email protected]                                                     *

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 ***************************************************************************/

#include "exportdlg.h"

#include <qgscontexthelp.h>

//qt includes

#include <qlabel.h>

#include <qcombobox.h>

#include <QHBoxLayout>

#include <QVBoxLayout>

#include <qdialogbuttonbox.h>

#include <qmessagebox.h>

// Qgis includes

#include <qgsvectorlayer.h>

#include <qgsmaplayerregistry.h>

#include <qgsproviderregistry.h>

#include <qgsvectordataprovider.h>

//standard includes

RgExportDlg::RgExportDlg( QWidget* parent, Qt::WFlags fl )

    : QDialog( parent, fl )

{

  // create base widgets;

  setWindowTitle( tr("Export feature") );

  QVBoxLayout *v = new QVBoxLayout( this );

  QHBoxLayout *h = new QHBoxLayout();

  QLabel *l = new QLabel( tr("Select destination layer:"), this);

  h->addWidget(l);

  mcbLayers = new QComboBox( this );

  h->addWidget(mcbLayers);

  v->addLayout(h);

  QDialogButtonBox *bb = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, this);

  connect(bb, SIGNAL(accepted()), this, SLOT(on_buttonBox_accepted()) );

  connect(bb, SIGNAL(rejected()), this, SLOT(on_buttonBox_rejected()) );

  v->addWidget(bb);

  //fill list of layers

  mcbLayers->insertItem( 0, tr("new temporary layer"), QVariant("-1") );

  QMap<QString, QgsMapLayer*> mapLayers = QgsMapLayerRegistry::instance()->mapLayers();

  QMap<QString, QgsMapLayer*>::iterator layer_it = mapLayers.begin();

  for ( ; layer_it != mapLayers.end(); ++layer_it )

  {

    QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( layer_it.value() );

    if ( !vl )

      continue;

    if ( vl->geometryType() != QGis::Line )

      continue;

    mcbLayers->insertItem( 0, vl->name(), QVariant( vl->getLayerID() ) );

  }

} // RgSettingsDlg::RgSettingsDlg()

RgExportDlg::~RgExportDlg()

{

}

QgsVectorLayer* RgExportDlg::mapLayer() const

{

  QgsVectorLayer* myLayer = NULL;

  QString layerId = mcbLayers->itemData( mcbLayers->currentIndex() ).toString();

  if ( layerId == QString("-1") )

  {

    // create a temporary layer

    myLayer = new QgsVectorLayer( "LineString", "shortest path", "memory" );

    QgsVectorDataProvider *prov = myLayer->dataProvider();

    if ( prov == NULL)

     return NULL;

    QList<QgsField> attrList;

    attrList.append( QgsField("one", QVariant::Int) );

    prov->addAttributes( attrList );

    QgsMapLayerRegistry::instance()->addMapLayer( myLayer );  

  }else

  {

    // retrun selected layer

    myLayer = dynamic_cast<QgsVectorLayer*>( QgsMapLayerRegistry::instance()->mapLayer( layerId ) );

  }

  return myLayer;

} // QgsVectorLayer* RgExportDlg::vectorLayer() const

void RgExportDlg::on_buttonBox_accepted()

{  

   accept();

} // void RgExportDlg::on_buttonBox_accepted()

void RgExportDlg::on_buttonBox_rejected()

{

  reject();

}

void RgExportDlg::on_buttonBox_helpRequested()

{

  QgsContextHelp::run( context_id );

}

<RCC>

  <qresource prefix="/roadgraph/" >

    <file>roadgraph.png</file>

    <file>showdirect.png</file>

    <file>about.png</file>

    <file>coordinate_capture.png</file>

  </qresource>

</RCC>

/***************************************************************************

 *   Copyright (C) 2010 by Sergey Yakushev                                 *

 *   [email protected]                                                     *

 *                                                                         *

 *   This is a plugin generated from the QGIS plugin template              *

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 ***************************************************************************/

#include "linevectorlayerwidget.h"

#include "linevectorlayersettings.h"

//qt includes

#include <qgscontexthelp.h>

#include <qlabel.h>

#include <qcombobox.h>

#include <QHBoxLayout>

#include <QVBoxLayout>

#include <qdialogbuttonbox.h>

#include <qtabwidget.h>

#include <qspinbox.h>

#include <qmessagebox.h>

#include <qlineedit.h>

// Qgis includes

#include "qgsfield.h"

#include "qgsmaplayerregistry.h"

#include "qgsvectordataprovider.h"

#include "qgsvectorlayer.h"

//standard includes

RgLineVectorLayerSettingsWidget::RgLineVectorLayerSettingsWidget( RgLineVectorLayerSettings *s, QWidget* parent )

    : QWidget( parent )

{

  // create base widgets;

  QTabWidget *tab = new QTabWidget(this);

  QVBoxLayout *v= new QVBoxLayout(this);

  v->addWidget(tab);

  // transportation layer

  QFrame *frame = new QFrame(this);

  tab->addTab( frame, tr("Transportation layer") );

  v = new QVBoxLayout(frame);

  QLabel *l = new QLabel(tr("Layer"), frame);

  mcbLayers = new QComboBox(frame);

  QHBoxLayout *h = new QHBoxLayout(this);

  h->addWidget(l);

  h->addWidget(mcbLayers);

  v->addLayout(h);

  h = new QHBoxLayout();

  l = new QLabel( tr("Direction field"), frame );

  mcbDirection = new QComboBox(frame);

  h->addWidget(l);

  h->addWidget(mcbDirection);

  v->addLayout(h);

  h = new QHBoxLayout();

  h->addWidget( new QLabel( tr("Direct direction"), frame) );

  mleFirstPointToLastPointDirection = new QLineEdit( s->mFirstPointToLastPointDirectionVal, frame );

  h->addWidget( mleFirstPointToLastPointDirection );

  v->addLayout(h);

  h = new QHBoxLayout();

  h->addWidget( new QLabel( tr("Reverse direction"), frame) );

  mleLastPointToFirstPointDirection = new QLineEdit( s->mLastPointToFirstPointDirectionVal, frame );

  h->addWidget( mleLastPointToFirstPointDirection );

  v->addLayout(h);

  h = new QHBoxLayout();

  h->addWidget( new QLabel( tr("Both direction"), frame) );

  mleBothDirection = new QLineEdit( s->mBothDirectionVal, frame );

  h->addWidget( mleBothDirection );

  v->addLayout(h);

  h = new QHBoxLayout();

  l = new QLabel( tr("Speed field"), frame );

  mcbSpeed = new QComboBox(frame);

  h->addWidget(l);

  h->addWidget(mcbSpeed);

  v->addLayout(h);

  frame = new QFrame(tab);

  tab->addTab( frame, tr("Default settings") );

  v = new QVBoxLayout(frame);

  h = new QHBoxLayout();

  l = new QLabel( tr("Direction"), frame );

  mcbDirectionDefault = new QComboBox(frame);

  mcbDirectionDefault->insertItem( 0, tr("Both direction") );

  mcbDirectionDefault->insertItem( 1, tr("Direct direction") );

  mcbDirectionDefault->insertItem( 2, tr("Reverse direction") );

  connect( mcbLayers, SIGNAL(currentIndexChanged(int)), this, SLOT(on_mcbLayers_selectItem()) );

  h->addWidget(l);

  h->addWidget(mcbDirectionDefault);

  v->addLayout(h);

  h = new QHBoxLayout(frame);

  l = new QLabel( tr("Cost"), frame );

  h->addWidget(l);

  l = new QLabel( tr("lines length"), frame );

  h->addWidget(l);

  v->addLayout(h);

  h = new QHBoxLayout(frame);

  l = new QLabel( tr("Speed"), frame );

  msbSpeedDefault = new QSpinBox( frame );

  msbSpeedDefault->setMinimum( 1 );

  msbSpeedDefault->setMaximum( 10000000 );

  h->addWidget( l );

  h->addWidget( msbSpeedDefault );

  v->addLayout( h );

  frame = new QFrame(tab);

  tab->addTab( frame, tr("Units") );

  v = new QVBoxLayout( frame );

  h = new QHBoxLayout();

  l = new QLabel( tr("Unit of speed") );

  mcbUnitOfSpeed = new QComboBox(this);

  h->addWidget(l);

  h->addWidget( mcbUnitOfSpeed );  

  v->addLayout( h );

  mcbUnitOfSpeed->insertItem( 0, tr("km/h") );

  mcbUnitOfSpeed->insertItem( 0, tr("m/s") );

  if ( s->mSpeedUnitName == "km/h" ) 

    mcbUnitOfSpeed->setCurrentIndex( 1 );

  else if (s->mSpeedUnitName == "m/s" )

    mcbUnitOfSpeed->setCurrentIndex( 0 );

  // fill list of layers

  QMap<QString, QgsMapLayer*> mapLayers = QgsMapLayerRegistry::instance()->mapLayers();

  QMap<QString, QgsMapLayer*>::iterator layer_it = mapLayers.begin();

  for ( ; layer_it != mapLayers.end(); ++layer_it )

  {

    QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( layer_it.value() );

    if ( !vl )

      continue;

    if ( vl->geometryType() != QGis::Line )

      continue;

    mcbLayers->insertItem( 0, vl->name() );  

  }

  //sets current settings

  msbSpeedDefault->setValue( static_cast<int>( s->mDefaultSpeed ) );  

  int idx = mcbLayers->findText( s->mLayer );

  if (idx != -1)

  {

    mcbLayers->setCurrentIndex( idx );

  }

  idx = mcbDirection->findText( s->mDirection );

  if (idx != -1)

    mcbDirection->setCurrentIndex( idx );

  idx = mcbSpeed->findText( s->mSpeed );

  if (idx != -1)

    mcbSpeed->setCurrentIndex( idx );

  switch( s->mDefaultDirection )

  {

  case RgLineVectorLayerSettings::Both:

    mcbDirectionDefault->setCurrentIndex(0);

    break;

  case RgLineVectorLayerSettings::FirstPointToLastPoint:

    mcbDirectionDefault->setCurrentIndex(1);

    break;

  case RgLineVectorLayerSettings::LastPointToFirstPoint:

    mcbDirectionDefault->setCurrentIndex(2);

    break;

  }

} // RgLineVectorLayerSettingsWidget::RgLineVectorLayerSettingsWidget()

QgsVectorLayer* RgLineVectorLayerSettingsWidget::selectedLayer()

{

  QMap<QString, QgsMapLayer*> mapLayers = QgsMapLayerRegistry::instance()->mapLayers();

  QMap<QString, QgsMapLayer*>::iterator layer_it = mapLayers.begin();

  for ( ; layer_it != mapLayers.end(); ++layer_it )

  {

    QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( layer_it.value() );

    if ( !vl )

      continue;

    if ( vl->geometryType() != QGis::Line )

      continue;

    if ( vl->name() == mcbLayers->currentText() )

      return vl;

  }

  return NULL;

} // RgLineVectorLayerSettingsWidget::setlectedLayer()

void RgLineVectorLayerSettingsWidget::on_mcbLayers_selectItem()

{

  mcbDirection->clear();

  mcbSpeed->clear();

  mcbDirection->insertItem( 0, tr("Always use default") );

  mcbSpeed->insertItem( 0, tr("Always use default") );

  QgsVectorLayer* vl = selectedLayer();

  if ( !vl )

    return;

  QgsVectorDataProvider* provider = vl->dataProvider();

  if ( !provider )

    return;

  const QgsFieldMap& fields = provider->fields();

  QgsFieldMap::const_iterator it;

  for (it = fields.constBegin(); it != fields.constEnd(); ++it)

  {

    QgsField currentField = it.value();

    QVariant currentType = currentField.type();

    if ( currentType == QVariant::Int || currentType == QVariant::String )

    {

      mcbDirection->insertItem(1, currentField.name());

    }

    if ( currentType == QVariant::Int || currentType == QVariant::Double )

    {

      mcbSpeed->insertItem(1, currentField.name());

    }

  }

} // RgDSettingsDlg::on_mcbLayers_selectItem()

/***************************************************************************

  graphbuilder.h

  --------------------------------------

  Date                 : 2010-10-22

  Copyright            : (C) 2010 by Yakushev Sergey

  Email                : YakushevS <at> list.ru

****************************************************************************

*                                                                          *

*   This program is free software; you can redistribute it and/or modify   *

*   it under the terms of the GNU General Public License as published by   *

*   the Free Software Foundation; either version 2 of the License, or      *

*   (at your option) any later version.                                    *

*                                                                          *

***************************************************************************/

#ifndef ROADGRAPH_GRAPHBUILDER

#define ROADGRAPH_GRAPHBUILDER

#include "utils.h"

//QT4 includes

//QGIS includes

#include <qgspoint.h>

#include <qgscoordinatereferencesystem.h>

//forward declarations

/**

* \class RgGraphDirector

* \brief Determine making the graph

* contained the settings

*/

class RgGraphBuilder

{

public:

  //! Destructor

  virtual ~RgGraphBuilder()

  {};

  /**

   * set source CRS

   */

  virtual void setSourceCrs( const QgsCoordinateReferenceSystem& crs ) = 0;

  /**

   * set destionation CRS

   */

  virtual void setDestinationCrs( const QgsCoordinateReferenceSystem& crs ) = 0;

  /**

   * add vertex

   */

  virtual void addVertex( const QgsPoint& pt ) = 0;

  /**

   * add arc

   */

  virtual void addArc( const QgsPoint& pt1, const QgsPoint& pt2, double speed ) = 0;

  /**

   * tie point

   * @param pt maps point

   * @param pt ok = false if tiePoint failed.

   * @return Graph vertex corresponding pt.

   * @note: graph can be modified

   */

  virtual QgsPoint tiePoint( const QgsPoint &pt, bool &ok ) = 0;

};

#endif //GRAPHBUILDER