var _sensor = KinectSensor.GetDefault();
if (!_sensor.IsOpen)
	_sensor.Open();

var source = _sensor.ColorFrameSource;
var description = source.CreateFrameDescription(ColorImageFormat.Bgra);
var width = description.Width;
var height = description.Height;
Il suffit ensuite d’initialiser un WriteableBitmap et l’assigner à un contrôle Image nommé myImage 
_bitmap = new WriteableBitmap(width, height);
myImage.Source = _bitmap;
La suite consiste logiquement à acquérir le reader du flux courant, l’ouvrir et s’abonner à l’évènement FrameArrived comme suit :
_colorReader = source.OpenReader();
_colorReader.FrameArrived += Reader_FrameArrived;

private void Reader_FrameArrived(ColorFrameReader sender, ColorFrameArrivedEventArgs args)
{
	using (var frame = args.FrameReference.AcquireFrame())
	{
		if (frame == null) return;
		frame.CopyConvertedFrameDataToBuffer(_bitmap.PixelBuffer, ColorImageFormat.Bgra);
		_bitmap.Invalidate();
	}
}

private void StopCurrentDemo()
{
	if (_colorReader != null)
	{
		_colorReader.FrameArrived -= Reader_FrameArrived;
_colorReader.Dispose();
_colorReader = null;
	}
	myImage.Source = null;
	_bitmap = null;
}

var source = _sensor.InfraredFrameSource;
var description = source.FrameDescription;
var width = description.Width;
var height = description.Height;
_bitmap = new WriteableBitmap(width, height);:
_infraredBuffer = new ushort[description.LengthInPixels];
On stockera le pixel sous forme de byte au format BGRA (où la constante BGRA_BYTES_PER_PIXEL vaut 4) :
_bitmapIntermediateBuffer = new byte[width * height * BGRA_BYTES_PER_PIXEL];

private void Reader_FrameArrived(InfraredFrameReader sender, InfraredFrameArrivedEventArgs args)
{
	using (var frame = args.FrameReference.AcquireFrame())
	{
		if (frame == null) return;
		frame.CopyFrameDataToArray(_infraredBuffer);
		//suite ici...
		_bitmap.Invalidate();
	}
}

for (var i = 0; i < _infraredBuffer.Length; ++i)
{
	var intensity = _infraredBuffer[i];
	const float CONTRAST = 1.2F;
	var color = (byte)((intensity + CONTRAST * intensity) * byte.MaxValue / short.MaxValue);
	var j = i * BGRA_BYTES_PER_PIXEL;
	_bitmapIntermediateBuffer[j + 0] = color; //blue
	_bitmapIntermediateBuffer[j + 1] = color; //green
	_bitmapIntermediateBuffer[j + 2] = color; //red
	_bitmapIntermediateBuffer[j + 3] = byte.MaxValue; //alpha
}

var source = _sensor.DepthFrameSource;
var description = source.FrameDescription;
var width = description.Width;
var height = description.Height;
_bitmap = new WriteableBitmap(width, height);
_bitmapIntermediateBuffer = new byte[width * height * BGRA_BYTES_PER_PIXEL];
_depthBuffer = new ushort[description.LengthInPixels];
myImage.Source = _bitmap;
_depthReader = source.OpenReader();
_depthReader.FrameArrived += Reader_FrameArrived;

private void Reader_FrameArrived(DepthFrameReader sender, DepthFrameArrivedEventArgs args)
{
	using (var frame = args.FrameReference.AcquireFrame())
	{
		if (frame == null) return;
		frame.CopyFrameDataToArray(_depthBuffer);
		for (var i = 0; i < _depthBuffer.Length; ++i)
		{
			var depth = _depthBuffer[i]; 
			var color = (byte)(depth * byte.MaxValue / 8000);
			var j = i * BGRA_BYTES_PER_PIXEL;
			_bitmapIntermediateBuffer[j + 0] = color; // blue
			_bitmapIntermediateBuffer[j + 1] = color; // green
			_bitmapIntermediateBuffer[j + 2] = color; // red
			_bitmapIntermediateBuffer[j + 3] = byte.MaxValue; //alpha 
		}
		_bitmapIntermediateBuffer.CopyTo(_bitmap.PixelBuffer);
		_bitmap.Invalidate();
	}
}

