add KnowledgeBase to PsychologyStatus

allows to add multiple Knowledge items to a pedestrian. These are
used to filter pedestrians based on some knowledge pedestrians have.

VadereManager/src/org/vadere/manager/client/TestClient.java

@@ -655,4 +655,8 @@ public class TestClient extends org.vadere.manager.client.AbstractTestClient imp
 		System.out.println(res.toString());
 	}
 
+	@Override
+	public void personapi_setInformation(String[] args) throws IOException {
+
+	}
 }

VadereManager/src/org/vadere/manager/traci/commandHandler/PersonCommandHandler.java

@@ -13,8 +13,10 @@ import org.vadere.manager.traci.commandHandler.variables.PersonVar;
 import org.vadere.manager.traci.commands.TraCICommand;
 import org.vadere.manager.traci.commands.TraCIGetCommand;
 import org.vadere.manager.traci.commands.TraCISetCommand;
+import org.vadere.manager.traci.compound.CompoundObject;
 import org.vadere.manager.traci.response.TraCIGetResponse;
 import org.vadere.simulator.control.simulation.SimulationState;
+import org.vadere.state.psychology.perception.types.InformationStimulus;
 import org.vadere.state.scenario.Pedestrian;
 import org.vadere.state.util.StateJsonConverter;
 import org.vadere.util.geometry.Vector3D;
@@ -392,6 +394,26 @@ public class PersonCommandHandler extends CommandHandler<PersonVar> {
 		return cmd;
 	}
 
