TaxiRadar - Aprendiendo a programar javaME y googleAPI


Otro proyecto mas, este se encuentra en version Beta, lo auto nombre TaxiRadar, nombre de desarrollo canaan peek (que en maya significa cuidar el movimiento).
Que implementa este proyecto:

JAVA ME clcd 1.1 Midp 2.1
Theads
Conexion a internet
RecordStore
Canvas (gui a bajo nivel para algunos menus)
Forms
XML parsing (por fuerza bruta)

La dinamica del proyecto es la siguiente:


El programa lee de un servidor un archivo del cual obtiene una lista de camiones, que para fines de este proyecto yo les hice un cast a (taxi)
De cada uno se muestra un mapa usando el api de google de:
su posicion actual
su ruta hacia el destino
La posición de todos los taxis.

Como una segunda etapa del progrma seria implementar una interfaz para mensajeo entre las flotillas via un servidor web.
Hacer que soporte geolocalizacion si el telefono lo soporta
Darle soporte a las pantallas touchscreen.

Uno de estos dias subo el código terminado.

Aplicación tipo DropBox sobre Java y SSL


Hi, no estaba muerta andaba de parranda terminando mis materias.
Esta ocasion voy a publicarles el codigo fuente de un proyecto escolar, se trata de una aplicación para sincronización en espejo tipo DropBox, la nombre arbitrariamente MirrorBox, como entrada prepublicacion de mi codigo, voy a compartirles el diagrama de clases y una descripcion general del proyecto.
Actualmente se encuentra en version Alfa, y apenas si esta implementado el 20% de la funcionalidad final.


Mi diagrama de clases propuesto es el siguiente:



En días posteriores iré subiendo fragmentos del programa, la lógica de programación, el protocolo de comunicación cliente servidor que nos inventamos :D y el código Alfa.
Finalmente quiero agradecer a mis testers e ingenieros en redes que colaboraron en la fumacion de la estructura del codigo.
Por seguridad y no por egoismo no incluyo sus nombres completos, gracias David, Ivan y Jose.

Viviendo con Lxde en Debian



Esta entrada cuenta la historia de mi lap, despues de que ajuste mis particiones, dado que ahora tiene doble sistema operativo (no interesa cual es el otro), reinstale mi Debian desde cero, en una sola particion, mas una particion ntfs compartida por ambos sistemas, ahora bien, el primer paso fue compilar un kernel mas reciente para poder gozar de mejor soporte a mi HW, los drivers de la tarjeta grafica y obtener actualziaciones de seguridad.
En esta ocasion le dije adios a mi tradicional KDE3.5 y decidi usar un escritorio mas ligero, LXDE, basado en OpenBox, que encontre, que mi escritorio se mantiene liviano y funcional gracias a una serie de aplicaciones escritas para X, es decir, no dependientes de alguno de los dos escritorios mas famosos, asi que por si alguien tiene curiosidad en que cosas instale en conjunto con lxde aqui esta la lista:

apt-get install +

  • lxde
  • samba
  • wireless-tools
  • xsmbrowser
  • xpdf
  • xchm
  • djview
  • gimp
  • inkscape (depende de algunas librerias de gnome, nada serio)
  • amsn
  • audacity
  • apache (http)
  • imagemagick

y desde las paginas oficiales de cada uno:

  • nvidia-driver-module (nvidia.com)
  • java (Oracle)
  • openoffice
  • netbeansIDE (full version)
  • DeadBeef (reproductor de musica)
  • chrome (navegador web)
Que cosas tengo pendientes?
  • instalar un reproductor de video
  • un convertidor multiformato (pdf,html,xml,etc)
  • Perfeccionar un script de autoconexión a mis redes inalámbricas favoritas
  • Implementar un script de sincronización con los archivos de mi otra pc
Espero que este post despierte la curiosidad de algunos, y prueben a jugar con sus entornos de trabajo y de esparcimiento con PC.

Programa básico para razonamiento hacia atrás

Programa que efectúa razonamientos hacia atrás a partir de hechos y premisas básicas. Las reglas se uso de explican en la interfaz, y aquí esta en resumen:

