private void btnOpenVoice_Click(object sender, EventArgs e)
{
if (null == lbxDecisionMakers.SelectedItem)
{
MessageBox.Show("Please select an owner for the voice channel.");
return;
}
if ((null == lbxVoiceMembers.SelectedItems) || (lbxVoiceMembers.SelectedItems.Count < 2))
{
MessageBox.Show("Please select at least two members for the voice channel.");
return;
}
if ("" == txtOpenVoiceName.Text)
{
MessageBox.Show("Please provide a name for the voice channel.");
return;
}
SimulationEvent openVoice = SimulationEventFactory.BuildEvent(ref simModelInfo, "RequestVoiceChannelCreate");
openVoice["ChannelName"] = DataValueFactory.BuildString(txtOpenVoiceName.Text);
openVoice["SenderDM_ID"] = DataValueFactory.BuildString((string)lbxDecisionMakers.SelectedItem);
StringListValue voiceMembers = new StringListValue();
for (int i = 0; i < lbxVoiceMembers.SelectedItems.Count; i++)
{
voiceMembers.strings.Add((string)lbxVoiceMembers.SelectedItems[i]);
}
openVoice["MembershipList"] = DataValueFactory.BuildFromDataValue(voiceMembers);
EventListener.Network.PutEvent(openVoice);
}
/// <summary>
/// For a given decision maker, get all sensor ranges which they currently have (max range per sensor object)
/// </summary>
/// <param name="dmID"></param>
/// <returns></returns>
public List <SensorRange> GetDecisionMakersSensorRanges(String dmID)
{
List <SensorRange> ranges = new List <SensorRange>();
lock (GroundTruthLock)
{
DMView view = _dddConnection.GetDMView(dmID);
SensorRange range = null;
if (view != null)
{
foreach (String s in view.MyObjects.Keys)
{
if (view.MyObjects[s].Location.exists)
{
double maxRange = 0;
foreach (SensorValue sv in view.MyObjects[s].Sensors.sensors)
{
if (sv.maxRange > maxRange)
{
maxRange = sv.maxRange;
}
}
range = new SensorRange(DataValueFactory.BuildFromDataValue(view.MyObjects[s].Location) as LocationValue, maxRange);
ranges.Add(range);
}
}
}
}
return(ranges);
}
private Dictionary <string, DataValue> CopyFromCustomAttributes(Dictionary <string, DataValue> incoming)
{
Dictionary <string, DataValue> returnDict = new Dictionary <string, DataValue>();
foreach (KeyValuePair <string, DataValue> kvp in incoming)
{
returnDict.Add(kvp.Key, DataValueFactory.BuildFromDataValue(kvp.Value));
}
return(returnDict);
}
/// <summary>
/// This method retrieves all sensable attributes from the target proxy into the referenced attribute collection value.
/// </summary>
/// <param name="ACV">Current collection to add attributes into.</param>
/// <param name="targetProxy">SimulationProxy to retrieve attributes from.</param>
private void SenseAllAttributes(ref AttributeCollectionValue singleObjectACV, SimulationObjectProxy targetProxy)
{
//for the target object, go through each observable attribute, and add to the view with full confidence.
string targetObjectID = ((StringValue)targetProxy["ID"].GetDataValue()).value;
string objectType = targetProxy.GetObjectType();
DetectedAttributeValue dav;
List <string> keys = targetProxy.GetKeys();
foreach (string att in simModel.objectModel.objects[objectType].attributes.Keys)
{
if (simModel.objectModel.objects[objectType].attributes[att].otherObservable)
{
if (keys.Contains(att))
{
dav = new DetectedAttributeValue();
if (att == "CustomAttributes")
{
DataValue t = targetProxy[att].GetDataValue();
if (t.dataType == "CustomAttributesType")
{
Dictionary <string, DataValue> copiedDict = CopyFromCustomAttributes(((CustomAttributesValue)t).attributes);
t = new CustomAttributesValue();
((CustomAttributesValue)t).attributes = copiedDict;
}
dav = new DetectedAttributeValue();
dav.stdDev = 100;
dav.value = DataValueFactory.BuildFromDataValue(t);
//AddAttributeToACV(ref singleAttributeCollection, simModelAtt.Key, detectedAttribute);
}
else
{
dav.value = DataValueFactory.BuildFromDataValue(targetProxy[att].GetDataValue());
dav.stdDev = 100;
}
if (((AttributeCollectionValue)singleObjectACV).attributes.ContainsKey(att))
{
((AttributeCollectionValue)singleObjectACV)[att] = dav;
}
else
{
((AttributeCollectionValue)singleObjectACV).attributes.Add(att, dav);
}
}
}
}
}
/// <summary>
/// For a given decision maker, get all of their object locations
/// </summary>
/// <param name="dmID"></param>
/// <returns></returns>
public List <LocationValue> GetDecisionMakersObjectPositions(String dmID)
{
List <LocationValue> positions = new List <LocationValue>();
lock (GroundTruthLock)
{
DMView view = _dddConnection.GetDMView(dmID);
if (view != null)
{
foreach (String s in view.MyObjects.Keys)
{
if (view.MyObjects[s].Location.exists)
{
positions.Add(DataValueFactory.BuildFromDataValue(view.MyObjects[s].Location) as LocationValue);
}
}
}
}
return(positions);
}
private void ProcessObject(SimulationEvent ev)
{
String id = ((StringValue)ev["ID"]).value;
String objectType = ((StringValue)((AttributeCollectionValue)ev["Attributes"])["ClassName"]).value;
AttributeCollectionValue atts = ev["Attributes"] as AttributeCollectionValue;
SeamateObject seamateObject = null;
if (_unrevealedObjects.ContainsKey(id))
{
}
else
{
_unrevealedObjects.Add(id, new SeamateObject(id));
Console.WriteLine("Added to UnrevealedObjects: " + id);
}
_unrevealedObjects[id].SetAttributes(atts);
if (atts.attributes.ContainsKey("OwnerID"))
{
EstablishOwnership(id, ((StringValue)atts.attributes["OwnerID"]).value);
}
if (ev.parameters.ContainsKey("StateTable") && !_speciesPossibleStates.ContainsKey(objectType))
{
_speciesPossibleStates.Add(objectType, new Dictionary <string, AttributeCollectionValue>());
StateTableValue stv = (StateTableValue)ev["StateTable"];
AttributeCollectionValue stateAttributes = null;
foreach (String stateName in stv.states.Keys)
{
stateAttributes = (AttributeCollectionValue)stv[stateName];
_speciesPossibleStates[objectType].Add(stateName, new AttributeCollectionValue());
foreach (String att in stateAttributes.attributes.Keys)
{
_speciesPossibleStates[objectType][stateName].attributes.Add(att, DataValueFactory.BuildFromDataValue(stateAttributes[att]));
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="allObjectViews"></param>
private void SenseAllObjects(ref Dictionary <string, Dictionary <string, AttributeCollectionValue> > allObjectsViews)
{
SimulationObjectProxy sensingProxy = null;
SimulationObjectProxy targetProxy = null;
Vec3D sensingLocation = null;
Vec3D targetsLocation = null;
LocationValue senLocation = null;
LocationValue tarLocation = null;
double distance = 0.0;
SensorArrayValue sav = null;
DataValue targetsAttribute = null;
string ownerID = null;
string objectType = null;
DetectedAttributeValue detectedAttribute;
AttributeCollectionValue singleAttributeCollection = null;
bool isSensed = false;
// The dictionary is constantly created in this method //
Dictionary <string, AttributeCollectionValue> singleObjectView;
//AD to improve this later:
// for each object in the visible ObjectDistances collection
// for each object after the current index
// check for the index object's view of the nested object
// check for the nested object's view of the index object
//Possible hangup is the "All" emitter.
int x = 0;
//Each object senses each other object
//foreach (string sensorObjectID in listOfObjectIDs)
foreach (KeyValuePair <string, List <string> > networks in networkRosters)
{
if (!activeSensorNetworks[networks.Key])
{
continue;
}
foreach (string sensorObjectID in networkObjects[networks.Key])
{
sensingProxy = objectProxies[sensorObjectID];
objectType = sensingProxy.GetObjectType();
senLocation = sensingProxy["Location"].GetDataValue() as LocationValue;
if (senLocation.exists)
{
ownerID = ((StringValue)sensingProxy["OwnerID"].GetDataValue()).value;
singleObjectView = new Dictionary <string, AttributeCollectionValue>();
x++;
//foreach (string targetObjectID in listOfObjectIDs)
foreach (List <string> objects in networkObjects.Values)
{
if (objects.Contains(sensorObjectID))
{
if (((EmitterValue)sensingProxy["Emitters"].GetDataValue()).emitters.ContainsKey("Invisible"))
//OR if it's the "master" object for a region?? -lisa
{
continue;
}
string target = sensorObjectID;
singleAttributeCollection = new AttributeCollectionValue();
foreach (KeyValuePair <string, AttributeInfo> simModelAtt in simModel.objectModel.objects[objectType].attributes)
{
if (!simModelAtt.Value.ownerObservable == true)
{
continue;
}
//if (!sensingProxy.GetKeys().Contains(simModelAtt.Key))
// continue;
DataValue t = sensingProxy[simModelAtt.Key].GetDataValue();
if (t.dataType == "CustomAttributesType")
{
Dictionary <string, DataValue> copiedDict = CopyFromCustomAttributes(((CustomAttributesValue)t).attributes);
t = new CustomAttributesValue();
((CustomAttributesValue)t).attributes = copiedDict;
}
detectedAttribute = new DetectedAttributeValue();
detectedAttribute.stdDev = 100;
detectedAttribute.value = DataValueFactory.BuildFromDataValue(t);
AddAttributeToACV(ref singleAttributeCollection, simModelAtt.Key, detectedAttribute);
}//end foreach sensable attribute
if (!allObjectsViews.ContainsKey(sensorObjectID))
{
allObjectsViews.Add(sensorObjectID, new Dictionary <string, AttributeCollectionValue>());
}
if (!objectViews.ContainsKey(sensorObjectID))
{
objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
}
//update the global "allObjectViews". The return from UpdateObject is the collection of attributes
//that have changed. These attributes are stored in allObjectsViews and then sent out
//to users.
AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(target, singleAttributeCollection);
//if (changedAttributes != null && selectedRangeRingLevel != RangeRingLevels.DISABLED)
//{
// CalculateRangeRings(ref changedAttributes, ref sensingProxy);
//}
if (changedAttributes != null)
{
allObjectsViews[sensorObjectID].Add(target, changedAttributes);
}
else//this is so there is at least the empty entry for the detected object so
//you still know it is detected.
{
if (!allObjectsViews[sensorObjectID].ContainsKey(target))
{
allObjectsViews[sensorObjectID].Add(target, new AttributeCollectionValue());
}
}
}
else
{
foreach (string targetObjectID in objects)
{//sensing and target objects are not the same
targetProxy = objectProxies[targetObjectID];
tarLocation = targetProxy["Location"].GetDataValue() as LocationValue;
if (tarLocation.exists)
{
EmitterValue emitters = targetProxy["Emitters"].GetDataValue() as EmitterValue;
if (emitters.emitters.ContainsKey("All"))
{
//if an object has an all emitter, retrieve all attributes without sensing algorithm
AttributeCollectionValue atts = new AttributeCollectionValue();
if (singleObjectView.ContainsKey(targetObjectID))
{
atts = singleObjectView[targetObjectID];
}
SenseAllAttributes(ref atts, targetProxy);
singleObjectView[targetObjectID] = atts;
isSensed = true;
if (!allObjectsViews.ContainsKey(sensorObjectID))
{
allObjectsViews.Add(sensorObjectID, new Dictionary <string, AttributeCollectionValue>());
}
if (!objectViews.ContainsKey(sensorObjectID))
{
objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
}
//update the global "allObjectViews". The return from UpdateObject is the collection of attributes
//that have changed. These attributes are stored in allObjectsViews and then sent out
//to users.
AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(targetObjectID, atts);
//if (changedAttributes != null && selectedRangeRingLevel == RangeRingLevels.FULL)
//{//the only way to sense a "target" here is for FULL ring display
// CalculateRangeRings(ref changedAttributes, ref targetProxy);
//}
if (changedAttributes != null)
{
allObjectsViews[sensorObjectID].Add(targetObjectID, changedAttributes);
}
else//this is so there is at least the empty entry for the detected object so
//you still know it is detected.
{
if (!allObjectsViews[sensorObjectID].ContainsKey(targetObjectID))
{
allObjectsViews[sensorObjectID].Add(targetObjectID, new AttributeCollectionValue());
}
}
}
else if (emitters.emitters.ContainsKey("Invisible"))
//or if object is "master" for moving region -lisa
{
continue;
}
else
{//object does not have an all emitter, continue to check each emitter value
AttributeCollectionValue atts = new AttributeCollectionValue();
if (Omniscience)
{
if (singleObjectView.ContainsKey(targetObjectID))
{
atts = singleObjectView[targetObjectID];
}
SenseAllAttributes(ref atts, targetProxy);
singleObjectView[targetObjectID] = atts;
isSensed = true;
if (!allObjectsViews.ContainsKey(sensorObjectID))
{
allObjectsViews.Add(sensorObjectID, new Dictionary <string, AttributeCollectionValue>());
}
if (!objectViews.ContainsKey(sensorObjectID))
{
objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
}
//update the global "allObjectViews". The return from UpdateObject is the collection of attributes
//that have changed. These attributes are stored in allObjectsViews and then sent out
//to users.
AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(targetObjectID, atts);
//if (changedAttributes != null && selectedRangeRingLevel == RangeRingLevels.FULL)
//{//the only way to sense a "target" here is for FULL ring display
// CalculateRangeRings(ref changedAttributes, ref targetProxy);
//}
if (changedAttributes != null)
{
allObjectsViews[sensorObjectID].Add(targetObjectID, changedAttributes);
}
else//this is so there is at least the empty entry for the detected object so
//you still know it is detected.
{
if (!allObjectsViews[sensorObjectID].ContainsKey(targetObjectID))
{
allObjectsViews[sensorObjectID].Add(targetObjectID, new AttributeCollectionValue());
}
}
continue;
}
sensingLocation = new Vec3D(senLocation);
targetsLocation = new Vec3D(tarLocation);
isSensed = false;
distance = sensingLocation.ScalerDistanceTo(targetsLocation);
sav = sensingProxy["Sensors"].GetDataValue() as SensorArrayValue;
foreach (SensorValue sv in sav.sensors)
{
if (distance < sv.maxRange)
{
//Find obstructions
List <SimulationObjectProxy> obstructions = FindObstructions(sensingLocation, targetsLocation);
foreach (KeyValuePair <string, List <ConeValue> > kvp in sv.ranges)
{ //Key is the attribute being sensed, value is a list of cones
if (kvp.Key == "All")
{
atts = new AttributeCollectionValue();
if (singleObjectView.ContainsKey(targetObjectID))
{
atts = singleObjectView[targetObjectID];
}
SenseAllAttributes(ref atts, targetProxy);
singleObjectView[targetObjectID] = atts;
isSensed = true;
}
else //not an All sensor, so run detection algorithm
{//Added in main-line
if (!emitters.emitters.ContainsKey(kvp.Key))
{
continue;
}
//Custom attributes fix:
DataValue currentDataValue;
try
{
currentDataValue = targetProxy[kvp.Key].GetDataValue();
}
catch
{
currentDataValue = targetProxy["CustomAttributes"].GetDataValue();
currentDataValue = ((CustomAttributesValue)currentDataValue)[kvp.Key];
//will throw an error here if object doesn't contain custom atts, or
//if it doesnt contain the specified custom att.
}
bool isObstructed = false;
foreach (SimulationObjectProxy reg in obstructions)
{
foreach (string attributeBlocked in ((StringListValue)reg["BlocksSensorTypes"].GetDataValue()).strings)
{
if (kvp.Key == attributeBlocked)
{
isObstructed = true;
}
}
}
if (isObstructed)
{
detectedAttribute = new DetectedAttributeValue();
detectedAttribute.value = DataValueFactory.BuildValue(currentDataValue.dataType);
detectedAttribute.confidence = 0;
//continue;
}
else
{
targetsAttribute = DataValueFactory.BuildFromDataValue(currentDataValue);
//ev is emitters
Dictionary <string, double> emitterCollection = emitters.emitters[kvp.Key];
detectedAttribute = new DetectedAttributeValue();
detectedAttribute = ObjectMath.Detection(senLocation, tarLocation, targetsAttribute, kvp.Value, emitterCollection, obstructions, ref randomGenerator);
}
if (detectedAttribute != null)
{
singleAttributeCollection = new AttributeCollectionValue();
if (singleObjectView.ContainsKey(targetObjectID))
{
singleAttributeCollection = singleObjectView[targetObjectID];
}
AddAttributeToACV(ref singleAttributeCollection, kvp.Key, detectedAttribute);
isSensed = true;
}
}
}//end foreach attribute in sensor
//if the object has any attributes sensed, fill in some other info for the object's view.
if (isSensed)
{
detectedAttribute = new DetectedAttributeValue();
detectedAttribute.stdDev = 100;
detectedAttribute.value = targetProxy["ID"].GetDataValue();
if (singleAttributeCollection == null)
{
singleAttributeCollection = new AttributeCollectionValue();
}
if (!singleObjectView.ContainsKey(targetObjectID))
{
singleObjectView.Add(targetObjectID, singleAttributeCollection);
}
singleAttributeCollection = singleObjectView[targetObjectID];
AddAttributeToACV(ref singleAttributeCollection, "ID", detectedAttribute);
detectedAttribute = new DetectedAttributeValue();
detectedAttribute.stdDev = 100;
detectedAttribute.value = targetProxy["OwnerID"].GetDataValue();
AddAttributeToACV(ref singleAttributeCollection, "OwnerID", detectedAttribute);
} //end if isSensed.
}
} //end foreach sensor in sensor array
if (singleObjectView.ContainsKey(targetObjectID))
{
AttributeCollectionValue attr = singleObjectView[targetObjectID];
if (!allObjectsViews.ContainsKey(sensorObjectID))
{
allObjectsViews.Add(sensorObjectID, new Dictionary <string, AttributeCollectionValue>());
}
if (!objectViews.ContainsKey(sensorObjectID))
{
objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
}
if (attr.attributes.ContainsKey("CustomAttributes"))
{
DataValue t = ((DetectedAttributeValue)attr["CustomAttributes"]).value;
double conf = ((DetectedAttributeValue)attr["CustomAttributes"]).confidence;
Dictionary <string, DataValue> copiedDict = CopyFromCustomAttributes(((CustomAttributesValue)t).attributes);
t = new CustomAttributesValue();
((CustomAttributesValue)t).attributes = copiedDict;
attr.attributes.Remove("CustomAttributes");
attr.attributes.Add("CustomAttributes", DataValueFactory.BuildDetectedValue(t, Convert.ToInt32(conf)));
}
//update the global "allObjectViews". The return from UpdateObject is the collection of attributes
//that have changed. These attributes are stored in allObjectsViews and then sent out
//to users.
AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(targetObjectID, attr);
//if (changedAttributes != null && selectedRangeRingLevel == RangeRingLevels.FULL)
//{//the only way to sense a "target" here is for FULL ring display
// CalculateRangeRings(ref changedAttributes, ref targetProxy);
//}
if (changedAttributes != null)
{
allObjectsViews[sensorObjectID].Add(targetObjectID, changedAttributes);
}
else//this is so there is at least the empty entry for the detected object so
//you still know it is detected.
{
if (!allObjectsViews[sensorObjectID].ContainsKey(targetObjectID))
{
allObjectsViews[sensorObjectID].Add(targetObjectID, new AttributeCollectionValue());
}
}
}
else
{
if (objectViews.ContainsKey(sensorObjectID))
{
if (objectViews[sensorObjectID].ContainsObject(targetObjectID))
{
objectViews[sensorObjectID].RemoveObject(targetObjectID);
//if you once knew of this object, and now don't, remove it from object's view.
}
}
}
} //end emitter detection
} //end if target is visible
}
}
} //end foreach target object
} //end if sensor is visible
} //end of foreach sensing object
} //end of Foreach sensor network
if (x > 0)
{
//Console.Out.WriteLine("ViewPro: {0} objects were sensing at time {1}.", x, currentTick / 1000);
}
}