Bewegungsdrang (Teil 4): Die tiefen Weiten des Kinect Universums

Home » Dev » Bewegungsdrang (Teil 4): Die tiefen Weiten des Kinect Universums

Bewegungsdrang (Teil 4): Die tiefen Weiten des Kinect Universums

10. September 2012

Die Leser unter Ihnen, die, so wie ich, als Kind der 80er aufgewachsen sind, werden sich sicherlich erinnern. Damals rannte ein blaues pelziges Etwas namens Grobi hektisch durch das Programm der Sesamstraße und versuchte uns die Begriffe "Nah & Fern" zu erklären. Heute, also gute 30 Jahre später, habe ich das Vergnügen diese Begriffe noch mal neu für mich zu entdecken. Und wie damals sitze ich wieder gebannt vor dem Bildschirm und erfreue mich der Dinge. Kinect sei Dank!

Sie können sich sicherlich denken worum es geht. Während wir uns im letzten Artikel Über die Kinect im Bilde noch mit Oberflächlichkeiten begnügen mussten, gehen wir heute einen Schritt weiter. Wir verpassen einer Anwendung den nötigen Tiefgang indem wir uns dieses Mal den Stream des Tiefensensors zu nutze machen.

Eine Sache des Blickwinkels

Im ersten Teil dieser Serie hatte ich geschrieben, dass der maßgebliche Unterschied zwischen der Kinect für Windows verglichen mit der Xbox 360 Variante im Tiefensensor liegt. Heute möchte ich dies ein wenig besser spezifizieren, denn Microsoft hat hier nicht – wie man glauben könnte – einen verbesserten Sensor verbaut. Nein, stattdessen wurde eine neue Firmware entwickelt die besser mit den Lichtverhältnissen bezogen auf nahe Objekte umgehen kann.

Dies hat zur Folge dass die Kinect je nach Aufgabe im Default Mode und im Near Mode betrieben werden kann. Auf das Blickfeld (field of view), oder präziser gesagt auf die Distanz in der Objekte erkannt werden, hat das folgenden Einfluss:

Quelle: Kinect for Windows Blog, Near Mode – What t is (and isn’t)

Wie man also sieht gibt es, trotz der räumlichen Einschränkungen die durch die Kinect gegeben sind, genug Freiraum um ein wenig Kreativität in Sachen Interaktion ausleben zu können.

Alles grau in grau

So, nach all den einleitenden Worten raus aus der grauen Theorie und rein in die graue Praxis. Wir wollen wie auch im letzten Teil dieser Blogserie eine einfache WPF Applikation erstellen in der unser Antlitz erstrahlt. Dieses mal wird selbiges allerdings nicht ganz so farbgewaltig sein wie zuletzt.

Nach dem erklärten Schema erstellen wir also zuerst eine WPF Applikation mit einem klangvollen Namen, platzieren ein Image Control, hängen uns an den Window_Loaded bzw. Window_Closed Event und fügen noch ein wenig Kinect Voodoo als letzte Zutat hinzu um zu folgendem Ergebnis zu kommen:

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

/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
    /// <summary>
    /// Kinect Sensor
    /// </summary>
    public KinectSensor Kinect { get; set; }
  
    /// <summary>
    /// Die Bitmap die in der Anwendung angezeigt wird
    /// </summary>
    public WriteableBitmap DepthBitmap { get; set; }
  
    /// <summary>
    /// Pixel Array welches ein Image des Streams enthält
    /// </summary>
    public short[] PixelData { 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
            {
                // Initialisieren der DepthStreams
                InitializeDepthStream();
  
                // 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();
        }
    }
  
    private void InitializeDepthStream()
    {
        // Fenstertitel dahingehend ändern das der aktuelle Modus angezeigt wird
        this.Title = this.Kinect.DepthStream.Range.ToString();
  
        // Der jeweilige Stream muß für die Verarbeitung enabled werden. Wahlweise können auch
        // die Formate Resolution320x240Fps30 sowie Resolution80x60Fps30 verarbeitet werden
        // YuvResolution640x480Fps15 verarbeitet werden. Sie können Enable auch ohne ImageFormat
        // aufrufen dann wird den das unten angegebene Format ist per defualt gesetzt.
        this.Kinect.DepthStream.Enable(DepthImageFormat.Resolution640x480Fps30);
  
        // 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 den Depth
        // Stream nutzen wir das PixelFormat Gray16. Dieses besagt dass 16 Pixel pro Tiefeninformation
        // genutzt werden, was insgesamt 65536 Schattierungen von Grau bedeutet. Alternativ können 
        // Sie natürlich auch andere Formate nutzen wie z.B: BGR32, allerdings sollten Sie vorher 
        // darüber nachdenken wie sinnvoll das für Ihren Fall ist. Wenn Sie dies tun, dann sollten
        // Sie allerdings daran denken der Pixel Array entsprechend zu dimensionieren. Bei BGR32 
        // wäre dies z.B. byte[] pixelData = new byte[frame.PixelDataLength*sizeof(int)]  weil das
        // BGR32 Format ja 32 Bit anstatt 16 Bit ist. Hinzu kommt dass man den Intensitätsgrad dann
        // immer manuell für Rot, Grün und Blau setzen muss.
        this.DepthBitmap = new WriteableBitmap(this.Kinect.DepthStream.FrameWidth, this.Kinect.DepthStream.FrameHeight,
            96.0, 96.0, PixelFormats.Gray16, null);
  
        // Die Source des Images in der Anwendung ist natürlich die vorher definierte WriteableBitmap
        this.ImageDepth.Source = this.DepthBitmap;
  
        // Last-but-not-least sorgen wir dafür dass die FrameReady Events in der Methode 
        // Kinect_DepthFrameReady verarbeitet werden können
        this.Kinect.DepthFrameReady += this.Kinect_DepthFrameReady;
    }
  
    private void Kinect_DepthFrameReady(object sender, DepthImageFrameReadyEventArgs e)
    {
        // Der DepthImageFrame stellt den Container für die Daten des Sensors
        using (DepthImageFrame frame = e.OpenDepthImageFrame())
        {
            if (frame != null)
            {
                // Der Byte Array der vom Tiefensensor geliefert wird ist Array of short wobei
                // jeder Wert des Arrays zusammengesetzt ist aus Tiefeninformation und PlayerIndex
                PixelData = new short[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 depthBitmapRect = new Int32Rect(0, 0, this.Kinect.DepthStream.FrameWidth, this.Kinect.DepthStream.FrameHeight);
  
                // Die Angabe wieviele Pixel jeweils auf ein mal upgedated werden sollen. Mit der vorliegenden
                // Definition geschieht dies also Zeilenweise
                int depthBitmapStride = this.Kinect.DepthStream.FrameWidth * this.Kinect.DepthStream.FrameBytesPerPixel;
  
                // Erstellen der neuen Bitmap
                this.DepthBitmap.WritePixels(depthBitmapRect, PixelData, depthBitmapStride, 0);
            }
        }
    }
}

