FINAL DE COMPUTACION GRAFICA

El semestre ya llego a su fin y ya solo falta entregar el proyecto final de computación grafica.

ALGORITMOS DE TRAZO DE LÍNEAS

Algoritmo DDA (Digital Differential Analyzer)

Es un algoritmo que se basa en el cálculo y la evaluación de un DeltaX ( X) y un DeltaY( Y). Por medio de las siguientes ecuaciones:

DeltaX = DeltaY / m DeltaY = m * DeltaX

Se efectúa un muestreo de la línea en intervalos unitarios en una coordenada y se determinan los valores enteros correspondientes más próximos a la trayectoria de la línea para la siguiente coordenada.

Se aceptan como datos de entradas las dos posiciones de los pixeles correspondientes a los extremos de la línea P1(Xinicial,Yinicial) y P2(Xfinal,Yfinal). Las diferencias horizontal y vertical entre las posiciones de los extremos dados, se asignan a las varialbles DeltaX y DeltaY respectivamente. La diferencia con la mayor magnitud determina el valor del parámetro Pasos. Se procede a determinar la compensación necesaria (incremento), para generar la posición del pixel siguiente a lo largo de la trayectoria de la línea. Luego, se ilumina la posición en la pantalla, y se repite este proceso cíclico Pasos Veces, hasta obtener la línea deseada.

