Libro procesamiento imagenes

ING. HERNAN VARGAS NOLIVOS UTM
ENFOQUE PRACTICO AL PROCESAMIENTO
DE IMÁGENES DIGITALES Y LAS
GRAFICAS POR COMPUTADORA
I. PROGRAMACION ORIENTADA A OBJETOS
1.1. INTRODUCCIÓN
Hoy en día todos los sistemas de computadora están creados con la técnica
descubierta en los años 60 que es la programación orientada a objetos, menos
los sistemas de tiempo real.
1.2. RESEÑA HISTORICA
- Antes la programación era lineal, lo cual no era muy eficiente,
códigos muy largos, en esta era surgen los GOTO Y LOS
PROCEDIOS, para mejorar esta técnica aparece la programación
estructurada.
- Con en pasar de los tiempos la programación evoluciona y nace la
programación estructurada aquí ya se utiliza nuevas técnicas tales
como los procedimientos y funciones aquí ya desaparece los GOTO
(mala programación)
- Con el pasar de los tiempos en la década de los 60 nace una nueva
técnica que viene a mejorar las dos anteriores (Programación
Orientada a Objetos) que no es mas que representar las imágenes
de las cosas que no hemos visto como objetos (simular los objetos
que nos rpdean).
OBJETOS
SISTEMA DE ADMINISTRACIÓN
INSTITUCIONAL
ESTUDIANTE
PROFESOR
EMPLEADOS

1.3. CONCEPTOS BÁSICOS GENERALES DE LA
PROGRAMACIÓN ORIENTADA A OBJETOS
Es una técnica de programación que utiliza objetos como bloques de
construcción como por ejemplo: “La construcción de una casa en donde los
objetos son los bloques”.
La comunicación entre los objetos, se establece por medio de los mensajes.
La Programación Orientada a Objetos son los mismos Struct (estructura de
datos) solo que se agregan los procedimientos y funciones sobre los datos.
El hecho de que los procedimientos y funciones trabajen sobre una clase , se
debe buscar errores solo sobre esa clase, mientras que en la programación
estructurada y lineal se busca errores sobre todo el programa
1.3.1. OBJETOS.-
Son tipos de datos abstractos definidos por el programador donde se
especifican los datos y las operaciones que se pueden realizar sobre ellos.
Es una entidad donde se definen los atributos o características (datos) y las
formas de operar sobre ellos, la estructura interna es oculta a cualquier otra
parte del programa.
Es la concepción material de la clase.
1.3.2. MENSAJE.-
No son mas que las peticiones que hace un objeto a otro para que este tenga
un comportamiento determinado.
La comunicación de los objetos se basa en la técnica cliente / servidor donde
un objeto se convierte en cliente y el otro objeto servidor o viceversa.
Comunicación entre los objetos Ej: Pedir como objeto que se paren a los
alumnos (como objetos).
1.3.3. METODOS.-
No son mas que procedimientos y funciones.
Un método determina como tiene que actuar el objetos cuando recibe un
mensaje y permite almacenar la información en sus atributos, también puede
enviar mensajes a otros objetos solicitando determinado comportamiento.
Ej: Si se quema los archivos y computadores del registro civil nos deberán
entregar otra C.I., otros nombre otra dirección, es como encontrar un método
para almacenar esa información, tomando en cuenta que somos objetos.

1.3.4. CLASES.-
Es un tipo de datos definidos por el programador que determina los atributos y
métodos de los objetos con características comunes.
Ejemplo:
ESTUDIANTES CLASE COMUN
PERSONAS
PROFESORES
Es la abstracción de los objetos donde se definen que características tienen los
objetos en general
“Struct” define la clase
A;B;C son objetos de la clase “Struct”.
1.3.5. ENCAPSULAMIENTO.-
Es la forma que utiliza la P.O.O para proteger la información o programación de
los objetos. La única forma que se puede acceder a esa información es de
acuerdo a algún mensaje que actúa sobre los atributos establecidos.
Ej: Los Yogas pueden detener el corazón utilizando algún método mental lo
cual no es explicable por la ciencia médica, la otra manera de detener el
corazón sería abrir el cuerpo para sacar el corazón y detenerlo, locual
estaríamos “violando el encapsulamiento”.
1.3.6. HERENCIA.-
Posibilidad que tienen los objetos de adquirir propiedades de otros objetos (el
nuevo hereda del ancestro) Ej: El hombre  los hojos se parecen a su mamá
al heredar el pelo (propiedades) y camina como el papá (método).
En programación la herencia es a nivel de clases y se crean los objetos con las
características de las clases.
1.3.6.1 HERENCIA SIMPLE.-
Un objeto hereda de otro. Ejemplo: los perros heredan características del perro
que se cruzó con la hembra.
Como ya habíamos dicho anteriormente que el lenguaje de programación en
Pascal no soporta la herencia múltiple, para lo cual hace lo siguiente para
solucionar el problema.

El acceso a un objeto se realiza directamente con la siguiente sintaxis
accedemos a un objeto.
1.3.6.2 HERENCIA MÚLTIPLE
Un objeto hereda atributos de dos clases Ej: hombre hereda atributos de dos
personas (padre y madre).
Nota: en Delphi o en Object Pascal Orientado a Objetos no soporta la multi-
herencia por que complica la programación.
A continuación se describe gráficamente las dos clase de herencia que existe
en la programación.
A
CB
D
A A
A
B
Pone un objeto de tipo C se
duplica A, pero el
compilador quita el código
repetido
C
A
Objeto “C”.método
Herencia
Simple
A
CB
D
A A
Herencia
múltipleC
A
B
A

Nota: Pascal no soporta la herencia múltiple, C no soporta la programación
orientada a objetos, C++ si soporta la P.O.O y además soporta la multi-
herencia.
Una persona con atributos definidos es u objeto.
Clase.- Abstracto “Persona”
Clase_A = Integer
B: Clase_A
En teoría la clase no ocupa memoria
Sintaxis:
Objeto: Clase
a : Integer
Con el nombre “a” tienen valor los atributos y por lo tanto tiene 2 byte en
memoria.
1.3.7. POLIMORFISMO DE UN OBJETO.-
Objetos de clases distintas actúan de distinta manera ante un mismo mensaje;
Un objeto responde de diferente manera a un mensaje.
En C++ es muy versátil por lo cual se puede dar una sobrecarga de operadores
TAREA
Consultar que es herencia , Encapsulamiento, polimorfismo
A
CB
D
A A
A
B
C
Herencia
múltiple en
C++
A
CB
D
A A
D elimina
una AC
A
B
A


 El perro llama a su método y camina en cuatro patas
 La Gallina llama a su método y camina en dos patas
 El hombre llama a su método camina en dos pies
Los métodos son polifórmicos, mientras que los objetos no
1.4. CLASES Y OBJETOS EN DELPHI
¿Cómo en Delphi o Pascal se interpretan los objetos?
El objetos B va a tener acceso a la interface de A, o sea al procedure de A y
no al procedure de B
En Delphi las palabras reservadas son: Uses, Type, var, constantes, private,
protected, public, end, bejín, inherited, virtual, override
Animales
caminen Método
Caninos Aves Homosapien
Perro Gallina Hombre
A
Nombre:
Interface:
Procedure A
Implementation
Procedure B
B
Uses A
B
Int
Uses A
A
C
Int
Uses A, B

¿CÓMO SE DEFINEN LAS CLASES?
Las clases no son mas que un tipo de datos en Pascal
SINTAXIS
Type
Nombre_Class = Class(Nombre_Clase_Heredada)
________________________
________________________
________________________
Esto es público por defecto, no
así en C++ es privado.
Private
________________________
________________________
________________________
Se define lo que es privado de
la clase o sea los atributos y
métodos que no son públicos
Protected
________________________
________________________
________________________
Public
________________________
________________________
________________________
End;
Aquí van solo los métodos si se
pone algún atributo, violo el
Encapsulamiento.
Un objeto es un record con métodos (Estructura de datos)
¿COMO DEFINIMOS LOS OBJETOS?
Definimos a un objeto de tipo Nombre_Clase como se definen las variables en
Pascal

Sintaxis
Nombre_Objeto: Nombre_Clase;
CREAR UN OBJETO EN MEMORIA
Reservamos memoria a un objeto, y se nos devuelve una dirección o puntero
de ese objeto.
Sintaxis
Nombre_Objeto = Nombre_Clase.Create;
Todas las clases en Pascal tienen que heredar de algún tipo de clase, si no se
tiene de quien heredar se debe heredar d la clase mas general Tobject, esta
clase tiene métodos constructores y destructores que son internos
Sintaxis
Nombre_Clase = Class (TObject).
DESTRUIR UN OBJETO
El punto es la única manera de dirigirse a los métodos de un objeto en este
caso “Destruy”
Sintaxis
Nombre_Objeto.Destruy;
Cuando destruyo un objeto estoy liberando memoria y cuando lo creo reservo
memoria
DECLARAR UN OBJETO
Nombre_Objeto: Nombre_Clase;
Sintaxis General de las clases
Type
Nombre_Class = Class(Nombre_Clase_Heredada)
________________________
________________________
________________________
Esto es público por defecto, no
así en C++ es privado.

Private
________________________
________________________
________________________ Se define lo que es privado de
la clase o sea los atributos y
métodos que no son públicosProtected
________________________
________________________
________________________
Public
________________________
________________________
________________________
End;
Aquí van solo los métodos si se
pone algún atributo, violo el
Encapsulamiento.
Ejemplo:
Crear un objeto “Punto “ en el cual necesitamos coordenadas en X y en Y
Nota crear un Unit 2 para la creación del objeto Tpunto y en el Unit 1 del t Form
crear un formulario que tenga la siguiente interfaz
X
Y
X + Y
Crear
Calcular
Destruir

unit Unit2;
interface
type
TPunto=class(TObject)
private
x,y:integer;
public
procedure set_x(nx:integer);
procedure set_y(ny:integer);
function get_x():integer;
function get_y():integer;
function calcular():integer;
end;
implementation
procedure TPunto.set_x(nx:integer);
begin
x:=nx;
end;
procedure TPunto.set_y(ny:integer);
begin
y:=ny;
end;
function TPunto.get_x:integer;
begin
get_x:=x;
end;
function TPunto.get_y:integer;