So weit, so gut, was aber noch fehlt ist die Initialisierung sowie die Verarbeitung des Tiefensensor-Streams. Bevor ich jedoch dazu komme, möchte ich Ihnen noch den grundlegendsten Unterschied zum RGB Stream aufzeigen. Jedes DepthFrame wird nämlich durch ein short Array repräsentiert bei dem jedes Element eine einzelne Tiefeninformation enthält. Und da die 16 Bit mehr als genug Platz haben die Tiefe zu speichern, ist in jedem Element noch zusätzlich der sogenannte Playerindex zu finden (auf den ich ein anderes mal eingehe). Dies sieht dann in der Praxis wie folgt aus:

Mit diesen Informationen im Kopf und mit ein bisschen Kinect API Know-How können wir schließlich unsere Applikation vollenden. Und auch wenn wir damit sicherlich nicht den Olymp der Kinect Applikationen erklimmen werden, klar ist das wir mit recht einfachen Mitteln sehr schnell ans Ziel gelangen. Und weil dies der Fall ist fügen wir unserer Applikation noch ein Textfeld unterhalb des Image ein in der wir noch gerne den Abstand des Punktes in Millimetern zum Sensor ausgeben lassen wollen. Dazu fügen wir folgenden Code für den MouseMove-Event hinzu:

private void ImageDepth_MouseMove(object sender, MouseEventArgs e)
{
    // Position innerhalb des Image ermitteln
    Point point = e.GetPosition(ImageDepth);
    
    // Index des Pixels berechnen
    int pixelIndex = (int)(point.X + ((int)point.Y * this.DepthBitmap.Width));
  
    // Tiefeninformation extrahieren (letzte drei Bits im short Wert sind ja der Player index
    int depth = this.PixelData[pixelIndex] >> DepthImageFrame.PlayerIndexBitmaskWidth;
  
    // Player index extrahieren
    int playerIndex = this.PixelData[pixelIndex] & DepthImageFrame.PlayerIndexBitmask;
  
    TextDepthInfo.Text = string.Format("Depth {0} mm - Player {1} ", depth, playerIndex);
}

Aus der Nähe betrachtet

Haben Sie die Anwendung schon einmal gestartet? Nun … wenn Sie selbst stolzer Besitzer einer Kinect für Windows sind, dann könnte das Fenster das Ihren Bildschirm ziert in etwa so aussehen:

Da wir oben keine konkrete Initialisierung vorgenommen haben arbeitet die Kinect hier gerade im Default Mode. Stellt sich die Frage wie wir nun in den Near Mode wechseln und was für Auswirkungen das hat. Die Antwort ist denkbar einfach, aber bevor ich Sie Ihnen gebe sollten wir das WPF Fenster noch schnell erweitern. Der Einfachheit halber ergänzen wir die Anwendung einfach um ein Mouseup-Event in dem wir folgende Zeilen hinzufügen:

private void ImageDepth_MouseUp(object sender, MouseButtonEventArgs e)
{
    if (this.Kinect != null)
    {
        // Zu beachten ist dass dieser Code eine InvalidOperationException werfen würde
        // wenn er mit einer Xbox 360 Kinect ausgeführt werden würde 
        if (this.Kinect.DepthStream.Range == DepthRange.Default)
        {
            this.Kinect.DepthStream.Range = DepthRange.Near;
        }
        else
        {
            this.Kinect.DepthStream.Range = DepthRange.Default;
        }
  
        this.Title = this.Kinect.DepthStream.Range.ToString();
    }
}

Klicken wir nun zur Laufzeit auf das Image dann switchen wir zwischen Default- und Near-Mode hin und her. Optisch lässt sich die Veränderung hier sehr gut erkennen:.

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

Ausblick

Aus dem heutigen Artikel haben Sie wahrscheinlich zwei Dinge mitgenommen. Einerseits wie man den Zugriff auf die Daten vom Tiefensensor realisiert und andererseits, dass die guten alten Lehrstunden der Sesamstraße immer noch gut genug sind den Artikel eines Blogs einzuleiten. Ich hoffe Ihnen hat der Artikel genauso viel Spaß gemacht wie mir und ich würde mich freuen wenn Sie beim nächsten Mal wieder ein wenig Bewegungsdrang verspüren. Dann wird Ihnen die Kinect unter die Haut gehen.