pgrouting::Pg_points_graph Class Reference

#include "pgr_withPoints.hpp"

Inheritance diagram for pgrouting::Pg_points_graph:

Collaboration diagram for pgrouting::Pg_points_graph:

Classes
struct	pointCompare

Public Member Functions
	Pg_points_graph ()=delete
	Pg_points_graph (const Pg_points_graph &)=delete
	Pg_points_graph (std::vector< Point_on_edge_t > p_points, std::vector< pgr_edge_t > p_edges_to_modify, bool p_normal, char p_driving_side, bool p_directed)
void	adjust_pids (const std::vector< Point_on_edge_t > &points, Path &path)
void	clear ()
	clear More...
char	driving_side () const
std::vector< pgr_edge_t >	edges_of_points () const
Path	eliminate_details (Path path) const
void	eliminate_details_dd (Path &path) const
std::string	get_error () const
	get_error More...
std::string	get_log () const
	get_log More...
std::string	get_notice () const
	get_notice More...
bool	has_error () const
	get_error More...
std::vector< pgr_edge_t >	new_edges () const
std::vector< Point_on_edge_t >	points () const

Public Attributes
std::ostringstream	error
	Stores the error information. More...
std::ostringstream	log
	Stores the hint information. More...
std::ostringstream	notice
	Stores the notice information. More...

Private Member Functions
void	adjust_pids (const std::vector< Point_on_edge_t > &points, const int64_t &start_pid, const int64_t &end_pid, Path &path)
void	check_points ()
void	create_new_edges ()
const pgr_edge_t *	get_edge_data (int64_t eid) const
int64_t	get_edge_id (int64_t pid) const
void	reverse_sides ()

Private Attributes
bool	m_directed
char	m_driving_side
std::vector< pgr_edge_t >	m_edges_of_points
std::vector< pgr_edge_t >	m_new_edges
std::vector< Point_on_edge_t >	m_o_points
std::vector< Point_on_edge_t >	m_points

Friends
std::ostream &	operator<< (std::ostream &os, const Pg_points_graph &g)

Detailed Description

Definition at line 40 of file pgr_withPoints.hpp.

Constructor & Destructor Documentation

Pg_points_graph() [1/3]

pgrouting::Pg_points_graph::Pg_points_graph ( )

delete

Pg_points_graph() [2/3]

pgrouting::Pg_points_graph::Pg_points_graph ( const Pg_points_graph &  )

delete

Pg_points_graph() [3/3]

pgrouting::Pg_points_graph::Pg_points_graph	(	std::vector< Point_on_edge_t >	p_points,
		std::vector< pgr_edge_t >	p_edges_to_modify,
		bool	p_normal,
		char	p_driving_side,
		bool	p_directed
	)

Definition at line 71 of file pgr_withPoints.cpp.

                         :
    m_points(p_points),
    m_o_points(p_points),
    m_edges_of_points(p_edges_of_points),
    m_driving_side(p_driving_side),
    m_directed(p_directed) {
    if (!p_normal) {
        reverse_sides();
    }
    if (!m_directed) {
        m_driving_side = 'b';
    }
    check_points();
    create_new_edges();
    log << "constructor";
}

References check_points(), create_new_edges(), pgrouting::Pgr_messages::log, m_directed, m_driving_side, and reverse_sides().

Member Function Documentation

adjust_pids() [1/2]

void pgrouting::Pg_points_graph::adjust_pids ( const std::vector< Point_on_edge_t > &  points, const int64_t &  start_pid, const int64_t &  end_pid, Path &  path  )

private

Definition at line 273 of file pgr_withPoints.cpp.

                    {
    if (path.empty()) return;
    path.start_id(start_pid);
    path.end_id(end_pid);
 
    for (auto &path_stop : path) {
        for (const auto point : points) {
            if (point.vertex_id == path_stop.node) {
                path_stop.node = -point.pid;
                break;
            }
        }
    }
}

References Path::empty(), Path::end_id(), points(), and Path::start_id().