begin
get_y:=y;
end;
function TPunto.calcular:integer;
begin
calcular:=get_x+get_y;
end;
end.
Este código es el que se auto genera por el codigo del Tform del Uni1
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, Unit2;
type
TForm1 = class(TForm)
EditX: TEdit;
EditY: TEdit;
EditCalc: TEdit;
ButCrear: TButton;
ButCalcular: TButton;
ButDestruir: TButton;
procedure ButCrearClick(Sender: TObject);
procedure ButCalcularClick(Sender: TObject);
procedure ButDestruirClick(Sender: TObject);
private
Punto:TPunto;

{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.ButCrearClick(Sender: TObject);
begin
Punto:= TPunto.Create;
Punto.set_x(StrtoInt(EditX.Text));
Punto.set_y(StrtoInt(EditY.Text));
end;
procedure TForm1.ButCalcularClick(Sender: TObject);
begin
EditCalc.Text:=IntToStr(Punto.calcular);
end;
procedure TForm1.ButDestruirClick(Sender: TObject);
begin
Punto.Destroy
end;
end.
Tarea extra clase:
Crear la clase rectángulo y la clase círculo que permita calcular el área en Unit
distintos.
Crear una clase pila que permita insertar y extraer elementos de la misma
(hacer un array siguiendo el concepto de pila(métodos get_tope y pila_vacía)).

II. El Procesamiento de Imágenes Digitales y las
Gráficas por Computadora
- Introducción al Procesamiento de Imágenes y las Gráficas por Computadora
 Principales aplicaciones
 Algoritmos para el trazado de rectas
 Analizador Diferencia Digital (DDA)
 Algoritmo de Bresenham
2.1. Principales aplicaciones del Procesamiento de
Imágenes y las Gráficas por Computadora
 Diseño Asistido por Computadora (CAD)
 Gráficas, diagramas y modelos
 Arte por computadora
 Animación por computadora
 Interfases gráficas con el usuario
 Gráficas para uso doméstico
 Procesamiento de imágenes
2.2. Algoritmos para el trazado de rectas
Los algoritmos utilizados para el trazado de rectas se basan en la ecuación de
la recta:
y = m x + b
siendo m la pendiente y b la intercepción en y
Debido a que un segmento de recta puede ser definido por 2 puntos (x0, y0) y
(x1,y1), los valores de m pueden determinarse como:
m = y1 – y0

x1 – x0
2.3. Algoritmo DDA
También se conoce como Algoritmo básico incremental. Se incrementa
unitariamente una coordenada y se calcula la otra, es decir; se obtienen nuevos
valores de xi, yi en cada iteración, haciendo cálculos incrementales basados en
los pasos precedentes.
Para una línea con pendiente positiva: m  1
xi+1 = xi + 1
yi+1 = yi + m
¿Por qué?
y = mx + b
yi+1 = m(xi + 1) + b = mxi + b + m = yi + m
siendo m = y1 – y0
x1 – x0
Algoritmo:
1. Entrar los valores de x0, y0, x1, y1
2. y = y0
3. m = (y1 – y0)/(x1 – x0)
4. Para x = x0 hasta x1 con incremento 1
4.1 Escribir pixel (x, round(y))
4.2 y = y + m
Debido a que m es un número real cualquiera, se debe redondear al entero
más cercano, para cada valor de y calculado.
Para una línea con pendiente positiva m >1, el cambio de un pixel en x, puede
provocar incrementos en y de 2 o más pixeles, dejando huecos en el dibujo
Se invierten los papeles de x e y
yi+1 = yi + 1
xi+1 = xi + 1
m
Algoritmo:
1. Entrar los valores de x0, y0, x1, y1
2. x = x0
3. m = (x1 – x0)/(y1 – y0)
4. Para y = y0 hasta y1 con incremento 1
4.1 Escribir pixel ( round(x), y)
4.2 x = x + m

El algoritmo DDA tiene como inconveniente fundamental, que trabaja con
aritmética flotante, lo que ocasiona imprecisiones y demoras en la solución.
Ambos casos analizados, m  1 y m > 1, suponen que se trata de un línea que
va de izquierda a derecha. Si se trata de una línea que va de derecha a
izquierda, es decir, x0 > x1, entonces:
Para m  1:
xi+1 = xi - 1
yi+1 = yi – m
Para m > 1:
yi+1 = yi - 1
xi+1 = xi - 1
m
Ejercicio para el Laboratorio 1:
Elabore un programa que permita el trazado de rectas utilizando DDA, analice
los casos extremos, para pendiente m = 0 y m = infinito
2.4. Algoritmo de Bresenham:
Es más efectivo para el trazado de líneas debido a que elimina el trabajo con
aritmética flotante, hallando las coordenadas enteras más próximas a la
trayectoria real de la recta utilizando aritmética entera. Para dibujar el próximo
pixel, se tienen cuenta el punto medio entre los pixeles analizados.
Partiendo de la ecuación de la recta con pendiente dada:
y = mx + b
= (dy/dx) x + b
= dy x + dx b
Creando f(x,y):
f(x,y) = dy x – dy y + dx b (1)
Para 0 < m < 1 y x0 < x1

xp,yp
A partir de la función (1)
f(xp+1,yp+½) = dy(xp + 1) – dx(yp + ½) + dxb
= dyxp + dy – dxyp –dx/2 + dxb
Eliminando los términos que corresponden a la ecuación de la recta,
obtenemos :
dy – dx/2
para eliminar la aritmética flotante se multiplica por 2 y se obtiene el parámetro
d:
d = 2dy – dx
Si d<0 la recta está por debajo del punto medio, por lo tanto se escoge el pixel E
Si d>0 la recta está por encima del punto medio, por lo tanto se escoge el pixel NE
Si d = 0 se escoge E por convenio.
Este algoritmo trabaja adelantado un paso por lo que es necesario hallar el
próximo pixel entre los siguientes candidatos.
f(xp+2, yp + ½) y f(xp+2, yp + 3/2)
xp,yp
Obteniéndose
de = 2dy
dne = 2(dy – dx)
Algoritmo para 0<m<1 y x0<x1
1. dx = x1 – x0
2. dy = y1 – y0
3. d = 2dy – dx
4. de = 2dy
5. dne = 2(dy – dx)
6. x = x0
7. y = y0
8. escribir pixel(x,y)
9. Mientras x < x1

9.1 Si d<= 0 entonces d = d + de
sino d = d + dne
y = y + 1
9.2 x = x+1
9.3 escribe pixel (x,y)
Algoritmo para 0<m<1 y x0>x1
1. dx = x1 – x0
2. dy = y1 – y0
3. d = 2dy – dx
4. de = 2dy
5. dne = 2(dy – dx)
6. x = x0
7. y = y0
9. Mientras x > x1
9.1 Si d<= 0 entonces
y = y - 1
d = d + dne
sino d = d + de
9.2 x = x -1
En la conferencia anterior se estudió el algoritmo de Bresenham para el trazado
de rectas en el caso de pendiente positiva entre 0 y 1 y x0 < x1 y pendiente
positiva entre 0 y 1 y x0 > x1. Ahora se estudiarán los restantes casos.
Pendiente -1  m  0 y x0 < x1
xp,yp E
SE
Es necesario calcular nuevamente los parámetros d, de y dse, para determinar
las relaciones entre los puntos medios y la recta a trazar. Se parte de la función
obtenida f(x,y)
f(xp +1, yp –1/2) = dy(xp + 1) – dx(yp – ½) + dxb
= dyxp + dy – dxyp + dx/2 + dxb
Extrayendo la diferencia con la función original se obtiene:
dy + dx/2
Eliminando la aritmética flotante:
d = 2dy + dx

Para obtener la obtener la realción de la recta con los próximos pixeles
candidatose se calcula de y dse
f( xp + 2, yp – ½ ) = 2dy + dx/2
= 4dy + dx
de = 4dy + dx – d
de = 4dy + dx – 2dy – dx
de = 2dy
f( xp + 2, yp – 3/2 ) = 2dy + 3dx/2
= 4dy + 3dx
dse = 4dy + dx – d
dse = 4dy + 3dx – 2dy – dx
dse = 2dy + 2dx
dse = 2(dy + dx)
Algoritmo para -1  m  0 y x0 < x1
10. dx = x1 – x0
11. dy = y1 – y0
12. d = 2dy + dx
13. de = 2dy
14. dse = 2(dy + dx)
15. x = x0
16. y = y0
18. Mientras x < x1
d = d + dse
y = y - 1
sino d = d + de
18.2 x = x+1
Para el caso en que -1  m  0 y x0 > x1
NW
W xp,yp

Algoritmo para -1  m  0 y x0 > x1
1. dx = x1 – x0
2. dy = y1 – y0
3. d = 2dy + dx
4. de = 2dy
5. dse = 2(dy + dx)
6. x = x0
7. y = y0
9. Mientras x > x1
d = d + de
sino
y = y + 1
d = d + dse
9.2 x = x - 1
Pendiente m>1
En este caso, al igual que en el algoritmo incremental, se intercambian los
valores de x e y para eliminar la posibilidad de huecos.
N NE
xp,yp
Calculando d
F(xp + ½, yp + 1) = dy(xp + ½ ) – dx(yp + 1) + dxb
= dy/2 – dx
d = dy – 2dx
Calculando dn
F(xp + ½, yp + 2) = dy/2 – 2dx
= dy – 4dx

dn = dy – 4dx – d
dn = -2dx
Calculando dne
F(xp +3/2 , yp + 2) = 3dy/2 – 2dx
= 3dy – 4dx
dne = 3dy – 4dx – d
dne = 2dy - 2dx
dne = 2(dy – dx)
Algoritmo para m>0
1. dx = x1 – x0
2. dy = y1 – y0
3. d = dy - 2dx
4. dn = -2dx
5. dne = 2(dy - dx)
6. x = x0
7. y = y0
9. Mientras y > y1
d = d + dne
x = x + 1
sino d = d + de
9.2 y = y + 1

III. Trazado de círculos
Los parámetros básicos que definen una circunferencia, son las coordenadas
de centro (xc,yc) y el radio r. Teniendo en cuenta la simetría de las
circunferencias. Un punto determinado de la circunferencia, tiene sus puntos
simétricos que pueden ser dibujado a la vez, solo intercambiando coordenadas
y cambiando el signo de los valores.
Un punto (x,y) en un octavo de circunferencia, puede generar 7 más:
3.1. Subprograma CirclePoint
Procedure CirclePoint(xc, yc, r, x, y : Integer)
Begin
Putpixel(xc + x, yc + y);
Putpixel(xc - x, yc + y);
Putpixel(xc + x, yc - y);
Putpixel(xc - x, yc - y);
Putpixel(xc + x, yc + y);
Putpixel(xc - x, yc + y);
Putpixel(xc + x, yc - y);
Putpixel(xc - x, yc - y);
End;
3.2. Algoritmo de Bresenham para el trazado de circunferencias
Se selecciona el pixel que está más cerca de la trayectoria de la circunferencia
a trazar. Considerando una circunferencia con centro en (0,0), se calculan los
puntos de un octavo de circunferencia y los restantes puntos se obtienen
teniendo en cuenta el criterio de simetría. Se originan pasos desde x= 0 hasta x
= y, siendo la coordenada inicial (0,r).
Partiendo de la función de una circunferencia:
F(x,y) = x2
+ y2
– r2
Para saber cuál es el pixel más cercano se evalúa la función en el punto medio,
obteniéndose el parámetro d

xp,yp E
SE
Calculando d
F(1, r-1/2 ) = 5/4 – r
Para eliminar la aritmética flotante, se introduce d = h + ¼
h + ¼ = 5/4 – r
h = 1 – r
La comparación d<0 sería h < -1/4, pero esta comparación no se sustituye por
h < 0 para eliminar el trabajo con aritmética flotante.
Algoritmo
1. x = 0
2. y = r
3. leer xc
4. leer yc
5. d = 1-r
6. de = 3
7. dse = -2r + 5
8. CirclePoint (xc,yc,x,y)
9. Mientras y > x
9.1 Si d < 0 entonces
d = d + de
de = de + 2
dse = dse + 2
sino
d = d + dse
y = y-1
de = de +2
dse = dse + 4
9.2 x = x + 1
9.3 Circlepoint(xc,yc,x,y)
Tarea de Laboratorio
1. Elabore un programa para trazado de rectas por Bresenham incluyendo
todas las variantes
2. Elabore un programa para el trazado de círculos por Bresenham

IV. TRANSFORMACIONES
Transformaciones de coordenadas de ventana a viewport
Transformaciones bidimensionales:
 Traslación
 Cambio de escala
 Rotación
 Reflexión
4.1. Transformaciones de coordenadas
Cuando se desea representar un objeto del mundo real en la computadora,
primeramente se utiliza un sistema de coordenadas del mundo real, es decir,
en el caso del plano; se puede utilizar cualquier sistema de coordenadas
Cartesianas que sea conveniente. Cuando el objeto a dibujar ha sido
debidamente procesado, se procede a realizar una transformación de
coordenadas del mundo real a las coordenadas de pantalla.
4.1.1. Ventana
Es un área rectangular especificada en coordenadas del mundo real, donde
(xwmin,ywmin) es la esquina inferior izquierda de la ventana y (xwmax, ywmax)
es la esquina superior derecha de la ventana.
ywmax
ywmin
xwmin xwmax

ViewPort
Es el área rectangular en la pantalla, donde se va a representar la imagen encerrada en
la ventana. El viewport utiliza coordenadas de l dispositivo donde se va a hacer la
representación, en este caso; la pantalla. (xvmin, yvmin) es la esquina inferior izquierda
y (xvmax, yvmax) la esquina superior derecha.
yvmax
yvmin
xvmin xvmax
El viewport, al igual que la ventana, puede ser cualquier área de la pantalla. Cuando se
utilizan coordenadas normalizadas para el viewport, el sistema gráfico, será mucho más
independiente del dispositivo.
1
ViewPort
0 1
Antes de realizar cualquier despliegue de imagen, es necesario utilizar los
procedimientos que establecen las coordenadas de ventana y viewport.
Para una misma imagen, se pueden definir varias ventanas y viewports. En la
medida que las ventanas son más pequeñas, puede lograrse un acercamiento
o nivel de detalle del objeto en cuestión.
4.1.2. Ecuaciones de transformación de coordenadas de ventana
a viewport:
Esta transformación garantiza que se conserven las proporciones relativas de
los objetos en la ventana del mundo real. Esta tranformación se hará para cada
punto significativo del objeto a dibujar.
Se debe cumplir que:

xw - xwmin = xv – xvmin
xwmax – xwmin xvmax – xvmin
yw - ywmin = yv – yvmin
ywmax – ywmin yvmax – yvmin
Despejando de ambas ecuaciones a xv y yv se obtienen las coordenadas del
punto en el viewport:
Para la transformación de coordenadas de viewport a ventana, basta con
despejar en cada fórmula a xw y yw, respectivamente.
Tarea de Laboratorio:
Elabore los procedimientos
 SetWindows (xwmin, ywmin, xwmax, ywmax)
 SetViewPort(xvmin, yvmin, xvmax, yvmax)
 GetWindows (xwmin, ywmin, xwmax, ywmax)
 GetViewPort (xvmin, yvmin, xvmax, yvmax)
 WindowToViewPort y ViewPortToWindow
Recuerde que en las ecuaciones de transformación, no se tuvo en cuenta que
en el sistema de coordenadas de la pantalla, la y crece hacia abajo, téngalo en
cuenta para la elaboración de los procedimientos WindowToViewPort y
ViewPortToWindow. Elabore un programa que dibuje una casa utilizando el line
del compilador.
4.2. Transformaciones bidimensionales básicas
4.2.1. Traslación:
Es el movimiento en línea recta de un objeto, de una posición a otra. Un punto
se traslada de (x,y) a (x’, y’) a través de un factor de traslación Tx y Ty
y
(x,y) (x’,y’)
Ty
x
Tx
x’ = x + Tx
  xvminxwminxw
xwminxwmax
xvminxvmax
xv 



  yvminywminyw
ywminywmax
yvminyvmax
yv 




y’ = y + Ty
4.2.2. Cambio de escala:
Esta transformación permite alterar el tamaño de los objetos. Para escalar un
punto, se multiplican las coordenadas (x, y) por un factor de escala Sx en x y
un factor de escala Sy en y, obteniéndose (x’, y’)
y
(x,y) (x’,y’)
Sy
x
Sx
x’ = x * Sx
y’ = y * Sy
Para valores positivos (diferentes de uno) de Sx y Sy se aumenta el tamaño del
objeto y para valores negativos, disminuye.
4.2.3. Rotación:
Esta transformación permite la rotación de objetos alrededor de un punto dado
un ángulo de rotación. Se analizará la rotación alrededor del centro de
coordenadas.
(x’, y’)
r
 (x, y)
r

Las ecuaciones de transformación se obtienen de las relaciones entre los lados de los
triángulos rectángulos y los ángulos mostrados.
x’ = r cos ( + ) = r cos cos - r sen sen
y’ = r sen ( + ) = r sen cos + r cos sen
También:
x = r cos 
y = r sen 

Expresando las ecuaciones x’ y y’ en función de x e y:
x’ = x cos  - y sen 
y’ = y cos  + x sen 
Los valores positivos de  indican una rotación contraria a las manecillas del reloj.
4.2.4. Representación de matrices y coordenadas homogéneas
Generalmente en las aplicaciones gráficas es necesario hacer una sucesión de
transformaciones. Por ejemplo, puede necesitarse hacer una traslación de un
objeto, luego una rotación y a continuación; un cambio de escala. Más eficaz
que realizar una por una de las transformaciones, es calcular el resultado final
de la secuenciación de transformaciones, representando cada transformación
de forma matricial.
Para esto se utilizan las coordenadas homogéneas, donde una posición
coordenada (x,y) se representa mediante la triada [xh, yh, w]
En las transformaciones analizadas, w= 1.
Traslación
[x’ y’ 1] = [x y 1] 1 0 0
0 1 0
Tx Ty 1
Siendo la matriz de traslación, la matriz T
T = 1 0 0
0 1 0
Tx Ty 1
En forma compacta se expresa:
P’ = P * T
P’  [x’ y’ 1]
P  [x y 1]
Para calcular el punto resultante de la traslación de (x,y) con factores de traslación Tx y
Ty no es buena práctica utilizar un procedimiento que explícitamente multiplica un
vector por una matriz, debido a que esto implica la ejecución de sumas y productos
innecesarios. El procedimiento para trasladar un punto dadas sus coordenadas y los
factores de traslación, sería:
Procedure Trasladar(x,y,Tx,Ty: Integer; Var xp, yp: Integer);
Begin
xp := x + Tx;
yp := y + Ty;

end;
Cambio de escala
[x’ y’ 1] = [x y 1] Sx 0 0
0 Sy 0
0 0 1
P’ = P * S
S = Sx 0 0
0 Sy 0
0 0 1
Procedure Escalar (x, y, Sx, Sy: Integer; Var xp, yp: Integer);
Begin
xp = x * Sx;
yp = y * Sy;
end;
Rotación
[x’ y’ 1] = [x y 1] cos sen 0
-sen cos 0
0 0 1
P’ = P * R()
R() = cos sen 0
-sen cos 0
0 0 1
Procedure Rotar (x, y, sita: Integer; Var xp, yp: Integer);
Begin
xp := x * cos (sita) - y * sen (sita);
yp := y * cos (sita) + x * sen (sita);
end;
Secuenciación de transformaciones
Cualquier sucesión de transformaciones puede representarse a través de una
matriz de transformación compuesta calculando el producto de las matrices de
transformación involucradas.
Ejemplo:

Rotación de un punto alrededor de un punto arbitrario (xr, yr) un ángulo sita. En
esta operación están involucradas 3 transformaciones:
1. Trasladar el centro de rotación al origen de coordenadas Tx = -xr y Ty = -xr
2. Rotar alrededor del origen de coordenadas un ángulo sita
3. Trasladar el punto a su posición original Tx = xr y Ty = yr
1 0 0 cos sen 0 1 0 0
0 1 0 * -sen cos 0 * 0 1 0
-xr -yr 1 0 0 1 xr yr 1
M = T(-xr,-yr) * R(sita) * T(xr,yr)
Para realizar una secuenciación de transformaciones en programa, se tiene en
cuenta que:
[x’ y’ 1] = [x y 1] a d 0
b e 0
c f 1
Como se observa, no son necesarias todas las sumas y productos del vector
por la matriz, sino que son de interés, solo las dos primeras columnas de la
matriz. Por lo tanto, las ecuaciones explícitas para calcular las coordenadas
transformadas son:
x’ = ax + by + c y’ = dx + ey + f
En el programa, se debe mantener una matriz, que se inicializa en:
0 0 0
0 0 0
0 0 1
Los elementos de las dos primeras columnas se van actualizando en la
sucesión de transformaciones.
Tarea de laboratorio:
Programe los subprogramas correspondientes a las transformaciones básicas:
Traslación
Rotación
Cambio de escala
Elabore un programa que permita realizar la rotación de un cuadrado alrededor
de un punto dado.

V. Algoritmos de corte
5.1. Cohen – Sutherland para el corte de líneas
Cuando se dibuja un área determinada de una ventana en un viewport (puerta
de visión), solo debe dibujarse la parte de la imagen que está dentro de la
ventana y lo que está por fuera, se desprecia.
Cuando se define una ventana se realiza el corte a la ventana y luego se dibuja
en el viewport. También se puede hacer la transformación de coordenadas de
mundo real a viewport y luego hacer el corte en coordenadas del dispositivo.
El corte de líneas a desarrollar, se basa en cortar contra las coordenadas de
ventana del mundo real. Esto implica:
xwmin  x  xwmax
ywmin  y  ywmax
Los pasos para el dibujo de un área determinada de ventana, serían:
Entrada de Dibujar en viewport
coordenadas el resultado del corte
de ventana
Transformación de la visión
Algoritmo de Cohen – Sutherland para el corte de líneas
Y P4 Y
P3 Ventana Ventana
P5 P6 P5 P6
P7 P8 P7’ P8’
P9 P9
P10 P10’
X X
Antes del corte Después del corte
El algoritmo determina cuáles rectas están totalmente dentro de la ventana,
totalmente fuera y cuáles están parcialmente dentro y deben ser cortadas.
Corte
contra
ventana
Transformación
de coordenadas
de ventana a
viewport

Las líneas que están parcialmente dentro de la ventana, deben ser cortadas
hallando el punto de intersección entre la recta y el lado de la ventana con a la
cual intercepta.
Pasos para el corte y dibujo del área dentro de la ventana:
 Determinar cuáles líneas se recortarán
 Hallar los puntos de intersección de estas líneas con la ventana
 Transformar las coordenadas de los puntos que determinan los segmentos
de recta dentro de la ventana, a coordenadas de viewport
 Dibujar en coordenadas de viewport
Algoritmo:
1. Cada extremo de las líneas de un dibujo, es asignado a un código
binario de 4 dígitos, llamado código de región
2. Las regiones se establecen en relación a las fronteras de la ventana
1001 1000 1010
0001 0000 0010
0101 0100 0110
Disposición de los bits de derecha a izquierda
Bit 1  izquierda
Bit 2  derecha
Bit 3  abajo
Bit 4  arriba
Un valor de 1 en cualquier posición de bit, indica que el punto está en esa
región. Dentro de la ventana el código de región es 0000. El valor de cada bit
para cada punto se determina comparando con las coordenadas de ventana: el
bit 1 es 1 si x < xwmin y así sucesivamente.

1. Determinar cuáles líneas están completamente fuera de la ventana y
cuáles están completamente dentro:
 Si ambos puntos de la línea tienen código de región 0000, la línea está
completamente dentro de la ventana y no hay que cortarla
 Si ambos puntos de la línea tienen 1 en la misma posición del bit, la línea
está completamente fuera de la ventana y se elimina del dibujo
 Cualquier otro caso, es una línea que debe cortarse, por lo que es necesario
hallar los puntos de intersección. Estas líneas pueden o no atravesar el
interior de la ventana.
P2
P2’
ventana
P1’
P3
P3’ P1
P4
1) Realizar el corte de líneas determinando los puntos de intersección con
las rectas que definen a la ventana:
x = xwmin x = xwmax
y = ywmin y = ywmax
Se utiliza la ecuación de la recta en cuestión dada por 2 puntos (x1,y1) y
(x2,y2)
La coordenada y del punto de intersección se calcula:
y = y1 + m (x – x1)
x = xwmin o x = xwmax
La coordenada x del punto de intersección se calcula:
x = x1 + (y – y1)/m
y = ywmin o y = ywmax
Procedimiento para el corte por Cohen – Sutherland
Var

