giovedì 24 luglio 2014

Un milione di ragioni per.....

.....concorrere a Intel RealSense App Challenge 2014!!!

L'Italia (inizialmente esclusa a causa del nostro regime fiscale a dir poco di melma) e' stata ammessa tra le nazioni che possono partecipare all'Intel RealSense App Challenge 2014.

https://software.intel.com/sites/campaigns/realsensechallenge/

Il concorso prevede 1.000.000$ in premio tra contanti e altro!

Si parte lunedi' 28 Luglio 2014, quindi pronti a partecipare. Il concorso prevede diverse fasi. Ci saranno premi anche solamente per le idee sottomesse al concorso!

E, poi, 1.000.000 di ragioni sono sufficienti!!!

lunedì 9 giugno 2014

Intel Software Innovator Program

Ieri ho ricevuto la notizia di essere entrato a far parte dell’Intel Software Innovator Program ed è per me un onore farne parte.

Intel Software Innovator Program è un iniziativa di Intel Software volta a coinvolgere (e premiare) esperti sulle tecnologie Android e Intel Perceptual Computing/Real Sense che si sono distinti in eventi, pubblicazioni e progetti innovativi.

Allo stato attuale dell’arte sono coinvolte 8 nazioni ma il programma verrà esteso ad altre nazioni fino a coprire un gruppo di circa 2000 developer.

Maggiori info sul programma all’indirizzo https://software.intel.com/en-us/blogs/2014/05/28/intel-software-innovators

 

lunedì 26 maggio 2014

Kinect V2: supporto per le Windows Store App

Alla fine di Aprile è stata rilasciata una nuova versione dell’SDK per Kinect V2 e questa porta con se alcune novità interessanti tra le quali spicca il supporto per le Windows Store Apps.

Questo significa che, nel momento in cui il device sarà commercializzato (presumibilmente in estate), potremo cominciare a pubblicare applicazioni WinRT per Windows 8.1 che supportino il Kinect.

In questo post vedremo come utilizzare le API esposte dall’SDK in un contesto Windows Store App.

Per prima cosa, ovviamente, creiamo il nostro progetto Windows Store App:

image

Una volta che il progetto e i file relativi sono stati creati da Visual Studio, abbiamo la necessità di referenziare la dll contenente le classi per la gestione del Kinect.

Questa, a differenza della versione per applicazioni desktop “classiche”, si chiama WindowsPreview.Kinect (invece che Microsoft.Kinect):

image

Rispetto alla versione desktop “classica”, nella versione WinRT possiamo riscontrare due macro differenze:

  • la classe KinectSensor mette a disposizione il metodo statico GetDefault() per recuperare l’istanza di default del device anzichè la proprietà Default;
  • la classe KinectSensor non implementa l’interfaccia IDisposable. Non è necessario, quindi, eseguire il dispose dell’istanza del device alla chiusura per rilasciare correttamente l’istanza..

A parte questo, tutto il resto continua a funzionare allo stesso modo visto nei precedenti post della serie Kinect V2 senza alcuna modifica.

Se abbiamo intenzione di gestire l’interazione con il device utilizzando gli eventi, dobbiamo prestare attenzione a rilasciare in breve tempo i frame recuperati.
Gli eventi, infatti, vengono richiamati nel thread principale dell’applicazione e, questo, facilita l’aggiornamento dell’interfaccia non dovendo eseguire uno switch di contesto tramite il dispatcher. Dobbiamo essere, però, rapidi nella gestione dei dati provenienti dal device stesso per lasciare libero il prima possibile il thread.

