bbiwarg-original/bbiwarg/Recognition/Tracking/TrackedObject.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace bbiwarg.Recognition.Tracking
{
    public enum TrackingState
    {
        Undefined = 0,
        Detected = 1,
        Tracked = 2,
        Lost = 3,
        Deleted = 4
    }

    public abstract class TrackedObject<T> where T : TrackableObject
    {
        private int numFramesDetectedUntilTracked;
        private int numFramesLostUntilDeleted;
        private bool wasTrackedBefore;

        public int ID { get; private set; }
        public List<T> DetectedObjects;
        public T CurrentObject { get { return DetectedObjects[DetectedObjects.Count - 1]; } }
        public List<TrackingState> States;
        public TrackingState CurrentState { get { return States[States.Count - 1]; } }
        public int NumFramesInCurrentState { get; private set; }

        public TrackedObject(int id, T detectedObject, int numFramesDetectedUntilTracked, int numFramesLostUntilDeleted)
        {
            ID = id;
            this.numFramesDetectedUntilTracked = numFramesDetectedUntilTracked;
            this.numFramesLostUntilDeleted = numFramesLostUntilDeleted;
            wasTrackedBefore = false;
            DetectedObjects = new List<T>();
            States = new List<TrackingState>();

            DetectedObjects.Add(detectedObject);
            States.Add(TrackingState.Detected);
            NumFramesInCurrentState = 1;
        }

        public abstract float calculateSimilarity(T detectedObject);

        public virtual void updateFrame(T detectedObject)
        {
            if (detectedObject != null)
                detectedObject.setTracked(ID);

            TrackingState previousState = CurrentState;
            TrackingState newState = getNewState(detectedObject);

            if (!wasTrackedBefore && newState == TrackingState.Tracked)
                wasTrackedBefore = true;

            DetectedObjects.Add(detectedObject);
            States.Add(newState);

            if (previousState == newState)
                NumFramesInCurrentState++;
            else
                NumFramesInCurrentState = 1;
          }

        private TrackingState getNewState(T detectedObject)
        {
            TrackingState previousState = CurrentState;
            TrackingState newState = TrackingState.Undefined;

            if (detectedObject != null)
            {
                switch (previousState)
                {
                    case TrackingState.Lost:
                        if (wasTrackedBefore)
                            newState = TrackingState.Tracked;
                        else
                            newState = TrackingState.Detected;
                        break;
                    case TrackingState.Tracked:
                        newState = TrackingState.Tracked;
                        break;
                    case TrackingState.Detected:
                        if (NumFramesInCurrentState >= numFramesDetectedUntilTracked)
                            newState = TrackingState.Tracked;
                        else
                            newState = TrackingState.Detected;
                        break;
                }
            }
            else if (previousState == TrackingState.Lost && NumFramesInCurrentState >= numFramesLostUntilDeleted)
                newState = TrackingState.Deleted;
            else
                newState = TrackingState.Lost;

            return newState;
        }
    }
}