Los hechos de especifican de la siguiente forma hecho=valor donde valor = 1|0
las premisas con conjuntivas de la forma: premisa:hecho,hecho2,...,hechoN
los nombres de los hechos pueden ser uniliterales o estar formados por palabras completas sin espacios.

Se cargan los hechos y las premisas y se corre el motor de inferencia el cual responde a tratar de comprobar el hecho escrito en el área de comandos, lo cual afirma ejecuta el motor por medio del razonamiento hacia adelante para poder afirmar o negar el hecho según las reglas y hechos que se conocen o se van generando.

El programa esta hecho en java y posee una interfaz gráfica independiente del código del motor de inferencia, basta con generar una instancia del motor y asociarle un objeto de tipo textbox para que lo use como salida default, así que la GUI se puede rediseñar a voluntad, asociando los comandos de ejecución del motor a los eventos de la misma.

CODIGO AQUI
El programa fue hecho en netbeansIDE

Lineas y rellenado de poligonos version 1

Ya me canse de hacer cosas web, así que mejor publico mi código para generar polígonos mediante lineas por Bresseham y para rellenarlos por medio de barrido horizontal :P
Esta primera versión del código tiene un pequeño error en el algoritmo de rellenado, es el típico problema de los vértices de la figura, en la medida de mi tiempo lo corregire, pero mientras aquí les dejo el código. Esta implementado usando Allegro (si, muy vieja, pero útil para esto) y programado en C. Click en el nombre del proyecto para visualizar codigo en pdf:

Proyecto: Poligono |Yesica Hernandez |Computacion Grafica

DIBUJADO DE POLIGONOS CON IMPLEMENTACION DEL ALGORTIMO DE BRESENHAM PARA UNIR LOS NODOS DEL MISMO PROTOTIPO DE ALGORITMO DE RELLENADO Y FUNCIONES DE DETECCION DE INTERSECCIONES CON LINEAS
DESCRIPCION DEL PROGRAMA
EL USUARIO PUEDE GENERAR POLIGONOS DE CUALQUIER NUMERO DE LADOS CON DAR CLICK CON EL BOTON IZQUIERDO DEL MOUSE, Y LOS PUNTOS SE IRAN UNIENDO EN LA SECUENCIA EN QUE SEAN CREADOS. PARA INDICAR QUE SE HA TERMINADO DE DEFINIR EL POLIGONO DE HACE CLICK CON EL BOTON DERECHO, LO QUE ACTIVA EL PROCESO DE PINTADO MEDIANTE EL PROTOTIPO DE ALGORTIMO POR BARRIDO

Y bueno, que es un codigo tan largo sin screenshots de su ejecucion:




NetBoot Server con Debian Lenny (Virtual Machine)



Este fue un trabajito para una materia, es un breve resumen de los pasos seguidos para configurar el servidor, compuesto por:
  • servidor NFS
  • servidor TFTP
  • servidor DHCP
y la configuracion de los mismos para iniciar pxelinux.0 como cargador de arranque de un sistema más complejo por red, en este caso se usó una copia de Debian 5.0 Live para Red.
El documento esta en pdf en la siguiente dirección
y a continuacion se muestra un diagrama de como funciona el Servidor:

Hardening Básico a un servidor

Compartimos la pequeña tarea que nos dejaron en clase de Admintración de Redes, cuyo objetivo era implementar criterios de aseguramiento de un sistema,
el proceso que llevamos a cabo fue enlistar los aspectos básicos que debiamos considerar cuando el sistema esta recién instalado. Las condiciones simuladas son las siguientes:

Una máquina virtual que funge como el servidor fisico en el cual se instalo Debian (Lenny)
La maquina esta resguardada por un firewall y tiene una direccion Ip estatica asignada mediante la cual el firewall solo permite peticiones al puerto 80 (asignado para http)
Para probar una máquina virtual a la que se le apliquen estas configuraciones, se debe configurar una red entre la misma y el host, por ejemplo hemos configurado el segmento 192.168.56.0 para este fin. Una vez activo el servidor apache basta con teclear en el navegador de Host la ip asignada a la máquina virtual para poder observar el servidor web.