Algoritmo de Bresenham (Pendiente <>

Considerado uno de los algoritmos más efectivos para el trazo de líneas mediante rastreo. Emplea cálculos incrementales con valores enteros. La forma de determinar el siguiente pixel a iluminar en la generación de una línea, se describe a continuación: Se parte de un punto inicial P1(Xinicial,Yinicial). Luego se desplaza una columna (incrementando la posición en X) y se traza el pixel cuyo valor de Y de la línea de rastreo se aproxima más a la trayectoria de la línea.

Se capturan los dos extremos de la línea P1(Xinicial,Yinicial) y P2(Xfinal,Yfinal), se ilumina el primer pixel correspondiente al extremo izquierdo de la línea(P1). Luego se calculan los parámetros que permiten decidir cuál será el próximo pixel a iluminar (DeltaX, DeltaY y ConstanteP). Dependiendo del valor que tome el Parámetro ConstanteP se evalúa y determina la coordenada a iluminar que puede ser: (X+1,Y) para ConstanteP < 0, en caso contrario se ilumina (X+1,Y+1). El proceso anterior debe repetirse 4DeltaX veces.


REFERENCIA:

http://72.14.253.104/search?q=cache:nn__bPjg9W0J:agr115ues.iespana.es/guialineasrectas.doc+algoritmo+de+bresenham&hl=es&ct=clnk&cd=16&gl=mx

Examen

ALGORITMO DE RECORTE

PROYECCIONES

Puerco Araña

SeudoCódigo:

//tronco

Push;

Cilindro (radio=2, largo=7);

Pop;

//cabeza

Push;

Translate(0,0,3.5);

Esfera (radio=2);

//trompa

Push;

Translatef(0,-0.5,1.75);

Cilindro (radio=0.5, largo=0.7);

Pop;

//orejas

Push;

Rotate(-90,0,1,0);

Rotate(-45,1,0,0);

Translate(0.0f,0.3f,2.0f);

Cono(radio=0.5,altura=1);

Pop:

Push;

Rotate(90,0,1,0);

Rotate(-45,1,0,0);

Translate(0.0f,0.3f,2.0f);

Cono(radio=0.5,altura=1);

Pop;

//ojos

Push;

Translate(-1,0.6,2);

Esfera(radio=0.5);

Pop:

Push;

Translate(1,0.6,2);

Esfera(radio=0.5);

Pop;

Pop;

//cola

Push;

Translate(0.0f,1.2f,-6.2f);

Rotate(40,1,0,0);

Cilindro (radio= 0.2,largo=1);

Pop;

//Patas delanteras

Push;

Translate(-1.0f,-1.5f,0.0f);

Rotate(90,1,0,0);

Cilindro (Radio= 0.7,Largo=2);

Push;

Translatef(0.0f,0.0f,2.0f);

Cilindro (radio= 0.4,Largo=1);

Pop;

Pop;

Push;

Translate(1.0f,-1.5f,0.0f);

Rotate(90,1,0,0);

Cilindro (Radio= 0.7,Largo=2);

Push;

Translatef(0.0f,0.0f,2.0f);

Cilindro (radio= 0.4,Largo=1);

Pop;

Pop

//patas traseras

Push;

Translate(1.0f,-1.5f,-4.0f);

Rotate(135,1,0,0);

Cilindro(radio= 0.7,largo=2.1213);

Push;

Translate(0.0f,-0.7f,2.5213f);

Rotate(-90,1,0,0);

Cilindror(radio= 0.4,largo=2.1142);

Pop;

Pop;

Push;

Translate(-1.0f,-1.5f,-4.0f);

Rotate(135,1,0,0);

Cilindro(radio= 0.7,largo=2.1213);

Push;

Translate(0.0f,-0.7f,2.5213f);

Rotate(-90,1,0,0);

Cilindror(radio= 0.4,largo=2.1142);

Pop;

Pop;

Imagen Terminado

Código en C++; //tiene funciones de teclado para mover y hacercar la imagen en 3d

#include "glut.h"


float angleX = 0.0f;
float angleY = 0.0f;
float angleZ = 0.0f;
float transZ = -10.0f;
int proOr=0;
float al,an,pro;
GLint venAncho=600;
GLint venAlto=600;
void puerco_araña();
void reshape(int width, int height);
void keyboard(unsigned char key, int x, int y);
int main(int argc, char **argv) {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowPosition(20,20);
glutInitWindowSize( 600, 600);
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);
glutCreateWindow("Puerco Araña");
glutDisplayFunc(puerco_araña);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutIdleFunc(puerco_araña);
glutMainLoop();
return 0;
}
void puerco_araña(void){
GLUquadricObj *qobj;
qobj = gluNewQuadric ();
gluQuadricDrawStyle(qobj,GLU_FILL);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
if(proOr==1){
glRotatef(90,0,1,0);
glTranslatef(0,0,15);
}
else {
glMatrixMode(GL_PROJECTION);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
glTranslatef(0.0f, 0.0f, transZ);
glRotatef(angleX, 1.0f, 0.0f, 0.0f);
glRotatef(angleY, 0.0f, 1.0f, 0.0f);
glRotatef(angleZ, 0.0f, 0.0f, 1.0f);
glPushMatrix();
//tronco
glPushMatrix();
glTranslatef(0,0,-5.5f);
glColor3f(0.6f,0.0f,0.0f);
gluCylinder(qobj, 2, 2,7, 20, 20);
glPopMatrix();
//cabeza
glPushMatrix();
glTranslatef(0,0,3.5f);
glColor3f(0.0f,0.6f,0.2f);
glutSolidSphere(2,20,20);
//trompa
glPushMatrix();
glColor3f(0.6f,0.0f,0.0f);
glTranslatef(0.0f,-0.5f,1.75f);
gluCylinder(qobj, 0.5,0.5,0.75, 20, 20);
glPopMatrix();
//orejas
glPushMatrix();
glColor3f(0.0f,0.0f,0.9f);
glRotatef(-90,0,1,0);
glRotatef(-45,1,0,0);
glTranslatef(0.0f,0.3f,2.0f);
glutSolidCone (0.5, 1, 20, 20);
glPopMatrix();
glPushMatrix();
glColor3f(0.0f,0.0f,0.9f);
glRotatef(90,0,1,0);
glRotatef(-45,1,0,0);
glTranslatef(0.0f,0.3f,2.0f);
glutSolidCone (0.5, 1, 20, 20);
glPopMatrix();
//ojos
glPushMatrix();
glTranslatef(-1,0.6,2);
glColor3f(0.0f,0.9f,0.0f);
glutSolidSphere(0.5f,20,20);
glPopMatrix();
glPushMatrix();
glTranslatef(1,0.6,2);
glColor3f(0.0f,0.9f,0.0f);
glutSolidSphere(0.5f,20,20);
glPopMatrix();
glPopMatrix();
//cola
glPushMatrix();
glColor3f(0.6f,0.2f,0.9f);
glTranslatef(0.0f,1.2f,-6.2f);
glRotatef(40,1,0,0);
gluCylinder(qobj, 0.2,0.2,1,20,20);
glPopMatrix();
//patas delanteras
glPushMatrix();
glColor3f(0.6f,0.9f,0.2f);
glTranslatef(-1.0f,-1.5f,0.0f);
glRotatef(90,1,0,0);
gluCylinder(qobj, 0.7,0.7,2,20,20);
glPushMatrix();
glColor3f(0.0f,0.9f,0.9f);
glTranslatef(0.0f,0.0f,2.0f);
gluCylinder(qobj, 0.4,0.4,1,20,20);
glPopMatrix();
glPopMatrix();
glPushMatrix();
glColor3f(0.6f,0.9f,0.2f);
glTranslatef(1.0f,-1.5f,0.0f);
glRotatef(90,1,0,0);
gluCylinder(qobj, 0.7,0.7,2,20,20);
glPushMatrix();
glColor3f(0.0f,0.9f,0.9f);
glTranslatef(0.0f,0.0f,2.0f);
gluCylinder(qobj, 0.4,0.4,1,20,20);
glPopMatrix();
glPopMatrix();
//patas traseras
glPushMatrix();
glColor3f(0.6f,0.9f,0.2f);
glTranslatef(1.0f,-1.5f,-4.0f);
glRotatef(135,1,0,0);
gluCylinder(qobj, 0.7,0.7,2.1213f,20,20);
glPushMatrix();
glColor3f(0.0f,0.1f,0.9f);
glTranslatef(0.0f,-0.7f,2.5213f);
glRotatef(-90,1,0,0);
gluCylinder(qobj, 0.4,0.4,2.1142,20,20);
glPopMatrix();
glPopMatrix();
glPushMatrix();
glColor3f(0.6f,0.9f,0.2f);
glTranslatef(-1.0f,-1.5f,-4.0f);
glRotatef(135,1,0,0);
gluCylinder(qobj, 0.7,0.7,2.1213f,20,20);
glPushMatrix();
glColor3f(0.0f,0.1f,0.9f);
glTranslatef(0.0f,-0.7f,2.5213f);
glRotatef(-90,1,0,0);
gluCylinder(qobj, 0.4,0.4,2.1142,20,20);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glutSwapBuffers();
}

void reshape(int width, int height){
glViewport(0, 0, width, height);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
if(proOr!=2)
glOrtho(-20, 20, -20, 20, -50, 50);
if(proOr==2)
gluPerspective(90, (GLfloat) width/(GLfloat) height,2.0, 70.0);
glMatrixMode (GL_MODELVIEW);
venAncho = width;
venAlto = height;
}

void keyboard(unsigned char key, int x, int y){
switch(key)
{
case 27:
exit(0);
case 'w':
angleX += 1.0f;
break;
case 'W':
angleX -= 1.0f;
break;
case 's':
angleZ += 1.0f;
break;
case 'S':
angleZ -= 1.0f;
break;
case 'a':
angleY += 1.0f;
break;
case 'A':
angleY -= 1.0f;
break;
case 'z':
transZ += 0.1f;
break;
case 'Z':
transZ -= 0.1f;
break;
case '1':
proOr=1;
break;
case '2':
proOr=0;
break;
case '3':
proOr=2;
break;
default:
break;
}
}

Modelado Jerarquico

Imagen de la hormiga ya modelada en visual c++ con openGL


Còdigo en c++:

Libreria que dibuja un cubo dimensiones pasadas por parametros lo alto, ancho y profundidad:

#include "glut.h"



void drawCube(float A,float B,float C){

float ancho=A/2;

float alto=B/2;

float prof=C/2;



//Caras del cubo

//frontal

glBegin(GL_QUADS);

glVertex3f(-ancho,-alto,prof);

glVertex3f(ancho,-alto,prof);

glVertex3f(ancho,alto,prof);

glVertex3f(-ancho,alto,prof);

glEnd();



glBegin(GL_QUADS); //cara trasera

glVertex3f( ancho, -alto, -prof);

glVertex3f(-ancho, -alto, -prof);

glVertex3f(-ancho, alto, -prof);

glVertex3f( ancho, alto, -prof);

glEnd();



glBegin(GL_QUADS); //cara lateral izq

glVertex3f(-ancho,-alto, -prof);

glVertex3f(-ancho,-alto, prof);

glVertex3f(-ancho, alto, prof);

glVertex3f(-ancho, alto, -prof);

glEnd();



glBegin(GL_QUADS); //cara lateral dcha

glVertex3f(ancho, -alto, prof);

glVertex3f(ancho, -alto, -prof);

glVertex3f(ancho, alto, -prof);

glVertex3f(ancho, alto, prof);

glEnd();



glBegin(GL_QUADS); //cara arriba

glVertex3f(-ancho, alto, prof);

glVertex3f( ancho, alto, prof);

glVertex3f( ancho, alto, -prof);

glVertex3f(-ancho, alto, -prof);

glEnd();



glBegin(GL_QUADS); //cara abajo

glVertex3f( ancho,-alto, -prof);

glVertex3f( ancho,-alto, prof);

glVertex3f(-ancho,-alto, prof);

glVertex3f(-ancho,-alto, -prof);

glEnd();

}

Codigo del programa principal que contiene el "main":

#include

#include "glut.h"

#include "Cubo.h"



using namespace std;



float angleX = 0.0f;

float angleY = 0.0f;

float angleZ = 0.0f;

float transZ = -10.0f;



float al,an,pro;

GLint venAncho=600;

GLint venAlto=600;

void humanoide();

void reshape(int width, int height);

void keyboard(unsigned char key, int x, int y);

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

cout<<"dimensiones del cubo\nAlto: ";

cin>>al;

cout<<"Ancho: ";

cin >>an;

cout<<"Profundidad: ";

cin>>pro;

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

glutInitWindowPosition(20,20);

glutInitWindowSize( 600, 600);

glClearColor(0,0,0,0);

glEnable(GL_DEPTH_TEST);

glutCreateWindow("Humanoide");

glutDisplayFunc(humanoide);

glutReshapeFunc(reshape);

glutKeyboardFunc(keyboard);

glutIdleFunc(humanoide);

glutMainLoop();

return 0;

}

