public boolean isFitForAggregation(Point point) { boolean result = false; for (String propertyName : GlobalProperties.getPropertiesOfInterestDatabase().keySet()) { Object numberObject = point.getProperty(propertyName); if (numberObject instanceof Number) { result = result || !Utils.isNumberObjectNullOrZero((Number) numberObject); } else { /* * not a number, we cannot aggregate this currently */ result = result || false; } } /* * also check for bbox */ if (bbox != null) { Coordinate pointCoordinate = new Coordinate(point.getX(), point.getY()); if (!bbox.contains(Utils.geometryFactory.createPoint(pointCoordinate))) { return false; } } return result; }
public void runAccessibilityComputation() { final Network network = (Network) this.scenario.getNetwork(); ProgressBar bar = new ProgressBar(this.measuringPoints.getZones().size()); for (Zone<Id<Zone>> measurePoint : this.measuringPoints.getZones()) { bar.update(); Coord coord = MGC.point2Coord(measurePoint.getGeometry().getCentroid()); Point p = measurePoint.getGeometry().getCentroid(); final Coord coord1 = coord; Link nearestLink = NetworkUtils.getNearestLinkExactly(network, coord1); final Coord coord2 = coord; Node nearestNode = NetworkUtils.getNearestNode(network, coord2); Distances distance = NetworkUtil.getDistances2NodeViaGivenLink(coord, nearestLink, nearestNode); double distanceMeasuringPoint2Road_meter = distance.getDistancePoint2Intersection(); double walkTravelTime_h = distanceMeasuringPoint2Road_meter / this.walkSpeedMeterPerHour; // travel time from coord to network (node or link) if (boundary.contains(p)) this.freeSpeedGrid.setValue(walkTravelTime_h, p); } }
private static final List<Coord> getRandomCoordinatesInZone( int numCoordinates, Geometry zoneGeometry, Random random) { /* * Get the bounding box of the geometry. The returned geometry is a polygon with the following points: * (minx, miny), (maxx, miny), (maxx, maxy), (minx, maxy), (minx, miny). */ Geometry envelope = zoneGeometry.getEnvelope(); Coordinate[] coords = envelope.getCoordinates(); double minX = Double.MAX_VALUE; double maxX = Double.MIN_VALUE; double minY = Double.MAX_VALUE; double maxY = Double.MIN_VALUE; for (Coordinate coord : coords) { if (coord.x < minX) minX = coord.x; if (coord.x > maxX) maxX = coord.x; if (coord.y < minY) minY = coord.y; if (coord.y > maxY) maxY = coord.y; } List<Coord> list = new ArrayList<Coord>(); // loop until a valid point was found and is returned while (list.size() < numCoordinates) { double x = minX + random.nextDouble() * (maxX - minX); double y = minY + random.nextDouble() * (maxY - minY); Point point = geometryFactory.createPoint(new Coordinate(x, y)); if (zoneGeometry.contains(point)) list.add(fromWGS84CoordinateTransformation.transform(new Coord(x, y))); } return list; }
/** * <b>validateMultipleLayers Purpose:</b> <br> * * <p>This validation tests for a geometry containing another geometry. Uses JTS' * Geometry.contains(Geometry) method. DE-9IM intersection matrix is T*F**F***. * <b>Description:</b><br> * * <p>The function filters the FeatureSources using the given bounding box. It creates iterators * over both filtered FeatureSources. It calls contains() using the geometries in the * SimpleFeatureSource layers. Tests the results of the method call against the given expected * results. Returns true if the returned results and the expected results are true, false * otherwise. Author: bowens<br> * Created on: Apr 27, 2004<br> * * @param featureSourceA - the SimpleFeatureSource to pull the original geometries from. This * geometry is the one that is tested for containing the other * @param featureSourceB - the SimpleFeatureSource to pull the other geometries from - these * geometries will be those that may be contained within the first geometry * @param expected - boolean value representing the user's expected outcome of the test * @param results - ValidationResults * @param bBox - Envelope - the bounding box within which to perform the contains() * @return boolean result of the test * @throws Exception - IOException if iterators improperly closed */ private boolean validateMultipleLayers( SimpleFeatureSource featureSourceA, SimpleFeatureSource featureSourceB, boolean expected, ValidationResults results, Envelope bBox) throws Exception { boolean success = true; FilterFactory ff = CommonFactoryFinder.getFilterFactory(null); Filter filter = null; SimpleFeatureCollection featureResultsA = featureSourceA.getFeatures(filter); SimpleFeatureCollection featureResultsB = featureSourceB.getFeatures(filter); SimpleFeatureIterator fr1 = null; SimpleFeatureIterator fr2 = null; try { fr1 = featureResultsA.features(); if (fr1 == null) return false; while (fr1.hasNext()) { SimpleFeature f1 = fr1.next(); Geometry g1 = (Geometry) f1.getDefaultGeometry(); fr2 = featureResultsB.features(); try { while (fr2 != null && fr2.hasNext()) { SimpleFeature f2 = fr2.next(); Geometry g2 = (Geometry) f2.getDefaultGeometry(); if (g1.contains(g2) != expected) { results.error( f1, ((Geometry) f1.getDefaultGeometry()).getGeometryType() + " " + getGeomTypeRefA() + " contains " + getGeomTypeRefB() + "(" + f2.getID() + "), Result was not " + expected); success = false; } } } finally { fr2.close(); } } } finally { fr1.close(); fr2.close(); } return success; }
/** * Check if geometry is in SpatialFilter envelopes * * @param geometry Geometry to check * @param envelopes SpatialFilter envelopes * @return True if geometry is contained in envelopes */ public boolean featureIsInFilter(final Geometry geometry, final List<Geometry> envelopes) { if (geometry != null && !geometry.isEmpty()) { for (final Geometry envelope : envelopes) { if (envelope.contains(geometry)) { return true; } } } return false; }
private static Set<Point> filterCoors(Set<Coord> source, Geometry zone) { GeometryFactory factory = new GeometryFactory(); Set<Point> points = new HashSet<Point>(); for (Coord c : source) { Point p = factory.createPoint(new Coordinate(c.getX(), c.getY())); if (zone.contains(p)) points.add(p); } return points; }
/** * @param toSplit the line to split * @param line the line to use for the split * @return a sorted list of geometries as a result of splitting toSplit with line */ protected List<LineString> splitLine(Geometry toSplit, Geometry line) { List<LineString> output = new ArrayList(); Geometry lines = toSplit.union(line); for (int i = 0; i < lines.getNumGeometries(); i++) { LineString l = (LineString) lines.getGeometryN(i); // TODO to be tested if (toSplit.contains(l.getInteriorPoint())) { output.add(l); } } geometrySorter(output); return output; }
private Map<String, Double> fetchPointValues(KmlFeature feature, List<String> parameters) { try { SimpleFeatureIterator iterator = getIterator(); while (iterator.hasNext()) { SimpleFeature shape = iterator.next(); Geometry geometry = (Geometry) shape.getDefaultGeometry(); if (geometry.contains(feature.getGeometry())) return fetchValues(shape, parameters); } return Collections.emptyMap(); } catch (Exception e) { log.error("failed to fetch point values", e); return Collections.emptyMap(); } }
private TransitStopFacility drawRandomStop( Geometry buffer, PRouteProvider pRouteProvider, Set<Id> stopsUsed) { List<TransitStopFacility> choiceSet = new LinkedList<TransitStopFacility>(); // find choice-set for (TransitStopFacility stop : pRouteProvider.getAllPStops()) { if (!stopsUsed.contains(stop.getId())) { if (buffer.contains(MGC.coord2Point(stop.getCoord()))) { choiceSet.add(stop); } } } return pRouteProvider.drawRandomStopFromList(choiceSet); }
/*package*/ void addConnectorLinks() { QuadTree<Node> quadTree = getNodesQuadTree(); NetworkFactory factory = network.getFactory(); /* * Try to use the centroid of the polygon. If that does not lie within * the polygon, use an interior point. */ for (Entry<Integer, SimpleFeature> entry : zonesMap.entrySet()) { int zoneId = entry.getKey(); SimpleFeature zone = entry.getValue(); if (SpecialZones.skipZone(zone)) continue; Geometry polygon = (Geometry) zone.getDefaultGeometry(); Point point = polygon.getCentroid(); if (!polygon.contains(point)) point = polygon.getInteriorPoint(); /* * Convert coordinate from WGS84 to EPSG:28992 (Netherlands Projection) */ Coord wgs84Coord = new Coord(point.getCoordinate().x, point.getCoordinate().y); Coord nodeCoord = ct.transform(wgs84Coord); Id<Node> nodeId = Id.create(String.valueOf(zoneId), Node.class); network.addNode(factory.createNode(nodeId, nodeCoord)); Node networkConnectorNode = quadTree.getClosest(nodeCoord.getX(), nodeCoord.getY()); Id<Node> networkConnectorNodeId = networkConnectorNode.getId(); double length = CoordUtils.calcDistance(nodeCoord, networkConnectorNode.getCoord()); Id<Link> linkFromId = Id.create(String.valueOf(zoneId) + "from", Link.class); Link fromLink = factory.createLink(linkFromId, nodeId, networkConnectorNodeId); fromLink.setLength(length); fromLink.setCapacity(this.connectorCapacity); fromLink.setFreespeed(this.connectorLinkFreeSpeed); network.addLink(fromLink); Id<Link> linkToId = Id.create(String.valueOf(zoneId) + "to", Link.class); Link toLink = factory.createLink(linkToId, networkConnectorNodeId, nodeId); toLink.setLength(length); toLink.setCapacity(this.connectorCapacity); toLink.setFreespeed(this.connectorLinkFreeSpeed); network.addLink(toLink); } }
/** * @param poly the polygon to split * @param line the line to use for the split * @return a sorted list of geometries as a result of splitting poly with line */ protected List<Polygon> splitPolygon(Geometry poly, Geometry line) { List<Polygon> output = new ArrayList(); Geometry nodedLinework = poly.getBoundary().union(line); Geometry polys = polygonize(nodedLinework); // only keep polygons which are inside the input for (int i = 0; i < polys.getNumGeometries(); i++) { Polygon candpoly = (Polygon) polys.getGeometryN(i); if (poly.contains(candpoly.getInteriorPoint())) { output.add(candpoly); } } geometrySorter(output); return output; }
private Coord drawRandomPointFromGeometry(Geometry g) { Point p; double x, y; do { x = g.getEnvelopeInternal().getMinX() + random.nextDouble() * (g.getEnvelopeInternal().getMaxX() - g.getEnvelopeInternal().getMinX()); y = g.getEnvelopeInternal().getMinY() + random.nextDouble() * (g.getEnvelopeInternal().getMaxY() - g.getEnvelopeInternal().getMinY()); p = MGC.xy2Point(x, y); } while (!g.contains(p)); Coord coord = new Coord(p.getX(), p.getY()); return coord; }
@Override public boolean isWater(double lat, double lon) { double realLon = lon; if (lon == -180.0) { realLon = -179.9; } else if (lon == 180.0) { realLon = 179.9; } Coordinate coordinate = new Coordinate(realLon, lat); com.vividsolutions.jts.geom.Point point = geometryFactory.createPoint(coordinate); for (Geometry geometry : geometryList) { if (geometry.contains(point)) { return true; } } return false; // To change body of implemented methods use File | Settings | File Templates. }
// iterate over all nodes to find all external nodes private static final Set<Id<Node>> getExternalNodes( Scenario scenario, Map<Integer, SimpleFeature> zonalShapes) { Set<Id<Node>> externalNodes = new TreeSet<Id<Node>>(); for (Node node : scenario.getNetwork().getNodes().values()) { Coord pointCoord = toWGS84CoordinateTransformation.transform(node.getCoord()); Point point = geometryFactory.createPoint(new Coordinate(pointCoord.getX(), pointCoord.getY())); SimpleFeature pointZone = null; for (SimpleFeature zone : zonalShapes.values()) { Geometry polygon = (Geometry) zone.getDefaultGeometry(); if (polygon.contains(point)) { pointZone = zone; break; } } // if the point is not contained in any Zone it is an external node. if (pointZone == null) externalNodes.add(node.getId()); } return externalNodes; }
public void setupAgents(GeomVectorField populationLayer) { Bag nodeBag = majorRoadNodesLayer.getGeometries(); int numNodes = nodeBag.size(); for (Object o : populationLayer.getGeometries()) { MasonGeometry g = (MasonGeometry) o; Coordinate c = g.geometry.getCoordinate(); for (int i = 0; i < 50; i++) { // GeoNode gn = (GeoNode) nodeBag.get(random.nextInt(numNodes)); // Coordinate myHome = (Coordinate) gn.geometry.getCoordinate().clone(); // double distance = Math.abs(random.nextGaussian()) * 1500; // double degrees = random.nextDouble() * 2 * Math.PI; // double xOffset = distance * Math.cos(degrees) + c.x; double xOffset = random.nextGaussian() * 100 + c.x; // double yOffset = distance * Math.sin(degrees) + c.y; double yOffset = random.nextGaussian() * 100 + c.y; Coordinate myHome = new Coordinate(xOffset, yOffset); Geometry point = fa.createPoint(myHome); if (!landArea.contains(point)) continue; HumanTeleporter hum = new HumanTeleporter("id_" + random.nextLong(), myHome, myHome, this); humans.add(hum); } } }
public static void main(String[] args) { // Parameters Integer planningAreaId = 11000000; boolean onlyCar = false; // car; new, should be used for runs with ChangeLedModes enabled boolean onlyInterior = false; // int boolean onlyBerlinBased = true; // ber; usually varied for analysis boolean distanceFilter = true; // dist; usually varied for analysis // double minDistance = 0; double maxDistance = 100; boolean onlyWorkTrips = false; // NEW // -------------------------------------------------------------------------------------------------- boolean ageFilter = false; Integer minAge = 80; Integer maxAge = 119; // -------------------------------------------------------------------------------------------------- String runId = "run_168a"; // String runId = "run791"; String usedIteration = "300"; // most frequently used value: 150 // String usedIteration = "600"; int maxBinDuration = 120; int binWidthDuration = 1; // int binWidthDuration = 5; int maxBinTime = 23; int binWidthTime = 1; int maxBinDistance = 60; int binWidthDistance = 1; // int binWidthDistance = 5; int maxBinSpeed = 60; int binWidthSpeed = 1; // int binWidthSpeed = 5; // Input and output files String networkFile = "/Users/dominik/Workspace/shared-svn/studies/countries/de/berlin/counts/iv_counts/network.xml"; // String networkFile = // "D:/Workspace/shared-svn/studies/countries/de/berlin/counts/iv_counts/network.xml"; // String networkFile = "D:/Workspace/runs-svn/" + runId + // "/counts_network_merged.xml_cl.xml.gz"; // String eventsFile = "D:/Workspace/data/cemdapMatsimCadyts/output/" + runId + "/ITERS/it." // + usedIteration + "/" // String eventsFile = "D:/Workspace/runs-svn/" + runId + "/output_rerun/ITERS/it." + // usedIteration + "/" // + runId + "." + usedIteration + ".events.txt.gz"; // String eventsFile = "D:/Workspace/runs-svn/cemdapMatsimCadyts/" + runId + "/ITERS/it." + // usedIteration + "/" // + runId + "." + usedIteration + ".events.xml.gz"; String eventsFile = "/Users/dominik/Workspace/runs-svn/cemdapMatsimCadyts/" + runId + "/ITERS/it." + usedIteration + "/" + runId + "." + usedIteration + ".events.xml.gz"; // String cemdapPersonFile = // "D:/Workspace/data/cemdapMatsimCadyts/input/cemdap_berlin/19/persons1.dat"; // wrong!!! // String cemdapPersonFile = // "D:/Workspace/data/cemdapMatsimCadyts/input/cemdap_berlin/18/persons1.dat"; // String cemdapPersonFile = // "D:/Workspace/data/cemdapMatsimCadyts/input/cemdap_berlin/21/persons1.dat"; String cemdapPersonFile = "/Users/dominik/Workspace/data/cemdapMatsimCadyts/input/cemdap_berlin/21/persons1.dat"; // String outputDirectory = "D:/Workspace/data/cemdapMatsimCadyts/output/" + runId + // "/analysis"; // String outputDirectory = "D:/Workspace/runs-svn/cemdapMatsimCadyts/" + runId + // "/analysis"; String outputDirectory = "/Users/dominik/Workspace/runs-svn/cemdapMatsimCadyts/" + runId + "/analysis"; // String outputDirectory = "D:/Workspace/runs-svn/other/" + runId + "/analysis"; // String shapeFileBerlin = // "D:/Workspace/data/cemdapMatsimCadyts/input/shapefiles/Berlin_DHDN_GK4.shp"; String shapeFileBerlin = "/Users/dominik/Workspace/data/cemdapMatsimCadyts/input/shapefiles/Berlin_DHDN_GK4.shp"; Map<Integer, Geometry> zoneGeometries = ShapeReader.read(shapeFileBerlin, "NR"); Geometry berlinGeometry = zoneGeometries.get(planningAreaId); // Output naming Integer usedIt = Integer.parseInt(usedIteration); if (!usedIt.equals(150)) { outputDirectory = outputDirectory + "_" + usedIteration; } // -------------------------------------------------------------------------------------------------- if (onlyCar == true) { outputDirectory = outputDirectory + "_car"; } // -------------------------------------------------------------------------------------------------- if (onlyInterior == true) { outputDirectory = outputDirectory + "_int"; } if (onlyBerlinBased == true) { outputDirectory = outputDirectory + "_ber"; } if (distanceFilter == true) { outputDirectory = outputDirectory + "_dist"; } // -------------------------------------------------------------------------------------------------- if (onlyWorkTrips == true) { outputDirectory = outputDirectory + "_work"; } // -------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------- if (ageFilter == true) { outputDirectory = outputDirectory + "_" + minAge.toString(); outputDirectory = outputDirectory + "_" + maxAge.toString(); } // -------------------------------------------------------------------------------------------------- // Create an EventsManager instance (MATSim infrastructure) EventsManager eventsManager = EventsUtils.createEventsManager(); TripHandler handler = new TripHandler(); eventsManager.addHandler(handler); // Connect a file reader to the EventsManager and read in the event file MatsimEventsReader reader = new MatsimEventsReader(eventsManager); reader.readFile(eventsFile); System.out.println("Events file read!"); // check if all trips have been completed; if so, result will be zero int numberOfIncompleteTrips = 0; for (Trip trip : handler.getTrips().values()) { if (!trip.getTripComplete()) { numberOfIncompleteTrips++; } } System.out.println(numberOfIncompleteTrips + " trips are incomplete."); // -------------------------------------------------------------------------------------------------- CemdapPersonFileReader cemdapPersonFileReader = new CemdapPersonFileReader(); if (ageFilter == true) { // TODO needs to be adapted for other analyses that are based on person-specific attributes as // well // so far age is the only one // parse person file cemdapPersonFileReader.parse(cemdapPersonFile); } // -------------------------------------------------------------------------------------------------- // get network, which is needed to calculate distances Config config = ConfigUtils.createConfig(); Scenario scenario = ScenarioUtils.createScenario(config); MatsimNetworkReader networkReader = new MatsimNetworkReader(scenario); networkReader.readFile(networkFile); Network network = scenario.getNetwork(); // create objects int tripCounter = 0; int tripCounterSpeed = 0; int tripCounterIncomplete = 0; Map<Integer, Double> tripDurationMap = new TreeMap<Integer, Double>(); double aggregateTripDuration = 0.; Map<Integer, Double> departureTimeMap = new TreeMap<Integer, Double>(); Map<String, Double> activityTypeMap = new TreeMap<String, Double>(); Map<Integer, Double> tripDistanceRoutedMap = new TreeMap<Integer, Double>(); double aggregateTripDistanceRouted = 0.; Map<Integer, Double> tripDistanceBeelineMap = new TreeMap<Integer, Double>(); double aggregateTripDistanceBeeline = 0.; Map<Integer, Double> averageTripSpeedRoutedMap = new TreeMap<Integer, Double>(); double aggregateOfAverageTripSpeedsRouted = 0.; Map<Integer, Double> averageTripSpeedBeelineMap = new TreeMap<Integer, Double>(); double aggregateOfAverageTripSpeedsBeeline = 0.; int numberOfTripsWithNoCalculableSpeed = 0; Map<Id<Trip>, Double> distanceRoutedMap = new TreeMap<Id<Trip>, Double>(); Map<Id<Trip>, Double> distanceBeelineMap = new TreeMap<Id<Trip>, Double>(); Map<String, Integer> otherInformationMap = new TreeMap<String, Integer>(); // -------------------------------------------------------------------------------------------------- ObjectAttributes personActivityAttributes = new ObjectAttributes(); // -------------------------------------------------------------------------------------------------- // do calculations for (Trip trip : handler.getTrips().values()) { if (trip.getTripComplete()) { boolean considerTrip = false; // get coordinates of links Id<Link> departureLinkId = trip.getDepartureLinkId(); Id<Link> arrivalLinkId = trip.getArrivalLinkId(); Link departureLink = network.getLinks().get(departureLinkId); Link arrivalLink = network.getLinks().get(arrivalLinkId); double arrivalCoordX = arrivalLink.getCoord().getX(); double arrivalCoordY = arrivalLink.getCoord().getY(); double departureCoordX = departureLink.getCoord().getX(); double departureCoordY = departureLink.getCoord().getY(); // calculate (beeline) distance double horizontalDistanceInMeter = (Math.abs(departureCoordX - arrivalCoordX)) / 1000; double verticalDistanceInMeter = (Math.abs(departureCoordY - arrivalCoordY)) / 1000; double tripDistanceBeeline = Math.sqrt( horizontalDistanceInMeter * horizontalDistanceInMeter + verticalDistanceInMeter * verticalDistanceInMeter); // create points Point arrivalLocation = MGC.xy2Point(arrivalCoordX, arrivalCoordY); Point departureLocation = MGC.xy2Point(departureCoordX, departureCoordY); // choose if trip will be considered // Note: Check of "interior"/"berlinBased" has to come first since this sets the // "considerTrip" // variable to true. if (onlyInterior == true) { if (berlinGeometry.contains(arrivalLocation) && berlinGeometry.contains(departureLocation)) { considerTrip = true; } } else if (onlyBerlinBased == true) { if (berlinGeometry.contains(arrivalLocation) || berlinGeometry.contains(departureLocation)) { considerTrip = true; } } else { considerTrip = true; } // -------------------------------------------------------------------------------------------------- // if (!trip.getMode().equals("car") && !trip.getMode().equals("pt")) { // throw new RuntimeException("In current implementation leg mode must either be car or // pt"); // } if (onlyCar == true) { if (!trip.getMode().equals("car")) { considerTrip = false; } } // -------------------------------------------------------------------------------------------------- if (distanceFilter == true && tripDistanceBeeline >= maxDistance) { considerTrip = false; } // if (distanceFilter == true && tripDistanceBeeline <= minDistance) { // considerTrip = false; // } // -------------------------------------------------------------------------------------------------------------------- if (onlyWorkTrips == true) { boolean doesWorkTrip = false; if (trip.getActivityEndActType().equals("work")) { doesWorkTrip = true; } if (doesWorkTrip == true) { // can be varied considerTrip = false; } } // -------------------------------------------------------------------------------------------------------------------- // write person activity attributes // if (trip.getActivityEndActType().equals("work")) { // personActivityAttributes.putAttribute(trip.getDriverId(), "hasWorkActivity", // true); // } // TODO The plan was to claculated activity-chain frequencies here... // -------------------------------------------------------------------------------------------------- // PERSON-SPECIFIC ATTRIBUTES if (ageFilter == true) { // TODO needs to be adapted for other analyses that are based on person-specific // attributes as well // so far age is the only one String personId = trip.getPersonId().toString(); int age = (int) cemdapPersonFileReader.getPersonAttributes().getAttribute(personId, "age"); if (age < minAge) { considerTrip = false; } if (age > maxAge) { considerTrip = false; } } // -------------------------------------------------------------------------------------------------- if (considerTrip == true) { tripCounter++; // calculate travel times and store them in a map // trip.getArrivalTime() / trip.getDepartureTime() yields values in seconds! double departureTimeInSeconds = trip.getDepartureTime(); double arrivalTimeInSeconds = trip.getArrivalTime(); double tripDurationInSeconds = arrivalTimeInSeconds - departureTimeInSeconds; double tripDurationInMinutes = tripDurationInSeconds / 60.; double tripDurationInHours = tripDurationInMinutes / 60.; // addToMapIntegerKey(tripDurationMap, tripDurationInMinutes, 5, 120); addToMapIntegerKey( tripDurationMap, tripDurationInMinutes, binWidthDuration, maxBinDuration, 1.); aggregateTripDuration = aggregateTripDuration + tripDurationInMinutes; // store departure times in a map double departureTimeInHours = departureTimeInSeconds / 3600.; addToMapIntegerKey(departureTimeMap, departureTimeInHours, binWidthTime, maxBinTime, 1.); // store activities in a map String activityType = trip.getActivityStartActType(); addToMapStringKey(activityTypeMap, activityType); // calculate (routed) distances and and store them in a map double tripDistanceMeter = 0.; for (int i = 0; i < trip.getLinks().size(); i++) { Id<Link> linkId = trip.getLinks().get(i); Link link = network.getLinks().get(linkId); double length = link.getLength(); tripDistanceMeter = tripDistanceMeter + length; } // TODO here, the distances from activity to link and link to activity are missing! double tripDistanceRouted = tripDistanceMeter / 1000.; // store (routed) distances in a map addToMapIntegerKey( tripDistanceRoutedMap, tripDistanceRouted, binWidthDistance, maxBinDistance, 1.); aggregateTripDistanceRouted = aggregateTripDistanceRouted + tripDistanceRouted; distanceRoutedMap.put(trip.getTripId(), tripDistanceRouted); // store (beeline) distances in a map addToMapIntegerKey( tripDistanceBeelineMap, tripDistanceBeeline, binWidthDistance, maxBinDistance, 1.); aggregateTripDistanceBeeline = aggregateTripDistanceBeeline + tripDistanceBeeline; distanceBeelineMap.put(trip.getTripId(), tripDistanceBeeline); // calculate speeds and and store them in a map if (tripDurationInHours > 0.) { // System.out.println("trip distance is " + tripDistance + " and time is " + // timeInHours); double averageTripSpeedRouted = tripDistanceRouted / tripDurationInHours; addToMapIntegerKey( averageTripSpeedRoutedMap, averageTripSpeedRouted, binWidthSpeed, maxBinSpeed, 1.); aggregateOfAverageTripSpeedsRouted = aggregateOfAverageTripSpeedsRouted + averageTripSpeedRouted; double averageTripSpeedBeeline = tripDistanceBeeline / tripDurationInHours; addToMapIntegerKey( averageTripSpeedBeelineMap, averageTripSpeedBeeline, binWidthSpeed, maxBinSpeed, 1.); aggregateOfAverageTripSpeedsBeeline = aggregateOfAverageTripSpeedsBeeline + averageTripSpeedBeeline; tripCounterSpeed++; } else { numberOfTripsWithNoCalculableSpeed++; } } } else { System.err.println("Trip is not complete!"); tripCounterIncomplete++; // Until now, the only case where incomplete trips happen is when agents are removed // according to "removeStuckVehicles = true" // Since a removed agent can at most have one incomplete trip (this incomplete trip is // exactly the event when he is removed) // the number of incomplete trips should be equal to the number of removed agents } } double averageTripDuration = aggregateTripDuration / tripCounter; double averageTripDistanceRouted = aggregateTripDistanceRouted / tripCounter; double averageTripDistanceBeeline = aggregateTripDistanceBeeline / tripCounter; double averageOfAverageTripSpeedsRouted = aggregateOfAverageTripSpeedsRouted / tripCounterSpeed; double averageOfAverageTripSpeedsBeeline = aggregateOfAverageTripSpeedsBeeline / tripCounterSpeed; otherInformationMap.put( "Number of trips that have no previous activity", handler.getNoPreviousEndOfActivityCounter()); otherInformationMap.put( "Number of trips that have no calculable speed", numberOfTripsWithNoCalculableSpeed); otherInformationMap.put( "Number of incomplete trips (i.e. number of removed agents)", tripCounterIncomplete); otherInformationMap.put("Number of (complete) trips", tripCounter); // write results to files new File(outputDirectory).mkdir(); AnalysisFileWriter writer = new AnalysisFileWriter(); writer.writeToFileIntegerKey( tripDurationMap, outputDirectory + "/tripDuration.txt", binWidthDuration, tripCounter, averageTripDuration); writer.writeToFileIntegerKey( departureTimeMap, outputDirectory + "/departureTime.txt", binWidthTime, tripCounter, averageTripDuration); writer.writeToFileStringKey( activityTypeMap, outputDirectory + "/activityTypes.txt", tripCounter); writer.writeToFileIntegerKey( tripDistanceRoutedMap, outputDirectory + "/tripDistanceRouted.txt", binWidthDistance, tripCounter, averageTripDistanceRouted); writer.writeToFileIntegerKey( tripDistanceBeelineMap, outputDirectory + "/tripDistanceBeeline.txt", binWidthDistance, tripCounter, averageTripDistanceBeeline); writer.writeToFileIntegerKey( averageTripSpeedRoutedMap, outputDirectory + "/averageTripSpeedRouted.txt", binWidthSpeed, tripCounterSpeed, averageOfAverageTripSpeedsRouted); writer.writeToFileIntegerKey( averageTripSpeedBeelineMap, outputDirectory + "/averageTripSpeedBeeline.txt", binWidthSpeed, tripCounterSpeed, averageOfAverageTripSpeedsBeeline); writer.writeToFileIntegerKeyCumulative( tripDurationMap, outputDirectory + "/tripDurationCumulative.txt", binWidthDuration, tripCounter, averageTripDuration); writer.writeToFileIntegerKeyCumulative( tripDistanceBeelineMap, outputDirectory + "/tripDistanceBeelineCumulative.txt", binWidthDistance, tripCounter, averageTripDistanceBeeline); writer.writeToFileIntegerKeyCumulative( averageTripSpeedBeelineMap, outputDirectory + "/averageTripSpeedBeelineCumulative.txt", binWidthSpeed, tripCounterSpeed, averageOfAverageTripSpeedsBeeline); writer.writeToFileOther(otherInformationMap, outputDirectory + "/otherInformation.txt"); // write a routed distance vs. beeline distance comparison file writer.writeRoutedBeelineDistanceComparisonFile( distanceRoutedMap, distanceBeelineMap, outputDirectory + "/beeline.txt", tripCounter); }
private boolean isBuildingInZone(Geometry zone, Coord building) { ; Point p = MGC.xy2Point(building.getX(), building.getY()); return zone.contains(p); }
/** * Returns a boolean value that shows if this geometry contains the specified geometry. * * @param node1 xml element containing gml object(s) * @param node2 xml element containing gml object(s) * @return boolean value * @throws QueryException query exception */ @Deterministic public Bln contains(final ANode node1, final ANode node2) throws QueryException { final Geometry geo1 = checkGeo(node1); final Geometry geo2 = checkGeo(node2); return Bln.get(geo1.contains(geo2)); }