Nel seguente esempio di codice gestiamo l’evento MultiSourceFrameArrived per visualizzare nell’interfaccia il frame proveniente dalla sorgente colore:

  1. Private Async Sub FrameArrivedHandler(sender As Object, e As MultiSourceFrameArrivedEventArgs)
  2.     Dim colorFrameProcessed As Boolean = False
  3.     Using frame = e.FrameReference.AcquireFrame()
  4.         If frame IsNot Nothing Then
  5.             Using colorFrame = frame.ColorFrameReference.AcquireFrame()
  6.                 If colorFrame IsNot Nothing Then
  7.                     CameraSettings = colorFrame.ColorCameraSettings
  8.                     ColorFrameDescription = colorFrame.FrameDescription
  9.                     If ColorFrameDescription.Width = CInt(Bitmap.PixelWidth) _
  10.                         And ColorFrameDescription.Height = CInt(Bitmap.PixelHeight) Then
  11.  
  12.                         If colorFrame.RawColorImageFormat = ColorImageFormat.Bgra Then
  13.                             colorFrame.CopyRawFrameDataToArray(Me.ColorPixels)
  14.                         Else
  15.                             colorFrame.CopyConvertedFrameDataToArray(Me.ColorPixels, ColorImageFormat.Bgra)
  16.                         End If
  17.                         colorFrameProcessed = True
  18.                     End If
  19.                 End If
  20.             End Using
  21.         End If
  22.     End Using
  23.  
  24.     If colorFrameProcessed Then
  25.         Await DrawImage(ColorPixels)
  26.     End If
  27. End Sub

Osserviamo che il recupero dei dati colore viene eseguito il piu’ velocemente possibile e, solo dopo aver rilasciato il frame, viene creata l’immagine da proporre a video utilizzando un metodo asincrono.

  1. Private Async Function DrawImage(pixels As Byte()) As Task
  2.     ColorPixelStream.Seek(0, SeekOrigin.Begin)
  3.     Await ColorPixelStream.WriteAsync(pixels, 0, pixels.Length)
  4.     Bitmap.Invalidate()
  5. End Function

Il fatto che la dll contenente le classi utilizzabili per gestire il Kinect si chiami WindowsPreview fa presagire che qualcosa potrebbe cambiare prima del rilascio definitivo (che dovrebbe avvenire con la messa in commercio del sensore) ma, d’altro canto la possibilità di usare il Kinect per applicazioni NUI immersive in Windows 8.1 solletica la fantasia e apre nuovi scenari che, allo stato attuale, altri device dello stesso tipo non permettono.

 

lunedì 28 aprile 2014

Intervista Codemotion su HTML.it

Come di consuetudine, durante l’evento Codemotion, vengono registrate diverse interviste da parte di HTML.it che coinvolgono gli speaker e i presidenti delle community italiane.
Questa e’ la mia intervista su Kinect e le applicazioni NUI.

Link al video


domenica 13 aprile 2014

Codemotion Roma 2014 : le slide

Venerdì e sabato si è svolta la tappa romana di Codemotion 2014. Due giorni ricchi di incontri, formazione e nuove cosa da apprendere.

La mia sessione, dedicata interamente alle nuove funzionalità di Kinect, ha visto una buona affluenza di pubblico con tante domande e un interesse crescente verso questo genere di dispositivi e delle loro possibili applicazioni.

Se volete scaricare le slide utilizzate il link.

Alla prossima!!! Thumbs up

 

lunedì 7 aprile 2014

Kinect V2: MultiFrameSource

Nei precedenti post abbiamo dato un’occhiata alle varie sorgenti messe a disposizione dalla nuova versione del Kinect.

Abbiamo visto come sia possibile recuperare il reader opportuno e sfruttare tale reader per ottenere i singoli frame desiderati.

Nella stragrande maggioranza delle applicazioni, però, abbiamo la necessità di elaborare più sorgenti contemporaneamente (basti pensare, ad esempio ad una applicazione che rileva il body del giorcatore e contemporaneamente mostra l’immagine proveniente dalla cam).

In questo caso, l’SDK ci viene in aiuto mettendoci a disposizione una sorgente particolare della MultiFrameSource.

