Bewegungsdrang (Teil 3): Über die Kinect im Bilde

Home » Dev » Bewegungsdrang (Teil 3): Über die Kinect im Bilde

Bewegungsdrang (Teil 3): Über die Kinect im Bilde

6. August 2012

Ein verregneter Sonntag und im Fernsehen laufen zum x-ten mal Filme die ich schon zu Jugendzeiten in die Kategorie alte Schinken eingeordnet habe. Was also spricht dagegen einen eigenen kleinen Film zu machen? Schließlich steht da ein neues Spielzeug auf dem Tisch, welches mich im Stile von "Nummer 5 lebt!" mitleidig anschaut und darauf wartet in Betrieb genommen zu werden.

Gesagt, getan! Und so gibt ein kleines grünes Licht schließlich den Startschuss für den nächsten Flurfunk-Artikel, der sich wie in meinem letzten Beitrag "Hello (Kinect) World!" angekündigt ganz und gar um die bewegten Bilder dreht. Selbiges scheint mir wesentlich spannender als der Film der im Hintergrund läuft und dessen Dialoge mein Unterbewusstsein wahrscheinlich schon auswendig kennt. Ich hoffe Sie verspüren ähnlichen Bewegungsdrang!

Stromaufwärts

Als ich Ihnen vor ein paar Wochen den Kinect Controller vorgestellt hatte erwähnte ich schon, dass sowohl RGB-Kamera als auch der Tiefensensor mit 30fps arbeiten. Die Frage aber ist, wie gelangen diese Daten bzw. Bilder nun in die eigene Anwendung? Und wie Sie sich sicher vorstellen können ist die Antwort denkbar einfach und lautet Datenströme oder zu neudeutsch Streams.

Die NUI Library (Natural User Interface) ist an dieser Stelle vereinfacht gesagt nichts anderes als die Runtime der Kinect. Sie umfasst somit alles was für die Nutzung notwendig ist, angefangen vom Treiber, über den Kernel, bis hin zu Bibliotheken die in Visual Studio referenziert werden können. Anschaulich wird das Ganze in dem folgenden SDK Architektur Überblick:

Wie wir sehen sind die Daten also bereits durch einige Schichten "geströmt" bevor Sie in einer Anwendung über das NUI API das Licht der Welt erblicken. Selbiges möchte ich Ihnen in den nächsten Abschnitten für die RGB-Kamera veranschaulichen.

Lauter bunte Bilder

Schluss mit der Theorie, rein in die Praxis! Nachdem wir das SDK ja bereits installiert haben, starten wir Visual Studio und erstellen uns einfach eine neue WPF Applikation, dessen Name ich einfach mal Ihrer eigenen Kreativität überlasse. Ist dies vollbracht brauchen wir als erstes Zugriff auf das NUI API und das lösen wir durch einfaches einbinden der Kinect Library, die im Verzeichnis “C:Program FilesMicrosoft SDKsKinectv1.5Assemblies” zu finden ist.

Mit dem hochgesteckten Ziel ein bewegtes Bild zu sehen und mit dem Wissen dass die Kinect uns Frames durch Streams zur Verfügung stellt, platzieren wir in unserem WPF Hauptfenster wohlweislich schon mal ein Image Control. Ihr XAML sollte dann in etwa so aussehen:

<Window x:Class="RGBCameraFundamentals.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="480" Width="640" MinWidth="640" 
        MinHeight="480" Loaded="Window_Loaded" Closed="Window_Closed">
    <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
        <Image Name="ImageRGB" Width="640" Height="480"/>
    </StackPanel>
</Window>

Bevor jedoch unser Anlitz das soeben erstellte Control ziert, gilt es erst noch die ein oder andere Zeile Code zu implementieren. In unserem Fall wäre es also durchaus sinnvoll sich an das Window_Loaded bzw. Window_Closed Event zu hängen um die Frame Capture Engine der Kinect parallel zur Anwendung zu starten bzw. zu beenden.

using System;
using System.Linq;
using System.Windows;
using Microsoft.Kinect;
using System.IO;
using System.Windows.Media.Imaging;
using System.Windows.Media;
 
