Fala filhotes, tudo bem?

Recentemente fizemos um evento na faculdade Infórium e tive a oportunidade de falar sobre o bom e velho Kinect. Como é meio difícil explicar passo a passo na palestra ( é pouco tempo) vamos voltar com uma sequência de posts explicando cada parte:

Hoje iremos cobrir a parte da câmera RGB. Se quiser hoje eu consegui fazer um video explicando o passo a passo, então você pode só ver ele.

Tutorial

Nivel: Básico
Objetivo: Mostrar a imagem da câmera do Kinect em sua aplicação.
Video:

Requerimentos

Para usar o SDK, você vai precisar de:

  • Visual Studio 2010 (Podendo ser a versão express)
  • .NET framework 4.o
  • windows 7 ou  windows 8 consumer preview

Versão 1.5

Houve muitas mudanças da versão beta do SDK para a 1.5 mas foram para melhor. Alem de uma nomenclatura mais clara de classes e métodos, aumentou consideravelmente os recursos que o SDK disponibiliza.

A versão 1.5 ainda traz varias novidades com relação a 1.0, entre elas o SDK de localização de face (Posição dos olhos, sobrancelhas, etc..) e a capacidade de rastrear pessoas sentadas (para uma lista com todas as melhorias clique aqui)

Se você já desenvolveu para a versão 1.0 do Kinect SDK então você não deverá ter problemas com essa versão!

Arquivos necessários

No site oficial do Kinect SDK, você irá encontrar 3 downloads:

* Kinect SDK –  provê os drivers necessários para programar para o Kinect. (Necessário)

* Kinect Toolkit – Traz vários exemplos, códigos e documentação. ( É extramente recomendável o download desse)

* Language Packs – Pacote de línguas para permitir o reconhecimento de voz do Kinect. (Infelizmente ainda não tem português )

Se você instalou o developer toolkit então basta executa-lo para mostrar todos os exemplos/documentos ( tem uns MUITOS INTERESSANTES )

Precisa de alguma ajuda ou exemplo? Clique em algum e seja feliz!

Começando a usar a “mágica”:

Agora que ja está tudo instalado, vamos criar um novo projeto no Visual Studio:

No meu caso estou criando um projeto WPF, mas fique a vontade para criar um outro tipo

E depois vamos adicionar a referência ao Microsoft.Kinect ( que é o Kinect SDK que acabamos de baixar):

Agora estamos prontos! Bora programar!

Dentro do MainWindow.cs (code-behind da janela principal) vamos colocar um using e criar uma variável do KinectSensor que representará o nosso sensor:

using Microsoft.Kinect;

namespace TesteCameraRGB
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        // Nosso Sensor
        KinectSensor sensor;
...

O Kinect SDK permite que você tenha mais de 1 Kinect conectado ao sistema,  então dentro do construtor do MainWindow vamos fazer isso:

   public MainWindow()
        {
            InitializeComponent();

            // Verificamos quantos sensores estão conectado
            if (KinectSensor.KinectSensors.Count > 0)
            {
                // Pega o sensor conectado
                sensor = KinectSensor.KinectSensors[0];

Agora habilitamos a função que queremos do Kinect, e adicionamos um evento no ColorStreamReady ou AllFrameReady:

//Habilita a camera RGB
sensor.ColorStream.Enable(ColorImageFormat.RgbResolution640x480Fps30);

// Associo o evento ao AllFrameReady
sensor.AllFramesReady += new EventHandler<AllFramesReadyEventArgs>(sensor_AllFramesReady);
// Inicio o sensor
sensor.Start();

A diferença entre os dois eventos é: O ColorStreamReady é responsável apenas pelo stream de cores e só será disparado quando o stream de cores tiver disponível, enquanto com AllFrameReady você tem acesso a todos os streams e será disparado depois de que todos os streams tiverem prontos, por isso se tiver um stream que é 15fps e outro 30fps o AllFramesReady será disparada na velocidade do mais lento ( nesse caso 15fps) fazendo você perder alguns ‘pacotes’ se a velocidade for diferente.

E depois disso nós usamos o método Start() para inicializar o Kinect.

Excelente! Antes de prosseguirmos vamos voltar ao modo de design e adicionar uma imagem dentro do grid:

<Grid>
        <Image Height="287" HorizontalAlignment="Left" Margin="12,12,0,0" Name="imgKinect" Stretch="Fill" VerticalAlignment="Top" Width="479" />
</Grid>

Estou chamando ela de imgKinect e ela que irá mostrar o “vídeo” do kinect.

“Mas como uma imagem irá mostrar um vídeo?”  –  Um vídeo é só um conjunto de imagens que passam muito rápidas, e cada vez que o kinect entrar no nosso evento (aproximadamente 30 vezes por segundo) ele atualizará a imagem.

Continuando dentro do design, vamos implementar o evento Unloaded de window:

E dentro do MainWindow.cs vamos implementar esse evento:

 private void Window_Unloaded(object sender, RoutedEventArgs e)
        {
            // Se existir um sensor para ele
            if (sensor != null)
            {
                sensor.Stop();
                sensor.Dispose();
            }
        }

Lembre de sempre desativar o Kinect quando o seu sistema não precisar usar-lo!

Agora só falta uma ultima coisa! Vamos implementar o evento AllFrameReady:

        /// <summary>
        /// A cada vez que o kinect detectar uma imagem ele passará aqui
        /// </summary>
        void sensor_AllFramesReady(object sender, AllFramesReadyEventArgs e)
        {
            // Pego o frame de cor
            using (ColorImageFrame cframe = e.OpenColorImageFrame())
            {
                // Se não vier nada então sai do metodo
                if (cframe == null)
                    return;
                // Array de bytes com o tamanho do frame
                byte[] cbytes = new byte[cframe.PixelDataLength];

                // Copio os bytes para o array de bytes
                cframe.CopyPixelDataTo(cbytes);

                // Numero de bytes por linha / width * (R G B Vazio)
                int stride = cframe.Width * 4;

                // Cria um bitmap baseado nos bytes, passando o tamanho da imagem (640x480), o dpi (no nosso caso é um padrão 96x96 mesmo)
                // passando o formato do pixel (32 bits), a paleta (nulo), os bytes (cbytes) e o stride)
                imgKinect.Source = BitmapImage.Create(640, 480, 96, 96, PixelFormats.Bgr32, null, cbytes, stride);

            }
        }

Detalhe que o Kinect não retorna imagens nem nada bonitinho para gente, apenas bytes e o trabalho de conversão fica sendo todo nosso. Mas mesmo que pareça confuso de inicio você vai ver que  o Kinect SDK não é nenhum bicho de 7 cabeças.

pois é… estamos cortando custos na parte de designer =/

Então eu vou ficar por aqui… Ja estou criando mais artigos ( com videos! ) sobre o kinect e vamos tentar cobrir todas as partes (do mais basico como hoje, ao mais avançado).

Por hoje é só, qualquer duvida, no video eu crio esse projeto do zero e explico ( pelo menos tento) parte por parte.

Espero que tenham entendido, ate mais.

[EDITADO]

Segue a coleção completa de artigos (até agora):

  1. Camera RGB
  2. Camera de Profundidade
  3. Inclinação
  4. Detectando Esqueletos