CUBEMAP

#include<stdio.h>
#include<stdlib.h>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <windows.h>
#include <C:\Program Files (x86)\CodeBlocks\MinGW\include\GL\glut.h>
#include <math.h>
#define PI 3.14159

using namespace std;


int HL=1,angx=30,angy=60;
unsigned char * datos;

float a;

int an1=512,al1=512;//dim imagenes, ancho, alto
unsigned char * imagen1;
unsigned char * imagen2;
unsigned char * imagen3;
unsigned char * imagen4;
unsigned char * imagen5;
unsigned char * imagen6;


int leerImagen1(){
    FILE *imagen;
    imagen=fopen("/Users/Juan/Desktop/cube/negy.RAW","r");
    imagen1=(unsigned char*)malloc(an1*al1*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagen1,an1*al1*3,1,imagen);
    fclose(imagen);
    return 1;
}
int leerImagen2(){
    FILE *imagen;
    imagen=fopen("/Users/Juan/Desktop/cube/negx.RAW","r");
    imagen2=(unsigned char*)malloc(an1*al1*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagen2,an1*al1*3,1,imagen);
    fclose(imagen);
    return 1;
}
int leerImagen3(){
    FILE *imagen;
    imagen=fopen("/Users/Juan/Desktop/cube/negz.RAW","r");
    imagen3=(unsigned char*)malloc(an1*al1*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagen3,an1*al1*3,1,imagen);
    fclose(imagen);
    return 1;
}
int leerImagen4(){

    FILE *imagen;
    imagen=fopen("/Users/Juan/Desktop/cube/posz.RAW","r");
    imagen4=(unsigned char*)malloc(an1*al1*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagen4,an1*al1*3,1,imagen);
    fclose(imagen);
    return 1;
}
int leerImagen5(){
    FILE *imagen;
    imagen=fopen("/Users/Juan/Desktop/cube/posx.RAW","r");
    imagen5=(unsigned char*)malloc(an1*al1*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagen5,an1*al1*3,1,imagen);
    fclose(imagen);
    return 1;
}
int leerImagen6(){
    FILE *imagen;
    imagen=fopen("/Users/Juan/Desktop/cube/posy.RAW","r");
    imagen6=(unsigned char*)malloc(an1*al1*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagen6,an1*al1*3,1,imagen);
    fclose(imagen);
    return 1;
}

void texturaI1(void)
{
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, an1, al1, 0, GL_RGB, GL_UNSIGNED_BYTE, imagen1);
}
void texturaI2(void)
{
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, an1, al1, 0, GL_RGB, GL_UNSIGNED_BYTE, imagen2);
}
void texturaI3(void)
{
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, an1, al1, 0, GL_RGB, GL_UNSIGNED_BYTE, imagen3);
}
void texturaI4(void)
{
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, an1, al1, 0, GL_RGB, GL_UNSIGNED_BYTE, imagen4);
}
void texturaI5(void)
{
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, an1, al1, 0, GL_RGB, GL_UNSIGNED_BYTE, imagen5);
}
void texturaI6(void)
{
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, an1, al1, 0, GL_RGB, GL_UNSIGNED_BYTE, imagen6);
}

void dibujaI1(void)//PISO
{
    glDisable(GL_LIGHTING);
    glColor3f(1,1,1);
    glBegin(GL_QUADS);
    glTexCoord3f(0.0, 1.0,0.0);
    glVertex3f(-100,-100,100);
    glTexCoord3f(0.0, 0.0,0.0);
    glVertex3f(-100,-100,-100);
    glTexCoord3f(1.0, 0.0,0.0);
    glVertex3f(100,-100,-100);
    glTexCoord3f(1.0, 1.0,0.0);
    glVertex3f(100,-100,100);
    glEnd();
    glEnable(GL_LIGHTING);
}

void dibujaI2(void)//negx
{
    glDisable(GL_LIGHTING);
    glColor3f(1,1,1);
    glBegin(GL_QUADS);
    glTexCoord3f(0.0, 1.0,0.0);
    glVertex3f(-100,-100,100);
    glTexCoord3f(0.0, 0.0,0.0);
    glVertex3f(-100,100,100);
    glTexCoord3f(1.0, 0.0,0.0);
    glVertex3f(-100,100,-100);
    glTexCoord3f(1.0, 1.0,0.0);
    glVertex3f(-100,-100,-100);
    glEnd();
    glEnable(GL_LIGHTING);
}

