Graficación: octubre 2016

jueves, 27 de octubre de 2016

martes, 25 de octubre de 2016

David Gómez Jaramillo

CUBE MAP
Una textura cubemap es una textura , donde cada nivel en mapas MIP consiste en seis imágenes en 2D. Las imágenes están dispuestas en una forma de cubo, de ahí el nombre. Cubemaps pueden tener múltiples niveles de mipmap.

CAPTURAS

Imagenes usadas:

Back

Bottom

Left

Rigth

Front

Top

CODIGO
#include<stdio.h>
#include<stdlib.h>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <windows.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("C:/ImagenesC/cubo/bottom.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/cubo/back.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("C:/ImagenesC/cubo/left.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("C:/ImagenesC/cubo/right.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("C:/ImagenesC/cubo/front.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("C:/ImagenesC/cubo/top.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.6;
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, 5.0, 50.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;
}

DESCARGAR
link

lunes, 24 de octubre de 2016

CubeMap En OpenGL

El CubeMap de texturización es una forma de mapeado de texturas que utiliza un vector de dirección 3D (una frase de fantasía que no significa nada más que una dirección) para indexar una textura , que eson seis texturas en 2D cuadrados como las caras de un cubo. Una vez más en cuenta el medio ambiente que lo rodea ahora. Se puede "capturar" una vista de 360 grados de los alrededores de pie en un solo lugar y tomando seis fotografías cada una a una vista ortogonal de 90 grados de los demás. A continuación se muestra un conjunto de seis de estas imágenes que capturan un entorno de patio al aire libre:

Aquí está un diagrama que muestra cómo un conjunto diferente de las imágenes de mapa de cubo forman las caras de un cubo.

A continuación se presenta el ejemplo de un CubeMap:

/**

Garnica Ayala Héctor Daniel

CubeMap:  Se puede "capturar" una vista de 360 grados de los alrededores 
de pie en un solo lugar y tomando seis fotografías cada una a una vista 
ortogonal de 90 grados de los demás
*/
#include 
#include 
#include 
#include 

/*******Variables Globales*****/
float a;  ///
int anchoImagen=512,altoImagen=512;///dimensiones de las imagenes
unsigned char * imagenDown;
unsigned char * imagenLeft;
unsigned char * imagenBack;
unsigned char * imagenFront;
unsigned char * imagenRight;
unsigned char * imagenTop;


int leerimagenDown(){///piso
    FILE *imagen;
    imagen=fopen("C:/Users/host/Documents/PROG_Graficacion/sdoparcial/CubeMap/down.RAW","r");
    imagenDown=(unsigned char*)malloc(anchoImagen*altoImagen*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagenDown,anchoImagen*altoImagen*3,1,imagen);
    fclose(imagen);
    return 1;
}
int leerimagenLeft(){///lado izquierdo
    FILE *imagen;
    imagen=fopen("C:/Users/host/Documents/PROG_Graficacion/sdoparcial/CubeMap/left.RAW","r");
    imagenLeft=(unsigned char*)malloc(anchoImagen*altoImagen*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagenLeft,anchoImagen*altoImagen*3,1,imagen);
    fclose(imagen);
    return 1;
}
int leerimagenFront(){///parte frontal
    FILE *imagen;
    imagen=fopen("C:/Users/host/Documents/PROG_Graficacion/sdoparcial/CubeMap/front.RAW","r");
    imagenFront=(unsigned char*)malloc(anchoImagen*altoImagen*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagenFront,anchoImagen*altoImagen*3,1,imagen);
    fclose(imagen);
    return 1;
}
int leerimagenRight(){///lado derecho
    FILE *imagen;
    imagen=fopen("C:/Users/host/Documents/PROG_Graficacion/sdoparcial/CubeMap/right.RAW","r");
    imagenRight=(unsigned char*)malloc(anchoImagen*altoImagen*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagenRight,anchoImagen*altoImagen*3,1,imagen);
    fclose(imagen);
    return 1;
}

int leerimagenBack(){///parte trasera del cubo
    FILE *imagen;
    imagen=fopen("C:/Users/host/Documents/PROG_Graficacion/sdoparcial/CubeMap/back.RAW","r");
    imagenBack=(unsigned char*)malloc(anchoImagen*altoImagen*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagenBack,anchoImagen*altoImagen*3,1,imagen);
    fclose(imagen);
    return 1;
}
int leerimagenTop(){///techo o parte superior
    FILE *imagen;
    imagen=fopen("C:/Users/host/Documents/PROG_Graficacion/sdoparcial/CubeMap/top.RAW","r");
    imagenTop=(unsigned char*)malloc(anchoImagen*altoImagen*3);
    if(imagen==NULL){
        printf("Error: No imagen");
        return 0;
    }
    fread(imagenTop,anchoImagen*altoImagen*3,1,imagen);
    fclose(imagen);
    return 1;
}

