pgrouting::alphashape::anonymous_namespace{pgr_alphaShape.cpp} Namespace Reference

Classes
struct	CompareRadius

Typedefs
typedef std::pair< Triangle, double >	MyPairType

Functions
Bpoint	circumcenter (const Bpoint a, const Bpoint b, const Bpoint c)
double	det (double r00, double r01, double r10, double r11)
template<typename B_G , typename V >
Bpoly	get_polygon (V source, V target, const std::vector< V > &predecessors, const B_G &graph, std::set< E > &edges_used)
template<typename B_G , typename V >
std::vector< V >	get_predecessors (V source, V target, const B_G &subg)

Typedef Documentation

MyPairType

typedef std::pair<Triangle, double> pgrouting::alphashape::anonymous_namespace{pgr_alphaShape.cpp}::MyPairType

Definition at line 154 of file pgr_alphaShape.cpp.

Function Documentation

circumcenter()

Bpoint pgrouting::alphashape::anonymous_namespace{pgr_alphaShape.cpp}::circumcenter	(	const Bpoint	a,
		const Bpoint	b,
		const Bpoint	c
	)

Definition at line 73 of file pgr_alphaShape.cpp.

                                                             {
    auto cx = c.x();
    auto cy = c.y();
    auto ax = a.x() - cx;
    auto ay = a.y() - cy;
    auto bx = b.x() - cx;
    auto by = b.y() - cy;
 
    auto denom = 2 * det(ax, ay, bx, by);
    /*
     * If denom == 0 then points are colinear
     */
    pgassert(denom != 0);
 
    auto numx = det(ay, ax * ax + ay * ay, by, bx * bx + by * by);
    auto numy = det(ax, ax * ax + ay * ay, bx, bx * bx + by * by);
 
    return Bpoint {cx - numx / denom, cy + numy / denom};
}

References det(), and pgassert.

Referenced by pgrouting::alphashape::Pgr_alphaShape::radius().

det()

double pgrouting::alphashape::anonymous_namespace{pgr_alphaShape.cpp}::det	(	double	r00,
		double	r01,
		double	r10,
		double	r11
	)

Definition at line 68 of file pgr_alphaShape.cpp.

                                                    {
    return r00 * r11 - r01 * r10;
}

Referenced by circumcenter().

get_polygon()

template<typename B_G , typename V >

Bpoly pgrouting::alphashape::anonymous_namespace{pgr_alphaShape.cpp}::get_polygon	(	V	source,
		V	target,
		const std::vector< V > &	predecessors,
		const B_G &	graph,
		std::set< E > &	edges_used
	)

Definition at line 127 of file pgr_alphaShape.cpp.

                                                                                                            {
        Bpoly polygon;
        /*
         * There is no path -> returning empty polygon
         */
        if (target == predecessors[target]) {
            pgassert(bg::num_points(polygon) == 0);
            return polygon;
        }
 
        /*
         * the last stop is the target
         */
        bg::append(polygon.outer(), graph[source].point);
 
        /*
         * get the path
         */
        while (target != source || target != predecessors[target]) {
            bg::append(polygon.outer(), graph[target].point);
            edges_used.insert(boost::edge(predecessors[target], target, graph).first);
            target = predecessors[target];
        }
        bg::correct(polygon);
        return polygon;
}

References pgassert.

Referenced by pgrouting::alphashape::Pgr_alphaShape::operator()().

get_predecessors()

template<typename B_G , typename V >

std::vector<V> pgrouting::alphashape::anonymous_namespace{pgr_alphaShape.cpp}::get_predecessors	(	V	source,
		V	target,
		const B_G &	subg
	)

Definition at line 95 of file pgr_alphaShape.cpp.

                                                       {
    pgassert(boost::num_vertices(subg));
    std::vector<V> predecessors(boost::num_vertices(subg));
    std::vector<double> distances(num_vertices(subg));
    pgassert(predecessors.size() == boost::num_vertices(subg));
    pgassert(distances.size() == boost::num_vertices(subg));
 
    /* abort in case of an interruption occurs (e.g. the query is being cancelled) */
    CHECK_FOR_INTERRUPTS();
 
    try {
        boost::dijkstra_shortest_paths(subg, source,
                boost::predecessor_map(&predecessors[0])
                .weight_map(get(&Basic_edge::cost, subg))
                .distance_map(&distances[0])
                .visitor(visitors::dijkstra_one_goal_visitor<V>(target)));
    } catch(found_goals &) {
    } catch (boost::exception const& ex) {
        (void)ex;
        throw;
    } catch (std::exception &e) {
        (void)e;
        throw;
    } catch (...) {
             throw;
         }
    return predecessors;
}

References pgrouting::Basic_edge::cost, and pgassert.

Referenced by pgrouting::alphashape::Pgr_alphaShape::operator()().