@Override public Coord getCoord() { return this.activityFacility.getCoord(); }
private static Collection<ActivityFacility> approximatePrism( final double maxTraveledDistance, final QuadTree<ActivityFacility> quadTree, final ActivityFacility start, final ActivityFacility end) { return quadTree.getElliptical( start.getCoord().getX(), start.getCoord().getY(), end.getCoord().getX(), end.getCoord().getY(), maxTraveledDistance); }
@Override public void setFacilityAccessibilities(ActivityFacility origin, Double timeOfDay, Map<String, Double> accessibilities) { for (Map.Entry<String, Double> modes4AccessibilityDoubleEntry : accessibilities.entrySet()) { accessibilityGrids.get(modes4AccessibilityDoubleEntry.getKey()).setValue(modes4AccessibilityDoubleEntry.getValue(), origin.getCoord().getX(), origin.getCoord().getY()); } }
final Coord calcBarycenterCoord( final List<Activity> activitiesToMutate ) { double sumX = 0; double sumY = 0; for ( Activity act : activitiesToMutate ) { final Id facilityId = act.getFacilityId(); if ( facilityId == null ) throw new RuntimeException( "no facility for act "+act ); final ActivityFacility fac = facilities.getFacilities().get( facilityId ); sumX += fac.getCoord().getX(); sumY += fac.getCoord().getY(); } return new Coord(sumX / activitiesToMutate.size(), sumY / activitiesToMutate.size()); }
public void run(ActivityFacilitiesImpl facilities) { System.out.println(" running " + this.getClass().getName() + " module..."); TreeSet<Id<ActivityFacility>> fid_set = new TreeSet<Id<ActivityFacility>>(); Iterator<Id<ActivityFacility>> fid_it = facilities.getFacilities().keySet().iterator(); while (fid_it.hasNext()) { Id<ActivityFacility> fid = fid_it.next(); ActivityFacility f = facilities.getFacilities().get(fid); Coord coord = f.getCoord(); double x = coord.getX(); double y = coord.getY(); if (!((x < this.maxX) && (this.minX < x) && (y < this.maxY) && (this.minY < y))) { fid_set.add(fid); } } System.out.println(" Number of facilities to be cut = " + fid_set.size() + "..."); fid_it = fid_set.iterator(); while (fid_it.hasNext()) { Id<ActivityFacility> fid = fid_it.next(); facilities.getFacilities().remove(fid); } System.out.println(" done."); } }
private Map<Id<Node>, ArrayList<ActivityFacility>> aggregateMeasurePointsWithSameNearestNode() { Map<Id<Node>,ArrayList<ActivityFacility>> aggregatedOrigins = new ConcurrentHashMap<>(); Gbl.assertNotNull(measuringPoints); Gbl.assertNotNull(measuringPoints.getFacilities()) ; for (ActivityFacility measuringPoint : measuringPoints.getFacilities().values()) { // Determine nearest network node (from- or toNode) based on the link Node nearestNode = NetworkUtils.getCloserNodeOnLink(measuringPoint.getCoord(), NetworkUtils.getNearestLinkExactly(network, measuringPoint.getCoord())); Id<Node> nearestNodeId = nearestNode.getId(); // Create new entry if key does not exist! if(!aggregatedOrigins.containsKey(nearestNodeId)) { aggregatedOrigins.put(nearestNodeId, new ArrayList<ActivityFacility>()); } // Assign measure point (origin) to it's nearest node aggregatedOrigins.get(nearestNodeId).add(measuringPoint); } LOG.info("Number of measuring points: " + measuringPoints.getFacilities().values().size()); LOG.info("Number of aggregated measuring points: " + aggregatedOrigins.size()); return aggregatedOrigins; }
static Collection<Geometry> determineVoronoiShapes(ActivityFacilities measuringPoints, BoundingBox box) { LOG.warn("Started creating Voronoi shapes."); Collection<Coordinate> sites = new ArrayList<>(); for (ActivityFacility measuringPoint : measuringPoints.getFacilities().values()) { Coordinate coordinate = new Coordinate(measuringPoint.getCoord().getX(), measuringPoint.getCoord().getY()); sites.add(coordinate); } VoronoiDiagramBuilder voronoiDiagramBuilder = new VoronoiDiagramBuilder(); voronoiDiagramBuilder.setSites(sites); List<Polygon> polygons = voronoiDiagramBuilder.getSubdivision().getVoronoiCellPolygons(geometryFactory); Polygon boundingPolygon = createBoundingPolygon(box); Collection<Geometry> geometries = cutPolygonsByBoundary(polygons, boundingPolygon); LOG.warn("Finished creating Voronoi shapes."); return geometries; }
private void assertReprojectedCorrectly(ActivityFacility originalFacility, ActivityFacility reprojectedFacility) { final Coord original = originalFacility.getCoord(); final Coord transformed = reprojectedFacility.getCoord(); Assert.assertEquals( "wrong reprojected coordinate", transformation.transform(original), transformed); } }
protected boolean modifyLocation(Activity act, Coord startCoord, Coord endCoord, double radius, int trialNr) { ArrayList<ActivityFacility> choiceSet = this.computeChoiceSetCircle(startCoord, endCoord, radius, act.getType()); if (choiceSet.size()>1) { //final Facility facility=(Facility)choiceSet.toArray()[ // MatsimRandom.random.nextInt(choiceSet.size())]; final ActivityFacility facility = choiceSet.get(super.random.nextInt(choiceSet.size())); act.setFacilityId(facility.getId()); act.setLinkId(NetworkUtils.getNearestLink(((Network) this.scenario.getNetwork()), facility.getCoord()).getId()); act.setCoord(facility.getCoord()); return true; } // else ... return false; }
public static void assignAdditionalFacilitiesDataToMeasurePoint(ActivityFacilities measurePoints, Map<Id<ActivityFacility>, Geometry> measurePointGeometryMap, Map<String, ActivityFacilities> additionalFacilityData) { LOG.info("Start assigning additional facilities data to measure point."); GeometryFactory geometryFactory = new GeometryFactory(); for (ActivityFacilities additionalDataFacilities : additionalFacilityData.values()) { // Iterate over all additional data collections String additionalDataName = additionalDataFacilities.getName(); int additionalDataFacilitiesToAssign = additionalDataFacilities.getFacilities().size(); for (Id<ActivityFacility> measurePointId : measurePoints.getFacilities().keySet()) { // Iterate over all measure points ActivityFacility measurePoint = measurePoints.getFacilities().get(measurePointId); measurePoint.getAttributes().putAttribute(additionalDataName, 0); Geometry geometry = measurePointGeometryMap.get(measurePointId); for (ActivityFacility facility : additionalDataFacilities.getFacilities().values()) { // Iterate over additional-data facilities Point point = geometryFactory.createPoint(new Coordinate(facility.getCoord().getX(), facility.getCoord().getY())); if (geometry.contains(point)) { measurePoint.getAttributes().putAttribute(additionalDataName, (int) measurePoint.getAttributes().getAttribute(additionalDataName) + 1); additionalDataFacilitiesToAssign--; } } } LOG.warn(additionalDataFacilitiesToAssign + " have not been assigned to a measure point geometry."); } LOG.info("Finished assigning additional facilities data to measure point."); } }
public final void connectFacilitiesWithLinks(final ActivityFacilities facilities, final Network network) { log.info(" connecting facilities with links..."); Set<Id<ActivityFacility>> remainingFacilities = new HashSet<>(facilities.getFacilities().keySet()); if (this.config != null) { String inputF2LFile = this.config.findParam(CONFIG_F2L,CONFIG_F2L_INPUTF2LFile); if (inputF2LFile != null) { connectByFile(facilities,network,inputF2LFile,remainingFacilities); } } log.info(" connecting remaining facilities with links ("+remainingFacilities.size()+" remaining)..."); for (Id<ActivityFacility> fid : remainingFacilities) { ActivityFacility f = facilities.getFacilities().get(fid); Link l = NetworkUtils.getNearestRightEntryLink(network, f.getCoord()); l = network.getLinks().get(l.getId()); mapFacilityToLink(f,l); } log.info(" done."); if (this.config != null) { String outputF2LFile = this.config.findParam(CONFIG_F2L,CONFIG_F2L_OUTPUTF2LFile); if (outputF2LFile != null) { writeF2LFile(facilities,outputF2LFile); } } log.info(" done. (connecting facilities with links)"); }
public PrismicLocationChoiceAlgorithm( final PrismicLocationChoiceConfigGroup config, final LocationChooser chooser, final ActivityFacilities facilities, final SocialNetwork socialNetwork, final StageActivityTypes stages) { this.random = MatsimRandom.getLocalInstance(); this.chooser = chooser; this.config = config; this.facilities = facilities; this.socialNetwork = socialNetwork; this.stages = stages; this.facilitiesPerType = new HashMap<String, QuadTree<ActivityFacility>>(); for ( String type : config.getTypes() ) { final QuadTreeRebuilder<ActivityFacility> builder = new QuadTreeRebuilder<ActivityFacility>(); for ( ActivityFacility facility : facilities.getFacilitiesForActivityType( type ).values() ) { builder.put( facility.getCoord() , facility ); } this.facilitiesPerType.put( type , builder.getQuadTree() ); } }
private void setLocation(Activity act2, Id<ActivityFacility> facilityId) { // ActivityImpl act = (ActivityImpl) act2; // act.setFacilityId(facilityId); PlanUtils.setFacilityId(act2, facilityId); ActivityFacility facility = this.facilities.getFacilities().get(facilityId); Id<Link> linkId = null; // try to get linkId from facility, else get it from coords. other options not allowed! if (facility.getLinkId() != null) { linkId = facility.getLinkId(); } else { linkId = this.nearestLinks.get(facilityId); } // act.setLinkId(linkId); // act.setCoord(facility.getCoord()); PlanUtils.setLinkId(act2, linkId); PlanUtils.setCoord(act2, facility.getCoord()); }
protected final boolean modifyLocation(Activity act, Coord startCoord, Coord endCoord, double radius) { double midPointX = (startCoord.getX() + endCoord.getX()) / 2.0; double midPointY = (startCoord.getY() + endCoord.getY()) / 2.0; ArrayList<ActivityFacility> facilitySet = (ArrayList<ActivityFacility>) this.quadTreesOfType.get(this.defineFlexibleActivities.getConverter().convertType(act.getType())). getDisk(midPointX, midPointY, radius); ActivityFacility facility = null; if (facilitySet.size() > 1) { facility = facilitySet.get(super.random.nextInt(facilitySet.size())); } else { return false; } act.setFacilityId(facility.getId()); act.setLinkId(NetworkUtils.getNearestLink(((Network) this.scenario.getNetwork()), facility.getCoord()).getId()); act.setCoord(facility.getCoord()); return true; }
@Deprecated // use "decideOnCoord..." public static Coord computeCoordFromActivity( Activity act, ActivityFacilities facs, Network network, Config config ) { // the following might eventually become configurable by config. kai, feb'16 if ( act.getFacilityId()==null ) { if ( act.getCoord()!=null ) { return act.getCoord() ; } else { Gbl.assertNotNull( network ); Link link = network.getLinks().get( act.getLinkId() ) ; return link.getCoord() ; } } else { Gbl.assertIf( facs!=null ) ; ActivityFacility facility = facs.getFacilities().get( act.getFacilityId() ) ; Gbl.assertIf( facility!=null ); return facility.getCoord() ; } }
public static Coord decideOnCoordForActivity( Activity act, Scenario sc ) { if ( act.getFacilityId() !=null ) { final ActivityFacility facility = sc.getActivityFacilities().getFacilities().get( act.getFacilityId() );; Gbl.assertNotNull( facility ); Gbl.assertNotNull( facility.getCoord() ) ; return facility.getCoord() ; } if ( act.getCoord()!=null ) { return act.getCoord() ; } else { Gbl.assertNotNull( sc.getNetwork() ); Link link = sc.getNetwork().getLinks().get( act.getLinkId() ) ; Gbl.assertNotNull( link ); return link.getCoord() ; } } public static double decideOnTravelTimeForLeg( Leg leg ) {
private void mutateLocations( final String type, final List<Activity> activitiesToMutate) { final Coord coordBarycenter = calcBarycenterCoord( activitiesToMutate ); final double angle = random.nextDouble() * Math.PI; final double distance = nextNormalDouble() * config.getStandardDeviation(); final ActivityFacility fac = getFacility( type, coordBarycenter, angle, distance ); for ( Activity act : activitiesToMutate ) { ((Activity) act).setFacilityId( fac.getId() ); ((Activity) act).setLinkId( fac.getLinkId() ); ((Activity) act).setCoord( fac.getCoord() ); } }
private static void changeLocation( final Collection<Subchain> subchains, final ActivityFacility facility) { for ( Subchain subchain : subchains ) { ((Activity) subchain.getToMove()).setFacilityId( facility.getId() ); ((Activity) subchain.getToMove()).setLinkId( facility.getLinkId() ); ((Activity) subchain.getToMove()).setCoord( facility.getCoord() ); } }
private Tuple<QuadTree<ActivityFacilityWithIndex>, ActivityFacilityImpl[]> getTuple(String activityType) { TreesBuilder treesBuilder = new TreesBuilder(CollectionUtils.stringToSet(activityType), this.scenario.getNetwork(), this.dccg); treesBuilder.setActTypeConverter(this.getConverter()); treesBuilder.createTrees(scenario.getActivityFacilities()); ActivityFacilityImpl[] facilities = treesBuilder.getFacilitiesOfType().get(activityType); /* * Create a copy of the treesBuilder.getQuadTreesOfType() outcome where the * ActivityFacility objects are replaced by ActivityFacilityWithIndex objects. * TODO: let the TreeBuilder use ActivityFacilityWithIndex objects directly? */ QuadTree<ActivityFacilityWithIndex> quadTree = null; QuadTree<ActivityFacility> qt = treesBuilder.getQuadTreesOfType().get(activityType); if (qt != null) { double minX = qt.getMinEasting(); double maxX = qt.getMaxEasting(); double minY = qt.getMinNorthing(); double maxY = qt.getMaxNorthing(); quadTree = new QuadTree<ActivityFacilityWithIndex>(minX, minY, maxX, maxY); for (ActivityFacility activityFacility : qt.values()) { quadTree.put(activityFacility.getCoord().getX(), activityFacility.getCoord().getY(), this.faciliesWithIndexMap.get(activityFacility.getId())); } } return new Tuple<QuadTree<ActivityFacilityWithIndex>, ActivityFacilityImpl[]>(quadTree, facilities); }
@Test public void testCreateActivityFacility() { ActivityFacilitiesFactoryImpl factory = new ActivityFacilitiesFactoryImpl(); ActivityFacility facility = factory.createActivityFacility(Id.create(1980, ActivityFacility.class), new Coord((double) 5, (double) 11)); Assert.assertEquals("1980", facility.getId().toString()); Assert.assertEquals(5.0, facility.getCoord().getX(), 1e-9); Assert.assertEquals(11.0, facility.getCoord().getY(), 1e-9); }