adjust_pids() [2/2]

void pgrouting::Pg_points_graph::adjust_pids	(	const std::vector< Point_on_edge_t > &	points,
		Path &	path
	)

Definition at line 293 of file pgr_withPoints.cpp.

                    {
    /*
     * There is no path nothing to do
     */
    if (path.empty()) return;
    /* from, to:
     *      * are constant along the path
     *           */
    int64_t start_vid = path.start_id();
    int64_t end_vid = path.end_id();
 
    int64_t start_pid = 0;
    int64_t end_pid = 0;
 
    for (auto &p : points) {
        if (p.vertex_id == start_vid) {
            start_pid = -p.pid;
        }
        if (p.vertex_id == end_vid) {
            end_pid = -p.pid;
        }
    }
    adjust_pids(points, start_pid, end_pid, path);
}

References Path::empty(), Path::end_id(), points(), and Path::start_id().

check_points()

void pgrouting::Pg_points_graph::check_points ( )

private

Definition at line 112 of file pgr_withPoints.cpp.

                              {
    log << "original points" << *this;
    /*
     * deleting duplicate points
     */
    std::sort(m_points.begin(), m_points.end(),
            [](const Point_on_edge_t &a, const Point_on_edge_t &b)
            -> bool {
            if (a.pid != b.pid) return a.pid < b.pid;
            if (a.edge_id != b.edge_id) return a.edge_id < b.edge_id;
            if (a.fraction != b.fraction) return a.fraction < b.fraction;
            return a.side < b.side;
            });
    log << "after sorting" << *this;
    auto last = std::unique(m_points.begin(), m_points.end(),
            [](const Point_on_edge_t &a, const Point_on_edge_t &b) {
            return a.pid == b.pid &&
            a.edge_id == b.edge_id &&
            a.fraction == b.fraction &&
            a.side == b.side;
            });
    m_points.erase(last, m_points.end());
    size_t total_points = m_points.size();
 
    log << "after deleting repetitions" << *this;
    log << "We have " << total_points << " different points";
 
    last = std::unique(m_points.begin(), m_points.end(),
            [](const Point_on_edge_t &a, const Point_on_edge_t &b) {
            return a.pid == b.pid;
            });
    m_points.erase(last, m_points.end());
    log << "after deleting points with same id" << *this;
 
    if (m_points.size() != total_points) {
        error << "Unexpected point(s) with same pid"
            << " but different edge/fraction/side combination found.";
    }
}

References pgrouting::Pgr_messages::error, pgrouting::Pgr_messages::log, and m_points.

Referenced by Pg_points_graph().

clear()

void pgrouting::Pgr_messages::clear ( )

inherited

clear

Clears All the messages

Definition at line 59 of file pgr_messages.cpp.

                    {
    log.str("");
    log.clear();
 
    notice.str("");
    notice.clear();
 
    error.str("");
    error.clear();
}

References pgrouting::Pgr_messages::error, pgrouting::Pgr_messages::log, and pgrouting::Pgr_messages::notice.

Referenced by do_pgr_pickDeliver().

create_new_edges()

void pgrouting::Pg_points_graph::create_new_edges ( )

private

