Repair errors

Assets/Editor/SourceBufferTests.cs

@@ -62,10 +62,7 @@ public class SourceBufferTests
         var obj = new SourceBuffer();
         obj.UpdateBuffers(frame);
 
-        var expected = new byte[KinectConstants.ColorWidth *
-                                KinectConstants.ColorHeight *
-                                KinectConstants.ColorCount];
-        frame.LastColorFrame.CopyData(expected);
+        var expected = frame.LastColorFrame.GetData();
 
         var actual = obj.ColorBuffer;
 
@@ -83,9 +80,7 @@ public class SourceBufferTests
         var obj = new SourceBuffer();
         obj.UpdateBuffers(frame);
 
-        var expected = new byte[KinectConstants.DepthWidth *
-                                KinectConstants.DepthHeight];
-        frame.LastBodyIndexFrame.CopyData(expected);
+        var expected = frame.LastBodyIndexFrame.GetData();
 
         var actual = obj.BodyIndexBuffer;
 
@@ -103,9 +98,7 @@ public class SourceBufferTests
         var obj = new SourceBuffer();
         obj.UpdateBuffers(frame);
 
-        var expected = new ushort[KinectConstants.DepthWidth *
-                                  KinectConstants.DepthHeight];
-        frame.LastDepthFrame.CopyData(expected);
+        var expected = frame.LastDepthFrame.GetData();
 
         var actual = obj.DepthBuffer;
 
@@ -123,8 +116,7 @@ public class SourceBufferTests
         var obj = new SourceBuffer();
         obj.UpdateBuffers(frame);
 
-        var expected = new IBody[KinectConstants.BodyCount];
-        frame.LastBodyFrame.CopyData(expected);
+        var expected = frame.LastBodyFrame.GetData();
 
         var actual = obj.BodyBuffer;
 
@@ -157,74 +149,121 @@ public class MultiSourceFrameStub : IMultiSourceFrame
 
 public class GreenColorFrameStub : IColorFrame
 {
-    private static uint[] data =
-        Enumerable.Repeat<uint>(0x00FF00FF,
-                                KinectConstants.ColorWidth *
-                                KinectConstants.ColorHeight).ToArray();
-
-    public void CopyData(byte[] buffer)
+    private static byte[] data = Enumerable.Range(0,
+                                                  KinectConstants.ColorWidth *
+                                                  KinectConstants.ColorHeight)
+                                           .Select(x => (byte)((x & 1) == 1 ? 0xFF : 0))
+                                           .ToArray();
+    
+    public byte[] GetData()
     {
-        Buffer.BlockCopy(buffer, 0, data, 0, buffer.Length);
+        return data;
     }
 }
 
 public class Fill1BodyIndexFrameStub : IBodyIndexFrame
 {
-    public void CopyData(byte[] buffer)
+    private static byte[] data = Enumerable.Repeat(0,
+                                                   KinectConstants.DepthWidth *
+                                                   KinectConstants.DepthHeight)
+                                           .Select(x => (byte)x)
+                                           .ToArray();
+    
+    public byte[] GetData()
     {
-        for (int i = 0; i < buffer.Length; ++i)
-            buffer[i] = 1;
+        return data;
     }
 }
 
 public class Fill8000DepthFrameStub : IDepthFrame
 {
-    public void CopyData(ushort[] buffer)
+    private static ushort[] data = Enumerable.Repeat(8000,
+                                                     KinectConstants.DepthWidth *
+                                                     KinectConstants.DepthHeight)
+                                             .Select(x => (ushort)x)
+                                             .ToArray();
+    
+    public ushort[] GetData()
     {
-        for (int i = 0; i < buffer.Length; ++i)
-            buffer[i] = 8000;
+        return data;
     }
 }
 
 public class CleanBodyFrameStub : IBodyFrame
 {
-    public void CopyData(IBody[] buffer)
+    private static BodyFake[] data = Enumerable.Range(0, KinectConstants.BodyCount)
+                                               .Select(x =>
+                                               {
+                                                   var tmp = new BodyFake();
+                                                   var joints = tmp.Joints;
+                                                   for (int j = 0; j < KinectConstants.JointCount; ++j)
+                                                       joints[joints.ElementAt(j).Key] = new JointStub();
+                                                   tmp.IsTracked = false;
+
+                                                   return tmp;
+                                               })
+                                               .ToArray();
+
+    public IBody[] GetData()
     {
-        for (int i = 0; i < buffer.Length; ++i)
-        {
-            var tmp = new BodyFake();
-            var joints = tmp.Joints;
-            for(int j = 0; j < KinectConstants.JointCount; ++j)
-                joints[joints.ElementAt(j).Key] = new JointStub();
-            tmp.IsTracked = false;
-
-            buffer[i] = tmp;
-        }
+        return data;
     }
 }
 
 public class ColorFrameDummy : IColorFrame
 {
+    private static byte[] data = new byte[KinectConstants.ColorWidth *
+                                          KinectConstants.ColorHeight *
+                                          KinectConstants.ColorCount];
+
     public void CopyData(byte[] buffer)
     { }
+
+    public byte[] GetData()
+    {
+        return data;
+    }
 }
 
 public class BodyIndexFrameDummy : IBodyIndexFrame
 {
+    private static byte[] data = new byte[KinectConstants.DepthWidth *
+                                          KinectConstants.DepthHeight];
+
     public void CopyData(byte[] buffer)
     { }
+
+    public byte[] GetData()
+    {
+        return data;
+    }
 }
 
 public class DepthFrameDummy : IDepthFrame
 {
+    private static ushort[] data = new ushort[KinectConstants.DepthWidth *
+                                              KinectConstants.DepthHeight];
+
     public void CopyData(ushort[] buffer)
     { }
+
+    public ushort[] GetData()
+    {
+        return data;
+    }
 }
 
 public class BodyFrameDummy : IBodyFrame
 {
+    private static IBody[] data = new IBody[KinectConstants.BodyCount];
+
     public void CopyData(IBody[] buffer)
     { }
+
+    public IBody[] GetData()
+    {
+        return data;
+    }
 }
 
 public class BodyFake : IBody