xwmin, xwmax, ywmin, ywmax : real;
procedure Clip_a_line(x1, y1, x2, y2 : real);
type
boundaries = (left, right, bottom, top);
code = array [boundaries] of boolean;
var
code1, code2 : code;
done, diaplay : boolean;
m : real;
color: Integer;
procedure encode (x, y: real; var c : code);
begin
if x < xwmin then c[left] := true
else c[left] := false;
if x > xwmax then c[right] := true
else c[right] := false;
if y < ywmin then c[bottom] := true
else c[bottom] := false;
if y > ywmax then c[top] := true
else c[top] := false;
end;
function accept (c1, c2 : code) : boolean;
var
k : boundaries;
begin
{ si un punto tiene true en su código no es posible aceptación trivial}
accept := true;
for k := left to top do
if c1[k] or c2[k] then accept := false;
end;
function reject (c1, c2 : code) : boolean;
var
k : boundaries;
Begin
{Si los puntos extremos tienen true que concuerdan, se desprecia la línea}
reject := false;
for k := left to top do
if c1[k] AND c2[k] then reject := true;
end;

procedure swap_if_needed (var x1, y1, x2, y2 : real; var c1, c2 : code);
Begin
{asegura que x1,y1 es un punto fuera de la ventana y c1 es su código}
end;
Begin {Clip_a_line}
done := false;
display := false;
while NOT done do
Begin
Encode (x1, y1, code1);
Encode ( x2, y2, code2);
If accept (code1, code2) then
Begin
Done := true;
Display := true;
End
Else
If reject (code1, code2) then done := true
Else
Begin {hallar la intersección }
{ asegurar que x1,y1 está fuera de la ventana}
swap_if_needed (x1, y1, x2, y2, code1, code2);
m := (y2 – y1)/(x2 – x1);
if code1[left] then
Begin
y1 := y1 + (xwmin – x1) * m;
x1 := xwmin;
end {cruza hacia la izquirda}
else
if code1[right] then
Begin
y1 := y1 + (xwmax – x1) * m;
x1 := xwmax;
end {cruza hacia la derecha}
else
if code1[bottom] then
Begin
x1 := x1 + (ywmin – y1) / m;
y1 := ywmin;
end {cruza hacia abajo}
else
if code1[top] then
Begin
x1 := x1 + (ywmax – y1) / m;
y1 := ywmax;
end {cruza hacia arriba}