+	@PersonHandler(cmd = TraCICmd.SET_PERSON_STATE, var = PersonVar.STIMULUS, name = "setInformation")
+	public TraCICommand process_setStimulus(TraCISetCommand cmd, RemoteManager remoteManager) {
+		CompoundObject data = (CompoundObject) cmd.getVariableValue();
+		double start_t = (double)data.getData(0, TraCIDataType.DOUBLE);
+		double obsolete_at = (double)data.getData(1, TraCIDataType.DOUBLE);
+		String information = (String)data.getData(2, TraCIDataType.STRING);
+
+//		LinkedList<Integer> data = tmp.stream().map(Integer::parseInt).collect(Collectors.toCollection(LinkedList::new));
+		remoteManager.accessState((manager, state) -> {
+			Pedestrian ped = state.getTopography().getPedestrianDynamicElements()
+					.getElement(Integer.parseInt(cmd.getElementId()));
+			if (checkIfPedestrianExists(ped, cmd)) {
+				InformationStimulus s = new InformationStimulus(start_t, obsolete_at, information);
+				ped.getKnowledgeBase().add_information(s);
+				cmd.setOK();
+			}
+		});
+		return cmd;
+	}
+
 	@PersonHandler(cmd = TraCICmd.SET_PERSON_STATE, var = PersonVar.TARGET_LIST, name = "setTargetList", dataTypeStr = "ArrayList<String>")
 	public TraCICommand process_setTargetList(TraCISetCommand cmd, RemoteManager remoteManager) {
 		List<String> tmp = (List<String>) cmd.getVariableValue();

VadereManager/src/org/vadere/manager/traci/commandHandler/variables/PersonVar.java

@@ -36,6 +36,7 @@ public enum PersonVar {
 	ADD(0x80, TraCIDataType.STRING),
 	REMOVE_STAGE(0xc5, TraCIDataType.INTEGER), // set
 	TARGET_LIST(0xfe, TraCIDataType.STRING_LIST), // get, set
+	STIMULUS(0xfd, TraCIDataType.COMPOUND_OBJECT)
 	;
 
 

VadereSimulator/src/org/vadere/simulator/projects/dataprocessing/processor/MeshDensityCountingProcessor.java

@@ -18,8 +18,8 @@ import java.util.Collection;
 @DataProcessorClass(label = "MeshDensityCountingProcessor")
 public class MeshDensityCountingProcessor extends DataProcessor<TimestepFaceIdKey, Integer> {
 
-	private final static String propertyNameNumberOfPedestrians = "numberOfPedestrians";
-	private MeshProcessor meshProcessor;
+	protected final static String propertyNameNumberOfPedestrians = "numberOfPedestrians";
+	protected MeshProcessor meshProcessor;
 
 	public MeshDensityCountingProcessor() {
 		super("meshDensityCounting");
@@ -32,38 +32,35 @@ public class MeshDensityCountingProcessor extends DataProcessor<TimestepFaceIdKe
 		this.meshProcessor = (MeshProcessor) manager.getProcessor(getAttributes().getMeshProcessorId());
 	}
 
-	private IMesh<PVertex, PHalfEdge, PFace> getMesh() {
+	protected IMesh<PVertex, PHalfEdge, PFace> getMesh() {
 		return meshProcessor.getTriangulation().getMesh();
 	}
 
-	private MeasurementArea getMeasurementArea() {
+	protected MeasurementArea getMeasurementArea() {
 		return meshProcessor.getMeasurementArea();
 	}
 
-	private IIncrementalTriangulation<PVertex, PHalfEdge, PFace> getTriangulation() {
+	protected IIncrementalTriangulation<PVertex, PHalfEdge, PFace> getTriangulation() {
 		return meshProcessor.getTriangulation();
 	}
 
-	@Override
-	protected void doUpdate(SimulationState state) {
-		Collection<Pedestrian> peds = state.getTopography().getElements(Pedestrian.class);
+	protected void doUpdateOnPed(Pedestrian ped){
+		if(getMeasurementArea().asPolygon().contains(ped.getPosition())) {
+			PFace f = getTriangulation().locate(ped.getPosition(), ped).get();
+			int n = getMesh().getIntegerData(f, propertyNameNumberOfPedestrians) + 1;
+			getMesh().setIntegerData(f, propertyNameNumberOfPedestrians, n);
+			assert !getMesh().isBoundary(f);
+		}
+	}
 
+	protected void reset_count(){
 		// reset count
 		for(PFace f : getMesh().getFaces()) {
 			getMesh().setIntegerData(f, propertyNameNumberOfPedestrians, 0);
 		}
+	}
 
-		// compute count
-		for(Pedestrian ped : peds) {
-
-			if(getMeasurementArea().asPolygon().contains(ped.getPosition())) {
-				PFace f = getTriangulation().locate(ped.getPosition(), ped).get();
-				int n = getMesh().getIntegerData(f, propertyNameNumberOfPedestrians) + 1;
-				getMesh().setIntegerData(f, propertyNameNumberOfPedestrians, n);
-				assert !getMesh().isBoundary(f);
-			}
-		}
-
+	protected void write_count(SimulationState state){
 		// write count
 		int faceId = 1;
 		for(PFace f : getMesh().getFaces()) {
@@ -73,6 +70,20 @@ public class MeshDensityCountingProcessor extends DataProcessor<TimestepFaceIdKe
 		}
 	}
 
+	@Override
+	protected void doUpdate(SimulationState state) {
+		Collection<Pedestrian> peds = state.getTopography().getElements(Pedestrian.class);
+
+		reset_count();
+
+		// compute count
+		for(Pedestrian ped : peds) {
+			doUpdateOnPed(ped);
+		}
+
+		write_count(state);
+	}
+
 	@Override
 	public AttributesMeshDensityCountingProcessor getAttributes() {
 		if(super.getAttributes() == null) {

VadereSimulator/src/org/vadere/simulator/projects/dataprocessing/processor/MeshPedStimulusCountingProcessor.java

+package org.vadere.simulator.projects.dataprocessing.processor;
+
+import org.vadere.annotation.factories.dataprocessors.DataProcessorClass;
+import org.vadere.simulator.control.simulation.SimulationState;
+import org.vadere.simulator.projects.dataprocessing.ProcessorManager;
+import org.vadere.state.attributes.processor.AttributesMeshPedStimulusCountingProcessor;
+import org.vadere.state.scenario.Pedestrian;
+
+import java.util.Collection;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+
+@DataProcessorClass(label = "MeshPedStimulusCountingProcessor")
+public class MeshPedStimulusCountingProcessor extends MeshDensityCountingProcessor {
+
+	private Predicate<Pedestrian> filter_by_stimuli;
+	private Pattern filter_pattern = null;
+
+	public MeshPedStimulusCountingProcessor(){
+		setAttributes(new AttributesMeshPedStimulusCountingProcessor());
+	}
+
+	@Override
+	public void init(ProcessorManager manager) {
+		super.init(manager);
+		// setup filter
+		if (getAttributes().isRegexFilter()){
+			filter_pattern = Pattern.compile(getAttributes().getInformationFilter());
+			filter_by_stimuli = ped -> ped.getKnowledgeBase().knows_about(filter_pattern);
+		} else {
+			filter_by_stimuli = ped -> ped.getKnowledgeBase().knows_about(getAttributes().getInformationFilter());
+		}
+	}
+
+	@Override
+	protected void doUpdate(SimulationState state) {
+		Collection<Pedestrian> peds = state.getTopography().getElements(Pedestrian.class);
+
+		reset_count();
+
+		// compute count
+		for(Pedestrian ped : peds) {
+			// update knowledgeBase
+			ped.getKnowledgeBase().update_obsolete(state.getSimTimeInSec());
+			// filter by knowledge of pedestrian
+			if (filter_by_stimuli.test(ped)) {
+				doUpdateOnPed(ped);
+			}
+		}
+
+		write_count(state);
+	}
+
+	@Override
+	public AttributesMeshPedStimulusCountingProcessor getAttributes() {
+		if(super.getAttributes() == null) {
+			setAttributes(new AttributesMeshPedStimulusCountingProcessor());
+		}
+		return (AttributesMeshPedStimulusCountingProcessor)super.getAttributes();
+	}
+}

VadereState/src/org/vadere/state/attributes/processor/AttributesMeshPedStimulusCountingProcessor.java

+package org.vadere.state.attributes.processor;
+
+import java.util.ArrayList;
+
+public class AttributesMeshPedStimulusCountingProcessor extends AttributesMeshDensityCountingProcessor {
+
+	private String informationFilter = "";
+	private boolean isRegexFilter = false;
+
+	public String getInformationFilter() {
+		return informationFilter;
+	}
+
+	public void setInformationFilter(String informationFilter) {
+		checkSealed();
+		this.informationFilter = informationFilter;
+	}
+
+	public boolean isRegexFilter() {
+		return isRegexFilter;
+	}
+
+	public void setRegexFilter(boolean regexFilter) {
+		checkSealed();
+		isRegexFilter = regexFilter;
+	}
+}

VadereState/src/org/vadere/state/psychology/KnowledgeBase.java

+package org.vadere.state.psychology;
+
+import org.vadere.state.psychology.perception.types.InformationStimulus;
+import org.vadere.state.psychology.perception.types.Stimulus;
+
+import java.util.ArrayList;
+import java.util.regex.Pattern;
+
+public class KnowledgeBase {
+
+	private ArrayList<InformationStimulus> knowledge;
+
+	public KnowledgeBase() {
+		this.knowledge = new ArrayList<>();
+	}
+
+	/**
+	 * remove Information no longer usable at given time.
+	 */
+	public void update_obsolete(double current_time){
+		knowledge.removeIf(i-> i.getObsolete_at() > 0 && current_time > i.getObsolete_at());
+	}
+
+	/**
+	 *  True if KnowledgeBase contains this information.
+	 */
+	public boolean knows_about(String information){
+		return knowledge.stream().anyMatch(i->i.getInformation().equals(information));
+	}
+	public boolean knows_about(Pattern information){
+		return knowledge.stream().anyMatch(i->information.matcher(i.getInformation()).matches());
+	}
+
+
+	public boolean knows_about(String information, Class<? extends Stimulus> clz){
+		return knowledge.stream().anyMatch(i->i.getInformation().equals(information));
+	}
+
+	public void add_information(InformationStimulus info){
+		knowledge.add(info);
+	}
+
+	public void remove_information(String info){
+		knowledge.removeIf(i->i.getInformation().equals(info));
+	}
+
+
+}

VadereState/src/org/vadere/state/psychology/PsychologyStatus.java

@@ -12,17 +12,19 @@ public class PsychologyStatus {
     private ThreatMemory threatMemory;
     private SelfCategory selfCategory;
     private GroupMembership groupMembership;
+    private KnowledgeBase knowledgeBase;
 
     // Constructors
     public PsychologyStatus() {
-        this(null, new ThreatMemory(), SelfCategory.TARGET_ORIENTED, GroupMembership.OUT_GROUP);
+        this(null, new ThreatMemory(), SelfCategory.TARGET_ORIENTED, GroupMembership.OUT_GROUP, new KnowledgeBase());
     }
 
-    public PsychologyStatus(Stimulus mostImportantStimulus, ThreatMemory threatMemory, SelfCategory selfCategory, GroupMembership groupMembership) {
+    public PsychologyStatus(Stimulus mostImportantStimulus, ThreatMemory threatMemory, SelfCategory selfCategory, GroupMembership groupMembership, KnowledgeBase knowledgeBase) {
         this.mostImportantStimulus = mostImportantStimulus;
         this.threatMemory = threatMemory;
         this.selfCategory = selfCategory;
         this.groupMembership = groupMembership;
+        this.knowledgeBase = knowledgeBase;
     }
 
     public PsychologyStatus(PsychologyStatus other) {
@@ -30,6 +32,7 @@ public class PsychologyStatus {
         this.threatMemory = other.getThreatMemory() != null ? other.getThreatMemory().clone() : null;
         this.selfCategory = other.getSelfCategory();
         this.groupMembership = other.getGroupMembership();
+        this.knowledgeBase = other.getKnowledgeBase();
     }
 
     // Getter
@@ -37,6 +40,7 @@ public class PsychologyStatus {
     public ThreatMemory getThreatMemory() { return threatMemory; }
     public SelfCategory getSelfCategory() { return selfCategory; }
     public GroupMembership getGroupMembership() { return groupMembership; }
+    public KnowledgeBase getKnowledgeBase() { return knowledgeBase; }
 
     // Setter
     public void setMostImportantStimulus(Stimulus mostImportantStimulus) {

VadereState/src/org/vadere/state/psychology/perception/types/InformationStimulus.java

+package org.vadere.state.psychology.perception.types;
+
+/**
+ * Class encodes some kind of information a pedestrian knows about.
+ * The information is active from the time gien in {@link #time} and will be
+ * forgotten at {@link #obsolete_at} (or never if {@link #obsolete_at} == -1
+ */
+public class InformationStimulus extends Stimulus {
+
+	private String information;
+	private double obsolete_at;
+
+	public InformationStimulus(String information) {
+		super(0.0);
+		this.information = information;
+		this.obsolete_at = -1; // never
+	}
+
+	public InformationStimulus(double time, double obsolete_at, String information) {
+		super(time);
+		this.information = information;
+		this.obsolete_at = obsolete_at;
+	}
+
+	public InformationStimulus(InformationStimulus other) {
+		super(other.time);
+		this.information = other.information;
+		this.obsolete_at  = other.obsolete_at;
+	}
+
+	public String getInformation() {
+		return information;
+	}
+
+
+	public double getObsolete_at() {
+		return obsolete_at;
+	}
+
+
+	@Override
+	public Stimulus clone() {
+		return new InformationStimulus(this);
+	}
+}

VadereState/src/org/vadere/state/psychology/perception/types/Stimulus.java

@@ -35,7 +35,8 @@ import java.util.List;
         @Type(value = ElapsedTime.class, name = "ElapsedTime"),
         @Type(value = Wait.class, name = "Wait"),
         @Type(value = WaitInArea.class, name = "WaitInArea"),
-        @Type(value = ChangeTarget.class, name = "ChangeTarget")
+        @Type(value = ChangeTarget.class, name = "ChangeTarget"),
+        @Type(value = InformationStimulus.class, name = "InformationAvailable")
 })
 // "time" is set when the stimulus is injected into the simulation run and must not be de-/serialized.
 @JsonIgnoreProperties({ "time" })

VadereState/src/org/vadere/state/scenario/Pedestrian.java

 package org.vadere.state.scenario;
 
 import org.vadere.state.attributes.scenario.AttributesAgent;
+import org.vadere.state.psychology.KnowledgeBase;
 import org.vadere.state.psychology.PsychologyStatus;
 import org.vadere.state.psychology.cognition.GroupMembership;
 import org.vadere.state.psychology.cognition.SelfCategory;
@@ -66,7 +67,7 @@ public class Pedestrian extends Agent {
 		idAsTarget = -1;
 		isChild = false;
 		isLikelyInjured = false;
-		psychologyStatus = new PsychologyStatus(null, new ThreatMemory(), SelfCategory.TARGET_ORIENTED, GroupMembership.OUT_GROUP);
+		psychologyStatus = new PsychologyStatus(null, new ThreatMemory(), SelfCategory.TARGET_ORIENTED, GroupMembership.OUT_GROUP, new KnowledgeBase());
 		groupIds = new LinkedList<>();
 		groupSizes = new LinkedList<>();
 		modelPedestrianMap = new HashMap<>();
@@ -110,6 +111,7 @@ public class Pedestrian extends Agent {
 	public ThreatMemory getThreatMemory() { return psychologyStatus.getThreatMemory(); }
 	public SelfCategory getSelfCategory() { return psychologyStatus.getSelfCategory(); }
 	public GroupMembership getGroupMembership() { return psychologyStatus.getGroupMembership(); }
+	public KnowledgeBase getKnowledgeBase() {return psychologyStatus.getKnowledgeBase(); }
 	public LinkedList<Integer> getGroupIds() { return groupIds; }
 	public LinkedList<Integer> getGroupSizes() {
 		return groupSizes;