Definition at line 328 of file pgr_withPoints.cpp.

                                  {
    for (const auto &point : m_points) {
        log << "point: "
            << point.pid << "\t"
            << point.edge_id << "\t"
            << point.fraction << "\t"
            << point.side << "\t"
            << point.vertex_id << "\n";
    }
 
    int64_t vertex_id = 1;
    std::vector< Point_on_edge_t > new_points;
    for (const auto edge : m_edges_of_points) {
        std::set< Point_on_edge_t, pointCompare> points_on_edge;
        for (const auto point : m_points) {
            if (edge.id == point.edge_id) {
                points_on_edge.insert(point);
                log << "working points: "
                    << point.pid << "\t"
                    << point.edge_id << "\t"
                    << point.fraction << "\t"
                    << point.side << "\t"
                    << point.vertex_id << "\n";
            }
        }
        if (points_on_edge.empty()) {
            error << "For some reason didn't find a point belonging to the edge"
                << ", must be an error\n";
            return;
        }
#if 0
        log << "breaking: \n"
            << edge.id << "\t"
            << edge.source << "\t"
            << edge.target << "\t"
            << edge.cost << "\t"
            << edge.reverse_cost << "\n";
#endif
        int64_t prev_target = edge.source;
        int64_t prev_rtarget = edge.source;
        double prev_fraction = 0;
        double prev_rfraction = 0;
        double agg_cost = 0;
        double agg_rcost = 0;
        double last_cost = 0;
        double last_rcost = 0;
        std::vector<Point_on_edge_t> the_points(
                points_on_edge.begin(), points_on_edge.end());
 
        for (auto &point : the_points) {
            /* the point either has
             * vertex_id = source
             * vertex_id = target
             * vertex_id = -newnumber
             */
            log << "\npid"
                << point.pid
                << "\teid" << point.edge_id
                << "/t" << point.fraction
                << "\t" << point.side << "\n";
            if (point.fraction < 0 ||  point.fraction > 1) {
                error << "For some reason an invalid fraction was accepted,"
                    << " must be an error\n";
                return;
            }
            if (point.fraction == 0) {
                log << "Point's vertex_id = source" << edge.source << "\n";
                point.vertex_id = edge.source;
            }
            if (point.fraction == 1) {
                log << "point's vertex_id = target" << edge.target << "\n";
                point.vertex_id = edge.target;
            }
            if (point.fraction > 0 &&  point.fraction < 1) {
                log << "vertex_id of the point is " << -point.pid << "\n";
                point.vertex_id = -point.pid;
                ++vertex_id;
            }
            new_points.push_back(point);
 
            double deltaFraction = point.fraction - prev_fraction;
            double deltarFraction = point.fraction - prev_rfraction;
            if ((edge.cost < 0 ||  edge.reverse_cost < 0)
                    || m_driving_side == 'b'
                    || point.side == 'b') {
                log << "Edge is one way "
                    << " or driving side is both or point side is both\n";
                log << "Edge is one way: "
                    << (edge.cost < 0 || edge.reverse_cost < 0)
                    << "\n";
                log << "driving side: " << m_driving_side << "\n";
                log << "point side: " << point.side << "\n";
                if (point.fraction > 0 &&  point.fraction < 1) {
                    if (edge.cost >= 0) {
                        last_cost = deltaFraction * edge.cost;
                        pgr_edge_t new_edge = {
                            edge.id,
                            prev_target,
                            point.vertex_id,
                            last_cost,
                            -1};
                        m_new_edges.push_back(new_edge);
                        log << "new_edge("
                            << "id, source, target, cost, reverse_cost) = ("
                            << new_edge.id << "\t"
                            << new_edge.source << "\t"
                            << new_edge.target << "\t"
                            << new_edge.cost << "\t"
                            << new_edge.reverse_cost << ")\n";
                    }
                    if (edge.reverse_cost >= 0) {
                        last_rcost = deltarFraction * edge.reverse_cost;
                        pgr_edge_t new_edge = {
                            edge.id,
                            prev_target,
                            point.vertex_id,
                            -1,
                            last_rcost};
                        m_new_edges.push_back(new_edge);
                        log << "new_edge("
                            << "id, source, target, cost, reverse_cost) = ("
                            << new_edge.id << "\t"
                            << new_edge.source << "\t"
                            << new_edge.target << "\t"
                            << new_edge.cost << "\t"
                            << new_edge.reverse_cost << ")\n";
                    }
                }
                prev_target = point.vertex_id;
                prev_fraction = point.fraction;
                agg_cost += last_cost;
 
                prev_rtarget = point.vertex_id;
                prev_rfraction = point.fraction;
                agg_rcost += last_rcost;
                continue;
            }
 
            pgassert(edge.cost > 0 &&  edge.reverse_cost > 0);
            pgassert(point.side != 'b');
 
            if (m_driving_side == point.side) {
                log << "two way and driving side == the side of the point\n";
                log << "Breaking (source, target) when its not the extreme\n";
                if (point.fraction > 0 &&  point.fraction < 1) {
                    last_cost = deltaFraction * edge.cost;
                    pgr_edge_t new_edge = {
                        edge.id, prev_target, point.vertex_id, last_cost, -1};
                    m_new_edges.push_back(new_edge);
                    log << "new_edge("
                        << "id, source, target, cost, reverse_cost) = ("
                        << new_edge.id << "\t"
                        << new_edge.source << "\t"
                        << new_edge.target << "\t"
                        << new_edge.cost << "\t"
                        << new_edge.reverse_cost << ")\n";
                }
                prev_target = point.vertex_id;
                prev_fraction = point.fraction;
                agg_cost += last_cost;
                continue;
            }
 
            log << "\ntwo way and driving side != the side of the point";
            if (point.fraction > 0 &&  point.fraction < 1) {
                last_rcost = deltarFraction * edge.reverse_cost;
                pgr_edge_t new_edge = {
                    edge.id,
                    prev_rtarget,
                    point.vertex_id,
                    -1,
                    last_rcost};
                m_new_edges.push_back(new_edge);
                log << "\nnew_edge(id, source, target, cost, reverse_cost) = ("
                    << new_edge.id << "\t"
                    << new_edge.source << "\t"
                    << new_edge.target << "\t"
                    << new_edge.cost << "\t"
                    << new_edge.reverse_cost << ")\n";
            }
            prev_rtarget = point.vertex_id;
            prev_rfraction = point.fraction;
            agg_rcost += last_rcost;
        }
 
        {  //  the last segments
            pgr_edge_t new_edge = {
                edge.id,
                prev_target,
                edge.target,
                (edge.cost - agg_cost),
                -1};
            m_new_edges.push_back(new_edge);
            log << "last edge: (id, source, target, cost, reverse_cost) = ("
                << new_edge.id << "\t"
                << new_edge.source << "\t"
                << new_edge.target << "\t"
                << new_edge.cost << "\t"
                << new_edge.reverse_cost << ")\n";
 
            new_edge = {edge.id , prev_rtarget, edge.target,
                -1, (edge.reverse_cost - agg_rcost)};
            m_new_edges.push_back(new_edge);
            log << "last edge: (id, source, target, cost, reverse_cost) = ("
                << new_edge.id << "\t"
                << new_edge.source << "\t"
                << new_edge.target << "\t"
                << new_edge.cost << "\t"
                << new_edge.reverse_cost << ")\n";
        }
    }
 
    m_points = new_points;
    for (const auto &point : m_points) {
        log << "point: "
            << point.pid << "\t"
            << point.edge_id << "\t"
            << point.fraction << "\t"
            << point.side << "\t"
            << point.vertex_id << "\n";
    }
}

