rm.getPosition(this), rm, Parcel.class)); if (!inCargo && !rm.containsObject(curr.get())) { curr = Optional.absent(); } else if (inCargo) { rm.moveTo(this, curr.get().getDeliveryLocation(), time); if (rm.getPosition(this).equals(curr.get().getDeliveryLocation())) { rm.moveTo(this, curr.get(), time); if (rm.equalPosition(this, curr.get())) {
/** * Convenience method for {@link Graphs#findClosestObject}. * @param pos The {@link Point} which is used as reference. * @param rm The {@link RoadModel} which is searched. * @param type The type of object that is searched. * @param <T> The type of the returned object. * @return The closest object in <code>rm</code> to <code>pos</code> of type * <code>type</code>. * @see Graphs#findClosestObject */ @Nullable public static <T extends RoadUser> T findClosestObject(Point pos, RoadModel rm, final Class<T> type) { return findClosestObject(pos, rm, rm.getObjectsOfType(type)); }
@Override public void tick(TimeLapse timeLapse) { // every time step (tick) this gets called. Each time we chose a // different destination and move in that direction using the time // that was made available to us. if (!roadModel.containsObject(this)) { roadModel.addObjectAt(this, roadModel.getRandomPosition(rnd)); } roadModel.moveTo(this, roadModel.getRandomPosition(rnd), timeLapse); }
@Override public void initRoadUser(RoadModel model) { roadModel = Optional.of(model); roadModel.get().addObjectAt(this, roadModel.get().getRandomPosition(rng)); }
@Override public Optional<Point> getPosition() { if (roadModel.get().containsObject(this)) { return Optional.of(roadModel.get().getPosition(this)); } return Optional.absent(); }
pm.deliver(this, delivery, time); } else { rm.moveTo(this, delivery.getDeliveryLocation(), time); rm.getPosition(this), rm, new Predicate<RoadUser>() { @Override public boolean apply(@Nullable RoadUser input) { && Point.distance(rm.getPosition(closest), getPosition()) < DISTANCE_THRESHOLD_KM) { if (rm.equalPosition(closest, this) && pm.getTimeWindowPolicy().canPickup(closest.getPickupTimeWindow(), time.getTime(), closest.getPickupDuration())) { rm.moveTo(this, rm.getPosition(closest), time); if (rm.getObjectsOfType(Parcel.class).isEmpty()) { rm.moveTo(this, getStartPosition(), time); return; final Point p = verifyNotNull(gradientModel).getTargetFor(this); if (p != null) { rm.moveTo(this, p, time);
@Override protected void tickImpl(TimeLapse time) { final RoadModel rm = getRoadModel(); final PDPModel pm = getPDPModel(); // we always go to the closest available parcel final Parcel closest = (Parcel) RoadModels .findClosestObject(rm.getPosition(this), rm, new Predicate<RoadUser>() { @Override public boolean apply(@Nullable RoadUser input) { return input instanceof Parcel && pm.getParcelState((Parcel) input) == ParcelState.AVAILABLE; } }); if (closest != null) { rm.moveTo(this, closest, time); if (rm.equalPosition(closest, this) && pm .getTimeWindowPolicy() .canPickup(closest.getPickupTimeWindow(), time.getTime(), closest.getPickupDuration())) { pm.pickup(this, closest, time); } } } }
@Override @Nullable public Point apply(@Nullable T input) { return rm.getPosition(verifyNotNull(input)); } }
@Override public void tick(TimeLapse timeLapse) { if (!destination.isPresent()) { destination = Optional.of(roadModel.get().getRandomPosition(rng)); roadModel.get().moveTo(this, destination.get(), timeLapse); if (roadModel.get().getPosition(this).equals(destination.get())) { destination = Optional.absent();
@SuppressWarnings("synthetic-access") @Nullable @Override public DefaultEvent handle(@Nullable StateEvent event, RouteFollowingVehicle context) { if (route.isEmpty()) { return DefaultEvent.NOGO; } else if (destination.get() != route.element()) { return DefaultEvent.REROUTE; } final Parcel cur = route.element(); if (getRoadModel().equalPosition(context, cur)) { return DefaultEvent.ARRIVED; } getRoadModel().moveTo(context, cur, currentTime.get(), context.routeHeuristic); if (getRoadModel().equalPosition(context, cur) && currentTime.get().hasTimeLeft()) { return DefaultEvent.ARRIVED; } return null; }
.capacity(10) .build()); rm.register(truck); model.register(truck); final Parcel pack1 = Parcel.builder(new Point(1, 1), new Point(2, 2)) .neededCapacity(2d) .build(); rm.register(pack1); model.register(pack1); assertTrue(rm.equalPosition(truck, pack1)); assertEquals(ParcelState.AVAILABLE, model.getParcelState(pack1)); assertEquals(VehicleState.IDLE, model.getVehicleState(truck)); assertTrue(model.getParcels(ParcelState.AVAILABLE).isEmpty()); rm.moveTo(truck, pack1.getDeliveryLocation(), TimeLapseFactory.create(0, 3600000 * 3)); assertEquals(pack1.getDeliveryLocation(), rm.getPosition(truck)); .neededCapacity(2d) .build(); rm.register(pack2); model.register(pack2); assertEquals(ParcelState.AVAILABLE, model.getParcelState(pack2));
@Override public void renderDynamic(GC gc, ViewPort vp, long time) { final Set<RouteFollowingVehicle> vehicles = roadModel.getObjectsOfType( RouteFollowingVehicle.class); for (final RouteFollowingVehicle v : vehicles) { final Set<Parcel> seen = newHashSet(); final Point from = roadModel.getPosition(v); int prevX = vp.toCoordX(from.x); int prevY = vp.toCoordY(from.y); for (final Parcel parcel : ImmutableList.copyOf(v.getRoute())) { final Point to; if (pdpModel.getParcelState(parcel).isPickedUp() || seen.contains(parcel)) { to = parcel.getDto().getDeliveryLocation(); } else { to = parcel.getDto().getPickupLocation(); } seen.add(parcel); final int x = vp.toCoordX(to.x); final int y = vp.toCoordY(to.y); gc.drawLine(prevX, prevY, x, y); prevX = x; prevY = y; } } }
@Test public void moveToHeuristicTest() { final MovingRoadUser fastestPathAgent = new SpeedyRoadUser(10); final MovingRoadUser shortestPathAgent = new SpeedyRoadUser(10); final Point origin = new Point(0, 0); final Point destination = new Point(0, 10); final Point midway = new Point(5, 5); // Graph with slow direct (shortest) route, but fast longer route. final Graph<MultiAttributeData> graph = new TableGraph<>(); graph.addConnection(origin, destination, MultiAttributeData.builder().setLength(10).setMaxSpeed(1).build()); graph.addConnection(origin, midway, MultiAttributeData.builder().setLength(10).setMaxSpeed(10).build()); graph.addConnection(midway, destination, MultiAttributeData.builder().setLength(10).setMaxSpeed(10).build()); final RoadModel moveModel = RoadModelBuilders.staticGraph(graph) .withDistanceUnit(SI.KILOMETER).withSpeedUnit(NonSI.KILOMETERS_PER_HOUR) .build(mock(DependencyProvider.class)); moveModel.addObjectAt(fastestPathAgent, origin); moveModel.addObjectAt(shortestPathAgent, origin); moveModel.moveTo(fastestPathAgent, destination, hour(1), GeomHeuristics.time(10)); moveModel.moveTo(shortestPathAgent, destination, hour(1), GeomHeuristics.euclidean()); // Agent chose speedy route assertEquals(midway, moveModel.getPosition(fastestPathAgent)); // Agent chose shortest route assertEquals(new Point(0, 1), moveModel.getPosition(shortestPathAgent)); }
model.register(pack1); model.register(truck); rm.register(pack1); rm.register(truck); assertEquals(VehicleState.IDLE, model.getVehicleState(truck)); assertFalse(rm.containsObject(pack1)); assertTrue(model.containerContains(truck, pack1)); assertEquals(2, model.getContentsSize(truck), EPSILON); .build(); model.register(pack2); rm.register(pack2); rm.followPath(truck, newLinkedList(asList(new Point(1, 2))), TimeLapseFactory.create(0, 3600000)); assertEquals(new Point(1, 2), rm.getPosition(truck)); assertEquals(new Point(1, 2), rm.getPosition(pack2)); assertEquals(ParcelState.AVAILABLE, model.getParcelState(pack2)); assertEquals(VehicleState.IDLE, model.getVehicleState(truck)); model.pickup(truck, pack2, TimeLapseFactory.create(0, 40)); assertFalse(rm.containsObject(pack2)); final PickupAction action = (PickupAction) model .getVehicleActionInfo(truck);
@Test(expected = IllegalArgumentException.class) public void testPickupFail3A() { // package not in available state (it is already been picked up) final Vehicle truck = new TestVehicle( VehicleDTO.builder().startPosition(new Point(1, 1)).build()); rm.register(truck); model.register(truck); final Parcel pack1 = Parcel.builder(new Point(0, 0), new Point(2, 2)) .pickupDuration(10) .deliveryDuration(10) .neededCapacity(2d) .build(); rm.register(pack1); model.register(pack1); rm.addObjectAtSamePosition(pack1, truck); assertTrue(rm.equalPosition(truck, pack1)); assertEquals(ParcelState.AVAILABLE, model.getParcelState(pack1)); assertEquals(VehicleState.IDLE, model.getVehicleState(truck)); model.pickup(truck, pack1, TimeLapseFactory.create(0, 100)); assertEquals(ParcelState.IN_CARGO, model.getParcelState(pack1)); assertEquals(VehicleState.IDLE, model.getVehicleState(truck)); // checks what happens when you add a package to the roadmodel which has // already been picked up rm.addObjectAt(pack1, new Point(1, 1)); model.pickup(truck, pack1, TimeLapseFactory.create(0, 100)); }
@OverridingMethodsMustInvokeSuper @Override public void initRoadPDP(RoadModel pRoadModel, PDPModel pPdpModel) { super.initRoadPDP(pRoadModel, pPdpModel); final Set<Depot> depots = getRoadModel().getObjectsOfType(Depot.class); checkArgument(depots.size() == 1, "This vehicle requires exactly 1 depot, found %s depots.", depots.size()); checkArgument(getRoadModel() instanceof PDPRoadModel, "This vehicle requires the PDPRoadModel."); isDiversionAllowed = ((PDPRoadModel) getRoadModel()) .isVehicleDiversionAllowed(); depot = Optional.of(depots.iterator().next()); speed = Optional.of(Measure.valueOf(getSpeed(), getRoadModel() .getSpeedUnit())); }
synchronized (this) { /* 2 */checkArgument(roadModel.containsObject(parcel), "parcel does not exist in RoadModel"); final ParcelState ps = parcelState.getKeys(parcel); /* 5 */checkArgument(roadModel.equalPosition(vehicle, parcel), "vehicle must be at the same location as the parcel it wishes to " + "pickup"); roadModel.removeObject(parcel);
@Test(expected = IllegalArgumentException.class) public void testPickupFail6A() { // package does not fit in truck final Vehicle truck = new TestVehicle( VehicleDTO.builder().startPosition(new Point(1, 1)).build()); rm.register(truck); model.register(truck); final Parcel pack1 = Parcel.builder(new Point(0, 0), new Point(2, 2)) .neededCapacity(2d) .build(); rm.register(pack1); model.register(pack1); rm.addObjectAtSamePosition(pack1, truck); assertTrue(rm.equalPosition(truck, pack1)); model.pickup(truck, pack1, TimeLapseFactory.create(0, 100)); }
helper.adapt(gc, vp); synchronized (pdpModel) { final Map<RoadUser, Point> posMap = roadModel.getObjectsAndPositions(); final Set<Vehicle> vehicles = pdpModel.getVehicles(); final Set<Depot> depots = roadModel.getObjectsOfType(Depot.class); for (final Depot d : depots) { helper.setBackgroundSysCol(SWT.COLOR_GRAY);
@Override public final void initRoadUser(RoadModel model) { checkState(!roadModel.isPresent(), "RoadModel can not be registered twice!"); roadModel = Optional.of(model); if (startPosition.isPresent()) { model.addObjectAt(this, startPosition.get()); } if (pdpModel.isPresent()) { isRegistered = true; initRoadPDP(roadModel.get(), pdpModel.get()); } }