Assets/KinectModule/IBodyFrame.cs

@@ -2,6 +2,6 @@
 {
     public interface IBodyFrame
     {
-        void CopyData(IBody[] buffer);
+        IBody[] GetData();
     }
 }
\ No newline at end of file

Assets/KinectModule/IBodyIndexFrame.cs

@@ -2,6 +2,6 @@
 {
     public interface IBodyIndexFrame
     {
-        void CopyData(byte[] buffer);
+        byte[] GetData();
     }
 }
\ No newline at end of file

Assets/KinectModule/IColorFrame.cs

@@ -2,6 +2,6 @@
 {
     public interface IColorFrame
     {
-        void CopyData(byte[] buffer);
+        byte[] GetData();
     }
 }
\ No newline at end of file

Assets/KinectModule/IDepthFrame.cs

@@ -2,6 +2,6 @@
 {
     public interface IDepthFrame
     {
-        void CopyData(ushort[] buffer);
+        ushort[] GetData();
     }
 }
\ No newline at end of file

Assets/KinectModule/RealBody.cs

@@ -7,6 +7,7 @@ namespace KinectModule
     public class RealBody : IBody
     {
         private Body _Body;
+        private Dictionary<JointType, IJoint> _Joints;
 
         public bool                          IsTracked
         {
@@ -19,9 +20,7 @@ namespace KinectModule
         {
             get
             {
-                return _Body.Joints.Select(x => new KeyValuePair<JointType, IJoint>
-                                        (x.Key, new RealJoint(x.Value)))
-                                   .ToDictionary(x => x.Key, x => x.Value);
+                return _Joints;
             }
         }
         public Body                          Value
@@ -34,16 +33,25 @@ namespace KinectModule
 
         public RealBody(Body body)
         {
-            _Body = body;
+            if (body != null)
+            {
+                _Body = body;
+                _Joints = _Body.Joints.Select(x => new KeyValuePair<JointType, IJoint>
+                                            (x.Key, new RealJoint(x.Value)))
+                                      .ToDictionary(x => x.Key, x => x.Value);
+            }
         }
 
         public override bool Equals(object obj)
         {
-            return this.Equals(obj as IBody);
+            return Equals(obj as IBody);
         }
 
         public bool Equals(IBody obj)
         {
+            if (_Body == null)
+                return obj == null;
+
             var keys = Joints.Select(x => x.Key);
             foreach (var key in keys)
             {

Assets/KinectModule/RealBodyFrame.cs

@@ -5,25 +5,22 @@ namespace KinectModule
 {
     public class RealBodyFrame : IBodyFrame
     {
-        private Body[] _Buffer = new Body[KinectConstants.BodyCount];
-        private bool IsValid   = false;
+        private static Body[] _Buffer = new Body[KinectConstants.BodyCount];
 
         public RealBodyFrame(BodyFrame frame)
         {
             if (frame != null)
             {
                 frame.GetAndRefreshBodyData(_Buffer);
-
-                IsValid = true;
             }
         }
 
-        public void CopyData(IBody[] buffer)
+        public IBody[] GetData()
         {
-            if (IsValid)
-                Enumerable.Range(0, KinectConstants.BodyCount)
-                          .ToList()
-                          .ForEach(x => buffer[x] = new RealBody(_Buffer[x]));
+            return Enumerable.Range(0, KinectConstants.BodyCount)
+                             .ToList()
+                             .Select(x => new RealBody(_Buffer[x]))
+                             .ToArray();
         }
     }
 }
\ No newline at end of file

Assets/KinectModule/RealBodyIndexFrame.cs

-using System;
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;
 using Windows.Kinect;
 
 namespace KinectModule
 {
     public class RealBodyIndexFrame : IBodyIndexFrame
     {
-        private byte[] _Buffer = new byte[KinectConstants.DepthWidth *
-                                          KinectConstants.DepthHeight];
-        private bool IsValid   = false;
+        private static byte[] _Buffer = new byte[KinectConstants.DepthWidth *
+                                                 KinectConstants.DepthHeight];
 
         public RealBodyIndexFrame(BodyIndexFrame frame)
         {
@@ -17,15 +15,12 @@ namespace KinectModule
                 var BodyIndexData = GCHandle.Alloc(_Buffer, GCHandleType.Pinned);
                 frame.CopyFrameDataToIntPtr(BodyIndexData.AddrOfPinnedObject(), (uint)_Buffer.Length);
                 BodyIndexData.Free();
-
-                IsValid = true;
             }
         }
 
-        public void CopyData(byte[] buffer)
+        public byte[] GetData()
         {
-            if (IsValid)
-                Array.Copy(_Buffer, buffer, _Buffer.Length);
+            return _Buffer;
         }
     }
 }
\ No newline at end of file

Assets/KinectModule/RealColorFrame.cs

-using System;
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;
 using Windows.Kinect;
 
 namespace KinectModule
 {
     public class RealColorFrame : IColorFrame
     {
-        private byte[] _Buffer = new byte[KinectConstants.ColorWidth *
-                                          KinectConstants.ColorHeight *
-                                          KinectConstants.ColorCount];
-        private bool IsValid   = false;
+        private static byte[] _Buffer = new byte[KinectConstants.ColorWidth *
+                                                 KinectConstants.ColorHeight *
+                                                 KinectConstants.ColorCount];
 
         public RealColorFrame(ColorFrame frame)
         {
@@ -18,15 +16,12 @@ namespace KinectModule
                 var ColorData = GCHandle.Alloc(_Buffer, GCHandleType.Pinned);
                 frame.CopyConvertedFrameDataToIntPtr(ColorData.AddrOfPinnedObject(), (uint)_Buffer.Length, ColorImageFormat.Rgba);
                 ColorData.Free();
-
-                IsValid = true;
             }
         }
 
-        public void CopyData(byte[] buffer)
+        public byte[] GetData()
         {
-            if (IsValid)
-                Array.Copy(_Buffer, buffer, _Buffer.Length);
+            return _Buffer;
         }
     }
 }
\ No newline at end of file

Assets/KinectModule/RealDepthFrame.cs

-using System;
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;
 using Windows.Kinect;
 
 namespace KinectModule
 {
     public class RealDepthFrame : IDepthFrame
     {
-        private ushort[] _Buffer = new ushort[KinectConstants.DepthWidth *
-                                              KinectConstants.DepthHeight];
-        private bool     IsValid = false;
+        private static ushort[] _Buffer = new ushort[KinectConstants.DepthWidth *
+                                                     KinectConstants.DepthHeight];
 
         public RealDepthFrame(DepthFrame frame)
         {
@@ -17,15 +15,12 @@ namespace KinectModule
                 var DepthData = GCHandle.Alloc(_Buffer, GCHandleType.Pinned);
                 frame.CopyFrameDataToIntPtr(DepthData.AddrOfPinnedObject(), (uint)_Buffer.Length * sizeof(ushort));
                 DepthData.Free();
-
-                IsValid = true;
             }
         }
 
-        public void CopyData(ushort[] buffer)
+        public ushort[] GetData()
         {
-            if (IsValid)
-                Array.Copy(_Buffer, buffer, _Buffer.Length);
+            return _Buffer;
         }
     }
 }
\ No newline at end of file

Assets/KinectModule/RealMultiSourceFrame.cs

@@ -4,60 +4,35 @@ namespace KinectModule
 {
     public class RealMultiSourceFrame : IMultiSourceFrame
     {
-        RealColorFrame     _ColorFrame;
-        RealBodyIndexFrame _BodyIndexFrame;
-        RealDepthFrame     _DepthFrame;
-        RealBodyFrame      _BodyFrame;
-
         public IColorFrame     LastColorFrame
-        {
-            get
-            {
-                return _ColorFrame;
-            }
-        }
+        { get; private set; }
         public IBodyIndexFrame LastBodyIndexFrame
-        {
-            get
-            {
-                return _BodyIndexFrame;
-            }
-        }
+        { get; private set; }
         public IDepthFrame     LastDepthFrame
-        {
-            get
-            {
-                return _DepthFrame;
-            }
-        }
+        { get; private set; }
         public IBodyFrame      LastBodyFrame
-        {
-            get
-            {
-                return _BodyFrame;
-            }
-        }
+        { get; private set; }
 
         public RealMultiSourceFrame(MultiSourceFrame sourceFrame)
         {
             if (sourceFrame == null)
             {
-                _ColorFrame     = new RealColorFrame    (null);
-                _BodyIndexFrame = new RealBodyIndexFrame(null);
-                _DepthFrame     = new RealDepthFrame    (null);
-                _BodyFrame      = new RealBodyFrame     (null);
+                LastColorFrame     = new RealColorFrame    (null);
+                LastBodyIndexFrame = new RealBodyIndexFrame(null);
+                LastDepthFrame     = new RealDepthFrame    (null);
+                LastBodyFrame      = new RealBodyFrame     (null);
 
                 return;
             }
 
             using (var colorFrame     = sourceFrame.ColorFrameReference    .AcquireFrame())
-                _ColorFrame           = new RealColorFrame    (colorFrame);
+                LastColorFrame        = new RealColorFrame    (colorFrame);
             using (var bodyIndexFrame = sourceFrame.BodyIndexFrameReference.AcquireFrame())
-                _BodyIndexFrame       = new RealBodyIndexFrame(bodyIndexFrame);
+                LastBodyIndexFrame    = new RealBodyIndexFrame(bodyIndexFrame);
             using (var depthFrame     = sourceFrame.DepthFrameReference    .AcquireFrame())
-                _DepthFrame           = new RealDepthFrame    (depthFrame);
+                LastDepthFrame        = new RealDepthFrame    (depthFrame);
             using (var bodyFrame      = sourceFrame.BodyFrameReference     .AcquireFrame())
-                _BodyFrame            = new RealBodyFrame     (bodyFrame);
+                LastBodyFrame         = new RealBodyFrame     (bodyFrame);
         }
     }
 }
\ No newline at end of file

Assets/KinectModule/SourceBuffer.cs

@@ -2,50 +2,33 @@
 {
     public class SourceBuffer
     {
-        private byte[]   _ColorBuffer     = new byte  [KinectConstants.ColorWidth *
-                                                       KinectConstants.ColorHeight *
-                                                       KinectConstants.ColorCount],
-                         _BodyIndexBuffer = new byte  [KinectConstants.DepthWidth *
-                                                       KinectConstants.DepthHeight];
-        private ushort[] _DepthBuffer     = new ushort[KinectConstants.DepthWidth *
-                                                       KinectConstants.DepthHeight];
-        private IBody[]  _BodyBuffer      = new IBody [KinectConstants.BodyCount];
-
-        public byte[] ColorBuffer
-        {
-            get
-            {
-                return _ColorBuffer;
-            }
-        }
-        public byte[] BodyIndexBuffer
-        {
-            get
-            {
-                return _BodyIndexBuffer;
-            }
-        }
+        public byte[]   ColorBuffer
+        { get; private set; }
+        public byte[]   BodyIndexBuffer
+        { get; private set; }
         public ushort[] DepthBuffer
+        { get; private set; }
+        public IBody[]  BodyBuffer
+        { get; private set; }
+
+        public SourceBuffer()
         {
-            get
-            {
-                return _DepthBuffer;
-            }
-        }
-        public IBody[] BodyBuffer
-        {
-            get
-            {
-                return _BodyBuffer;
-            }
+            ColorBuffer     = new byte  [KinectConstants.ColorWidth *
+                                         KinectConstants.ColorHeight *
+                                         KinectConstants.ColorCount];
+            BodyIndexBuffer = new byte  [KinectConstants.DepthWidth *
+                                         KinectConstants.DepthHeight];
+            DepthBuffer     = new ushort[KinectConstants.DepthWidth *
+                                         KinectConstants.DepthHeight];
+            BodyBuffer      = new IBody [KinectConstants.BodyCount];
         }
 
         public void UpdateBuffers(IMultiSourceFrame sourceFrame)
         {
-            sourceFrame.LastColorFrame    .CopyData(_ColorBuffer);
-            sourceFrame.LastBodyIndexFrame.CopyData(_BodyIndexBuffer);
-            sourceFrame.LastDepthFrame    .CopyData(_DepthBuffer);
-            sourceFrame.LastBodyFrame     .CopyData(_BodyBuffer);
+            ColorBuffer     = sourceFrame.LastColorFrame    .GetData();
+            BodyIndexBuffer = sourceFrame.LastBodyIndexFrame.GetData();
+            DepthBuffer     = sourceFrame.LastDepthFrame    .GetData();
+            BodyBuffer      = sourceFrame.LastBodyFrame     .GetData();
         }
     }
 }
\ No newline at end of file

Assets/MotionAnalysis/MotionDiscriminator.cs

-using System.Linq;
+using KinectModule;
+using System.Linq;
 using Windows.Kinect;
 
 namespace MotionAnalysis
@@ -12,7 +13,7 @@ namespace MotionAnalysis
         public bool        IsPreseted
         { get; private set; }
         
-        public void Preset(KinectModule.IBody body)
+        public void Preset(IBody body)
         {
             IsPreseted = false;
 
@@ -26,14 +27,15 @@ namespace MotionAnalysis
             }
         }
 
