//detection
public static DetectedAttributeValue Detection(LocationValue sensingLocation,
LocationValue emittingLocation,
DataValue emittingObjectAttribute,
List<ConeValue> sensingCones,
Dictionary<string, double> emitters,
List<SimulationObjectProxy> obstructions,
ref Random random)
{
DetectedAttributeValue returnDAV = new DetectedAttributeValue();
Vec3D sensingPoint = new Vec3D(sensingLocation);
Vec3D emittingPoint = new Vec3D(emittingLocation);
Vec3D sensingDirection = new Vec3D(sensingPoint); //can't set to blank, just ignore.
double coneAngle = 0.0;
double angleBetweenSensorAndEmitter = 0.0;
foreach(ConeValue cone in sensingCones)
{
sensingDirection.Set(cone.direction);
Vec3D closestPoint = FindClosestPoint(sensingPoint, sensingDirection, emittingPoint);
if (cone.extent > sensingPoint.ScalerDistanceTo(closestPoint))
{//p* is within the cone's extent.
//determine if emitting point is within the spread of the cone.
coneAngle = cone.spread * Math.PI / 180;// System.Math.Atan(emittingPoint.ScalerDistanceTo(closestPoint) / sensingPoint.ScalerDistanceTo(closestPoint));//should be cone.spread
angleBetweenSensorAndEmitter = System.Math.Atan(emittingPoint.ScalerDistanceTo(closestPoint) / sensingPoint.ScalerDistanceTo(closestPoint));
if (coneAngle < angleBetweenSensorAndEmitter)
{
continue; //should go to next cone.
}
if (emitters.ContainsKey(cone.level))
{//emitter has an emission at the same level as the cone.
//returnDAV = (DetectedAttributeValue)ObfuscateAttributeValue(emittingObjectAttribute, emitters[cone.level], ref random);
returnDAV = (DetectedAttributeValue)FuzzAttributeValue(emittingObjectAttribute, emitters[cone.level], ref random);
return returnDAV;
}
else
{ //emitter does not emit the same level as the cone.
//should this find next best, or just move on?
}
}
}
return null;
}
public void SetDataValue(DataValue dv)
{
lock (blackboard.blackboardLock)
{
if (publish)
{
blackboard[objectID][attributeName] = dv;
ObjectLog.Write(blackboard.simTime, objectID, attributeName, DataValueFactory.XMLSerialize(dv));
}
else
{
throw new Exception("Error: Simulator tried to modify attribute it doesn't own.");
}
}
}
/// <summary>
/// Sends a ForceUpdateObjectAttribute event to the Simulation. These events update a specific object's attribute.
/// This event contains an object ID, an attribute name, and an attribute value. The attribute value can be any
/// data type in the system
/// </summary>
/// <param name="objectID">The object's ID</param>
/// <param name="updatedAttributeName">An object's Attribute name</param>
/// <param name="updatedAttributeValue">An object's updated Attribute value</param>
public void SendObjectAttributeUpdateEvent(String objectID, String updatedAttributeName, DataValue updatedAttributeValue)
{
SimulationEvent e = SimulationEventFactory.BuildEvent(ref m_simModel, "ForceUpdateObjectAttribute");
((StringValue)e["ObjectID"]).value = objectID;
((StringValue)e["AttributeName"]).value = updatedAttributeName;
((WrapperValue)e["AttributeValue"]).value = updatedAttributeValue; //the WrapperValue contains any single DataValue class
((StringValue)e["UpdateType"]).value = "AGENT";
SendSimEvent(e);
}
/* *************************************************************** */
private static DataValue FuzzAttributeValue(DataValue dv, double confidence, ref Random random)
{ //maybe pass level as well, have a sim model def of how each model affects clarity?
DetectedAttributeValue returnValue = new DetectedAttributeValue();
((DetectedAttributeValue)returnValue).value = dv;
((DetectedAttributeValue)returnValue).stdDev = confidence;
//check data type
string attributeType = dv.dataType;
//switch statement
switch (attributeType)
{
case "LocationType":
FuzzLocationValue(ref returnValue, ref random);
break;
case "VelocityType":
FuzzVelocityValue(ref returnValue, ref random);
break;
case "IntegerType":
FuzzIntegerValue(ref returnValue, ref random);
break;
case "DoubleType":
FuzzDoubleValue(ref returnValue, ref random);
break;
case "StringType":
FuzzStringValue(ref returnValue, ref random);
break;
default:
break;
}
return returnValue as DataValue;
}
/// <summary>
/// Takes a DataValue, and returns a human-readable string representation.
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
public static string ToString(DataValue v)
{
if (v == null)
{
return "";
}
switch (v.dataType)
{
case "StringType":
return ((StringValue)v).ToString();
case "DoubleType":
return ((DoubleValue)v).ToString();
case "IntegerType":
return ((IntegerValue)v).ToString();
case "BooleanType":
return ((BooleanValue)v).ToString();
case "LocationType":
return ((LocationValue)v).ToString();
case "VelocityType":
return ((VelocityValue)v).ToString();
case "AttributeCollectionType":
return ((AttributeCollectionValue)v).ToString();
case "CustomAttributesType":
return ((CustomAttributesValue)v).ToString();
case "StringListType":
return ((StringListValue)v).ToString();
case "PolygonType":
return ((PolygonValue)v).ToString();
case "StateTableType":
return ((StateTableValue)v).ToString();
case "CapabilityType":
return ((CapabilityValue)v).ToString();
case "VulnerabilityType":
return ((VulnerabilityValue)v).ToString();
case "ConeType":
return ((ConeValue)v).ToString();
case "SensorType":
return ((SensorValue)v).ToString();
case "SensorArrayType":
return ((SensorArrayValue)v).ToString();
case "EmitterType":
return ((EmitterValue)v).ToString();
case "RangeRingDisplayType":
return ((RangeRingDisplayValue)v).ToString();
case "AttackCollectionType":
return ((AttackCollectionValue)v).ToString();
case "WrapperType":
return ((WrapperValue)v).ToString();
case "ClassificationDisplayRulesType":
return ((ClassificationDisplayRulesValue)v).ToString();
default:
return "";
}
}
/// <summary>
/// This method takes in two data values, and returns true if their values are equal.
/// </summary>
/// <param name="firstDV"></param>
/// <param name="secondDV"></param>
/// <returns></returns>
public static bool CompareDataValues(DataValue firstDV, DataValue secondDV)
{
if (firstDV.getType() != secondDV.getType())
{
return false;
}
switch (firstDV.getType())
{
case "StringType":
if (((StringValue)firstDV).value == ((StringValue)secondDV).value)
{
return true;
}
break;
case "IntegerType":
if (((IntegerValue)firstDV).value == ((IntegerValue)secondDV).value)
{
return true;
}
break;
case "DoubleType":
if (((DoubleValue)firstDV).value == ((DoubleValue)secondDV).value)
{
return true;
}
break;
case "BooleanType":
if (((BooleanValue)firstDV).value == ((BooleanValue)secondDV).value)
{
return true;
}
break;
case "LocationType":
if (Math.Abs(((LocationValue)firstDV).X - ((LocationValue)secondDV).X) < 0.000001 &&
Math.Abs(((LocationValue)firstDV).Y - ((LocationValue)secondDV).Y) < 0.000001 &&
Math.Abs(((LocationValue)firstDV).Z - ((LocationValue)secondDV).Z) < 0.000001)
//if (((LocationValue)firstDV).X == ((LocationValue)secondDV).X &&
// ((LocationValue)firstDV).Y == ((LocationValue)secondDV).Y &&
// ((LocationValue)firstDV).Z == ((LocationValue)secondDV).Z)
{
return true;
}
break;
case "VelocityType":
if (Math.Abs(((VelocityValue)firstDV).VX - ((VelocityValue)secondDV).VX) < 0.000001 &&
Math.Abs(((VelocityValue)firstDV).VY - ((VelocityValue)secondDV).VY) < 0.000001 &&
Math.Abs(((VelocityValue)firstDV).VZ - ((VelocityValue)secondDV).VZ) < 0.000001)
//if (((VelocityValue)firstDV).VX == ((VelocityValue)secondDV).VX &&
// ((VelocityValue)firstDV).VY == ((VelocityValue)secondDV).VY &&
// ((VelocityValue)firstDV).VZ == ((VelocityValue)secondDV).VZ)
{
return true;
}
break;
case "AttributeCollectionType":
if (((AttributeCollectionValue)firstDV).ToString() == ((AttributeCollectionValue)secondDV).ToString())
{
return true;
}
break;
case "CustomAttributesType":
if (((CustomAttributesValue)firstDV).ToString() == ((CustomAttributesValue)secondDV).ToString())
{
return true;
}
break;
case "CapabilityType":
if (((CapabilityValue)firstDV).ToString() == ((CapabilityValue)secondDV).ToString())
{
return true;
}
break;
case "ConeType":
if (((ConeValue)firstDV).ToString() == ((ConeValue)secondDV).ToString())
{
return true;
}
break;
case "DetectedAttributeType":
if (CompareDataValues(((DetectedAttributeValue)firstDV).value, ((DetectedAttributeValue)secondDV).value))
{
return true;
}
break;
case "EmitterType":
if (((EmitterValue)firstDV).ToString() == ((EmitterValue)secondDV).ToString())
{
return true;
}
break;
case "PolygonType":
if (((PolygonValue)firstDV).ToString() == ((PolygonValue)secondDV).ToString())
{
return true;
}
break;
case "SensorArrayType":
if (((SensorArrayValue)firstDV).ToString() == ((SensorArrayValue)secondDV).ToString())
{
return true;
}
break;
case "SensorType":
if (((SensorValue)firstDV).ToString() == ((SensorValue)secondDV).ToString())
{
return true;
}
break;
case "StateTableType":
if (((StateTableValue)firstDV).ToString() == ((StateTableValue)secondDV).ToString())
{
return true;
}
break;
case "StringListType":
if (((StringListValue)firstDV).ToString() == ((StringListValue)secondDV).ToString())
{
return true;
}
break;
case "VulnerabilityType":
if (((VulnerabilityValue)firstDV).ToString() == ((VulnerabilityValue)secondDV).ToString())
{
return true;
}
break;
case "RangeRingDisplayType":
if (((RangeRingDisplayValue)firstDV).ToString() == ((RangeRingDisplayValue)secondDV).ToString())
{
return true;
}
break;
case "AttackCollectionType":
if (((AttackCollectionValue)firstDV).ToString() == ((AttackCollectionValue)secondDV).ToString())
{
return true;
}
break;
case "WrapperType":
DataValue firstNestedDV = ((WrapperValue)firstDV).value;
DataValue secondNestedDV = ((WrapperValue)firstDV).value;
return CompareDataValues(firstNestedDV, secondNestedDV);
break;
case "ClassificationDisplayRulesType":
if (((ClassificationDisplayRulesValue)firstDV).ToString() == ((ClassificationDisplayRulesValue)secondDV).ToString())
{
return true;
}
break;
default:
throw new Exception("There is no definition for this data type");
break;
}
return false;
}
/// <summary>
/// A helper method for building and populating a WrapperValue object.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static DataValue BuildWrapper(DataValue value)
{
DataValue dv = BuildValue("WrapperType");
((WrapperValue)dv).value = DataValueFactory.BuildFromDataValue(value);
return dv;
}
/// <summary>
/// A Helper method for building and populating a DetectedValue object
/// </summary>
/// <exclude/>
/// <param name="dv"></param>
/// <param name="confidence"></param>
/// <returns></returns>
public static DataValue BuildDetectedValue(DataValue dv, int confidence)
{
DataValue dav = new DetectedAttributeValue() as DataValue;
((DetectedAttributeValue)dav).value = dv;
((DetectedAttributeValue)dav).stdDev = confidence;
return dav;
}
new public void FromXML(string xml)
{
Match m = regex.Match(xml);
if (m.Success)
{
Group g = m.Groups[1];
value = DataValueFactory.XMLDeserialize(g.Value);
}
else
{
throw new Exception(String.Format("Invalid XML string in {0}: {1}",dataType,xml));
}
}
/// <summary>
///
/// </summary>
/// <exclude/>
/// <param name="dv"></param>
/// <returns></returns>
public static DataValue BuildFromDataValue(DataValue dv)
{
DataValue returnDV;
switch (dv.dataType)
{
case "WrapperType":
returnDV = DataValueFactory.BuildWrapper(((WrapperValue)dv).value);
return returnDV;
break;
case "StringType":
returnDV = DataValueFactory.BuildString(((StringValue)dv).value);
return returnDV;
break;
case "IntegerType":
returnDV = DataValueFactory.BuildInteger(((IntegerValue)dv).value);
return returnDV;
break;
case "DoubleType":
returnDV = DataValueFactory.BuildDouble(((DoubleValue)dv).value);
return returnDV;
break;
case "LocationType":
returnDV = DataValueFactory.BuildLocation(((LocationValue)dv).X, ((LocationValue)dv).Y, ((LocationValue)dv).Z, ((LocationValue)dv).exists);
return returnDV;
break;
case "VelocityType":
returnDV = DataValueFactory.BuildVelocity(((VelocityValue)dv).VX, ((VelocityValue)dv).VY, ((VelocityValue)dv).VZ);
return returnDV;
break;
case "StringListType":
returnDV = new StringListValue();
foreach (string s in ((StringListValue)dv).strings)
{
((StringListValue)returnDV).strings.Add(s);
}
return returnDV;
break;
case "RangeRingDisplayType":
returnDV = DataValueFactory.BuildRangeRingDisplayValue(((RangeRingDisplayValue)dv).name, ((RangeRingDisplayValue)dv).type, ((RangeRingDisplayValue)dv).isWeapon, ((RangeRingDisplayValue)dv).rangeIntensities);
return returnDV;
break;
case "AttackCollectionType":
returnDV = new AttackCollectionValue();
String errMsg = String.Empty;
foreach (AttackCollectionValue.AttackValue av in ((AttackCollectionValue)dv).GetCurrentAttacks())
{
AttackCollectionValue.AttackValue newAttack = new AttackCollectionValue.AttackValue(av.attackStartTime, av.attackTimeWindow, av.targetObjectId, av.attackingObjectId, av.capabilityName, av.percentageApplied, av.isSelfdefense);
((AttackCollectionValue)returnDV).AddAttack(newAttack, out errMsg);
}
return returnDV;
break;
default:
returnDV = new DataValue();
returnDV = dv;
return returnDV;
}
return null;
}
public WrapperValue()
{
dataType = "WrapperType";
value = null;
xmlStartTag = String.Format("<{0}>", dataType);
xmlEndTag = String.Format("</{0}>", dataType);
}
public void SetValues(DataValue dv, double conf)
{
value = dv;
stdDev = conf;
}
public DetectedAttributeValue()
{
dataType = "DetectedAttributeType";
value = new DataValue();
stdDev = 0.0;
}
private void RevealObject(SimulationEvent e)
{
AttributeCollectionValue atts = (AttributeCollectionValue)e["Attributes"];
string id = ((StringValue)e["ObjectID"]).value;
SimulationObjectProxy prox = null;
prox = GetObjectProxy(id);
if (prox == null)
return;
//Set State info?
//AD: This is kind of a quick fix. Gabe would have a better idea on a more permanent
//solution.
DataValue stv = new DataValue();
stv = prox["StateTable"].GetDataValue();
Dictionary<string, DataValue> tempDict = ((StateTableValue)stv).states;
tempDict = ((AttributeCollectionValue)tempDict[((StringValue)atts["State"]).value]).attributes;
foreach (KeyValuePair<String, DataValue> kvp in tempDict)
{
if (!atts.attributes.ContainsKey(kvp.Key))
{//if att exists in atts, it should NOT overwrite reveal attributes.
atts.attributes.Add(kvp.Key, kvp.Value);
}
}
////AD
foreach (string attname in atts.attributes.Keys)
{
if (attname == "ID")
{
continue;
}
if (prox.GetKeys().Contains(attname) && prox[attname].IsOwner())
{
prox[attname].SetDataValue(atts[attname]);
if (attname == "Sensors")
{
double maxSensor = -1.0;
SensorArrayValue sav = atts[attname] as SensorArrayValue;
foreach (SensorValue sv in sav.sensors)
{
maxSensor = Math.Max(maxSensor, sv.maxRange);
}
if (maxSensor >= 0)
{
ObjectDistances.UpdateObjectSensorRange(id, maxSensor);
}
}
}
}
Dictionary<string, DataValue> x = new Dictionary<string, DataValue>();
EmitterValue em = (EmitterValue)prox["Emitters"].GetDataValue();
foreach (string attName in em.attIsEngram.Keys)
{
if (em.attIsEngram[attName])
{
if (StateDB.engrams.ContainsKey(attName))
{
x[attName] = DataValueFactory.BuildString(StateDB.engrams[attName].engramValue);
}
}
}
prox["CustomAttributes"].SetDataValue(DataValueFactory.BuildCustomAttributes(x));
}
private DataValue GetNestedDataValue(DataValue dv)
{
if (dv is DetectedAttributeValue)
{
return ((DetectedAttributeValue)dv).value;
}
return dv;
}