void dibujaI3(void)//negz
{
    glDisable(GL_LIGHTING);
    glColor3f(1,1,1);
    glBegin(GL_QUADS);
    glTexCoord3f(0.0, 1.0,0.0);
    glVertex3f(100,-100,100);
    glTexCoord3f(0.0, 0.0,0.0);
    glVertex3f(100,100,100);
    glTexCoord3f(1.0, 0.0,0.0);
    glVertex3f(-100,100,100);
    glTexCoord3f(1.0, 1.0,0.0);
    glVertex3f(-100,-100,100);
    glEnd();
    glEnable(GL_LIGHTING);
}

void dibujaI4(void)
{
    glDisable(GL_LIGHTING);
    glColor3f(1,1,1);
    glBegin(GL_QUADS);
    glTexCoord3f(0.0, 1.0,0.0);
    glVertex3f(-100,-100,-100);
    glTexCoord3f(0.0, 0.0,0.0);
    glVertex3f(-100,100,-100);
    glTexCoord3f(1.0, 0.0,0.0);
    glVertex3f(100,100,-100);
    glTexCoord3f(1.0, 1.0,0.0);
    glVertex3f(100,-100,-100);
    glEnd();
    glEnable(GL_LIGHTING);
}

void dibujaI5(void)
{
    glDisable(GL_LIGHTING);
    glColor3f(1,1,1);
    glBegin(GL_QUADS);
    glTexCoord3f(0.0, 1.0,0.0);
    glVertex3f(100,-100,-100);
    glTexCoord3f(0.0, 0.0,0.0);
    glVertex3f(100,100,-100);
    glTexCoord3f(1.0, 0.0,0.0);
    glVertex3f(100,100,100);
    glTexCoord3f(1.0, 1.0,0.0);
    glVertex3f(100,-100,100);
    glEnd();
    glEnable(GL_LIGHTING);
}

void dibujaI6(void)
{
    glDisable(GL_LIGHTING);
    glColor3f(1,1,1);
    glBegin(GL_QUADS);
    glTexCoord3f(0.0, 1.0,0.0);
    glVertex3f(-100,100,-100);
    glTexCoord3f(0.0, 0.0,0.0);
    glVertex3f(-100,100,100);
    glTexCoord3f(1.0, 0.0,0.0);
    glVertex3f(100,100,100);
    glTexCoord3f(1.0, 1.0,0.0);
    glVertex3f(100,100,-100);
    glEnd();
    glEnable(GL_LIGHTING);
}

void display(void)
{
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_MODELVIEW);

    GLfloat mat_specular[]={1.0,1.0,1.0,1.0};
    GLfloat mat_shininess[]={50.0};
    GLfloat mat_diff[]={1.0,0.5,0.0,0.5};

    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_diff);

glPushMatrix();
    glRotatef(a, 0, 1, 0);
    glColor3f(1,1,1);

    glPushMatrix();
            texturaI1();
            dibujaI1();
            texturaI2();
            dibujaI2();
            texturaI3();
            dibujaI3();
            texturaI4();
            dibujaI4();
            texturaI5();
            dibujaI5();
            texturaI6();
            dibujaI6();
    glPopMatrix();

    glPushMatrix();//TETERA
        glColor3f(1.0, 1.0, 1.0);
        glTranslated(0.0,10,0);
        glutSolidTeapot(2);
    glPopMatrix();
glPopMatrix();
    a += 0.3;
    glutSwapBuffers();
}

void myReshape(int w, int h)
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective( 90.0, (GLdouble)w/(GLdouble)h, 0.1,200.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(0.0, 15.0, 20.0,
              0.0, 7.0, 0.0,
              0.0, 1.0, 0.0);
    glEnable(GL_NORMALIZE);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    //glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);
    glShadeModel(GL_SMOOTH);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_COLOR_MATERIAL);
}

void myIdleFunc(void) {
    glutPostRedisplay();
}

void inicio()
{
    glEnable(GL_TEXTURE_2D);
    glMatrixMode(GL_PROJECTION);
    leerImagen1();
    leerImagen2();
    leerImagen3();
    leerImagen4();
    leerImagen5();
    leerImagen6();
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
    glutInitWindowSize(800, 800);
    glutCreateWindow("3D");
    inicio();
    glutReshapeFunc(myReshape);
    glutDisplayFunc(display);
    glutIdleFunc(myIdleFunc);
    glClearColor(1.0, 1.0, 1.0, 1.0);
    glutMainLoop();
    return 0;
}

Proyecciones 3D Ricardo D. Gonzalez Gomez

Capturas de Pantalla