L’utilizzo di questo tipo particolare di sorgente si differenzia rispetto all’utilizzo delle altre sorgenti “singole”. Le sorgenti singole sono esposte direttamente, tramite delle proprietà, dalla classe KinectSensor. Una volta ottenuta la reference alla sorgente, possimao utilizzare il metodo OpenReader per avere a disposizione il reader che, effettivamente, ci permette di consumare i dati.

Nel caso della MultiFrameSource, questa non è direttamente accessibile tramite la classe KinectSensor, ma quest’ultima ci fornisce un metodo (il metodo OpenMultiSourceFrameReader() ) per aprire il reader opportuno.

Sensor = KinectSensor.Default
If Sensor IsNot Nothing Then
    Sensor.Open()
    MultiReader = Sensor.OpenMultiSourceFrameReader(FrameSourceTypes.Color Or
                                                    FrameSourceTypes.BodyIndex Or
                                                    FrameSourceTypes.Body)
End If

Nel precedente pezzo di codice osserviamo che il metodo OPenMultiSourceFrameReader accetta come argomento l’elenco delle sorgenti a cui siamo effettivamente interessati (enumerazione FrameSourceTypes):

image

Una volta ottenuto il reader, il procedimento con cui elaboriamo i frame provenienti dal device è analogo a quello delle altre sorgenti.

Il reader espone il metodo MultiSourceFrameArrived che possiamo gestire e che viene richiamato ogni volta che il frame è disponibile per l’eleborazione:

If MultiReader IsNot Nothing Then
    AddHandler MultiReader.MultiSourceFrameArrived, AddressOf MultiSourceFrameArrivedHandler
End If

L’argomento fornito dal metodo (di tipo MultiSourceFrameArrivedEventArgs) espone, in maniera analoga a quanto fanno i corrispettivi argomenti forniti dagli altri metodi di gestione dei frame, una proprietà, di tipo MultiSourceFrameReference.
Ancora una volta, come per gli altri source reference, abbiamo a disposizione il metodo AcquireFrame() per recuperare, effettivamente il frame.

image

L’istanza di MultiSourceFrame espone le reference ai singoli frame il cui utilizzo è già stato trattato nei precedenti post.

Nel seguente pezzo di codice, ad esempio, andiamo a gestire l’immagine proveniente dal device, i body e il body index:

Private Sub MultiSourceFrameArrivedHandler(sender As Object, e As MultiSourceFrameArrivedEventArgs)
    Dim frameReference = e.FrameReference
    Dim frame As MultiSourceFrame = Nothing
    Try
        frame = frameReference.AcquireFrame()
        If frame IsNot Nothing Then
            Using dc = DrawingGroup.Open()
                DrawColorImage(frame, dc)

                DrawBody(frame, dc)

                DrawPlayerIndex(frame, dc)
            End Using
        End If
    Catch ex As Exception

    Finally
        If frame IsNot Nothing Then frame.Dispose()
    End Try
End Sub

Il codice per la gestione dell’immagine è, come possiamo vedere, del tutto simile a quello visto nel precedente post.

Private Sub DrawColorImage(ByVal frame As MultiSourceFrame, dc As DrawingContext)
    If frame Is Nothing Then Return
    Using colorFrame = frame.ColorFrameReference.AcquireFrame()
        If colorFrame IsNot Nothing Then
            If colorFrame.RawColorImageFormat = ColorImageFormat.Bgra Then
                colorFrame.CopyRawFrameDataToArray(Me.ColorData)
            Else
                colorFrame.CopyConvertedFrameDataToArray(Me.ColorData, ColorImageFormat.Bgra)
            End If

            Dim bitmap = New WriteableBitmap(colorFrame.FrameDescription.Width, colorFrame.FrameDescription.Height,
                                             96.0, 96.0, PixelFormats.Bgr32, Nothing)
            bitmap.WritePixels(New Int32Rect(0, 0, colorFrame.FrameDescription.Width, colorFrame.FrameDescription.Height),
                               Me.ColorData,
                               colorFrame.FrameDescription.Width * BytesPerPixel,
                               0)

            dc.DrawImage(bitmap, New System.Windows.Rect(0, 0, colorFrame.FrameDescription.Width, colorFrame.FrameDescription.Height))
        End If
    End Using