void texturaDown(void)
{
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, anchoImagen, altoImagen, 0, GL_RGB, GL_UNSIGNED_BYTE, imagenDown);
}
void texturaLeft(void)
{
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, anchoImagen, altoImagen, 0, GL_RGB, GL_UNSIGNED_BYTE, imagenLeft);
}
void texturaFront(void)
{
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, anchoImagen, altoImagen, 0, GL_RGB, GL_UNSIGNED_BYTE, imagenFront);
}
void texturaRight(void)
{
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, anchoImagen, altoImagen, 0, GL_RGB, GL_UNSIGNED_BYTE, imagenRight);
}

void texturaBack(void)
{
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, anchoImagen, altoImagen, 0, GL_RGB, GL_UNSIGNED_BYTE, imagenBack);
}
void texturaTop(void)
{
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, anchoImagen, altoImagen, 0, GL_RGB, GL_UNSIGNED_BYTE, imagenTop);
}

void dibujaDown(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 dibujaLeft(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 dibujaFront(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 dibujaRight(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 dibujaBack(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 dibujaTop(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[]={80.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();
   glColor3f(1,1,1);
   glRotatef(a, 0, 1, 0);

   glPushMatrix();
    texturaDown();
     dibujaDown();
    texturaLeft();
     dibujaLeft();
    texturaBack();
     dibujaBack();
    texturaFront();
     dibujaFront();
    texturaRight();
     dibujaRight();
    texturaTop();
     dibujaTop();
   glPopMatrix();

   glPushMatrix();//TEAPOT
    glColor3f(1.0, 1.0, 1.0);
    glTranslated(0.0,10,0);
    glutSolidTeapot(3);
   glPopMatrix();
 glPopMatrix();
    a += 0.1;//velocidad de rotacion
    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 Init()
{
    glEnable(GL_TEXTURE_2D);
    glMatrixMode(GL_PROJECTION);
    leerimagenDown();
    leerimagenLeft();
    leerimagenBack();
    leerimagenFront();
    leerimagenRight();
    leerimagenTop();
}

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

Descargar Archivo.txt
CuboMap.txt

sábado, 22 de octubre de 2016

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;
}

miércoles, 19 de octubre de 2016

Proyecciones 3D Ricardo D. Gonzalez Gomez

Capturas de Pantalla

Código
DESCARGAR

martes, 18 de octubre de 2016

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 $#include #include int ancho=512,alto=512, angx=0, angy=0, angz=0;

unsigned char * datos,*datos2,*datos3,*datos4,*datos5,*datos6;

void DrawTexturedCube(GLdouble size)
{
    GLdouble HL; // half length for the sides of cube
    HL = size / 2.0f;
    glPushMatrix();

    // Cara frontal
    //glBindTexture(GL_TEXTURE_2D, *datos);
    glBegin(GL_QUADS);
    glTexCoord2f(0.0f, 0.0f);
    glVertex3f(-HL,-HL, HL);
    glTexCoord2f(1.0f, 0.0f);
    glVertex3f( HL,-HL, HL);
    glTexCoord2f(1.0f, 1.0f);
    glVertex3f( HL, HL, HL);
    glTexCoord2f(0.0f, 1.0f);
    glVertex3f(-HL, HL, HL);
    glEnd();
    // Cara tracera
    glBindTexture(GL_TEXTURE_2D, *datos2);
    glBegin(GL_QUADS);
    glTexCoord2f(1.0f, 0.0f);
    glVertex3f(-HL,-HL,-HL);
    glTexCoord2f(1.0f, 1.0f);
    glVertex3f(-HL, HL,-HL);
    glTexCoord2f(0.0f, 1.0f);
    glVertex3f( HL, HL,-HL);
    glTexCoord2f(0.0f, 0.0f);
    glVertex3f( HL,-HL,-HL);
    glEnd();
    // Carra superior o tapa
    glBindTexture(GL_TEXTURE_2D, *datos3);
    glBegin(GL_QUADS);
    glTexCoord2f(0.0f, 1.0f);
    glVertex3f(-HL, HL,-HL);
    glTexCoord2f(0.0f, 0.0f);
    glVertex3f(-HL, HL, HL);
    glTexCoord2f(1.0f, 0.0f);
    glVertex3f( HL, HL, HL);
    glTexCoord2f(1.0f, 1.0f);
    glVertex3f( HL, HL,-HL);
    glEnd();
    // Cara de abajo
    glBindTexture(GL_TEXTURE_2D, *datos4);
    glBegin(GL_QUADS);
    glTexCoord2f(1.0f, 1.0f);
    glVertex3f(-HL,-HL,-HL);
    glTexCoord2f(0.0f, 1.0f);
    glVertex3f( HL,-HL,-HL);
    glTexCoord2f(0.0f, 0.0f);
    glVertex3f( HL,-HL, HL);
    glTexCoord2f(1.0f, 0.0f);
    glVertex3f(-HL,-HL, HL);
    glEnd();
    // cara izquierda
    glBindTexture(GL_TEXTURE_2D, *datos5);
    glBegin(GL_QUADS);
    glTexCoord2f(0.0f, 0.0f);
    glVertex3f(-HL,-HL,-HL);
    glTexCoord2f(1.0f, 0.0f);
    glVertex3f(-HL,-HL, HL);
    glTexCoord2f(1.0f, 1.0f);
    glVertex3f(-HL, HL, HL);
    glTexCoord2f(0.0f, 1.0f);
    glVertex3f(-HL, HL,-HL);
    glEnd();
    //cara derecha
    glBindTexture(GL_TEXTURE_2D, *datos6);
    glBegin(GL_QUADS);
    glTexCoord2f(1.0f, 0.0f);
    glVertex3f( HL,-HL,-HL);
    glTexCoord2f(1.0f, 1.0f);
    glVertex3f( HL, HL,-HL);
    glTexCoord2f(0.0f, 1.0f);
    glVertex3f( HL, HL, HL);
    glTexCoord2f(0.0f, 0.0f);
    glVertex3f( HL,-HL, HL);
    glEnd();
    glPopMatrix();
}


int leerImagen()
{
    FILE *imagen;
    imagen=fopen("C:/Users/host/Documents/PROG_Graficacion/sdoparcial/TextCube3D/box.raw","r");
    datos=(unsigned char*)malloc(ancho*alto*3);
    datos2=(unsigned char*)malloc(ancho*alto*3);
    datos3=(unsigned char*)malloc(ancho*alto*3);
    datos4=(unsigned char*)malloc(ancho*alto*3);
    datos5=(unsigned char*)malloc(ancho*alto*3);
    datos6=(unsigned char*)malloc(ancho*alto*3);

    if(imagen==NULL)
    {
        printf("Error: No imagen");
        return 0;
    }
    else
    {
        printf("OK: Imagen cargada correctamente");
    }
    fread(datos,ancho*alto*3,1,imagen);
    fread(datos2,ancho*alto*3,1,imagen);
    fread(datos3,ancho*alto*3,1,imagen);
    fread(datos4,ancho*alto*3,1,imagen);
    fread(datos5,ancho*alto*3,1,imagen);
    fread(datos6,ancho*alto*3,1,imagen);
    fclose(imagen);

    return 1;
}
void teclado(unsigned char tecla, int x, int y)
{
    switch(tecla)
    {
    case(27):
        exit(0);
    case 'd':
        angy=5;
        break;
    case 'a':
        angy=-5;
        break;
    case 's':
        angx=5;
        break;
    case 'w':
        angx=-5;
        break;
    default:
        glutPostRedisplay();
        break;
    }
    glutPostRedisplay();
}


void display(void)
{
    glClear(GL_COLOR_BUFFER_BIT);

    glRotatef(angz, 0, 0, 1);
    glRotatef(angy, 0, 1, 0);
    glRotatef(angx, 1, 0, 0);
    DrawTexturedCube(1.0);
    glFlush();
}
void Init()
{
    glClearColor(0.0,0.0,0.0,0);
    //________________________________________________________________
    gluOrtho2D(-1.5,1.5,-1.5,1.5);
    gluPerspective(45, 1, 1, 30);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    leerImagen();
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, ancho, alto, 0, GL_RGB, GL_UNSIGNED_BYTE, datos);
    glEnable(GL_TEXTURE_2D);

}
int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE);
    glutInitWindowSize(600,600);
    glutInitWindowPosition(10,10);
    glutCreateWindow ("Textura a un cubo en 3D");

    glEnable(GL_LIGHT0); // Enable a single light source
    glEnable(GL_CULL_FACE);

    Init();
    glutDisplayFunc(display);
    glutKeyboardFunc(teclado);
    glutMainLoop();
    return 0;
}$

Descargar Archivo.txt Cubo3D.txt

lunes, 17 de octubre de 2016

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(an1al13);
if(imagen==NULL){
printf("Error: No imagen");
return 0;
}
fread(imagen1,an1al13,1,imagen);
fclose(imagen);
return 1;
}
int leerImagen2(){
FILE imagen;
imagen=fopen("C:/ImagenesC/madera.RAW","r");
imagen2=(unsigned char)malloc(an1al13);
if(imagen==NULL){
printf("Error: No imagen");
return 0;
}
fread(imagen2,an2al23,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

Graficación

jueves, 27 de octubre de 2016

Cronograma

martes, 25 de octubre de 2016

cube map - David Gomez

lunes, 24 de octubre de 2016

CubeMap En OpenGL

sábado, 22 de octubre de 2016

CUBEMAP

miércoles, 19 de octubre de 2016

Proyecciones 3D Ricardo D. Gonzalez Gomez

martes, 18 de octubre de 2016

Textura Cubo en 3D

lunes, 17 de octubre de 2016

Texturas 3D - David Gómez Jaramillo

David Gómez Jaramillo

Imágenes Utilizadas:

Código:

Tutorial

jueves, 27 de octubre de 2016

Cronograma

martes, 25 de octubre de 2016

cube map - David Gomez

lunes, 24 de octubre de 2016

CubeMap En OpenGL

sábado, 22 de octubre de 2016

CUBEMAP

miércoles, 19 de octubre de 2016

Proyecciones 3D Ricardo D. Gonzalez Gomez

martes, 18 de octubre de 2016

Textura Cubo en 3D

lunes, 17 de octubre de 2016

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:

Código:

Tutorial