var source = _sensor.BodyIndexFrameSource;
var description = source.FrameDescription;
var width = description.Width;
var height = description.Height;
_bitmap = new WriteableBitmap(width, height);
_bitmapIntermediateBuffer = new byte[width * height * BGRA_BYTES_PER_PIXEL];
_bodyIndexBuffer = new byte[description.LengthInPixels];

myImage.Source = _bitmap;
_bodyIndexReader = source.OpenReader();
_bodyIndexReader.FrameArrived += Reader_FrameArrived;

private void Reader_FrameArrived(BodyIndexFrameReader sender, BodyIndexFrameArrivedEventArgs args)
{
	using (var frame = args.FrameReference.AcquireFrame())
	{
		if (frame == null) return;
		frame.CopyFrameDataToArray(_bodyIndexBuffer);
		for (var i = 0; i < _bodyIndexBuffer.Length; ++i)
		{
			var j = i * BGRA_BYTES_PER_PIXEL;
			var index = _bodyIndexBuffer[i];
			if (index == 0)
			{
				var color = _bodyIndexColors[index];
				_bitmapIntermediateBuffer[j + 0] = (byte)(255);	// blue
				_bitmapIntermediateBuffer[j + 1] = (byte)(0);	// green
				_bitmapIntermediateBuffer[j + 2] = (byte)(0);	// red
				_bitmapIntermediateBuffer[j + 3] = (byte)(0);	// alpha 
			}
			else
			{
				_bitmapIntermediateBuffer[j + 0] = 0; // blue
				_bitmapIntermediateBuffer[j + 1] = 0; // green
				_bitmapIntermediateBuffer[j + 2] = 0; // red
				_bitmapIntermediateBuffer[j + 3] = 0; // alpha 
			}
		}
		_bitmapIntermediateBuffer.CopyTo(_bitmap.PixelBuffer);
		_bitmap.Invalidate();
	}
}

public class JointModel : INotifyPropertyChanged
{
    private double _x;
    private double _y;
    private JointType _type;
    private bool _isTracked; 
    private Color _color = Colors.Red;

    public double X
    {
        get { return _x; }
        set { Set(ref _x, value); }
    }

    public double Y
    {
        get { return _y; }
        set { Set(ref _y, value); }
    }

    public double Width
    {
        get { return 40; }
    }

    public double Height
    {
        get { return Width; }
    }

    public JointType Type
    {
        get { return _type; }
        set
        {
            if (Set(ref _type, value))
            {
                if (PropertyChanged != null)
                    PropertyChanged(this, new PropertyChangedEventArgs("Label"));
            }
        }
    }

    public string Label
    {
        get { return Type.ToString(); }
    }

    public bool IsTracked
    {
        get { return _isTracked; }
        set
        {
            if (Set(ref _isTracked, value))
            {
                if (PropertyChanged != null)
                    PropertyChanged(this, new PropertyChangedEventArgs("Visibility"));
            }
        }
    }
    public Visibility Visibility
    {
        get { return IsTracked ? Visibility.Visible : Visibility.Collapsed; }
    }