Código
DESCARGAR

Textura Cubo en 3D

Este ejercicio consta de agregar una textura a un cubo en 3D con las teclas a,s,d,w cambias el sentido de rotación de la figura.

Cubo3D

/**
Garnica Ayala Hector Daniel
Textura a un cubo en 3D
*/

#include 
#include
#include

Descargar Archivo.txt Cubo3D.txt

Texturas 3D - David Gómez Jaramillo

David Gómez Jaramillo

El ejercicio consiste en el dibujo de un cubo en 3D aplicando texturas con lo cual se lo implemente a manera de que al presionar la tecla "o", usa una textura y "p", utiliza otra textura.

También se aplica que al utilizar las teclas izquierda y derecha se realicen rotaciones.

Capturas de Pantalla:

  

Imágenes Utilizadas:

Ladrillo

Madera

Código:

/*
Texturas 3D
David Gómez Jaramillo
 */
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <stdlib.h>
#include<stdio.h>
#include<stdlib.h>
int opcion =0;
int HL=1,angx=30,angy=60;
unsigned char * datos;
int an1=128,al1=128;
unsigned char * imagen1;
int an2=128,al2=128;
unsigned char * imagen2;
int leerImagen1(){
    FILE *imagen;
    imagen=fopen("C:/ImagenesC/ladrillo.RAW","r");
    imagen1=(unsigned char*)malloc(an1*al1*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagen1,an1*al1*3,1,imagen);
    fclose(imagen);
    return 1;
}
int leerImagen2(){
    FILE *imagen;
    imagen=fopen("C:/ImagenesC/madera.RAW","r");
    imagen2=(unsigned char*)malloc(an1*al1*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagen2,an2*al2*3,1,imagen);
    fclose(imagen);
    return 1;
}
void texturaI1(void)
{
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, an1, al1, 0, GL_RGB, GL_UNSIGNED_BYTE, imagen1);
}
void texturaI2(void)
{
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, an2, al2, 0, GL_RGB, GL_UNSIGNED_BYTE, imagen2);
}

void dibujaCara(int j, int img)
{
    glDisable(GL_LIGHTING);
    glColor3f(1,1,1);
    glBegin(GL_QUADS);
    switch(j){
    case 1:
        glTexCoord3f(0.0, 1.0,0.0);
        glVertex3f(0,0.5,0);
        glTexCoord3f(0.0, 0.0,0.0);
        glVertex3f(0,0,0);
        glTexCoord3f(1.0, 0.0,0.0);
        glVertex3f(0.5,0,0);
        glTexCoord3f(1.0, 1.0,0.0);
        glVertex3f(0.5,0.5,0);
        break;
    case 2:
        glTexCoord3f(0.0, 1.0,0.0);
        glVertex3f(0,0.5,-0.5);
        glTexCoord3f(0.0, 0.0,0.0);
        glVertex3f(0,0,-0.5);
        glTexCoord3f(1.0, 0.0,0.0);
        glVertex3f(0,0,0);
        glTexCoord3f(1.0, 1.0,0.0);
        glVertex3f(0,0.5,0);
        break;
    case 3:
        glTexCoord3f(0.0, 1.0,0.0);
        glVertex3f(0.5,0.5,-0.5);
        glTexCoord3f(0.0, 0.0,0.0);
        glVertex3f(0.5,0,-0.5);
        glTexCoord3f(1.0, 0.0,0.0);
        glVertex3f(0,0,-0.5);
        glTexCoord3f(1.0, 1.0,0.0);
        glVertex3f(0,0.5,-0.5);
        break;
    case 4:
        glTexCoord3f(0.0, 1.0,0.0);
        glVertex3f(0.5,0.5,0);
        glTexCoord3f(0.0, 0.0,0.0);
        glVertex3f(0.5,0,0);
        glTexCoord3f(1.0, 0.0,0.0);
        glVertex3f(0.5,0,-0.5);
        glTexCoord3f(1.0, 1.0,0.0);
        glVertex3f(0.5,0.5,-0.5);
        break;
    case 5:
        glTexCoord3f(0.0, 1.0,0.0);
        glVertex3f(0,0.5,-0.5);
        glTexCoord3f(0.0, 0.0,0.0);
        glVertex3f(0,0.5,0);
        glTexCoord3f(1.0, 0.0,0.0);
        glVertex3f(0.5,0.5,0);
        glTexCoord3f(1.0, 1.0,0.0);
        glVertex3f(0.5,0.5,-0.5);
        break;
    case 6:
        glTexCoord3f(0.0, 1.0,0.0);
        glVertex3f(0,0,-0.5);
        glTexCoord3f(0.0, 0.0,0.0);
        glVertex3f(0,0,0);
        glTexCoord3f(1.0, 0.0,0.0);
        glVertex3f(0.5,0,0);
        glTexCoord3f(1.0, 1.0,0.0);
        glVertex3f(0.5,0,-0.5);
        break;
    }
    glEnd();
    glEnable(GL_LIGHTING);
}

