Question

I need to make a console application that uses Kinect, with Kinect SDK and c#. Since it’s a console application, I’ve found polling to be the best way to retrieve the frames I need to process. I’ll need to retrieve frames from the depth camera and the rgb camera, do some processing on then in separate threads (one for the depth image and one for the rgb image), and give an output to the user for each of the two processed frames. The way I’ve been thinking about doing this is the following:

1 – create 2 threads, the first is on the method that polls the rgb camera and do the processing, the second is on the method that polls the depth camera and do the processing

2 – Start the threads

3 – enter a while some stop condition loop

4 – check separately if each thread is alive, if not, create them again and start them again

I’ve made a test program that follows those steps and it works, but I’m not sure it’s the best way of doing it. My test program is

class Program
{
    private static ClassExecutioner Executioner;
    private static Class1 Cls;

    static void Main(string[] args)
    {
        Executioner = new ClassExecutioner();
        Cls = new Class1();

        Thread fThread = new Thread(new ThreadStart(processA));
        Thread sThread = new Thread(new ThreadStart(processB));
        fThread.Start();
        sThread.Start();

        while (true)
        {
            if (!fThread.IsAlive)
            {
                fThread = new Thread(new ThreadStart(processA));
                fThread.Start();
            }

            if (!sThread.IsAlive)
            {
                sThread = new Thread(new ThreadStart(processB));
                sThread.Start();
            }
        }

    }
    static void processA()
    {
        String frameA = Cls.pollA();
        Executioner.CallA(frameA);
    }
    static void processB()
    {
        String frameB = Cls.pollB();
        Executioner.CallB(frameB);
    }
}

Class 1 methods represent the polling of the cameras on kinect

class Class1
{
    private int a;
    private int b;

    public Class1()
    {
        a = 0;
        b = 0;
    }

    public String pollA()
    {
        String frame = "this is " + a % 100;
        a++;
        return frame;
    }

    public String pollB()
    {
        String frame = "I am " + b % 100;
        b++;
        return frame;
    }
}

Executioner represents the methods that process the frames obtained from Kinect

class ClassExecutioner
{

    public ClassExecutioner()
    {
    }

    public void CallA(String frameA)
    {
        Random rand = new Random();
        int time = rand.Next() % 1000000000;
        //'processing' - wait some time
        for (int i = 0; i < time; i++)
        {
        }
        // finishes the processing of the 'frame' from stream A
        Console.WriteLine(frameA);
    }

    public void CallB(String frameB)
    {
        Random rand = new Random();
        int time = rand.Next() % 1000000000;
        // 'processing' - wait some time
        for (int i = 0; i < time; i++)
        {
        }
        // finishes the processing of the 'frame' from stream B
        Console.WriteLine(frameB);
    }
}

The program is very simple but ilustrates well what I want to do with the Kinect streams. The problem is, I’m not sure this is the best way of doing it or even if this is gonna work at all on a practical, Kinect application. Keep in mind that, for now, each processing (depth and rgb) doesn’t need information from the other.

Thanks in advance!

Answer 1

It might be cool to look into the ReactiveExtensions framework. It deals with async event streams very cleanly.

You can write LINQ against the data sources and do very interesting composable operations.

http://msdn.microsoft.com/en-us/data/gg577609.aspx

You basically would have two IEnumerable sequences (the things that loop infinitely) that yield out the frame at the given interval. You can then “query” these sequences using Rx. RX handles all the complicated threading issues for you and makes your consumer code clean and simple.

To be clear, you don’t want to be creating new threads each time. You can create two infinite enumerables that each run on their own thread and yield out the result on each iteration. That way they don’t even “die”