void humanoide(void){

glClear(GL_COLOR_BUFFER_BIT);

glMatrixMode(GL_PROJECTION);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

glPushMatrix();

glTranslatef(0.0f, 0.0f, transZ);

glRotatef(angleX, 1.0f, 0.0f, 0.0f);

glRotatef(angleY, 0.0f, 1.0f, 0.0f);

glRotatef(angleZ, 0.0f, 0.0f, 1.0f);



//Tronco

glTranslatef(0.0f,4,0.0f);

glPushMatrix();

glColor4f(0.0f,0.0f,2.0f,1.0f);

glScalef(3,2,2);

drawCube(an,al,pro);

glPopMatrix();



//cabeza

glPushMatrix();

glColor4f(0.0f,1.0f,.0f,1.0f);

glTranslatef(0.0f,1.5*al,0.0f);

drawCube(an,al,pro);

glPopMatrix();



//cintura

glPushMatrix();

glColor4f(0.0f,0.9f,0.5f,1.0f);

glScalef(1,1.5,1);

glTranslatef(0.0f,-(7*al)/6,0.0f);

drawCube(an,al,pro);

glPopMatrix();



//pata IZQ 1

glPushMatrix();

glColor4f(1.0f,2.0f,0.0f,1.0f);

glRotatef(30.0f,0.0f,1.0f, 0.0f);

glRotatef(-10.0f,0.0f,0.0f, 1.0f);

glScalef(2,0.5,0.5);

glTranslatef(-1.2*an,1.3*al,-2.5*pro);

drawCube(an,al,pro);

glPushMatrix();

glScalef(0.5f,2,2);

glRotatef(-70.0f,0.0f,1.0f, 0.0f);

glScalef(2.5,0.5,0.5);

glTranslatef(-0.73*an,0*al,2.4*pro);

drawCube(an,al,pro);

glPushMatrix();

glScalef(1/2.5,2,2);

glRotatef(20.0f,0.0f,1.0f, 0.0f);

glScalef(1,0.5,0.5);

glTranslatef(-1.8*an,0.0f,-0.8*pro);

drawCube(an,al,pro);

glPopMatrix();

glPopMatrix();

glPopMatrix();



//pata IZQ 2

glPushMatrix();

glColor4f(1.0f,2.0f,0.0f,1.0f);

glRotatef(30.0f,0.0f,1.0f, 0.0f);

glScalef(2,0.5,0.5);

glTranslatef(-1.2*an,0.0,-2.5*pro);

drawCube(an,al,pro);

glPushMatrix();

glScalef(0.5f,2,2);

glRotatef(-70.0f,0.0f,1.0f, 0.0f);

glScalef(2.5,0.5,0.5);

glTranslatef(-0.73*an,0*al,2.4*pro);

drawCube(an,al,pro);

glPushMatrix();

glScalef(1/2.5,2,2);

glRotatef(20.0f,0.0f,1.0f, 0.0f);

glScalef(1,0.5,0.5);

glTranslatef(-1.8*an,0.0f,-0.8*pro);

drawCube(an,al,pro);

glPopMatrix();

glPopMatrix();

glPopMatrix();



//pata IZQ 3

glPushMatrix();

glColor4f(1.0f,2.0f,0.0f,1.0f);

glRotatef(30.0f,0.0f,1.0f, 0.0f);

glRotatef(10.0f,0.0f,0.0f, 1.0f);

glScalef(2,0.5,0.5);

glTranslatef(-1.2*an,-1.3*al,-2.5*pro);

drawCube(an,al,pro);

glPushMatrix();

glScalef(0.5f,2,2);

glRotatef(-70.0f,0.0f,1.0f, 0.0f);

glScalef(2.5,0.5,0.5);

glTranslatef(-0.73*an,0*al,2.4*pro);

drawCube(an,al,pro);

glPushMatrix();

glScalef(1/2.5,2,2);

glRotatef(20.0f,0.0f,1.0f, 0.0f);

glScalef(1,0.5,0.5);

glTranslatef(-1.8*an,0.0f,-0.8*pro);

drawCube(an,al,pro);

glPopMatrix();

glPopMatrix();

glPopMatrix();





//pata der 1

glPushMatrix();

glColor4f(1.0f,2.0f,0.0f,1.0f);

glRotatef(-30.0f,0.0f,1.0f, 0.0f);

glRotatef(10.0f,0.0f,0.0f, 1.0f);

glScalef(2,0.5,0.5);

glTranslatef(1.2*an,1.3*al,-2.5*pro);

drawCube(an,al,pro);

glPushMatrix();

glScalef(0.5f,2,2);

glRotatef(70.0f,0.0f,1.0f, 0.0f);

glScalef(2.5,0.5,0.5);

glTranslatef(0.73*an,0*al,2.4*pro);

drawCube(an,al,pro);

glPushMatrix();

glScalef(1/2.5,2,2);

glRotatef(-20.0f,0.0f,1.0f, 0.0f);

glScalef(1,0.5,0.5);

glTranslatef(1.8*an,0.0f,-0.8*pro);

drawCube(an,al,pro);

glPopMatrix();

glPopMatrix();

glPopMatrix();



//pata der 2

glPushMatrix();

glColor4f(1.0f,2.0f,0.0f,1.0f);

glRotatef(-30.0f,0.0f,1.0f, 0.0f);

glScalef(2,0.5,0.5);

glTranslatef(1.2*an,0.0,-2.5*pro);

drawCube(an,al,pro);

glPushMatrix();

glScalef(0.5f,2,2);

glRotatef(70.0f,0.0f,1.0f, 0.0f);

glScalef(2.5,0.5,0.5);

glTranslatef(0.73*an,0*al,2.4*pro);

drawCube(an,al,pro);

glPushMatrix();

glScalef(1/2.5,2,2);

glRotatef(-20.0f,0.0f,1.0f, 0.0f);

glScalef(1,0.5,0.5);

glTranslatef(1.8*an,0.0f,-0.8*pro);

drawCube(an,al,pro);

glPopMatrix();

glPopMatrix();

glPopMatrix();



//pata der 3

glPushMatrix();

glColor4f(1.0f,2.0f,0.0f,1.0f);

glRotatef(-30.0f,0.0f,1.0f, 0.0f);

glRotatef(-10.0f,0.0f,0.0f, 1.0f);

glScalef(2,0.5,0.5);

glTranslatef(1.2*an,-1.3*al,-2.5*pro);

drawCube(an,al,pro);

glPushMatrix();

glScalef(0.5f,2,2);

glRotatef(70.0f,0.0f,1.0f, 0.0f);

glScalef(2.5,0.5,0.5);

glTranslatef(0.73*an,0*al,2.4*pro);

drawCube(an,al,pro);

glPushMatrix();

glScalef(1/2.5,2,2);

glRotatef(-20.0f,0.0f,1.0f, 0.0f);

glScalef(1,0.5,0.5);

glTranslatef(1.8*an,0.0f,-0.8*pro);

drawCube(an,al,pro);

glPopMatrix();

glPopMatrix();

glPopMatrix();



//cola

glPushMatrix();

glColor4f(1.0f,0.0f,0.5f,0.9f);

glScalef(4,4,4);

glTranslatef(0.0f,-1.125*al,0.0f);

drawCube(an,al,pro);

glPopMatrix();



glPopMatrix();

glutSwapBuffers();

}