end {hallar intersección}
end ; {while}
if display then
line(x1, y1, x2, y2, color);
end; {Clip_a_line}
Defina un dibujo simple de una casa en coordenadas del mundo real. Elabore
un programa que permita definir diferentes ventanas y realice el corte por
Cohen – Sutherland.
5.2. Sutherland – Hodgman para el corte de polígonos.
Los polígono pueden recortarse, procesando cada línea con el algoritmo
estudiado para el corte de líneas. Cuando la frontera del polígono recortado,
define un área por rellenar, debe generarse las líneas que faltan.
Antes del corte Después del corte
El algoritmo estudiando debe modificarse para que queden las áreas cerradas
y luego puedan ser rellenadas por algún algoritmo de relleno de superficies.
Algoritmo de Sutherland – Hodgman para el recorte de polígonos
1. Las áreas del polígono se definen especificando una secuencia de ordenada de
vértices

2. Cada vértice se compara contra una frontera de la ventana
3. Los vértices dentro de la arista de la ventana actual, se salvan para recortarse contra
la siguiente frontera. Los vértices fuera de la arista se desprecian
4. Si se va de un punto interior de la arista a uno exterior, se salva la intersección de la
línea con la frontera de la ventana y así con las otras variantes.
I
S P S P
P S
P I S
Salvar P Salvar I No salvar Salvar I,P
5. Cada punto salvado pasa al subprograma de corte. Se salva un vértice o una
intersección, solo después de haber sido procesado contra todas las fronteras.
6. Se dibujan los nuevos vértices del polígono
Debido a que al cortar un polígono cóncavo contra una ventana rectangular,
puede obtenerse como resultado más de un polígono, las áreas separadas se
unen con líneas conectivas.
Algoritmo de Sutherland – Hodgman para corte de polígonos cóncavos y
convexos
Type
Point = array [1.. maxpoints] of real;
Procedure polygon_clip(n : Integer; x, y : point; var m : Integer; var xout, yout : point);
Const
Boundary_count = 4;
Type
Vertex = array [1..2] of real;
Boundary_range = 1.. boundary_count;
Var
k : Integer;
p : vertex;
s, first_point : array [1.. boundary_count] of vertex;
new_edge : array [1.. boundary_count] of boolean;
function inside ( p : vertex; edge : boundary_range ) : boolean;
Begin
{retornar true si el vértice p está dentro de la arista de la ventana}
end;
function cross ( p, s : vertex; edge : integer) : boolean;
Begin
{ retornar true si el lado ps de polígono interseca la arista de la ventana}
end;
procedure output_vertex (p : vertex);