Este fue un trabajo muy básico, le faltan aun muchos aspectos a considerar, entre ellos la configuración de los puertos abiertos y configurar el acceso mediante secure shell así como una configuración mas especifica del servidor apache.

El documento esta disponible en este enlace
Creditos por el trabajo: Yesica Hdz y Mario Arredondo

Dopaciones de Madrugadas


Ya eso de dejar volar la imaginacion y ejercitar la creatividad esta llegando a un nivel enfermo jajajja, he aqui lo que se puede hacer con un par de horas libres algunas imagenes de internet y mucho GIMP. Hecha para el Flisol 2010.


How to, construyendo una figura para dar textura a un objeto en blender

Hágase una pausa en su agitada vida de cuando en cuando para ejercitar sus dotes artísticos, en esta ocasión, vamos a hacer una textura con componente alpha, este es un buen truco para hacer chulísimos efectos en un modelo 3D,
esta es la primera parte, como crear la imagen, en este caso yo deseo trabajar con unas alas de mariposa, las cuales se cargaran sobre un plano, y se hara uso del canal alpha para eliminar todo lo que este fuera de la silueta del ala, y así dar la impresión de que la figura es en sí el ala. Posteriormente y usando el mismo modelo, de le hara un mapa de relieve (bumping map) para resaltar la textura cuando se haga el render ya con los efectos de iluminación.

PRIMERA PARTE:
CREANDO EL ELEMENTO

Qué usaremos? usaremos Inkscape para generar una imagen lo mas pulida posible, el primer paso es el más divertido pues es aquí donde entra la imaginación.

Vamos a construir un ala a partir de una figura básica como un cuadrado. Primero debemos transformar la naturaleza de sus nodos, seleccionando la figura y haciendo click en el botón de edición de nodos, luego en la barra de herramientas de nodo, en el botón de "Convertir a curva".
Aqui mostramos el botón de edición de nodo, luego el menu de nodo y la opción de convertir a curva
En este punto la representación de la figura se verá como sigue, con sus nodos marcados por rombos:Lo segundo que debemos hacer es añadir más nodos, hacemos doble click en algun punto de las lineas que unen los nodos existentes y asi se crea un nuevo nodo, hagamos cuantos nodos deseemos, entre más, la figura tendrá un acabado mas fino, pero sera más dificil de modelar.


Una vez hechos algunos nodos extra, recordemos el principio que nos ayuda a decidir en donde debería estar cada nodo:
Los nodos son las terminaciones de las esquinas de la figura por asi decirlo, pero también son los puntos en los que cambia el sentido o la dirección de una curva. Si se dirigía hacia abajo y de pronto gira hacia arriba, en se punto donde cambia el sentido, ahi debería ir un nodo.

Hablando como ingenieros es el punto en el que la derivada cambia de valor XD el llamado punto de inflexión. Por ahora son lineas rectas, no vemos aqui los cambios de curvatura, pero deben estar presentes en nuestra mente para posteriormente modelar bien la silueta:

Ahora movemos la posción de los nodos y debemos formar algo similar a la imagen anterior y a la siguientes:

más cambios de posición:
... esto ya semeja un ala:

En este punto debemos seleccionar todos los nodos que tiene la figura y entonces en la barra de opciones de los nodos elegir, nodos asimétricos curvos, se generaran unas líneas con puntos que salen de cada nodo , nos indica que podemos modificar la curvatura de los trayectos entre nodos sin afectar el lado contrario al que se esta modificado, para modificar la curvatura, posicionamos el raton en algun lugar de la linea y lo arrastramos presionando el boton derecho, asi se van curveando los trayectos. Mas o menos podemos hacer algo asi:


y con un poco de paciencia vamos ajustando las curvaturas a nuestra conveniencia
no todas las curvas deben ser homogeneas, podemos usar las líneas guias que salen de cada nodo para modificar el trayecto, solo se hace click en el círculo vacio terminal de las mismas y se arrastra, vemos como esto modifica el trayecto:

Finalmente, cuando nos agrade la silueta, seleccionamos un conjunto de nodos y los separamos del resto, esto se hace con un botón de las opciones del menu de nodos:


