public void add() {
List<Link> links = ((BusLaneAdderPanel) layersPanels.get(PanelIds.ONE)).getLinks();
Node prevNode = links.get(0).getFromNode();
for (Link link : links)
if (!link.getAllowedModes().contains("bus")) {
exitSave();
JOptionPane.showMessageDialog(this, "Wrong path, network saved");
}
for (int i = 0; i < links.size(); i++) {
Link link = links.get(i);
Node node = null;
if (link.getNumberOfLanes() == 1) {
Set<String> modes = new HashSet<String>();
modes.add("bus");
link.setAllowedModes(modes);
node = link.getToNode();
} else {
Node oldNode = link.getToNode();
if (i == links.size() - 1 || oldNode.getInLinks().size() + oldNode.getOutLinks().size() > 2)
node = oldNode;
else {
node =
network
.getFactory()
.createNode(
Id.createNodeId("fl" + oldNode.getId().toString()), oldNode.getCoord());
network.addNode(node);
}
LinkImpl newLink =
(LinkImpl)
network
.getFactory()
.createLink(Id.createLinkId("fl" + link.getId().toString()), prevNode, node);
Set<String> modes = new HashSet<String>();
modes.add("car");
newLink.setAllowedModes(modes);
newLink.setCapacity(link.getCapacity());
newLink.setFreespeed(link.getFreespeed());
newLink.setLength(link.getLength());
newLink.setNumberOfLanes(link.getNumberOfLanes() - 1);
newLink.setOrigId(((LinkImpl) link).getOrigId());
newLink.setType(((LinkImpl) link).getType());
network.addLink(newLink);
Set<String> modes2 = new HashSet<String>();
modes2.add("bus");
link.setAllowedModes(modes2);
link.setCapacity(900);
link.setNumberOfLanes(1);
}
prevNode = node;
}
((BusLaneAdderPanel) layersPanels.get(PanelIds.ONE)).clearSelection();
}
/**
* Removes all TransportMode.pt flags from the network
*
* @param network The network to be processed.
* @return
*/
public static Network removeAllPtTagsFromNetwork(Network network) {
log.info("Untagging pt network links");
int removedTags = 0;
for (Link link : network.getLinks().values()) {
Set<String> allowedModes = new TreeSet<String>(link.getAllowedModes());
if (allowedModes.remove(TransportMode.pt)) {
removedTags++;
}
link.setAllowedModes(allowedModes);
}
log.info("Finished - Removed " + removedTags + " tags from links.");
return network;
}
private Link getNewLink(Node fromNode, Node toNode) {
Link link =
networkFactory.createLink(
Id.create(prefix + linkIdCounter++, Link.class), fromNode, toNode);
if (fromNode == toNode) {
link.setLength(50);
} else {
link.setLength(CoordUtils.calcDistance(fromNode.getCoord(), toNode.getCoord()));
}
link.setFreespeed(80.0 / 3.6);
link.setCapacity(10000);
link.setNumberOfLanes(1);
link.setAllowedModes(this.transitModes);
return link;
}
/**
* Setting up the simulation {@link Scenario}, using a given {@link Config}. In the scenario setup
* each network link is given both {@code car} and {@code commercial} as mode. Also, each person
* is assigned a vehicle, which is based on the Gauteng Freeway Improvement Project (GFIP) vehicle
* toll classes. the following vehicle types are available.
*
* <ul>
* <li>{@code A2}: Light delivery vehicle with length 7.0m, maximum velocity of 100km/h, and
* accounting for 80% of all commercial vehicles;
* <li>{@code B}: Short heavy vehicles with length 12.0m, maximum velocity of 90km/h, and
* accounting for 15% of all commercial vehicles; and
* <li>{@code C}: Long heavy vehicles with length 20.0m, maximum velocity of 90km/h, and
* accounting for the remaining 5% of all commercial vehicles.
* </ul>
*
* These vehicle classes are randomly sampled and assigned to the individuals. No cognisance is
* given to intra- and inter-area traffic (based on the activity chain structure). This
* <i><b>should</b></i> be refined.
*
* @param config typically the {@link Config} resulting from calling the method {@link
* #setupConfig(String, Machine)}.
* @return a scenario in which the network has the necessary {@code commercial} mode; and each
* agent has a vehicle with a particular commercial vehicle class.
*/
public static Scenario setupScenario(Config config) {
Scenario sc = ScenarioUtils.loadScenario(config);
/* Ensure that all links take 'commercial' as mode. */
LOG.warn("Ensuring all links take 'commercial' as mode...");
Collection<String> modesCollection = Arrays.asList("car", "commercial");
Set<String> modesSet = new HashSet<>(modesCollection);
for (Link link : sc.getNetwork().getLinks().values()) {
link.setAllowedModes(modesSet);
}
LOG.warn("Done adding 'commercial' modes.");
/* Add all VehicleTypes. */
Vehicles vehicles = sc.getVehicles();
for (VehicleTypeSA vt : VehicleTypeSA.values()) {
vehicles.addVehicleType(vt.getVehicleType());
}
MatsimRandom.reset(2015093001l);
for (Person person : sc.getPopulation().getPersons().values()) {
/* Randomly sample a vehicle type for each person. */
VehicleType vehicleType = null;
double r = MatsimRandom.getRandom().nextDouble();
if (r <= 0.8) {
vehicleType = VehicleTypeSA.A2.getVehicleType();
} else if (r <= 0.95) {
vehicleType = VehicleTypeSA.B.getVehicleType();
} else {
vehicleType = VehicleTypeSA.C.getVehicleType();
}
Vehicle truck =
VehicleUtils.getFactory()
.createVehicle(Id.create(person.getId(), Vehicle.class), vehicleType);
vehicles.addVehicle(truck);
/* Link the vehicle type to the person's attributes. */
sc.getPopulation()
.getPersonAttributes()
.putAttribute(person.getId().toString(), "vehicleType", vehicleType.getId().toString());
}
return sc;
}
/**
* Add to any link that is passed by any route a "pt" in the modes, if it hasn't already one...
*/
private void prepareNetwork() {
Map<Id<Link>, ? extends Link> networkLinks = network.getLinks();
Set<Id<Link>> transitLinks = new HashSet<>();
for (TransitLine line : this.schedule.getTransitLines().values()) {
for (TransitRoute transitRoute : line.getRoutes().values()) {
NetworkRoute networkRoute = transitRoute.getRoute();
transitLinks.add(networkRoute.getStartLinkId());
for (Id<Link> linkId : transitRoute.getRoute().getLinkIds()) {
transitLinks.add(linkId);
}
transitLinks.add(networkRoute.getEndLinkId());
}
}
for (Id<Link> transitLinkId : transitLinks) {
Link transitLink = networkLinks.get(transitLinkId);
if (!transitLink.getAllowedModes().contains(TransportMode.pt)) {
Set<String> modes = new HashSet<>();
modes.addAll(transitLink.getAllowedModes());
modes.add(TransportMode.pt);
transitLink.setAllowedModes(modes);
}
}
}
private void createNetwork() {
NetworkImpl network = (NetworkImpl) scenario.getNetwork();
double x = -50;
Node nodeHome = network.createAndAddNode(Id.createNodeId("home"), new Coord(x, (double) 0));
Node node1 = network.createAndAddNode(Id.createNodeId(0), new Coord((double) 0, (double) 0));
Node node2 = network.createAndAddNode(Id.createNodeId(1), new Coord((double) 1000, (double) 0));
Node node3 = network.createAndAddNode(Id.createNodeId(2), new Coord((double) 500, 866.0));
Node nodeWork =
network.createAndAddNode(Id.createNodeId("work"), new Coord((double) 1050, (double) 0));
network.createAndAddLink(Id.createLinkId("home"), nodeHome, node1, 25, 60, 27000, 1);
network.createAndAddLink(Id.createLinkId(0), node1, node2, 1000, 60, 2700, 1);
network.createAndAddLink(Id.createLinkId(1), node2, node3, 1000, 60, 2700, 1);
network.createAndAddLink(Id.createLinkId(2), node3, node1, 1000, 60, 2700, 1);
network.createAndAddLink(Id.createLinkId("work"), node2, nodeWork, 25, 60, 27000, 1);
Set<String> allowedModes = new HashSet<String>();
allowedModes.addAll(Arrays.asList(travelModes));
for (Link l : network.getLinks().values()) {
l.setAllowedModes(allowedModes);
}
}
private static void testRestrictedNetwork(final Config config) throws Exception {
// create a simple scenario, with two parallel links,
// a long one for cars, a short one for pt.
final Scenario scenario = ScenarioUtils.createScenario(config);
Network net = scenario.getNetwork();
Node n1 =
net.getFactory().createNode(Id.create(1, Node.class), new Coord((double) 0, (double) 0));
Node n2 =
net.getFactory().createNode(Id.create(2, Node.class), new Coord((double) 0, (double) 0));
Node n3 =
net.getFactory().createNode(Id.create(3, Node.class), new Coord((double) 0, (double) 0));
Node n4 =
net.getFactory().createNode(Id.create(4, Node.class), new Coord((double) 0, (double) 0));
Link l1 = net.getFactory().createLink(Id.create("l1", Link.class), n1, n2);
Link l2c = net.getFactory().createLink(Id.create("l2c", Link.class), n2, n3);
Link l2pt = net.getFactory().createLink(Id.create("l2pt", Link.class), n2, n3);
Link l3 = net.getFactory().createLink(Id.create("l3", Link.class), n3, n4);
l2c.setAllowedModes(Collections.singleton(TransportMode.car));
l2c.setLength(1000);
l2pt.setAllowedModes(Collections.singleton(TransportMode.pt));
l2pt.setLength(10);
net.addNode(n1);
net.addNode(n2);
net.addNode(n3);
net.addNode(n4);
net.addLink(l1);
net.addLink(l2c);
net.addLink(l2pt);
net.addLink(l3);
Injector injector =
Injector.createInjector(
scenario.getConfig(),
new AbstractModule() {
@Override
public void install() {
install(
AbstractModule.override(
Arrays.asList(new TripRouterModule()),
new AbstractModule() {
@Override
public void install() {
bind(Scenario.class).toInstance(scenario);
addTravelTimeBinding("car")
.toInstance(
new FreespeedTravelTimeAndDisutility(config.planCalcScore()));
addTravelDisutilityFactoryBinding("car")
.toInstance(new OnlyTimeDependentTravelDisutilityFactory());
}
}));
}
});
// create the factory, get a router, route.
Provider<TripRouter> factory = injector.getProvider(TripRouter.class);
TripRouter router = factory.get();
List<? extends PlanElement> trip =
router.calcRoute(
TransportMode.car,
new LinkFacility(l1),
new LinkFacility(l3),
0,
PersonImpl.createPerson(Id.create("toto", Person.class)));
Leg l = (Leg) trip.get(0);
// actual test
NetworkRoute r = (NetworkRoute) l.getRoute();
Assert.assertEquals("unexpected route length " + r.getLinkIds(), 1, r.getLinkIds().size());
Assert.assertEquals("unexpected link", l2c.getId(), r.getLinkIds().get(0));
}
private void createLink(
final Network network,
final OsmWay way,
final OsmNode fromNode,
final OsmNode toNode,
final double length) {
double nofLanes;
double laneCapacity;
double freespeed;
double freespeedFactor;
boolean oneway;
boolean onewayReverse = false;
// load defaults
String highway = way.tags.get(TAG_HIGHWAY);
String railway = way.tags.get(TAG_RAILWAY);
String ptway = way.tags.get(TAG_PT_WAYS);
OsmHighwayDefaults defaults;
if (highway != null) {
defaults = this.highwayDefaults.get(highway);
if (defaults == null) {
this.unknownHighways.add(highway);
return;
}
} else if (railway != null) {
defaults = this.railwayDefaults.get(railway);
if (defaults == null) {
this.unknownRailways.add(railway);
return;
}
} else if (ptway != null) {
defaults = this.ptDefaults.get(ptway);
if (defaults == null) {
this.unknownPTs.add(ptway);
return;
}
} else {
this.unknownWays.add(way.tags.values().toString());
return;
}
nofLanes = defaults.lanes;
laneCapacity = defaults.laneCapacity;
freespeed = defaults.freespeed;
freespeedFactor = defaults.freespeedFactor;
oneway = defaults.oneway;
// check if there are tags that overwrite defaults
// - check tag "junction"
if ("roundabout".equals(way.tags.get(TAG_JUNCTION))) {
// if "junction" is not set in tags, get() returns null and equals() evaluates to false
oneway = true;
}
// - check tag "oneway"
String onewayTag = way.tags.get(TAG_ONEWAY);
if (onewayTag != null) {
if ("yes".equals(onewayTag)) {
oneway = true;
} else if ("true".equals(onewayTag)) {
oneway = true;
} else if ("1".equals(onewayTag)) {
oneway = true;
} else if ("-1".equals(onewayTag)) {
onewayReverse = true;
oneway = false;
} else if ("no".equals(onewayTag)) {
oneway = false; // may be used to overwrite defaults
}
}
// - check tag "oneway" with trunks, primary and secondary roads
// (if they are marked as such, the default number of lanes should be two instead of one)
if (highway != null) {
if (highway.equalsIgnoreCase("trunk")
|| highway.equalsIgnoreCase("primary")
|| highway.equalsIgnoreCase("secondary")) {
if (oneway && nofLanes == 1.0) {
nofLanes = 2.0;
}
}
}
// - ckeck tag "maxspeed"
String maxspeedTag = way.tags.get(TAG_MAXSPEED);
if (maxspeedTag != null) {
try {
freespeed = Double.parseDouble(maxspeedTag) / 3.6; // convert km/h to m/s
} catch (NumberFormatException e) {
if (!this.unknownMaxspeedTags.contains(maxspeedTag)) {
this.unknownMaxspeedTags.add(maxspeedTag);
log.warn("Could not parse maxspeed tag:" + e.getMessage() + ". Ignoring it.");
}
}
}
// - check tag "lanes"
String lanesTag = way.tags.get(TAG_LANES);
if (lanesTag != null) {
try {
double tmp = Double.parseDouble(lanesTag);
if (tmp > 0) {
nofLanes = tmp;
}
} catch (Exception e) {
if (!this.unknownLanesTags.contains(lanesTag)) {
this.unknownLanesTags.add(lanesTag);
log.warn("Could not parse lanes tag:" + e.getMessage() + ". Ignoring it.");
}
}
}
// define the links' capacity and freespeed
double capacity = nofLanes * laneCapacity;
if (this.scaleMaxSpeed) {
freespeed = freespeed * freespeedFactor;
}
// define modes allowed on link(s)
// basic type:
Set<String> modes = new HashSet<String>();
if (highway != null) {
modes.add("car");
}
if (railway != null) {
modes.add(railway);
}
if (ptway != null) {
modes.add(ptway);
}
if (modes.isEmpty()) {
modes.add("unknownStreetType");
}
// public transport:
for (OsmRelation relation : this.relations.values()) {
for (OsmParser.OsmRelationMember member : relation.members) {
if ((member.type == OsmParser.OsmRelationMemberType.WAY) && (member.refId == way.id)) {
String mode = relation.tags.get("name");
// mark that it is a link used by any pt:
if (mode == null) {
break;
} else {
modes.add("pt");
}
if (mode.indexOf(":") > 0
&& mode.indexOf(" ") > 0
&& mode.indexOf(" ") < mode.indexOf(":")) {
modes.add(mode.toLowerCase().substring(mode.indexOf(" "), mode.indexOf(":")).trim());
}
// modes.add(relation.tags.get("name"));
break;
}
}
}
// only create link, if both nodes were found, node could be null, since nodes outside a layer
// were dropped
Id<Node> fromId = Id.create(fromNode.id, Node.class);
Id<Node> toId = Id.create(toNode.id, Node.class);
if (network.getNodes().get(fromId) != null && network.getNodes().get(toId) != null) {
String origId = Long.toString(way.id);
if (!onewayReverse) {
Link l =
network
.getFactory()
.createLink(
Id.create(this.id, Link.class),
network.getNodes().get(fromId),
network.getNodes().get(toId));
l.setLength(length);
l.setFreespeed(freespeed);
l.setCapacity(capacity);
l.setNumberOfLanes(nofLanes);
l.setAllowedModes(modes);
if (l instanceof Link) {
final String id1 = origId;
NetworkUtils.setOrigId(((Link) l), id1);
}
network.addLink(l);
this.id++;
}
if (!oneway) {
Link l =
network
.getFactory()
.createLink(
Id.create(this.id, Link.class),
network.getNodes().get(toId),
network.getNodes().get(fromId));
l.setLength(length);
l.setFreespeed(freespeed);
l.setCapacity(capacity);
l.setNumberOfLanes(nofLanes);
l.setAllowedModes(modes);
if (l instanceof Link) {
final String id1 = origId;
NetworkUtils.setOrigId(((Link) l), id1);
}
network.addLink(l);
this.id++;
}
}
}
private static int createNetwork(Scenario sc) {
Network net = sc.getNetwork();
NetworkFactory fac = net.getFactory();
double length = 30;
double width = 20;
int id = 0;
Node n0 = fac.createNode(Id.createNodeId(id++), CoordUtils.createCoord(0, 0));
Node n1 = fac.createNode(Id.createNodeId(id++), CoordUtils.createCoord(length, 0));
net.addNode(n0);
net.addNode(n1);
List<Node> someNodes = new ArrayList<>();
for (double y = -30; y <= 30; y += 10) {
Node n = fac.createNode(Id.createNodeId(id++), CoordUtils.createCoord(length * 3, y));
net.addNode(n);
someNodes.add(n);
}
Node n2 = fac.createNode(Id.createNodeId(id++), CoordUtils.createCoord(length * 4, 0));
Node n3 = fac.createNode(Id.createNodeId(id++), CoordUtils.createCoord(length * 5, 0));
net.addNode(n2);
net.addNode(n3);
id = 0;
{
Link l0 = fac.createLink(Id.createLinkId(id++), n0, n1);
net.addLink(l0);
l0.setCapacity(width);
l0.setLength(length);
Link l0Rev = fac.createLink(Id.createLinkId(id++), n1, n0);
net.addLink(l0Rev);
l0Rev.setCapacity(width);
l0Rev.setLength(length);
}
int cnt = 0;
for (Node n : someNodes) {
{
Link l0 = fac.createLink(Id.createLinkId(id++), n1, n);
net.addLink(l0);
l0.setCapacity(width / someNodes.size());
l0.setLength(length * 2); // ?check!!
if (cnt++ % 2 != 0) {
Link l0Rev = fac.createLink(Id.createLinkId(id++), n, n1);
net.addLink(l0Rev);
l0Rev.setCapacity(width / someNodes.size());
l0Rev.setLength(length * 2);
}
}
{
Link l0 = fac.createLink(Id.createLinkId(id++), n, n2);
net.addLink(l0);
l0.setCapacity(width / someNodes.size());
l0.setLength(length); // ?check!!
Link l0Rev = fac.createLink(Id.createLinkId(id++), n2, n);
net.addLink(l0Rev);
l0Rev.setCapacity(width / someNodes.size());
l0Rev.setLength(length);
}
}
int ret;
{
ret = id++;
Link l0 = fac.createLink(Id.createLinkId(ret), n2, n3);
net.addLink(l0);
l0.setCapacity(width);
l0.setLength(length);
}
{
Link l0 = fac.createLink(Id.createLinkId(id++), n3, n2);
net.addLink(l0);
l0.setCapacity(width);
l0.setLength(length);
}
Set<String> modes = new HashSet<>();
modes.add("walkct");
for (Link l : net.getLinks().values()) {
l.setAllowedModes(modes);
l.setFreespeed(20);
}
return ret;
}