begin
m := m + 1;
xout[m] := p[1];
yout[m] := p[2];
end;
procedure find_intersection ( p, s : vertex; edge : boundary_range; var i : vertex);
Begin
{ retornar en el parámetro i la intersección de ps con la arista de la ventana}
end;
procedure clip_this ( p : vertex; edge : boundary_range);
var
i : vertex;
Begin
{ salvar el primer punto recortado contra una arista de la ventana}
if new_edge[edge] then
Begin
first_point [edge]:= p;
new_edge[edge] := false;
end
else
{si ps cruza la arista de la ventana, hallar la intersección, recortar la intersección
contra la siguiente arista de la ventana}
if cross ( p, s[edge], edge) then
Begin
find_intersection ( p, s[edge], edge, i);
if edge < boundary_count then
clip_this ( i, edge + 1)
else
output_vertex (i);
end; {si ps cruza la arista}
{actualizar el vértice salvado}
s[edge] := p;
{ si p está dentro de la arista de la ventana, recortar contra la siguiente arista}
if inside (p , edge) then
clip_this (p, edge + 1)
else
output_vertex (p);
end; { clip_this}
procedure clip_closer;
{ para cada arista de la ventana, recorta la línea que conecta el último
vértice salvado y el primer punto procesado contra la arista }
var
i : vertex;

edge : integer;
Begin
for edge := 1 to boundary_count do
if cross ( s[edge], first_point[edge], edge ) then
Begin
find_intersection (s[edge], first_point[edge], edge, i);
clip_this (i, edge + 1)
else
output_vertex (i)
end { si s y el primer punto punto cruzan la arista }
end; { clip_closer }
Begin {polygon_clip}
m := 0; { número de vértices de salida }
for k := 1 to boundary_count do
new_edge[k] := true;
for k := 1 to n do { coloca cada vértice en la serie }
Begin
p[1] := x[k];
p[2] := y[k];
clip_this (p, 1) { corta contra la primera arista de la ventana }
end;
clip_closer;
end; {polygon_clip}
Basado en el algoritmo de corte de polígonos estudiado, elabore el objeto
polígono.
Incorpore el algoritmo de corte de polígonos a su biblioteca y elabore un
programa para comprobar su uso.
Elabore el subprograma rectangle(x0,y0,x1,y1,color)

VI. RELLENO DE POLÍGONOS
 Rellenado de rectángulos
 Rellenado de polígonos cóncavos y convexos por el algoritmo “Scan Line”
(Línea de exploración)
6.1. Rellenado de rectángulos
Este algoritmo es muy simple y evidente y podría interpretarse como:
Para y= ymin hasta ymax
Para x = xmin hasta xmax
Escribirpixel(x,y,color)
Si se consideran las fronteras para el caso en se desea dibujar rectángulos
consecutivos sin reescribir sobre las mismas líneas:
Para y= ymin hasta ymax - 1
Para x = xmin hasta xmax - 1
Escribirpixel(x,y,color)
Ambos algoritmos pueden modificarse utilizando una sola estructura repetitiva y
un procedimiento de trazado de line
6.2. Rellenado de polígonos por “Scan Line”
Polígono convexo Polígono cóncavo
Este algoritmo utiliza una línea de rastreo o exploración para ir llenando los
espacios interiores del polígono. Utiliza un algoritmo incremental para
determinar la intersección de la línea de rastreo con las tramas del polígono, a
partir de las intersecciones anteriores. Este algoritmo se ejecuta en
coordenadas de viewport.
Algoritmo general:
1. Buscar los interceptos de la línea de exploración con los lados del polígono
2. Ordenar los interceptos en orden creciente de las abscisas (x)

3. Dibujar los pixeles entre 2 interceptos, utilizando la regla de la paridad impar para
determinar si un pixel es interior o no.
Paso 3 del algoritmo:
La regla de paridad impar plantea que la paridad al inicio es par y cada
intercepto encontrado invierte la paridad. Solo se dibuja cuando la paridad es
impar.
1. Si avanzando de izquierda a derecha se encuentra un intercepto fraccionario y se
estaba dentro del polígono; se redondea el valor del intercepto hacia abajo. Si se
estaba fuera del polígono se redondea hacia arriba para garantizar que el pixel sea
interior.
2. Si el extremo izquierdo de un tramo es entero, se toma como interior y se dibuja, el
derecho es exterior.
3. Un vértice ymax de un lado es considerado solamente si es su vez, ymin de otro lado
adyacente
4. Las líneas horizontales inferiores se dibujan mientras que las superiores no.
11 D
10 F
9
8 E
7
6
5 C
4
3 A
2
1 B
1 2 3 4 5 6 7 8 9 10 11 12 13 Scan Line y = 2
Paso 1 del algoritmo:
Buscar los interceptos de la scan line con los lados del polígono
Para calcular el nuevo intercepto de la scan line con un lado del polígono, se
tiene en cuenta el intercepto anterior:
xi+1 = x1 + 1/m m = (ymax – ymin)/(xmax – xmin)
Este incremento en x puede ser expresado como una fracción con
denominador:
ymax – ymin

Se puede evitar la aritmética flotante, manteniendo el numerador y observando
que la parte fraccionaria es mayor que 1 cuando el numerador es mayor que el
denominador. Es en este caso cuando hay que incrementar x.
Algoritmo:
1. x = xmin
2. numerador = xmax – xmin
3. denominador = ymax – ymin
4. incremento = denominador
5. Para y = ymin hasta ymax
5.1 escribirPixel (x, y, color)
5.2 incremento = incremento + numerador
5.3 Si incremento > denominador
5.3.1 x = x+1
5.3.2 incremento = incremento – denominador
Algoritmo de la Tabla de Lados Activos (AET)
1. Crear Tabla de Lados Globales con la siguiente estructura de nodo
Ymax Xmin 1/m
Ymax  coordenada y máxima del lado
Xmin  coordenada x de la y mínima del lado
m  pendiente de la recta que representa a dicho lado
 Cada lado se incorpora solo una vez en la lista en la posición correspondiente a la y
mínima
 En una lista, los lados están ordenados en orden creciente de las x de la ymin
Para el ejemplo anterior, la Tabla de Lados Global (ET) es:
9
8
7 9 7 -5/2 11 7 6/4
6
5 11 13 0
4
3 9 2 0
2
1 3 7 -5/2 5 7 3/2

2. Una vez creada la Tabla de Lados Global se trabaja con la Tabla de
Lados Activos según el algoritmo:
1. y = primera ymin cuya lista de lados no esté vacía (1 en el ejemplo)
2. Inicializar la Tabla de Lados Activos (AET) en vacía
3. Repetir hasta que ET y AET estén vacías
3.1 Mover la lista de ordenada y de la ET a la AET
3.2 Ordenar la AET según las x
3.3 Dibujar los pixeles en la scan line y con las x de la AET
3.4 Y = y + 1
3.5 Eliminar de laAET los lados cuyas ymax = y
3.6 Calcular los nuevos valores de x
Utilizando el algoritmo con el ejemplo anterior:
y = 1
AB BC
3 7 -5/2 5 7 3/2
Dibujar (7,1)
y = 2
AB BC
3 9/2 -5/2 5 17/2 3/2
Dibujar (5,2) – (8,2)
y = 3
Debido a que ymax del AB es 3 se elimina este lado de la AET y en la ET en la y = 3 se
encuentra el lado FA que se adiciona a la AET ordenando en orden creciente de las x
FA BC
9 2 0 5 10 3/2
Dibujar (2,3) – (9,3)
 Programar el algoritmo de Scan Line para el relleno de polígonos.
 Elabore las primitivas rectangle(x0,y0,x1,y1) y polygon(vertex,
list_vertex)
 Elabore un programa para ejemplificar el uso de las primitivas y el
relleno

VII. La tercera dimensión
 Sistema de coordenada tridimensional
 Modelación de sólidos
 Algunos métodos de modelación
- Parametrización de primitivas
- Representación de recorrido
- Representación de frontera
- Representaciones de particionamiento espacial:
- Descomposición celular
- Enumeración del espacio ocupado
- Octrees
- Geometría conductiva de sólidos
Introducción
La tercera dimensión en Gráficas por Computadora, permite la representación
de objetos sólidos del mundo real o el diseño de estos objetos desde la
computadora. Los objetos pueden modelarse de diferentes formas, ya sea por
estructuras de líneas y vértices, por superficies planas, por superficies curvas,
etc.
Las descripciones de sólidos se especifican utilizando un sistema de
coordenadas reales tridimensional y se proyectan y dibujan, sobre un sistema
bidimensional como es la pantalla de la computadora.
Sistema de coordenadas tridimensionales
Sistema de la mano derecha:
Y
y
P
X x
z
Z
En 3D un punto está representado por sus tres coordenadas P(x,y,z)
Para representar un objeto del mundo real o reproducir un objeto sólido
en la pantalla, se siguen los siguientes pasos:

1. Representar el objeto en memoria, utilizando algún modelo de
representación de sólidos
2. En dependencia del tipo de proyección que se valla a hacer del objeto
(perspectiva o paralela), realizar las transformaciones de normalización para
llevar al objeto a un volumen canónico.
3. Realizar el corte de polígonos del sólido contra el volumen canónico
4. Eliminar las líneas y superficies ocultas
5. Obtener los parámetros del objeto resultado de la proyección
6. Realizar la transformación de coordenadas de ventana a viewport
7. Dibujar el objeto ya proyectado
8. Realizar el relleno de polígonos según un modelo de iluminación
Modelación de sólidos
La Geometría es la parte de las Matemáticas que estudia las propiedades y
medidas de la extensión. En muchas aplicaciones es necesario modelar los
objetos sólidos para distinguir las superficies, delimitar los interiores y
exteriores, etc., es decir, definir su geometría para poder procesar sus
propiedades.
Si un objeto sólido puede ser modelado de forma tal que se capture
adecuadamente su geometría, entonces se puede realizar sobre él, un conjunto
de operaciones útiles antes de ser manufacturado. Puede predecirse si un
objeto intercepta a otro, si el brazo de un robot alcanzará a determinado objeto,
si una herramienta de corte cortará solo lo deseado, etc.
En la simulación de mecanismos físicos es necesario calcular propiedades
como volumen, centro de masa, etc. Una representación satisfactoria de un
objeto sólido puede hacer posible la generación de instrucciones automáticas
para máquinas herramientas controladas por computadoras, para crear esos
objetos.
La modelación de sólidos permite:
- Conocer la geometría de los objetos sólidos
- Determinar las posiciones relativas entre objetos
- Calcular propiedades físicas como volumen, centro de masa, etc.
- Representación gráfica realista de los objetos
- Simulación de mecanismos físicos
1. Parametrización de primitivas
Utiliza sólidos tipos, definidos como primitivas que contienen un conjunto de
parámetros que permiten su reproducción diversa según dichos parámetros, es
decir, para obtener otro sólido del mismo tipo, solo es necesario cambiar los
valores de los parámetros.
Primitiva Nuevo sólido