Ahora procedemos a crear elementos de decoracion de la figura, el proceso que se sigue es el mismo, se parte de una figura basica, circulo, cuadrado, figura libre, y de editan sus nodos para moldear su silueta a nuestra conveniencia, aqui modificamos algunas circunferencias para hacer gotas y figuras:
Aqui se muestra con detalle como al mover las líneas directrices, con terminaciones redondas vacias, podemos modificar el trayecto de la curva que esta entre los nodos en cuestión:


Al dar click sobre una figura, obtenemos distintas opciones de modificación, una de ellas es el escalado, si de da otro click, se obtienen las opciones de rotación.

Después de juguetear un rato con las figuras, podemos seleccionar grupos de ellas y hacer "copy-paste" y asi generamos cosas como lo siguiente:

Para concluir estos pasos podemos agregar color para resaltar las distintas areas

Bien esta figura base es una imagen escalable (SVG), para generar el bumping map en la segunda parte la exportaremos a un formato de imagen plana, cuidando que tenga buena resolución y haremos algunas ediciones con GIMP.

Este post aun no esta terminado, ni corregido ni revisado!
esperar... u_u

Informe sobre pagina en lidsol.fi-b.unam

En este post solo deseo informar los cambios hechos a la página que hice para el laboratorio:

Se reestructuraron los códigos para el servicio de noticias y eventos.
Se creo un guestbook hospedado dentro de los servidores del lab. (En Metztli para ser exactos)
Se añadieron las secciones que faltaban: Acerca de nosotros, flisol2010, Archivos variados, etc.

La página esta disponible en modo de prueba en el siguiente enlace:
http://lidsol.fi-b.unam.mx/yezika/Pagina/

Aún faltan algunas cuestiones por resolver como un mecanismo para agregar contactos de los integrantes del lab, por ejemplo sus blogs y otras páginas personales.
La seccion de administración de noticias, iconos y eventos no pide contraseña, asi que cualquiera puede crear lo que quiera, deseo implementar la autenticación de usuarios por medio de los usuarios registrados en el jaws de Metztli.

Algoritmo para generar lineas

En clase hicimos un ejercicio para dibujar lineas de la forma: y=mx +b en la pantalla, de tal suerte que elegimos que pixel representa al elemento de la linea de la mejor forma. El código me pareció divertido, esta hecho usando la librería Allegro (obsoleta dicen por ahí) pero bastante útil para programar en 5 minutos XD.

/*
YESICA HERNANDEZ HERNANDEZ
COMPUTACION GRAFICA
PROGRAMA PARA DIBUJAR LINEAS EN LA PANTALLA

INSTRUCIONES:
CON LA TECLA ESC CERRAMOS LA VENTANA
DESCRIPCION:
EN ESTE CODIGO SE USO LA LIBRERIA GRAFICA ALLEGRO
SE IMPLEMENTA EL ALGORTIMO VISTO EN CLASE PARA DIBUJAR LINEAS
PIXEL POR PIXEL, CONOCIENDO DOS PUNTOS QUE PERTENECEN A ELLA,
SE PINTAN 600 COORDENADAS ANTES DE FINALIZAR LA ANIMACION.
LOS VALORES DE LAS COORDENADAS SE DEBEN DAR AL PROGRAMA COMO
PARAMETROS, EJEMPLO:
Linea.exe 20.0 86.0 44.0 11.0
EN DONDE TENEMOS:
Linea.exe x1 y1 x2 y2
*/
#include
#include

//VARIABLE PARA MANIPULAR LOS PIXELES COLOREADOS
float vi[2],vf[2],vx[2],px,m,dx,dy;
int contador;


//DECLARACIONES DE LAS FUNCIONES
void init();
void deinit();
int linea();
void titulo();
void get_values();

//-------------------------------------MAIN -------------------------
int main(int arg, char** val){

//Agregando valores iniciales, transformados a numeros:
vi[0]=atof(val[1]);
vi[1]=atof(val[2]);
vf[0]=atof(val[3]);
vf[1]=atof(val[4]);

dx=vf[0]-vi[0];
dy=vf[1]-vi[1];
m = dy/dx;
//Inicializamos los metodos de la libreria,
// grafics, teclado, mouse y temporizadores
init();
//imprimimos informacion sobre el programa en pantalla (mis datos)
titulo();
get_values();
//bucle principal de eecucion
while (!key[KEY_ESC]) {
//llamamos a la rutina para colorear pixeles aleatoriamente
if(linea()==1){
//hacemos una pausa de 0.2 segundos
rest(100);
}else break;
}
//llamada a las rutinas de finalizacion de allegro
deinit();
return 0;
}
END_OF_MAIN()