-        private bool HaveKneeJoint(KinectModule.IBody body)
+        private bool HaveKneeJoint(IBody body)
         {
-            return body != null                                &&
+            return body        != null                         &&
+                   body.Joints != null                         &&
                    body.Joints.ContainsKey(JointType.KneeLeft) &&
                    body.Joints.ContainsKey(JointType.KneeRight);
         }
 
-        private float ComputeKneeMean(KinectModule.IBody body)
+        private float ComputeKneeMean(IBody body)
         {
             return body.Joints.Where(x => x.Key == JointType.KneeLeft ||
                                           x.Key == JointType.KneeRight)
@@ -46,7 +48,7 @@ namespace MotionAnalysis
             Motion = MotionState.UNKNOWN;
         }
 
-        public void Update(KinectModule.IBody body)
+        public void Update(IBody body)
         {
             Extractor.Extract(body);
 

Assets/Script/CoordinateMapperView.cs

@@ -4,7 +4,7 @@ using Windows.Kinect;
 
 public class CoordinateMapperView : MonoBehaviour
 {
-    private GameObject manager;
+    private CoordinateMapperManager manager;
 
 	private ComputeBuffer DepthBuffer,
                           BodyIndexBuffer;
@@ -14,16 +14,16 @@ public class CoordinateMapperView : MonoBehaviour
 
     void Start ()
 	{
-        var CoordinateMapperManager = GameObject.Find("InGameManagers").GetComponent<CoordinateMapperManager>();
+        manager = GameObject.Find("InGameManagers").GetComponent<CoordinateMapperManager>();
 
         var material = GetComponent<Renderer>().material;
 
-        material.SetTexture("_MainTex", CoordinateMapperManager.ColorTexture);
+        material.SetTexture("_MainTex", manager.ColorTexture);
 
         DepthBuffer     = GenerateBuffer("depthCoordinates", sizeof(float) * 2,
-                                         (DepthPoints = CoordinateMapperManager.DepthCoordinates), material);
+                                         manager.DepthCoordinates, material);
         BodyIndexBuffer = GenerateBuffer("BodyIndexBuffer", sizeof(float),
-                                         (BodyIndexPoints = CoordinateMapperManager.BodyIndexBuffer), material);
+                                         manager.BodyIndexBuffer, material);
     }
 
     ComputeBuffer GenerateBuffer(string name, int stride, Array points, Material material)
@@ -35,12 +35,10 @@ public class CoordinateMapperView : MonoBehaviour
 
 	void Update()
 	{
-
-
 		//TODO: fix perf on this call.
-		DepthBuffer.SetData(DepthPoints);
+		DepthBuffer.SetData(manager.DepthCoordinates);
         
-		BodyIndexBuffer.SetData(Array.ConvertAll(BodyIndexPoints, Convert.ToSingle));
+		BodyIndexBuffer.SetData(Array.ConvertAll(manager.BodyIndexBuffer, Convert.ToSingle));
 	}
 	
 	void OnDisable()