void reshape(int width, int height){

glViewport(0, 0, width, height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

glOrtho(-10,10,-10,10, 0.1, 20);

glMatrixMode(GL_MODELVIEW);

venAncho = width;

venAlto = height;

}



void keyboard(unsigned char key, int x, int y){

switch(key)

{

case 27:

exit(0);

case 'w':

angleX += 1.0f;

break;

case 'W':

angleX -= 1.0f;

break;

case 's':

angleZ += 1.0f;

break;

case 'S':

angleZ -= 1.0f;

break;

case 'a':

angleY += 1.0f;

break;

case 'A':

angleY -= 1.0f;

break;

case 'z':

transZ += 0.1f;

break;

case 'Z':

transZ -= 0.1f;

break;

default:

break;

}

}

ESTRUCTURAS ALGEBRAICAS (TAREA 2)

REFERENCIAS:
http://carreras.frba.utn.edu.ar/civil/mef/FEMmatrices2.pdf
http://www.ing.unrc.edu.ar/publicaciones/doc_de_trabajo/archivos/estructuras_algebraicas.doc

Formatos de Video (Tarea 1)

CGA

Con la llegada de los primeros PS/2 de IBM, arribó la primera tarjeta de vídeo con capacidad gráfica, la CGA (Color Graphics Array, Arreglo de Gráficos a Color), cuyo nombre se deriva del hecho que maneja la pantalla como un arreglo de puntos, o pixeles y cada uno de ellos puede tener un color específico hasta con 4 bits de profundidad. A partir de estas capacidades gráficas se crearon juegos y aplicaciones que explotaban al máximo la capacidad gráfica de esta tarjeta controladora.

EGA

Continuando con la evolución y el entonces liderazgo de IBM, el siguiente estándar que llegó al mercado al final de los 80s fue el EGA (Enhanced Graphics Adapter, Adaptador de Gráficos Mejorado, Adaptador de Gráficos Mejorados), la traducción correcta al espańol del nombre de esta tarjeta resulta un tanto confusa, ya que si bien se mejora el adaptador, también los gráficos, ya que esta tarjeta soportaba hasta 16 colores visibles que podían ser seleccionados de una paleta de 64, con una resolución de 640x350, y daba soporte hacia atrás con todas las existentes. Estas características hicieron posible que los entornos gráficos se extendieran al mundo PC (los Macintosh llevaban ańos con ello), y aparecieron el GEM, el Windows y otros muchos. Sobre las posibilidades de las pantallas EGA, una curiosidad: los controladores EGA de Windows 3.1 funcionan en Windows 95, y resulta curioso (y sumamente incómodo) ver esta combinación...

VGA

(Video Graphics Array). Sistema gráfico de pantallas para PCs desarrollado por IBM. VGA se convirtió en un estándar de facto para PCs. Las tarjetas gráficas VGA estándares traían 256 KB de memoria de video. En modo texto, el sistema VGA provee una resolución de 720 x 400 pixeles. En modo gráfico permite 640 x 480 (con 16 colores) o 320 x 200 (con 256 colores). El número total de colores de la paleta es 262.144 y tasa de refresco de hasta 70 Hz. A diferencia de estándares para PC más viejos (MDA, CGA y EGA), VGA utiliza señales analógicas. Por esta razón un monitor diseñado para estándares anteriores no puede utilizar VGA.

XGA

Este acrónimo es para eXtended Graphics Array, Arreglo de Gráficos Extendido, que fuera utilizado en modelos PS/2 más avanzados y puede realizar bus mastering en el bus MCA utilizando 512KB o 1MB de VRAM. En esta última soporta 1024x768/256 o 640x480/ 65K.

WXGA

Es una norma de visualización de gráficos de ordenador. Abreviatura de "Wide eXtended Graphics Array" o "Wide XGA", que es una ampliación de resolución horizontal (el término "wide" se refiere al formato panorámico) del formato XGA.

La resolución de éste formato es de 1366x768 que constituyen una imagen de 1.049.088 píxeles con una relación de aspecto de 16:9 (16 unidades horizontales por 9 verticales). Aunque la relación de aspecto considerada panorámica más usada en el entorno informático es de 16:10.

Éstas especificaciones no pueden considerarse exactas puesto que existen variantes entre fabricantes (1280x768, 1280x800, 1360x768, 1440x900)

Esta norma suele ser usada en ordenadores portátiles y en televisores de gran formato aunque no todos ellos, a pesar de tener la resolución suficiente, soportan señales de Alta definición (HDTV).

WGA

(Windows Genuine Advantage - Ventaja de Windows Genuino). Programa ActiveX desarrollado por Microsoft para detectar si un sistema operativo Windows XP o Vista fue legalmente comprado o es una copia ilegal.

PGA

(Professional Graphics Adapter). Estándar de video desarrollado por IBM que soporta una resolución de 640 x 480 pixeles.

VESA

Video Electronics Standards Association (Asociación para estándares electrónicos y de video) es una asociación internacional de fabricantes de electrónica. Fue fundada por NEC en los años 80 del siglo XX, con el objetivo inicial de desarrollar pantallas de vídeo con una resolución común de 800x600 píxeles. Desde entonces, la VESA ha otros estándares relacionados con funcionalidades de vídeo en periféricos de los IBM PC y compatibles, como conectores, BIOS o características de la frecuencia, transmisión y sincronización de la imagen.

Principales estándares de la VESA:

• Bus VESA (VLB), antes usado como un puerto de alta velocidad para vídeo (antes de la aparición del AGP)
• VESA BIOS Extensions (VBE), usado para crear un estándar que soportase modos de vídeo avanzados (a alta resolución y miles de millones de colores).
• VESA Display Data Channel (DDC), que permite a los monitores autoidentificarse a las tarjetas gráficas a las que están conectados. Sin embargo, el formato actual de identificación es llamado EDID (Extended Display Identification Data).
• VESA Display Power Management Signaling, que permite a los monitores comunicar que tipo de modos de ahorro de energía poseen.
• Digital Packet Video Link
• Una serie de patentes sobre pantallas planas, conectores de video y sincronización del vídeo digital.

REFERENCIAS:

• http://www.alegsa.com.ar/Dic/VGA.php
• http://www.tecnotopia.com.mx/mecatronica/video.htm
• http://es.wikipedia.org/wiki/WXGA
• http://www.alegsa.com.ar/Dic/wga.php
• http://es.wikipedia.org/wiki/Video_Electronics_Standards_Association