Merge pull request #12 from MarekKowalski/streaming

Streaming of the merged point cloud to other services.

LiveScanServer/LiveScanServer.csproj

@@ -65,6 +65,8 @@
     <Compile Include="SettingsForm.Designer.cs">
       <DependentUpon>SettingsForm.cs</DependentUpon>
     </Compile>
+    <Compile Include="TransferServer.cs" />
+    <Compile Include="TransferSocket.cs" />
     <Compile Include="Utils.cs" />
     <EmbeddedResource Include="MainWindowForm.resx">
       <DependentUpon>MainWindowForm.cs</DependentUpon>

LiveScanServer/MainWindowForm.cs

@@ -42,6 +42,7 @@ namespace KinectServer
         static extern float ICP(IntPtr verts1, IntPtr verts2, int nVerts1, int nVerts2, float[] R, float[] t, int maxIter = 200);
 
         KinectServer oServer;
+        TransferServer oTranfserServer;
 
         //Those three variables are shared with the OpenGLWindow class and are used to exchange data with it.
         //Vertices from all of the sensors
@@ -82,6 +83,9 @@ namespace KinectServer
 
             oServer = new KinectServer(oSettings);
             oServer.eSocketListChanged += new SocketListChangedHandler(UpdateListView);
+            oTranfserServer = new TransferServer();
+            oTranfserServer.lVertices = lAllVertices;
+            oTranfserServer.lColors = lAllColors;
 
             InitializeComponent();
         }
@@ -96,6 +100,7 @@ namespace KinectServer
             stream.Close();
 
             oServer.StopServer();
+            oTranfserServer.StopServer();
         }
 
         //Starts the server
@@ -106,11 +111,13 @@ namespace KinectServer
             if (bServerRunning)
             {
                 oServer.StartServer();
+                oTranfserServer.StartServer();
                 btStart.Text = "Stop server";
             }
             else
             {
                 oServer.StopServer();
+                oTranfserServer.StopServer();
                 btStart.Text = "Start server";
             }
         }

LiveScanServer/TransferServer.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Threading;
+
+using System.Net.Sockets;
+using System.Net;
+
+
+namespace KinectServer
+{
+    class TransferServer
+    {
+        public List<float> lVertices = new List<float>();
+        public List<byte> lColors = new List<byte>();
+
+        TcpListener oListener;
+        List<TransferSocket> lClientSockets = new List<TransferSocket>();
+
+        object oClientSocketLock = new object();
+        bool bServerRunning = false;
+
+        public void StartServer()
+        {
+            if (!bServerRunning)
+            {
+                oListener = new TcpListener(IPAddress.Any, 48002);
+                oListener.Start();
+
+                bServerRunning = true;
+                Thread listeningThread = new Thread(this.ListeningWorker);
+                listeningThread.Start();
+                Thread receivingThread = new Thread(this.ReceivingWorker);
+                receivingThread.Start();
+            }
+        }
+
+        public void StopServer()
+        {
+            if (bServerRunning)
+            {
+                bServerRunning = false;
+
+                oListener.Stop();
+                lock (oClientSocketLock)
+                    lClientSockets.Clear();
+            }
+        }
+
+        private void ListeningWorker()
+        {
+            while (bServerRunning)
+            {
+                try
+                {
+                    TcpClient newClient = oListener.AcceptTcpClient();
+
+                    lock (oClientSocketLock)
+                    {
+                        lClientSockets.Add(new TransferSocket(newClient));
+                    }
+                }
+                catch (SocketException)
+                {
+                }
+                System.Threading.Thread.Sleep(100);
+            }
+        }
+
+        private void ReceivingWorker()
+        {
+            System.Timers.Timer checkConnectionTimer = new System.Timers.Timer();
+            checkConnectionTimer.Interval = 1000;
+
+            checkConnectionTimer.Elapsed += delegate (object sender, System.Timers.ElapsedEventArgs e)
+            {
+                lock (oClientSocketLock)
+                {
+                    for (int i = 0; i < lClientSockets.Count; i++)
+                    {                      
+                        if (!lClientSockets[i].SocketConnected())
+                        {
+                            lClientSockets.RemoveAt(i);
+                            i--;
+                        }
+                    }
+                }
+            };
+
+            checkConnectionTimer.Start();
+
+            while (bServerRunning)
+            {
+                lock (oClientSocketLock)
+                {
+                    for (int i = 0; i < lClientSockets.Count; i++)
+                    {
+                        byte[] buffer = lClientSockets[i].Receive(1);
+
+                        while (buffer.Length != 0)
+                        {
+                            if (buffer[0] == 0)
+                            {
+                                lock (lVertices)
+                                {
+                                    lClientSockets[i].SendFrame(lVertices, lColors);
+                                }
+                            }
+
+                            buffer = lClientSockets[i].Receive(1);
+                        }
+                    }
+                }
+
+                Thread.Sleep(10);
+            }
+
+            checkConnectionTimer.Stop();
+        }
+    }
+}

LiveScanServer/TransferSocket.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using System.Net.Sockets;
+using System.Runtime.Serialization.Formatters.Binary;
+
+namespace KinectServer
+{
+    class TransferSocket
+    {
+        TcpClient oSocket;
+
+        public TransferSocket(TcpClient clientSocket)
+        {
+            oSocket = clientSocket;
+        }
+
+        public byte[] Receive(int nBytes)
+        {
+            byte[] buffer;
+            if (oSocket.Available != 0)
+            {
+                buffer = new byte[Math.Min(nBytes, oSocket.Available)];
+                oSocket.GetStream().Read(buffer, 0, nBytes);
+            }
+            else
+                buffer = new byte[0];
+
+            return buffer;
+        }
+
+        public bool SocketConnected()
+        {
+            return oSocket.Connected;
+        }
+
+        public void WriteInt(int val)
+        {
+            oSocket.GetStream().Write(BitConverter.GetBytes(val), 0, 4);
+        }
+
+        public void WriteFloat(float val)
+        {
+            oSocket.GetStream().Write(BitConverter.GetBytes(val), 0, 4);
+        }
+
+        public void SendFrame(List<float> vertices, List<byte> colors)
+        {
+            short[] sVertices = Array.ConvertAll(vertices.ToArray(), x => (short)(x * 1000));
+
+            
+            int nVerticesToSend = vertices.Count / 3;
+            byte[] buffer = new byte[sizeof(short) * 3 * nVerticesToSend];
+            Buffer.BlockCopy(sVertices, 0, buffer, 0, sizeof(short) * 3 * nVerticesToSend);
+            try
+            {                 
+                WriteInt(nVerticesToSend);                               
+                oSocket.GetStream().Write(buffer, 0, buffer.Length);
+                oSocket.GetStream().Write(colors.ToArray(), 0, sizeof(byte) * 3 * nVerticesToSend);
+            }
+            catch (Exception ex)
+            {
+            }
+        }
+    }
+}