void get_values(){
rectfill(screen, 290, 10, 590, 40, makecol(40,20, 30));
textprintf_ex(screen, font, 300, 20, makecol(202,255, 112),-1, "Puntos de la recta:");
textprintf_ex(screen, font, 300, 30, makecol(202,255, 112),-1,"(%3.1f,%3.1f) (%3.1f,%3.1f)",vi[0],vi[1],vf[0],vf[1]);
}

/*
esta funcion pinta pixeles aleatoriamente en la pantalla, cuyo tamaño
definimos como 600x480
*/
int linea(){
int edo=1;
//generamos valores aleatorios dentro de ciertos rangos por
//medio del modulo
if(contador>0){
int r = rand()%255;
int g = rand()%255;
int b = rand()%255;
//incluimos el pixel en pantalla
putpixel (screen,vx[0],430- vx[1], makecol(r, g, b));
// hacemos el reemplazo por el siguiente pixel
if(px<0){
vx[0]++;
px=px+dy;
}
else if(px>=0){
vx[0]++;
vx[1]++;
px = (2*dy)-(2*dx)+px;
}
// NOS ASEGURAMOS QUE SOLO SE PINTEN 600 PUNTOS PERTENECIENTES A LA RECTA
contador--;
}else edo = 0;
return edo;
}

/*
funcion para mostrar en pantalla mis datos
*/
void titulo(){
textprintf(screen, font, 20, 430, makecol(0,197, 205), "YESICA HERNANDEZ HERNANDEZ / Computacion Grafica");
textprintf(screen, font, 10, 440, makecol(72,209, 174), ".................ALGORITMO PARA LINEA.................");
textprintf(screen, font, 20, 460, makecol(202,255, 112), "Presione ESC para cerrar");
}


/*
funcion que inicializa los elementos de allegro, necesaria para establecer
el modo de pantalla, la profundidad
de colo el tamaño de la venta y el estado de la misma.
TAMBIEN ESTABLECEMOS LA SEMILLA A UTILIZAR PARA LOS
NUMEROS ALEATORIOS
*/
void init() {
int depth, res;
allegro_init();
depth = desktop_color_depth();
if (depth == 0) depth = 32;
set_color_depth(depth);
res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);
if (res != 0) {
allegro_message(allegro_error);
exit(-1);
}
srand (time(0));
install_timer();
install_keyboard();
//incializamos las variables de calculo;
contador=600;
vx[0]=vi[0];
vx[1]=vi[1];
px=(2*dy)-dx;

}
/*FUNCION DE ALLEGRO QUE LIMPIA EL BUFFER DEL TECLADO*/
void deinit() {
clear_keybuf();
}
¿Que se necesita para probar este codigo?
Tener la librería Allegro instalada,
si se prueba desde el IDE de desarrollo, poner los parámetros en la configuración de ejecución
si se prueba desde un shell/linea de comandos, probar con la sintaxis expuesta en los comentarios


Programas de prueba para opengl

En la clase de computacion gráfica probamos el siguiente codigo

#include
#include
#define EXIT_SUCCESS 0

void Dibuja(void);

int main(int argc, char **argv){

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(640,480);
glutInitWindowPosition(100,150);
glutCreateWindow("Ventana");
glutDisplayFunc(Dibuja);
glutMainLoop();
getchar();
return EXIT_SUCCESS;
}

void Dibuja(void){
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}

que usa opengl, por ahora no hace nada si no crear una ventana vacia, pero ella esta lista para desplegar figuritas, un ejemplo de como generar figuritas coloridas es el siguiente, no se asombre usté de la extension, es el precio de la naturaleza de glut:

/*
When creating your project, uncheck OWL,
uncheck Class Library, select Static
instead of Dynamic and change the target
model to Console from GUI.
Also link glut.lib to your project once its done.
*/