namespace RGBCameraFundamentals
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        /// <summary>
        /// Kinect Sensor
        /// </summary>
        public KinectSensor Kinect { get; set; }
 
        public MainWindow()
        {
            InitializeComponent();
        }
 
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            // Generell ist es möglich mehr als einen Kinect Sensor 
            // an einem Rechner zu betreiben. Für unsere Zwecke reicht 
            // es deshalb aus den ersten verfügbaren Sensor mit Status 
            // Connected zu ermitteln.
            this.Kinect = KinectSensor.KinectSensors
                .FirstOrDefault(ks => ks.Status 
                    == KinectStatus.Connected);
 
            if (this.Kinect != null)
            {
                try
                {
                    // Starten des Sensors
                    this.Kinect.Start();
                }
                catch (IOException)
                {
                    this.Kinect = null;
                }
            }
        }
 
        private void Window_Closed(object sender, EventArgs e)
        {
            if (this.Kinect != null)
            {
                // Stoppen des Sensors
                this.Kinect.Stop();
            }
        }
    }
}

So weit, so gut, zwar haben wir die Kinect jetzt eingebunden, aber unserem Ziel sind wir nicht sonderlich viel näher gekommen. Zeit für ein bisschen Initialisierung:

private void Window_Loaded(object sender, RoutedEventArgs e)
{
    ....
 
            try
            {
                // Initialisieren der ColorStreams
                InitializeColorStream();
 
                // Starten des Sensors
                this.Kinect.Start();
            }
            catch (IOException)
            {
                this.Kinect = null;
            }
 
    ....
}
 
private void InitializeColorStream()
{
    // Der jeweilige Stream muß für die Verarbeitung enabled werden. 
    // Wahlweise können auch die Formate RgbResolution1280x960Fps12, 
    // RawYuvResolution640x480Fps15 und YuvResolution640x480Fps15 
    // verarbeitet werden
    this.Kinect.ColorStream.Enable
        (ColorImageFormat.RgbResolution640x480Fps30);
 
    // Zwar könnte man auch eine normale Bitmap nehmen aber die 
    // WriteableBitmap eignet sich durch die Benutzun von internen 
    // Puffern besser zum rendern von Frames. Da wir einen RGB Stream
    // benutzen ist das PixelFormat Bgr32 was einem Standard RGB Format 
    // mit 32 Bits pro Pixel entspricht. Falls Sie eine eigene Palette 
    // benutzen können Sie desweiteren den null Parameter ersetzen, in 
    // der Regel ist dies aber nicht nötig. Und um es nicht zu vergessen 
    // Windows samt WPF nutzen per Default 96dpi, so gesehen sollten 
    // Ihnen die zwei bisher nicht genannten Parameter durchaus klar 
    // sein.
    this.ColorBitmap = new WriteableBitmap(
        this.Kinect.ColorStream.FrameWidth, 
        this.Kinect.ColorStream.FrameHeight,
        96.0, 96.0, PixelFormats.Bgr32, null);
 
    // Die Source des Images in der Anwendung ist natürlich die vorher 
    // definierte WriteableBitmap
    this.ImageRGB.Source = this.ColorBitmap;
}

Die Frage die sich jetzt noch stellt ist die, wie den nun der Zugriff auf die von der Kinect erstellten Frames aus dem ColorStream realisiert wird? Hierfür gibt es generell zwei Möglichkeiten. Einerseits lassen sich die Daten abrufen (Poll-Model) und andererseits können Sie die FrameReady-Events nutzen die seitens der Frame Capture Engine gefeuert werden (Event-Model).

Ich für meinen Teil bevorzuge letztere Variante, denn warum soll ich mich in diesem Kontext mit Threads, Timern oder gar Endlosschleifen herumschlagen wenn ich mich mit einfachsten Mitteln an einen bereits vorhandenen Eventhandler hängen kann? Sollten Sie das anders sehen oder gar zur seltenen Spezies der XNA Entwickler gehören (die Events pollen müssen), dann dürfen Sie gerne einen Blick auf die Methode OpenNextFrame der Klasse ColorImageStream werfen.

