Add TrackerMOSSE and MultiTracker

src/OpenCvSharp/Modules/core/Struct/Rect2d.cs

@@ -399,6 +399,15 @@ public Point2d BottomRight
 
         #region Methods
 
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        public Rect ToRect()
+        {
+            return new Rect((int) X, (int) Y, (int) Width, (int) Height);
+        }
+
 #if LANG_JP
         /// <summary>
         /// 指定した点がこの矩形に含まれているかどうかを判断する

src/OpenCvSharp/Modules/tracking/MultiTracker.cs

@@ -0,0 +1,179 @@
+
+using System;
+using System.Collections.Generic;
+using OpenCvSharp.Util;
+
+namespace OpenCvSharp.Tracking
+{
+    /// <inheritdoc />
+    /// <summary>
+    /// This class is used to track multiple objects using the specified tracker algorithm.
+    /// The MultiTracker is naive implementation of multiple object tracking.
+    /// It process the tracked objects independently without any optimization accross the tracked objects.
+    /// </summary>
+    public class MultiTracker : Algorithm
+    {
+        /// <summary>
+        /// cv::Ptr&lt;T&gt;
+        /// </summary>
+        private Ptr ptrObj;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected MultiTracker(IntPtr p)
+        {
+            ptrObj = new Ptr(p);
+            ptr = ptrObj.Get();
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <returns></returns>
+        public static MultiTracker Create()
+        {
+            IntPtr p = NativeMethods.tracking_MultiTracker_create();
+            return new MultiTracker(p);
+        }
+
+        /// <summary>
+        /// Releases managed resources
+        /// </summary>
+        protected override void DisposeManaged()
+        {
+            ptrObj?.Dispose();
+            ptrObj = null;
+            base.DisposeManaged();
+        }
+
+        /// <summary>
+        /// Add a new object to be tracked.
+        /// </summary>
+        /// <param name="newTracker">tracking algorithm to be used</param>
+        /// <param name="image">input image</param>
+        /// <param name="boundingBox">a rectangle represents ROI of the tracked object</param>
+        /// <returns></returns>
+        public bool Add(Tracker newTracker, InputArray image, Rect2d boundingBox)
+        {
+            if (newTracker == null)
+                throw new ArgumentNullException(nameof(newTracker));
+            if (image == null)
+                throw new ArgumentNullException(nameof(image));
+            newTracker.ThrowIfDisposed();
+            image.ThrowIfDisposed();
+
+            int ret = NativeMethods.tracking_MultiTracker_add1(ptr, newTracker.PtrObj.CvPtr, image.CvPtr, boundingBox);
+
+            GC.KeepAlive(newTracker);
+            GC.KeepAlive(image);
+            GC.KeepAlive(this);
+
+            return ret != 0;
+        }
+
+        /// <summary>
+        /// Add a set of objects to be tracked.
+        /// </summary>
+        /// <param name="newTrackers">list of tracking algorithms to be used</param>
+        /// <param name="image">input image</param>
+        /// <param name="boundingBox">list of the tracked objects</param>
+        /// <returns></returns>
+        public bool Add(IEnumerable<Tracker> newTrackers, InputArray image, IEnumerable<Rect2d> boundingBox)
+        {
+            if (newTrackers == null)
+                throw new ArgumentNullException(nameof(newTrackers));
+            if (image == null)
+                throw new ArgumentNullException(nameof(image));
+            if (boundingBox == null)
+                throw new ArgumentNullException(nameof(boundingBox));
+
+            IntPtr[] newTrackersPtrs = EnumerableEx.SelectToArray(newTrackers, t => t.PtrObj.CvPtr);
+            Rect2d[] boundingBoxArray = EnumerableEx.ToArray(boundingBox);
+            int ret = NativeMethods.tracking_MultiTracker_add2(ptr, newTrackersPtrs, newTrackersPtrs.Length,
+                image.CvPtr, boundingBoxArray, boundingBoxArray.Length);
+
+            GC.KeepAlive(newTrackers);
+            GC.KeepAlive(image);
+            GC.KeepAlive(boundingBox);
+            GC.KeepAlive(this);
+
+            return ret != 0;
+        }
+
+        /// <summary>
+        /// Update the current tracking status.
+        /// The result will be saved in the internal storage.
+        /// </summary>
+        /// <param name="image">input image</param>
+        /// <returns></returns>
+        public bool Update(InputArray image)
+        {
+            if (image == null)
+                throw new ArgumentNullException(nameof(image));
+
+            int ret = NativeMethods.tracking_MultiTracker_update1(ptr, image.CvPtr);
+
+            GC.KeepAlive(image);
+            GC.KeepAlive(this);
+
+            return ret != 0;
+        }
+
+        /// <summary>
+        /// Update the current tracking status.
+        /// </summary>
+        /// <param name="image">input image</param>
+        /// <param name="boundingBox">the tracking result, represent a list of ROIs of the tracked objects.</param>
+        /// <returns></returns>
+        public bool Update(InputArray image, out Rect2d[] boundingBox)
+        {
+            if (image == null)
+                throw new ArgumentNullException(nameof(image));
+
+            using (var bbVec = new VectorOfRect2d())
+            {
+                int ret = NativeMethods.tracking_MultiTracker_update2(ptr, image.CvPtr, bbVec.CvPtr);
+                boundingBox = bbVec.ToArray();
+
+                GC.KeepAlive(image);
+                GC.KeepAlive(this);
+
+                return ret != 0;
+            }
+        }
+
+        /// <summary>
+        /// Returns a reference to a storage for the tracked objects, each object corresponds to one tracker algorithm
+        /// </summary>
+        /// <returns></returns>
+        public Rect2d[] GetObjects()
+        {
+            using (var bbVec = new VectorOfRect2d())
+            {
+                NativeMethods.tracking_MultiTracker_getObjects(ptr, bbVec.CvPtr);
+                GC.KeepAlive(this);
+                return bbVec.ToArray();
+            }
+        }
+
+        internal class Ptr : OpenCvSharp.Ptr
+        {
+            public Ptr(IntPtr ptr) : base(ptr)
+            {
+            }
+
+            public override IntPtr Get()
+            {
+                return NativeMethods.tracking_Ptr_MultiTracker_get(ptr);
+            }
+
+            protected override void DisposeUnmanaged()
+            {
+                NativeMethods.tracking_Ptr_MultiTracker_delete(ptr);
+                base.DisposeUnmanaged();
+            }
+        }
+    }
+}
+

src/OpenCvSharp/Modules/tracking/Tracker.cs

@@ -7,6 +7,28 @@ namespace OpenCvSharp.Tracking
     /// </summary>
     public abstract class Tracker : Algorithm
     {
+        internal Ptr PtrObj { get; private set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="ptrObj"></param>
+        protected Tracker(Ptr ptrObj)
+        {
+            PtrObj = ptrObj;
+            ptr = ptrObj.Get();
+        }
+
+        /// <summary>
+        /// Releases managed resources
+        /// </summary>
+        protected override void DisposeManaged()
+        {
+            PtrObj?.Dispose();
+            PtrObj = null;
+            base.DisposeManaged();
+        }
+
         /// <summary>
         /// Initialize the tracker with a know bounding box that surrounding the target
         /// </summary>

src/OpenCvSharp/Modules/tracking/TrackerBoosting.cs

@@ -11,18 +11,12 @@ namespace OpenCvSharp.Tracking
     /// </summary>
     public class TrackerBoosting : Tracker
     {
-        /// <summary>
-        /// cv::Ptr&lt;T&gt;
-        /// </summary>
-        private Ptr ptrObj;
-
         /// <summary>
         /// 
         /// </summary>
         protected TrackerBoosting(IntPtr p)
+            : base(new Ptr(p)) 
         {
-            ptrObj = new Ptr(p);
-            ptr = ptrObj.Get();
         }
 
         /// <summary>
@@ -49,15 +43,6 @@ public static TrackerBoosting Create(Params parameters)
             }
         }
 
-        /// <summary>
-        /// Releases managed resources
-        /// </summary>
-        protected override void DisposeManaged()
-        {
-            ptrObj?.Dispose();
-            ptrObj = null;
-            base.DisposeManaged();
-        }
 
         internal class Ptr : OpenCvSharp.Ptr
         {

src/OpenCvSharp/Modules/tracking/TrackerGOTURN.cs

@@ -25,18 +25,12 @@ namespace OpenCvSharp.Tracking
     // ReSharper disable once InconsistentNaming
     public class TrackerGOTURN : Tracker
     {
-        /// <summary>
-        /// cv::Ptr&lt;T&gt;
-        /// </summary>
-        private Ptr ptrObj;
-
         /// <summary>
         /// 
         /// </summary>
         protected TrackerGOTURN(IntPtr p)
+            : base(new Ptr(p))
         {
-            ptrObj = new Ptr(p);
-            ptr = ptrObj.Get();
         }
 
         /// <summary>
@@ -62,17 +56,7 @@ public static TrackerGOTURN Create(Params parameters)
                 return new TrackerGOTURN(p);
             }
         }
-
-        /// <summary>
-        /// Releases managed resources
-        /// </summary>
-        protected override void DisposeManaged()
-        {
-            ptrObj?.Dispose();
-            ptrObj = null;
-            base.DisposeManaged();
-        }
-
+
         internal class Ptr : OpenCvSharp.Ptr
         {
             public Ptr(IntPtr ptr) : base(ptr)

src/OpenCvSharp/Modules/tracking/TrackerKCF.cs

@@ -14,18 +14,12 @@ namespace OpenCvSharp.Tracking
     // ReSharper disable once InconsistentNaming
     public class TrackerKCF : Tracker
     {
-        /// <summary>
-        /// cv::Ptr&lt;T&gt;
-        /// </summary>
-        private Ptr ptrObj;
-
         /// <summary>
         /// 
         /// </summary>
         protected TrackerKCF(IntPtr p)
+            : base(new Ptr(p)) 
         {
-            ptrObj = new Ptr(p);
-            ptr = ptrObj.Get();
         }
 
         /// <summary>
@@ -57,8 +51,6 @@ public static TrackerKCF Create(Params parameters)
         /// </summary>
         protected override void DisposeManaged()
         {
-            ptrObj?.Dispose();
-            ptrObj = null;
             base.DisposeManaged();
         }
 

src/OpenCvSharp/Modules/tracking/TrackerMIL.cs

@@ -12,18 +12,12 @@ namespace OpenCvSharp.Tracking
     // ReSharper disable once InconsistentNaming
     public class TrackerMIL : Tracker
     {
-        /// <summary>
-        /// cv::Ptr&lt;T&gt;
-        /// </summary>
-        private Ptr ptrObj;
-
         /// <summary>
         /// 
         /// </summary>
         protected TrackerMIL(IntPtr p)
+            : base(new Ptr(p))
         {
-            ptrObj = new Ptr(p);
-            ptr = ptrObj.Get();
         }
 
         /// <summary>
@@ -49,17 +43,7 @@ public static TrackerMIL Create(Params parameters)
                 return new TrackerMIL(p);
             }
         }
-
-        /// <summary>
-        /// Releases managed resources
-        /// </summary>
-        protected override void DisposeManaged()
-        {
-            ptrObj?.Dispose();
-            ptrObj = null;
-            base.DisposeManaged();
-        }
-
+
         internal class Ptr : OpenCvSharp.Ptr
         {
             public Ptr(IntPtr ptr) : base(ptr)