void construyeCubo1(int t){
    if(t==0){
        texturaI1();
    }else{
        texturaI2();
    }
    dibujaCara(1,1);
    dibujaCara(4,1);
    dibujaCara(2,1);
    dibujaCara(3,1);
    dibujaCara(6,1);
    dibujaCara(5,1);
}
void display(void)
{
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(0, 1, 0);
    glLineWidth(3);
    glPushMatrix();
    glTranslatef(0, 0, -2);
    glRotatef(angx, 1, 0, 0);
    glRotatef(angy, 0, 1, 0);
    if (opcion==0){
        construyeCubo1(0);
    }else{
        construyeCubo1(1);
    }
    glPopMatrix();
    glFlush();
}
void proy(unsigned char key, int x,int y){
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    switch (key) {
        case 27:exit(0);
        case 'p':
            gluPerspective(60, 1, 0.1, 10); //se genera el modo de perspectiva 3D
            //field of view campo de vision 60°
            //relacion de aspecto 1 a 1
            //Znear lo mas cerca en z (0.1)
            //Zfar lo mas lejano es 10
            opcion=1;
            break;
        case 'o':
            opcion=0;
            gluPerspective(60, 1, 0.1, 10); //se genera el modo de perspectiva 3D
            //glOrtho(-1,1,-1,1,-1,10); //se genera el modo ortogonal 2D (x1,x2, y1,y2, z1,z2)
            break;
    }
    glutPostRedisplay();
}
void inicio()
{
    glEnable(GL_TEXTURE_2D);
    glMatrixMode(GL_PROJECTION); //Hacer uso de la pantalla
    leerImagen1();
    leerImagen2();
}
void girar(int key, int x, int y){
switch(key){
    case GLUT_KEY_LEFT:
        angx=angx+3;
        break;
    case GLUT_KEY_RIGHT:
        angx=angx-3;
        break;
}
    glutPostRedisplay();
}
int main(int argc, char **argv){
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
    glutInitWindowSize(600,600);
    glutInitWindowPosition(10,10);
    glutCreateWindow ("Proyecciones y Multi-Textura");
    inicio();
    glutDisplayFunc(display);
    glutKeyboardFunc(proy);
    glutSpecialFunc(girar);
    glutMainLoop();
    return 0;
}

Descargar Código:

Clic Aquí para descargar

Como pintar un skeleton en WPF utilizando la Beta 2 del Kinect for Windows SDK. 

La base de un skeleton en Kinect es una colección de Joints con los que luego podemos “armar el skeleton”. Además es posible armar y pintar más de un skeleton, para este ejemplo, pues solo pintamos el skeleton[0] en amarillo.

Tutorial

1. Crear un nuevo proyecto de tipo WPF Application en Visual Studio 2010.

2. Agregamos las siguientes referencias

• Microsoft.Research.Kinect
  <%Program Files%>\Microsoft SDKs\Kinect\v1.0 Beta2\Assemblies\Microsoft.Research.Kinect.dll

3. Modificamos la MainWindow para mostrar un título y un Canvas donde mostraremos el skeleton

   1: <Window x:Class="ElBruno.KinectSkeleton01.MainWindow"

   2:         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   3:         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   4:         Title="MainWindow" Height="480" Width="360">

   5:     <Grid>

   6:         <TextBlock Text="El Bruno - Skeleton Viewer" 

   7:                    FontSize="20" HorizontalAlignment="Center" />

   8:         <Canvas x:Name="Skeleton" Margin="10,40,10,10" 

   9:                 Background="Black" />

  10:     </Grid>

  11: </Window>

La ventana queda similar a la siguiente