private void InitializeColorStream()
{
    ....
  
    // Last-but-not-least sorgen wir dafür dass die FrameReady Events 
    // in der Methode Kinect_ColorFrameReady verarbeitet werden können
    this.Kinect.ColorFrameReady += this.Kinect_ColorFrameReady;
}
  
private void Kinect_ColorFrameReady(object sender, 
    ColorImageFrameReadyEventArgs e)
{
    // Der ColorImageFrame stellt den Container für die Daten des Sensors
    using (ColorImageFrame frame = e.OpenColorImageFrame())
    {
        if (frame != null)
        {
            // Ersten des für die Erstellung des Image nötigen Byte Arrays. 
            // Die Größe des Arrays von 1228800 Byte errechnet sich durch 
            // 640x480x4 (letzteres siehe BGR32)
            byte[] pixelData = new byte[frame.PixelDataLength];
  
            // Übername der Daten aus dem Frame
            frame.CopyPixelDataTo(pixelData);
  
            // Die WriteableBitmap benötigt beim rendern die Angabe welcher 
            // Bereich aktualisiert werden soll. Hier benutzen wir die gesamte 
            //Fläche der Bitmap
            Int32Rect colorBitmapRect = 
                new Int32Rect(0, 0, this.Kinect.ColorStream.FrameWidth, 
                this.Kinect.ColorStream.FrameHeight);
  
            // Die Angabe wieviele Pixel jeweils auf ein mal upgedated werden 
            // sollen. Mit der vorliegenden Definition geschieht dies also 
            //Zeilenweise
            int colorBitmapStride = this.Kinect.ColorStream.FrameWidth * 
                this.Kinect.ColorStream.FrameBytesPerPixel;
  
            // Erstellen der neuen Bitmap
            this.ColorBitmap.WritePixels(colorBitmapRect, pixelData, colorBitmapStride, 0);
        }
    }
}

So, nun ist der große Moment gekommen in dem Sie Ihrer ersten Kinect Applikation eine Chance geben dürfen. Starten Sie die Anwendung und empfinden Sie Freude beim Anblick Ihres Gesichts.

Das kleine grüne Männchen in mir

Bevor ich das Projekt RGB Kamera vorerst schließe, will ich noch einen kurzen und einfachen Exkurs Richtung Imagemanipulation machen. Sicherlich können Sie mit GDI+ die Images vor der Anzeige manipulieren. Worauf ich aber in meinem Beispiel hinaus will, ist die einfache Manipulation des Farbschemas durch Anpassung der Frames bzw. des damit verbundenen Byte-Arrays.

Passen wir unsere Methode Kinect_ColorFrameReady doch einfach mal wie folgt an:

private void Kinect_ColorFrameReady(
    object sender, ColorImageFrameReadyEventArgs e)
{
            ....
 
            // Übername der Daten aus dem Frame
            frame.CopyPixelDataTo(pixelData);
 
            // Wie BGR schon sagt sind die vier Byte pro Pixel Blau, Grün 
            // und Rot gefolgt von einer null die in anderen Formaten wie
            // Bgra32, Pbgra32 den Alpha Wert darstellt. In unserem Fall 
            // reicht es also die Blau und Rot Werte auf 0 zu setzen
            for (int i = 0; i < pixelData.Length; i += frame.BytesPerPixel)
            {
                pixelData[i] = 0x00;
                pixelData[i + 2] = 0x00;
            }
 
            ....
}

Wenn man die Anwendung nun startet sieht man sich, sofern man das so ausdrücken kann, plötzlich in einem ganz neuen Licht.

Der Vollständigkeit halber finden sie den kompletten Source-Code hier.

Ausblick

Der aufmerksame Leser mag gemerkt haben, dass ich ursprünglich angekündigt hatte auch auf den Tiefensensor einzugehen. Asche auf mein Haupt, aber letztlich sind die Themen einfach zu umfangreich (und zu spannend). Somit vertröste ich Sie an dieser Stelle auf den nächsten Artikel in dem ich der Entwicklung den nötigen Tiefgang verpasse. Ich würde mich freuen Sie auch dann wieder die Lust auf ein wenig Bewegungsdrang verspüren.