gtfs-actions/generate-shapes
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

make geometry precision configurable for build

Browse source
This commit is contained in:
Patrick Brosi 2018-08-10 16:42:38 +02:00
parent 486a8136fd
commit 8446db5c4b
25 changed files with 222 additions and 208 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
CMakeLists.txt
View file

@ -50,6 +50,8 @@ else ()
message(FATAL_ERROR "Your C++ compiler does not support C++11.")
endif ()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPFAEDLE_PRECISION=${PFAEDLE_PRECISION}")
# http://brianmilco.blogspot.de/2012/11/cmake-automatically-use-git-tags-as.html
include(GetGitRevisionDescription)
git_get_tag(VERSION_GIT)

7
src/pfaedle/config/ConfigReader.cpp
View file

@ -7,6 +7,7 @@
#include <exception>
#include <iostream>
#include <string>
#include "pfaedle/Def.h"
#include "pfaedle/_config.h"
#include "pfaedle/config/ConfigReader.h"
#include "util/String.h"
@ -27,7 +28,8 @@ static const char* AUTHORS = "Patrick Brosi <brosi@informatik.uni-freiburg.de>";
void ConfigReader::help(const char* bin) {
std::cout
<< std::setfill(' ') << std::left << "pfaedle GTFS map matcher\n"
<< VERSION_FULL << " (built " << __DATE__ << " " << __TIME__ << ")\n\n"
<< VERSION_FULL << " (built " << __DATE__ << " " << __TIME__
<< " with geometry precision <" << PFAEDLE_PRECISION_STR << ">)\n\n"
<< "(C) " << YEAR << " " << COPY << "\n"
<< "Authors: " << AUTHORS << "\n\n"
<< "Usage: " << bin << " -x <OSM FILE> -c <CFG FILE> <GTFS FEED>\n\n"
@ -170,7 +172,8 @@ void ConfigReader::read(Config* cfg, int argc, char** argv) {
break;
case 'v':
std::cout << "pfaedle " << VERSION_FULL << " (built " << __DATE__ << " "
<< __TIME__ << ")\n"
<< __TIME__ << " with geometry precision <"
<< PFAEDLE_PRECISION_STR << ">)\n"
<< "(C) " << YEAR << " " << COPY << "\n"
<< "Authors: " << AUTHORS << "\nGNU General Public "
"License v3.0\n";

63
src/pfaedle/eval/Collector.cpp
View file

@ -8,6 +8,7 @@
#include <string>
#include <utility>
#include "ad/cppgtfs/gtfs/Feed.h"
#include "pfaedle/Def.h"
#include "pfaedle/eval/Collector.h"
#include "pfaedle/eval/Result.h"
#include "util/geo/Geo.h"
@ -15,9 +16,8 @@
#include "util/geo/output/GeoJsonOutput.h"
#include "util/log/Log.h"
using util::geo::DLine;
using util::geo::PolyLine;
using util::geo::DPoint;
using ad::cppgtfs::gtfs::Trip;
using ad::cppgtfs::gtfs::Shape;
using pfaedle::eval::Collector;
@ -46,12 +46,12 @@ double Collector::add(const Trip* t, const Shape* oldS, const Shape* newS,
double unmatchedSegmentsLength;
std::vector<double> oldDists;
DLine oldL = getWebMercLine(
LINE oldL = getWebMercLine(
oldS, t->getStopTimes().begin()->getShapeDistanceTravelled(),
(--t->getStopTimes().end())->getShapeDistanceTravelled(), &oldDists);
std::vector<double> newDists;
DLine newL = getWebMercLine(newS, -1, -1, &newDists);
LINE newL = getWebMercLine(newS, -1, -1, &newDists);
std::ofstream fstr(_evalOutPath + "/trip-" + t->getId() + ".json");
GeoJsonOutput gjout(fstr);
@ -61,8 +61,8 @@ double Collector::add(const Trip* t, const Shape* oldS, const Shape* newS,
// cut both result at the beginning and end to clear evaluation from
// loops at the end
PolyLine<double> oldStart = oldSegs[0];
PolyLine<double> newStart = newSegs[0];
POLYLINE oldStart = oldSegs[0];
POLYLINE newStart = newSegs[0];
auto oldStartNew =
oldStart.getSegment(oldStart.projectOn(newSegs[0][0]).totalPos, 1);
auto newStartNew =
@ -77,8 +77,8 @@ double Collector::add(const Trip* t, const Shape* oldS, const Shape* newS,
newSegs[0] = newStartNew.getLine();
}
PolyLine<double> oldEnd = oldSegs[oldSegs.size() - 1];
PolyLine<double> newEnd = newSegs[oldSegs.size() - 1];
POLYLINE oldEnd = oldSegs[oldSegs.size() - 1];
POLYLINE newEnd = newSegs[oldSegs.size() - 1];
auto oldEndNew =
oldEnd.getSegment(0, oldEnd.projectOn(newSegs.back().back()).totalPos);
auto newEndNew =
@ -103,8 +103,8 @@ double Collector::add(const Trip* t, const Shape* oldS, const Shape* newS,
}
// new lines build from cleaned-up shapes
DLine oldLCut;
DLine newLCut;
LINE oldLCut;
LINE newLCut;
for (auto oldL : oldSegs) {
gjout.print(oldL, util::json::Dict{{"ver", "old"}});
@ -166,32 +166,31 @@ double Collector::add(const Trip* t, const Shape* oldS, const Shape* newS,
<< " A_L/L = " << unmatchedSegmentsLength << "/" << totL << " = "
<< unmatchedSegmentsLength / totL << " d_f = " << fd;
return fd;
}
// _____________________________________________________________________________
std::vector<DLine> Collector::segmentize(
const Trip* t, const DLine& shape, const std::vector<double>& dists,
std::vector<LINE> Collector::segmentize(
const Trip* t, const LINE& shape, const std::vector<double>& dists,
const std::vector<double>* newTripDists) {
std::vector<DLine> ret;
std::vector<LINE> ret;
if (t->getStopTimes().size() < 2) return ret;
util::geo::PolyLine<double> pl(shape);
std::vector<std::pair<DPoint, double> > cuts;
POLYLINE pl(shape);
std::vector<std::pair<POINT, double> > cuts;
size_t i = 0;
for (auto st : t->getStopTimes()) {
if (newTripDists) {
cuts.push_back(std::pair<DPoint, double>(
util::geo::latLngToWebMerc<double>(st.getStop()->getLat(),
st.getStop()->getLng()),
cuts.push_back(std::pair<POINT, double>(
util::geo::latLngToWebMerc<PFAEDLE_PRECISION>(st.getStop()->getLat(),
st.getStop()->getLng()),
(*newTripDists)[i]));
} else {
cuts.push_back(std::pair<DPoint, double>(
util::geo::latLngToWebMerc<double>(st.getStop()->getLat(),
st.getStop()->getLng()),
cuts.push_back(std::pair<POINT, double>(
util::geo::latLngToWebMerc<PFAEDLE_PRECISION>(st.getStop()->getLat(),
st.getStop()->getLng()),
st.getShapeDistanceTravelled()));
}
i++;
@ -200,8 +199,7 @@ std::vector<DLine> Collector::segmentize(
// get first half of geometry, and search for start point there!
size_t before = std::upper_bound(dists.begin(), dists.end(), cuts[1].second) -
dists.begin();
util::geo::PolyLine<double> l(
DLine(shape.begin(), shape.begin() + before + 1));
POLYLINE l(LINE(shape.begin(), shape.begin() + before + 1));
auto lastLp = l.projectOn(cuts.front().first);
for (size_t i = 1; i < cuts.size(); i++) {
@ -212,8 +210,7 @@ std::vector<DLine> Collector::segmentize(
dists.begin();
}
util::geo::PolyLine<double> beforePl(
DLine(shape.begin(), shape.begin() + before));
POLYLINE beforePl(LINE(shape.begin(), shape.begin() + before));
auto curLp = beforePl.projectOnAfter(cuts[i].first, lastLp.lastIndex);
@ -226,14 +223,14 @@ std::vector<DLine> Collector::segmentize(
}
// _____________________________________________________________________________
DLine Collector::getWebMercLine(const Shape* s, double from, double t) {
LINE Collector::getWebMercLine(const Shape* s, double from, double t) {
return getWebMercLine(s, from, t, 0);
}
// _____________________________________________________________________________
DLine Collector::getWebMercLine(const Shape* s, double from, double to,
std::vector<double>* dists) {
DLine ret;
LINE Collector::getWebMercLine(const Shape* s, double from, double to,
std::vector<double>* dists) {
LINE ret;
auto i = s->getPoints().begin();
@ -243,7 +240,7 @@ DLine Collector::getWebMercLine(const Shape* s, double from, double to,
if ((from < 0 || (p.travelDist - from) > -0.01)) {
if (to >= 0 && (p.travelDist - to) > 0.01) break;
DPoint mercP = util::geo::latLngToWebMerc<double>(p.lat, p.lng);
POINT mercP = util::geo::latLngToWebMerc<PFAEDLE_PRECISION>(p.lat, p.lng);
ret.push_back(mercP);
if (dists) dists->push_back(p.travelDist);
@ -393,8 +390,8 @@ void Collector::printStats(std::ostream* os) const {
}
// _____________________________________________________________________________
std::pair<size_t, double> Collector::getDa(const std::vector<DLine>& a,
const std::vector<DLine>& b) {
std::pair<size_t, double> Collector::getDa(const std::vector<LINE>& a,
const std::vector<LINE>& b) {
assert(a.size() == b.size());
std::pair<size_t, double> ret{0, 0};

18
src/pfaedle/eval/Collector.h
View file

@ -12,12 +12,12 @@
#include <utility>
#include <vector>
#include "ad/cppgtfs/gtfs/Feed.h"
#include "pfaedle/Def.h"
#include "pfaedle/eval/Result.h"
#include "util/geo/Geo.h"
using ad::cppgtfs::gtfs::Trip;
using ad::cppgtfs::gtfs::Shape;
using util::geo::DLine;
namespace pfaedle {
namespace eval {
@ -57,9 +57,9 @@ class Collector {
// Return the averaged average frechet distance
double getAvgDist() const;
static DLine getWebMercLine(const Shape* s, double from, double to);
static DLine getWebMercLine(const Shape* s, double from, double to,
std::vector<double>* dists);
static LINE getWebMercLine(const Shape* s, double from, double to);
static LINE getWebMercLine(const Shape* s, double from, double to,
std::vector<double>* dists);
private:
std::set<Result> _results;
@ -78,12 +78,12 @@ class Collector {
std::vector<double> _dfBins;
static std::pair<size_t, double> getDa(const std::vector<DLine>& a,
const std::vector<DLine>& b);
static std::pair<size_t, double> getDa(const std::vector<LINE>& a,
const std::vector<LINE>& b);
static std::vector<DLine> segmentize(const Trip* t, const DLine& shape,
const std::vector<double>& dists,
const std::vector<double>* newTripDists);
static std::vector<LINE> segmentize(const Trip* t, const LINE& shape,
const std::vector<double>& dists,
const std::vector<double>* newTripDists);
static std::vector<double> getBins(double mind, double maxd, size_t steps);
};

8
src/pfaedle/netgraph/EdgePL.h
View file

@ -22,17 +22,17 @@ namespace netgraph {
* A payload class for edges on a network graph - that is a graph
* that exactly represents a physical public transit network
*/
class EdgePL : public GeoEdgePL<double> {
class EdgePL : public GeoEdgePL<PFAEDLE_PRECISION> {
public:
EdgePL() {}
EdgePL(const util::geo::DLine& l, const std::set<const Trip*>& trips)
EdgePL(const LINE& l, const std::set<const Trip*>& trips)
: _l(l), _trips(trips) {
for (const auto t : _trips) {
_routeShortNames.insert(t->getRoute()->getShortName());
_tripShortNames.insert(t->getShortname());
}
}
const util::geo::DLine* getGeom() const { return &_l; }
const LINE* getGeom() const { return &_l; }
util::json::Dict getAttrs() const {
util::json::Dict obj;
obj["num_trips"] = static_cast<int>(_trips.size());
@ -44,7 +44,7 @@ class EdgePL : public GeoEdgePL<double> {
}
private:
util::geo::DLine _l;
LINE _l;
std::set<const Trip*> _trips;
std::set<std::string> _routeShortNames;
std::set<std::string> _tripShortNames;

4
src/pfaedle/netgraph/Graph.h
View file

@ -11,8 +11,8 @@
using util::geo::Point;
using util::geo::Line;
using util::geo::DPoint;
using util::geo::DLine;
namespace pfaedle {
namespace netgraph {

10
src/pfaedle/netgraph/NodePL.h
View file

@ -11,7 +11,7 @@
#include "util/geo/GeoGraph.h"
using util::geograph::GeoNodePL;
using util::geo::DPoint;
namespace pfaedle {
namespace netgraph {
@ -20,18 +20,18 @@ namespace netgraph {
* A payload class for edges on a network graph - that is a graph
* that exactly represents a physical public transit network
*/
class NodePL : public GeoNodePL<double> {
class NodePL : public GeoNodePL<PFAEDLE_PRECISION> {
public:
NodePL() {}
NodePL(const util::geo::DPoint& geom) { _geom = geom; } // NOLINT
NodePL(const POINT& geom) { _geom = geom; } // NOLINT
const DPoint* getGeom() const { return &_geom; }
const POINT* getGeom() const { return &_geom; }
util::json::Dict getAttrs() const {
return util::json::Dict();
}
private:
DPoint _geom;
POINT _geom;
};
} // namespace netgraph
} // namespace pfaedle

12
src/pfaedle/osm/BBoxIdx.cpp
View file

@ -29,12 +29,12 @@ bool BBoxIdx::contains(const Point<double>& p) const {
}
// _____________________________________________________________________________
util::geo::Box<double> BBoxIdx::getFullWebMercBox() const {
return util::geo::DBox(
util::geo::latLngToWebMerc<double>(_root.box.getLowerLeft().getY(),
_root.box.getLowerLeft().getX()),
util::geo::latLngToWebMerc<double>(_root.box.getUpperRight().getY(),
_root.box.getUpperRight().getX()));
BOX BBoxIdx::getFullWebMercBox() const {
return BOX(
util::geo::latLngToWebMerc<PFAEDLE_PRECISION>(
_root.box.getLowerLeft().getY(), _root.box.getLowerLeft().getX()),
util::geo::latLngToWebMerc<PFAEDLE_PRECISION>(
_root.box.getUpperRight().getY(), _root.box.getUpperRight().getX()));
}
// _____________________________________________________________________________

3
src/pfaedle/osm/BBoxIdx.h
View file

@ -6,6 +6,7 @@
#define PFAEDLE_OSM_BBOXIDX_H_
#include <vector>
#include "pfaedle/Def.h"
#include "util/geo/Geo.h"
namespace pfaedle {
@ -35,7 +36,7 @@ class BBoxIdx {
bool contains(const Point<double>& box) const;
// Return the full total bounding box of this index
util::geo::Box<double> getFullWebMercBox() const;
BOX getFullWebMercBox() const;
// Return the size of this index
size_t size() const;

57
src/pfaedle/osm/OsmBuilder.cpp
View file

@ -12,6 +12,7 @@
#include <string>
#include <utility>
#include <vector>
#include "pfaedle/Def.h"
#include "pfaedle/osm/BBoxIdx.h"
#include "pfaedle/osm/Osm.h"
#include "pfaedle/osm/OsmBuilder.h"
@ -136,7 +137,7 @@ void OsmBuilder::read(const std::string& path, const OsmReadOpts& opts,
for (double d : opts.maxSnapDistances) {
for (auto s : orphanStations) {
DPoint geom = *s->pl().getGeom();
POINT geom = *s->pl().getGeom();
NodePL pl = s->pl();
pl.getSI()->setIsFromOsm(false);
const auto& r = snapStation(g, &pl, &eg, &sng, opts, res, false, d);
@ -374,9 +375,10 @@ void OsmBuilder::readWriteWays(xml::File* i, util::xml::XmlWriter* o,
// _____________________________________________________________________________
NodePL OsmBuilder::plFromGtfs(const Stop* s, const OsmReadOpts& ops) const {
NodePL ret(util::geo::latLngToWebMerc<double>(s->getLat(), s->getLng()),
StatInfo(ops.statNormzer(s->getName()),
ops.trackNormzer(s->getPlatformCode()), false));
NodePL ret(
util::geo::latLngToWebMerc<PFAEDLE_PRECISION>(s->getLat(), s->getLng()),
StatInfo(ops.statNormzer(s->getName()),
ops.trackNormzer(s->getPlatformCode()), false));
if (s->getParentStation()) {
ret.getSI()->addAltName(ops.statNormzer(s->getParentStation()->getName()));
@ -705,7 +707,7 @@ void OsmBuilder::readNodes(xml::File* xml, Graph* g, const RelLst& rels,
keepAttrs, fl))
.id) {
Node* n = 0;
auto pos = util::geo::latLngToWebMerc<double>(nd.lat, nd.lng);
auto pos = util::geo::latLngToWebMerc<PFAEDLE_PRECISION>(nd.lat, nd.lng);
if (nodes->count(nd.id)) {
n = (*nodes)[nd.id];
n->pl().setGeom(pos);
@ -930,7 +932,7 @@ std::string OsmBuilder::getAttr(const DeepAttrRule& s, osmid id,
// _____________________________________________________________________________
Nullable<StatInfo> OsmBuilder::getStatInfo(Node* node, osmid nid,
const DPoint& pos, const AttrMap& m,
const POINT& pos, const AttrMap& m,
StAttrGroups* groups,
const RelMap& nodeRels,
const RelLst& rels,
@ -994,7 +996,7 @@ double OsmBuilder::dist(const Node* a, const Node* b) const {
}
// _____________________________________________________________________________
double OsmBuilder::webMercDistFactor(const util::geo::DPoint& a) const {
double OsmBuilder::webMercDistFactor(const POINT& a) const {
// euclidean distance on web mercator is in meters on equator,
// and proportional to cos(lat) in both y directions
@ -1035,7 +1037,7 @@ void OsmBuilder::fixGaps(Graph* g, NodeGrid* ng) const {
otherN = (*nb->getAdjListOut().begin())->getOtherNd(nb);
else
otherN = (*nb->getAdjListIn().begin())->getOtherNd(nb);
DLine l;
LINE l;
l.push_back(*otherN->pl().getGeom());
l.push_back(*n->pl().getGeom());
@ -1057,7 +1059,7 @@ void OsmBuilder::fixGaps(Graph* g, NodeGrid* ng) const {
// _____________________________________________________________________________
EdgeGrid OsmBuilder::buildEdgeIdx(Graph* g, size_t size,
const Box<double>& webMercBox) const {
const BOX& webMercBox) const {
EdgeGrid ret(size, size, webMercBox, false);
for (auto* n : *g->getNds()) {
for (auto* e : n->getAdjListOut()) {
@ -1070,7 +1072,7 @@ EdgeGrid OsmBuilder::buildEdgeIdx(Graph* g, size_t size,
// _____________________________________________________________________________
NodeGrid OsmBuilder::buildNodeIdx(Graph* g, size_t size,
const Box<double>& webMercBox,
const BOX& webMercBox,
bool which) const {
NodeGrid ret(size, size, webMercBox, false);
for (auto* n : *g->getNds()) {
@ -1083,9 +1085,8 @@ NodeGrid OsmBuilder::buildNodeIdx(Graph* g, size_t size,
}
// _____________________________________________________________________________
Node* OsmBuilder::depthSearch(const Edge* e, const StatInfo* si,
const util::geo::DPoint& p, double maxD,
int maxFullTurns, double minAngle,
Node* OsmBuilder::depthSearch(const Edge* e, const StatInfo* si, const POINT& p,
double maxD, int maxFullTurns, double minAngle,
const SearchFunc& sfunc) const {
// shortcuts
double dFrom = webMercMeterDist(*e->getFrom()->pl().getGeom(), p);
@ -1125,10 +1126,10 @@ Node* OsmBuilder::depthSearch(const Edge* e, const StatInfo* si,
if (cur.fromEdge &&
cur.node->getInDeg() + cur.node->getOutDeg() >
2) { // only intersection angles
const DPoint& toP = *cand->pl().getGeom();
const DPoint& fromP =
const POINT& toP = *cand->pl().getGeom();
const POINT& fromP =
*cur.fromEdge->getOtherNd(cur.node)->pl().getGeom();
const DPoint& nodeP = *cur.node->pl().getGeom();
const POINT& nodeP = *cur.node->pl().getGeom();
if (util::geo::innerProd(nodeP, fromP, toP) < minAngle) fullTurn = 1;
}
@ -1149,25 +1150,25 @@ Node* OsmBuilder::depthSearch(const Edge* e, const StatInfo* si,
}
// _____________________________________________________________________________
bool OsmBuilder::isBlocked(const Edge* e, const StatInfo* si,
const util::geo::DPoint& p, double maxD,
int maxFullTurns, double minAngle) const {
bool OsmBuilder::isBlocked(const Edge* e, const StatInfo* si, const POINT& p,
double maxD, int maxFullTurns,
double minAngle) const {
return depthSearch(e, si, p, maxD, maxFullTurns, minAngle, BlockSearch());
}
// _____________________________________________________________________________
Node* OsmBuilder::eqStatReach(const Edge* e, const StatInfo* si,
const util::geo::DPoint& p, double maxD,
int maxFullTurns, double minAngle) const {
Node* OsmBuilder::eqStatReach(const Edge* e, const StatInfo* si, const POINT& p,
double maxD, int maxFullTurns,
double minAngle) const {
return depthSearch(e, si, p, maxD, maxFullTurns, minAngle, EqSearch());
}
// _____________________________________________________________________________
void OsmBuilder::getEdgCands(const DPoint& geom, EdgeCandPQ* ret, EdgeGrid* eg,
void OsmBuilder::getEdgCands(const POINT& geom, EdgeCandPQ* ret, EdgeGrid* eg,
double d) const {
double distor = webMercDistFactor(geom);
std::set<Edge*> neighs;
Box<double> box = util::geo::pad(util::geo::getBoundingBox(geom), d / distor);
BOX box = util::geo::pad(util::geo::getBoundingBox(geom), d / distor);
eg->get(box, &neighs);
for (auto* e : neighs) {
@ -1186,7 +1187,7 @@ std::set<Node*> OsmBuilder::getMatchingNds(const NodePL& s, NodeGrid* ng,
std::set<Node*> ret;
double distor = webMercDistFactor(*s.getGeom());
std::set<Node*> neighs;
Box<double> box =
BOX box =
util::geo::pad(util::geo::getBoundingBox(*s.getGeom()), d / distor);
ng->get(box, &neighs);
@ -1204,7 +1205,7 @@ std::set<Node*> OsmBuilder::getMatchingNds(const NodePL& s, NodeGrid* ng,
Node* OsmBuilder::getMatchingNd(const NodePL& s, NodeGrid* ng, double d) const {
double distor = webMercDistFactor(*s.getGeom());
std::set<Node*> neighs;
Box<double> box =
BOX box =
util::geo::pad(util::geo::getBoundingBox(*s.getGeom()), d / distor);
ng->get(box, &neighs);
@ -1282,7 +1283,7 @@ std::set<Node*> OsmBuilder::snapStation(Graph* g, NodePL* s, EdgeGrid* eg,
auto ne = g->addEdg(e->getFrom(), n, e->pl());
ne->pl().setLength(webMercDist(n, e->getFrom()));
DLine l;
LINE l;
l.push_back(*e->getFrom()->pl().getGeom());
l.push_back(*n->pl().getGeom());
*ne->pl().getGeom() = l;
@ -1290,7 +1291,7 @@ std::set<Node*> OsmBuilder::snapStation(Graph* g, NodePL* s, EdgeGrid* eg,
auto nf = g->addEdg(n, e->getTo(), e->pl());
nf->pl().setLength(webMercDist(n, e->getTo()));
DLine ll;
LINE ll;
ll.push_back(*n->pl().getGeom());
ll.push_back(*e->getTo()->pl().getGeom());
*nf->pl().getGeom() = ll;

31
src/pfaedle/osm/OsmBuilder.h
View file

@ -5,14 +5,15 @@
#ifndef PFAEDLE_OSM_OSMBUILDER_H_
#define PFAEDLE_OSM_OSMBUILDER_H_
#include <map>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "ad/cppgtfs/gtfs/Feed.h"
#include "pfaedle/Def.h"
#include "pfaedle/osm/BBoxIdx.h"
#include "pfaedle/osm/OsmFilter.h"
#include "pfaedle/osm/OsmIdSet.h"
@ -23,6 +24,7 @@
#include "pfaedle/trgraph/Normalizer.h"
#include "pfaedle/trgraph/StatInfo.h"
#include "util/Nullable.h"
#include "util/geo/Geo.h"
#include "util/xml/XmlWriter.h"
#include "xml/File.h"
@ -89,7 +91,6 @@ class OsmBuilder {
const BBoxIdx& box, size_t gridSize, router::FeedStops* fs,
Restrictor* res);
// Based on the list of options, read an OSM file from in and output an
// OSM file to out which contains exactly the entities that are needed
// from the file at in
@ -162,7 +163,7 @@ class OsmBuilder {
OsmRel nextRel(xml::File* xml, const OsmFilter& filter,
const AttrKeySet& keepAttrs) const;
Nullable<StatInfo> getStatInfo(Node* node, osmid nid, const DPoint& pos,
Nullable<StatInfo> getStatInfo(Node* node, osmid nid, const POINT& pos,
const AttrMap& m, StAttrGroups* groups,
const RelMap& nodeRels, const RelLst& rels,
const OsmReadOpts& ops) const;
@ -172,14 +173,12 @@ class OsmBuilder {
void deleteOrphEdgs(Graph* g) const;
double dist(const Node* a, const Node* b) const;
double webMercDist(const Node* a, const Node* b) const;
double webMercDistFactor(const DPoint& a) const;
double webMercDistFactor(const POINT& a) const;
NodeGrid buildNodeIdx(Graph* g, size_t size,
const util::geo::Box<double>& webMercBox,
NodeGrid buildNodeIdx(Graph* g, size_t size, const BOX& webMercBox,
bool which) const;
EdgeGrid buildEdgeIdx(Graph* g, size_t size,
const util::geo::Box<double>& webMercBox) const;
EdgeGrid buildEdgeIdx(Graph* g, size_t size, const BOX& webMercBox) const;
void fixGaps(Graph* g, NodeGrid* ng) const;
void collapseEdges(Graph* g) const;
@ -190,7 +189,7 @@ class OsmBuilder {
uint32_t writeComps(Graph* g) const;
bool edgesSim(const Edge* a, const Edge* b) const;
const EdgePL& mergeEdgePL(Edge* a, Edge* b) const;
void getEdgCands(const DPoint& s, EdgeCandPQ* ret, EdgeGrid* eg,
void getEdgCands(const POINT& s, EdgeCandPQ* ret, EdgeGrid* eg,
double d) const;
std::set<Node*> getMatchingNds(const NodePL& s, NodeGrid* ng, double d) const;
@ -204,15 +203,15 @@ class OsmBuilder {
// Checks if from the edge e, a station similar to si can be reach with less
// than maxD distance and less or equal to "maxFullTurns" full turns. If
// such a station exists, it is returned. If not, 0 is returned.
Node* eqStatReach(const Edge* e, const StatInfo* si, const DPoint& p,
Node* eqStatReach(const Edge* e, const StatInfo* si, const POINT& p,
double maxD, int maxFullTurns, double maxAng) const;
Node* depthSearch(const Edge* e, const StatInfo* si,
const DPoint& p, double maxD, int maxFullTurns,
double minAngle, const SearchFunc& sfunc) const;
Node* depthSearch(const Edge* e, const StatInfo* si, const POINT& p,
double maxD, int maxFullTurns, double minAngle,
const SearchFunc& sfunc) const;
bool isBlocked(const Edge* e, const StatInfo* si, const DPoint& p,
double maxD, int maxFullTurns, double minAngle) const;
bool isBlocked(const Edge* e, const StatInfo* si, const POINT& p, double maxD,
int maxFullTurns, double minAngle) const;
StatGroup* groupStats(const NodeSet& s) const;

9
src/pfaedle/router/EdgePL.cpp
View file

@ -2,6 +2,8 @@
// Chair of Algorithms and Data Structures.
// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
#include "pfaedle/Def.h"
#include "util/geo/Geo.h"
#include "pfaedle/router/EdgePL.h"
#include "pfaedle/router/Router.h"
#include "util/String.h"
@ -18,13 +20,13 @@ EdgeList* EdgePL::getEdges() { return &_edges; }
const EdgeList& EdgePL::getEdges() const { return _edges; }
// _____________________________________________________________________________
const DPoint& EdgePL::frontHop() const {
const POINT& EdgePL::frontHop() const {
if (!_edges.size()) return *_end->pl().getGeom();
return _edges.back()->pl().frontHop();
}
// _____________________________________________________________________________
const DPoint& EdgePL::backHop() const {
const POINT& EdgePL::backHop() const {
if (!_edges.size()) return *_start->pl().getGeom();
return _edges.front()->pl().backHop();
}
@ -36,7 +38,7 @@ const Node* EdgePL::backNode() const { return _end; }
const Node* EdgePL::frontNode() const { return _start; }
// _____________________________________________________________________________
const util::geo::DLine* EdgePL::getGeom() const {
const LINE* EdgePL::getGeom() const {
if (!_edges.size()) return 0;
if (!_geom.size()) {
const trgraph::Node* l = _start;
@ -74,7 +76,6 @@ const EdgeCost& EdgePL::getCost() const { return _cost; }
// _____________________________________________________________________________
void EdgePL::setCost(const router::EdgeCost& c) { _cost = c; }
// _____________________________________________________________________________
util::json::Dict EdgePL::getAttrs() const {
util::json::Dict obj;

15
src/pfaedle/router/EdgePL.h
View file

@ -7,21 +7,20 @@
#include <map>
#include <string>
#include "pfaedle/Def.h"
#include "pfaedle/router/Misc.h"
#include "util/geo/GeoGraph.h"
#include "util/geo/Geo.h"
#include "util/geo/GeoGraph.h"
using util::geograph::GeoEdgePL;
using util::geo::DPoint;
using util::geo::DLine;
namespace pfaedle {
namespace router {
class EdgePL : public GeoEdgePL<double> {
class EdgePL : public GeoEdgePL<PFAEDLE_PRECISION> {
public:
EdgePL() : _cost(), _start(0), _end(0), _startE(0), _endE(0) {}
const util::geo::DLine* getGeom() const;
const LINE* getGeom() const;
util::json::Dict getAttrs() const;
router::EdgeList* getEdges();
const router::EdgeList& getEdges() const;
@ -31,8 +30,8 @@ class EdgePL : public GeoEdgePL<double> {
void setEndEdge(const trgraph::Edge* s);
const router::EdgeCost& getCost() const;
void setCost(const router::EdgeCost& c);
const DPoint& frontHop() const;
const DPoint& backHop() const;
const POINT& frontHop() const;
const POINT& backHop() const;
const trgraph::Node* frontNode() const;
const trgraph::Node* backNode() const;
@ -44,7 +43,7 @@ class EdgePL : public GeoEdgePL<double> {
const trgraph::Node* _end;
const trgraph::Edge* _startE;
const trgraph::Edge* _endE;
mutable DLine _geom;
mutable LINE _geom;
};
} // namespace router
} // namespace pfaedle

8
src/pfaedle/router/NodePL.h
View file

@ -9,19 +9,21 @@
#include <string>
#include "pfaedle/trgraph/Graph.h"
#include "util/geo/GeoGraph.h"
#include "util/geo/Geo.h"
#include "pfaedle/Def.h"
using util::geograph::GeoNodePL;
using util::geo::DPoint;
namespace pfaedle {
namespace router {
class NodePL : public GeoNodePL<double> {
class NodePL : public GeoNodePL<PFAEDLE_PRECISION> {
public:
NodePL() : _n(0) {}
NodePL(const pfaedle::trgraph::Node* n) : _n(n) {} // NOLINT
const DPoint* getGeom() const {
const POINT* getGeom() const {
return !_n ? 0 : _n->pl().getGeom();
}
util::json::Dict getAttrs() const {

4
src/pfaedle/router/Router.cpp
View file

@ -132,7 +132,7 @@ NDistHeur::NDistHeur(const RoutingOpts& rOpts,
x /= c;
y /= c;
_center = DPoint(x, y);
_center = POINT(x, y);
for (auto to : tos) {
double cur = webMercMeterDist(*to->pl().getGeom(), _center);
@ -154,7 +154,7 @@ DistHeur::DistHeur(uint8_t minLvl, const RoutingOpts& rOpts,
x /= c;
y /= c;
_center = DPoint(x, y);
_center = POINT(x, y);
for (auto to : tos) {
double cur = webMercMeterDist(*to->getFrom()->pl().getGeom(), _center) *

6
src/pfaedle/router/Router.h
View file

@ -20,6 +20,8 @@
#include "pfaedle/trgraph/Graph.h"
#include "util/graph/Dijkstra.h"
#include "util/graph/EDijkstra.h"
#include "util/geo/Geo.h"
#include "pfaedle/Def.h"
using util::graph::EDijkstra;
using util::graph::Dijkstra;
@ -100,7 +102,7 @@ struct DistHeur
const RoutingOpts& _rOpts;
uint8_t _lvl;
DPoint _center;
POINT _center;
double _maxCentD;
EdgeCost operator()(const trgraph::Edge* a,
const std::set<trgraph::Edge*>& b) const;
@ -111,7 +113,7 @@ struct NDistHeur
NDistHeur(const RoutingOpts& rOpts, const std::set<trgraph::Node*>& tos);
const RoutingOpts& _rOpts;
DPoint _center;
POINT _center;
double _maxCentD;
EdgeCost operator()(const trgraph::Node* a,
const std::set<trgraph::Node*>& b) const;

70
src/pfaedle/router/ShapeBuilder.cpp
View file

@ -14,20 +14,22 @@
#include <unordered_map>
#include <utility>
#include "ad/cppgtfs/gtfs/Feed.h"
#include "pfaedle/Def.h"
#include "pfaedle/eval/Collector.h"
#include "pfaedle/osm/OsmBuilder.h"
#include "pfaedle/router/ShapeBuilder.h"
#include "pfaedle/trgraph/StatGroup.h"
#include "util/geo/Geo.h"
#include "util/geo/output/GeoGraphJsonOutput.h"
#include "util/geo/output/GeoJsonOutput.h"
#include "util/graph/EDijkstra.h"
#include "util/log/Log.h"
using util::geo::DPoint;
using util::geo::extendBox;
using util::geo::DBox;
using util::geo::DPoint;
using util::geo::minbox;
using util::geo::DLine;
using util::geo::webMercMeterDist;
using util::geo::webMercToLatLng;
using util::geo::latLngToWebMerc;
@ -91,11 +93,11 @@ const NodeCandGroup& ShapeBuilder::getNodeCands(const Stop* s) const {
}
// _____________________________________________________________________________
DLine ShapeBuilder::shapeL(const router::NodeCandRoute& ncr,
const router::RoutingAttrs& rAttrs) {
LINE ShapeBuilder::shapeL(const router::NodeCandRoute& ncr,
const router::RoutingAttrs& rAttrs) {
const router::EdgeListHops& res = route(ncr, rAttrs);
DLine l;
LINE l;
for (const auto& hop : res) {
const trgraph::Node* last = hop.start;
if (hop.edges.size() == 0) {
@ -118,7 +120,7 @@ DLine ShapeBuilder::shapeL(const router::NodeCandRoute& ncr,
}
// _____________________________________________________________________________
DLine ShapeBuilder::shapeL(Trip* trip) {
LINE ShapeBuilder::shapeL(Trip* trip) {
return shapeL(getNCR(trip), getRAttrs(trip));
}
@ -218,8 +220,7 @@ void ShapeBuilder::shape(pfaedle::netgraph::Graph* ng) {
{
LOG(INFO) << "@ " << j << " / " << clusters.size() << " ("
<< (static_cast<int>((j * 1.0) / clusters.size() * 100))
<< "%, "
<< (EDijkstra::ITERS - oiters) << " iters, "
<< "%, " << (EDijkstra::ITERS - oiters) << " iters, "
/**
TODO: this is actually misleading. We are counting the
Dijkstra iterations, but the measuring them against
@ -275,16 +276,17 @@ void ShapeBuilder::shape(pfaedle::netgraph::Graph* ng) {
LOG(INFO) << "Matched " << totNumTrips << " trips in " << clusters.size()
<< " clusters.";
LOG(DEBUG) << "Took " << (EDijkstra::ITERS - totiters)
<< " iterations in total.";
<< " iterations in total.";
LOG(DEBUG) << "Took " << TOOK(t2, TIME()) << " ms in total.";
LOG(DEBUG) << "Total avg. tput "
<< (static_cast<double>(EDijkstra::ITERS - totiters)) /
TOOK(t2, TIME())
<< " iters/sec";
<< (static_cast<double>(EDijkstra::ITERS - totiters)) /
TOOK(t2, TIME())
<< " iters/sec";
LOG(DEBUG) << "Total avg. trip tput "
<< (clusters.size() / (TOOK(t2, TIME()) / 1000)) << " trips/sec";
<< (clusters.size() / (TOOK(t2, TIME()) / 1000)) << " trips/sec";
LOG(DEBUG) << "Avg hop distance was "
<< (totAvgDist / static_cast<double>(clusters.size())) << " meters";
<< (totAvgDist / static_cast<double>(clusters.size()))
<< " meters";
if (_cfg.buildTransitGraph) {
LOG(INFO) << "Building transit network graph...";
@ -321,12 +323,12 @@ ad::cppgtfs::gtfs::Shape* ShapeBuilder::getGtfsShape(
double dist = -1;
double lastDist = -1;
hopDists->push_back(0);
DPoint last(0, 0);
POINT last(0, 0);
for (const auto& hop : shp.hops) {
const trgraph::Node* l = hop.start;
if (hop.edges.size() == 0) {
DPoint ll = webMercToLatLng<double>(hop.start->pl().getGeom()->getX(),
hop.start->pl().getGeom()->getY());
POINT ll = webMercToLatLng<PFAEDLE_PRECISION>(
hop.start->pl().getGeom()->getX(), hop.start->pl().getGeom()->getY());
if (dist > -0.5)
dist += webMercMeterDist(last, *hop.start->pl().getGeom());
@ -345,8 +347,8 @@ ad::cppgtfs::gtfs::Shape* ShapeBuilder::getGtfsShape(
last = *hop.end->pl().getGeom();
if (dist - lastDist > 0.01) {
ll = webMercToLatLng<double>(hop.end->pl().getGeom()->getX(),
hop.end->pl().getGeom()->getY());
ll = webMercToLatLng<PFAEDLE_PRECISION>(
hop.end->pl().getGeom()->getX(), hop.end->pl().getGeom()->getY());
ret->addPoint(ShapePoint(ll.getY(), ll.getX(), dist, seq));
seq++;
lastDist = dist;
@ -356,14 +358,15 @@ ad::cppgtfs::gtfs::Shape* ShapeBuilder::getGtfsShape(
const auto* e = *i;
if ((e->getFrom() == l) ^ e->pl().isRev()) {
for (size_t i = 0; i < e->pl().getGeom()->size(); i++) {
const DPoint& cur = (*e->pl().getGeom())[i];
const POINT& cur = (*e->pl().getGeom())[i];
if (dist > -0.5)
dist += webMercMeterDist(last, cur);
else
dist = 0;
last = cur;
if (dist - lastDist > 0.01) {
DPoint ll = webMercToLatLng<double>(cur.getX(), cur.getY());
POINT ll =
webMercToLatLng<PFAEDLE_PRECISION>(cur.getX(), cur.getY());
ret->addPoint(ShapePoint(ll.getY(), ll.getX(), dist, seq));
seq++;
lastDist = dist;
@ -371,14 +374,15 @@ ad::cppgtfs::gtfs::Shape* ShapeBuilder::getGtfsShape(
}
} else {
for (int64_t i = e->pl().getGeom()->size() - 1; i >= 0; i--) {
const DPoint& cur = (*e->pl().getGeom())[i];
const POINT& cur = (*e->pl().getGeom())[i];
if (dist > -0.5)
dist += webMercMeterDist(last, cur);
else
dist = 0;
last = cur;
if (dist - lastDist > 0.01) {
DPoint ll = webMercToLatLng<double>(cur.getX(), cur.getY());
POINT ll =
webMercToLatLng<PFAEDLE_PRECISION>(cur.getX(), cur.getY());
ret->addPoint(ShapePoint(ll.getY(), ll.getX(), dist, seq));
seq++;
lastDist = dist;
@ -452,10 +456,10 @@ BBoxIdx ShapeBuilder::getPaddedGtfsBox(const Feed* feed, double pad,
if (tid.empty() && t.second->getShape() && !dropShapes) continue;
if (t.second->getStopTimes().size() < 2) continue;
if (mots.count(t.second->getRoute()->getType())) {
DBox cur = minbox<double>();
DBox cur;
for (const auto& st : t.second->getStopTimes()) {
cur = extendBox(
DPoint(st.getStop()->getLng(), st.getStop()->getLat()), cur);
cur = extendBox(DPoint(st.getStop()->getLng(), st.getStop()->getLat()),
cur);
}
box.add(cur);
}
@ -471,7 +475,6 @@ void ShapeBuilder::buildGraph() {
osm::BBoxIdx box =
getPaddedGtfsBox(_feed, 2500, _mots, _cfg.shapeTripId, _cfg.dropShapes);
osmBuilder.read(_cfg.osmPath, _motCfg.osmBuildOpts, &_g, box, _cfg.gridSize,
getFeedStops(), &_restr);
@ -511,9 +514,10 @@ double ShapeBuilder::avgHopDist(Trip* trip) const {
prev = st.getStop();
continue;
}
auto a = util::geo::latLngToWebMerc<double>(prev->getLat(), prev->getLng());
auto b = util::geo::latLngToWebMerc<double>(st.getStop()->getLat(),
st.getStop()->getLng());
auto a = util::geo::latLngToWebMerc<PFAEDLE_PRECISION>(prev->getLat(),
prev->getLng());
auto b = util::geo::latLngToWebMerc<PFAEDLE_PRECISION>(
st.getStop()->getLat(), st.getStop()->getLng());
sum += util::geo::webMercMeterDist(a, b);
prev = st.getStop();
@ -573,8 +577,10 @@ bool ShapeBuilder::routingEqual(const Stop* a, const Stop* b) {
auto trackb = _motCfg.osmBuildOpts.trackNormzer(b->getPlatformCode());
if (tracka != trackb) return false;
DPoint ap = util::geo::latLngToWebMerc<double>(a->getLat(), a->getLng());
DPoint bp = util::geo::latLngToWebMerc<double>(b->getLat(), b->getLng());
POINT ap =
util::geo::latLngToWebMerc<PFAEDLE_PRECISION>(a->getLat(), a->getLng());
POINT bp =
util::geo::latLngToWebMerc<PFAEDLE_PRECISION>(b->getLat(), b->getLng());
double d = util::geo::webMercMeterDist(ap, bp);

15
src/pfaedle/router/ShapeBuilder.h
View file

@ -12,6 +12,7 @@
#include <utility>
#include <vector>
#include "ad/cppgtfs/gtfs/Feed.h"
#include "pfaedle/Def.h"
#include "pfaedle/config/MotConfig.h"
#include "pfaedle/config/PfaedleConfig.h"
#include "pfaedle/eval/Collector.h"
@ -20,6 +21,7 @@
#include "pfaedle/router/Misc.h"
#include "pfaedle/router/Router.h"
#include "pfaedle/trgraph/Graph.h"
#include "util/geo/Geo.h"
namespace pfaedle {
namespace router {
@ -28,8 +30,6 @@ using ad::cppgtfs::gtfs::Stop;
using ad::cppgtfs::gtfs::Trip;
using ad::cppgtfs::gtfs::Feed;
using util::geo::DLine;
struct Shape {
router::EdgeListHops hops;
double avgHopDist;
@ -57,9 +57,9 @@ class ShapeBuilder {
const NodeCandGroup& getNodeCands(const Stop* s) const;
DLine shapeL(const router::NodeCandRoute& ncr,
const router::RoutingAttrs& rAttrs);
DLine shapeL(Trip* trip);
LINE shapeL(const router::NodeCandRoute& ncr,
const router::RoutingAttrs& rAttrs);
LINE shapeL(Trip* trip);
pfaedle::router::Shape shape(Trip* trip) const;
pfaedle::router::Shape shape(Trip* trip);
@ -67,8 +67,7 @@ class ShapeBuilder {
const trgraph::Graph* getGraph() const;
static osm::BBoxIdx getPaddedGtfsBox(const Feed* feed, double pad,
const MOTs& mots,
const std::string& tid,
const MOTs& mots, const std::string& tid,
bool dropShapes);
private:
@ -103,7 +102,7 @@ class ShapeBuilder {
std::string getFreeShapeId(Trip* t);
ad::cppgtfs::gtfs::Shape* getGtfsShape(const Shape& shp, Trip* t,
std::vector<double>* hopDists);
std::vector<double>* hopDists);
void setShape(Trip* t, ad::cppgtfs::gtfs::Shape* s,
const std::vector<double>& dists);

18
src/pfaedle/trgraph/EdgePL.cpp
View file

@ -10,15 +10,15 @@
using pfaedle::trgraph::EdgePL;
using pfaedle::trgraph::TransitEdgeLine;
using util::geo::DLine;
std::map<DLine*, size_t> EdgePL::_flines;
std::map<LINE*, size_t> EdgePL::_flines;
std::map<const TransitEdgeLine*, size_t> EdgePL::_tlines;
// _____________________________________________________________________________
EdgePL::EdgePL()
: _length(0), _oneWay(0), _hasRestr(false), _rev(false), _lvl(0) {
_l = new DLine();
_l = new LINE();
_flines[_l] = 1;
}
@ -35,7 +35,7 @@ EdgePL::EdgePL(const EdgePL& pl, bool geoflat)
if (geoflat) {
_l = pl._l;
} else {
_l = new DLine(*pl._l);
_l = new LINE(*pl._l);
}
_flines[_l]++;
@ -101,13 +101,13 @@ const std::set<const TransitEdgeLine*>& EdgePL::getLines() const {
}
// _____________________________________________________________________________
void EdgePL::addPoint(const util::geo::DPoint& p) { _l->push_back(p); }
void EdgePL::addPoint(const POINT& p) { _l->push_back(p); }
// _____________________________________________________________________________
const DLine* EdgePL::getGeom() const { return _l; }
const LINE* EdgePL::getGeom() const { return _l; }
// _____________________________________________________________________________
DLine* EdgePL::getGeom() { return _l; }
LINE* EdgePL::getGeom() { return _l; }
// _____________________________________________________________________________
util::json::Dict EdgePL::getAttrs() const {
@ -162,7 +162,7 @@ void EdgePL::setRev() { _rev = true; }
bool EdgePL::isRev() const { return _rev; }
// _____________________________________________________________________________
const util::geo::DPoint& EdgePL::backHop() const {
const POINT& EdgePL::backHop() const {
if (isRev()) {
return *(++(getGeom()->cbegin()));
}
@ -170,7 +170,7 @@ const util::geo::DPoint& EdgePL::backHop() const {
}
// _____________________________________________________________________________
const util::geo::DPoint& EdgePL::frontHop() const {
const POINT& EdgePL::frontHop() const {
if (isRev()) {
return *(++(getGeom()->crbegin()));
}

22
src/pfaedle/trgraph/EdgePL.h
View file

@ -9,12 +9,14 @@
#include <set>
#include <string>
#include <vector>
#include "pfaedle/Def.h"
#include "pfaedle/router/Comp.h"
#include "util/geo/Geo.h"
#include "util/geo/GeoGraph.h"
using util::geograph::GeoEdgePL;
using util::geo::DLine;
using util::geo::DPoint;
namespace pfaedle {
namespace trgraph {
@ -43,7 +45,7 @@ inline bool operator<(const TransitEdgeLine& a, const TransitEdgeLine& b) {
/*
* An edge payload class for the transit graph.
*/
class EdgePL : public GeoEdgePL<double> {
class EdgePL : public GeoEdgePL<PFAEDLE_PRECISION> {
public:
EdgePL();
~EdgePL();
@ -51,11 +53,11 @@ class EdgePL : public GeoEdgePL<double> {
EdgePL(const EdgePL& pl, bool geoFlat);
// Return the geometry of this edge.
const DLine* getGeom() const;
DLine* getGeom();
const LINE* getGeom() const;
LINE* getGeom();
// Extends this edge payload's geometry by Point p
void addPoint(const DPoint& p);
void addPoint(const POINT& p);
// Fill obj with k/v pairs describing the parameters of this payload.
util::json::Dict getAttrs() const;
@ -103,11 +105,11 @@ class EdgePL : public GeoEdgePL<double> {
// Returns the last hop of the payload - this is the (n-2)th point in
// the payload geometry of length n > 1
const DPoint& backHop() const;
const POINT& backHop() const;
// Returns the first hop of the payload - this is the 2nd point in
// the payload geometry of length n > 1
const DPoint& frontHop() const;
const POINT& frontHop() const;
// Obtain an exact copy of this edge, but in reverse.
EdgePL revCopy() const;
@ -119,13 +121,13 @@ class EdgePL : public GeoEdgePL<double> {
bool _rev : 1;
uint8_t _lvl : 3;
DLine* _l;
LINE* _l;
std::set<const TransitEdgeLine*> _lines;
static void unRefTLine(const TransitEdgeLine* l);
static std::map<DLine*, size_t> _flines;
static std::map<LINE*, size_t> _flines;
static std::map<const TransitEdgeLine*, size_t> _tlines;
};
} // namespace trgraph

4
src/pfaedle/trgraph/Graph.h
View file

@ -24,8 +24,8 @@ namespace trgraph {
typedef util::graph::Edge<NodePL, EdgePL> Edge;
typedef util::graph::Node<NodePL, EdgePL> Node;
typedef util::graph::DirGraph<NodePL, EdgePL> Graph;
typedef Grid<Node*, Point, double> NodeGrid;
typedef Grid<Edge*, Line, double> EdgeGrid;
typedef Grid<Node*, Point, PFAEDLE_PRECISION> NodeGrid;
typedef Grid<Edge*, Line, PFAEDLE_PRECISION> EdgeGrid;
} // namespace trgraph
} // namespace pfaedle

8
src/pfaedle/trgraph/NodePL.cpp
View file

@ -46,7 +46,7 @@ NodePL::NodePL(const NodePL& pl)
}
// _____________________________________________________________________________
NodePL::NodePL(const DPoint& geom)
NodePL::NodePL(const POINT& geom)
: _geom(geom),
_si(0),
_component(0)
@ -58,7 +58,7 @@ NodePL::NodePL(const DPoint& geom)
}
// _____________________________________________________________________________
NodePL::NodePL(const DPoint& geom, const StatInfo& si)
NodePL::NodePL(const POINT& geom, const StatInfo& si)
: _geom(geom),
_si(0),
_component(0)
@ -108,10 +108,10 @@ void NodePL::setComp(const Component* c) {
}
// _____________________________________________________________________________
const DPoint* NodePL::getGeom() const { return &_geom; }
const POINT* NodePL::getGeom() const { return &_geom; }
// _____________________________________________________________________________
void NodePL::setGeom(const DPoint& geom) { _geom = geom; }
void NodePL::setGeom(const POINT& geom) { _geom = geom; }
// _____________________________________________________________________________
util::json::Dict NodePL::getAttrs() const {

18
src/pfaedle/trgraph/NodePL.h
View file

@ -9,12 +9,12 @@
#include <string>
#include <unordered_map>
#include "ad/cppgtfs/gtfs/Feed.h"
#include "pfaedle/Def.h"
#include "pfaedle/trgraph/StatInfo.h"
#include "util/geo/GeoGraph.h"
#include "util/geo/Geo.h"
#include "util/geo/GeoGraph.h"
using util::geograph::GeoNodePL;
using util::geo::DPoint;
namespace pfaedle {
namespace trgraph {
@ -26,17 +26,17 @@ struct Component {
/*
* A node payload class for the transit graph.
*/
class NodePL : public GeoNodePL<double> {
class NodePL : public GeoNodePL<PFAEDLE_PRECISION> {
public:
NodePL();
NodePL(const NodePL& pl); // NOLINT
NodePL(const DPoint& geom); // NOLINT
NodePL(const DPoint& geom, const StatInfo& si);
NodePL(const NodePL& pl); // NOLINT
NodePL(const POINT& geom); // NOLINT
NodePL(const POINT& geom, const StatInfo& si);
~NodePL();
// Return the geometry of this node.
const DPoint* getGeom() const;
void setGeom(const DPoint& geom);
const POINT* getGeom() const;
void setGeom(const POINT& geom);
// Fill obj with k/v pairs describing the parameters of this payload.
util::json::Dict getAttrs() const;
@ -68,7 +68,7 @@ class NodePL : public GeoNodePL<double> {
void setVisited() const;
private:
DPoint _geom;
POINT _geom;
StatInfo* _si;
const Component* _component;

17
src/pfaedle/trgraph/StatGroup.cpp
View file

@ -43,9 +43,7 @@ const NodeCandGroup& StatGroup::getNodeCands(const Stop* s) const {
}
// _____________________________________________________________________________
const std::set<Node*>& StatGroup::getNodes() const {
return _nodes;
}
const std::set<Node*>& StatGroup::getNodes() const { return _nodes; }
// _____________________________________________________________________________
void StatGroup::remNode(trgraph::Node* n) {
@ -61,10 +59,11 @@ const std::set<const Stop*>& StatGroup::getStops() const { return _stops; }
// _____________________________________________________________________________
double StatGroup::getPen(const Stop* s, trgraph::Node* n,
const trgraph::Normalizer& platformNorm,
double trackPen, double distPenFac,
double nonOsmPen) const {
DPoint p = util::geo::latLngToWebMerc<double>(s->getLat(), s->getLng());
const trgraph::Normalizer& platformNorm,
double trackPen, double distPenFac,
double nonOsmPen) const {
POINT p =
util::geo::latLngToWebMerc<PFAEDLE_PRECISION>(s->getLat(), s->getLng());
double distPen = util::geo::webMercMeterDist(p, *n->pl().getGeom());
distPen *= distPenFac;
@ -83,8 +82,8 @@ double StatGroup::getPen(const Stop* s, trgraph::Node* n,
// _____________________________________________________________________________
void StatGroup::writePens(const trgraph::Normalizer& platformNorm,
double trackPen, double distPenFac,
double nonOsmPen) {
double trackPen, double distPenFac,
double nonOsmPen) {
if (_stopNodePens.size()) return; // already written
for (auto* s : _stops) {
for (auto* n : _nodes) {

1
src/util/geo/PolyLine.h
View file

@ -9,6 +9,7 @@
#include <ostream>
#include <iomanip>
#include <string>
#include <set>
#include <vector>
#include "Geo.h"