4. Agregamos un manejador para el evento Load() de la Window. Además agregamos un runtime para trabajar contra el Kinect e inicializamos el mismo con las opciones básicas de trabajo.

   1: private Runtime _kinect;

   2:  

   3: public MainWindow()

   4: {

   5:     InitializeComponent();

   6:     Loaded += MainWindowLoaded;

   7: }

   8:  

   9: void MainWindowLoaded(object sender, RoutedEventArgs e)

  10: {

  11:     InitKinect();

  12: }

  13:  

  14: void InitKinect()

  15: {

  16:     if (Runtime.Kinects.Count == 0)

  17:         return;

  18:  

  19:     _kinect = Runtime.Kinects[0];

  20:     _kinect.Initialize(RuntimeOptions.UseDepthAndPlayerIndex | 

  21:       RuntimeOptions.UseSkeletalTracking | RuntimeOptions.UseColor);

  22:  

  23:         _kinect.VideoStream.Open(ImageStreamType.Video, 2, 

  24:                 ImageResolution.Resolution640x480, ImageType.Color);

  25:         _kinect.DepthStream.Open(ImageStreamType.Depth, 2, 

  26:                 ImageResolution.Resolution320x240, ImageType.DepthAndPlayerIndex);

  27:     _kinect.SkeletonFrameReady += KinectSkeletonFrameReady;

  28: }

En este ejemplo no he puesto ningún tipo de gestión de excepciones, trabajando con una Beta deberíamos agregar algo después.

5. A continuación sólo nos queda pintar nuestro esqueleto en Kinect. Para esto utilizaremos la colección de Joints que nos retorna el Runtime y en el evento KinectSkeletonFrameReady pintaremos los Joints y los Bones que unen los mismos.

   1: void KinectSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)

   2: {

   3:     foreach (var skeleton in 

   4:              e.SkeletonFrame.Skeletons.Where

   5:             (skeleton => 

   6:                       SkeletonTrackingState.Tracked == skeleton.TrackingState))

   7:     {

   8:         Skeleton.Children.Clear();

   9:         PaintBones(skeleton);

  10:         PaintJoints(skeleton);

  11:     }

  12: }

6. Obviamente para que funcione la rutina anterior hace falta la implementación de PaintJoins y de PaintBones. Como pueden ver en el siguiente fragmento de código, es bastante simple ya que solo se recorren las colecciones y se pinta a partir de las mismas.

   1: private void PaintJoints(SkeletonData skeleton)

   2: {

   3:     foreach (Joint joint in skeleton.Joints)

   4:     {

   5:         var jointPos = _kinectCanvas.GetDisplayPosition(joint);

   6:         var jointLine = new Line

   7:                             {

   8:                                 X1 = jointPos.X - 3

   9:                             };

  10:         jointLine.X2 = jointLine.X1 + 6;

  11:         jointLine.Y1 = jointLine.Y2 = jointPos.Y;

  12:         jointLine.Stroke = KinectCanvas.JointColors[joint.ID];

  13:         jointLine.StrokeThickness = 6;

  14:         Skeleton.Children.Add(jointLine);

  15:     }

  16: }

  17:  

  18: private void PaintBones(SkeletonData skeleton)

  19: {

  20:     var brush = new SolidColorBrush(Colors.Yellow);

  21:     Skeleton.Children.Add(_kinectCanvas.GetBodySegment

  22:         (skeleton.Joints, brush, JointID.HipCenter, 

  23:         JointID.Spine, JointID.ShoulderCenter, JointID.Head));

  24:     Skeleton.Children.Add(_kinectCanvas.GetBodySegment

  25:         (skeleton.Joints, brush, JointID.ShoulderCenter, 

  26:         JointID.ShoulderLeft, JointID.ElbowLeft, JointID.WristLeft, JointID.HandLeft));

  27:     Skeleton.Children.Add(_kinectCanvas.GetBodySegment

  28:         (skeleton.Joints, brush, JointID.ShoulderCenter,

  29:         JointID.ShoulderRight, JointID.ElbowRight, JointID.WristRight, JointID.HandRight));

  30:     Skeleton.Children.Add(_kinectCanvas.GetBodySegment

  31:         (skeleton.Joints, brush, JointID.HipCenter, JointID.HipLeft,

  32:         JointID.KneeLeft, JointID.AnkleLeft, JointID.FootLeft));

  33:     Skeleton.Children.Add(_kinectCanvas.GetBodySegment

  34:         (skeleton.Joints, brush, JointID.HipCenter, JointID.HipRight,

  35:         JointID.KneeRight, JointID.AnkleRight, JointID.FootRight));

  36: }

En el ejemplo completo pueden ver la clase KinectCanvas() que es la que posee las definiciones para convertir joints en points y bones en lineas.

7. Si ejecutamos la aplicación y somos rápidos para sacar un screenshot podremos algo similar a

Referencias: El Bruno Innovation Craftsman