End Sub

Le reference ai frame che non abbiamo selezionato in fase di apertura del reader non sono valorizzati.

 

Technorati Tags: ,,,

mercoledì 2 aprile 2014

Windows Store App: dalla build allo Store

Vi segnalo un mio articolo comparso su HTML.it riguardante il processo di pubblicazione di una app Windows Store.

Potete trovare la versione per C# e XAML all’indirizzo:

http://www.html.it/pag/47817/windows-store-app-dalla-build-allo-store-2/

Esiste anche una versione HTML+WinJS all’indirizzo:

http://www.html.it/pag/47756/windows-store-app-dalla-build-allo-store/

 

Buona lettura!!

 

lunedì 31 marzo 2014

Kinect V2 : Body stream – Activities, Appearance e Expressions

In questo post prenderemo alcune nuove funzionalità messe a disposizione dall’SDK del Kinect 2 e che riguardano il modo di apparire e di porsi dell’utente davanti al device.

La classe Body, vista in dettaglo nel precedente post, ci permette di accedere ad alcune caratteristiche “dinamiche” del singolo player che si pone davanti al device.

In particolare abbiamo a disposizione:

  • Activities : ci dicono cosa sta facendo il player. Ad esempio se ha l’occhio destro chiuso o se ha la bocca aperta;
  • Appearance : come appare l’utente. Ad esempio se indossa gli occhiali;
  • Expressions : le espressioni che l’utente assume. Ad esempio se sta ridendo.

La classe Body espone tre Dictionary che contengono le tre caratteristiche elencate in precedenza:

image

La proprietà Activities è un Dictionary (a sola lettura) con chiave uno dei valori dell’enumerazione Activity e valore l’enumerazione DetectionResult.
Le altre due collezioni funzionano in maniera del tutto analoga cambiando esclusivamente l’enumerazione chiave.

In questo momento abbiamo le seguenti Activity:

  • EyeLeftClosed : il player ha l’occhio sinistro chiuso;
  • EyeRightClosed : il player ha l’occhio destro chiuso;
  • LookingAway : il player non sta guardando il sensore;
  • MouthMoved : il player sta muovendo la bocca;
  • MouthOpen : il player ha la bocca aperta.

Se interroghiamo la proprietà Acivities con uno dei valori di enumerazione precedente, otteniamo un oggetto di tipo DetectionResult i cui valori ci permettono di capire se l’activity in esame è attiva o meno o potrebbe esserlo (MayBe).

Le Expression che abbiamo a disposizione in questo momento sono:

  • Happy : il player ha un espressione allegra (ad esempio sta ridendo);
  • Neutral : il player non ha nessuna espressione particolare.

Infine, per quanto riguarda le Appearance, in questo momento, abbiamo solo la WearingGlass che ci dice se il player porta gli occhiali.

 

Disclaimer: “This is preliminary software and/or hardware and APIs are preliminary and subject to change.”

 

Technorati Tags: ,,

lunedì 24 marzo 2014

Kinect V2 : body stream – hand tracking

In questo post continuiamo l’analisi delle informazioni forniteci dallo stream body del Kinect V2 prendendo in esame la funzionalità di tracking delle mani dei player.

Le funzionalità di tracking delle mani dei player sono accessibili grazie alla classe Body vista nel precedente post.

In particolare la classe Body espone due proprietà per ogni mano:

  • HandRighState, HandLeftState: permette di conoscere lo stato della mano ovvero se la mano è non tracciata, aperta, chiusa o con le dita a V oppure se l’SDK non è riuscito a riconoscerla;
  • HandRghtConfience, HandeLeftConfidence: indica la confidence (low o high) dello stato della mano.

image

Possiamo, quindi, utilizzare queste proprietà per prendere decisioni in base allo stato della mano o delle mani del player.

A livello di codice abbiamo la necessità di inizializzare il device e gestire la sorgente Body in maniera analoga a quanto visto nel precedente post:

Sensor = KinectSensor.Default
If Sensor IsNot Nothing Then
    Sensor.Open()

    BodyData = New Body(CInt(Sensor.BodyFrameSource.BodyCount - 1)) {}
    
    BodyReader = Sensor.BodyFrameSource.OpenReader()
End If

dove

Private Property Sensor As KinectSensor
Private Property BodyReader As BodyFrameReader
Private Property BodyData As Body()

Per ricevere i frame riguardanti i Body rilevati dal device dobbiamo gestire l’evento FrameArrived del BodyReader:

If BodyReader IsNot Nothing Then
    AddHandler BodyReader.FrameArrived, AddressOf BodyFrameArrivedHandler
End If

E, quindi, possiamo recuperare la collezione di Body:

Private Sub BodyFrameArrivedHandler(sender As Object, e As BodyFrameArrivedEventArgs)
    Dim frameReference = e.FrameReference
    Dim frame As BodyFrame = Nothing
    Try
        frame = frameReference.AcquireFrame()
        If frame IsNot Nothing Then
            frame.GetAndRefreshBodyData(BodyData)
            OnPropertyChanged("Player0HandRightState")
            OnPropertyChanged("Player0HandLeftState")
            OnPropertyChanged("Player0HandRightConfidence")
            OnPropertyChanged("Player0HandLeftConfidence")
        End If
    Catch ex As Exception

    Finally
        If frame IsNot Nothing Then
            frame.Dispose()
        End If
    End Try
End Sub

Supponiamo di avere un’applicazione WPF e di voler semplicemente visualizzare lo stato delle mani con immagini differenti e la confidence con un differente valore di opacità (senza necessariamente dover visualizzare la mano nella posizione spaziale in cui si trova).

Per fare questo, esponeniamo le 4 proprietà riguardanti lo stato e la confidence delle mani del player con indice 0:

Public ReadOnly Property Player0HandRightState As HandState
    Get
        Return GetHandStateForPlayer(0, Hand.Right)
    End Get
End Property

Public ReadOnly Property Player0HandLeftState As HandState
    Get
        Return GetHandStateForPlayer(0, Hand.Left)
    End Get
End Property

Public ReadOnly Property Player0HandRightConfidence As TrackingConfidence
    Get
        Return GetHandConfidenceForPlayer(0, Hand.Right)
    End Get
End Property

Public ReadOnly Property Player0HandLeftConfidence As TrackingConfidence
    Get
        Return GetHandConfidenceForPlayer(0, Hand.Left)
    End Get
End Property

 

Private Function GetHandStateForPlayer(playerIndex As Int16, hand As Hand) As HandState
    If playerIndex < 0 Or playerIndex > 5 Then Throw New ArgumentOutOfRangeException

    If BodyData(playerIndex) Is Nothing Then Return HandState.NotTracked
    Select Case hand
        Case MainWindowViewModel.Hand.Left
            Return BodyData(playerIndex).HandLeftState
        Case MainWindowViewModel.Hand.Right
            Return BodyData(playerIndex).HandRightState
    End Select
    Throw New NotImplementedException()
End Function

Private Function GetHandConfidenceForPlayer(playerIndex As Int16, hand As Hand) As TrackingConfidence
    If playerIndex < 0 Or playerIndex > 5 Then Throw New ArgumentOutOfRangeException

    If BodyData(playerIndex) Is Nothing Then Return TrackingConfidence.Low
    Select Case hand
        Case MainWindowViewModel.Hand.Left
            Return BodyData(playerIndex).HandLeftConfidence
        Case MainWindowViewModel.Hand.Right
            Return BodyData(playerIndex).HandRightConfidence
    End Select
    Throw New NotImplementedException()
End Function

e le mettiamo in binding con la nostra interfaccia:

<TextBlock Grid.Row="1" Grid.Column="0" HorizontalAlignment="Right" VerticalAlignment="center" FontWeight="Bold" FontSize="24">Player 0</TextBlock>
<Image Grid.Row="1" Grid.Column="1" Width="64" Height="64"
       Source="{Binding Path=Player0HandRightState, Converter={StaticResource ResourceKey=HandStateConverter}, ConverterParameter=Right}"
       Opacity="{Binding Path=Player0HandRightConfidence, Converter={StaticResource ResourceKey=HandConfidenceConverter}}"
       Margin="20,10,20,10"/>
<Image Grid.Row="1" Grid.Column="2" Width="64" Height="64"
       Source="{Binding Path=Player0HandLeftState, Converter={StaticResource ResourceKey=HandStateConverter}, ConverterParameter=Left}"
       Opacity="{Binding Path=Player0HandLeftConfidence, Converter={StaticResource ResourceKey=HandConfidenceConverter}}"
       Margin="20,10,20,10"/>

Nel precedente XAML sfruttiamo due converter che, rispetivamente, selezionano l’immagine da visualizzare e decidono l’opacità della stessa:

Public Class HandStateToImageConverter
    Implements IValueConverter

    Public Function Convert(value As Object, targetType As Type, parameter As Object, culture As Globalization.CultureInfo) As Object Implements IValueConverter.Convert
        If TypeOf value Is HandState And TypeOf parameter Is String Then
            Dim handString = parameter.ToString()
            Return GetImageForHandState(CType(value, HandState), handString)
        End If
        Return Nothing
    End Function

    Public Function ConvertBack(value As Object, targetType As Type, parameter As Object, culture As Globalization.CultureInfo) As Object Implements IValueConverter.ConvertBack
        Throw New NotImplementedException()
    End Function

    Private Function GetImageForHandState(state As HandState, hand As String) As ImageSource
        Dim uriString As String = Nothing
        Select Case state
            Case HandState.Closed
                uriString = String.Format("./Assets/{0}HandClose.png", hand)
            Case HandState.Lasso
                uriString = String.Format("./Assets/{0}HandLasso.png", hand)
            Case HandState.Open
                uriString = String.Format("./Assets/{0}HandOpen.png", hand)
            Case HandState.Unknown
                uriString = "./Assets/UnknowState.png"
        End Select
        If uriString IsNot Nothing Then
            Dim bitmap = New BitmapImage(New Uri(uriString, UriKind.RelativeOrAbsolute))
            Return bitmap
        Else
            Return Nothing
        End If
    End Function
End Class

Public Class HandConfidenceToOpacityConverter
    Implements IValueConverter

    Public Function Convert(value As Object, targetType As Type, parameter As Object, culture As Globalization.CultureInfo) As Object Implements IValueConverter.Convert
        If TypeOf value Is TrackingConfidence Then
            Dim confidence = CType(value, TrackingConfidence)
            Select Case confidence
                Case TrackingConfidence.High
                    Return 1
                Case TrackingConfidence.Low
                    Return 0.5
                Case Else
                    Return 0
            End Select
        End If
        Return Nothing
    End Function

    Public Function ConvertBack(value As Object, targetType As Type, parameter As Object, culture As Globalization.CultureInfo) As Object Implements IValueConverter.ConvertBack
        Throw New NotImplementedException()
    End Function
End Class

Il primo converter agisce su un oggetto di tipo HandState e si aspetta un parametro stringa che indica di quale mano si tratta, mentre il secondo agisce su un oggetto di tipo TrackingConfidence.

Come possiamo vedere, una volta a disposizione l’istanza di Body, è relativamente semplice capire quale è lo stato delle mani dei singoli player.

Attualmente, l’SDK del Kinect è in grado di tracciare, per quanto riguarda le mani, solo due player (di default il player 0 ed il player 1). Possiamo modificare qualli player vengono tracciati grazie al metodo OverrideHandTracking() esposto dalla sorgente Body.

Disclaimer: “This is preliminary software and/or hardware and APIs are preliminary and subject to change.”

 

Technorati Tags: ,,