References pgr_edge_t::cost, edge::cost, pgrouting::Pgr_messages::error, pgr_edge_t::id, edge::id, pgrouting::Pgr_messages::log, m_driving_side, m_edges_of_points, m_new_edges, m_points, pgassert, pgr_edge_t::reverse_cost, edge::reverse_cost, pgr_edge_t::source, edge::source, pgr_edge_t::target, and edge::target.

Referenced by Pg_points_graph().

driving_side()

char pgrouting::Pg_points_graph::driving_side ( ) const

inline

Definition at line 61 of file pgr_withPoints.hpp.

{return m_driving_side;}

References m_driving_side.

edges_of_points()

std::vector< pgr_edge_t > pgrouting::Pg_points_graph::edges_of_points

(

)

const

Definition at line 65 of file pgr_withPoints.cpp.

                                       {
    return m_edges_of_points;
}

References m_edges_of_points.

eliminate_details()

Path pgrouting::Pg_points_graph::eliminate_details

(

Path

path

)

const

Definition at line 229 of file pgr_withPoints.cpp.

                         {
    /*
     * There is no path nothing to do
     */
    if (path.empty()) return path;
 
    Path newPath(path.start_id(), path.end_id());
    double cost = 0.0;
    for (const auto &pathstop : path) {
        if ((pathstop.node == path.start_id())
                || (pathstop.node == path.end_id())
                || (pathstop.node > 0)) {
            newPath.push_back(pathstop);
            if (pathstop.node != path.end_id()) cost = 0.0;
            continue;
        }
        cost += pathstop.cost;
    }
 
    newPath[0].cost = newPath[1].agg_cost;
    for (unsigned int i = 1; i < newPath.size() - 2; ++i) {
        /* newPath[i] has: node, edge, cost, agg_cost
         * pgr_type_t has: id, source, target, cost, reverse_cost
         *
         * find the edge where the pathstop.edge == edge.id */
 
        int64_t edge_to_find = newPath[i].edge;
        auto edge_ptr = std::find_if(
                m_edges_of_points.begin(), m_edges_of_points.end(),
                [&edge_to_find](const pgr_edge_t &edge)
                {return edge_to_find == edge.id;});
        if (edge_ptr != m_edges_of_points.end()) {
            newPath[i].cost = edge_ptr->target == newPath[i+1].node ?
                edge_ptr->cost : edge_ptr->reverse_cost;
        }
    }
    newPath[newPath.size()-2].cost += cost;
 
    return newPath;
}