Parámetros:
- Largo
- Ancho
- Profundidad
2. Representaciones de recorrido
Consiste en la creación de sólidos a partir de la traslación o extrucción a través
de un eje o de la rotación alrededor de un eje.
Trayectoria en el plano Extrucción a lo largo de un jej
Trayectoria en el plano Revolución alrededor de un eje
3. Representación de frontera
Los objetos son descritos en términos de sus superficies fronteras: vértices,
aristas y caras.
Las superficies planas están limitadas por polígonos mientras que las curvas
son aproximadas a un conjunto de superficies planas.

Ejemplo:
Vértices Aristas Caras
V1 V1-V2 V1-V2-V3_v4
V2 . .
. . .
Vn Vn-1-Vn Vn-2-Vn-1-Vn
Los vértices en las caras se definen de forma tal que por regla de la mano
derecha, se obtenga la normal en la dirección hacia el exterior del sólido.
4. Representaciones de particionamiento espacial
El sólido está compuesto por una colección de sólidos adjuntos que no se
interceptan y no necesariamente son del mismo tipo.
4.1Descomposición celular:
A partir de un conjunto de células primitivas, se forman los objetos sólidos. Las
células primitivas son generalmente paramétricas.
Primitiva Primitiva
4.2Enumeración del espacio ocupado
Las células primitivas son idénticas y forman una red regular. La célula más
utilizada es el cubo. Para definir un objeto en la red de células, se especifica
qué célula está ocupada por el mismo.

4.3Octrees
Es una variante jerárquica de la enumeración del espacio ocupado. Se supone
que el espacio está parcialmente ocupado y se subdivide en 8 cubos que serán
subdivididos a su vez en 8, si están parcialmente ocupados por los objetos, en
caso contrario, no se subdividen.
Existe un criterio para determinar cuándo no se continúa particionando debido
al tamaño del cubo y para determinar si una célula pequeña, está parcialmente
ocupada o no por el objeto.
4.4Geometría conductiva de sólidos
Los objetos se almacenan como árboles en cuyas hojas se en cuentran
primitivas y en los nodos se encuentran operaciones booleanas.

VIII. Vistas en 3D
 Necesidad de las proyecciones geométricas planas.
 Proyecciones paralelas y perspectivas
8.1. Introducción
Debido a que los objetos tridimensionales serán representados en una
superficie plana como es la pantalla del monitor de la computadora, es
necesario lograr una proyección de dichos objetos en un plano bidimensional.
De forma general, una proyección transforma los punto situados en un sistema
de dimensión n, en puntos de un sistema de dimensión n-m (m>0).
8.2. Proyecciones
Existen dos métodos básicos para proyectar objetos tridimensionales sobre una
superficie bidimensional:
 Proyección en paralelo
 Proyección en perspectiva
Cuando se realiza una proyección se obtiene una vista determinada del objeto
en dependencia de los parámetros de la proyección.
8.2.1. Proyecciones en paralelo
Plano de proyección
Las vistas que se obtienen de esta proyección, dependen del ángulo que se
forma entre la dirección de proyección y el plano de proyección. Si la dirección
de la proyección es perpendicular al plano de proyección, es proyección
ortogonal y si no; es proyección oblicua.

Ortogonal
Se clasifican en:
Clásicas:
El plano de proyección es paralelo a uno de los planos coordenados para
obtener las tres vistas clásicas:
 Planta
 Frontal
 Lateral
Si el plano de proyección no es paralelo a ninguna de las caras del objeto, o lo
que es lo mismo; no es perpendicular a ninguna de sus aristas, entonces se
trata de una proyección axonométrica.
Axonométricas
En estas proyecciones varían las distancias y los ángulos del objeto, pero se
conserva el paralelismo. Se clasifican en:
 Isométricas
 Dimétricas
 Trimétricas
Isométricas: Acorta la distancia de los ejes en la misma medida
Dimétricas: Las distancias de dos de los ejes se acortan en la misma medida
Trimétricas: Las distancias en los tres ejes, se acortan de manera desigual
Proyecciones oblicuas:
En estas proyecciones el plano de proyección es paralelo a una de las aristas
del objeto pero no es perpendicular a la dirección de la proyección.
Se clasifican en:
 Caballera
 Cabinete

Caballera:
La dirección de la proyección forma un ángulo de 45º con el plano de
proyección y no se producen acortamientos
α =45º
Las componentes de la dirección de la proyección referidas al sistema son:
x’, y’, z’: (cos α, sen α, 1)
Cabinete o militar
Se produce un acortamiento a la mitad de las líneas paralelas al eje z y es más
realista
x’, y’, z’: (cos α, sen α, 2)
8.2.2. Proyecciones perspectivas
En estas proyecciones no se trabaja con la dirección de la proyección, sino con
un centro de proyección situado a una distancia finita del plano de proyección,
creándose un efecto visual parecido al producido por el sistema de visión
humano.
El tamaño de los objetos es inversamente proporcional a la distancia que los
separa del centro de proyección. Las distancias, ángulos y el paralelismo del
objeto, varían en la proyección, excepto los ángulos y paralelas que se
encuentran en una cara paralela al plano de proyección.

a Plano de proyección
a’
centro de proyección
b b’
Las proyecciones perspectivas se clasifican en:
Simple escorzo:
Se obtiene al proyectar un paralelepípedo con una cara paralela al plano de
proyección. En dicha cara se conservan los ángulos y las paralelas mientras
que en las otras caras las paralelas tienden a interseptarse en un solo punto. A
esta proyección también se le llama proyección con un punto de fuga.
Doble escorzo:
Se obtiene al proyectar un paralelepípedo con una arista paralela al plano de
proyección. Sólo se conserva el paralelismo para las rectas paralelas al plano
de proyección. Se observan dos puntos donde tienden a interceptarse las
restantes aristas por lo que esta proyección se conoce también como
proyección con dos puntos de fuga.

Triple escorzo
En esta proyección no hay ni arista ni cara paralela al plano de proyección por
lo que no se conservan las distancias, ángulos ni paralelismo y se observan
tres puntos de fuga.
Vistas
La vista es el resultado de seleccionar los parámetros de la proyección en
dependencia del tipo de proyección, y obtener la vista del objeto según esos
parámetros.
Parámetros de la vista para fijar el sistema de coordenadas del plano de
proyección
El plano de proyección queda determinado por:
PR  Punto de referencia de la vista, se encuentra en el plano de proyección y
coicide con el origen del sistema del plano de vista

N  Vector normal al plano de proyección
DV  Es un vector que expresa la dirección vertical. La proyección de este
vector en el plano de proyección determina el eje Y del sistema del plano de la
vista
Obtención de los ejes coordenados del sistema de la vista:
1. Z’ coincide con N
2. El producto vectorial de Z’ con un vector cualquiera (0,1,0) (dirección del
eje Y) determina la coordenada X’
3. El producto vectorial Z’ x X’ determina el eje Y’
Para facilitar el proceso de obtención de la vista, se obtiene un volumen de
visión canónico
Parámetros del sistema de coordenadas de la vista para determinar la
proyección y el volumen de visión canónico:
Proyección perspectiva

Proyección paralela
Parámetros de la proyección
Umax, Vmax  esquina superior derecha de la ventana en el plano de vista
Umin, Vmin  esquina inferior izquirda
ZF  coordenada Z del plano frontal
ZP  coordenada Z del plano posterior
CP  Centro de proyección en proyección perspectiva. En paralela: DP = CV – CP
CV  centro de la ventana
CV = ((Umax + Umin)/2, (Vmax + Vmin)/2, 0)
Volúmenes de visión canónicos

Proyección paralela
Proyección perspectiva

IX. FOTOMOSAICOS EN LAS IMÁGENES
DIGITALES
9.1. Percepción de colores
El ojo tiene dos tipos de receptores: bastones y conos. Los bastones transmiten
diferentes intensidades de gris y los conos le permiten al cerebro percibir la
tonalidad de los colores. Existen tres tipos de conos, el primero es sensible a la
luz rojo/naranja, el segundo a la luz verde y el tercero a la luz azul/violeta.
Cuando un cono es estimulado, el cerebro percibe el color correspondiente. Por
ejemplo, cuando los conos verdes son estimulados, se percibe el color verde;
cuando los conos rojo/naranja son estimulados, se percibe el color rojo. Si son
estimulados simultáneamente ambos tipos de conos, los verdes y los
rojo/naranja, se percibe el color amarrillo. El ojo no puede diferenciar entre un
color amarillo espectral, y alguna combinación de rojo y verde. Lo mismo
sucede con nuestra percepción de los colores cian, magenta, y los otros
colores espectrales intermedios. Debido a esta respuesta fisiológica, el ojo
puede percibir una amplia gama de tonalidades por medio de la variación de
solo tres colores: rojo, verde y azul. Cualquier color puede ser espectralmente
analizado usando un prisma para determinar sus intensidades primarias de
rojo, verde y azul.
9.2. Imágenes digitales
La digitalización de imágenes es el proceso por medio del cual se convierte una
imagen en un formato interpretable por las computadoras. Una imagen digital
se puede obtener utilizando cámaras fotográficas digitales, escáneres, etcétera.
En la década de los ochenta solo era posible utilizar cuatro colores en las
pantallas de las computadoras. Esto evolucionó rápidamente y actualmente se
utilizan millones de colores.
Una imagen digital es un arreglo de dos dimensiones de píxeles ( picture
element ) y un píxel es la unidad mínima que conforma una imagen digital.
9.3. Representación de colores en imágenes digitales.
Normalmente, los colores primarios son el rojo, el amarillo y el azul, y a partir de la
mezcla de estos se crean los otros colores. Sin embargo, en las imágenes digitales
los colores primarios son el rojo (Red), el verde (Green) y el azul (Blue) y se tilizan
las intensidades de luz para obtener nuevos colores. Esto dio lugar al sistema
RGB.
Una imagen digital está compuesta por una matriz bidimensional de elementos
RGB. En imágenes digitales de color verdadero, se utilizan 8 bits (1byte) para
representar la intensidad de cada componente o canal de color, y por ser 3
componentes por color, se necesitan 24 bits (3 bytes) para formar un solo color, lo
que es equivalente a un píxel. Entonces, una imagen de 10 x 10 píxe les utiliza
2400 bits o sea 300 bytes.
Siguiendo el esquema de 1 byte por cada componente o canal, y sabiendo que el
valor máximo que puede ser representado por 1 byte es 255, la intensidad de una

