private void OnDestroy()
{
_trackable = null;
_buildingObject = null;
_floorContainer = null;
//GC.Collect();
}
private List <TrackableObject> GenerateTestObjects(int objectCount)
{
List <TrackableObject> trackedItems = new List <TrackableObject>();
for (int n = 0; n < objectCount; n++)
{
var item = new TrackableObject()
{
Id = Guid.NewGuid(),
Name = $"Test Name {n}"
};
item.Children.Add(new TrackableSubObject()
{
Id = Guid.NewGuid(), Name = "Child 1", Description = $"Child 1 of Parent {n}"
});
item.Children.Add(new TrackableSubObject()
{
Id = Guid.NewGuid(), Name = "Child 2", Description = $"Child 2 of Parent {n}"
});
trackedItems.Add(item);
}
return(trackedItems);
}
//checks whether object fullfils current ending conditions
public void checkObjectCondition(TrackableObject obj)
{
if (m_CurrentWorkingStepNumber < m_LoadedWorkflow.WorkingSteps.Count)
{
string endConditionObjectName = m_LoadedWorkflow.WorkingSteps.ElementAt(m_CurrentWorkingStepNumber).EndConditionObjectName;
if (m_LoadedWorkflow.WorkingSteps.ElementAt(m_CurrentWorkingStepNumber).Mode == AllEnums.PBD_Mode.OBJECT_RECOGNIZED)
{
long now = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
if (m_ObjectwasFoundOnce)
{
if (now - m_UsedObjectLastSeenTimestamp > 3000) // < 3seconds
{
// object was used correctly and is back again
NextWorkingStep(AllEnums.WorkingStepEndConditionTrigger.TRACKABLE_OBJECT);
WorkingstepChanged();
m_ObjectwasFoundOnce = false;
}
}
if (obj.Name == endConditionObjectName)
{
m_UsedObjectLastSeenTimestamp = now;
m_ObjectwasFoundOnce = true;
}
}
else if (obj.Name == endConditionObjectName)
{
NextWorkingStep(AllEnums.WorkingStepEndConditionTrigger.TRACKABLE_OBJECT);
WorkingstepChanged();
}
}
}
public void OnObjectRecognized(TrackableObject obj)
{
if (m_LoadedWorkflow != null)
{
ObjectRecognized(obj);
}
}
public void SaveAndAddObjectToDatabase(Image <Bgra, byte> tempCropImg)
{
// check if object dir exists
if (!Directory.Exists(ProjectConstants.OBJECT_DIR))
{
// if not create it
Directory.CreateDirectory(ProjectConstants.OBJECT_DIR);
}
// save the scanned image using milliseconds as a uid
long millis = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
string imagePath = ProjectConstants.OBJECT_DIR + "\\" + millis + ".jpg";
tempCropImg.Save(imagePath);
TrackableObject obj = new TrackableObject();
obj.Image = imagePath;
obj.ImageFullPath = System.IO.Path.GetFullPath(imagePath);
obj.Name = "Erkanntes Objekt";
obj.Category = "Group 1"; // improve with pbd
DatabaseManager.Instance.insertTrackableObject(obj);
DatabaseManager.Instance.listTrackableObject(); // refresh
BackendControl.Instance.refreshGUI();
}
public void runPBDObjectThereCheck()
{
if (m_LastSeenObject != null)
{
long now = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
foreach (TrackableObject obj in DatabaseManager.Instance.Objects)
{
if (obj.Id == m_LastSeenObject.Id)
{
// was the object seen in the last ten seconds?
if (now - obj.LastSeenTimeStamp < 10000)
{
// it was seen - all good
m_LastSeenObject = obj;
PBDManager.Instance.disablePBDBlockAgain();
}
else
{
// it was not seen - trigger PBD stuff
PBDManager.Instance.OnObjectWasTakenTrigger(obj);
}
break;
}
}
}
}
public TargetTrackRequest(string _requestedType, TrackableObject _requestingObject, float _requestRadius, Action <TrackableObject, bool> _callback)
{
requestedType = _requestedType;
requestingObject = _requestingObject;
requestRadius = _requestRadius;
callback = _callback;
}
public void OnObjectWasTakenTrigger(TrackableObject obj)
{
ObjectDetectionZone myZone = null;
// find the zone that the object was last seen
foreach (ObjectDetectionZone zone in ObjectDetectionManager.Instance.CurrentLayout.ObjectDetectionZones)
{
if (zone.Id == obj.LastSeenZoneId)
{
// found the zone
myZone = zone;
}
}
// check if rec is running
if (StateManager.Instance.State == AllEnums.State.RECORD && !m_BlockUntilObjectIsBackAgain)
{
// create a scene for displaying the picking of the object
Scene.Scene autoScene = new Scene.Scene();
Scene.SceneRect rect = ObjectDetectionManager.Instance.createSceneRectForObjectDetectionZone(myZone, true);
autoScene.Add(rect);
AdaptiveScene adaptiveScene = new AdaptiveScene(autoScene, AdaptivityLevel.AdaptivityLevels.FirstOrDefault());
EditWorkflowManager.Instance.createStep(AllEnums.PBD_Mode.OBJECT_RECOGNIZED, adaptiveScene, "Benutze Objekt-" + obj.Name, obj.Name);
m_BlockUntilObjectIsBackAgain = true;
}
}
// Use this for initialization
void Start()
{
mrs = GetComponentsInChildren <MeshRenderer>();
headMat = mrs[0].material;
bodyMat = mrs[1].material;
regColor = headMat.color;
actorScript = GetComponent <TestCustomActor>();
leftTrackable = playerLeftHand.GetComponent <TrackableObject>();
rightTrackable = playerRightHand.GetComponent <TrackableObject>();
leftBlade = playerLeftHand.GetComponentInChildren <EnergyBlade>();
rightBlade = playerRightHand.GetComponentInChildren <EnergyBlade>();
leftHandLabel = "L" + playerIndex;
rightHandLabel = "R" + playerIndex;
SyncVarsWithActorScript();
//VRHead = GameObject.FindGameObjectWithTag("MainCamera");
/*
* if (isBuildPlayer) {
* mrs[0].enabled = false;
* }
*/
}
public void MergeTrackingEnumerableTest()
{
Guid[] ids = new Guid[] { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() };
List <TrackableObject> contextList = new List <TrackableObject>()
{
new TrackableObject()
{
Id = ids[0], TextValue = "Modify 1"
},
new TrackableObject()
{
Id = ids[1], TextValue = "Modify 2"
},
new TrackableObject()
{
Id = ids[2], TextValue = "Delete 102"
}
};
contextList.StartTracking();
Assert.IsFalse(contextList.HasChanges());
TrackableObject contextAdd = new TrackableObject()
{
Id = ids[3], TextValue = "Add 101"
};
contextList.Add(contextAdd);
contextAdd.New();
Assert.IsTrue(contextList.HasChanges());
contextList.First(item => item.Id == ids[2]).Delete();
List <TrackableObject> merge = new List <TrackableObject>()
{
new TrackableObject()
{
Id = ids[0], TextValue = "Modify 1"
},
new TrackableObject()
{
Id = ids[1], TextValue = "Modify 2"
},
new TrackableObject()
{
Id = ids[2], TextValue = "Delete 102"
}
};
merge.MergeTracking(contextList);
Assert.IsTrue(merge.HasChanges());
Assert.AreEqual(4, merge.Count);
Assert.IsTrue(merge.First(item => item.Id == ids[3]).IsNew());
Assert.IsTrue(merge.First(item => item.Id == ids[2]).IsDeleted());
}
private void RemoveObjectFromCanvas(TrackableObject obj)
{
if (trackableObjects.TryGetValue(obj.Id, out var color))
{
var e = (UIElement)LogicalTreeHelper.FindLogicalNode(MainCanvas, "e" + obj.Id.ToString());
MainCanvas.Children.Remove(e);
e = null;
}
}
internal PropertyChangedRecord(ViewModel.ViewModelController controller, TrackableObject trackableObject, string propertyName, string v) : base(ActionTypes.ChangeProperty, controller, trackableObject)
{
ObjectType = trackableObject.GetType().ToString();
PropertyName = propertyName;
Value = v;
#if DEBUGUNDOREDO
Debug.WriteLine($@">>> PropertyChangedRecord.PropertyChangedRecord: Created {UnitDescription} record, Id: {Id}, PropertyName: {PropertyName}, Value: {v}");
#endif
}
public void HookOnTrackingChanged()
{
_trackable = FindObjectOfType <TrackableObject>();
if (_trackable)
{
_trackable.OnTrackingChanged += _trackable_OnTrackingChanged;
_turbine = _trackable.GetComponentInChildren <AnimationController>(true);
}
}
private void initContent(TrackableObject obj)
{
content = obj;
textBoxName.Text = obj.Name;
textBoxGroup.Text = obj.Category;
labelIdText.Content = obj.Id;
imageCarrier.Source = new BitmapImage(new Uri(obj.ImageFullPath));
}
/// <summary>
/// Delete object callback
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
///
///
private void Menuitem_Delete_Click(object sender, RoutedEventArgs e)
{
if (m_ObjectsListView.SelectedIndex != -1)
{
TrackableObject obj = (TrackableObject)m_ObjectsListView.SelectedItem;
DatabaseManager.Instance.deleteTrackableObject(obj);
DatabaseManager.Instance.listTrackableObject(); // refresh
m_ObjectsListView.Items.Refresh();
}
}
private void AddObjectToCanvas(TrackableObject c, TextBlock t)
{
if (float.IsNaN(c.Location.X) || float.IsNaN(c.Location.Y))
{
return;
}
MainCanvas.Children.Add(t);
Canvas.SetLeft(t, c.Location.X * 100 + 500);
Canvas.SetTop(t, c.Location.Y * 100 + 500);
}
public void OnTargetFound(TrackableObject _target, bool _success)
{
if (_success == true)
{
agent.currentTarget = _target.trackedObject;
}
else
{
agent.currentTarget = null;
}
}
private void DrawObject(TrackableObject obj, Color color)
{
Dispatcher.Invoke(() =>
{
var textBlock = CreateObjectUI(color, obj.Id.ToString());
RemoveObjectFromCanvas(obj);
AddObjectToCanvas(obj, textBlock);
});
}
public void OnFoodFound(TrackableObject _target, bool _success)
{
if (_success == true)
{
agent.foodTarget = _target;
}
else
{
agent.foodTarget = null;
}
}
private void UDTEventHandler_OnTargetBuilt(object sender, TargetBuiltEventArgs args)
{
if (_trackable)
{
_trackable.OnTrackingChanged -= Trackable_OnTrackingChanged;
}
_trackable = args.TrackableObject;
_trackable.OnTrackingChanged += Trackable_OnTrackingChanged;
_buildingObject = _trackable.GetComponentInChildren <BuildingObject>(true);
_floorContainer = _buildingObject.GetComponentInChildren <FloorContainer>(true);
HouseViewModel.Instance.MaxFloor = _floorContainer.Floors.Count - 1;
}
private void ObjectsListView_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
// check if an object is selected
if (m_ObjectsListView.SelectedItems.Count == 1)
{
foreach (var item in m_ObjectsListView.SelectedItems)
{
TrackableObject obj = item as TrackableObject;
ObjectDetectionManager.Instance.DisplayObjectEditDialog(obj);
}
}
}
public bool ObjectAlteredCallback(TrackableObject obj)
{
bool ret = false;
ret = Database.DatabaseManager.Instance.updateTrackableObject(obj);
if (ret)
{
Database.DatabaseManager.Instance.listTrackableObject(); // refresh
BackendControl.Instance.refreshGUI();
}
return(ret);
}
private void RadarEventReceived(object sender, TrackableObject e)
{
if (e != null)
{
Color color;
if (!trackableObjects.TryGetValue(e.Id, out color))
{
color = Color.FromRgb((byte)rand.Next(0, 256), (byte)rand.Next(0, 256), (byte)rand.Next(0, 256));
trackableObjects.Add(e.Id, color);
}
DrawObject(e, color);
}
}
/// <summary>
/// deletes the given object from the database
/// </summary>
/// <param name="obj">object to delete</param>
///
///
public void deleteTrackableObject(TrackableObject obj)
{
try
{
using (ITransaction transaction = sess.BeginTransaction())
{
sess.Delete(obj);
transaction.Commit();
}
}
catch (Exception e)
{
Logger.Instance.Log(e.Message, Logger.LoggerState.ERROR);
}
}
public void PrintTrackingTest()
{
int changesDetected = 0;
TrackableObject context = new TrackableObject();
context.StartTracking();
context.WhenChanged(() => changesDetected++);
context.Print();
Assert.IsFalse(context.HasChanges()); //We dont expect print to show up as having changes.
Assert.IsTrue(context.IsPrintRequired());
Assert.AreEqual(1, changesDetected);
}
public void InitPBDLogic()
{
long now = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
foreach (TrackableObject obj in DatabaseManager.Instance.Objects)
{
// was the object seen in the last two seconds?
if (now - obj.LastSeenTimeStamp < 2000)
{
// it was seen - save it
m_LastSeenObject = obj;
break;
}
}
}
public void FindFood(FoodTrackRequest _request, Action <FoodTrackResult> callback)
{
for (int i = 0; i < deadObjects.Count; i++)
{
TrackableObject possibleFood = deadObjects[i];
float foodDistance = Vector3.Distance(possibleFood.objectPosition, _request.requestingObject.objectPosition);
if (foodDistance <= _request.requestRadius)
{
callback(new FoodTrackResult(possibleFood, true, _request.callback));
}
else
{
callback(new FoodTrackResult(null, false, _request.callback));
}
}
}
protected static IReadOnlyDictionary <string, TrackablePropertyChangedEventObject> PrintChangedValues(
TrackableObject p)
{
if (p == null)
{
Debug.WriteLine($"Object is NULL");
return(null);
}
var changes = p.ChangedProperties;
foreach (var item in changes)
{
Debug.WriteLine($"{item.Key} :: {item.Value.OldValue} ==> {item.Value.NewValue}");
}
return(changes);
}
public void HasChangedTest()
{
TrackableObject context = new TrackableObject();
context.StartTracking();
Assert.IsFalse(context.HasChanges());
context.IntValue = 2;
Assert.IsTrue(context.HasChanges());
context.StartTracking();
Assert.IsFalse(context.HasChanges());
context.NotMappedValue = "test";
Assert.IsFalse(context.HasChanges());
context.TextValue = "test";
Assert.IsTrue(context.HasChanges());
}
/// <summary>
/// updates the given TrackableObject in the Database
/// </summary>
/// <param name="obj">object to update</param>
///
///
public bool updateTrackableObject(TrackableObject obj)
{
bool ret = true;
try
{
using (ITransaction transaction = sess.BeginTransaction())
{
sess.Update(obj);
transaction.Commit();
}
}
catch (Exception e)
{
ret = false;
Logger.Instance.Log(e.Message, Logger.LoggerState.ERROR);
}
return(ret);
}
public void TestMethodTrackableObj()
{
TrackableObject<Person> trackable = new TrackableObject<Person>(new Person(1, "1`2123"));
trackable.OnDirtyStatusChanged += trackable_OnDirtyStatusChanged;
trackable.Data.Name = "Kirill";
}