References Path::empty(), Path::end_id(), m_edges_of_points, Path::push_back(), Path::size(), and Path::start_id().

Referenced by do_pgr_withPoints(), and do_pgr_withPointsKsp().

eliminate_details_dd()

void pgrouting::Pg_points_graph::eliminate_details_dd

(

Path &

path

)

const

Definition at line 176 of file pgr_withPoints.cpp.

                          {
    /*
     * There is no path nothing to do
     */
    if (path.empty()) return;
 
    Path newPath(path.start_id(), path.end_id());
    auto edge_id = path.start_id() < 0?
        get_edge_id(path.start_id()) :
        -1;
 
    for (auto pathstop : path) {
        /*
         * skip points (no details)
         *  except if ithe point its the starting point
         */
        if (!((pathstop.node == path.start_id())
                || (pathstop.node > 0))) {
            continue;
        }
 
        /*
         * Change costs only when the node is not:
         * - start_id
         * - directly connected to start_id
         */
        if (pathstop.node != path.start_id()) {
            auto edge_ptr = get_edge_data(pathstop.edge);
            /*
             * edge found
             * and its not the edge directly connected to start_id()
             */
            if (edge_ptr
                    && edge_ptr->id != edge_id) {
                pathstop.cost = pathstop.node == edge_ptr->source?
                    edge_ptr->cost :
                        edge_ptr->reverse_cost;
                }
        }
 
        /*
         * add to the new path
         */
        newPath.push_back(pathstop);
    }
 
    path = newPath;
}

References Path::empty(), Path::end_id(), get_edge_data(), get_edge_id(), Path::push_back(), and Path::start_id().

Referenced by do_pgr_many_withPointsDD().

get_edge_data()

const pgr_edge_t * pgrouting::Pg_points_graph::get_edge_data ( int64_t  eid ) const

private

Definition at line 165 of file pgr_withPoints.cpp.

                                                {
    auto e_itr = std::find_if(
            m_edges_of_points.begin(), m_edges_of_points.end(),
            [&eid](const pgr_edge_t &edge)
            {return eid == edge.id;});
    return e_itr ==  m_edges_of_points.end()?
       nullptr : &(*e_itr);
}

References m_edges_of_points.

Referenced by eliminate_details_dd().

get_edge_id()

int64_t pgrouting::Pg_points_graph::get_edge_id ( int64_t  pid ) const

private