    public Color Color
    {
        get { return _color; }
        set { Set(ref _color, value); }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    private bool Set<T>(ref T prop, T value, [CallerMemberName] string propertyName = null)
    {
        if (Equals(prop, value)) return false;
        prop = value;
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        return true;
    }
}

var source = _sensor.BodyFrameSource;
_bodies = new Body[source.BodyCount]; // BodyCount == 6
var totalJointCount = source.BodyCount * JOINTS_PER_BODY;
_joints = new List<JointModel>(totalJointCount);
for (var i = 0; i < totalJointCount; i++)
    _joints.Insert(i, new JointModel { IsTracked = false , Type = (JointType)(i % JOINTS_PER_BODY) });
SceneWidth = _sensor.ColorFrameSource.FrameDescription.Width;
SceneHeight = _sensor.ColorFrameSource.FrameDescription.Height;
if (PropertyChanged != null)
{
    PropertyChanged(this, new PropertyChangedEventArgs(nameof(SceneWidth)));
    PropertyChanged(this, new PropertyChangedEventArgs(nameof(SceneHeight)));
}

_bodyReader = source.OpenReader();
_bodyReader.FrameArrived += Reader_FrameArrived;

public event PropertyChangedEventHandler PropertyChanged;
private const int JOINTS_PER_BODY = 25;
public double SceneWidth { get; set; }
public double SceneHeight { get; set; }
private List<JointModel> _joints;
public List<JointModels> Joints
{
    get { return _joints; }
}

using (var frame = args.FrameReference.AcquireFrame())
{
    if (frame == null) return;
    frame.GetAndRefreshBodyData(_bodies);
    var bodyCount = frame.BodyCount;
    for (var i = 0; i < bodyCount; i++)
    {
        var body = _bodies[i];
        //...
    }
}

if (!body.IsTracked)
{
    for (var j = 0; j < JOINTS_PER_BODY; j++)
        _joints[i * JOINTS_PER_BODY + j].IsTracked = false;
    continue;
}

var mapper = frame.BodyFrameSource.KinectSensor.CoordinateMapper;
for (var j = 0; j < JOINTS_PER_BODY; j++)
{
    var bodyJoint = body.Joints[(JointType)j];
    var uiJoint = _joints[i * JOINTS_PER_BODY + j];
    uiJoint.IsTracked = bodyJoint.TrackingState != TrackingState.NotTracked;
    if (uiJoint.IsTracked)
    {
        var pos = mapper.MapCameraPointToColorSpace(bodyJoint.Position);
        uiJoint.X = pos.X;
        uiJoint.Y = pos.Y;
    }
}

<Viewbox Stretch="Uniform">
    <ItemsControl ItemsSource="{Binding ElementName=Self, Path=Joints}">
        <ItemsControl.ItemsPanel>
            <ItemsPanelTemplate>
                <Canvas Width="{Binding ElementName=Self, Path=SceneWidth}"
                        Height="{Binding ElementName=Self, Path=SceneHeight}" />
            </ItemsPanelTemplate>
        </ItemsControl.ItemsPanel>
        <ItemsControl.ItemTemplate>
            <DataTemplate>
                <Grid Visibility="{Binding Visibility}">
                    <Ellipse Width="{Binding Width}"
                             Height="{Binding Height}"
                             VerticalAlignment="Top"
                             HorizontalAlignment="Left" />
                        <Ellipse.Fill>
                            <SolidColorBrush Color="{Binding Color}" />
                        </Ellipse.Fill>
                    </Ellipse>
                    <TextBlock Text="{Binding Label}"
                               Margin="30"/>
                    <Grid.RenderTransform>
                        <TranslateTransform X="{Binding X}"
                                            Y="{Binding Y}" />
                    </Grid.RenderTransform>
                </Grid>
            </DataTemplate>
        </ItemsControl.ItemTemplate>
    </ItemsControl>
</Viewbox>

public double Width
{
    get
    {
        return Type == JointType.HandLeft || Type == JointType.HandRight
          ? 40
          : 20;
    }
}

if (uiJoint.IsTracked)
{
    if (uiJoint.Type == JointType.HandLeft)
        uiJoint.Color = HandStateToColor(body.HandLeftState);

    if (uiJoint.Type == JointType.HandRight)
        uiJoint.Color = HandStateToColor(body.HandRightState);

    var pos = mapper.MapCameraPointToColorSpace(bodyJoint.Position);
    uiJoint.X = pos.X - uiJoint.Width / 2;
    uiJoint.Y = pos.Y - uiJoint.Height / 2;
}

return state == HandState.Closed
    ? Colors.Yellow
    : state == HandState.Open
        ? Colors.Green
        : state == HandState.Lasso
            ? Colors.Blue
            : state == HandState.Unknown
                ? Colors.Gray
                : Colors.Transparent;