#include
// The GL Header File
#include
// The GL Utility Toolkit (Glut) Header

float rtri; // Angle For The Triangle
float rquad; // Angle For The Quad


void InitGL ( GLvoid ) // Create Some Everyday Functions
{

glShadeModel(GL_SMOOTH);
// Enable Smooth Shading
glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
// Black Background
glClearDepth(1.0f);
// Depth Buffer Setup
glEnable(GL_DEPTH_TEST);
// Enables Depth Testing
glDepthFunc(GL_LEQUAL);
// The Type Of Depth Testing To Do
glEnable ( GL_COLOR_MATERIAL );
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
}

void display ( void ) // Create The Display Function
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Screen And Depth Buffer
glLoadIdentity();
// Reset The Current Modelview Matrix
glPushMatrix();
glTranslatef(-1.5f,0.0f,-6.0f);
// Move Left 1.5 Units And Into The Screen 6.0
glRotatef(rtri,0.0f,1.0f,0.0f); // Rotate The Triangle On The Y axis
glBegin(GL_TRIANGLES);
// Drawing Using Triangles
glColor3f(1.0f,0.0f,0.0f); // Red
glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Front)
glColor3f(0.0f,1.0f,0.0f); // Green
glVertex3f(-1.0f,-1.0f, 1.0f); // Left Of Triangle (Front)
glColor3f(0.0f,0.0f,1.0f); // Blue
glVertex3f( 1.0f,-1.0f, 1.0f); // Right Of Triangle (Front)
glColor3f(1.0f,0.0f,0.0f); // Red
glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Right)
glColor3f(0.0f,0.0f,1.0f); // Blue
glVertex3f( 1.0f,-1.0f, 1.0f); // Left Of Triangle (Right)
glColor3f(0.0f,1.0f,0.0f); // Green
glVertex3f( 1.0f,-1.0f, -1.0f); // Right Of Triangle (Right)
glColor3f(1.0f,0.0f,0.0f); // Red
glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Back)
glColor3f(0.0f,1.0f,0.0f); // Green
glVertex3f( 1.0f,-1.0f, -1.0f); // Left Of Triangle (Back)
glColor3f(0.0f,0.0f,1.0f); // Blue
glVertex3f(-1.0f,-1.0f, -1.0f); // Right Of Triangle (Back)
glColor3f(1.0f,0.0f,0.0f); // Red
glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Left)
glColor3f(0.0f,0.0f,1.0f); // Blue
glVertex3f(-1.0f,-1.0f,-1.0f); // Left Of Triangle (Left)
glColor3f(0.0f,1.0f,0.0f); // Green
glVertex3f(-1.0f,-1.0f, 1.0f); // Right Of Triangle (Left)
glEnd();
// Finished Drawing The Triangle