canal está en un rango de 0 a 255, por lo que un píxel estará compuesto por tres
diferentes intensidades de R, G y B en un rango de 0 a 255.
El sistema RGB no es el único utilizado en las imágenes digitales. Se han
creado diversos sistemas para representar los colores según la aplicación. El
sistema RGB es nativo de las computadoras, pero no siempre es el más
adecuado. Es un sistema aditivo porque el color blanco se logra mezclando los
tres colores rojo, verde y azul, y el negro es la ausencia de color. Por el
contrario, en el sistema CMY (Cyan, Magenta, Yellow) utilizado para los medios
impresos, expresa las intensidades de los colores cian, magenta y amarillo, es
un sistema sustractivo porque el color negro se logra mezclando los tres
colores y el blanco es la ausencia de color.
En el sistema RGB el blanco es RGB (255, 255, 255) y el negro es RGB (0, 0,
0), en donde los valores entre paréntesis son las intensidades de cada uno de
los canales RGB. RGB(255,0,0), RGB(0,255,0) y RGB(0,0,255) representan el
rojo, el verde y el azul respectivamente. Al mezclar el color rojo con el azul se
obtiene el color morado, RGB(255, 0, 255). Se pueden crear todos los colores
disponibles variando las intensidades de las componentes RGB.
Otro sistema es el YUV, que fue adoptado por National Television System
Commitee (NTSC) para la transmisión de señales de televisión a color. Su
propósito es hacer uso de las características del ojo humano para maximizar la
utilización de un ancho de banda definido. El sistema visual humano es más
sensible a los cambios de intensidad del color que a los cambios de la
tonalidad. Existe una formula para convertir de un sistema de representación
de colores a otro. En la conversión no se pierde la información sino se
representa de una forma distinta.
9.4. Resolución de las imágenes digitales
La resolución es un factor que se utiliza para convertir las dimensiones de una
imagen física a píxeles de una imagen digital y viceversa. Si una fotografía es
digitalizada a 300 dpi (Dots Per Inch) o puntos por pulgada, significa que por
cada pulgada de la fotografía física original se van a obtener 300 píxeles en la
imagen digitalizada. Si se imprime una imagen a 75 dpi, quiere decir que por
cada 75 píxeles se imprimirá una pulgada sobre papel.
9.5. El proceso de creación de fotomosaicos
Notación y vocabulario
A continuación se encuentra una lista de la notación y el vocabulario utilizados
Cuadro Una división de la imagen original. La imagen
original es dividida en partes iguales a las
que se les llamaran cuadros.
C (x, y) Cuadro localizado en x, y dentro de la matriz de
cuadros que conforman la imagen original.
W y H El ancho y el alto de un cuadro.
X y Y Columna y fila.
RGB(r,g,b) Un color en formato RGB con sus
correspondientes componentes rojo, verde y
azul. Ejemplo: RGB(100, 25, 210)

Imagen original La imagen que será transformada en
fotomosaico.
Colección de
imágenes
El conjunto de imágenes que sirven de entrada al
programa para reemplazar la imagen
original.
Fotomosaico final o
resultado
La imagen original convertida en
fotomosaico.
9.5.1. Creación de fotomosaicos
La creación de un fotomosaico involucra métodos de alteración de imágenes y
el reconocimiento de las mismas. En el Diagrama 1 se presenta el bosquejo del
proceso de creación de fotomosaicos.
Entrada
El proceso de creación de fotomosaicos necesita como mínimo:
La imagen original que será convertida en un fotomosaico.
Una colección de imágenes que se utilizaran para reemplazar la imagen original.
Salida
El proceso dará como resultado un fotomosaico en donde la imagen original es
reemplazada completamente por una parte o toda la colección imágenes.
Proceso
Algoritmo general
El proceso para la creación de fotomosaicos parte de la siguiente idea:

Reemplazar los segmentos de una imagen con otras imágenes de
características
similares. El proceso puede apreciarse en el cuadro del algoritmo 1, el cual
puede
resumirse en los siguientes pasos:
Dividir la imagen original en cuadros.
Por cada cuadro:
Buscar en la colección de imágenes la imagen que más similitud tenga al cuadro
original.
Remplazar el cuadro con la imagen encontrada.
Algoritmo general para fotomosaicos.
Según el Algoritmo 1, es necesario definir el número de columnas y filas que
tendrá el fotomosaico, para determinar el número de cuadros. Si se quiere
obtener por ejemplo un fotomosaico de 1280 por 1000 píxeles con cuadros de
128 por 100 píxeles cada uno, se debe dividir la imagen original en 100
cuadros distribuidos en 10 columnas y 10 filas.
En el Algoritmo 1, la función diferencia indica que tan diferentes son dos
imágenes. Si el valor de la función diferencia es cero significa que las
imágenes son idénticas. Entre más grande es el valor de la función, las
imágenes son más distintas entre si. La mejor imagen será aquella que dé el
menor valor al ser comparada con el cuadro de la imagen original utilizando la
función diferencia. Esta es la parte más importante del proceso, por lo que en
la implementación esta función debe ser especialmente eficiente. Es ejecutada
por cada imagen de la colección de imágenes por cada cuadro en el
fotomosaico.

La función reemplazar del Algoritmo 1, es la función que reemplaza un cuadro
de la imagen original definida en el primer parámetro y lo sustituye con la
imagen del segundo parámetro. En la implementación esta función es
simplemente copiar y pegar una imagen origen a una imagen destino.
En el Diagrama 2 se aprecia el procedimiento para procesar un cuadro del
fotomosaico.
Diagrama 2.
9.5.2. Reconocimiento de imágenes
La función diferencia es la base del reconocimiento de imágenes; indica la
distancia entre dos imágenes. Existen diversas estrategias para reconocimiento
de imágenes digitales de acuerdo al tipo de aplicación y de los recursos del
sistema. Utilizando los conceptos derivados del OCR (Optical Carácter
Recognition), el primer paso para comparar dos imágenes es vectorizar cada
imagen y cada cuadro para luego, comparar las formas de los objetos
resultantes. El proceso de vectorización consiste en definir imágenes utilizando
la geometría y funciones matemáticas. Los algoritmos existentes para este
proceso consumen una gran cantidad de recursos, y la metodología para
reconocer la similitud entre estos objetos resulta muy compleja.
La manera más directa de comparar un cuadro la imagen original con una
colección de imágenes, es comparar cada píxel del cuadro de la imagen
original con su correspondiente píxel en la imagen de la colección imágenes, y
acumular las distancia entre cada pareja de píxeles para determinar la distancia
general entre las dos imágenes. Aunque esta es una estrategia relativamente
buena para comparar imágenes, la cantidad de comparaciones necesarias es
muy grande. Por cada comparación debe calcularse la distancia entre los
píxeles de las dos imágenes y por cada pareja de píxeles debe compararse
cada uno de los tres canales RGB.
Método lineal
La distancia D entre dos píxeles está dada por:
D=(R)+(G)+(B)
Esta distancia es calculada por cada píxel y por cada canal de color en las
imágenes comparadas.
Metodo lineal

