Simple Movement with real random waypoint map movement

src/de/tud/kom/p2psim/impl/topology/movement/RandomFixedWaypointMovement.java

+/*
+ * Copyright (c) 2005-2010 KOM – Multimedia Communications Lab
+ *
+ * This file is part of PeerfactSim.KOM.
+ * 
+ * PeerfactSim.KOM is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+ * 
+ * PeerfactSim.KOM is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with PeerfactSim.KOM.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package de.tud.kom.p2psim.impl.topology.movement;
+
+import java.util.List;
+import java.util.Random;
+
+import com.google.common.collect.Lists;
+
+import de.tud.kom.p2psim.api.scenario.ConfigurationException;
+import de.tud.kom.p2psim.api.topology.movement.SimLocationActuator;
+import de.tud.kom.p2psim.impl.topology.waypoints.graph.Waypoint;
+import de.tud.kom.p2psim.impl.topology.waypoints.graph.WeakWaypoint;
+import de.tudarmstadt.maki.simonstrator.api.Randoms;
+import de.tudarmstadt.maki.simonstrator.api.util.XMLConfigurableConstructor;
+
+public class RandomFixedWaypointMovement extends AbstractWaypointMovementModel {
+	private Random random = Randoms
+			.getRandom(RandomFixedWaypointMovement.class);
+	
+	@XMLConfigurableConstructor({"worldX", "worldY"})
+	public RandomFixedWaypointMovement(double worldX, double worldY) {
+		super(worldX, worldY);
+	}
+
+	@Override
+	public void nextPosition(SimLocationActuator component) {
+		if (waypointModel == null) {
+			throw new ConfigurationException("SLAWMovementModel requires a valid waypoint model which hasn't been provided, cannot execute");
+		}
+
+		List<Waypoint> waypoints = Lists.newArrayList(waypointModel.getWaypoints(WeakWaypoint.class));
+		
+		nextDestination(component, waypoints.get(random.nextInt(waypoints.size())).getPosition(), 0);
+		
+	}
+
+}

src/de/tud/kom/p2psim/impl/topology/movement/RandomWaypointMovement.java

@@ -20,22 +20,13 @@
 
 package de.tud.kom.p2psim.impl.topology.movement;
 
-import java.util.List;
-import java.util.Random;
-
-import com.google.common.collect.Lists;
-
 import de.tud.kom.p2psim.api.scenario.ConfigurationException;
 import de.tud.kom.p2psim.api.topology.movement.SimLocationActuator;
-import de.tud.kom.p2psim.impl.topology.waypoints.graph.Waypoint;
-import de.tud.kom.p2psim.impl.topology.waypoints.graph.WeakWaypoint;
-import de.tudarmstadt.maki.simonstrator.api.Randoms;
+import de.tud.kom.p2psim.impl.topology.waypoints.RandomWaypointGenerator;
 import de.tudarmstadt.maki.simonstrator.api.util.XMLConfigurableConstructor;
 
 public class RandomWaypointMovement extends AbstractWaypointMovementModel {
-	private Random random = Randoms
-			.getRandom(RandomWaypointMovement.class);
-	
+		
 	@XMLConfigurableConstructor({"worldX", "worldY"})
 	public RandomWaypointMovement(double worldX, double worldY) {
 		super(worldX, worldY);
@@ -46,10 +37,12 @@ public class RandomWaypointMovement extends AbstractWaypointMovementModel {
 		if (waypointModel == null) {
 			throw new ConfigurationException("SLAWMovementModel requires a valid waypoint model which hasn't been provided, cannot execute");
 		}
-
-		List<Waypoint> waypoints = Lists.newArrayList(waypointModel.getWaypoints(WeakWaypoint.class));
 		
-		nextDestination(component, waypoints.get(random.nextInt(waypoints.size())).getPosition(), 0);
+		if(!(waypointModel instanceof RandomWaypointGenerator)) {
+			throw new ConfigurationException("RandomWaypointMovement requires RandomWaypointModel generator which hasn't been provided, cannot execute");
+		}
+				
+		nextDestination(component, ((RandomWaypointGenerator)waypointModel).getRandomPoint(), 0);
 		
 	}
 

src/de/tud/kom/p2psim/impl/topology/movement/modularosm/SimpleMovementModel.java

+/*
+ * Copyright (c) 2005-2010 KOM – Multimedia Communications Lab
+ *
+ * This file is part of PeerfactSim.KOM.
+ * 
+ * PeerfactSim.KOM is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+ * 
+ * PeerfactSim.KOM is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with PeerfactSim.KOM.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package de.tud.kom.p2psim.impl.topology.movement.modularosm;
+
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+
+import de.tud.kom.p2psim.api.scenario.ConfigurationException;
+import de.tud.kom.p2psim.api.topology.Topology;
+import de.tud.kom.p2psim.api.topology.movement.MovementModel;
+import de.tud.kom.p2psim.api.topology.movement.SimLocationActuator;
+import de.tud.kom.p2psim.api.topology.movement.local.LocalMovementStrategy;
+import de.tud.kom.p2psim.api.topology.placement.PlacementModel;
+import de.tud.kom.p2psim.impl.simengine.Simulator;
+import de.tud.kom.p2psim.impl.topology.DefaultTopology;
+import de.tud.kom.p2psim.impl.topology.TopologyFactory;
+import de.tud.kom.p2psim.impl.topology.movement.modularosm.mapvisualization.IMapVisualization;
+import de.tud.kom.p2psim.impl.topology.util.PositionVector;
+import de.tud.kom.p2psim.impl.topology.views.VisualizationTopologyView.VisualizationInjector;
+import de.tud.kom.p2psim.impl.topology.waypoints.RandomWaypointGenerator;
+import de.tud.kom.p2psim.impl.util.Either;
+import de.tudarmstadt.maki.simonstrator.api.Binder;
+import de.tudarmstadt.maki.simonstrator.api.Event;
+import de.tudarmstadt.maki.simonstrator.api.EventHandler;
+import de.tudarmstadt.maki.simonstrator.api.Randoms;
+import de.tudarmstadt.maki.simonstrator.api.Time;
+
+
+
+public class SimpleMovementModel implements MovementModel, EventHandler {
+
+	protected final int EVENT_MOVE = 1;
+
+	protected final int EVENT_INIT = 2;
+
+	protected PositionVector worldDimensions;
+
+	protected LocalMovementStrategy localMovementStrategy;
+	
+	// TODO more generic approach
+	protected RandomWaypointGenerator attractionGenerator;
+	
+	protected IMapVisualization mapVisualization;
+	
+	protected Set<SimLocationActuator> moveableHosts = new LinkedHashSet<SimLocationActuator>();
+
+	protected Map<SimLocationActuator, PositionVector> currentTargets = new LinkedHashMap<>();
+
+	protected Map<SimLocationActuator, RouteSensorComponent> routeSensorComponents = new LinkedHashMap<>();
+
+	protected boolean initialized = false;
+
+	protected long timeBetweenMoveOperation = Simulator.SECOND_UNIT;
+
+	protected Random rand = Randoms.getRandom(SimpleMovementModel.class);
+	
+	
+	public SimpleMovementModel() {
+		this.worldDimensions = Binder.getComponentOrNull(Topology.class)
+				.getWorldDimensions();
+		
+		this.attractionGenerator =  new RandomWaypointGenerator();
+		
+		// scheduling initalization!
+		Event.scheduleImmediately(this, null, EVENT_INIT);
+	}
+		
+	
+	/**
+	 * This Method will be not called from the Components. So we call this
+	 * manually!
+	 */
+	public void initialize() {
+
+		if (!initialized) {
+						
+			
+			if (mapVisualization != null) {
+				VisualizationInjector.injectComponent(mapVisualization);
+			}
+		
+			checkConfiguration();
+
+			// setWayPointModel
+			localMovementStrategy.setObstacleModel(Binder
+					.getComponentOrNull(Topology.class).getObstacleModel());
+			localMovementStrategy.setWaypointModel(Binder
+					.getComponentOrNull(Topology.class).getWaypointModel());
+
+			/*
+			 * Scale depending on calculation interval, if interval != 1 Second.
+			 */
+			localMovementStrategy
+					.setScaleFactor(timeBetweenMoveOperation / (double) Time.SECOND);
+			
+			
+			setTimeBetweenMoveOperations(timeBetweenMoveOperation);
+
+			for (SimLocationActuator component : moveableHosts) {
+				updatedTargetAssignment(component, attractionGenerator.getRandomPoint());
+			}
+			
+			// initial move
+			move();
+
+			initialized = true;			
+		}
+	}
+
+	/**
+	 * This default implementation relies on {@link PlacementModel}s to be
+	 * configured in the {@link TopologyFactory}
+	 */
+	@Override
+	public void placeComponent(SimLocationActuator actuator) {
+		// not supported
+	}
+		
+	protected void checkConfiguration() {
+		if (localMovementStrategy == null) {
+			throw new ConfigurationException(
+					"LocalMovementStrategy is missing in ModularMovementModel!");
+		}		
+		if (attractionGenerator == null) {
+			throw new ConfigurationException(
+					"AttractionGenerator is missing in ModularMovementModel!");
+		}
+	}
+
+	@Override
+	public void addComponent(SimLocationActuator comp) {
+		moveableHosts.add(comp);
+		if (!routeSensorComponents.containsKey(comp)) {
+			routeSensorComponents.put(comp, new RouteSensorComponent(comp));
+		}
+	}
+	
+	public void updatedTargetAssignment(SimLocationActuator component,
+			PositionVector target) {
+		
+		currentTargets.put(component, target);
+	}
+
+	protected void move() {
+		for (SimLocationActuator component : moveableHosts) {
+			assert currentTargets.containsKey(component);
+			doLocalMovement(component, currentTargets.get(component));
+		}
+		
+		Event.scheduleWithDelay(timeBetweenMoveOperation, this, null,
+				EVENT_MOVE);
+	}
+		
+	
+	/**
+	 * 
+	 * Ask the local movement strategy for the next position. It may return the
+	 * next position or a boolean with true to notify the movement model that it
+	 * can't get any closer to the current way point.
+	 * 
+	 * @param ms
+	 * @param destination
+	 */
+	protected void doLocalMovement(SimLocationActuator ms, PositionVector destination) {
+		Either<PositionVector, Boolean> either = localMovementStrategy.nextPosition(ms, destination);
+		
+		if (either.hasLeft()) {
+			ms.updateCurrentLocation(either.getLeft());
+			if(!checkBoundaries(ms.getRealPosition())) {
+				System.err.println("Modular Movement Model: Host moved outside of simulated area!");
+			}				
+		} 
+		else {
+			updatedTargetAssignment(ms, attractionGenerator.getRandomPoint());
+		}
+	}
+
+	/* 
+	 * =====================================================================================================
+	 * === HELPER FUNCTIONS
+	 * =====================================================================================================
+	 */
+	/**
+	 * Notifies the user if a hosts position lies outside of the specified world size.
+	 * Enable asserts to get the notification
+	 * 
+	 */
+	public boolean checkBoundaries(PositionVector position) {		
+		return DefaultTopology.isWithinWorldBoundaries(position);
+	}
+
+	@Override
+	public void eventOccurred(Object content, int type) {
+		if (type == EVENT_INIT) {
+			initialize();
+		} else if (type == EVENT_MOVE) {
+			move();
+		}
+	}
+	
+	/* 
+	 * =====================================================================================================
+	 * === GETTER AND SETTER FUNCTIONS
+	 * =====================================================================================================
+	 */
+	public Set<SimLocationActuator> getAllLocationActuators() {
+		return moveableHosts;
+	}
+
+	@Override
+	public void setTimeBetweenMoveOperations(long time) {
+		if (time > 0) {
+			this.timeBetweenMoveOperation = time;
+		} else {
+			throw new ConfigurationException(
+					"time is negative for the Move Operations");
+		}
+	}
+	
+	public void setLocalMovementStrategy(LocalMovementStrategy localMovementStrategy) {
+		if (localMovementStrategy == null) {
+			throw new ConfigurationException(
+					"LocalMovementStrategy is missing in ModularMovementModel!");
+		}
+		this.localMovementStrategy = localMovementStrategy;
+	}
+	
+
+	public void setIMapVisualization(IMapVisualization mapVisualization) {
+		this.mapVisualization = mapVisualization;
+	}
+	
+	
+}