glLoadIdentity(); // Reset The Current Modelview Matrix
glTranslatef(1.5f,0.0f,-6.0f); // Move Right 1.5 Units And Into The Screen 6.0
glRotatef(rquad,1.0f,0.0f,0.0f); // Rotate The Quad On The X axis
glColor3f(0.5f,0.5f,1.0f);
// Set The Color To Blue One Time Only
glBegin(GL_QUADS);
// Draw A Quad
glColor3f(0.0f,1.0f,0.0f); // Set The Color To Blue
glVertex3f( 1.0f, 1.0f,-1.0f); // Top Right Of The Quad (Top)
glVertex3f(-1.0f, 1.0f,-1.0f); // Top Left Of The Quad (Top)
glVertex3f(-1.0f, 1.0f, 1.0f); // Bottom Left Of The Quad (Top)
glVertex3f( 1.0f, 1.0f, 1.0f); // Bottom Right Of The Quad (Top)
glColor3f(1.0f,0.5f,0.0f); // Set The Color To Orange
glVertex3f( 1.0f,-1.0f, 1.0f); // Top Right Of The Quad (Bottom)
glVertex3f(-1.0f,-1.0f, 1.0f); // Top Left Of The Quad (Bottom)
glVertex3f(-1.0f,-1.0f,-1.0f); // Bottom Left Of The Quad (Bottom)
glVertex3f( 1.0f,-1.0f,-1.0f); // Bottom Right Of The Quad (Bottom)
glColor3f(1.0f,0.0f,0.0f); // Set The Color To Red
glVertex3f( 1.0f, 1.0f, 1.0f); // Top Right Of The Quad (Front)
glVertex3f(-1.0f, 1.0f, 1.0f); // Top Left Of The Quad (Front)
glVertex3f(-1.0f,-1.0f, 1.0f); // Bottom Left Of The Quad (Front)
glVertex3f( 1.0f,-1.0f, 1.0f); // Bottom Right Of The Quad (Front)
glColor3f(1.0f,1.0f,0.0f); // Set The Color To Yellow
glVertex3f( 1.0f,-1.0f,-1.0f); // Bottom Left Of The Quad (Back)
glVertex3f(-1.0f,-1.0f,-1.0f); // Bottom Right Of The Quad (Back)
glVertex3f(-1.0f, 1.0f,-1.0f); // Top Right Of The Quad (Back)
glVertex3f( 1.0f, 1.0f,-1.0f); // Top Left Of The Quad (Back)
glColor3f(0.0f,0.0f,1.0f); // Set The Color To Blue
glVertex3f(-1.0f, 1.0f, 1.0f); // Top Right Of The Quad (Left)
glVertex3f(-1.0f, 1.0f,-1.0f); // Top Left Of The Quad (Left)
glVertex3f(-1.0f,-1.0f,-1.0f); // Bottom Left Of The Quad (Left)
glVertex3f(-1.0f,-1.0f, 1.0f); // Bottom Right Of The Quad (Left)
glColor3f(1.0f,0.0f,1.0f); // Set The Color To Violet
glVertex3f( 1.0f, 1.0f,-1.0f); // Top Right Of The Quad (Right)
glVertex3f( 1.0f, 1.0f, 1.0f); // Top Left Of The Quad (Right)
glVertex3f( 1.0f,-1.0f, 1.0f); // Bottom Left Of The Quad (Right)
glVertex3f( 1.0f,-1.0f,-1.0f); // Bottom Right Of The Quad (Right)
glEnd(); // Done
//Drawing The Quad

// Done Drawing The Quad
glPopMatrix();
rtri+=0.2f; // Increase The Rotation Variable For The Triangle ( NEW )
rquad-=0.15f; // Decrease The Rotation Variable For The Quad ( NEW )


glutSwapBuffers ( );
// Swap The Buffers To Not Be Left With A Clear Screen
}

void reshape ( int width , int height ) // Create The Reshape Function (the viewport)
{
if (height==0)
// Prevent A Divide By Zero By
{
height=1;
// Making Height Equal One
}

glViewport(0,0,width,height);
// Reset The Current Viewport

glMatrixMode(GL_PROJECTION);
// Select The Projection Matrix
glLoadIdentity();
// Reset The Projection Matrix

// Calculate The Aspect Ratio Of The Window

gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

glMatrixMode(GL_MODELVIEW);
// Select The Modelview Matrix
glLoadIdentity();
}

void keyboard ( unsigned char key, int x, int y ) // Create Keyboard Function
{
switch ( key ) {
case 27: // When Escape Is Pressed...
exit ( 0 ); // Exit The Program
break; // Ready For Next Case
default: // Now Wrap It Up
break;
}
}

void arrow_keys ( int a_keys, int x, int y ) // Create Special Function (required for arrow keys)
{
switch ( a_keys ) {
case GLUT_KEY_UP: // When Up Arrow Is Pressed...
glutFullScreen ( ); // Go Into Full Screen Mode
break;
case GLUT_KEY_DOWN: // When Down Arrow Is Pressed...
glutReshapeWindow ( 500, 500 ); // Go Into A 500 By 500 Window
break;
default:
break;
}
}