Método cuadrático
Se puede acentuar el efecto de la diferencia de cada píxel utilizando una
diferencia cuadrática o distancia euclidiana.
D2=(R)2+(G)2+(B)2
Como el objetivo es encontrar un valor significativo que nos indique que tan
diferentes son dos imágenes, podemos eliminar el cálculo de la raíz cuadrada
debido al siguiente teorema matemático:
Si a2 > b2 entonces a > b
Este requiere más procesamiento que el método lineal pero es el más utilizado
por la calidad de sus resultados. Puede acentuarse aun mas la diferencia
utilizando diferentes potencias en la fórmula, pero usualmente no es necesario.
En estos métodos presentados, se asume que las dos imágenes – parámetro
tienen las mismas dimensiones y que cada píxel esta compuesto por tres
canales de color RGB.
Método Compuphase
El grupo de investigación Compuphase en Holanda, determinó
experimentalmente una fórmula que se aproxima mejor a nuestra percepción
decolores. (http://www.compuphase.com/cmetric.htm)

Este método requiere mucho mas capacidad de procesamiento que los dos
anteriores y sus resultados no difieren mucho, por lo que debe utilizarse solo si
se requiere de mayor precisión en la selección de imágenes.
9.5.3. Calidad de los fotomosaicos
La mejor herramienta para determinar la calidad de una forma de arte visuales
el sentido de la vista, sin embargo, este es muy subjetivo. Es necesario definir
un parámetro para poder comparar fotomosaicos de manera objetiva y así
determinar si una técnica esta siendo efectiva o no. Un parámetro puede ser el
promedio de las diferencias encontradas en el proceso de cada cuadro de la
imagen. Esta medida de comparación se puede usar únicamente para
comparar los resultados de distintas técnicas sobre una misma imagen original.
En la Gráfica 3 se encuentran fotomosaicos creados con técnicas que aún no
han sido introducidas pero sirven de ejemplo para explicar la calidad de los
fotomosaicos. El fotomosaico (b) se creo utilizando filtro de colores y alteración
de las imágenes, reporto una diferencia acumulada mayor al mosaico del literal
(c) pero evidentemente produce un mejor efecto por tener un color mas
parecido a la imagen original. El fotomosaico (c) fue creado sin tomar en cuenta
la información de color, reportó la diferencia acumulada más pequeña ya que
se hizo énfasis en la detección de contornos

COMPARACIÓN DE LOS FOTOMOSAICOS
9.5.4. Reduciendo el número de imágenes comparadas
Por cada cuadro se recorre toda la colección de imágenes. A medida que la
colección aumenta, el tiempo necesario para encontrar la mejor imagen para
ese cuadro también aumenta. Es necesario clasificar las imágenes según sus
características de color.
Color promedio
Al alejarnos de una imagen, se llega a una distancia en donde la imagen se ve
como un punto de un solo color. Se puede reemplazar un cuadro de la imagen
con una imagen de un color sólido, como se aprecia en la Gráfica 4, y como
menciona Harmon en su artículo. Este color se calcula con el promedio de los
colores en la imagen. Para poder usar el color promedio en la colección de
imágenes es necesario calcularlo previo a la ejecución del proceso de creación
de fotomosaicos.
Algoritmo 4. Color promedio.
Color promedio

Margen de selección
Utilizando un byte por cada canal, existen millones de combinaciones de
colores posibles. Al buscar las imágenes en la colección de imágenes con un
color específico, es posible que no se tenga ninguna imagen con ese color.
Entonces se hace necesario definir un rango de colores para filtrar las
imágenes.
Por otro lado, si la colección de imágenes no es muy grande, puede ser que no
existan imágenes que se encuentren dentro del rango definido del filtro,
entonces la definición del rango debe ser dinámica; el margen se debe auto
ajustar hasta que exista por lo menos una imagen en el rango definido.

9.6. Alteración de colores
Si el rango de colores de selección definido en la sección anterior se vuelve
muy grande, es posible que se tengan imágenes con color promedio muy
distinto al color promedio del cuadro original que esta siendo procesado. Esto
puede corregirse con la alteración de los colores en la imagen que va a ser
sustituida, pero tratando que sea lo más similar posible al cuadro original
procesado.
Modificación de color.
El valor de la modificación puede ser muy grande, y las imágenes de los
cuadros individualmente podrán verse distorsionadas causando un efecto
indeseable, pero el color general del fotomosaico es mejorado.

Diagrama 4.
Procesar Nuevo Cuadro
9.7. Reutilización de imágenes
Si se tiene una colección de imágenes muy pequeña y la imagen original tiene
muy poco detalle, es posible que el proceso repita una imagen ya utilizada Este
efecto, en la mayoría de casos no es deseable por estética; a distancia un
fotomosaico puede lucir bien pero al acercarse y percibir el detalle, existen
series de imágenes repetidas como puede apreciarse en la Gráfica 5.

Gráfica 5. Reutilización de imágenes.
Este efecto se puede contrarrestar, marcando cada imagen utilizada en la
colección de imágenes y agregar la condición al filtro de selección de imágenes
de que las imágenes ya utilizadas una vez no pueden utilizarse nuevamente.
Esto puede implementarse fácilmente utilizando un campo de tipo boolean
como bandera en la colección de imágenes. Esta condición obliga a disponer
de una colección de imágenes suficientemente grande como para poder
sustituir toda la imagen original. Al utilizar esta técnica, es posible que la
calidad del fotomosaico sea disminuida ya que con cada cuadro que se
procesa se va disminuyendo la disponibilidad de imágenes.

9.8. Prioridad
Si se utiliza la técnica para evitar la repetición las imágenes ya utilizadas, la
imagen se va deteriorando a medida que se procesa la imagen original. Al
procesar los últimos cuadros se tiene una menor disponibilidad de imágenes en
la colección de imágenes que en los primeros ya que una buena parte de la
colección de imágenes habrá sido marcada como utilizada. Algunos cuadros
necesitan especial atención. Debe dárseles prioridad a los cuadros que tengan
más contornos, ya que estos definen las figuras, o a aquellos que tengan una
mayor variación de colores. Con la varianza, derivada de cálculos estadísticos, es
posible encontrar la variación de colores en los cuadros.
La varianza indica la distancia que hay entre el color promedio de una imagen y
cada uno de los píxeles que la componen.
Varianza.
Antes de iniciar con el proceso de elaboración del fotomosaico es necesario
calcular la varianza de cada uno de los cuadros y con esto construir una lista
de prioridades. Los cuadros con mayor varianza deben ser procesados primero
para que estos tengan una mejor disponibilidad de imágenes. La calidad del
fotomosaico es mejorada con esta técnica.

X. BIBLIOGRAFÍA
 ABRASH, Michael. Michael Abrashs’s Graphics Programming Black
Book Special Edition. Coriolis Group Books. Estados Unidos, 1997. 1342
pp.ISBN 1-57610-174-6
 ROCHESTER INSTITUTE OF TECHNOLOGY / Department of Computer
Science.
Color Conversion Algorithms.
http://www.cs.rit.edu/~ncs/color/t_convert.html
 RIEMERSMA, Thiadmer. Colour Metric. Holanda. 2001.
http://www.compuphase.com/cmetric.htm
 KAPLAN, Ian. The Daubechies D4 Wavelet Transform. 2002.
http://www.bearcave.com/misl/misl_tech/wavelets/daubechies/
 FISCHER, R. Sobel Edge Detectors.
http://www.dai.ed.ac.uk/HIPR2/sobel.htm

INDICE
ENFOQUE PRACTICO AL PROCESAMIENTO DE IMÁGENES DIGITALES Y
LAS GRAFICAS POR COMPUTADORA ..................................................................... 1
I. PROGRAMACION ORIENTADA A OBJETOS ................................................... 1
1.1. INTRODUCCIÓN............................................................................................ 1
1.2. RESEÑA HISTORICA .................................................................................... 1
1.3. CONCEPTOS BÁSICOS GENERALES DE LA PROGRAMACIÓN
ORIENTADA A OBJETOS......................................................................................... 2
1.3.1. OBJETOS.-............................................................................................... 2
1.3.2. MENSAJE.-.............................................................................................. 2
1.3.3. METODOS.- ............................................................................................ 2
1.3.4. CLASES.-................................................................................................. 3
1.3.5. ENCAPSULAMIENTO.-......................................................................... 3
1.3.6. HERENCIA.-............................................................................................ 3
1.3.6.1 HERENCIA SIMPLE.- ............................................................................ 3
1.3.6.2 HERENCIA MÚLTIPLE ......................................................................... 4
1.3.7. POLIMORFISMO DE UN OBJETO.-..................................................... 5
1.4. CLASES Y OBJETOS EN DELPHI................................................................ 6
________________________ .................................................................................. 9
________________________ .................................................................................. 9
II. El Procesamiento de Imágenes Digitales y las Gráficas por Computadora .......... 13
2.1. Principales aplicaciones del Procesamiento de Imágenes y las Gráficas por
Computadora .............................................................................................................. 13
2.2. Algoritmos para el trazado de rectas .............................................................. 13
2.3. Algoritmo DDA.............................................................................................. 14
2.4. Algoritmo de Bresenham:............................................................................... 15
III. Trazado de círculos............................................................................................. 21
3.1. Subprograma CirclePoint ............................................................................... 21
3.2. Algoritmo de Bresenham para el trazado de circunferencias......................... 21
IV. TRANSFORMACIONES .................................................................................. 23
4.1. Transformaciones de coordenadas.................................................................. 23
4.1.1. Ventana................................................................................................... 23
4.1.2. Ecuaciones de transformación de coordenadas de ventana a viewport:. 24
4.2. Transformaciones bidimensionales básicas.................................................... 25
4.2.1. Traslación: .............................................................................................. 25
4.2.2. Cambio de escala:................................................................................... 26
4.2.3. Rotación:................................................................................................. 26
4.2.4. Representación de matrices y coordenadas homogéneas ....................... 27
V. Algoritmos de corte ................................................................................................ 30
5.1. Cohen – Sutherland para el corte de líneas..................................................... 30
5.2. Sutherland – Hodgman para el corte de polígonos......................................... 35
VI. RELLENO DE POLÍGONOS............................................................................ 39
6.1. Rellenado de rectángulos................................................................................ 39
6.2. Rellenado de polígonos por “Scan Line” ....................................................... 39
VII. La tercera dimensión .......................................................................................... 43
Vértices Aristas Caras............................................................................................. 46
VIII. Vistas en 3D ....................................................................................................... 48
8.1. Introducción.................................................................................................... 48
8.2. Proyecciones................................................................................................... 48

8.2.1. Proyecciones en paralelo ........................................................................ 48
8.2.2. Proyecciones perspectivas...................................................................... 50
IX. FOTOMOSAICOS EN LAS IMÁGENES DIGITALES................................... 56
9.1. Percepción de colores..................................................................................... 56
9.2. Imágenes digitales .......................................................................................... 56
9.3. Representación de colores en imágenes digitales........................................... 56
9.4. Resolución de las imágenes digitales ............................................................. 57
9.5. El proceso de creación de fotomosaicos......................................................... 57
9.5.1. Creación de fotomosaicos....................................................................... 58
9.5.2. Reconocimiento de imágenes................................................................. 60
9.5.3. Calidad de los fotomosaicos................................................................... 62
9.5.4. Reduciendo el número de imágenes comparadas................................... 63
9.6. Alteración de colores...................................................................................... 65
9.7. Reutilización de imágenes.............................................................................. 66
9.8. Prioridad ......................................................................................................... 68
X. BIBLIOGRAFÍA.................................................................................................... 70

Libro procesamiento imagenes

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Libro procesamiento imagenes

Similar a Libro procesamiento imagenes (20)

Libro procesamiento imagenes