src/de/tud/kom/p2psim/impl/topology/waypoints/RandomWaypointGenerator.java

+/*
+ * Copyright (c) 2005-2010 KOM – Multimedia Communications Lab
+ *
+ * This file is part of PeerfactSim.KOM.
+ * 
+ * PeerfactSim.KOM is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+ * 
+ * PeerfactSim.KOM is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with PeerfactSim.KOM.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package de.tud.kom.p2psim.impl.topology.waypoints;
+
+import java.util.Random;
+
+import de.tud.kom.p2psim.api.topology.Topology;
+import de.tud.kom.p2psim.impl.topology.DefaultTopology;
+import de.tud.kom.p2psim.impl.topology.util.PositionVector;
+import de.tudarmstadt.maki.simonstrator.api.Binder;
+import de.tudarmstadt.maki.simonstrator.api.Randoms;
+
+public class RandomWaypointGenerator {
+	
+	private Random rand;
+	private PositionVector worldDimension;
+	
+	public RandomWaypointGenerator() {
+		super();
+		
+		this.worldDimension = Binder.getComponentOrNull(Topology.class)
+				.getWorldDimensions();
+		
+		this.rand = Randoms.getRandom(RandomWaypointGenerator.class);
+	}
+	
+	public PositionVector getRandomPoint() {
+		double x = rand.nextDouble() * Math.nextUp(worldDimension.getX());
+		double y = rand.nextDouble() * Math.nextUp(worldDimension.getY());
+		
+		PositionVector pos = new PositionVector(x, y);
+		
+		if(!DefaultTopology.isWithinWorldBoundaries(pos)) {
+			throw new UnsupportedOperationException("[RandomWaypointGenerator] The random generated point must be inside the simulation area!");
+		}
+		
+		return pos;
+	}
+}
\ No newline at end of file