void main ( int argc, char** argv ) // Create Main Function For Bringing It All Together
{
glutInit ( &argc, argv ); // Erm Just Write It =)
glutInitDisplayMode ( GLUT_RGBA | GLUT_DOUBLE ); // Display Mode
glutInitWindowSize ( 500, 500 ); // If glutFullScreen wasn't called this is the window size
glutCreateWindow ( "NeHe's OpenGL Framework" ); // Window Title (argv[0] for current directory as title)
glutFullScreen ( ); // Put Into Full Screen InitGL ();
glutDisplayFunc ( display ); // Matching Earlier Functions To Their Counterparts
glutReshapeFunc ( reshape );
glutKeyboardFunc ( keyboard );
glutSpecialFunc ( arrow_keys );
glutIdleFunc ( display );
glutMainLoop ( ); // Initialize The Main Loop
}


Para compilar este codigo en un sistema *nix necesitamos tener instalado freeglut toolkit o glut3g toolkit en el sistema, que no es si no el conjunto de librerias de glut. Para compilarlo, sin hacer uso de un makefile, por esta ocasion, diponemos de la siguiente linea de comando:

NOTESE QUEDEBEMOS TENER INSTALADA LA LIBRERIA GLUT, PARA ELLO POSTEE EN UNA ENTRADA ANTERIOR LOS PAQUETES NECESARIOS EN DEBIAN


gcc archivo_fuente -lglut -o archivo_salida

lo cual nos genera un archivo llamado archivo_salida, el cual ejecutamos en la terminal:

./archivo_salida (enter)

Makefile para openGL y Gtk+/wxWidgets

  • COMENZANDO POR EL PRINCIPIO
Tenemos que especificar que herramientas utilizaremos para desarrollar aplicaciones, me enfocare en las siguientes:

SO: Debian Lenny
OpenGL/Glut (version para linux freeglut3)
Make
Gcc/g++ (para programas escritos en C/C++)

instalamos esas dependencias:
sudo apt-get install gcc g++ make
sudo apt-get install freeglut3 freeglut3-dbg freeglut3-dev

Compilación de proyectos

MAKE
Dado el hecho de que debemos manejar librerías e incluso varios códigos fuente cuando programamos alguna aplicación, lo primero es entender como funcionan herramientas como el comando make, que ejecuta un script para realizar múltiples tareas.
basándonos en la información de la documentación oficial del proyecto GNU:

http://www.gnu.org/software/make/manual/make.html

realizamos la siguiente plantilla:

(no lo quería poner hasta que no entregara el previo de la practica 1 LOL)

#Makefile hecho por Yesica

OBJECTS = programa.o
OPENGL = -lglut
FUENTE = programa.c
SALIDA = programa.out
CC = gcc

inicio:
$(CC) $(FUENTE) $(OPENGL) -o $(SALIDA)

GA GA GA GA GA GA GA

Y AUN NO PARO DE REIR, GA GA GA GA GA GA!!!



Propuesta de trabajo

Je! bueno dado que este sem estaré bien metida en mi materia de compu gráfica, creo que mi trabajo será unificador, puesto que, el laboratorio lo tomaremos en el IBM JAVA de Estándares Abiertos, ubicado en posgrado, lugar en donde las maquinas trabajan con alguna versión de Fedora, por lo tanto, mi intención es echarle la mano al 99% de la clase que nunca ha programado nada en Linux, como? pues publicando código y ejemplos de como trabajar en un ambiente *nix, empezando por lo básico, Este rollo completo os podés leer aqui:

Cositas en red sobre seguridad en Linux

Baboseanto me encontre con un documento en la página de DGSCA que habla de las nociones básicas de seguridad en Linux, viene en un nivel básico-intermedio de conocimiento y nos recuerda aspectos que a veces no consideramos al hacer una instalación y que son buenas prácticas en pro de la seguridad. Aqui les dejo el link:


Lidsol everywhere


Así como traemos calcomanias de la Z en nuestros autos jajaja pongamos a lidsol en todos lados ^^
El banner de lidsol que muy amablemnete puso el administrador de fiunam.superforo.net podrá ser visto por todos los alumnos que pasen por ahí. El banner esta disponible en formato PNG en el siguiente enlace y tiene dos versiones, la de tipografia moderada y la de tipografia detallada y bueno son curiosidades como aquel asunto de la playeras, pero igual en nuestros ratos de oscio podríamos pensar en diseñar stickers para el LAB.