Definition at line 154 of file pgr_withPoints.cpp.

                                              {
    auto point_ptr = std::find_if(
            m_points.begin(), m_points.end(),
            [&pid](const Point_on_edge_t &point)
            {return pid == -point.pid;});
    return point_ptr != m_points.end() ?
        point_ptr->edge_id :
        -1;
}

References m_points.

Referenced by eliminate_details_dd().

get_error()

std::string pgrouting::Pgr_messages::get_error ( ) const

inherited

get_error

Returns

the current contents of the log and clears the log

Definition at line 53 of file pgr_messages.cpp.

                              {
    auto str = error.str();
    return str;
}

References pgrouting::Pgr_messages::error.

Referenced by do_pgr_many_withPointsDD(), do_pgr_pickDeliver(), do_pgr_pickDeliverEuclidean(), do_pgr_withPoints(), do_pgr_withPointsKsp(), and pgrouting::vrp::Pgr_pickDeliver::Pgr_pickDeliver().

get_log()

std::string pgrouting::Pgr_messages::get_log ( ) const

inherited

get_log

Returns

the current contents of the log and clears the log

Definition at line 36 of file pgr_messages.cpp.

                            {
    auto str = log.str();
    return str;
}

References pgrouting::Pgr_messages::log.

Referenced by do_pgr_bipartite(), do_pgr_boyerMyrvold(), do_pgr_LTDTree(), do_pgr_makeConnected(), do_pgr_many_withPointsDD(), do_pgr_pickDeliver(), do_pgr_pickDeliverEuclidean(), do_pgr_withPoints(), do_pgr_withPointsKsp(), pgr_bellman_ford(), pgr_dijkstraTR(), and pgrouting::vrp::Pgr_pickDeliver::Pgr_pickDeliver().

get_notice()

std::string pgrouting::Pgr_messages::get_notice ( ) const

inherited

get_notice

Returns

the current contents of the log and clears the log

Definition at line 42 of file pgr_messages.cpp.

                               {
    auto str = notice.str();
    return str;
}

References pgrouting::Pgr_messages::notice.

has_error()

bool pgrouting::Pgr_messages::has_error ( ) const

inherited

get_error

Returns

the current contents of the log and clears the log

Definition at line 48 of file pgr_messages.cpp.

                              {
    return  !error.str().empty();
}

References pgrouting::Pgr_messages::error.

Referenced by do_pgr_many_withPointsDD(), do_pgr_withPoints(), and do_pgr_withPointsKsp().

new_edges()

std::vector< pgr_edge_t > pgrouting::Pg_points_graph::new_edges

(

)

const

Definition at line 323 of file pgr_withPoints.cpp.

                                 {
    return m_new_edges;
}

References m_new_edges.

Referenced by do_pgr_many_withPointsDD(), do_pgr_withPoints(), and do_pgr_withPointsKsp().

points()

std::vector< Point_on_edge_t > pgrouting::Pg_points_graph::points

(

)

const

Definition at line 60 of file pgr_withPoints.cpp.

                              {
    return m_points;
}

References m_points.

Referenced by adjust_pids().

reverse_sides()

void pgrouting::Pg_points_graph::reverse_sides ( )

private

Definition at line 94 of file pgr_withPoints.cpp.

                               {
    for (auto &point : m_points) {
        if (point.side == 'r') {
            point.side = 'l';
        } else if (point.side == 'l') {
            point.side = 'r';
        }
        point.fraction = 1 - point.fraction;
    }
    if (m_driving_side == 'r') {
        m_driving_side = 'l';
    } else if (m_driving_side == 'l') {
        m_driving_side = 'r';
    }
}

References m_driving_side, and m_points.

Referenced by Pg_points_graph().

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  os, const Pg_points_graph &  g  )

friend

Definition at line 46 of file pgr_withPoints.cpp.

                                                  {
    for (const auto p : g.m_points) {
        os << p.pid << "\t"
            << p.edge_id << "\t"
            << p.fraction << "\t"
            << p.side << "\n";
    }
    return os;
}

Member Data Documentation

error

std::ostringstream pgrouting::Pgr_messages::error

mutableinherited

Stores the error information.

Definition at line 85 of file pgr_messages.h.

Referenced by pgrouting::vrp::Fleet::build_fleet(), check_points(), pgrouting::Pgr_messages::clear(), create_new_edges(), pgrouting::Pgr_messages::get_error(), pgrouting::Pgr_messages::has_error(), pgrouting::vrp::Fleet::is_fleet_ok(), and pgrouting::vrp::Pgr_pickDeliver::Pgr_pickDeliver().

log

std::ostringstream pgrouting::Pgr_messages::log

mutableinherited

Stores the hint information.

Definition at line 81 of file pgr_messages.h.

Referenced by pgrouting::vrp::Fleet::add_vehicle(), Pgr_bellman_ford< G >::bellman_ford(), Pgr_bellman_ford< G >::bellman_ford_1_to_1(), Pgr_bellman_ford< G >::bellman_ford_1_to_many(), pgrouting::alphashape::Pgr_alphaShape::build_best_alpha(), pgrouting::vrp::Fleet::build_fleet(), check_points(), pgrouting::Pgr_messages::clear(), create_new_edges(), pgrouting::vrp::Vehicle_pickDeliver::do_while_feasable(), pgrouting::vrp::Initial_solution::do_while_foo(), pgrouting::functions::Pgr_makeConnected< G >::generatemakeConnected(), pgrouting::Pgr_messages::get_log(), Pgr_bellman_ford< G >::get_paths(), pgrouting::vrp::Pgr_pickDeliver::get_postgres_result(), pgrouting::vrp::Vehicle::get_postgres_result(), pgrouting::vrp::Fleet::get_truck(), pgrouting::vrp::Optimize::inter_swap(), pgrouting::vrp::Fleet::is_fleet_ok(), pgrouting::vrp::Initial_solution::one_truck_all_orders(), pgrouting::vrp::Optimize::Optimize(), Pg_points_graph(), pgrouting::vrp::Pgr_pickDeliver::Pgr_pickDeliver(), pgrouting::vrp::Optimize::save_if_best(), pgrouting::vrp::Solution::Solution(), pgrouting::vrp::Pgr_pickDeliver::solve(), and pgrouting::vrp::Vehicle::Vehicle().

m_directed

bool pgrouting::Pg_points_graph::m_directed

private

Definition at line 96 of file pgr_withPoints.hpp.

Referenced by Pg_points_graph().

m_driving_side

char pgrouting::Pg_points_graph::m_driving_side

private

Definition at line 95 of file pgr_withPoints.hpp.

Referenced by create_new_edges(), driving_side(), Pg_points_graph(), and reverse_sides().

m_edges_of_points

std::vector<pgr_edge_t> pgrouting::Pg_points_graph::m_edges_of_points

private

Definition at line 93 of file pgr_withPoints.hpp.

Referenced by create_new_edges(), edges_of_points(), eliminate_details(), and get_edge_data().

m_new_edges

std::vector<pgr_edge_t> pgrouting::Pg_points_graph::m_new_edges

private

Definition at line 94 of file pgr_withPoints.hpp.

Referenced by create_new_edges(), and new_edges().

m_o_points

std::vector<Point_on_edge_t> pgrouting::Pg_points_graph::m_o_points

private

Definition at line 92 of file pgr_withPoints.hpp.

m_points

std::vector<Point_on_edge_t> pgrouting::Pg_points_graph::m_points

private

Definition at line 91 of file pgr_withPoints.hpp.

Referenced by check_points(), create_new_edges(), get_edge_id(), pgrouting::operator<<(), points(), and reverse_sides().

notice

std::ostringstream pgrouting::Pgr_messages::notice

mutableinherited

Stores the notice information.

Definition at line 83 of file pgr_messages.h.

Referenced by pgrouting::Pgr_messages::clear(), and pgrouting::Pgr_messages::get_notice().

---

The documentation for this class was generated from the following files:

• pgr_withPoints.hpp
• pgr_withPoints.cpp