Está en la página 1de 220

INSTITUTO TECNOLÓGICO DE SAN LUIS

POTOSÍ

DEPARTAMENTO DE SISTEMAS Y COMPUTACIÓN


CARRERA:
Ingeniería en Sistemas Computacionales

MANUAL DE PRÁCTICAS DE LA MATERIA:


Graficación

NOMBRE DEL AUTOR: PEDRO GARCÍA GUERRERO


NÚMERO DE DICTAMEN: AS-2-239/2018
PLAN DE ESTUDIOS: ISIC-2010-224
CLAVE DE LA ASIGNATURA: SCC-1010

SOLEDAD DE GRACIANO SÁNCHEZ, S.L.P., A 01 DE AGOSTO DEL 2019


Índice
PRÁCTICA 1. LÍNEA DDA ........................................................................................................................ 8
1.1 INTRODUCCIÓN ................................................................................................................................ 8
1.2 OBJETIVO (COMPETENCIA) ............................................................................................................... 8
1.3 FUNDAMENTO [3].............................................................................................................................. 8
1.4 PROCEDIMIENTO (DESCRIPCIÓN) ..................................................................................................... 9
1.4.1 EQUIPO NECESARIO............................................................................................................................ 9
1.4.2 MATERIAL DE APOYO ........................................................................................................................ 9
1.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 10
1.4.4 REPORTE .......................................................................................................................................... 17
1.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 17
PRÁCTICA 2. LÍNEA BRESENHAM ....................................................................................................... 18
2.1 INTRODUCCIÓN .............................................................................................................................. 18
2.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 18
2.3 FUNDAMENTO ................................................................................................................................. 18
2.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 19
2.4.1 EQUIPO NECESARIO.......................................................................................................................... 19
2.4.2 MATERIAL DE APOYO ...................................................................................................................... 19
2.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 19
2.4.4 REPORTE .......................................................................................................................................... 20
2.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 20
PRÁCTICA 3. CIRCUNFERENCIA COMÚN ............................................................................................ 21
3.1 INTRODUCCIÓN .............................................................................................................................. 21
3.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 21
3.3 FUNDAMENTO ................................................................................................................................. 21
3.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 22
3.4.1 EQUIPO NECESARIO.......................................................................................................................... 22
3.4.2 MATERIAL DE APOYO ...................................................................................................................... 22
3.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 22
3.4.4 REPORTE .......................................................................................................................................... 23
3.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 23
PRÁCTICA 4. CIRCUNFERENCIA BRESENHAM .................................................................................. 24
4.1 INTRODUCCIÓN .............................................................................................................................. 24
4.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 24
4.3 FUNDAMENTO ................................................................................................................................. 24
4.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 30
4.4.1 EQUIPO NECESARIO.......................................................................................................................... 30
4.4.2 MATERIAL DE APOYO ...................................................................................................................... 30
4.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 30
4.4.4 REPORTE .......................................................................................................................................... 31
4.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 31

Departamento de Sistemas y Computación Página ii


PRÁCTICA 5. CIRCUNFERENCIA PUNTO MEDIO ............................................................................... 32
5.1 INTRODUCCIÓN .............................................................................................................................. 32
5.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 32
5.3 FUNDAMENTO ................................................................................................................................. 32
5.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 35
5.4.1 EQUIPO NECESARIO.......................................................................................................................... 35
5.4.2 MATERIAL DE APOYO ...................................................................................................................... 35
5.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 35
5.4.4 REPORTE .......................................................................................................................................... 36
5.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 36
PRÁCTICA 6. DIBUJO DE LÍNEAS Y POLÍGONOS EN C CON LA LIBRERÍA WINBGIM ................... 37
6.1 INTRODUCCIÓN .............................................................................................................................. 37
6.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 37
6.3 FUNDAMENTO ................................................................................................................................. 37
6.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 38
6.4.1 EQUIPO NECESARIO.......................................................................................................................... 38
6.4.2 MATERIAL DE APOYO ...................................................................................................................... 38
6.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 38
6.4.4 REPORTE .......................................................................................................................................... 42
6.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 42
PRÁCTICA 7. DIBUJO DE LÍNEAS Y POLÍGONOS EN JAVA CON LA LIBRERÍA JOGL ..................... 43
7.1 INTRODUCCIÓN .............................................................................................................................. 43
7.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 43
7.3 FUNDAMENTO ................................................................................................................................. 43
7.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 43
7.4.1 EQUIPO NECESARIO.......................................................................................................................... 43
7.4.2 MATERIAL DE APOYO ...................................................................................................................... 43
7.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 44
7.4.4 REPORTE .......................................................................................................................................... 46
7.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 46
PRÁCTICA 8. GUARDAR Y RECUPERAR UNA IMAGEN PIXEL POR PIXEL ..................................... 47
8.1 INTRODUCCIÓN .............................................................................................................................. 47
8.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 47
8.3 FUNDAMENTO ................................................................................................................................. 48
8.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 49
8.4.1 EQUIPO NECESARIO.......................................................................................................................... 49
8.4.2 MATERIAL DE APOYO ...................................................................................................................... 49
8.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 50
8.4.4 REPORTE .......................................................................................................................................... 52
8.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 52
PRÁCTICA 9. GUARDAR Y RECUPERAR UNA IMAGEN POR LA DESCRIPCIÓN DE SUS
COMPONENTES ...................................................................................................................................... 53
9.1 INTRODUCCIÓN .............................................................................................................................. 53

Departamento de Sistemas y Computación Página iii


9.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 53
9.3 FUNDAMENTO ................................................................................................................................. 53
9.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 54
9.4.1 EQUIPO NECESARIO.......................................................................................................................... 54
9.4.2 MATERIAL DE APOYO ...................................................................................................................... 54
9.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 54
9.4.4 REPORTE .......................................................................................................................................... 58
9.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 58
PRÁCTICA 10. REPRESENTACIÓN DE UNA FIGURA 2D A PARTIR DE SUS VÉRTICES EN
LENGUAJE C............................................................................................................................................. 59
10.1 INTRODUCCIÓN .............................................................................................................................. 59
10.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 59
10.3 FUNDAMENTO ................................................................................................................................. 59
10.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 60
10.4.1 EQUIPO NECESARIO ..................................................................................................................... 60
10.4.2 MATERIAL DE APOYO.................................................................................................................. 60
10.4.3 DESARROLLO DE LA PRÁCTICA ................................................................................................... 60
10.4.4 REPORTE ..................................................................................................................................... 62
10.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 62
PRÁCTICA 11. TRASLACIÓN, ESCALA, ROTACIÓN Y SESGADO DE UNA FIGURA EN LENGUAJE C
.................................................................................................................................................................. 63
11.1 INTRODUCCIÓN .............................................................................................................................. 63
11.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 63
11.3 FUNDAMENTO ................................................................................................................................. 63
11.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 65
11.4.1 EQUIPO NECESARIO ..................................................................................................................... 65
11.4.2 MATERIAL DE APOYO.................................................................................................................. 65
11.4.3 DESARROLLO DE LA PRÁCTICA ................................................................................................... 65
11.4.4 REPORTE ..................................................................................................................................... 68
11.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 68
PRÁCTICA 12. TRAZADO DE UNA CURVA DE BEZIER 2D EN LENGUAJE C ................................... 69
12.1 INTRODUCCIÓN .............................................................................................................................. 69
12.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 70
12.3 FUNDAMENTO ................................................................................................................................. 70
12.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 72
12.4.1 EQUIPO NECESARIO ..................................................................................................................... 72
12.4.2 MATERIAL DE APOYO.................................................................................................................. 72
12.4.3 DESARROLLO DE LA PRÁCTICA ................................................................................................... 72
12.4.4 REPORTE ..................................................................................................................................... 74
12.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 74
PRÁCTICA 13. TRAZADO DE UNA CURVA DE SPLINE 2D EN LENGUAJE C ................................... 75
13.1 INTRODUCCIÓN .............................................................................................................................. 75
13.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 75
13.3 FUNDAMENTO ................................................................................................................................. 75

Departamento de Sistemas y Computación Página iv


13.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 78
13.4.1 EQUIPO NECESARIO ..................................................................................................................... 78
13.4.2 MATERIAL DE APOYO.................................................................................................................. 78
13.4.3 DESARROLLO DE LA PRÁCTICA ................................................................................................... 78
13.4.4 REPORTE ..................................................................................................................................... 80
13.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 80
PRÁCTICA 14. REPRESENTACIÓN DE UNA FIGURA CON COORDENADAS HOMOGÉNEAS A
PARTIR DE SUS VÉRTICES EN EL LENGUAJE PROCESSING ............................................................. 81
14.1 INTRODUCCIÓN .............................................................................................................................. 81
14.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 82
14.3 FUNDAMENTO ................................................................................................................................. 82
14.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 83
14.4.1 EQUIPO NECESARIO ..................................................................................................................... 83
14.4.2 MATERIAL DE APOYO.................................................................................................................. 83
14.4.3 DESARROLLO DE LA PRÁCTICA ................................................................................................... 83
14.4.4 REPORTE ..................................................................................................................................... 87
14.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 87
PRÁCTICA 15. TRASLACIÓN, ESCALA, ROTACIÓN DE UNA FIGURA EN EL LENGUAJE
PROCESSING ........................................................................................................................................... 88
15.1 INTRODUCCIÓN .............................................................................................................................. 88
15.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 88
15.3 FUNDAMENTO ................................................................................................................................. 88
15.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 88
15.4.1 EQUIPO NECESARIO ..................................................................................................................... 88
15.4.2 MATERIAL DE APOYO.................................................................................................................. 88
15.4.3 DESARROLLO DE LA PRÁCTICA ................................................................................................... 89
15.4.4 REPORTE ..................................................................................................................................... 90
15.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 90
PRÁCTICA 16. FORMAS GEOMÉTRICAS 3D EN EL LENGUAJE PROCESSING ................................. 91
16.1 INTRODUCCIÓN .............................................................................................................................. 91
16.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 91
16.3 FUNDAMENTO ................................................................................................................................. 91
16.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 92
16.4.1 EQUIPO NECESARIO ..................................................................................................................... 92
16.4.2 MATERIAL DE APOYO.................................................................................................................. 92
16.4.3 DESARROLLO DE LA PRÁCTICA ................................................................................................... 92
16.4.4 REPORTE ..................................................................................................................................... 94
16.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 94
PRÁCTICA 17. ILUMINACIÓN Y MAPEO DE TEXTURAS EN EL LENGUAJE PROCESSING ............ 95
17.1 INTRODUCCIÓN .............................................................................................................................. 95
17.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 95
17.3 FUNDAMENTO ................................................................................................................................. 95
17.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 96
17.4.1 EQUIPO NECESARIO ..................................................................................................................... 96

Departamento de Sistemas y Computación Página v


17.4.2 MATERIAL DE APOYO.................................................................................................................. 97
17.4.3 DESARROLLO DE LA PRÁCTICA ................................................................................................... 97
17.4.4 REPORTE ..................................................................................................................................... 98
17.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 98
PRÁCTICA 18. ANIMACIÓN SIMPLE EN EL LENGUAJE PROCESSING ............................................. 99
18.1 INTRODUCCIÓN .............................................................................................................................. 99
18.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 99
18.3 FUNDAMENTO ................................................................................................................................. 99
18.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................. 100
18.4.1 EQUIPO NECESARIO ................................................................................................................... 100
18.4.2 MATERIAL DE APOYO................................................................................................................ 100
18.4.3 DESARROLLO DE LA PRÁCTICA ................................................................................................. 100
18.4.4 REPORTE ................................................................................................................................... 101
18.5 RESULTADOS Y CONCLUSIONES.................................................................................................... 101
BIBLIOGRAFÍA ....................................................................................................................................... 102
ANEXO A. RÚBRICA ............................................................................................................................... 103
ANEXO B. PLANTILLA DEL REPORTE DE PRÁCTICAS. ....................................................................... 104
ANEXO C. REGLAMENTO INTERNO PARA EL USO DE LABORATORIOS. .......................................... 105

Departamento de Sistemas y Computación Página vi


Objetivo General del Manual
Se busca una vinculación de las bases matemáticas de la graficación con sus
aplicaciones en el mundo real, a través de la codificación de dichas ecuaciones y
algoritmos y que así verifiquen su conocimiento adquirido para que se desarrollen
profesionalmente de una forma veraz.

Además, se pretende motivar al alumno a la investigación y al estudio de


situaciones que relacionen hechos y fenómenos y adquirir así conocimientos
cada vez más precisos sobre la graficación por computadora.

El alumno deberá tender a ser creativo, ya que la apertura de distintas oportunidades


así lo requiere en este mundo tan cambiante.

Objetivo General de la Materia


La asignatura pretende que el estudiante adquiera una formación consistente en la
generación de gráficos en 2 y 3 dimensiones, su transformación y efectos diversos,
de cara a su aplicación posterior en el mundo de la animación y la realidad virtual. [1]

Competencias Específicas a
Desarrollar
 Aplica los modelos matemáticos básicos y los modelos de color utilizados en
objetos bidimensionales y tridimensionales. [1]

 Desarrolla y aplica modelos de graficación y transformación bidimensional para


el enriquecimiento visual de sus aplicaciones. [1]

Utilidad del Manual


Es una guía para los profesores que imparten la materia, para poder uniformizar los
contenidos y nivel de profundidad de los temas del programa.

Para los estudiantes juega un papel importante en su formación ya que es una


herramienta de aprendizaje que fortalece los objetivos del perfil de estudios.

Para la Academia de Sistemas Computacionales es una evidencia que se están


promoviendo nuevas e innovadoras estrategias didácticas.

Departamento de Sistemas y Computación Página 7


Practica 1. Línea DDA
1.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad I: Introducción a
la graficación por computadora del subtema 1.3. Aspectos matemáticos de la
graficación, del programa de estudios de la materia de Graficación, desarrollando la
competencia específica: “Aplica los modelos matemáticos básicos y los modelos
de color utilizados en objetos bidimensionales y tridimensionales”.

Al implementar gráficos en un monitor tenemos la limitante de estar en un espacio


discreto, por lo que podemos optimizar los cálculos para dibujar una línea. El
algoritmo DDA es un método muy sencillo, pero más eficiente que si intentamos usar
la formula y=mx+b, que se utiliza en un espacio continuo.

1.2 Objetivo (Competencia)


Elaborar un programa que trace una línea usando el algoritmo DDA.

1.3 Fundamento [3]


El analizador diferencial digital (DDA; digital differential analyzer) es un algoritmo
de línea de conversión de rastreo que se basa en el cálculo ya sea de Δx, o de Δy, por
medio de las siguientes ecuaciones:
∆𝑦
∆𝑥 =
𝑚

∆𝑦 = 𝑚 ∙ ∆𝑥

Se efectúa un muestreo de la línea e 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 otra coordenada.

Se debe considerar primero una línea con pendiente positiva. Si la pendiente es menor
o igual que 1, se lleva a cabo un muestreo de x intervalos unitarios (Δx = 1) y se
calcula cada valor sucesivo de y como:

𝑦𝑖+1 = 𝑦𝑖 + 𝑚 (A)

El subíndice i toma valores enteros a partir de 1 y aumenta a razón de 1 hasta que se


alcance el valor final. Ya que m puede ser cualquier número real entre 0 y 1, los
valores calculados de y deben redondearse al entero más cercano.

Para las líneas con una pendiente positiva mayor que 1, se revierten las funciones de
x y de y. Es decir, se realiza un muestreo de y en intervalos unitarios (Δy = 1) y se
calcula cada valor sucesivo de x como:

Departamento de Sistemas y Computación Página 8


1
𝑥𝑖+1 = 𝑥𝑖 + 𝑚 (B)

Las ecuaciones anteriores (A y B) se basan en la suposición de que las líneas deben


procesarse del extremo izquierdo al derecho. Si este procesamiento se revierte, de
manera que sea el extremo derecho donde se inicia, entonces se tiene ya sea

∆𝑥 = −1
𝑦𝑖+1 = 𝑦𝑖 − 𝑚

o (cuando la pendiente es mayor que 1)

∆𝑦 = −1
1
𝑥𝑖+1 = 𝑥𝑖 −
𝑚

𝑖 ∗ ∆𝑦

Línea ideal

1.4 Procedimiento (Descripción)


1.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

1.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java (IDE), por ejemplo, NetBeans.
 Librería swing o javaFX.

Departamento de Sistemas y Computación Página 9


1.4.3 Desarrollo de la Práctica
Debemos tener en cuenta que el sistema de coordenadas del monitor y de las ventanas
consideran el origen en la esquina superior izquierda, los valores en x crecen hacia la
derecha y los valores de y crecen hacia abajo.

En esta práctica usaremos netbeans 8.1 versión en inglés. Comenzaremos generando


una aplicación gráfica en la cual dejaremos una función asociada al evento de un
botón para que al dar clic sobre el botón se ejecute el código que traza una línea con
el algoritmo DDA. Ejecute los siguientes pasos:

PASO 1:
Inicie netbeans y configure un proyecto gráfico. Use la siguiente ruta del menú:

ArchivosNuevo Proyecto

Elija la categoría Java y el tipo de proyecto Java Application, después dele un


nombre al proyecto, por ejemplo, AppLineaDDA. Esto genera directorio y varios
archivos que contienen el proyecto.
Departamento de Sistemas y Computación Página 10
Paso2:
Debemos crear otro archivo que especificara la ventana gráfica conocida como
JFrame. De clic derecho sobre el paquete applineadda en el menú contextual elija
New y después JFrameForm. Esto creara una clase, la nombraremos Ventana. Dicha clase
tiene dos vistas: Modo Código (Source) y Modo Diseño (Design).

Departamento de Sistemas y Computación Página 11


Paso 3:
Vamos a mostrar la paleta con los controles gráficos de la librería swing. Lo hacemos
en la siguiente ruta del menú:

WindowsIDE ToolsPalette

Para colocar los controles en nuestro lienzo, solo debemos arrastrar y soltar los
controles deseados.

Departamento de Sistemas y Computación Página 12


Colocaremos dos controles: JPanel y JButton. Les cambiamos el nombre, dando clic
derecho sobre el control y en el menú contextual elegir change variable name… y
les ponemos el nombre como se indica en las imágenes:

También le cambiamos el valor a algunas propiedades. Para ver las propiedades del
control, damos clic derecho sobre el control y seleccionamos Properties.

Departamento de Sistemas y Computación Página 13


Paso 4:
Ahora debemos iniciar la ventana gráfica desde el inicio del programa principal. Para
lograrlo editamos el programa principal AppLineaDDA.java insertando las líneas 19
y 20 como se muestra en la imagen.

Paso 5:
Solo nos resta dejar el hueco para escribir nuestro algoritmo de la línea DDA.
Debemos editar el archivo Ventana.java, pero en el modo Source. Para lograrlo le
damos doble clic al control btnLinea, con esto logramos varias cosas: asociar una
Departamento de Sistemas y Computación Página 14
función al evento clic sobre dicho botón y cambiarnos al modo Source colocándonos
sobre la función btnLineaActionPerformed que se ejecutará cuando suceda el
evento clic. Editamos la función insertando el código en la línea 85, como se muestra
en la imagen:

Paso 6:
Ahora insertamos después de la línea 86 la función lineaDDA:

void lineaDDA(int Xinicial, int Yinicial, int Xfinal, int Yfinal)


{ Graphics lapiz= jPanelPizarron.getGraphics();
//implementar algoritmo DDA
lapiz.drawOval(Xinicial, Yinicial, 1, 1); //Usar para pintar un pixel
}

Pero al escribirlo, faltará una librería, netbeans nos lo indica con una alerta en la línea
83. Para agregar la librería necesaria, damos clic izquierdo sobre la alerta y elegimos
la primera opción, como se muestra en la imagen:

Nos debe quedar como sigue:

Departamento de Sistemas y Computación Página 15


Paso 7:
Compilamos y ejecutamos el proyecto para ver que no haya error. Para hacerlo damos
clic sobre el icono de play.

Si todo estuvo correcto, se muestra la ventana con la aplicación:

Si damos clic en el botón, no sucederá nada, pues la función esta hueca. Y es justo el
pasó final, implemente el código según el algoritmo DDA.

Paso 8:
Dentro de la función lineaDDA, implemente el siguiente algoritmo [5]:

Recibe los parámetros correspondientes al punto inicial y punto


final (Xinicial, Yinicial, Xfinal,Yfinal)
Asignar a DeltaX la diferencia de Xfinal – Xinicial
Asignar a DeltaY la diferencia de Yfinal – Yinicial
Si ABS(DeltaX) > ABS(DeltaY)
Asignar a Pasos el ABS(DeltaX)
De lo contrario
Asignar a Pasos el ABS(DeltaY)
Asignar a Xincremento el resultado de DeltaX / Pasos
Asignar a Yincremento el resultado de DeltaY / Pasos
Asignar a X el valor de Xinicial
Asignar a Y el valor de Yinicial
Iluminar pixel en coordenada X,Y
Desde k=1 hasta Pasos
Asignar a X la suma de X + Xincremento
Asignar a Y la suma de Y + Yincremento
Iluminar pixel en Coodenada X,Y
Fin de Algoritmo(DDA)
Vuelva a ejecutar el programa y verifique que se traza una línea.

Departamento de Sistemas y Computación Página 16


Investigue como generar números aleatorios y como medir intervalos de tiempo y
cree una función que dibuje 5000 líneas DDA aleatorias y mida el total de
milisegundos empleados.

1.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
una corrida de escritorio en una hoja de cálculo (por ejemplo, en Excel) y después el
código fuente de su función que implemento el pseudocódigo del algoritmo de la línea
DDA y al último incluir imágenes de la ejecución de su programa.

Mencione el tiempo requerido para dibujar 5000 líneas.

1.5 Resultados y Conclusiones


Con ésta práctica, el alumno comprenderá la diferencia de graficar en un espacio
discreto (como lo brinda un monitor) y un espacio continuo.

Departamento de Sistemas y Computación Página 17


Practica 2. Línea Bresenham
2.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad I: Introducción a
la graficación por computadora del subtema 1.3. Aspectos matemáticos de la
graficación, del programa de estudios de la materia de Graficación, desarrollando la
competencia específica: “Aplica los modelos matemáticos básicos y los modelos
de color utilizados en objetos bidimensionales y tridimensionales”.

El algoritmo DDA, aunque es eficiente, aún necesita variables tipo float para los
valores de la pendiente. La aritmética de flotantes es extremadamente lenta
comparada con la de enteros.

El algoritmo de la línea de Bresenham tiene la ventaja de trabajar solo con números


enteros.

En la presente práctica repetiremos los pasos del 1 al 6 del punto 1.4.3 que se refieren
a construir el entorno gráfico del programa y dejar todo listo para insertar la función
que implemente el algoritmo de línea de Bresenham.

2.2 Objetivo (Competencia)


Elaborar un programa que trace una línea usando el algoritmo de Bresenham.

2.3 Fundamento
Es un algoritmo preciso y efectivo para la generación de líneas de rastreo,
desarrollado por Bresenham, convierte mediante rastreo las líneas al utilizar sólo
cálculos incrementales con enteros que se pueden adoptar para desplegar
circunferencias y otras curvas.

El algoritmo de línea de Bresenham se basa en probar el signo de un parámetro entero,


cuyo valor es proporcional a la diferencia entre las separaciones de las dos posiciones
de pixel de la trayectoria real de la línea.

Algoritmo de Bresenham

Para realizar el trazo de línea de Bresenham para una línea con una pendiente positiva
menor que 1 se deben seguir los siguientes pasos:

1. Se capturan los dos extremos de la línea y se almacena el extremo izquierdo en


(𝑥0 , 𝑦0 ).

2. Se carga (𝑥0 , 𝑦0 ) en el búfer de estructura; es decir, se traza el primer punto.

Departamento de Sistemas y Computación Página 18


3. Se calculan las constantes ∆𝑥, ∆𝑦, 2∆𝑦 y 2∆𝑦 − 2∆𝑥 y se obtiene el valor inicial
para el parámetro de decisión como

𝑝0 = 2∆𝑦 − ∆𝑥

4. En cada 𝑥𝑖 , a lo largo de la línea, que inicia en i=0, se efectúa la prueba siguiente:


si 𝑝𝑖 < 0, el siguiente punto que se debe trazar es

(𝑥𝑖+𝑖 , 𝑦𝑖 ) y 𝑝𝑖+1 = 𝑝𝑖 + 2∆𝑦

De otro modo, el siguiente punto que se debe trazar es

(𝑥𝑖+𝑖 , 𝑦𝑖+1 ) 𝑝𝑖+1 = 𝑝𝑖 + 2∆𝑦 − 2∆𝑥

5. Se repite el paso 4 Δx veces.

2.4 Procedimiento (Descripción)


2.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

2.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java (IDE), por ejemplo, NetBeans.
 Librería swing o javaFX.

2.4.3 Desarrollo de la Práctica


Ejecutamos los pasos análogos de la práctica anterior desde el PASO 1 hasta el PASO
6, solo cambiamos el nombre del proyecto a AppLineaBresenham, la etiqueta del
botón a Dibuja línea Bresenham y el nombre de la función que contendrá el
algoritmo a lineaBresenham.

Paso 1:
Dentro de la función lineaDDA, implemente el siguiente algoritmo [5]:

Recibe los parámetros correspondientes al punto inicial y punto


final (Xinicial, Yinicial, Xfinal,Yfinal)

DeltaX = ABS( Xfinal – Xinicial)


DeltaY = ABS( Yfinal -Yinicial)
ConstanteP = 2*DeltaY – DeltaX

Si Xinicial > Xfinal


X = Xfinal
Y = Yfinal
Ultimo = Xinicial

Departamento de Sistemas y Computación Página 19


De lo contrario
X = Xinicial
Y = Yinicial
Ultimo = Xfinal
Iluminar pixel en coordenada X,Y
Hacer mientras X<Ultimo
X = X + 1
Si ConstanteP < 0
ConstanteP = ConstanteP + 2 *DeltaY
De lo contrario
Y+1 = Y
ConstanteP = ConstanteP+2 *(DeltaY-DeltaX)
Iluminar pixel en coordenada X,Y
Fin de Algoritmo (Bresenham)

Ejecute el programa y verifique que se traza una línea.

Programe una función que dibuje 5000 líneas de Bresenham aleatorias y mida el total
de milisegundos empleados.

2.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
una corrida de escritorio en una hoja de cálculo (por ejemplo, en Excel) y después el
código fuente de su función que implemento el pseudocódigo del algoritmo de la línea
de Bresenham y al último incluir imágenes de la ejecución de su programa.

Compare el tiempo requerido para dibujar 5000 líneas entre los métodos DDA y
Bresenham.

2.5 Resultados y Conclusiones


Con ésta práctica, el alumno apreciará la diferencia en tiempo de un algoritmo que
solo usa números entero a otro que usa números flotantes.

Departamento de Sistemas y Computación Página 20


Practica 3. Circunferencia Comun
3.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad I: Introducción a
la graficación por computadora del subtema 1.3. Aspectos matemáticos de la
graficación, del programa de estudios de la materia de Graficación, desarrollando la
competencia específica: “Aplica los modelos matemáticos básicos y los modelos
de color utilizados en objetos bidimensionales y tridimensionales”.

Además de puntos y líneas otro componente muy frecuentemente utilizado en la


graficación es la circunferencia.

En esta práctica dibujaremos una circunferencia a partir de la ecuación continua de la


circunferencia.

3.2 Objetivo (Competencia)


Elaborar un programa que trace una circunferencia usando la ecuación de la
circunferencia.
3.3 Fundamento
Una circunferencia se define como el conjunto de puntos que equidistan una distancia
r de otro punto (𝑥𝑐 , 𝑦𝑐 ) llamado centro.

Para cualquier punto del círculo, esta relación de distancia se expresa mediante el
teorema de Pitágoras en coordenadas cartesianas:

(𝑥 − 𝑥𝑐 )2 + (𝑦 − 𝑦𝑐 )2 = 𝑟 2

Podemos utilizar esta ecuación para calcular la posición de los puntos sobre una
circunferencia, recorriendo el eje x en pasos unitarios desde 𝑥𝑐 − 𝑟 a 𝑥𝑐 + 𝑟 y
calculando los correspondientes valores y en cada posición mediante la fórmula:

𝑦 = 𝑦𝑐 ± √𝑟 2 − (𝑥𝑐 − 𝑥)2

Pero este no es el mejor método para generar un círculo. Uno de los problemas con
este método es que requiere unos considerables cálculos en cada paso. Además, el
espaciado entre los píxeles dibujados no es uniforme.

Para optimizar la cantidad de cálculos, podemos aprovechar los ejes de simetría y tan
solo calcular 1/8 de circunferencia y los demás puntos obtenerlos por reflexión:

Departamento de Sistemas y Computación Página 21


Así, solo calcularemos valores para x desde 0 hasta x>=y.

3.4 Procedimiento (Descripción)


3.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

3.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java (IDE), por ejemplo, NetBeans.
 Librería swing o javaFX.

3.4.3 Desarrollo de la Práctica


Ejecutamos los pasos análogos de la práctica uno, desde el PASO 1 hasta el PASO 6,
solo cambiamos el nombre del proyecto a AppCircunferencia, la etiqueta del botón
a Dibuja circunferencia y el nombre de la función que contendrá el algoritmo a
circunferencia.

Paso 1:
Dentro de la función circunferencia, implemente el siguiente algoritmo [5]:

Recibe los parámetros correspondientes al centro y radio de la


circunferencia (Xcentro, Ycentro, radio)
X=0
Y=radio

Mientras X < Y
PX=X+Xcentro;
PY=Y+Ycentro;
Iluminar pixel en coordenada PX, PY
Iluminar pixel en coordenada PX,-PY

Departamento de Sistemas y Computación Página 22


Iluminar pixel en coordenada -PX, PY
Iluminar pixel en coordenada -PX, PY
Iluminar pixel en coordenada PY, PX
Iluminar pixel en coordenada PY,-PX
Iluminar pixel en coordenada -PY, PX
Iluminar pixel en coordenada -PY, PX
Y = Raíz cuadrada de (radio*radio – X*X)
Fin Mientras
Fin de Algoritmo (Bresenham)

Ejecute el programa y verifique que se traza una circunferencia.

Programe una función que dibuje 5000 circunferencias aleatorias y mida el total de
milisegundos empleados.

3.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
una corrida de escritorio en una hoja de cálculo (por ejemplo, en Excel) y después el
código fuente de su función que implemento el pseudocódigo del algoritmo de la
circunferencia y al último incluir imágenes de la ejecución de su programa.

Registre el tiempo requerido para dibujar 5000 circunferencias.

3.5 Resultados y Conclusiones


Con ésta práctica, el alumno aprenderá a dibujar una circunferencia, aprovechando
los ejes de simetría para minimizar la cantidad de operaciones que implican calcular
una raíz cuadrada (que es requiere mucho más recurso).

Departamento de Sistemas y Computación Página 23


Practica 4. Circunferencia Bresenham
4.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad I: Introducción a
la graficación por computadora del subtema 1.3. Aspectos matemáticos de la
graficación, del programa de estudios de la materia de Graficación, desarrollando la
competencia específica: “Aplica los modelos matemáticos básicos y los modelos
de color utilizados en objetos bidimensionales y tridimensionales”.

El siguiente algoritmo es una mejora del método anterior. Lo logra evitando trabajar
con números de tipo flotante, pero sobretodo, se ahorra el cálculo de una raíz cuadrada
por cada pixel.

Para hacerlo se inspira en el algoritmo de la línea de Bresenhan, por lo que se le


conoce como algoritmo de la circunferencia de Bresenham (aunque este no lo
inventó).

Así, el Algoritmo de la Circunferencia de Bresenham es un método rápido para el


trazado de circunferencias en dispositivos gráficos, cuya cualidad más apreciada es
que solo realiza cálculos con enteros.

4.2 Objetivo (Competencia)


Elaborar un programa que trace una circunferencia usando el Algoritmo de la
Circunferencia de Bresenham.

4.3 Fundamento
Al trazar una circunferencia sobre papel con un compás, no existen impedimentos
para generar una curva continua con un trazado prácticamente perfecto.

En cambio cuando se opera sobre un sistema discreto como un monitor que contiene
pixeles organizados en filas y columnas (cuadriculado), una circunferencia siempre
seguirá un trazado imperfecto, ya que el trazo ideal de una circunferencia requiere
que para cada valor de X se obtenga un valor de Y en el dominio de los números reales.

Y en nuestro espacio discreto, solo podemos tener valores en el dominio de los


números enteros.

Departamento de Sistemas y Computación Página 24


Los pixeles rojos representan parte del trazo de una circunferencia en un espacio
discreto.

La línea azul intenta representar parte del trazo de una circunferencia en un espacio
continuo.

La desventaja de trazar en un espacio discreto (como lo es un monitor) es que


perdemos fidelidad.

La ventaja es que podemos trabajar solo con números enteros. El algoritmo de


Bresenham propone que, en base a las diferencias respecto al trazo ideal, se tome la
decisión de pintar algún pixel.

Primero consideramos que solo tomaremos valores enteros para X que tomará valores
de 0 a r. Para cada valor de X le corresponde un valor de Y.

Según la imagen anterior, el trazo ideal (línea azul) nos indica que pixeles debemos
pintar. En los pixeles amarillos vemos que no hay controversia, pues la totalidad del
trazo solo toca el pixel (X, Y).

Pero en los pixeles marcados con el signo ‘?’, el trazo ideal cruza dos pixeles, o sea:

𝑌
𝑌𝑖+1 = { 𝑖
𝑌𝑖 − 1

Departamento de Sistemas y Computación Página 25


Entonces, ¿cual debemos pintar? Para determinarlo, definimos un parámetro Pi que
nos indicará que pixel está más cercano al trazo ideal. Esto se logra comparando las
distancias desde la altura del trazo ideal Y hasta el pixel en Yi y desde Y hasta el pixel
en Yi -1. Y para dejar esta comparación expresada en un valor único, restamos las
distancias:

𝑝𝑖 = 𝑑1 − 𝑑2

y tomamos la siguiente deducción:

Si pi es negativo entonces Y está más cerca Yi


Si pi es positivo entonces Y está más cerca Yi -1

Esto lo podemos expresar como:

𝑌𝑖 𝑠𝑖 𝑝𝑖 < 0
𝑌𝑖+1 = {
𝑌𝑖 − 1 𝑠𝑖 𝑝𝑖 ≥ 0

A partir de la siguiente gráfica, deducimos las ecuaciones usadas en el algoritmo.

Pasos para obtener las fórmulas usadas en el algoritmo:


 Partimos del hecho que conocemos los valores del i-ésimo pixel (Xi, Yi).
 Y queremos conocer el siguiente pixel (Xi+1, Yi+1).
 Los incrementos en el eje X son unitarios:

𝑋𝑖+1 = 𝑋𝑖 + 1 (Ecuación 1)

Departamento de Sistemas y Computación Página 26


 Ahora creamos un parámetro de decisión Pi que será la diferencia entre las
distancias D1 y D2, que representan a d1 y d2 respectivamente, pero por
conveniencia, trabajamos con diferencias de cuadrados y tener ecuaciones sin
raíces. Así, en lugar de usar:
𝑑1 = 𝑌𝑖 − 𝑌

𝑑2 = 𝑌 − (𝑌𝑖 − 1)

tendremos los siguientes valores de D1 y D2

𝐷1 = 𝑌𝑖2 − 𝑌 2

𝐷2 = 𝑌 2 − (𝑌𝑖 − 1)2

Y el parámetro de decisión Pi queda como:


𝑃𝑖 = 𝐷1 − 𝐷2

 Solo nos falta determinar la altura del siguiente pixel Yi+1, que como ya lo
habíamos determinado, se expresa como:

𝑌𝑖 𝑠𝑖 𝑃𝑖 ≥ 0 𝑐𝑎𝑠𝑜 1
𝑌𝑖+1 = { (Ecuación 2)
𝑌𝑖 − 1 𝑠𝑖 𝑃𝑖 < 0 𝑐𝑎𝑠𝑜 2

 Conocemos que la ecuación de la circunferencia es 𝑟 2 = 𝑥 2 + 𝑦 2 despejamos


a 𝑦 2 quedando 𝑦 2 = 𝑟 2 − 𝑥 2 ; usamos esta ecuación para evaluarla en el
siguiente pixel, y obtenemos:
2
𝑌 2 = 𝑟 2 − 𝑋𝑖+1

 Sustituimos por la ecuación 1:

𝑌 2 = 𝑟 2 − (𝑋𝑖 + 1)2 (Ecuación 3)

 Ya contamos con los elementos para expandir Pi

𝑃𝑖 = 𝐷1 − 𝐷2

𝑃𝑖 = 𝑌𝑖2 − 𝑌 2 − (𝑌 2 − (𝑌𝑖 − 1)2 )

𝑃𝑖 = 𝑌𝑖2 − 𝑌 2 − 𝑌 2 + (𝑌𝑖 − 1)2

𝑃𝑖 = 𝑌𝑖2 − 𝑌 2 − 𝑌 2 + 𝑌𝑖 2 − 2𝑌𝑖 + 1

𝑃𝑖 = 2𝑌𝑖2 − 2𝑌 2 − 2𝑌𝑖 + 1

Departamento de Sistemas y Computación Página 27


Sustituimos Y2 por la ecuación 3:

𝑃𝑖 = 2𝑌𝑖2 − 2(𝑟 2 − (𝑋𝑖 + 1)2 ) − 2𝑌𝑖 + 1

𝑃𝑖 = 2𝑌𝑖2 − 2(𝑟 2 − 𝑋𝑖 2 − 2𝑋𝑖 − 1) − 2𝑌𝑖 + 1

𝑃𝑖 = 2𝑌𝑖2 − 2𝑟 2 + 2𝑋𝑖 2 + 4𝑋𝑖 + 2 − 2𝑌𝑖 + 1

𝑃𝑖 = 2𝑋𝑖 2 + 2𝑌𝑖2 + 4𝑋𝑖 − 2𝑌𝑖 − 2𝑟 2 + 3 (Ecuación 4)

 Aplicamos la inducción matemática para obtener Pi+1

Primero suponemos que, si es válido para Pi, también lo será para Pi+1

𝑃𝑖+1 = 2𝑋𝑖+1 2 + 2𝑌𝑖+1


2
+ 4𝑋𝑖+1 − 2𝑌𝑖+1 − 2𝑟 2 + 3

Restamos Pi de Pi+1

𝑃𝑖+1 − 𝑃𝑖 = 2𝑋𝑖+1 2 − 2𝑋𝑖 2 + 2𝑌𝑖+1


2
− 2𝑌𝑖2 + 4𝑋𝑖+1 − 4𝑋𝑖 − 2𝑌𝑖+1 + 2𝑌𝑖

𝑃𝑖+1 − 𝑃𝑖 = 2[𝑋𝑖+1 2 − 𝑋𝑖 2 ] + 2[𝑌𝑖+1


2
− 𝑌𝑖2 ] + 4[𝑋𝑖+1 − 𝑋𝑖 ] − 2[𝑌𝑖+1 − 𝑌𝑖 ]

Despejamos Pi+1

𝑃𝑖+1 = 𝑃𝑖 + 2[𝑋𝑖+1 2 − 𝑋𝑖 2 ] + 2[𝑌𝑖+1


2
− 𝑌𝑖2 ] + 4[𝑋𝑖+1 − 𝑋𝑖 ] − 2[𝑌𝑖+1 − 𝑌𝑖 ]

Sustituimos Xi+1 por la ecuación 1:

𝑃𝑖+1 = 𝑃𝑖 + 2[(𝑋𝑖 + 1)2 − 𝑋𝑖 2 ] + 2[𝑌𝑖+1


2
− 𝑌𝑖2 ] + 4[(𝑋𝑖 + 1) − 𝑋𝑖 ] − 2[𝑌𝑖+1 − 𝑌𝑖 ]

𝑃𝑖+1 = 𝑃𝑖 + 2[𝑋𝑖 2 + 2𝑋𝑖 + 1 − 𝑋𝑖 2 ] + 2[𝑌𝑖+1


2
− 𝑌𝑖2 ] + 4[𝑋𝑖 + 1 − 𝑋𝑖 ] − 2[𝑌𝑖+1 − 𝑌𝑖 ]

2
𝑃𝑖+1 = 𝑃𝑖 + 2[2𝑋𝑖 + 1] + 2[𝑌𝑖+1 − 𝑌𝑖2 ] + 4 − 2[𝑌𝑖+1 − 𝑌𝑖 ]
2
𝑃𝑖+1 = 𝑃𝑖 + 4𝑋𝑖 + 2 + 2[𝑌𝑖+1 − 𝑌𝑖2 ] − 2[𝑌𝑖+1 − 𝑌𝑖 ] + 4
2
𝑃𝑖+1 = 𝑃𝑖 + 2[𝑌𝑖+1 − 𝑌𝑖2 ] + 4𝑋𝑖 − 2[𝑌𝑖+1 − 𝑌𝑖 ] + 6

 Sustituimos Yi+1 por la ecuación 2, en cada caso por separado.

o Caso 1. Si Pi<0 entonces Yi+1= Yi por lo tanto

𝑃𝑖+1 = 𝑃𝑖 + 2[𝑌𝑖2 − 𝑌𝑖2 ] + 4𝑋𝑖 − 2[𝑌𝑖 − 𝑌𝑖 ] + 6

Departamento de Sistemas y Computación Página 28


𝑃𝑖+1 = 𝑃𝑖 + 4𝑋𝑖 + 6 (Ecuación 5)

o Caso 2. Si Pi >= 0 entonces Yi+1= Yi -1 por lo tanto

𝑃𝑖+1 = 𝑃𝑖 + 2[(𝑌𝑖 − 1)2 − 𝑌𝑖2 ] + 4𝑋𝑖 − 2[(𝑌𝑖 − 1) − 𝑌𝑖 ] + 6

𝑃𝑖+1 = 𝑃𝑖 + 2[(𝑌𝑖2 −2𝑌𝑖 + 1) − 𝑌𝑖2 ] + 4𝑋𝑖 − 2[𝑌𝑖 − 1 − 𝑌𝑖 ] + 6

𝑃𝑖+1 = 𝑃𝑖 + 2[ 𝑌𝑖2 −2𝑌𝑖 + 1 − 𝑌𝑖2 ] + 4𝑋𝑖 + 2 + 6

𝑃𝑖+1 = 𝑃𝑖 + 2[ −2𝑌𝑖 + 1] + 4𝑋𝑖 + 8

𝑃𝑖+1 = 𝑃𝑖 −4𝑌𝑖 + 2 + 4𝑋𝑖 + 8


𝑃𝑖+1 = 𝑃𝑖 + 4𝑋𝑖 −4𝑌𝑖 + 10 (Ecuación 6)

 Ahora solo resta determinar el valor inicial de P, que sería P0. Nos basamos
en la ecuación 4, pero con subíndice cero.

𝑃0 = 2𝑋0 2 + 2𝑌02 + 4𝑋0 − 2𝑌0 − 2𝑟 2 + 3

El primer punto si lo conocemos, como se muestra en la figura;

Sustituimos por los valores iniciales de X y Y…

𝑃0 = 2(0)2 + 2𝑟 2 + 4(0) − 2(𝑟) − 2𝑟 2 + 3

𝑃0 = −2(𝑟) + 3

𝑃0 = 3 − 2𝑟 (Ecuación 7)

Departamento de Sistemas y Computación Página 29


Con las ecuaciones obtenidas podemos generar una circunferencia en un plano
discreto. Para lograrlo, seguimos el algoritmo de Bresenham para la circunferencia
que se describe a continuación.

4.4 Procedimiento (Descripción)


4.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

4.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java (IDE), por ejemplo, NetBeans.
 Librería swing o javaFX.

4.4.3 Desarrollo de la Práctica


Ejecutamos los pasos análogos de la práctica uno, desde el PASO 1 hasta el PASO 6,
solo cambiamos el nombre del proyecto a AppCircunferenciaBresenham, la
etiqueta del botón a Dibuja circunferencia y el nombre de la función que contendrá
el algoritmo a circunferenciaBresenham.

Paso 1:
Dentro de la función circunferenciaBresenham, implemente el siguiente algoritmo:

Recibe los parámetros correspondientes al centro y radio de la


circunferenciaBresenham(Xcentro, Ycentro, radio)
X=0
Y=radio
P=3-2r

Mientras X < Y
PX = X + Xcentro;
PY = Y + Ycentro;
Iluminar pixel en coordenada PX, PY
Iluminar pixel en coordenada PX,-PY
Iluminar pixel en coordenada -PX, PY
Iluminar pixel en coordenada -PX, PY
Iluminar pixel en coordenada PY, PX
Iluminar pixel en coordenada PY,-PX
Iluminar pixel en coordenada -PY, PX
Iluminar pixel en coordenada -PY, PX

Si P<0 Entonces
P = P+4X+6
En otro caso
P = P+4X-4Y+10
Y = Y-1
Fin del Si-Entonces

Departamento de Sistemas y Computación Página 30


X = X+1
Fin Mientras
Fin de Algoritmo (Bresenham)

Ejecute el programa y verifique que se traza una circunferencia.

Programe una función que dibuje 5000 circunferencias aleatorias y mida el total de
milisegundos empleados.

4.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
una corrida de escritorio en una hoja de cálculo (por ejemplo, en Excel) y después el
código fuente de su función que implemento el pseudocódigo del algoritmo de la
circunferencia y al último incluir imágenes de la ejecución de su programa.

Compare el tiempo requerido para dibujar 5000 circunferencias entre los métodos de
circunferencia común y el de circunferencia de Bresenham.

4.5 Resultados y Conclusiones


Con ésta práctica, el alumno apreciará la diferencia en el desempeño del algoritmo
que solo usa números enteros (Bresenham) a otro que requiere flotantes y el cálculo
de raíces (circunferencia común).

Departamento de Sistemas y Computación Página 31


Practica 5. Circunferencia Punto Medio
5.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad I: Introducción a
la graficación por computadora del subtema 1.3. Aspectos matemáticos de la
graficación, del programa de estudios de la materia de Graficación, desarrollando la
competencia específica: “Aplica los modelos matemáticos básicos y los modelos
de color utilizados en objetos bidimensionales y tridimensionales”.

El presente algoritmo tiene una forma un poco más simple de deducir las ecuaciones
usadas en el algoritmo de la circunferencia de Bresenham, aunque llega ecuaciones
similares.

5.2 Objetivo (Competencia)


Elaborar un programa que trace una circunferencia usando el Algoritmo de la
Circunferencia de Punto Medio.

5.3 Fundamento
Para aplicar el método del punto medio, definimos una función circular como:

𝑓(𝑥, 𝑦) = 𝑥 2 + 𝑦 2 − 𝑟 2 (Ecuación 1)

Cualquier punto (x, y) en la frontera del círculo de radio r satisfará la ecuación


𝑓(𝑥, 𝑦) = 0. Si el punto se encuentra en el interior del círculo, la función tomará un
valor negativo, mientras que, si el punto se encuentra fuera del círculo, el valor de la
función será positivo.

En resumen, la posición relativa de cualquier punto (x, y) puede determinarse


comprobando el signo de la función generadora del círculo:

Departamento de Sistemas y Computación Página 32


< 0, 𝑠𝑖 (𝑥, 𝑦) 𝑠𝑒 𝑒𝑛𝑐𝑢𝑒𝑛𝑡𝑟𝑎 𝑑𝑒𝑛𝑡𝑟𝑜 𝑑𝑒𝑙 𝑐í𝑟𝑐𝑢𝑙𝑜
𝑓(𝑥, 𝑦) { = 0, 𝑠𝑖 (𝑥, 𝑦) 𝑠𝑒 𝑒𝑛𝑐𝑢𝑒𝑛𝑡𝑟𝑎 𝑠𝑜𝑏𝑟𝑒 𝑙𝑎 𝑐𝑖𝑟𝑐𝑢𝑛𝑓𝑒𝑟𝑒𝑛𝑐𝑖𝑎
> 0, 𝑠𝑖 (𝑥, 𝑦) 𝑠𝑒 𝑒𝑛𝑐𝑢𝑒𝑛𝑡𝑟𝑎 𝑓𝑢𝑒𝑟𝑎 𝑑𝑒𝑙 𝑐í𝑟𝑐𝑢𝑙𝑜

Las comprobaciones de la Ecuación anterior, se realizan para los puntos intermedios


situados en la vecindad de la trayectoria circular en cada paso de muestreo.

Así, la función generadora del círculo es un parámetro de decisión en el algoritmo del


punto medio, y podemos determinar los cálculos incrementales necesarios para
esta función.

Nuestro parámetro de decisión será la ecuación 1 de generación del círculo, evaluado


en el punto medio entre estos dos píxeles:

1 1
𝑃𝑖 = 𝑓 (𝑋𝑖 + 1, 𝑌𝑖 − ) = (𝑋𝑖 + 1)2 + (𝑌𝑖 − )2 − 𝑟 2
2 2

y tomamos la siguiente deducción:

Si Pi es negativo entonces Y está más cerca Yi


Si Pi es positivo entonces Y está más cerca Yi -1

Así, la altura del siguiente pixel Yi+1, se expresa como:

𝑌𝑖 𝑠𝑖 𝑃𝑖 ≥ 0 𝑐𝑎𝑠𝑜 1
𝑌𝑖+1 = { (Ecuación 2)
𝑌𝑖 − 1 𝑠𝑖 𝑃𝑖 < 0 𝑐𝑎𝑠𝑜 2

Pasos para obtener las fórmulas usadas en el algoritmo:


 Partimos del hecho que conocemos los valores del i-ésimo pixel (Xi, Yi).
 Y queremos conocer el siguiente pixel (Xi+1, Yi+1).
 Los incrementos en el eje X son unitarios:

𝑋𝑖+1 = 𝑋𝑖 + 1 (Ecuación 3)

 Ahora creamos un parámetro de decisión P


1
𝑃𝑖 = (𝑋𝑖 + 1)2 + (𝑌𝑖 − )2 − 𝑟 2
2
2 2 1
𝑃𝑖 = (𝑋𝑖 + 2𝑋𝑖 + 1) + (𝑌𝑖 − 𝑌𝑖 + ) − 𝑟 2
4
2 2 2 5
𝑃𝑖 = 𝑋𝑖 + 𝑌𝑖 + 2𝑋𝑖 − 𝑌𝑖 − 𝑟 + 4 (Ecuación 4)

 Aplicamos la inducción matemática para obtener Pi+1

Primero suponemos que, si es válido para Pi, también lo será para Pi+1
Departamento de Sistemas y Computación Página 33
5
𝑃𝑖+1 = 𝑋𝑖+1 2 + 𝑌𝑖+1 2 + 2𝑋𝑖+1 − 𝑌𝑖+1 − 𝑟 2 +
4
Restamos Pi de Pi+1
𝑃𝑖+1 − 𝑃𝑖 = 𝑋𝑖+1 − 𝑋𝑖 2 + 𝑌𝑖+1 2 − 𝑌𝑖 2 + 2𝑋𝑖+1 − 2𝑋𝑖 − 𝑌𝑖+1 + 𝑌𝑖
2

𝑃𝑖+1 − 𝑃𝑖 = [𝑋𝑖+1 2 − 𝑋𝑖 2 ] + [𝑌𝑖+1 2 − 𝑌𝑖 2 ] + 2[𝑋𝑖+1 − 𝑋𝑖 ] − [𝑌𝑖+1 − 𝑌𝑖 ]


Despejamos Pi+1
𝑃𝑖+1 = 𝑃𝑖 + [𝑋𝑖+1 2 − 𝑋𝑖 2 ] + [𝑌𝑖+1 2 − 𝑌𝑖 2 ] + 2[𝑋𝑖+1 − 𝑋𝑖 ] − [𝑌𝑖+1 − 𝑌𝑖 ]
Sustituimos Xi+1 por la ecuación 3:
𝑃𝑖+1 = 𝑃𝑖 + [(𝑋𝑖 + 1)2 − 𝑋𝑖 2 ] + [𝑌𝑖+1 2 − 𝑌𝑖 2 ] + 2[𝑋𝑖 + 1 − 𝑋𝑖 ] − [𝑌𝑖+1 − 𝑌𝑖 ]
𝑃𝑖+1 = 𝑃𝑖 + [𝑋𝑖 2 + 2𝑋𝑖 + 1 − 𝑋𝑖 2 ] + [𝑌𝑖+1 2 − 𝑌𝑖 2 ] − [𝑌𝑖+1 − 𝑌𝑖 ] + 2
𝑃𝑖+1 = 𝑃𝑖 + 2𝑋𝑖 + 1 + [𝑌𝑖+1 2 − 𝑌𝑖 2 ] − [𝑌𝑖+1 − 𝑌𝑖 ] + 2
𝑃𝑖+1 = 𝑃𝑖 + [𝑌𝑖+1 2 − 𝑌𝑖 2 ] + 2𝑋𝑖 − [𝑌𝑖+1 − 𝑌𝑖 ] + 3

 Sustituimos Yi+1 por la ecuación 2, en cada caso por separado.

o Caso 1. Si Pi<0 entonces Yi+1= Yi por lo tanto


𝑃𝑖+1 = 𝑃𝑖 + [𝑌𝑖 2 − 𝑌𝑖 2 ] + 2𝑋𝑖 − [𝑌𝑖 − 𝑌𝑖 ] + 3
𝑃𝑖+1 = 𝑃𝑖 + 2𝑋𝑖 + 3 (Ecuación 5)

o Caso 2. Si Pi >= 0 entonces Yi+1= Yi -1 por lo tanto


𝑃𝑖+1 = 𝑃𝑖 + [(𝑌𝑖 − 1)2 − 𝑌𝑖 2 ] + 2𝑋𝑖 − [(𝑌𝑖 − 1) − 𝑌𝑖 ] + 3
𝑃𝑖+1 = 𝑃𝑖 + [(𝑌𝑖2 − 2𝑌 + 1) − 𝑌𝑖 2 ] + 2𝑋𝑖 − [𝑌𝑖 − 1 − 𝑌𝑖 ] + 3
𝑃𝑖+1 = 𝑃𝑖 + [𝑌𝑖2 − 2𝑌 + 1 − 𝑌𝑖 2 ] + 2𝑋𝑖 − [−1] + 3
𝑃𝑖+1 = 𝑃𝑖 + [−2𝑌 + 1] + 2𝑋𝑖 + 4
𝑃𝑖+1 = 𝑃𝑖 + 2𝑋𝑖 − 2𝑌 + 5 (Ecuación 6)

 Ahora solo resta determinar el valor inicial de P, que sería P0. Nos basamos
en la ecuación 4, pero con subíndice cero.
5
𝑃0 = 𝑋0 2 + 𝑌0 2 + 2𝑋0 − 𝑌0 − 𝑟 2 +
4
Sustituimos por los valores iniciales de X y Y que son respectivamente (0, r).
5
𝑃0 = (0)2 + (𝑟)2 + 2(0) − (𝑟) − 𝑟 2 +
4
5
𝑃0 = 𝑟 2 − 𝑟 − 𝑟 2 +
4
5
𝑃0 = − 𝑟
4
Pero para trabajar con enteros, redondeamos 5/4 quedando la ecuación:

𝑃0 ≈ 1 − 𝑟 (Ecuación 7)

Ahora, con las ecuaciones obtenidas, seguimos el algoritmo de la circunferencia de


punto medio, que se describe a continuación.

Departamento de Sistemas y Computación Página 34


5.4 Procedimiento (Descripción)
5.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

5.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java (IDE), por ejemplo, NetBeans.
 Librería swing o javaFX.

5.4.3 Desarrollo de la Práctica


Ejecutamos los pasos análogos de la práctica uno, desde el PASO 1 hasta el PASO 6,
solo cambiamos el nombre del proyecto a AppCircunferenciaPM, la etiqueta del
botón a Dibuja circunferencia y el nombre de la función que contendrá el algoritmo
a circunferenciaPM.

Paso 1:
Dentro de la función circunferenciaPM, implemente el siguiente algoritmo:

Recibe los parámetros correspondientes al centro y radio de la


circunferenciaPM (Xcentro, Ycentro, radio)
X=0
Y=radio
P=1-r

Mientras X < Y
PX = X + Xcentro;
PY = Y + Ycentro;
Iluminar pixel en coordenada PX, PY
Iluminar pixel en coordenada PX,-PY
Iluminar pixel en coordenada -PX, PY
Iluminar pixel en coordenada -PX, PY
Iluminar pixel en coordenada PY, PX
Iluminar pixel en coordenada PY,-PX
Iluminar pixel en coordenada -PY, PX
Iluminar pixel en coordenada -PY, PX

Si P<0 Entonces
P = P+2X+3
En otro caso
P = P+2X-2Y+5
Y = Y-1
Fin del Si-Entonces

X = X+1
Fin Mientras
Fin de Algoritmo (Bresenham)

Ejecute el programa y verifique que se traza una circunferencia.

Departamento de Sistemas y Computación Página 35


Programe una función que dibuje 5000 circunferencias aleatorias y mida el total de
milisegundos empleados.

5.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
una corrida de escritorio en una hoja de cálculo (por ejemplo, en Excel) y después el
código fuente de su función que implemento el pseudocódigo del algoritmo de la
circunferencia y al último incluir imágenes de la ejecución de su programa.

Compare el tiempo requerido para dibujar 5000 circunferencias entre los métodos de
circunferencia común, el de circunferencia de Bresenham y el de circunferencia de
punto medio.

5.5 Resultados y Conclusiones


Con ésta práctica, el alumno comprobará que el método de la circunferencia de
Bresenham y el de punto medio son prácticamente igual de eficientes.

Departamento de Sistemas y Computación Página 36


Practica 6. Dibujo de líneas y
polígonos en C con la librería
WinBGÍm
6.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad I: Introducción a
la graficación por computadora del subtema 1.5. Representación y trazo de líneas
y polígonos, del programa de estudios de la materia de Graficación, desarrollando la
competencia específica: “Aplica los modelos matemáticos básicos y los modelos
de color utilizados en objetos bidimensionales y tridimensionales”.

Uno de los lenguajes de programación más utilizados h sido el lenguaje C, por lo que
es importante dominar la programación de gráficos en este lenguaje. Existen varios
compiladores y diversas librerías gráficas. Las librerías gráficas contienen funciones
para dibujar figuras comunes como lo son puntos, líneas, circunferencias y polígonos.

Además de funciones para definir y limpiar ventanas, colores, rellenos y otras


operaciones más que ayudan a crear los gráficos y efectos que desee el programador.

Una de las librerías más usadas fue la que tenía el compilador Borland C, conocida
como BGI (Borland Graphic Interface). Así, la WinBGIm, es una librería BGI para
Windows.

6.2 Objetivo (Competencia)


Escribir un programa que use las funciones de la librería WinBGIm para el trazo de
líneas y polígonos.

6.3 Fundamento
En informática, una librería es un conjunto de funciones, codificadas en un lenguaje
de programación, que ofrece una interfaz bien definida para la funcionalidad que se
invoca. Su fin es ser utilizada por otros programas [9].

Las funciones agrupadas en una biblioteca, por lo general, atienden a un tema común,
por ejemplo, una librería matemática contendrá funciones para calcular raíces, senos,
cosenos, logaritmos, etcétera, una librería cronológica tendrá funciones para obtener
hora, fecha, días transcurridos, etc.

Así una librería de gráficos, se espera que contenga funciones que nos ayuden a
definir colores, tipos de contornos, figuras, etc…

El turbo C popularizo una librería llamada BGI (BORLOAND GRAPHICS

Departamento de Sistemas y Computación Página 37


INTERFACE). Fue ampliamente utilizada y aunque es muy anticuada, es muy fácil
aprender a usarla. Aunque solo funciona en MSDOS, se han hecho implementaciones
que pueden usarse en Windows, tal es el caso de la librería WinBGIm.

WinBGIm, es una librería de elementos gráficos para el compilador MingW (de


lenguaje c). Esta librería emula la librería BGI de Borland, pero hace que pueda usarse
en windows. Además, cuenta con funcionalidades extra. La descripción de esta
librería está disponible en:

http://www.cs.colorado.edu/~main/cs1300/doc/bgi/bgi.html

6.4 Procedimiento (Descripción)


6.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

6.4.2 Material de Apoyo


 Compilador de c mingw.
 Entorno de desarrollo Code::Blocks.
 Librería de gráficos WinBGIm.

6.4.3 Desarrollo de la Práctica


Descargamos El entorno de programación CodeBlocks y el compilador mingW del
siguiente sitio:
http://www.codeblocks.org/downloads/26

En este caso sería el archivo codeblocks-17.12mingw-setup.exe, ejecútelo y aparece


la siguiente ventana:

Departamento de Sistemas y Computación Página 38


Prosiga la instalación hasta terminar.

Ahora descargamos la librería WinBGIm de:


https://sangams.com.np/use-graphics-h-codeblocks-updated/

Descargamos el archivo WinBGIm_Library6_0_Dec2017.zip, que es un archivo


comprimido contiene los archivos:
info.txt
clock.cpp
MinGW\include\graphics.h
MinGW\include\winbgim.h
MinGW\lib\libbgi.a

Configuramos CodeBlocks para agregar la librería, con los siguientes pasos:

1. Extraer del zip la carpeta MinGW hacia la carpeta del directorio de


CodeBlocks:

2. Abrimos el programa CodeBlocks y abrimos el formulario ubicado en


“Settings  Compiler linker settings" damos clic en el botón Add

Departamento de Sistemas y Computación Página 39


3. Damos ok y el formulario queda como:

4. Da clic en el botón de OK para cerrar el formulario. Ahora En el Menú


FileNewProject, elije crear “Console application”

Departamento de Sistemas y Computación Página 40


5. Elija el lenguaje C++, le da un nombre al proyecto appFiguras. Se genera
el proyecto. En la carpeta sources está el archivo main.cpp, edítelo
escribiendo el código:

#include <iostream>
#include <graphics.h>

using namespace std;

int main()
{
cout << "Ventana de texto" << endl;
initwindow( 400 , 400 , "Libreria WinBGIm",200,50);

putpixel(200,200,YELLOW);
line(10,20,380,390);
setcolor(GREEN);
circle(200,200,100);

while( !kbhit() );

closegraph( );
return 0;
}

6. Ejecútelo, dando clic en el botón de “compilar y ejecutar” y veremos


algo como:

Departamento de Sistemas y Computación Página 41


7. Ahora modifique el código para probar el funcionamiento de otros objetos
gráficos (En la página de WinBGIm está el manual con las funciones de
la librería).
6.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
una descripción de cada una de las funciones usadas

6.5 Resultados y Conclusiones


Con ésta práctica, el alumno comparará la librería swing de java y la librería Win
BGIm de C++, y podrá decidir bajo qué circunstancias deberá usar una u otra.

Departamento de Sistemas y Computación Página 42


Practica 7. Dibujo de líneas y
polígonos en Java con la librería JOGL
7.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad I: Introducción a
la graficación por computadora del subtema 1.5. Representación y trazo de líneas
y polígonos, del programa de estudios de la materia de Graficación, desarrollando la
competencia específica: “Aplica los modelos matemáticos básicos y los modelos
de color utilizados en objetos bidimensionales y tridimensionales”.

Java OpenGL (JOGL) es una biblioteca que permite acceder a OpenGL mediante
programación en Java. JOGL permite acceder a la mayoría de características
disponibles para los programadores de C, con la excepción de las llamadas a ventanas
realizadas en GLUT (ya que Java contiene sus propios sistemas de ventanas, AWT y
Swing), y algunas extensiones de OpenGL. [10]

7.2 Objetivo (Competencia)


Escribir un programa Java que use las funciones de la librería JOGL para el trazo de
líneas y polígonos, según la filosofía de OpenGL.

7.3 Fundamento
OpenGL (Open Graphics Library) es una especificación estándar que define una API
multilenguaje y multiplataforma para escribir aplicaciones que produzcan gráficos 2D
y 3D. La interfaz consiste en más de 250 funciones diferentes que pueden usarse para
dibujar escenas tridimensionales complejas a partir de primitivas geométricas
simples, tales como puntos, líneas y triángulos. Fue desarrollada originalmente por
Silicon Graphics Inc. (SGI) en 1992. [11]

JOGL se diferencia de otras bibliotecas Java para OpenGL en que simplemente


expone las funciones de la OpenGL, basadas en un lenguaje procedural (lenguaje C),
por medio de métodos contenidos en unas pocas clases. [10]

7.4 Procedimiento (Descripción)


7.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

7.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java (IDE), por ejemplo, NetBeans.
 Librería JOGL.

Departamento de Sistemas y Computación Página 43


7.4.3 Desarrollo de la Práctica
Desde el portal de plugins de NetBeans descargamos la librería NetBeans OpenGL
Pack:
http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?plug
inid=3260

Sobre esa página, damos click en el botón de download y obtendremos el archivo


comprimido 1246294100841_netbeans-opengl-pack_0.5.5.zip. Extraemos el
archivo javax-media-opengl.nbm.

Iniciamos NetBeans, para desde ahí instalar la librería que acabamos de descargar y
descomprimir. Abrimos el formulario ubicado en ToolsPlugins

En la pestaña Downloaded le damos clic en el botón Add Plugins. Buscamos y


seleccionamos la librería javax-media-opengl.nbm.

Reiniciamos NetBeans (Cerramos y volvemos a abrir). Creamos un nuevo proyecto


siguiendo la ruta FileNew Project. Se muestra un formulario donde ya deben
aparecer plantilla de proyectos basados en JOGL. Seleccionamos JOGL Application

Departamento de Sistemas y Computación Página 44


Dejamos el nombre del Proyecto SimpleJOGL. Avanzamos y si llega a aparecer la
siguiente advertencia:

Le damos en el botón Resolve Problems… Le indicamos que resuelva cada problema


y listo. Podemos ejecutar la aplicación:

Departamento de Sistemas y Computación Página 45


Ahora modifique el código para probar las primitivas de OpenGL, como son cambiar
los colores de fondo, del lápiz, líneas, polígonos, etc…

7.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
una descripción de cada una de las funciones usadas

7.5 Resultados y Conclusiones


Con ésta práctica, el alumno comparará la librería swing de java, la librería Win
BGIm de C++, y la librería JOGL.

Sobre todo, deberá reflexionar sobre el paradigma que propone OpenGL al funcionar
como una máquina de estados.

Departamento de Sistemas y Computación Página 46


Practica 8. Guardar y recuperar una
imagen pixel por pixel
8.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad I: Introducción a
la graficación por computadora del subtema 1.6. Formatos de imagen, del
programa de estudios de la materia de Graficación, desarrollando la competencia
específica: “Aplica los modelos matemáticos básicos y los modelos de color
utilizados en objetos bidimensionales y tridimensionales”.

Una imagen digital o gráfico digital es una representación bidimensional de una


imagen a partir de una matriz numérica. Las imágenes digitales se pueden obtener de
varias formas:
 Por medio de dispositivos de entrada conversión analógica-digital como los
escáneres y las cámaras digitales.
 Directamente mediante programas informáticos editores de mapas de bits y
dibujo vectorial, como por ejemplo realizando dibujos con el ratón o tableta
digitalizadora gráfica incluyendo el lápiz óptico.

Una imagen en mapa de bits o imagen de píxeles, es una estructura o archivo de datos
que representa una cuadricula rectangular de píxeles o puntos de color, denominada
matriz, que se puede visualizar en un monitor, papel u otro dispositivo de
representación.

A las imágenes en mapa de bits se las suele definir por su altura y anchura (en píxeles)
y por su profundidad de color (en bits por píxel), que determina el número de colores
distintos que se pueden almacenar en cada punto individual, y por lo tanto, en gran
medida, la calidad del color de la imagen.

8.2 Objetivo (Competencia)


Concientizar a los alumnos que se requiere una gran cantidad de almacenamiento para
almacenar imágenes en comparación con los archivos de texto.

En la presente practica se conforma de dos partes:


i. Se verán las funciones para obtener el color de un pixel dada su posición y
guardar dicha información en un archivo.
ii. Se verán las funciones para pintar un pixel de alguna posición en el color que
deseemos. La información de la posición y color las leeremos de un archivo
dado.

Departamento de Sistemas y Computación Página 47


8.3 Fundamento
En la presente práctica, programaremos en C++ usando el IDE CodeBlocks con la
librería WinBGIm. Las librerías y funciones a destacar que usaremos son:

 <iostream>
Es un componente de la biblioteca estándar (STL) del lenguaje de programación
C++ que es utilizado para operaciones de entrada/salida. Su nombre es un
acrónimo de Input/Output Stream. El flujo de entrada y salida de datos en C++
(y su predecesor C) no se encuentra definida dentro de la sintaxis básica y se
provee por medio de librerías de funciones especializadas como iostream.

 <graphics.h>
Sus funciones permiten, entre otras cosas, escribir en modo gráfico en la pantalla
punto a punto, o figuras geométricas, copiar y modificar el contenido de un trozo
de la pantalla y manejar el ratón.

 <fstream>
Provee facilidades para la entrada y salida basada en archivos.

 ofstream archivo()
Es una clase para manejar archivos de salida.

 archivo.close()
Cierra el archivo asociado.

 archivo.flush()
Realiza las operaciones de escritura pendientes que aún se han realizado sólo en
el buffer.

 archivo.open()
Se usa para abrir el archivo a lo largo de la ejecución del programa.

 circle()
Esta función se usa para dibujar un círculo.

 closegraph()
Esta función es usada para cerrar el sistema gráfico como es iniciada por la
función initgraph.

 floodfill()
Esta función es usada para rellenar un área cerrado con el color de relleno y trama
de relleno actuales.

 getmaxx()

Departamento de Sistemas y Computación Página 48


Esta función es usada para obtener la coordenada máxima de la pantalla en la
dirección horizontal.

 getmaxy()
Esta función es usada para obtener la coordenada máxima de la pantalla en la
dirección vertical.

 getPixel()
Esta función es usada para obtener el valor del color del píxel especificado por
los argumentos x e y.

 initwindow()
Esta rutina hay que llamarla antes que cualquier otra de esta biblioteca, ya que
inicializa el sistema gráfico y crea una ventana gráfica del tamaño especificado
en los parámetros.
 line()
Esta función es usada para conectar dos puntos con una línea recta.

 putpixel()
Esta función es usada para asignar el valor del color a un píxel en particular.

 rectangle()
Esta función dibujará un rectángulo sin rellenar su interior usando el color actual.

 setcolor()
Esta función es usada para asignar el color al valor del color especificado por el
argumento color.

 setfillstyle()
Esta función es usada para seleccionar una trama predefinida y un color de
relleno.

8.4 Procedimiento (Descripción)


8.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

8.4.2 Material de Apoyo


 Compilador de c mingw.
 Entorno de desarrollo Code::Blocks.
 Librería de gráficos WinBGIm.

Departamento de Sistemas y Computación Página 49


8.4.3 Desarrollo de la Práctica
Esta práctica consta de dos partes, en la primera creamos una escena y procedemos a
guardarla en un archivo y en la segunda parte abrimos el archivo anterior y
procedemos a dibujar la imagen.

Parte I:
Iniciamos Codeblocks, y seguimos el menú FileNewProject, En el formulario
elije el icono con la leyenda Console application.

Selecciones el lenguaje C++, del título de proyecto como GuardarImagen, Elija la


carpeta donde almacenara el proyecto y de clic en el botón Next> luego en Finish.

Cree una escena cualquiera, dibujando diferentes figuras con diversos colores, por
ejemplo:

#include <iostream>
#include <graphics.h>
#include <fstream>

using namespace std;

int main()
{
initwindow(400 ,400 ,"Práctica Guardar Imagen", 200, 50);

// Crear escena
// Sol
setcolor(YELLOW);
circle(300,100,40);
setfillstyle(1,YELLOW);
floodfill(300,100,YELLOW);

// Casa
setcolor(BLUE);
line(65, 225, 195, 125);
line(195, 125, 320, 225);
rectangle(123, 180, 264, 280);

// Puerta
setcolor(RED);
rectangle(180, 230, 215, 280);
setfillstyle(1,RED);
floodfill(200,250,RED);

while( !kbhit() );

closegraph();
guardarImagen((char *)"casita.img");
return 0;
}

Departamento de Sistemas y Computación Página 50


Ahora creamos función guardarImagen(), y la invocaremos antes de terminar el
programa principal.

void guardarImagen(char * nombreArchivo)


{ ofstream archivo;
int i,j,tamX,tamY;

tamX=getmaxx();
tamY=getmaxy();
archivo.open(nombreArchivo);
// Necesitamos guardar información del tamaño
// de la imagen (cabecera)
archivo <<tamX<<" "<<tamY<<'\n';
for(i=0;i<tamX;i++)
for(j=0;j<tamY;j++)
{ archivo << getpixel(i,j)<<" ";
}

archivo.flush();
archivo.close();
}

Parte II:
Iniciamos Codeblocks, y seguimos el menú FileNewProject, En el formulario
elije el icono con la leyenda Console application.

Selecciones el lenguaje C++, del título de proyecto como LeerImagen, Elija la


carpeta donde almacenara el proyecto y de clic en el botón Next> luego en Finish.

Ahora escribimos el siguiente código que incluye la función leerImagen(), y la


invocaremos despúes de initwindow.

#include <iostream>
#include <graphics.h>
#include <fstream>

using namespace std;

void leerImagen(char * nombreArchivo)


{ ifstream archivo;
int i,j,tamX,tamY;
int color;

archivo.open(nombreArchivo);

// Necesitamos recuperar información del tamaño


// de la imagen (cabecera)
archivo >>tamX >>tamY;
cout<<"Tamaño en X: "<<tamX<<", tamaño en Y: "<<tamY;
for(i=0;i<tamX;i++)
for(j=0;j<tamY;j++)
{ archivo >> color;
cout << color<<" ";

Departamento de Sistemas y Computación Página 51


putpixel(i,j,color);
}
archivo.close();
}

int main()
{ initwindow(400 ,400 ,"Práctica Leer Imagen", 200, 50);
leerImagen((char *)"casita.img");

while( !kbhit() );
closegraph( );
return 0;
}

Antes de ejecutar el programa, copie el archivo gráfico casita.img al directorio del


proyecto:

8.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que nos diga
como calcular el tamaño esperado del archivo que contiene el gráfico.

Debe incluir código fuente y pantallas de la ejecución de los programas.

También debe realizar una investigación sobre los formatos gráficos de mapa de bits.

8.5 Resultados y Conclusiones


Con ésta práctica, el alumno tomará conciencia del tamaño tan grande que ocupa una
imagen y de la necesidad de comprimir de alguna manera la información.

Departamento de Sistemas y Computación Página 52


Practica 9. Guardar y recuperar una
imagen por la descripcion de sus
componentes
9.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad I: Introducción a
la graficación por computadora del subtema 1.6. Formatos de imagen, del
programa de estudios de la materia de Graficación, desarrollando la competencia
específica: “Aplica los modelos matemáticos básicos y los modelos de color
utilizados en objetos bidimensionales y tridimensionales”.

En la práctica anterior comprobamos que una imagen que se guarda pixel por pixel,
ocupa mucho espacio. Otra alternativa es guardar la descripción de las figuras, este
tipo de imágenes se les conoce como gráficos vectoriales.

Los gráficos en mapa de bits se distinguen de los gráficos vectoriales en que estos
últimos representan una imagen a través del uso de objetos geométricos como curvas
de Bézier y polígonos, no del simple almacenamiento del color de cada punto en la
matriz.

9.2 Objetivo (Competencia)


Almacenar imágenes a partir de las figuras geométricas que la componen.

En la presente practica se conforma de dos partes:


i. Se plantea una estrategia para describir y guardar las figuras que conforman
una imagen.
ii. Se reconstruye una imagen a partir de las descripciones obtenidas en un
archivo.

9.3 Fundamento
Una imagen vectorial es una imagen digital formada por objetos geométricos
dependientes (segmentos, polígonos, arcos, muros, etc.), cada uno de ellos definido
por atributos matemáticos de forma, de posición, etc. Por ejemplo, un círculo de color
rojo quedaría definido por la posición de su centro, su radio, el grosor de línea y su
color.

El interés principal de los gráficos vectoriales es poder ampliar el tamaño de una


imagen a voluntad sin sufrir la pérdida de calidad que sufren los mapas de bits. De la
misma forma, permiten mover, estirar y retorcer imágenes de manera relativamente
sencilla.

Departamento de Sistemas y Computación Página 53


Se propone la siguiente estructura:

Comando Función Id D1 D2 D3 D4
Ventana initwindow 0 ancho alto
Color lápiz setcolor 1 Color = 0 a 15
Tipo relleno setfillstyle 2 Borde = 0 a 15
rellenar floodfill 3 Color = 0 a 15 X Y
circulo circle 4 Cx Cy radio
línea line 5 X1 Y1 X2 Y2
rectángulo rectangle 6 X1 Y1 X2 Y2

9.4 Procedimiento (Descripción)


9.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

9.4.2 Material de Apoyo


 Compilador de c mingw.
 Entorno de desarrollo Code::Blocks.
 Librería de gráficos WinBGIm.

9.4.3 Desarrollo de la Práctica


Esta práctica consta de dos partes, en la primera creamos una escena y procedemos a
guardarla en un archivo y en la segunda parte abrimos el archivo anterior y
procedemos a dibujar la imagen.

Parte I:
Iniciamos Codeblocks, y seguimos el menú FileNewProject, En el formulario
elije el icono con la leyenda Console application.

Selecciones el lenguaje C++, del título de proyecto como GuardarImagenVectorial,


Elija la carpeta donde almacenara el proyecto y de clic en el botón Next> luego en
Finish.

Cree una escena cualquiera, especificando diferentes comandos para después


guardarlos en el archivo casita.vec, el código puede ser el siguiente:

#include <iostream>
#include <fstream>

using namespace std;

struct comando
{
int id;
int D1;
int D2;

Departamento de Sistemas y Computación Página 54


int D3;
int D4;
} fig[13];

void guardarImagenVectorial(char * nombreArchivo)


{
ofstream archivo;
int i;

archivo.open(nombreArchivo);
// Guardar la cantidad de figuras (cabecera)
// y objetos
archivo<<13<<'\n';
for(i=0; i<12; i++)
{
archivo<<fig[i].id<<" "<<fig[i].D1<<" ";
archivo<<fig[i].D2<<" "<<fig[i].D3<<" ";
archivo<<fig[i].D4<<'\n';
}
archivo.flush();
archivo.close();
}

int main()
{
cout<<"Practica Guardar Imagen Vectorial \n\n";
//Definir tamaño de ventana
fig[0].id=0;
fig[0].D1=400;
fig[0].D2=400; //initwindow(400 ,400 ,"Titulo", 200, 50);

// Crear escena
// Sol
cout<<"Comando para colocar el color de lápiz a amarillo \n";
fig[1].id=1;
fig[1].D1=14; //setcolor(YELLOW);

cout<<"Comando para dibujar circulo \n";


fig[2].id=4;
fig[2].D1=300;
fig[2].D2=100;
fig[2].D3=40; //circle(300,100,40);

cout<<"Comando para definir el color del contorno a rellenar \n";


fig[3].id=2;
fig[3].D1=14; //setfillstyle(1,YELLOW);

cout<<"Comando para rellenar una figura cerrada \n";


fig[4].id=3;
fig[4].D1=14;
fig[4].D2=300;
fig[4].D3=100; //floodfill(300,100,YELLOW);

// Casa
cout<<"Comando para definir el color del lapiz \n";
fig[5].id=1;
fig[5].D1=9; //setcolor(BLUE);

cout<<"Comando para dibujar una linea \n";


fig[6].id=5;
fig[6].D1=65;
fig[6].D2=225;

Departamento de Sistemas y Computación Página 55


fig[6].D3=195;
fig[6].D4=125; //line(65, 225, 195, 125);

cout<<"Comando para dibujar una linea \n";


fig[7].id=5;
fig[7].D1=195;
fig[7].D2=125;
fig[7].D3=320;
fig[7].D4=225; //line(195, 125, 320, 225);

cout<<"Comando para dibujar un rectangulo \n";


fig[8].id=6;
fig[8].D1=123;
fig[8].D2=180;
fig[8].D3=264;
fig[8].D4=280; //rectangle(123, 180, 264, 280);

// Puerta
cout<<"Comando para definir el color del lapiz \n";
fig[9].id=1;
fig[9].D1=12; //setcolor(RED);

cout<<"Comando para dibujar un rectangulo \n";


fig[10].id=6;
fig[10].D1=180;
fig[10].D2=230;
fig[10].D3=215;
fig[10].D4=280; //rectangle(180, 230, 215, 280);

cout<<"Comando para definir el color del contorno a rellenar \n";


fig[11].id=2;
fig[11].D1=12; //setfillstyle(1,RED);

cout<<"Comando para rellenar una figura cerrada \n";


fig[12].id=3;
fig[12].D1=12;
fig[12].D2=200;
fig[12].D3=250; //floodfill(200,250,RED);

guardarImagenVectorial((char *)"casita.vec");
cout<< "Objetos guardados!";
return 0;
}

Parte II:
Iniciamos Codeblocks, y seguimos el menú FileNewProject, En el formulario
elije el icono con la leyenda Console application.

Selecciones el lenguaje C++, del título de proyecto como LeerImagenVectorial,


Elija la carpeta donde almacenara el proyecto y de clic en el botón Next> luego en
Finish.

Ahora escribimos el siguiente código que incluye la función leerImagenVectorial(),


y la invocaremos despúes de initwindow.

#include <iostream>
#include <graphics.h>

Departamento de Sistemas y Computación Página 56


#include <fstream>

using namespace std;

struct comando
{
int id;
int D1;
int D2;
int D3;
int D4;
} fig;

void leerImagenVectorial(char * nombreArchivo)


{
ifstream archivo;
int i, totalObjetos;

archivo.open(nombreArchivo);
// Necesitamos recuperar información del tamaño
// de la imagen (cabecera)
archivo >>totalObjetos;
cout<<"objetos: "<<totalObjetos<<"\n";
for(i=0; i<totalObjetos; i++)
{
archivo>>fig.id>>fig.D1>>fig.D2>>fig.D3>>fig.D4;
cout<<fig.id<<"-"<<fig.D1<<" "<<fig.D2<<" "<<fig.D3<<"
"<<fig.D4<<"\n";
delay(1000); // Sea hace una pausa entre cada figura
switch(fig.id)
{
case 0:
initwindow(fig.D1, fig.D2,"Practica Leer Imagen Vectorial",
200, 50);
break;
case 1:
setcolor(fig.D1);
break;
case 2:
setfillstyle(1, fig.D1);
break;
case 3:
floodfill(fig.D2, fig.D3, fig.D1);
break;
case 4:
circle(fig.D1, fig.D2, fig.D3);
break;
case 5:
line(fig.D1, fig.D2, fig.D3, fig.D4);
break;
case 6:
rectangle(fig.D1, fig.D2, fig.D3, fig.D4);
break;
}
}
archivo.close();
}

int main()
{
leerImagenVectorial((char *)"casita.vec");
while( !kbhit() );

Departamento de Sistemas y Computación Página 57


closegraph( );
return 0;
}

Reto.
Ahora expanda el programa anterior para abarcar al menos 4 figuras y/o comandos
más.

9.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF donde muestre
el programa donde implemento más figuras y. además pantallas de su ejecución.

También debe realizar una investigación sobre los formatos gráficos vectoriales.

9.5 Resultados y Conclusiones


Compare el tamaño de este archivo casita.vec con el anterior casita.img y escriba sus
conclusiones.

Departamento de Sistemas y Computación Página 58


Practica 10. Representacion de una
figura 2D a partir de sus vertices en
lenguaje c
10.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad II: Graficación
2D del subtema 2.1. Transformación bidimensional, del programa de estudios de la
materia de Graficación, desarrollando la competencia específica: “Desarrolla y
aplica modelos de graficación y transformación bidimensional para el
enriquecimiento visual de sus aplicaciones”.

Para generar una imagen necesitamos proporcionar las descripciones geométricas de


los objetos que se han de mostrar. Estas descripciones determinan las posiciones y las
formas de los objetos. Por ejemplo, una caja se especifica mediante las posiciones de
sus esquinas (vértices), y una esfera se define con la posición de su centro y su radio.

Con pocas excepciones, se requiere que las descripciones geométricas se especifiquen


en un sistema de referencia de coordenadas cartesianas estándar (Apéndice A).

10.2 Objetivo (Competencia)


Definir una figura a partir de sus vértices, formar una matriz con estos vértices y
escribir un programa que pueda unir los vértices con líneas.

10.3 Fundamento
El sistema de referencia que usaremos es el que maneja el sistema de gráficos de
WinBGIm, en el cual el origen de la ventana gráfica está en la esquina superior
izquierda, las X crecen a la derecha y las Y crecen hacia abajo.

Departamento de Sistemas y Computación Página 59


Como nos enfocaremos solo en figuras en dos dimensiones (figuras 2D), cada vértice
se representa por dos valores, el desplazamiento horizontal y vertical (X, Y) respecto
al origen.

Formaremos una matriz de orden 2xN, N es la cantidad de vértices, así cada columna
corresponde X y a Y respectivamente y cada renglón corresponde a un vértice, por lo
que tendremos tantos renglones como vértices.
Por ejemplo:
𝑥0 𝑦0
𝑥1 𝑦1
Matriz genérica para una 𝑥2 𝑦2
figura de 7 vértices 𝑥3 𝑦3
𝑥4 𝑦4
𝑥5 𝑦5
[𝑥6 𝑦6 ]

2 7
2 3
Matriz de la presente 8 3
figura de 7 vértices 8 1
12 5
8 9
[8 7]

10.4 Procedimiento (Descripción)


10.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

10.4.2 Material de Apoyo


 Compilador de c mingw.
 Entorno de desarrollo Code::Blocks.
 Librería de gráficos WinBGIm.
 Una hoja de cuadricula u hoja milimetrada

10.4.3 Desarrollo de la Práctica


Seleccione una imagen que puede definirse a partir de sus vértices y que la cantidad
de vértices sea entre 20 y 40.

Dibujamos la figura en la hoja y obtenemos las coordenadas de los vértices en base


al sistema de referencia mencionado al inicio, tomando como origen la esquina
superior izquierda de la hoja. Ejemplo de figuras:

Departamento de Sistemas y Computación Página 60


Iniciamos Codeblocks, y seguimos el menú FileNewProject, En el formulario
elije el icono con la leyenda Console application.

Selecciones el lenguaje C++, del título de proyecto como DibujarImagen2D, Elija


la carpeta donde almacenara el proyecto y de clic en el botón Next> luego en Finish.

Escribimos el siguiente código que incluye la función dibujar(), Dicha función debe
recibir la matriz con los vértices y el total de vértices.

En la función principal definimos la matriz e invocamos a la función dibuja(). En el


presente ejemplo, dibujaremos la figura de 7 vértices de la cual ya tenemos definidos
los vértices, pero para lograr una mejor visualización, cada coordenada se escalará en
un factor de 10.

A continuación, se muestra el código de ejemplo:

#include <iostream>
#include <graphics.h>

using namespace std;

void dibujar(int fig[][2], int totalVertices)


{
int i;

for(i=0; i<totalVertices-1; i++)


line(fig[i][0], fig[i][1], fig[i+1][0], fig[i+1][1]);

line(fig[0][0], fig[0][1], fig[i][0], fig[i][1]);

Departamento de Sistemas y Computación Página 61


}

int main()
{
int flecha[7][2]= {
{20, 70},
{20, 30},
{80, 30},
{80, 10},
{120, 50},
{80, 90},
{80, 70}
};

initwindow(140,100,"Práctica Dibujar Imagen 2D", 200, 50);


dibujar(flecha,7);

while( !kbhit() );
closegraph( );
return 0;
}

El resultado del programa anterior es la siguiente ventana:

Reto.
Modifique la función dibuja() para que pueda dibujar figuras con relleno (color
sólido). Así la función debe recibir un parámetro que indique si la figura lleva o no
relleno.

10.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
la figura en papel milimetrado con sus respectivos vértices, el código y las pantallas
del programa que implementó.

10.5 Resultados y Conclusiones


Se toma conciencia que se pueden representar cualquier figura especificando sus
vértices, incluso curvas, que tendrán mejor definición aumentando la cantidad de
vértices.

Departamento de Sistemas y Computación Página 62


Practica 11. Traslacion, escala,
rotacion y sesgado de una figura en
lenguaje c
11.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad II: Graficación
2D del subtema 2.1. Transformación bidimensional, del programa de estudios de la
materia de Graficación, desarrollando la competencia específica: “Desarrolla y
aplica modelos de graficación y transformación bidimensional para el
enriquecimiento visual de sus aplicaciones”.

Las operaciones que se aplican a descripciones geométricas de un objeto para cambiar


su posición, orientación o tamaño se llaman transformaciones geométricas.

Las funciones de transformaciones geométricas que se pueden encontrar en todos los


paquetes gráficos, son aquellas que se usan para la traslación, la rotación y el cambio
de escala. [3]

En la presente práctica aplicaremos los conceptos y operaciones matriciales para


implementar las trasformaciones geométricas.

11.2 Objetivo (Competencia)


Describir una figura a partir de sus vértices (entre 20 y 40 vértices) para luego escribir
un programa que, primero dibuje la figura original (en color blanco) y después
muestre la figura aplicándole cada una de las transformaciones, por ejemplo:
o Una traslación con un desplazamiento de 150 unidades en X y 100
unidades en Y (en color verde)
o Una rotación de 15° grados (en color amarillo).
o Una escala de 2 a 1 en X y en Y (en color azul).
o Un sesgado en el eje X (en color rojo).

11.3 Fundamento
En esta práctica trataremos con las transformaciones bidimensionales. A
continuación, mostramos el fundamento matemático de cada una de las
transformaciones básicas:

Traslaciones
Para trasladar una posición bidimensional, añadimos distancias de traslación 𝑡𝑥 y 𝑡𝑦
a las coordenadas originales (𝑥, 𝑦) para obtener la nueva posición de coordenadas
(𝑥′, 𝑦′) como se muestra a continuación:

Departamento de Sistemas y Computación Página 63


𝑥 ′ = 𝑥 + 𝑡𝑥 y 𝑦 ′ = 𝑦 + 𝑡𝑦

El par de distancia de traslación (𝑡𝑥 , 𝑡𝑦 ) se llama vector de traslación o vector de


cambio. La traslación es un tipo de transformación de sólido-rígido que mueve
objetos sin deformarlos.

Rotaciones
Para aplicar una transformación de rotación de un objeto mediante la especificación
de un eje de rotación y un ángulo de rotación. Todos los puntos del objeto son
entonces transformados a la nueva posición, mediante la rotación de puntos con el
ángulo especificado sobre el eje de rotación.

Usamos las ecuaciones de transformación para rotar la posición de un punto (𝑥, 𝑦)


aplicando un ángulo θ sobre el origen:

𝑥 ′ = 𝑥 cos 𝜃 − 𝑦 sin 𝜃 y 𝑦 ′ = 𝑥 sin 𝜃 + 𝑦 cos 𝜃

Al igual que con las traslaciones, las rotaciones son transformaciones de sólido-rígido
que mueven objetos sin deformarlos. Cada punto de un objeto se rota un mismo
ángulo.

Escala
Para alterar el tamaño de un objeto, aplicamos transformaciones de escala. Una simple
operación de cambio de escala bidimensional se lleva a cabo multiplicando las
posiciones de los objetos (𝑥, 𝑦) por los factores de escala 𝑠𝑥 y 𝑠𝑦 para producir las
coordenadas transformadas (𝑥′, 𝑦′):

𝑥 ′ = 𝑥 ∙ 𝑠𝑥 y 𝑦 ′ = 𝑦 ∙ 𝑠𝑦

El factor de escala 𝑠𝑥 cambia la escala de un objeto en la dirección x, mientras que 𝑠𝑦


hace el cambio de escala en la dirección y.

Cualquier valor positivo puede ser asignado a los valores de escala 𝑠𝑥 y 𝑠𝑦 . Valores
inferiores a 1 reducen el tamaño de los objetos; valores superiores a 1 producen
alargamientos. Especificando un valor de 1 tanto para 𝑠𝑥 como para 𝑠𝑦 se deja el
tamaño del objeto inalterado. Cuando a 𝑠𝑥 y 𝑠𝑦 se les asigna el mismo valor, se
produce un cambio de escala uniforme que mantiene las proporciones relativas del
objeto. Valores desiguales de 𝑠𝑥 y 𝑠𝑦 resultan en un cambio de escala diferente

Sesgado
Dos transformaciones comunes para producir una inclinación son aquellas que
desplazan los valores de las coordenadas x y las que desplazan los valores de y.

Departamento de Sistemas y Computación Página 64


Una inclinación en la dirección-x respecto al eje x se transforma la posición de
coordenadas como sigue:
𝑥 ′ = 𝑥 + 𝑠ℎ𝑥 ∙ 𝑦 y 𝑦′ = 𝑦

Una inclinación en la dirección-y respecto al eje y se transforma la posición de


coordenadas como sigue:
𝑥′ = 𝑥 y 𝑦 ′ = 𝑦 + 𝑠ℎ𝑦 ∙ 𝑥

11.4 Procedimiento (Descripción)


11.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

11.4.2 Material de Apoyo


 Compilador de c mingw.
 Entorno de desarrollo Code::Blocks.
 Librería de gráficos WinBGIm.
 Una hoja de cuadricula u hoja milimetrada

11.4.3 Desarrollo de la Práctica


Seleccione una imagen que puede definirse a partir de sus vértices y que la cantidad
de vértices sea entre 20 y 40.

Dibujamos la figura en la hoja y obtenemos las coordenadas de los vértices en base


al sistema de referencia mencionado al inicio, tomando como origen la esquina
superior izquierda de la hoja.

Iniciamos Codeblocks, y seguimos el menú FileNewProject, En el formulario


elije el icono con la leyenda Console application.

Selecciones el lenguaje C++, del título de proyecto como Transformaciones2D,


Elija la carpeta donde almacenara el proyecto y de clic en el botón Next> luego en
Finish.

Escribimos el siguiente código que incluye la funciones dibujar(), trasladar(),


rotar(), escala() y sesgarX() Dicha función debe recibir la matriz con los vértices y
el total de vértices.

En la función principal definimos la matriz e invocamos a las funciones dibujar(),


trasladar(), rotar(), escala() y sesgarX(). En el presente ejemplo, dibujaremos la
figura de 7 vértices de la cual ya tenemos definidos los vértices.

A continuación, se muestra el código de ejemplo:

#include <iostream>

Departamento de Sistemas y Computación Página 65


#include <graphics.h>
#include <math.h>

using namespace std;

void dibujar(int fig[][2], int totalVertices)


{
int i;

for(i=0; i<totalVertices-1; i++)


line(fig[i][0], fig[i][1], fig[i+1][0], fig[i+1][1]);

line(fig[0][0], fig[0][1], fig[i][0], fig[i][1]);


}

void trasladar(int fig[][2], int totalVertices, int tx, int ty)


{
int i;
int r[totalVertices][2];

for(i=0; i<totalVertices; i++)


{
r[i][0]=fig[i][0]+tx;
r[i][1]=fig[i][1]+ty;
}
setcolor(GREEN);
dibujar(r,totalVertices);
}

void rotar(int fig[][2], int totalVertices, float angulo)


{
int i;
int r[totalVertices][2];

//pasar el angulo a radianes


angulo= angulo*M_PI/180;
for(i=0; i<totalVertices; i++)
{
r[i][0]=fig[i][0]*cos(angulo)-fig[i][1]*sin(angulo);
r[i][1]=fig[i][0]*sin(angulo)+fig[i][1]*cos(angulo);
}
setcolor(YELLOW);
dibujar(r,totalVertices);
}

void escala(int fig[][2], int totalVertices, float sx, float sy)


{
int i;
int r[totalVertices][2];

for(i=0; i<totalVertices; i++)


{
r[i][0]=fig[i][0]*sx;
r[i][1]=fig[i][1]*sy;
}
setcolor(LIGHTBLUE);

Departamento de Sistemas y Computación Página 66


dibujar(r,totalVertices);
}

void sesgarX(int fig[][2], int totalVertices, float shx)


{
int i;
int r[totalVertices][2];

for(i=0; i<totalVertices; i++)


{
r[i][0]=fig[i][0]+fig[i][1]*shx;
r[i][1]=fig[i][1];
}
setcolor(LIGHTRED);
dibujar(r,totalVertices);
}

int main()
{
int flecha[7][2]=
{
{20, 70},
{20, 30},
{80, 30},
{80, 10},
{120, 50},
{80, 90},
{80, 70}
};

initwindow(230,150,"Práctica Dibujar Imagen 2D", 200, 50);


dibujar(flecha,7);

// trasladar(Objeto, totalVertices, tx, ty)


trasladar(flecha, 7, 100, 50);

// rotar(Objeto, totalVertices, angulo)


rotar(flecha,7, 15);

// escala(Objeto, totalVertices, sx, sy)


escala(flecha,7, 0.5, 0.5);

// sesgarX(Objeto, totalVertices, shx)


sesgarX(flecha, 7, 1.2);

while( !kbhit() );
closegraph( );
return 0;
}

El resultado del programa anterior es la siguiente ventana:

Departamento de Sistemas y Computación Página 67


Reto.
Modifique el programa para que pueda aplicar transformaciones sucesivas a la misma
figura usando las siguientes teclas:

 Traslación
o Tecla A. Mover hacia la izquierda
o Tecla S. Mover hacia la derecha
o Tecla Q. Mover hacia arriba
o Tecla Z. Mover hacia abajo
 Rotación
o Tecla W. Rotar en contra de las manecillas del reloj
o Tecla E. Rotar en dirección de las manecillas del reloj
 Escala
o Tecla J. Disminuir la escala en X
o Tecla K. Aumentar la escala en Y
o Tecla I. Aumentar la escala en Y
o Tecla M. Disminuir la escala en Y
 Sesgo en X
o Tecla X. Estirar hacia atrás
o Tecla C. Estirar hacia adelante

11.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
el código y las pantallas del programa que implementó.

11.5 Resultados y Conclusiones


Además de conectar las ecuaciones de transformaciones con su implementación, se
usará el teclado para interactuar con el programa y aplicar las transformaciones en
tiempo real.

Departamento de Sistemas y Computación Página 68


Practica 12. Trazado de una curva de
Bezier 2D en lenguaje c
12.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad II: Graficación
2D del subtema 2.3. Trazo de líneas curvas, del programa de estudios de la materia
de Graficación, desarrollando la competencia específica: “Desarrolla y aplica
modelos de graficación y transformación bidimensional para el enriquecimiento
visual de sus aplicaciones”.

En la graficación por computadora nos encontraremos frecuentemente con superficies


curvadas que no se pueden representar fácilmente con formas estándar.

Generalmente, esta clase de objetos se denominan objetos sin forma (blobby). Los
dibujantes recurrían a unas plantillas llamadas curvígrafos.

Pero el utilizarlos correctamente para obtener las curvas deseadas era más un arte que
una ciencia. Así el generar exactamente la misma curva resultaba muy complicado.

Este método de aproximación con spline fue desarrollado por El ingeniero francés
Pierre Bézier desarrolló un método de generación de curvas y superficies para su uso
en el diseño de las carrocerías de automóviles Renault.

El método consiste en el uso de un spline, que es una banda flexible que se utiliza
para producir una curva suave que pasa por unos puntos concretos. Se distribuyen
varios pesos pequeños a lo largo de la banda para mantenerla en su posición sobre la
mesa de dibujo mientras se traza la curva.

Departamento de Sistemas y Computación Página 69


La ventaja es que podemos describir matemáticamente tal curva con una función
creada por tramos de polinomios cúbicos, cuya primera y segunda derivadas son
continuas en las diferentes partes de la curva. En los gráficos por computadora, el
término curva con spline ahora se refiere a cualquier curva compuesta formada por
partes polinómicas que satisfacen condiciones de continuidad específicas en los
límites de las mismas.

Los splines de Bézier disponen de unas propiedades que los hacen especialmente
útiles y convenientes para el diseño de curvas y superficies. Además, son fáciles de
implementar. Por estas razones, los splines de Bézier están disponibles con mucha
frecuencia en diversos sistemas CAD, en paquetes para gráficos generales y en
paquetes heterogéneos de dibujo y pintura.

12.2 Objetivo (Competencia)


Desarrollar las ecuaciones para trazar una curva de Bezier con 4 puntos de control y
luego escribir un programa que las use para generar la curva. Debe dibujar también
los puntos de control, pero de un color diferente a la curva.

12.3 Fundamento
Hemos visto, que si un lugar geométrico tiene una representación analítica, la cual es
Una sola ecuación que contiene dos variables.

Departamento de Sistemas y Computación Página 70


Ahora veremos la representación analítica de una curva utilizando dos ecuaciones,
que se llaman ecuaciones paramétricas de la curva. Reciben este nombre aquellas
ecuaciones en que las variables x y y, cada una separadamente, están expresadas en
función de la misma tercera variable. Según esto, designando por la letra u la tercera
variable, comúnmente llamada variable paramétrica, estas ecuaciones se representan
en la siguiente forma general:
𝑥 = 𝐹(𝑢)
𝑦 = 𝐺(𝑢)

Es muy importante aclarar que cada dos ecuaciones paramétricas representan una sola
curva perfectamente referida a un sistema de ejes cartesianos. [12]

Ecuaciones de las curvas de Bézier


En primer lugar consideraremos el caso general con n+1 puntos de control, indicados
como 𝑝𝑘 = (𝑥𝑘 , 𝑦𝑘 ), donde k varía desde 0 a n. Estos puntos se combinan para
producir el siguiente vector de posición 𝑃(𝑢), que describe la trayectoria de una
función de aproximación polinómica de Bézier entre 𝑝0 y 𝑝𝑛 .
𝑛

𝑃(𝑢) = ∑ 𝑝𝑘 𝐵𝐸𝑍𝑘,𝑛 (𝑢), 0 ≤ 𝑢 ≤ 1


𝑘=0

La Ecuación vectorial representa un sistema de dos ecuaciones paramétricas en las


coordenadas individuales de la curva:
𝑛

𝑥(𝑢) = ∑ 𝑥𝑘 𝐵𝐸𝑍𝑘,𝑛 (𝑢)


𝑘=0

𝑦(𝑢) = ∑ 𝑦𝑘 𝐵𝐸𝑍𝑘,𝑛 (𝑢)


𝑘=0

Por lo general, una parte de una curva de Bézier se puede ajustar a cualquier número
de puntos de control, aunque algunos paquetes gráficos limitan el número de puntos
de control a cuatro. Las curvas de Bézier cúbicas se generan con cuatro puntos de
control. Las cuatro funciones de combinación para curvas de Bézier cúbicas,
obtenidas sustituyendo n=3 son:

𝐵𝐸𝑍𝑜,3 = (1 − 𝑢)3
𝐵𝐸𝑍1,3 = 3𝑢(1 − 𝑢)2
𝐵𝐸𝑍2,3 = 3𝑢2 (1 − 𝑢)
𝐵𝐸𝑍3,3 = 𝑢3

Sustituyendo, obtenemos:

Departamento de Sistemas y Computación Página 71


𝑋(𝑢) = 𝑥0 (1 − 𝑢)3 + 𝑥1 3𝑢(1 − 𝑢)2 + 𝑥2 3𝑢2 (1 − 𝑢) + 𝑥3 𝑢3
𝑌(𝑢) = 𝑦0 (1 − 𝑢)3 + 𝑦1 3𝑢(1 − 𝑢)2 + 𝑦2 3𝑢2 (1 − 𝑢) + 𝑦3 𝑢3

12.4 Procedimiento (Descripción)


12.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

12.4.2 Material de Apoyo


 Compilador de c mingw.
 Entorno de desarrollo Code::Blocks.
 Librería de gráficos WinBGIm.

12.4.3 Desarrollo de la Práctica


Iniciamos Codeblocks, y seguimos el menú FileNewProject, En el formulario
elije el icono con la leyenda Console application.

Selecciones el lenguaje C++, del título de proyecto como CurvaBezier2D, Elija la


carpeta donde almacenara el proyecto y de clic en el botón Next> luego en Finish.

Escribimos el siguiente código que incluye la función bezier2D(), Dicha función debe
recibir la matriz con los puntos de control y el total de punto de control.

En la función principal definimos la matriz con los puntos de control e invocamos a


la función bezier2D(). En el presente ejemplo, dibujaremos una curva definida por 4
puntos de control.

A continuación, se muestra el código de ejemplo:

#include <iostream>
#include <graphics.h>

using namespace std;

void bezier2D(int pc[][2], int n)


{ float x,y,u;
setcolor(YELLOW);

// Puntos de control
for(int i=0; i<n; i++)
circle(pc[i][0], pc[i][1],2);

// Curva
for(u=0; u<1; u+=0.005)
{
x= pc[0][0]*(1-u)*(1-u)*(1-u) +
pc[1][0]*3*u*(1-u)*(1-u) +

Departamento de Sistemas y Computación Página 72


pc[2][0]*3*u*u*(1-u) +
pc[3][0]*u*u*u;

y= pc[0][1]*(1-u)*(1-u)*(1-u) +
pc[1][1]*3*u*(1-u)*(1-u) +
pc[2][1]*3*u*u*(1-u) +
pc[3][1]*u*u*u;

putpixel(x, y, WHITE);
}

int main()
{
int curva[4][2]=
{
{10, 180},
{40, 40},
{160, 160},
{180, 20}
};

initwindow(200,200,"Práctica Curva de Bezier 2D", 200, 50);


bezier2D(curva,4);

while( !kbhit() );
closegraph( );
return 0;
}

El resultado del programa anterior es la siguiente ventana:

Reto.
Desarrolle el modelo matemático para trazar una curva de Bezier con 6 puntos de
control y después implemente el programa que lo dibuje.

Departamento de Sistemas y Computación Página 73


12.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
las deducciones matemáticas, el código y las pantallas del programa que implementó.

12.5 Resultados y Conclusiones


El alumno comprenderá que, si necesita una curva más compleja o con mayor
definición, necesitará más puntos de control. Además, debe percibir que puede usar
casi el mismo programa para diferentes cantidades de puntos de control.

Departamento de Sistemas y Computación Página 74


Practica 13. Trazado de una curva de
Spline 2D en lenguaje c
13.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad II: Graficación
2D del subtema 2.3. Trazo de líneas curvas, del programa de estudios de la materia
de Graficación, desarrollando la competencia específica: “Desarrolla y aplica
modelos de graficación y transformación bidimensional para el enriquecimiento
visual de sus aplicaciones”.

Aunque las curvas de Bezier son muy simples de implementar, tienen dos desventajas
importantes:
 Al mover un punto de control se tiene que recalcular toda la curva,
 El tiempo computacional necesario afecta negativamente el tiempo para
dibujar la curva interactivamente.

Las curvas B-Splines eliminan las desventajas anteriores. La principal estrategia es


dividir una curva en varios segmentos de curva y la manera de unir dichos segmentos.

En la presente práctica implementaremos los B-Splines Uniformes No Racionales.


Esta clase de splines es la más profusamente utilizada y las funciones de splines B
están disponibles habitualmente en los sistemas CAD y en muchos paquetes de
programación de gráficos.

Al igual que los splines de Bézier, los splines B se generan aproximando un conjunto
de puntos de control. Pero los splines B presentan dos ventajas frente a los splines de
Bézier: (1) el grado de un polinomio de un spline B se puede establecer de forma
independiente al número de puntos de control (con ciertas limitaciones), y (2) los
splines B permiten control local sobre la forma de un spline. La desventaja es que los
splines B son más complejos que los splines de Bézier. [12]

13.2 Objetivo (Competencia)


En la presente práctica queremos trazar una curva spline donde cada segmento de
curva tenga distinto color.

13.3 Fundamento
El termino spline se usa para nombrar a las largas tiras flexibles de metal usada por
los dibujantes en el diseño de superficies de aeroplanos, carros y naves. A lo largo del
spline, se ligan pesos para jalar el spline en varias direcciones.

Departamento de Sistemas y Computación Página 75


Los splines de metal tiene una continuidad de segundo orden (o menos que se doblen
severamente). Los B-splines están formados por segmentos de curvas. Los
coeficientes de los polinomios de tales curvas dependen solo de unos cuantos puntos
de control, por lo cual se logra un "control local". Así, al mover un punto de control,
solo se afecta una pequeña parte de la curva.

Los B-Splines tienen la misma continuidad que los splines naturales, pero no
interpolan sus puntos de control.

Un segmento de curva no necesita pasar por sus puntos de control. Al compartir los
puntos de control entre segmentos, se logran las condiciones de continuidad.

Para trazar un solo segmento de curva Q, se requieren de 4 puntos de control


𝑃0 , 𝑃1 , 𝑃2 y 𝑃3 . Tal curva está definida sobre el dominio 0 ≤ 𝑡 < 1 . La ecuación que
define la curva es la siguiente:

(1 − 𝑡)3 3𝑡 3 − 6𝑡 2 + 4 −3𝑡 3 + 3𝑡 2 + 3𝑡 + 1 𝑡3
𝑄(𝑡) = ∙ 𝑃0 + ∙ 𝑃1 + ∙ 𝑃2 + ∙ 𝑃3
6 6 6 6

donde: 0 ≤ 𝑡 < 1

Departamento de Sistemas y Computación Página 76


Al punto en el cual termina un segmento y comienza otro segmento se le llama punto
de ruptura ó knot (también se consideran knots el principio y el final del B-spline).

El término uniforme significa que los knots están uniformemente distribuidos. El


termino No - racional se utiliza para diferenciar estos splines de las curvas
polinomiales cubicas racionales, donde x(t), y(t) y z(t) están definidos como el radio
de dos polinomios cúbicos. La B se refiere a básico, porque los splines pueden
representarse como sumas pesadas de funciones polinomiales básicas (esto no se
cumple con los splines naturales).

Una curva B-spline con N knots tendrá:

𝑁 − 1 Segmentos de curva 𝑄𝑖 donde 𝑖 = 0 … 𝑁 − 2


𝑁 + 2 Puntos de control 𝑃𝑖 donde 𝑖 = 0 … 𝑁 + 1
𝑁 knots donde 𝐾𝑖 donde 𝑖 = 0 … 𝑁 − 1
El segmento de curva 𝑄𝑖 (𝑡) esta definida por cuatro puntos de control
𝑃𝑖 , 𝑃𝑖+1 , 𝑃𝑖+2 y 𝑃𝑖+3 . Y el siguiente segmento de curva 𝑄𝑖+1 (𝑡)esta definida por cuatro
puntos de control 𝑃𝑖+1 , 𝑃𝑖+2 , 𝑃𝑖+3 y 𝑃𝑖+4 . Como puede verse, los segmentos de curva
cercanos comparten algunos puntos de control.

La ecuación general de un B-spline es:

(1 − 𝑡)3 3𝑡 3 − 6𝑡 2 + 4 −3𝑡 3 + 3𝑡 2 + 3𝑡 + 1 𝑡3
𝑄𝑖 (𝑡) = ∙ 𝑃𝑖 + ∙ 𝑃𝑖+1 + ∙ 𝑃𝑖+2 + ∙ 𝑃𝑖+3
6 6 6 6

dónde: 0 ≤ 𝑡 < 1 en cada segmento 𝑄𝑖 con 𝑖 = 0 … 𝑁 − 2, si hay N knots.

Departamento de Sistemas y Computación Página 77


Así, para graficar una curva B-spline en 2D usaremos las siguientes ecuaciones para
obtener cada pixel de la curva:

(1 − 𝑡)3 3𝑡 3 − 6𝑡 2 + 4 −3𝑡 3 + 3𝑡 2 + 3𝑡 + 1 𝑡3
𝑋𝑖 (𝑡) = ∙ 𝑥𝑖 + ∙ 𝑥𝑖+1 + ∙ 𝑥𝑖+2 + ∙ 𝑥𝑖+3
6 6 6 6

(1 − 𝑡)3 3𝑡 3 − 6𝑡 2 + 4 −3𝑡 3 + 3𝑡 2 + 3𝑡 + 1 𝑡3
𝑌𝑖 (𝑡) = ∙ 𝑦𝑖 + ∙ 𝑦𝑖+1 + ∙ 𝑦𝑖+2 + ∙ 𝑦𝑖+3
6 6 6 6

Se puede crear una curva B-spline cerrada fácilmente al agregar los tres primeros
puntos de control al final de la secuencia.

13.4 Procedimiento (Descripción)


13.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

13.4.2 Material de Apoyo


 Compilador de c mingw.
 Entorno de desarrollo Code::Blocks.
 Librería de gráficos WinBGIm.

13.4.3 Desarrollo de la Práctica


Iniciamos Codeblocks, y seguimos el menú FileNewProject, En el formulario
elije el icono con la leyenda Console application.

Selecciones el lenguaje C++, del título de proyecto como CurvaSpline2D, Elija la


carpeta donde almacenara el proyecto y de clic en el botón Next> luego en Finish.

Escribimos el siguiente código que incluye la función spline2D(), Dicha función debe
recibir la matriz con los puntos de control y el total de punto de control.

En la función principal definimos la matriz con los puntos de control e invocamos a


la función spline2D(). En el presente ejemplo, dibujaremos una curva definida por 8
puntos de control. Y para una mejor comprensión dibujaremos cada segmento de
curva de un color diferente.

A continuación, se muestra el código de ejemplo:

#include <iostream>
#include <graphics.h>

using namespace std;

Departamento de Sistemas y Computación Página 78


void spline2D(int pc[][2], int n)
{
float x,y,u;

// Puntos de control
setcolor(YELLOW);
for(int i=0; i<n; i++)
circle(pc[i][0], pc[i][1],2);

// Curva
for(n=3; n<8; n++)
{
for(u=0; u<1; u+=0.005)
{
x= (1-u)*(1-u)*(1-u)*pc[n-3][0]/6 +
(3*u*u*u-6*u*u+4)*pc[n-2][0]/6 +
(-3*u*u*u+3*u*u+3*u+1)*pc[n-1][0]/6 +
u*u*u*pc[n][0]/6;

y= (1-u)*(1-u)*(1-u)*pc[n-3][1]/6 +
(3*u*u*u-6*u*u+4)*pc[n-2][1]/6 +
(-3*u*u*u+3*u*u+3*u+1)*pc[n-1][1]/6 +
u*u*u*pc[n][1]/6;
//n%15+1 Asegura un id de color entre 1 y 15
putpixel(x, y, n%15+1);
}
}

int main()
{
int curva[8][2]=
{
{20, 20},
{120, 80},
{160, 140},
{140, 180},
{100, 190},
{80, 140},
{60, 120},
{40, 60}
};

initwindow(200,200,"Práctica Dibujar Curva Spline 2D", 200,


50);
spline2D(curva,8);

while( !kbhit() );
closegraph( );
return 0;
}

El resultado del programa anterior es la siguiente ventana:

Departamento de Sistemas y Computación Página 79


Reto.
Desarrolle el modelo matemático para trazar una curva de BSpline con 10 puntos de
control y después implemente el programa que lo dibuje.

13.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
las deducciones matemáticas, el código y las pantallas del programa que implementó.

Además, deberá entregar una investigación con los distintos tipos de splines que hay.

13.5 Resultados y Conclusiones


El alumno comprenderá que, si necesita una curva más compleja o con mayor
definición, necesitará más puntos de control. Además, que puede usar la misma
función para diferentes cantidades de puntos de control.

Departamento de Sistemas y Computación Página 80


Practica 14. Representacion de una
figura con coordenadas homogeneas a
partir de sus vertices en el lenguaje
Processing
14.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad II: Graficación
2D del subtema 2.3. Trazo de líneas curvas, del programa de estudios de la materia
de Graficación, desarrollando la competencia específica: “Desarrolla y aplica
modelos de graficación y transformación bidimensional para el enriquecimiento
visual de sus aplicaciones”.

Para implementar los conceptos básicos de graficación se han utilizados lenguajes de


propósito general potenciados con librerías gráficas, pero conforme se adentra uno a
cuestiones más complejas como lo pueden ser la animación, iluminación y
sombreado, etc. Se necesitan de otras herramientas que nos ayuden a hacer la
programación más sencilla. Una de estas herramientas es Processing.

Processing es un lenguaje de programación y entorno de desarrollo integrado de


código abierto basado en Java, de fácil utilización, y que sirve como medio para la
enseñanza y producción de proyectos multimedia e interactivos de diseño digital [13].

Departamento de Sistemas y Computación Página 81


Uno de los objetivos declarados de Processing es el de actuar como herramienta para
que artistas, diseñadores visuales y miembros de otras comunidades ajenos al lenguaje
de la programación, aprendieran las bases de la misma a través de una muestra gráfica
instantánea y visual de la información. El lenguaje de Processing se basa en Java,
aunque hace uso de una sintaxis simplificada y de un modelo de programación de
gráficos.

14.2 Objetivo (Competencia)


Usar las librerías de Processing para dibujar una figura con coordenadas homogéneas
a partir de sus vértices.

14.3 Fundamento
Los términos multiplicativos y traslacionales para una transformación geométrica
bidimensional pueden ser combinados dentro de una matriz sencilla, si expandimos
la representación a matrices de 3 por 3. Una técnica estándar para lograr esto consiste
en expandir cada representación de posición-coordenada bidimensional (𝑥, 𝑦) en
representaciones de 3 elementos (𝑥ℎ , 𝑦ℎ , ℎ) llamadas coordenadas homogéneas,
donde el parámetro homogéneo h. Para transformaciones geométricas, podemos
elegir el parámetro homogéneo h para que sea cualquier valor distinto de cero. Así,
hay un número infinito de representaciones homogéneas equivalentes para cada punto
de coordenadas (𝑥, 𝑦). Una elección acertada es fijar h=1. Cada posición
bidimensional se representa con coordenadas homogéneas (𝑥, 𝑦, 1) [3].

Expresar posiciones en coordenadas homogéneas nos permite representar todas las


ecuaciones de transformaciones geométricas como multiplicación de matrices, que es
el método estándar usado en los sistemas gráficos. Las posiciones de coordenadas
bidimensionales se representan con vectores columna de tres elementos, y las
operaciones de transformación bidimensionales se representan como matrices de 3
por 3.

Departamento de Sistemas y Computación Página 82


Matriz de traslación bidimensional
Usando la aproximación de coordenadas homogéneas, podemos representar las
ecuaciones para una traslación bidimensional de una posición de coordenadas usando
la siguiente matriz de multiplicación.

𝑥′ 1 0 𝑡𝑥 𝑥
[𝑦′] = [0 𝑦
1 𝑡𝑦 ] ∙ [ ]
1 0 0 1 1

Matriz de rotación bidimensional


De manera similar, las ecuaciones de transformación de rotación bidimensional sobre
el origen de coordenadas pueden expresarse en forma de matriz,

𝑥′ cos 𝜃 − sen 𝜃 0 𝑥
[𝑦′] = [sen 𝜃 cos 𝜃 0] ∙ [𝑦]
1 0 0 1 1

Matriz de cambio de escala bidimensional


Finalmente, una transformación de cambio de escala relativa al origen de coordenadas
puede ahora expresarse como la matriz de multiplicación:

𝑥′ 𝑠𝑥 0 0 𝑥
[𝑦′] = [ 0 𝑠𝑦 0] ∙ [𝑦]
1 0 0 1 1

14.4 Procedimiento (Descripción)


14.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

14.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo Processing (IDE).

14.4.3 Desarrollo de la Práctica


Primero instalamos Processing, que se puede descargar de:

https://processing.org/download/

En esta página elige el archivo adecuado para su equipo (Windows, Mac o Linux).
Una vez descargado, por ejemplo, la versión para windows 10 de 64 bits tendremos
el archivo processing-3.4-windows64.zip. Solo descomprima el archivo en una
carpeta, por ejemplo, en la de Documentos, quedándonos:

Departamento de Sistemas y Computación Página 83


Abrimos la carpeta y ejecutamos el archivo processing.exe. Debemos obtener la
siguiente interfaz:

Departamento de Sistemas y Computación Página 84


Escribimos el siguiente código y los guardamos como tHomogeneas2D, Processing
creara una carpeta para guardarlo como proyecto y dentro de la carpeta guardara el
código fuente. Quedando almacenado en la ruta:

..\Processing\ tHomogeneas2D\ tHomogeneas2D.pde

Código:
float[][] flecha=
{
{20, 70, 1},
{20, 30, 1},
{80, 30, 1},
{80, 10, 1},
{120, 50, 1},
{80, 90, 1},
{80, 70, 1} };

float[][] Escala={
{0.5, 0, 0},
{0, 0.5, 0},
{0, 0, 1} };

float[][] Traslacion={
{1, 0, 0},
{0, 1, 0},
{100, 50, 1} };

float[][] Rotacion={
{ 0.966, 0.259, 0},
{-0.259, 0.966, 0},
{ 0, 0, 1} };

float[][] R={
{0, 0, 0},
{0, 0, 0},
{0, 0, 0},
{0, 0, 0},
{0, 0, 0},
{0, 0, 0},
{0, 0, 0}};

void setup() {
size(230, 160); //Tamaño de la ventana
}

void draw() {
background(0); //Color de fondo
stroke(255); //Color del lápiz

dibuja(flecha, 7);

mult(flecha, Traslacion, 7);


dibuja(R, 7);
inicializa(7);

Departamento de Sistemas y Computación Página 85


mult(flecha, Rotacion, 7);
dibuja(R, 7);
inicializa(7);

mult(flecha, Escala, 7);


dibuja(R, 7);
inicializa(7);
}

void mult(float[][] A, float[][] B, int n)


{
int i, j, k;

for (i=0; i<n; i++)


for (j=0; j<3; j++)
for (k=0; k<3; k++)
R[i][k]+=A[i][j]*B[j][k];
}

void inicializa(int n)
{
int i, j;
for (i=0; i<n; i++)
for (j=0; j<3; j++)
R[i][j]=0;
}

void dibuja(float[][] X, int n)


{
int i, j;

for (i=0; i<n-1; i++)


line(X[i][0], X[i][1], X[i+1][0], X[i+1][1]);

line(X[0][0], X[0][1], X[i][0], X[i][1]);


}

El resultado del programa anterior es la siguiente ventana:

Departamento de Sistemas y Computación Página 86


Reto.
Modifique el programa para que pueda aplicar transformaciones sucesivas a la misma
figura usando las siguientes teclas:

 Traslación
o Tecla A. Mover hacia la izquierda
o Tecla S. Mover hacia la derecha
o Tecla Q. Mover hacia arriba
o Tecla Z. Mover hacia abajo
 Rotación
o Tecla W. Rotar en contra de las manecillas del reloj
o Tecla E. Rotar en dirección de las manecillas del reloj
 Escala
o Tecla J. Disminuir la escala en X
o Tecla K. Aumentar la escala en Y
o Tecla I. Aumentar la escala en Y
o Tecla M. Disminuir la escala en Y
 Sesgo en X
o Tecla X. Estirar hacia atrás
o Tecla C. Estirar hacia adelante

14.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
el código y las pantallas del programa que implementó.

14.5 Resultados y Conclusiones


El alumno se dará cuenta que, aunque Processing promete ser una herramienta
avanzada para el manejo de gráficos, el esfuerzo es casi el mismo que el hacerlo con
C++ y WinBGIm. Esto es porque no estamos usando las ventajas del lenguaje. Tales
ventajas se apreciarán en la siguiente práctica.

Departamento de Sistemas y Computación Página 87


Practica 15. Traslacion, escala,
rotacion de una figura en el lenguaje
Processing
15.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad II: Graficación
2D del subtema 2.3. Trazo de líneas curvas, del programa de estudios de la materia
de Graficación, desarrollando la competencia específica: “Desarrolla y aplica
modelos de graficación y transformación bidimensional para el enriquecimiento
visual de sus aplicaciones”.

En esta práctica se quiere tomar ventaja de las funciones que ofrece Processing para
el manejo de transformaciones en 2D.

15.2 Objetivo (Competencia)


Dibujar una figura y sus respectivas transformaciones básicas usando las funciones
que incluye el Processing.

15.3 Fundamento
Processing tiene funciones integradas que le facilitan tener objetos en un boceto:
mueva, gire y aumente o aumente su tamaño. A le presentará las funciones de
traslación, rotación, escala y otras para que pueda usarlas en sus bocetos.
 translate()
 rotate()
 rotateX()
 rotateY()
 rotateZ()
 scale()
 popMatrix()
 pushMatrix()

15.4 Procedimiento (Descripción)


15.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

15.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo Processing (IDE).

Departamento de Sistemas y Computación Página 88


15.4.3 Desarrollo de la Práctica
Ejecutamos processing.exe y en la interfaz seleccionamos Archivo->Nuevo y en la
nueva ventana escribimos el siguiente código y los guardamos como
transformaciones2D, Processing creara una carpeta para guardarlo como proyecto y
dentro de la carpeta guardara el código fuente. Quedando almacenado en la ruta:

..\Processing\transformciones2D\transformciones2D.pde

Código:
PShape flecha;

void setup() {
size(230, 160); //Tamaño de la ventana
flecha=createShape();

//Se definen los vertices de la figura


flecha.beginShape();
flecha.vertex(20, 70);
flecha.vertex(20, 30);
flecha.vertex(80, 30);
flecha.vertex(80, 10);
flecha.vertex(120, 50);
flecha.vertex(80, 90);
flecha.vertex(80, 70);
flecha.endShape();
}

void draw() {
background(20); //Color de fondo

stroke(255); //Color del lápiz


shape(flecha); //Dibuja la figura

//Se aplican las trnaformaciones. Son sucesivas


translate(100,50);
shape(flecha);

rotate(radians(15));
shape(flecha);

scale(0.5,0.5);
shape(flecha);
}

El resultado del programa anterior es la siguiente ventana:

Departamento de Sistemas y Computación Página 89


Reto.
Modifique el programa para que cada flecha sea de un color diferente y además, que
las transformaciones no sean sucesivas.

15.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
el código y las pantallas del programa que implementó.

Además, documente las funciones integradas que se mencionan en el punto 15.3

15.5 Resultados y Conclusiones


El alumno apreciará las ventajas de una herramienta de programación más avanzada,
viendo que puede implementar escenas mucho más complejas con menos esfuerzo.

Departamento de Sistemas y Computación Página 90


Practica 16. Formas geometricas 3D en
el lenguaje Processing
16.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad III: Graficación
3D del subtema 3.2. Formas geométricas tridimensionales (superficies planas y
curvas), del programa de estudios de la materia de Graficación, desarrollando la
competencia específica: “Desarrolla y aplica modelos de graficación y
transformación tridimensional sobre entidades geométricas en 3D para generar
proyecciones visuales en 2D”.

En esta práctica se quiere tomar ventaja de las funciones que ofrece Processing para
definir una superficie.

16.2 Objetivo (Competencia)


Definir las coordenadas de una superficie y dibujarla, usando una proyección
ortogonal. También debe dibujar los ejes de coordenadas para que sirvan de
referencia. Use las funciones que incluye el Processing.

16.3 Fundamento
Vistas o Proyecciones
Existen dos métodos básicos para proyectar objetos tridimensionales sobre una
superficie de visión bidimensional. Estas dos maneras, dependen de si todos los
puntos del objeto pueden proyectarse sobre la superficie a lo largo de líneas paralelas
o bien los puntos pueden proyectarse a lo largo de líneas que convergen a una posición
denominada centro de proyección. [4]

Una proyección isométrica es un método de representación gráfica de un objeto


tridimensional que se reduce en dos dimensiones, en la que los tres ejes ortogonales
principales, al proyectarse, forman ángulos de 120º, y las dimensiones paralelas a
dichos ejes se miden en una misma escala.

El término isométrico proviene del idioma griego: "igual al tiempo", y al castellano


"igual medida" ya que la escala de medición es la misma en los tres ejes principales
(x, y, z).

Las funciones integradas que usaremos en esta ocasión son:


 ortho()
 camera()
 beguinShape()
 endShape()
 vertex()

Departamento de Sistemas y Computación Página 91


 stroke()
 noStroke()
 color()

16.4 Procedimiento (Descripción)


16.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

16.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo Processing (IDE).

16.4.3 Desarrollo de la Práctica


Ejecutamos processing.exe y en la interfaz seleccionamos Archivo->Nuevo y en la
nueva ventana escribimos el siguiente código y los guardamos como superficie3D,
Processing creara una carpeta para guardarlo como proyecto y dentro de la carpeta
guardara el código fuente. Quedando almacenado en la ruta:

..\Processing\ superficie3D\superficie3D.pde

superficie3D.pde
PShape flecha;

void setup() {
size(400, 400, P3D);
noFill();
}

void draw() {
background(200);
noStroke();
ortho(-200, 200, 200, -200, -200, 200);
camera(50, 50, 50, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
ejes();
figura();
}

void figura() {
beginShape();
fill(255, 0, 0); //Esquina Roja
vertex( 20, 50, 0);
vertex( 20, 60, -30);
vertex( 20, 40, -60);
fill(0, 255, 0); //Esquina Verde
vertex( 20, 50, -90);
vertex( 50, 60, -90);
vertex( 80, 40, -90);
fill(0, 0, 255); //Esquina Azul
vertex( 110, 50, -90);

Departamento de Sistemas y Computación Página 92


vertex( 110, 60, -60);
vertex(110, 40, -30);
fill(255, 255, 0); //Esquina Amarilla
vertex( 110, 50, 0);
vertex( 80, 60, 0);
vertex( 50, 40, 0);
endShape(CLOSE);
}

void ejes() {
beginShape(LINES);
stroke(color(255, 0, 0)); // X's
vertex(-200, 0, 0);
vertex( 200, 0, 0);
stroke(color(0, 255, 0)); // Y´s
vertex(0, -200, 0);
vertex(0, 200, 0);
stroke(color(0, 0, 255)); // Y´s
vertex(0, 0, -200); // Z´s
vertex(0, 0, 200);
endShape();
}

El resultado del programa anterior es la siguiente ventana:

Departamento de Sistemas y Computación Página 93


Reto.
Cree un programa que dibuje una superficie de al menos 20 vértices.

16.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
el código y las pantallas del programa que implementó.

Además, documente las funciones integradas que se mencionan en el punto 16.3

16.5 Resultados y Conclusiones


El alumno apreciará las ventajas de una herramienta de programación más avanzada,
viendo que puede implementar escenas mucho más complejas con menos esfuerzo.

Departamento de Sistemas y Computación Página 94


Practica 17. Íluminacion y mapeo de
texturas en el lenguaje Processing
17.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad IV: Relleno,
iluminación y sombreado, del subtema 4.1. Relleno de polígonos y 4.2. Modelos
básicos de iluminación, del programa de estudios de la materia de Graficación,
desarrollando la competencia específica: “Aplica técnicas y herramientas de
iluminación y sombreado para obtener un enriquecimiento visual en
aplicaciones generales”.

En esta práctica se quiere tomar ventaja de las funciones que ofrece Processing para
iluminar una escena y mapear una textura en una superficie.

17.2 Objetivo (Competencia)


Dibujar una esfera en 3d, usando una imagen como textura. Además, definir una
fuente de luz que se mueva siguiendo al apuntador del ratón.

De esta manera se apreciará como varia el tono de la superficie conforme movamos


la fuente de luz. Use las funciones que incluye el Processing.

17.3 Fundamento
Relleno
Un polígono es una región del espacio delimitada por un conjunto de líneas (aristas)
y cuyo interior puede estar rellenado por un color o patrón dado.

El algoritmo de relleno en programas de dibujo, creado por S. Fazzini, requiere tres


parámetros: un nodo inicial, un color para sustituir, y otro de relleno. El algoritmo
rastrea todos los nodos que sean del color seleccionado, y a la vez contiguos entre sí
y con el inicial, y los sustituye por el color de relleno. [4]

Texturas
La textura es la apariencia externa y superficial de la estructura de los materiales,
objetos y cosas que nos rodean. Cuando miramos el mundo natural o el artificial,
podemos descubrir diversas texturas, como por ejemplo en la corteza de los árboles,
las piedras, las paredes, los edificios, etc., y en nosotros mismos descubrimos textura
cuando nos palpamos la piel, el pelo, nuestras ropas y zapatos.

La textura puede ser óptica o visual, cuando las diferencias en la superficie sólo
pueden ser captadas por el ojo, pero no responden al tacto. Asimismo, la textura puede
ser táctil cuando se presentan diferencias que responden, a la vez, al tacto y a la vista.

Departamento de Sistemas y Computación Página 95


El mapeado de texturas establece cómo se sitúa la textura sobre el objeto al momento
de proyectarse. Algunas texturas son tridimensionales y por lo general no necesitan
un mapeado detallado ya que no se verán exactamente deformaciones o imperfectos.
[4]

Iluminación y sombreado
Pueden obtenerse imágenes realistas de una escena generando proyecciones en
perspectiva de los objetos y aplicando efectos de iluminación naturales a las
superficies visibles. Se utiliza un modelo de iluminación, también denominado
modelo de sombreado, para calcular el color de cada posición iluminada en la
superficie de un objeto. Un método de representación superficial utiliza los cálculos
de color del modelo de iluminación para determinar los colores de los píxeles para
todas las posiciones proyectadas de una escena.

El modelo de iluminación puede aplicarse a cada posición de proyección, o bien


puede llevarse a cabo la representación de la superficie interpolando los colores de
las superficies a partir de un pequeño conjunto de cálculos relativos al modelo de
iluminación.

Entre otras cosas, el fotorrealismo en los gráficos por computadora requiere dos
elementos: representaciones precisas de las propiedades de las superficies y una
buena descripción física de los efectos de iluminación en la escena. Estos efectos de
iluminación de las superficies incluyen la reflexión de la luz, la transparencia, las
texturas de las superficies y las sombras.

En general, el modelado de los efectos de iluminación que podemos observar sobre


un objeto es un proceso muy complejo, en el que intervienen principios tanto de la
física como de la psicología. [4]

Las clases y funciones integradas que usaremos en esta ocasión son:


 PImage
 PShape
 sphereDetail()
 loadImage()
 createShape()
 directionalLight()
 spotLight()
 shape()

17.4 Procedimiento (Descripción)


17.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

Departamento de Sistemas y Computación Página 96


17.4.2 Material de Apoyo
 SDK de java.
 Entorno de desarrollo Processing (IDE).

17.4.3 Desarrollo de la Práctica


Ejecutamos processing.exe y en la interfaz seleccionamos Archivo->Nuevo y en la
nueva ventana escribimos el siguiente código y los guardamos como
iluminacionMapeo, Processing creara una carpeta para guardarlo como proyecto y
dentro de la carpeta guardara el código fuente. Quedando almacenado en la ruta:

..\Processing\iluminacionMapeo\iluminacionMapeo.pde

Código:
PImage logo;
PShape esfera;

void setup() {
size(500, 500, P3D);
noStroke();
sphereDetail(100);
logo = loadImage("ladrillo.jpg");
esfera = createShape(SPHERE, 150);
esfera.setTexture(logo);
}

void draw() {
background(color(30, 100, 180));

// Light the bottom of the sphere


directionalLight(80, 120, 140, 0, 0, -1);

// Hace que el punto de luz siga al puntero del ratón


spotLight(102, 153, 204, mouseX, mouseY, 600, 0, 0, -1, PI/2,
600);

translate(250, 250, 0);


shape(esfera);
}

El resultado del programa anterior es la siguiente ventana:

Departamento de Sistemas y Computación Página 97


Reto.
Cree un programa que mapee una superficie de pasto y además defina tres fuentes de
luz de color distinto que se distribuyan sobre la esfera.

17.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
el código y las pantallas del programa que implementó.

Además, documente las funciones integradas que se mencionan en el punto 17.3

17.5 Resultados y Conclusiones


El alumno apreciará las ventajas de una herramienta de programación más avanzada,
viendo que puede implementar escenas mucho más complejas con menos esfuerzo.

Departamento de Sistemas y Computación Página 98


Practica 18. Animacion simple en el
lenguaje Processing
18.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad V: Introducción
a la animación por computadora. del subtema 5.4. Animación 2D o 3D controlada
por el usuario, del programa de estudios de la materia de Graficación, desarrollando
la competencia específica: “Conoce el uso de técnicas de animación en 2D y 3D en
los contextos de animación gráfica y realidad virtual considerando los aspectos
matemáticos básicos y las técnicas de programación”.

18.2 Objetivo (Competencia)


En esta práctica aplicaremos transformaciones sucesivas para crear la ilusión de
animación al programa realizado en la práctica 17. Use las funciones que incluye el
Processing.

18.3 Fundamento
Animación
El término animación por computadora se refiere a cualquier secuencia temporal
donde se aprecien cambios visuales en una imagen. Además de cambiar las posiciones
de los objetos mediante traslaciones o rotaciones, una animación generada por
computadora puede mostrar variaciones temporales que afecten al tamaño de los
objetos, a su color, a su transparencia o a las texturas superficiales.

También podemos generar animaciones por computadora variando parámetros de la


cámara, como la posición, la orientación o la distancia focal. Y las variaciones en los
efectos de iluminación u otros parámetros y procedimientos asociados con la
iluminación y la representación de escenas pueden usarse también para producir
animaciones por computadora. [4]

Las funciones integradas que usaremos en esta ocasión son:


 ortho()
 camera()
 beguinShape()
 endShape()
 vertex()
 stroke()
 noStroke()
 color()

Departamento de Sistemas y Computación Página 99


18.4 Procedimiento (Descripción)
18.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

18.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo Processing (IDE).

18.4.3 Desarrollo de la Práctica


Primero conseguimos una imagen png o jpg para usarla como textura, en esta práctica
usamos ladrillo.jpg, que se muestra a continuación.

Ejecutamos processing.exe y en la interfaz seleccionamos Archivo->Nuevo y en la


nueva ventana escribimos el siguiente código y los guardamos como superficie3D,
Processing creara una carpeta para guardarlo como proyecto y dentro de la carpeta
guardara el código fuente. Quedando almacenado en la ruta:

..\Processing\animacionSimple\animacionSimple.pde

Código:
PImage logo;
PShape esfera;
float angulo=0; // En radianes

void setup() {
size(500, 500, P3D);
noStroke();
sphereDetail(100);
logo = loadImage("ladrillo.jpg");
esfera = createShape(SPHERE, 150);
esfera.setTexture(logo);
}

void draw() {
background(color(30, 100, 180));

// Light the bottom of the sphere


directionalLight(80, 120, 140, 0, 0, -1);

Departamento de Sistemas y Computación Página 100


// Hace que el punto de luz siga al puntero del ratón
spotLight(102, 153, 204, mouseX, mouseY, 600, 0, 0, -1, PI/2, 600);

translate(250, 250, 0);


rotateY(angulo); // Gira sobre si mismo
angulo+=0.03;
translate(60, 0, 0); // Se mueve sobre el eje X
shape(esfera);
}

El resultado del programa anterior es la siguiente ventana:

Reto.
Modifique el programa de la practica 16 para que el plano gire en torno del eje Y.

18.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
el código y las pantallas del programa que implementó.

Además, documente las funciones integradas que se mencionan en el punto 16.3

18.5 Resultados y Conclusiones


El alumno apreciará las ventajas de una herramienta de programación más avanzada,
viendo que puede implementar escenas mucho más complejas con menos esfuerzo.

Departamento de Sistemas y Computación Página 101


Bibliografía
[1] Tecnológico Nacional de México. Programa de estudios de Graficación. Toluca,
Toluca, México: s.n., febrero de 2014.
[2] —. Retícula de la carrera de ingeniería en sistemas computacionales ISIC-2010-
224. Ciudad de México, México: s.n., 2016.
[3] HEARN, Donald & M. Pauline Baker, Gráficas por computadora 2ª edición, Ed.
Prentice Hall Hispanoamericana. México
[4] FOLEY, James & Andries Van Dam, Introducción a la graficación por
computador, Ed. Addison Wesley Iberoamericana, 1996
[5] Hernández, Cristopher Eduardo Rojo. GRAFICACIÓN. Algoritmos DDA y
Bresenham. [En línea] 14 de agosto de 2017.
https://graficacion2017.wordpress.com/2017/08/14/algoritmos-dda-y-bresenham/.
[6] César, Marín López. DOCPLAYER. Rúbrica para Evaluación de Proyectos de
Programación (Modelo T). [En línea] https://docplayer.es/16465320-Rubrica-
para-evaluacion-de-proyectos-de-programacion-modelo-t-ciencia-tecnologia-y-
ambiente-departamento-academico-desarrollo-tecnologico.html.
[7] UNAM. portalacademico.cch.unam.mx. RUBRICA PARA EVALUAR EL
REPORTE DE LA PRÁCTICA. [En línea]
https://portalacademico.cch.unam.mx/materiales/prof/matdidac/sitpro/exp/quim/q
uim2/quimicII/525542524943415f504152415f4556414c5541525f454c5f5245504f
5254455f44455f4c415f5f5052c3814354494341.pdf.
[8] Evaluación de prácticas de programación mediante rúbricas en Moodle. Vaca,
Juan Manuel, Agudo, J, Enrique y Sánchez, Héctor. Oviedo: s.n., 11 de julio
de 2014, Actas de las XX JENUI, págs. 107-114.
[9] ACADEMIC. Enciclopedia Universal. Biblioteca (programación). [En línea]
2012.
http://enciclopedia_universal.esacademic.com/76215/Biblioteca_%28programaci
%C3%B3n%29.
[10] jogamp. Java™ Binding for the OpenGL® API. [En línea]
http://jogamp.org/jogl/www/.The OpenGL Graphics System: A Specification
(Version 3.0 - September 23, 2008)
[11] Segal, Mark y Akeley, Kurt. The OpenGL Graphics System: A Specification. 23
de septiembre de 2008.
[12] Fuentes Ramos, Pablo. GEOMETRÍA ANALÍTICA. ECUACIONES
PARAMÉTRICAS. [En línea]
https://expediente.ues.edu.sv/uiu/elementos_estudio/matematica/Jesus%20Infante
%20Murillo%20-
%20Geometria%20Analitica/10.%20Ecuaciones%20Parametricas.pdf.20Geometri
a%20Analitica/10.%20Ecuaciones%20Parametricas.pdf
[13] Fry, Ben y Reas, Casey. Processing. [En línea] https://processing.org/.

Departamento de Sistemas y Computación Página 102


Anexo A. Rubrica
Para la evaluación de esta práctica se recomienda la siguiente rúbrica [6][7][8], que
tiene una escala de 1% a 100%.

Criterios Deficiente Regular Bueno Muy Bueno


1% a 5% 6% a 10% 11% a 15% 16% a 20%
El documento El documento Además, no tiene Además, está bien
no cumple con cumple con la errores redactado y tiene
Documento la estructura y estructura y ortográficos y coherencia de
formato formato gramaticales. contenido.
explicitado explicitado por el
por el docente. docente.
1% a 7% 8% a 15% 16% a 23% 24% a 30%
Utiliza Utiliza Utiliza las Utiliza las
instrucciones instrucciones y instrucciones instrucciones
y algoritmos que no y algoritmos y algoritmos más
algoritmos que son necesarios adecuados para
Codificación no acordes para para resolver el resolver
resuelven el resolver el ejercicio, el ejercicio. Usa
ejercicio. ejercicio. aunque no son los buenas prácticas
más de codificación.
adecuados.
1% a 12% 13% a 24% 25% a 37% 38% a 50%
No funciona. El funcionamiento El funcionamiento El funcionamiento
Funcionamiento tiene fallos tiene fallos sin es completo.
importantes. importancia.

Departamento de Sistemas y Computación Página 103


Anexo B. Plantilla del reporte de
practicas.
PRÁCTICA [Número de práctica]. [Nombre de la práctica]
Lugar: [Nombre del laboratorio]

Duración: [Total de sesiones de n horas]

Grupo: [Materia, hora, año/mes, Profesor]

Integrantes: [Lista de los alumnos que realizaron la práctica]

1. Introducción
2. Objetivo (Competencia)
3. Fundamento
4. Procedimiento (Descripción)
4.1 Equipo necesario
4.2 Material de Apoyo
4.3 Desarrollo de la Práctica
4.4 Cálculos y reporte
5. Resultados y Conclusiones
6. Anexos
7. Bibliografía

Departamento de Sistemas y Computación Página 104


Anexo C. Reglamento interno para el
uso de laboratorios.
Con la finalidad de optimizar el uso del Laboratorio y acatando los lineamientos de
nuestras autoridades, hacemos de su conocimiento el siguiente:

REGLAMENTO

OBLIGACIONES DE LOS ALUMNOS:


1. Queda estrictamente prohibido introducir alimentos o bebidas al laboratorio
(incluyendo dulces y chicles).
2. Durante su permanencia en el laboratorio deberán mostrar su cultura no profiriendo
palabras obscenas y no dejando papeles o basura en las mesas o piso.
3. Queda estrictamente prohibido utilizar el laboratorio para estudiar o elaborar tareas,
ya que las salas están programadas únicamente para clases, cursos o prácticas. Para
estudiar y elaborar tareas el Centro de Información se encuentra debidamente
equipado para estos fines
4. A los alumnos que no tengan clase, curso o práctica en el laboratorio, les queda
estrictamente prohibido el acceso a dicha área. Únicamente pueden entrar al
laboratorio si el maestro está presente, ya que él es el responsable del grupo.
5. Al término de sus clases, cursos o prácticas, es obligación de todos los usuarios
apagar las computadoras (CPU, monitor) y acomodar las sillas en su lugar (una por
computadora y las restantes cerca de la pared).
6. Por ningún motivo pueden desconectar los cables de la computadora o de los
periféricos que se les asignó.
7. En caso de que no funcione correctamente el mouse, cables, teclado o CPU,
reportarlo inmediatamente al maestro, ya que ustedes son responsables de las
computadoras que se les asignó desde un principio, (para que éste a su vez nos lo
haga saber y arreglar el problema).
8. Los alumnos prestantes del Servicio Social cumplen con una función encomendada
por las autoridades escolares, por lo tanto, las posibles reclamaciones deberán
hacerlas los usuarios directamente a los coordinadores del laboratorio, por ningún
motivo sus compañeros de Servicio Social tolerarán un trato injustificado.
9. Sin excepción, cualquier usuario que sea sorprendido instalando juegos, utilizando
los juegos ya instalados, borrando o alterando la información que contengan las
máquinas, así como desconectándolas o haciendo uso indebido de ellas, será
suspendido definitivamente del laboratorio, y será reportado a las autoridades
escolares para que sea sancionado de acuerdo al reglamento del Instituto.

Es necesario recordar que estamos formando alumnos a un nivel profesional y que el


esfuerzo de la Institución a que pertenecemos es trabajo de muchas generaciones, por lo
cual te pedimos nos ayudes a conservar para tu propio beneficio en el mejor estado, la
infraestructura de que dispone el Instituto Tecnológico de San Luis Potosí.

Departamento de Sistemas y Computación Página 105


INSTITUTO TECNOLÓGICO DE SAN LUIS
POTOSÍ

DEPARTAMENTO DE SISTEMAS Y COMPUTACIÓN


CARRERA:
Ingeniería en Sistemas Computacionales

MANUAL DE PRÁCTICAS DE LA MATERIA:


Programación Orientada a Objetos

NOMBRE DEL AUTOR: PEDRO GARCÍA GUERRERO


NÚMERO DE DICTAMEN: AS-2-239/2018
PLAN DE ESTUDIOS: ISIC-2010-224
CLAVE DE LA ASIGNATURA: SCD-1020

SOLEDAD DE GRACIANO SÁNCHEZ, S.L.P., A 01 DE AGOSTO DEL 2019


Contenido
OBJETIVO GENERAL DEL MANUAL .......................................................................................................... 6
OBJETIVO GENERAL DE LA MATERIA ..................................................................................................... 6
COMPETENCIAS ESPECÍFICAS A DESARROLLAR ................................................................................... 6
UTILIDAD DEL MANUAL ........................................................................................................................... 6
PRÁCTICA 1. INTRODUCCIÓN A UML ................................................................................................... 7
1.1 INTRODUCCIÓN ................................................................................................................................ 7
1.2 OBJETIVO (COMPETENCIA) ............................................................................................................... 7
1.3 FUNDAMENTO ................................................................................................................................... 7
1.4 PROCEDIMIENTO (DESCRIPCIÓN) ..................................................................................................... 8
1.4.1 EQUIPO NECESARIO............................................................................................................................ 8
1.4.2 MATERIAL DE APOYO ........................................................................................................................ 8
1.4.3 DESARROLLO DE LA PRÁCTICA .......................................................................................................... 9
1.4.4 REPORTE .......................................................................................................................................... 19
1.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 19
PRÁCTICA 2. IMPLEMENTACIÓN DE UNA CLASE EN NETBEANS ................................................... 20
2.1 INTRODUCCIÓN .............................................................................................................................. 20
2.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 20
2.3 FUNDAMENTO ................................................................................................................................. 20
2.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 21
2.4.1 EQUIPO NECESARIO.......................................................................................................................... 21
2.4.2 MATERIAL DE APOYO ...................................................................................................................... 21
2.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 21
2.4.4 REPORTE .......................................................................................................................................... 28
2.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 28
PRÁCTICA 3. IMPLEMENTACIÓN DE CONCEPTOS BÁSICOS DE POO. ........................................... 29
3.1 INTRODUCCIÓN .............................................................................................................................. 29
3.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 29
3.3 FUNDAMENTO ................................................................................................................................. 29
3.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 30
3.4.1 EQUIPO NECESARIO.......................................................................................................................... 30
3.4.2 MATERIAL DE APOYO ...................................................................................................................... 30
3.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 30
3.4.4 REPORTE .......................................................................................................................................... 33
3.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 33
PRÁCTICA 4. JUEGO DE TRES EN RAYA (GATO). .............................................................................. 34
4.1 INTRODUCCIÓN .............................................................................................................................. 34
4.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 34
4.3 FUNDAMENTO ................................................................................................................................. 34

Departamento de Sistemas y Computación Página ii


4.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 34
4.4.1 EQUIPO NECESARIO.......................................................................................................................... 34
4.4.2 MATERIAL DE APOYO ...................................................................................................................... 34
4.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 35
4.4.4 REPORTE .......................................................................................................................................... 46
4.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 46
PRÁCTICA 5. USO DE HERENCIA. ........................................................................................................ 47
5.1 INTRODUCCIÓN .............................................................................................................................. 47
5.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 47
5.3 FUNDAMENTO ................................................................................................................................. 47
5.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 48
5.4.1 EQUIPO NECESARIO.......................................................................................................................... 48
5.4.2 MATERIAL DE APOYO ...................................................................................................................... 48
5.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 48
5.4.4 REPORTE .......................................................................................................................................... 52
5.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 52
PRÁCTICA 6. FACTURAS EN UNA ZAPATERÍA (HERENCIA 2). ....................................................... 53
6.1 INTRODUCCIÓN .............................................................................................................................. 53
6.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 53
6.3 FUNDAMENTO ................................................................................................................................. 53
6.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 55
6.4.1 EQUIPO NECESARIO.......................................................................................................................... 55
6.4.2 MATERIAL DE APOYO ...................................................................................................................... 55
6.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 56
6.4.4 REPORTE .......................................................................................................................................... 63
6.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 63
PRÁCTICA 7. GENERACIÓN Y APLICACIÓN DE EXÁMENES (HERENCIA 3). ................................. 64
7.1 INTRODUCCIÓN .............................................................................................................................. 64
7.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 64
7.3 FUNDAMENTO ................................................................................................................................. 64
7.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 65
7.4.1 EQUIPO NECESARIO.......................................................................................................................... 65
7.4.2 MATERIAL DE APOYO ...................................................................................................................... 65
7.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 65
7.4.4 REPORTE .......................................................................................................................................... 75
7.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 75
PRÁCTICA 8. INTRODUCCIÓN AL USO DE INTERFACES. ................................................................. 76
8.1 INTRODUCCIÓN .............................................................................................................................. 76
8.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 76
8.3 FUNDAMENTO ................................................................................................................................. 76
8.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 77
8.4.1 EQUIPO NECESARIO.......................................................................................................................... 77
8.4.2 MATERIAL DE APOYO ...................................................................................................................... 77
8.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 77

Departamento de Sistemas y Computación Página iii


8.4.4 REPORTE .......................................................................................................................................... 82
8.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 82
PRÁCTICA 9. MANEJO DE ERRORES.................................................................................................... 83
9.1 INTRODUCCIÓN .............................................................................................................................. 83
9.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 83
9.3 FUNDAMENTO. [10][11] .................................................................................................................. 83
9.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 88
9.4.1 EQUIPO NECESARIO.......................................................................................................................... 88
9.4.2 MATERIAL DE APOYO ...................................................................................................................... 88
9.4.3 DESARROLLO DE LA PRÁCTICA ........................................................................................................ 88
9.4.4 REPORTE .......................................................................................................................................... 90
9.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 90
PRÁCTICA 10. LEER Y ESCRIBIR ARCHIVOS DE TEXTO. ................................................................. 91
10.1 INTRODUCCIÓN .............................................................................................................................. 91
10.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 91
10.3 FUNDAMENTO ................................................................................................................................. 91
10.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 92
10.4.1 EQUIPO NECESARIO ..................................................................................................................... 92
10.4.2 MATERIAL DE APOYO.................................................................................................................. 92
10.4.3 DESARROLLO DE LA PRÁCTICA ................................................................................................... 92
10.4.4 REPORTE ..................................................................................................................................... 95
10.5 RESULTADOS Y CONCLUSIONES...................................................................................................... 95
PRÁCTICA 11. GUARDAR Y RECUPERAR OBJETOS. ......................................................................... 96
11.1 INTRODUCCIÓN .............................................................................................................................. 96
11.2 OBJETIVO (COMPETENCIA) ............................................................................................................. 96
11.3 FUNDAMENTO ................................................................................................................................. 96
11.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................... 97
11.4.1 EQUIPO NECESARIO ..................................................................................................................... 97
11.4.2 MATERIAL DE APOYO.................................................................................................................. 97
11.4.3 DESARROLLO DE LA PRÁCTICA ................................................................................................... 97
11.4.4 REPORTE ................................................................................................................................... 100
11.5 RESULTADOS Y CONCLUSIONES.................................................................................................... 100
PRÁCTICA 12. ALMACENAR VECTORES DE OBJETOS EN ARCHIVOS .......................................... 101
12.1 INTRODUCCIÓN ............................................................................................................................ 101
12.2 OBJETIVO (COMPETENCIA) ........................................................................................................... 101
12.3 FUNDAMENTO ............................................................................................................................... 101
12.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................. 102
12.4.1 EQUIPO NECESARIO ................................................................................................................... 102
12.4.2 MATERIAL DE APOYO................................................................................................................ 103
12.4.3 DESARROLLO DE LA PRÁCTICA ................................................................................................. 103
12.4.4 REPORTE ................................................................................................................................... 105
12.5 RESULTADOS Y CONCLUSIONES.................................................................................................... 105
PRÁCTICA 13. RECUPERAR VECTORES DE OBJETOS DESDE ARCHIVOS. ................................... 106

Departamento de Sistemas y Computación Página iv


13.1 INTRODUCCIÓN ............................................................................................................................ 106
13.2 OBJETIVO (COMPETENCIA) ........................................................................................................... 106
13.3 FUNDAMENTO ............................................................................................................................... 106
13.4 PROCEDIMIENTO (DESCRIPCIÓN) ................................................................................................. 106
13.4.1 EQUIPO NECESARIO ................................................................................................................... 106
13.4.2 MATERIAL DE APOYO................................................................................................................ 106
13.4.3 DESARROLLO DE LA PRÁCTICA ................................................................................................. 107
13.4.4 REPORTE ................................................................................................................................... 110
13.5 RESULTADOS Y CONCLUSIONES.................................................................................................... 110
BIBLIOGRAFÍA ....................................................................................................................................... 111
ANEXO A. RÚBRICA ............................................................................................................................... 113
ANEXO B. PLANTILLA DEL REPORTE DE PRÁCTICAS. ....................................................................... 114
ANEXO C. REGLAMENTO INTERNO PARA EL USO DE LABORATORIOS. .......................................... 115

Departamento de Sistemas y Computación Página v


Objetivo General del Manual
La intención es que el alumno asimile mejor los conceptos de la programación
orientado a objetos al ver la aplicación en un lenguaje de programación como java.

Al tener claro los conceptos podrá reconocer cuando aplicarlos al enfrentarse a


problemas del mundo real.

Además, el alumno tendrá un mejor conocimiento de las herramientas que brinda el


lenguaje para poder implementar exitosamente sus soluciones.

Objetivo General de la Materia


Proporcionar al estudiante las competencias necesarias para abordar el estudio de
cualquier lenguaje orientado a objetos, metodología de análisis y diseño orientado a
objetos, de los sistemas gestores de bases de datos, y en general de cualquier materia
basada en el modelo orientado a objetos. [1][2]

Competencias Específicas a
Desarrollar
Diseñar e implementar objetos de programación que permitan resolver situaciones
reales y de ingeniería. [1][2]

Utilidad del Manual


Es una guía para los profesores que imparten la materia, para poder uniformizar los
contenidos y nivel de profundidad de los temas del programa.

Para los estudiantes juega un papel importante en su formación ya que es una


herramienta de aprendizaje que fortalece los objetivos del perfil de estudios.

Para la Academia de Sistemas Computacionales es una evidencia que se están


promoviendo nuevas e innovadoras estrategias didácticas.

Departamento de Sistemas y Computación Página 6


Practica 1. Introduccion a UML
1.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad I: Introducción
al paradigma de la programación orientada a objetos del subtema 1.2. Lenguaje
de modelado unificado: diagrama de clases y 1.2 Lenguaje de modelado
unificado: diagrama de clases, del programa de estudios de la materia de
Programación Orientada a Objetos, desarrollando la competencia específica:
“Comprende y aplica los conceptos del paradigma de programación orientada a
objetos para modelar situaciones de la vida real.”.

1.2 Objetivo (Competencia)


Realizar los diagramas de actividades y de clases de un caso de estudio en plantUML
para familiarizarse con dicha la herramienta.

1.3 Fundamento
Al inicio de un proyecto de desarrollo de sistemas se debe comunicar efectivamente
quienes tienen la idea y los desarrolladores. EL UML (Lenguaje Unificado de Datos)
es una herramienta que sirve como enlace para cumplir esta función ya que le ayuda
a capturar la idea de un sistema para comunicarla posteriormente a quien está
involucrado en su proceso de desarrollo; esto se lleva a cabo mediante un conjunto de
símbolos y diagramas. Cada diagrama tiene fines distintos dentro del proceso de
desarrollo. [3]

Existen diversas herramientas que nos permiten generar diagramas UML y


coordinarlas en un modelo. Algunas de las más conocidas son: [4]

Software Características
MagicDraw Lo mejor es su usabilidad. NoMagic (la empresa detrás MagicDraw)
ha sido comprada por Dassault Systems. Es de prever que, como
consecuencia, MagicDraw siga mejorando en todo lo que se refiere
a la ingeniería de sistemas donde este tipo de simulaciones a partir
de modelos es clave. Disponible en:
https://www.nomagic.com/products/magicdraw

Papyrus El entorno de modelado estándar “de facto” en Eclipse. Gratuito y


UML open source, Papyrus es sin duda la mejor opción si trabajas con
Eclipse o necesitas integrar tus modelos con otros plug-ins de
Eclipse como parte de tu proceso de desarrollo. Disponible en:
https://www.eclipse.org/papyrus/

Modelio. Herramienta muy potente, organizada en un núcleo open source al


que se le pueden añadir funcionalidades mediante un sistema de

Departamento de Sistemas y Computación Página 7


extensión modular. Algunos de los modelos son también gratuitos,
pero muchos son ya extensiones comerciales, disponibles en la
modelio store. Esta estructuración te permite adaptar la herramienta
a tus necesidades de modelado UML. Por ejemplo, puedes empezar
modelando gratis. Disponible en:
https://www.modelio.org/

ArgoUML. ArgoUML fue de las primeras herramientas, por lo que es muy


popular aún. Disponible en:
http://argouml.tigris.org/

StarUML StarUML es la mejor opción si buscas una herramienta rápida, fácil


de usar y razonablemente barata en comparación a otras
herramientas UML. Disponible en:
http://staruml.io/

easyUML easyUML es una herramienta de diagrama UML para NetBeans que


proporciona funciones para crear y trabajar con diagramas UML
fácilmente. Actualmente soporta diagramas de clase proporcionando un
editor visual drag-and-drop para el dibujo de diagrama, Java código de
generación de diagramas y 'ingeniería inversa' para crear diagramas de
clases a partir de código Java. Es muy adecuado para la enseñanza de
diseño de software. Disponible en:
http://plugins.netbeans.org/plugin/55435/easyuml

plantUML PlantUML es una herramienta OpenSource que permite crear gráficos


vectoriales usando un lenguaje propio. Nada de Arrastrar-y-soltar. No,
solo debemos escribir unos textos casi como el HTML y el motor de
PlantUML nos creará el gráfico respectivo. [5]
Disponible en:
http://plugins.netbeans.org/plugin/49069/plantuml

En la presente practica usaremos plantUML como una extensión para NetBeans.

1.4 Procedimiento (Descripción)


1.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

1.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java (IDE) NetBeans.
 Extensión (plugin) para netbeans plantUML
 Herramienta Graphviz

Departamento de Sistemas y Computación Página 8


1.4.3 Desarrollo de la Práctica
Primero debemos abrir el IDE netbeans, y después ir a la opción “ToolsPLugins”.
Se aparecerá una ventana, de la cual seleccionamos la pestaña “Available Plugins”.

En el cuadro de texto “Search” escribimos uml y obtendremos una lista de plugins


relacionados con UML:

Seleccionamos PlantUML y damos clic en el botón “Install”, aceptamos los términos


y condiciones y damos clic en “install”, y esperamos a que termine de descargar e
instalar el software.

Departamento de Sistemas y Computación Página 9


Si aparece otros diálogos de advertencia, damos clic en “Continue” y para finalizar
selecionamos la opción de “Restar IDE Now” y damos clic al botón “Finish”

Y para poder ver los gráficos con los diagramas generados, requerimos de otra
herramienta: Graphviz. Esta la descargamos del sitio http://www.graphviz.org/

Departamento de Sistemas y Computación Página 10


Procedemos a ejecutar el archivo de instalación graphviz-2.38.msi.

Ahora buscamos el ejecutable dot.exe. En Windows es posible que se encuentre en


c:\Program Files (x86)\GraphvizX.X\bin

En netBeans entremos a la opción: “Tools  Options  Miscellaneous 


PlantUML”, e indicar la ubicación del archivo dot.exe.

Departamento de Sistemas y Computación Página 11


Ahora intentaremos modelar el siguiente ejemplo:

“Una clínica cuenta con varios doctores, y algunas recepcionistas. Se quiere


automatizar el proceso de agendar citas por teléfono o en la clínica. Se pueden
registrar nuevos pacientes. Los pacientes pueden solicitar la cita con algún doctor,
para lo cual la recepcionista verificará la disponibilidad de la fecha y si está
disponible, se la asignará. También debe ser posible re agendar citas”.

Crear el proyecto en NetBeans.


Iniciamos nebeans, elegimos la opción “FileNew Project”. Creamos una
aplicación java:

Le damos el nombre de “appCitas” al proyecto. En el nombre del proyecto damos


clic derecho y del menú emergente seleccionamos “New” y luego “Other”.

Departamento de Sistemas y Computación Página 12


Del nuevo dialogo seleccionamos la categoría “PlantUML” y del tipo de archivo
elegimos “New PlantUML Diagram” y luego clic en el botón “Next >”

Le damos un nombre al diagrama

Departamento de Sistemas y Computación Página 13


Sea parecerá una ventana donde escribiremos el código según la sintaxis de
plantUML para especificar el diagrama de actividades. [6]

Escriba el código:
diagramaActiviades.puml
@startuml

title "Diagrama de Actividades"


(*) --> "Llamada o Visita del Cliente"
"Llamada o Visita del Cliente" --> "Atiende recepcionista"

if "Ya es paciente?" then


-->if "Tiene cita?" then
-->[si] "Modificar cita"
-->"Registrar cita"
-->(*)
else
-right-->[no] "Solicitar cita"
-->"Registrar cita"
endif
else
-right-->[no] "Registrar paciente"
-->"Solicitar cita"
endif

@enduml

Departamento de Sistemas y Computación Página 14


Deberá obtener el siguiente diagrama:

Departamento de Sistemas y Computación Página 15


Ahora repetimos los pasos necesarios para crear otro diagrama. Ahora será el de casos
de uso:

El código sería:
DiagramaCasosUso.puml
@startuml
title "Diagrama de Casos de Uso"
left to right direction
skinparam packageStyle rect
actor paciente
actor recepcionista
rectangle Citas {
paciente -- (llamada/visita)
paciente -- (pedir datos)

(llamada/visita) -- recepcionista
(pedir datos) -- recepcionista
(registrar datos) -- recepcionista
(consultar datos) -- recepcionista
(modificar datos) -- recepcionista
}
@enduml

Departamento de Sistemas y Computación Página 16


Y el diagrama resultante es:

Por último, crearemos los diagramas de clase:

Departamento de Sistemas y Computación Página 17


Escribimos el código

@startuml
title "Diagrama de clases"

Paciente - Recepcionista : llama >


Recepcionista -- Cita : consulta, registra, actualiza >
Cita -- Doctor : agenda <

class Paciente{
-rfc
+nombre
+actualizarNombre()
+verRFC()
}

class Recepcionista{
-rfc
+nombre
+turno
+actualizarTurno()
+verRFC()
}

class Doctor{
-rfc
+nombre
+especialidad
+costoConsulta
+verCosto()
}

class Cita{
-id
-Paciente
-Recepcionista
-Doctor
+Fecha
+Hora
+actualizarCita()
+cancelarCita()
}

@enduml

Departamento de Sistemas y Computación Página 18


Y debemos obtener el siguiente diagrama:

Reto.
Crea los diagramas de actividades, casos de uso y de clases, usando NerBeans y
plantUML del siguiente enunciado:

“Para un sitio web se requiere un módulo de autenticación, el cual permite el registro


de usuarios (para lo cual se les pide alguna información). Los usuarios registrados
podrán entrar al sistema proporcionando un nombre de usuario y una contraseña. Si
los datos son correctos nos debe dar la bienvenida al sistema y, en caso contrario
decirnos si la contraseña es incorrecta o el nombre del usuario no está registrado”.

1.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
los diagramas desarrollados de los dos casos.

1.5 Resultados y Conclusiones


Con ésta práctica, el alumno comenzará a diseñar y crear diagramas UML básicos, y
comenzará a valorarla como una herramienta muy útil para comunicarse con los
clientes.

Departamento de Sistemas y Computación Página 19


Practica 2. Implementacion de una
Clase en NetBeans
2.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad II: Clases y
objetos de los subtemas 2.1 Declaración de clases: atributos, métodos,
encapsulamiento y 2.2 Instanciación de una clase, del programa de estudios de
la materia de Programación Orientada a Objetos, desarrollando la competencia
específica: “Aplica los conceptos de clases y objetos en el desarrollo de programas
para solución de problemas de acuerdo al paradigma orientado a objetos”.

2.2 Objetivo (Competencia)


Elaborar un programa que ejemplifique la orientación a objetos y además sirva como
un primer acercamiento al IDE NetBeans. Se pretende realizar un programa en java
que implemente la clase Auto, definiendo sus atributos y métodos.

2.3 Fundamento
La mayoría de las cosas que nos rodean se pueden agrupar en clasificaciones, bajo
ciertos criterios. Y para modelar ciertas partes del mundo real, tenemos que hacer un
ejercicio de abstracción y realizar las clasificaciones en base los atributos y acciones
que mejor describan a cada clasificación.

Así, cada clasificación, categoría o grupo de cosas es una clase que tiene atributos y
métodos. Y a cada entidad o cosa que pertenece a una clase le llamaremos objeto.

Para reflejar este paradigma en la programación en java, consideraremos a una clase como
una agrupación de datos (variables o campos) y de funciones (métodos) que operan sobre
estos datos A estos datos y funciones pertenecientes a una clase se les denomina atributos
y métodos o funciones miembro.

La programación orientada a objetos se basa en la programación de clases. Un programa


se construye a partir de un conjunto de clases.

Una vez definida e implementada una clase, es posible declarar elementos de esta clase de
modo similar a como se declaran las variables del lenguaje (de los tipos primitivos int,
double, String, …).

Los elementos declarados de una clase se denominan objetos de la clase. De una única clase
se pueden declarar o crear numerosos objetos. La clase es lo genérico: es el patrón o modelo
para crear objetos.

Departamento de Sistemas y Computación Página 20


Cada objeto tiene sus propias copias de las variables miembro, con sus propios valores, en
general distintos de los demás objetos de la clase. Las clases pueden tener variables static,
que son propias de la clase y no de cada objeto.

En UML las clases se representan por un rectángulo con tres divisiones horizontales.
En la sección superior se coloca el nombre de la clase, en la siguiente los atributos y
en la última los métodos o acciones.

Nombre de la Clase

Lista de Atributos

Lista de Métodos

2.4 Procedimiento (Descripción)


2.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

2.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java NetBeans.

2.4.3 Desarrollo de la Práctica


En la práctica modelaremos a un grupo de objetos muy comunes: los autos. Al intentar
clasificar a un grupo de autos, pensemos que tienen en común todos ellos.

Dependiendo del uso que se le dará al programa son las características que nos
interesaran modelar, por ejemplo:

 Un negocio de compra-venta de autos le interesa el kilometraje, condiciones


del motor, estatus legal.
 Un taller mecánico le puede interesar la descripción del fallo, costo de
refacciones, costo de mano de obra.
 Un estacionamiento le interesa las placas y dimensiones del auto.

En este caso solo modelaremos las características más comunes: marca, modelo y
precio Las acciones que puede ejecutar son: encenderse, apagarse, acelerar, frenar y
pintarlo, entre muchas otras. Dichas acciones modifican el estado del motor, la
velocidad del auto y el color.

Nuestra clase Auto se vería así:

Departamento de Sistemas y Computación Página 21


Auto
marca
modelo
precio
estadoMotor
velocidad
color
encenderAuto()
apagarAuto()
acelerarAuto()
frenarAuto()
pintarAuto()

Ahora procedemos a programar esta clase:

Primer paso. Crear el proyecto en NetBeans


Iniciamos nebeans, elegimos la opción “FileNew Project”. Creamos una
aplicación java:

Le damos el nombre de “appAutos” al proyecto. Damos clic en el botón “Finish” y


el proyecto se ha creado.

Departamento de Sistemas y Computación Página 22


Segundo paso. Seleccionar como proyecto principal.
Si es el único proyecto podemos saltar este paso. En otro caso, damos clic derecho
sobre el nombre del proyecto y en el menú contextual seleccionamos “Set as Main
Project”. El nombre del proyecto debe ponerse en negritas.

Departamento de Sistemas y Computación Página 23


Tercer paso. Crear la clase Auto
En el menú de proyectos que está a la izquierda, expandemos el proyecto hasta ver el
paquete appauto y sobre este damos clic derecho y del menú contextual
seleccionamos New y luego Java Class.

Le damos el nombre de Auto a la nueva clase y clic en el botón “Finish”:

Departamento de Sistemas y Computación Página 24


Cuarto paso. Codificar la clase Auto
Seleccionamos la pestaña de edición llamada “Auto.java” y escribimos el código:

Auto.java
package appautos;

public class Auto {


//Atributos
String marca = "Nissan";
int modelo = 2000;
float precio = 80000f;
boolean estadoMotor = false;
int velocidad = 0;
String color = "Blanco";

//Métodos
void encenderAuto() {
estadoMotor = true;
}

void apagarAuto() {
estadoMotor = false;
}

void acelerarAuto() {
velocidad += 10;
}

void frenarAuto() {
velocidad -= 10;
}

void pintarAuto(String c) {
color = c;
}

void precioAuto(float p) {
precio = p;
}

void imprimirAtributos() {
System.out.println("\t Marca: " + marca);
System.out.println("\t Modelo: " + modelo);
System.out.println("\t Precio: $" + precio);
System.out.print("\t Estado del motor: ");
if (estadoMotor) {
System.out.println("Encendido");
} else {
System.out.println("Apagado");
}
System.out.println("\t Velocidad: " + velocidad+" km/h");
System.out.println("\t Color: " + color);
System.out.println();
}
}

Departamento de Sistemas y Computación Página 25


Quinto paso. Editar la clase principal
Ahora debemos crear un objeto de la clase auto, le damos algún valor inicial a sus
propiedades y luego ejecutar algunos de sus métodos y verificar como cambian
algunos de sus atributos.

En el ejemplo, creamos el objeto y primero mostramos el valor de los atributos, luego


encendemos el auto, lo aceleramos hasta 30 km/h, mostramos los atributos, lo
frenamos hasta 20kn/h mostramos sus atributos, bajamos la velocidad a cero, los
pintamos de gris y aumentamos su precio un 10%, y por ultimo volvemos a imprimir
sus atributos. Seleccionamos la pestaña de edición llamada “AppAutos.java” y
escribimos:

AppAutos.java
package appautos;

public class AppAutos {

public static void main(String[] args) {


//creamos el objeto
Auto tsuru = new Auto();

//imprimir atributos
tsuru.imprimirAtributos();

//encendemos el auto,
System.out.println("Encendiendo...");
tsuru.encenderAuto();

//aceleramos hasta 30 km/h


System.out.println("Acelerando...");
tsuru.acelerarAuto();
tsuru.acelerarAuto();
tsuru.acelerarAuto();

//imprimir atributos
tsuru.imprimirAtributos();

//frenarlo hasta 20 kn/h


System.out.println("Frenando...");
tsuru.frenarAuto();

//imprimir atributos
tsuru.imprimirAtributos();

//bajamos la velocidad a 0 km/h,


System.out.println("Frenando...");

//lo pintamos de gris


System.out.println("Lo pintamos de gris");
tsuru.pintarAuto("Gris");

//aumentamos su precio un 10%


System.out.println("Aumentar precio del auto");

Departamento de Sistemas y Computación Página 26


float nuevoPrecio = tsuru.precio * 1.10f;
tsuru.precioAuto(nuevoPrecio);

//imprimir atributos
tsuru.imprimirAtributos();
}
}

Sexto paso. Compilar y Ejecutar


Ahora compilamos y ejecutamos el programa, dando clic en el icono , y obtenemos:

Departamento de Sistemas y Computación Página 27


Reto.
Ahora modifique los métodos de la clase para validar las siguientes situaciones:
 Debe marcar un error si intenta encender el auto y ya está encendido
 No puede apagar el auto si la velocidad es diferente de cero
 Avisar si intenta apagar el auto y ya estaba apagado.
 Para poder acelerar, el auto debe estar encendido
 La máxima velocidad del auto es 200km/h
 Al pisar el freno, la velocidad disminuye, pero nunca menos de 0 km/h

2.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
el código fuente y capturas de pantalla de la ejecución del programa.

2.5 Resultados y Conclusiones


Con ésta práctica, el alumno comenzará a acostumbrarse al entorno de programación
de netbeans y además comprenderá como reflejar las restricciones de la realidad en
el modelo computacional, acorde al paradigma de modelado orientado a objetos.

Departamento de Sistemas y Computación Página 28


Practica 3. Implementacion de
conceptos basicos de POO.
3.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad II: Clases y
objetos de los subtemas 2.3 Referencia al objeto actual, 2.4 Métodos: declaración,
mensajes, paso de parámetros, retorno de valores, 2.5 Constructores y
destructores declaración, uso y aplicaciones, del programa de estudios de la materia
de Programación Orientada a Objetos, desarrollando la competencia específica:
“Aplica los conceptos de clases y objetos en el desarrollo de programas para
solución de problemas de acuerdo al paradigma orientado a objetos”.

3.2 Objetivo (Competencia)


Familiarizarse con el entorno de NetBeans y reafirmar los conceptos básicos de la
Orientación a Objetos. Para lograrlo, se realizarán varios programas en java que
implementen respectivamente las clases Línea, Círculo, Punto, ConversorDivisas y
Fecha, definiendo sus atributos y métodos y usando diferentes constructores.

3.3 Fundamento
En el paradigma del modelado orientado a objetos se representa el mundo real y
resuelve problemas a través de objetos, ya sean tangibles o digitales. Este paradigma
tecnológico considera un sistema como una entidad dinámica formada de
componentes. Un sistema sólo se define por sus componentes y la manera en que
éstos interactúan. [7]

Un programa pueda ser visto como un conjunto de relaciones entre proveedores


clientes. Los servicios ofrecidos por los objetos son de dos tipos:
 Los datos, que llamamos atributos.
 Las acciones o funciones, que llamamos métodos.

Para construir un programa, primero identificamos los objetos que interactúan en el


sistema, los agrupamos en clases, a cada clase la caracterizamos por sus atributos y
métodos. Y al final establecemos la interacción entre los objetos a través del
intercambio de mensajes.
Objetos + Mensajes = Programa

Antes de comenzar a programar, debemos saber que clases necesitamos implementar,


sus atributos, métodos y cómo van a interactuar.

Constructores. [8]
Cuando se construye un objeto es necesario inicializar sus variables (atributos) con
valores coherentes. La solución en los lenguajes orientados a objetos es emplear los

Departamento de Sistemas y Computación Página 29


constructores. Un constructor es un método perteneciente a la clase que posee unas
características especiales:
 Se llama igual que la clase.
 No devuelve nada, ni siquiera void.
 Pueden existir varios (respetando ciertas reglas).
 Tan sólo uno se ejecutará, al crear un objeto de la clase.

Dentro del código de un constructor, suele existir inicializaciones de variables y


objetos, para conseguir que el objeto sea creado con dichos valores iniciales.

Para definir los constructores se emplea la siguiente sintaxis:

[modifVisibilidad] nombreConstructor (listaParámetros)


{
}

Para modifVisibilidad se aplica las mismas normas que para atributos y métodos:

public: indica que es un método accesible a través de una instancia del objeto.
private: indica que a través de una instancia no es accesible el método. Al
heredar el método se convierte en inaccesible.
protected: indica que a través de una instancia no es accesible el método. Al
heredar si se puede usar desde la clase derivada.
Sin especificar: indica visibilidad de paquete, se puede acceder a través de
una instancia, pero sólo de clases que se encuentren en el mismo paquete.

nombreConstructor debe de coincidir con el nombre de la clase.

listaParámetros es la lista de los parámetros que tomará la función separados por


comas y definidos cada uno de ellos como:
tipo nombreParámetro

3.4 Procedimiento (Descripción)


3.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

3.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java NetBeans.

3.4.3 Desarrollo de la Práctica


En la presente práctica debemos implementar las clases Línea, Círculo, Punto,
ConversorDivisas y Fecha.

Departamento de Sistemas y Computación Página 30


Solo se implementará paso a paso la clase línea. Las demás deberá implementarlas el
alumno por cuenta propia.

Primer paso. Definición del problema


Se pide hacer un programa que pueda calcular la longitud de una línea y su pendiente.
Tal línea estará definida por las coordenadas de los vértices de sus extremos. Se
trabajará en un plano cartesiano.

Segundo paso. Identificación de la clase


Se identifican dos objetos: la línea y vértice. Por ahora solo modelaremos en una clase
el objeto línea. Según el enunciado, vemos que una línea está definida inicialmente
por cuatro valores: la coordenadas bidimensionales de los vértices: inicial (Xi,Yi) y
final (Xf,Yf). Entonces los atributos serán:

int Xi, Yi, Xf, Yf. Coordenadas de los vértices.

En el enunciado vemos que queremos obtener la longitud y la pendiente. Así, los


métodos que necesitamos implementar son:

float getLongitud(). Método que calcula la longitud según las coordenadas


de los vértices.

float getPendiente(). Método que calcula la pendiente según las


coordenadas de los vértices.

Línea(Xi,Yi,Xf,Yf). Y el constructor, que es el método que se invoca


automáticamente al crear un objeto y normalmente en él
se inicializar los valores de los atributos.

El diagrama UML de la clase línea es:

Linea
int Xi
int Yi
int Xf
int Yf
Linea(int xi, int yi, int xf, int yf)
double getLongitud()
double getPendiente()

Tercer paso. Codificación de la clase en netbeans


Iniciamos nebeans, elegimos la opción “FileNew Project”. Creamos una
aplicación java. Le damos el nombre de “appLínea” al proyecto. Damos clic en el
botón “Finish” y el proyecto se ha creado.

Departamento de Sistemas y Computación Página 31


Si es el único proyecto podemos saltar este paso. En otro caso, damos clic derecho
sobre el nombre del proyecto y en el menú contextual seleccionamos “Set as Main
Project”. El nombre del proyecto debe ponerse en negritas.

Cuarto paso. Crear la clase Linea


En el menú de proyectos que está a la izquierda, expandemos el proyecto hasta ver el
paquete applinea y sobre este damos clic derecho y del menú contextual
seleccionamos New y luego Java Class. Le damos el nombre de Linea a la nueva
clase y clic en el botón “Finish”:

Quinto paso. Codificar la clase Linea


Seleccionamos la pestaña de edición llamada “Linea.java” y escribimos el código:

Linea.java
package applinea;

public class Linea {

int Xi;
int Yi;
int Xf;
int Yf;

Linea(int xi, int yi, int xf, int yf) {


this.Xi = xi;
this.Yi = yi;
this.Xf = xf;
this.Yf = yf;
}

double getLongitud() {
return java.lang.Math.sqrt((Xf-Xi)*(Xf-Xi)+(Yf-Yi)*(Yf-Yi));
}

double getPendiente() {
return (double) (Yf - Yi) / (Xf - Xi);
}
}

Sexto paso. Editar la clase principal


Ahora debemos crear un objeto de la clase Linea, le damos valores iniciales según
las coordenadas de los vértices y luego ejecutar algunos de sus métodos.

En el ejemplo, definimos dos variables, donde guardaremos los resultados que nos
devuelva el objeto. Después creamos el objeto línea dándole como parámetro los
valores de los vértices que acotan la línea: desde el vértice inicial (3, 5) hasta el vértice
final (7,8). Luego realizamos los cálculos de longitud y pendiente y al final
imprimimos los resultados. Seleccionamos la pestaña de edición llamada
“AppLinea.java” y escribimos:

Departamento de Sistemas y Computación Página 32


AppLinea.java
package applinea;

public class AppLinea {


public static void main(String[] args) {
// Definimos variables
double longitud;
double m;
// Creamos el objeto
Linea linea = new Linea(3, 5, 7, 8);

// Envíamos mensajes al objeto invocando sus métodos


longitud = linea.getLongitud();
m = linea.getPendiente();

// Imprimimos los resultados


System.out.print("Línea desde ");
System.out.print("(" + linea.Xi + ", " + linea.Yi + ")");
System.out.println(" hasta (" + linea.Xf + ", " +
linea.Yf + ") tiene:");

System.out.println("\t Longitud: " + longitud);


System.out.println("\t Pendiente: " + m);
}
}

Séptimo paso. Compilar y Ejecutar


Ahora compilamos y ejecutamos el programa, dando clic en el icono , y obtenemos:

Reto.
Ahora cree las clases que nos quedan pendientes: Círculo, Punto, ConversorDivisas
y Fecha. Recuerde que es un proyecto por cada clase

3.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
los diagramas de clases, el código fuente y capturas de pantalla de la ejecución de
cada programa.

3.5 Resultados y Conclusiones


Con ésta práctica, el alumno entenderá la importancia de los métodos constructores y
reforzará las bases del paradigma de programación orientada a objetos.

Departamento de Sistemas y Computación Página 33


Practica 4. juego de tres en raya (gato).
4.1 Introducción
La presente práctica ayuda a reforzar los contenidos de la Unidad II: Clases y
objetos de los subtemas 2.3 Referencia al objeto actual, 2.4 Métodos: declaración,
mensajes, paso de parámetros, retorno de valores, 2.5 Constructores y
destructores declaración, uso y aplicaciones, del programa de estudios de la materia
de Programación Orientada a Objetos, desarrollando la competencia específica:
“Aplica los conceptos de clases y objetos en el desarrollo de programas para
solución de problemas de acuerdo al paradigma orientado a objetos”.

4.2 Objetivo (Competencia)


Repasar los diagramas de clase en UML al analizar el juego de tres en raya (gato).
Elabore los diagramas de clase y luego impleméntelo en NetBeans.

4.3 Fundamento
Otros diagramas muy importantes en uml serían los diagramas de secuencias, pues a
través de ellos le indicamos al programador como deben interactuar los objetos para
cumplir con los objetivos del sistema.

Diagramas de Secuencias
Un diagrama de secuencias muestra la interacción de un conjunto de objetos de una
aplicación a través del tiempo. La idea primordial es que las interacciones entre los
objetos se realizan en una secuencia establecida y que la secuencia se toma su tiempo
en ir del principio al fin. Al momento de crear un sistema tendrá que especificar la
secuencia, y para ello, utilizará el diagrama correspondiente.

Para ver cómo usar el PlantUML en la generación de los diagramas de secuencias,


consulte la guía de referencia de PlantUml [6] a partir de la página 1.

4.4 Procedimiento (Descripción)


4.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

4.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java (IDE) NetBeans.
 Extensión (plugin) para netbeans plantUML
 Herramienta Graphviz

Departamento de Sistemas y Computación Página 34


4.4.3 Desarrollo de la Práctica
Esta práctica es un poco más larga y se divide en pasos, por lo que se sugiere se realice
en varias sesiones.

Paso 1. Crear el proyecto en NetBeans


Iniciamos netbeans, elegimos la opción “FileNew Project”. Creamos una
aplicación java. Le damos el nombre de “tresEnRaya” al proyecto.

Después de generarlo, lo establecemos como el proyecto principal.

Paso 2. Crear los diagramas UML


En el nombre del proyecto damos clic derecho y del menú emergente seleccionamos
“New” y del nuevo menú elegimos “New PlantUML Diagram”

Departamento de Sistemas y Computación Página 35


Diagrama de actividades
Primero creamos el diagrama de actividades, donde expresamos a grandes rasgos el
objetivo principal de la aplicación.

Código para generar el diagrama de actividades en PlantUML:

DiagramaActividades.puml
@startuml
title "Diagrama de Actividades"
(*)--> "Se registran los jugadores"
--> "Aleatoriamente se asigna la ficha y turno"
--> "Se prepara el tablero"
--> "Inicia la partida"

if "Empataron?" then
-left-->[si] "Empate, no hay ganador!"
--> (*)
else
if "Gano el jugador 1?" then
-->[si] "Felicidades ganaron las 'X' "
-->(*)
else
-right-->[no] "Felicidades ganaron las 'O' "
--> (*)
endif
endif

@enduml

Departamento de Sistemas y Computación Página 36


Diagrama de actividades resultante:

Diagrama de casos de uso


Este diagrama muestra para que usaríamos la aplicación. Repetimos el paso dos para
generar un nuevo archivo de PlantUML y lo nombramos DiagramaCasosUso.puml.
Escribe el siguiente código para generar el diagrama de casos de uso:

DiagramaCasosUso.puml
@startuml
title "Diagrama de Casos de Uso"
left to right direction
skinparam packageStyle rect
actor Jugador_1
actor Jugador_2
rectangle Juego {

Departamento de Sistemas y Computación Página 37


Jugador_1 -- (Dar nombre)
(Dar nombre) -- Jugador_2
Jugador_1 -- (comenzar juego)
(comenzar juego) -- Jugador_2
(comenzar juego) .> (turno y ficha aleatorio) : include
(comenzar juego) .> (preparar tablero) : include
Jugador_1 -- (Turno jugada)
(Turno jugada) -- Jugador_2
}
@enduml

Diagrama de casos de uso resultante:

Diagrama clases
Este diagrama muestra las clases que usaremos para modelar la aplicación. Repetimos
el paso dos para generar un nuevo archivo de PlantUML y lo nombramos
DiagramaClases.puml. Escribe el siguiente código para crear el diagrama de clases:

DiagramaClases.puml
@startuml
class Jugador {
-nombre: String
-ficha: char
+Jugador(nombre: String, ficha: char)
+String getNombre()
+char getFicha()
}
class Tablero {
-casilla: char[9]
-numJugada: int
+Tablero()

Departamento de Sistemas y Computación Página 38


+void muestraTablero()
+void marcaCasilla(ficha: char)
+boolean hayEmpate()
+boolean yaGano(char ficha)
}
+class App {
-jugadorA: Jugador
-jugadorB: Jugador
-tablero: Tablero
-nombre_A: String
-nombre_B: String
-teclado: Scanner
+void main(args: String[])
}
@enduml

Diagrama de clases resultante:

Diagrama de secuencias
Este diagrama muestra cómo interactúan los objetos entre sí a través del tiempo.
Repetimos el paso dos para generar un nuevo archivo de PlantUML y lo nombramos
DiagramaSecuencias.puml. El siguiente código crear el diagrama de secuencias:

DiagramaSecuencias.puml
@startuml
Actor Usuario
Usuario-> App : nombres 1 y 2
activate App
App -> App: Elegir quien comienza
deactivate App
group repetir

Departamento de Sistemas y Computación Página 39


App->Tablero: Mostrar tablero
activate Tablero
deactivate Tablero
App->Jugador_1: Solicita Nombre
Jugador_1->App: Devuelve Nombre
App->Tablero: Marcar casilla
activate Tablero
Tablero-->Jugador_1: Solictita tipo ficha
Jugador_1->Tablero: Devuelve tipo de ficha
Tablero->Usuario: Solicita elegir casilla
Usuario->Tablero: Devuelve num Casilla a marcar
deactivate Tablero
alt
App->Tablero: Gana X?
activate Tablero
Tablero->Tablero: Verificar reglas
rnote over Tablero
"Ganan las X"
endrnote
Tablero->Tablero: Muestra Tablero
destroy Tablero
end
App->Tablero: Mostrar tablero
activate Tablero
deactivate Tablero
App->Jugador_2: Solicita Nombre
Jugador_2->App: Devuelve Nombre
App->Tablero: Marcar casilla
activate Tablero
Tablero-->Jugador_2: Solictita tipo ficha
Jugador_2->Tablero: Devuelve tipo de ficha
Tablero->Usuario: Solicita elegir casilla
Usuario->Tablero: Devuelve num Casilla a marcar
deactivate Tablero
alt
App->Tablero: Gana O?
activate Tablero
Tablero->Tablero: Verificar reglas
rnote over Tablero
"Ganan las O"
endrnote
Tablero->Tablero: Muestra Tablero
destroy Tablero
end
alt
App->Tablero: Hay empate?
activate Tablero
Tablero->Tablero: Verificar reglas
return listo
end
end
rnote over App
"Hay Empate"
endrnote
@enduml

Departamento de Sistemas y Computación Página 40


Diagrama de secuencias resultante:

Departamento de Sistemas y Computación Página 41


Paso 3. Codificar las clases
En el menú de proyectos que está a la izquierda, expandimos el proyecto hasta ver el
paquete tresenraya y sobre este damos clic derecho y del menú contextual
seleccionamos New y luego Java Class. Le damos el nombre de Jugador a la nueva
clase y clic en el botón “Finish” y escribimos el siguiente código:

Jugador.java
package tresenraya;
public class Jugador {
String nombre;
char ficha;

public Jugador(String nombre, char ficha) {


this.nombre = nombre;
this.ficha = ficha;
}

public String getNombre() {


return nombre;
}

public char getFicha() {


return ficha;
}
}

Agregamos otra nueva clase con el nombre de Tablero. Después de crearla


escribimos el código:

Tablero.java
package tresenraya;
import java.util.Scanner;

public class Tablero {


char[] casilla;
int numJugadas;

public Tablero() {
casilla = new char[9];
numJugadas = 0;
for (int i = 0; i < 9; i++) {
casilla[i] = (char) (49 + i);
}
}

void muestraTablero() {
System.out.println("");
for (int i = 1; i < 10; i++) {
System.out.print(casilla[i - 1] + " ");
if (i % 3 == 0) {
System.out.println("");
}
}

Departamento de Sistemas y Computación Página 42


}

void marcaCasilla(char ficha) {


int n = -1;
Scanner teclado = new Scanner(System.in);

do {
n = teclado.nextInt();
if (n<1 || n>9) {
System.out.print("Casilla no válida. Introduce otro
valor: ");
continue;
}

if (casilla[n - 1] == 'X' || casilla[n - 1] == 'O') {


System.out.print("Casilla ocupada. Introduce otro
valor: ");
} else {
break;
}
} while (true);

casilla[n - 1] = ficha;
numJugadas++;
}

boolean hayEmpate() {
return numJugadas > 8;
}

boolean yaGano(char ficha) {


boolean gano = false;

if (ficha == casilla[0] && ficha == casilla[1] && ficha ==


casilla[2]) {
gano = true;
}
if (ficha == casilla[3] && ficha == casilla[4] && ficha ==
casilla[5]) {
gano = true;
}
if (ficha == casilla[6] && ficha == casilla[7] && ficha ==
casilla[8]) {
gano = true;
}

if (ficha == casilla[0] && ficha == casilla[3] && ficha ==


casilla[6]) {
gano = true;
}
if (ficha == casilla[1] && ficha == casilla[4] && ficha ==
casilla[7]) {
gano = true;
}
if (ficha == casilla[2] && ficha == casilla[5] && ficha ==
casilla[8]) {

Departamento de Sistemas y Computación Página 43


gano = true;
}

if (ficha == casilla[0] && ficha == casilla[4] && ficha ==


casilla[8]) {
gano = true;
}
if (ficha == casilla[2] && ficha == casilla[4] && ficha ==
casilla[6]) {
gano = true;
}
return gano;
}
}

Y por último editamos la clase principal, que se llama TresEnRaya:

TresEnRaya.java
package tresenraya;
import java.util.Scanner;

public class TresEnRaya {

public static void main(String[] args) {


Jugador jugadorA, jugadorB;
Tablero tablero = new Tablero();
String nombre_A, nombre_B;
Scanner teclado = new Scanner(System.in);

System.out.print("Nombre de jugador: ");


nombre_A = teclado.next();
System.out.print("Nombre del otro jugador: ");
nombre_B = teclado.next();
if (Math.random() < 0.5f) {
jugadorA = new Jugador(nombre_A, 'X');
jugadorB = new Jugador(nombre_B, 'O');
} else {
jugadorA = new Jugador(nombre_B, 'X');
jugadorB = new Jugador(nombre_A, 'O');
}
System.out.print("El primero en jugar es " + jugadorA.getNombre());
System.out.println(" con la ficha " + jugadorA.getFicha());
System.out.print("El segundo en jugar es " + jugadorB.getNombre());
System.out.println(" con la ficha " + jugadorB.getFicha());
System.out.println("Comenzamos!!!");

do {
tablero.muestraTablero();
System.out.print(jugadorA.getNombre() + " en que casilla pondrás
una X? ");
tablero.marcaCasilla(jugadorA.getFicha());
if (tablero.yaGano(jugadorA.getFicha())) {
System.out.println("El ganador es " + jugadorA.getNombre());
tablero.muestraTablero();
System.exit(0);

Departamento de Sistemas y Computación Página 44


}
tablero.muestraTablero();
System.out.print(jugadorB.getNombre() + " en que casilla pondras
una O? ");
tablero.marcaCasilla(jugadorB.getFicha());
if (tablero.yaGano(jugadorB.getFicha())) {
System.out.println("El ganador es " + jugadorB.getNombre());
tablero.muestraTablero();
System.exit(0);
}
} while (!tablero.hayEmpate());
System.out.println("Empate!!!, nadie gana");
}
}

Paso 4. Compilar y ejecutar el código


Ahora compilamos y ejecutamos el programa, dando clic en el icono , y obtenemos:

run:
Nombre de jugador: Andrés
Nombre del otro jugador: Donald
El primero en jugar es Andrés con la ficha X
El segundo en jugar es Donald con la ficha O
¡Comenzamos!!!

1 2 3
4 5 6
7 8 9
Andrés en que casilla pondrás una X? 5

1 2 3
4 X 6
7 8 9
Donald en que casilla pondrás una O? 8

1 2 3
4 X 6
7 O 9
Andrés en que casilla pondrás una X? 1

X 2 3
4 X 6
7 O 9
Donald en que casilla pondrás una O? 9

X 2 3
4 X 6
7 O O
Andrés en que casilla pondrás una X? 7

X 2 3
4 X 6
X O O
Donald en que casilla pondrás una O? 4

Departamento de Sistemas y Computación Página 45


X 2 3
O X 6
X O O
Andrés en que casilla pondrás una X? 3
El ganador es Andrés

X 2 X
O X 6
X O O
BUILD SUCCESSFUL (total time: 4 minutes 2 seconds)

Reto.
Ahora implemente una variante del “juego de oso”, que es parecido del juego tres en
raya. El juego consiste en lo siguiente:

 Es un juego para dos jugadores.


 A cada uno se le asigna una letra: la O y la S.
 Se juega en una cuadricula de 3 X 3.
 Por turnos, los jugadores van escribiendo ya sea la O, o la S en las cuadrículas.
 Gana el primero en formar la palabra OSO, en cualquier dirección: horizontal,
vertical, diagonal.
 Si se agotan los espacios y nadie forma la palabra, es un empate.

4.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
los diagramas de actividades, casos de uso, clases y de secuencias en PlantUML el
código fuente y capturas de pantalla de la ejecución del programa.

4.5 Resultados y Conclusiones


Al repensar un problema similar, el alumno tiene claro cómo atacarlo y representar la
solución en diagramas UML.

Departamento de Sistemas y Computación Página 46


Practica 5. Uso de herencia.
5.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad III: Herencia de
los subtemas 3.1 Definición: clase base, clase derivada, 3.2 Clasificación: herencia
simple, herencia múltiple, 3.3 Reutilización de miembros heredados, 3.4
Referencia al objeto de la clase base, 3.5 Constructores y destructores en clases
derivadas y 3.6 Redefinición de métodos en clases derivadas, del programa de
estudios de la materia de Programación Orientada a Objetos, desarrollando la
competencia específica: “Identifica y aplica relaciones de herencia en clases
derivadas para reutilizar los miembros de una clase base en el desarrollo de
aplicaciones”.

5.2 Objetivo (Competencia)


Elaborar un programa que use la herencia en java, realizando programa que
implemente las clases: Figura (clase base), Ovalo (clase derivada) y Línea (clase
derivada), definiendo sus atributos, sus métodos y especificando la herencia.

En la clase figura se especifica el rectángulo que contendrá al objeto. Se hace dando


las coordenadas de los vértices de la diagonal.

La clase línea hereda de la Clase Figura y solo debe calcular su longitud. La clase
ovalo hereda de la Clase Figura y solo debe calcular su área.

Al momento de declarar los objetos, se debe especificar las coordenadas del


rectángulo que los contendrá.

5.3 Fundamento
La herencia es un mecanismo que hace posible que una clase herede todo el
comportamiento y atributos de otra clase. Con la herencia, todas las clases se
acomodan en una jerarquía estricta, las creadas por el usuario y las que provienen de
la librería de clases de java y otras librerías. [9]

Departamento de Sistemas y Computación Página 47


La herencia es una parte integral de Java (y de todos los lenguajes de PO0 en general).
Cuando se hereda, se dice: "Esta clase nueva es como esa clase vieja". Se dice esto
en el código dando el nombre de la clase, como siempre, pero antes de abrir el
paréntesis del cuerpo de la clase, se pone la palabra clave extends seguida del nombre
de la clase base. Cuando se hace esto, automáticamente se tienen todos los datos
miembro y métodos de la clase base. [10]
En uml, la herencia se simboliza con una flecha que sale de la subclase y llega a la
clase base:
Diagrama Código en java

class Subclase extends Base


{

5.4 Procedimiento (Descripción)


5.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

5.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java (IDE) NetBeans.
 Extensión (plugin) para netbeans plantUML
 Herramienta Graphviz

5.4.3 Desarrollo de la Práctica


Primero crearemos el diagrama de clases, donde expresamos la herencia y después
generamos el programa.

Paso 1. Crear el proyecto en NetBeans


Iniciamos nebeans, elegimos la opción “FileNew Project”. Creamos una
aplicación java. Le damos el nombre de “appFiguras” al proyecto.

Departamento de Sistemas y Computación Página 48


Después de generarlo, lo establecemos como el proyecto principal.

Paso 2. Crear el diagrama UML de clases


En el nombre del proyecto damos clic derecho y del menú emergente seleccionamos
“New” y del nuevo menú elegimos “New PlantUML Diagram”

Diagrama de clases
En el diagrama de clases especificamos cual es la clase base y cuáles son las
subclases. Código para generar el diagrama de clases en PlantUML:

DiagramaClases.puml
@startuml
class Figura {
+x1: int
+y1: int
+x2: int
+y2: int
+Figura(a: int,b: int,c: int,d: int)
}

class Linea {
+double calculaLongitud()
}

class Ovalo {
+double calculaArea()
}

Figura <|-- Linea


Figura <|-- Ovalo
@enduml

Departamento de Sistemas y Computación Página 49


Diagrama de clases resultante:

Paso 3. Codificar las clases


En el menú de proyectos que está a la izquierda, expandimos el proyecto hasta ver el
paquete appFiguras y sobre este damos clic derecho y del menú contextual
seleccionamos New y luego Java Class. Le damos el nombre de Figura a la nueva
clase y clic en el botón “Finish” y escribimos el siguiente código:

Figura.java
package appfiguras;

public class Figura {

int x1;
int y1;
int x2;
int y2;

public Figura(int x1, int y1, int x2, int y2) {


this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
}

Departamento de Sistemas y Computación Página 50


Agregamos otra nueva clase con el nombre de Linea. Después de crearla escribimos
el código:

Linea.java
package appfiguras;

public class Linea extends Figura {

public Linea(int x1, int y1, int x2, int y2) {


super(x1, y1, x2, y2);
}

double calculaLongitud() {
return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
}

Agregamos la clase con el nombre de Ovalo. Después de crearla escribimos el código:

Ovalo.java
package appfiguras;

public class Ovalo extends Figura {

public Ovalo(int x1, int y1, int x2, int y2) {


super(x1, y1, x2, y2);
}

double calculaArea() {
return Math.PI * Math.pow(x1 - x2, 2) / 4;
}
}

Y por último editamos la clase principal, que se llama AppFiguras:

AppFiguras.java
package appfiguras;

public class AppFiguras {

public static void main(String[] args) {


Linea linea = new Linea(10, 150, 120, 25);
Ovalo ovalo = new Ovalo(5, 10, 105, 60);
System.out.print("La longitud de la línea es: ");
System.out.println(linea.calculaLongitud());
System.out.println("");
System.out.print("El área del óvalo es: ");
System.out.println(ovalo.calculaArea());
}

Departamento de Sistemas y Computación Página 51


Paso 4. Compilar y ejecutar el código
Ahora compilamos y ejecutamos el programa, dando clic en el icono , y obtenemos:

run:
La longitud de la línea es: 166.50825805346713

El área del óvalo es: 3926.9908169872415

Reto.
Para complementar el ejercicio, agregue un método a la clase Figura para imprimir
los vértices del rectángulo.

Después use dicho método en la clase principal para imprimir los vértices de cada
figura.

5.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
los diagramas de actividades, casos de uso, clases y de secuencias en PlantUML el
código fuente y capturas de pantalla de la ejecución del programa.

5.5 Resultados y Conclusiones


Con ésta práctica, el alumno comenzará a comprender el uso de la herencia en la
programación orientada a objetos.

Departamento de Sistemas y Computación Página 52


Practica 6. Facturas en una zapatería
(Herencia 2).
6.1 Introducción
La presente práctica ayuda a reforzar los contenidos de la Unidad III: Herencia de
los subtemas 3.1 Definición: clase base, clase derivada, 3.2 Clasificación: herencia
simple, herencia múltiple, 3.3 Reutilización de miembros heredados, 3.4
Referencia al objeto de la clase base, 3.5 Constructores y destructores en clases
derivadas y 3.6 Redefinición de métodos en clases derivadas, del programa de
estudios de la materia de Programación Orientada a Objetos, desarrollando la
competencia específica: “Identifica y aplica relaciones de herencia en clases
derivadas para reutilizar los miembros de una clase base en el desarrollo de
aplicaciones”.
6.2 Objetivo (Competencia)
Elaborar un programa que muestra las ventajas de la programación orientada a
objetos, desarrollando una solución de facturas para una zapatería. Analice el
problema de generar notas en una zapatería. Elabore los diagramas UML en PlantUml
y escriba el código en NetBeans.

6.3 Fundamento
En la presente práctica se utilizan los conceptos de agregación y composición para
modelar la zapatería. A continuación, se abordan de manera breve dichos conceptos:

Abstracción. [11]
consiste en centrarse en los aspectos esenciales de una entidad e ignorar sus
propiedades accidentales. En el desarrollo de sistemas esto significa centrarse en lo
que es y lo que hace un objeto antes de decidir cómo debería ser implementado. La
capacidad de utilizar herencia y polimorfismo proporciona una potencia adicional.

El uso de la abstracción durante el análisis significa tratar solamente conceptos del


dominio de la aplicación y no tomar decisiones de diseño o de implementación antes
de haber comprendido el problema.

Un uso adecuado de la abstracción permite utilizar el mismo modelo para el análisis,


diseño de alto nivel, estructura del programa, estructura de una base de datos y
documentación. Un estilo de diseño independiente del lenguaje pospone los detalles
de programación hasta la fase final, relativamente mecánica del desarrollo.

Modelado Orientado a Objetos. [11]


El Modelado y Diseño Orientado a Objetos se funda en pensar acerca de problemas a
resolver empleando modelos que se han organizado tomando como base conceptos
del mundo real.

Departamento de Sistemas y Computación Página 53


La técnica de Modelado de Objetos (Object Modeling Technique OMT) se basa en
un conjunto de conceptos que definen que es Orientación a Objetos y una notación
gráfica independiente.

La tecnología orientada a objetos propone una forma de pensar de modo abstracto


acerca de problemas a resolver empleando conceptos del mundo real y no conceptos
de computadoras. La notación gráfica propuesta ayuda al desarrollo de software
visualizando el problema sin recurrir en forma prematura a la implementación.

Es una premisa básica que los errores de las primeras fases del proceso de desarrollo
tienen mucha influencia sobre el producto final y también sobre el tiempo requerido
para finalizar.

El beneficio principal del desarrollo orientado a objetos no es reducir el tiempo de


desarrollo, más bien consiste en que las iteraciones subsiguientes son más rápidas y
más fáciles que empleando un desarrollo convencional porque las revisiones están
más localizadas. La práctica muestra que suelen ser necesarias menos iteraciones
porque se descubren y se corrigen más problemas durante el desarrollo.

La esencia del desarrollo orientado a objetos es la identificación y organización de


conceptos (objetos) del dominio de la aplicación. Tales conceptos suelen organizarse
en clases.

Una clase es una abstracción que describe propiedades importantes para una
aplicación y que ignora el resto. La selección de clases es arbitraria y depende de la
aplicación.

Agregación.
En ocasiones una clase puede estar conformada por otras clases; este es un tipo
especial de relación conocida agregación. Los componentes y la clase son una
asociación que conforman un todo. Y los componentes no son esenciales para definir
la clase. Por ejemplo, una mesa puede tener o no un mantel.

Se simboliza con una línea que conecta los componentes con la clase mediante un
rombo sin relleno. Ejemplo:

Departamento de Sistemas y Computación Página 54


Composición
En una composición los componentes son primordiales para la definición de la clase.
El símbolo de una composición es el mismo que de una agregación, pero el rombo
está relleno. Por ejemplo, una mesa debe tener patas:

6.4 Procedimiento (Descripción)


6.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

6.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java (IDE) NetBeans.
 Extensión (plugin) para netbeans plantUML
 Herramienta Graphviz

Departamento de Sistemas y Computación Página 55


6.4.3 Desarrollo de la Práctica
Primeramente, realizamos el análisis del sistema a modelar. Podemos realizarlo de
manera informal y usando dibujos y esquemas en medida de lo posible.

Descripción del negocio de la Zapatería.


 Para iniciar el negocio primero debemos tener zapatos que vender.
 Luego contratamos empleados (vendedores, almacenistas y cajeros).
 Podemos tener clientes que no piden factura, y clientes que solicitan factura
(deberán estar registrados).
 Los clientes son atendidos por los empleados de la zapatería.
 Les muestran tallas y modelos que traen de la bodega
 Cuando el cliente decide comprar uno o más zapatos se le extiende una factura
con los datos de los zapatos.
 A los clientes registrados se les otorga un crédito y un descuento, según su
comportamiento.

Diagrama esquemático.

CLIENTES

El empleado le cobra al cliente


El cliente solicita
zapatos
ZAPATOS

El empleado pide
Zapatos de la
bodega
EMPLEADOS

Zapatos vendidos Datos del zapato

FACTURAS

Departamento de Sistemas y Computación Página 56


Identificación de clases

CLIENTE DE NOTA
CLIENTE DE FACTURA

EMPLEADO

ZAPATO

FACTURA

DETALLE

Diagrama de clases

Departamento de Sistemas y Computación Página 57


Codificación
Ahora codificamos las clases. Iniciamos netbeans, elegimos la opción “FileNew
Project”. Creamos una aplicación java. Le damos el nombre de
“aplicacionZapateria” al proyecto.

En el menú de proyectos que está a la izquierda, expandimos el proyecto hasta ver el


paquete aplicacionzapateria y sobre este damos clic derecho y del menú contextual
seleccionamos New y luego Java Class. Le damos el nombre de Jugador a la nueva
clase y clic en el botón “Finish” y escribimos el siguiente código:

Cliente.java
package aplicacionzapateria;
public class Cliente {
String sNombre;

public String getsNombre() {


return sNombre;
}

public void setsNombre(String sNombre) {


this.sNombre = sNombre;
}
}

Usando la herencia, agregamos la clase derivada ClienteNota. Después de crearla


escribimos el código:

ClienteNota.java
package aplicacionzapateria;

public class ClienteNota extends Cliente{


String formaPago;
Boolean buenaAtencion;
Boolean buenPrecio;
}

También usamos la herencia para agregar la clase derivada ClienteFactura. Después


de crearla escribimos el código:

ClienteFactura.java
package aplicacionzapateria;

public class ClienteFactura extends Cliente {


String sRFC;
float nCredito;
float nDescuento;

public ClienteFactura(String sRFC) {


this.sRFC = sRFC;
}

Departamento de Sistemas y Computación Página 58


public float getnCredito() {
return nCredito;
}

public void setnCredito(float nCredito) {


this.nCredito = nCredito;
}

public float getnDescuento() {


return nDescuento;
}

public void setnDescuento(float nDescuento) {


this.nDescuento = nDescuento;
}
}

Agregamos la clase con el nombre de Vendedor. Después de crearla escribimos el


código:

Vendedor.java
package aplicacionzapateria;

public class Vendedor {


String sNombre;

public String getsNombre() {


return sNombre;
}

public void setsNombre(String sNombre) {


this.sNombre = sNombre;
}
}

Agregamos la clase con el nombre de Zapato. Después de crearla escribimos el


código:

Zapato.java
package aplicacionzapateria;
public class Zapato {
String sModelo;
int nTalla;
String sColor;
float nPrecio;

public String getsModelo() {


return sModelo;
}

public void setsModelo(String sModelo) {


this.sModelo = sModelo;
}

Departamento de Sistemas y Computación Página 59


public int getnTalla() {
return nTalla;
}

public void setnTalla(int nTalla) {


this.nTalla = nTalla;
}

public String getsColor() {


return sColor;
}

public void setsColor(String sColor) {


this.sColor = sColor;
}

public float getnPrecio() {


return nPrecio;
}

public void setnPrecio(float nPrecio) {


this.nPrecio = nPrecio;
}
}

Agregamos la clase Factura y la clase Detalle en un solo archivo. Después de crearla


escribimos el código:

Factura.java
package aplicacionzapateria;

package aplicacionzapateria;

public class Factura {

private int nFolio;


private ClienteFactura Cliente;
private String sFecha;
private float nTotal;
private float nIva;
private float nSubtotal;
private Vendedor Vendedor;
private int nItems;
Detalle[] vDetalle;

public Factura(int nItems) {


this.nItems = nItems;
vDetalle = new Detalle[nItems];

for (int i = 0; i < vDetalle.length; i++) {


vDetalle[i] = new Detalle();
}
}

Departamento de Sistemas y Computación Página 60


float Cobrar() {
for (int i = 0; i < vDetalle.length; i++) {
nSubtotal += vDetalle[i].nCantidad *
vDetalle[i].Zapato.nPrecio;
}
nIva = nSubtotal * 0.16f;

nTotal = (nSubtotal + nIva);

nTotal = nTotal - nTotal * Cliente.nDescuento;


return nTotal;
}

void verNota() {
System.out.println("Folio: " + nFolio);
System.out.println("Cliente nombre: " +
Cliente.getsNombre());
System.out.println("Fecha: " + sFecha);
System.out.println("Total: " + nTotal);
System.out.println("Detalle:");

System.out.println("\t Modelo \t Precio \t Cantidad");


for (int i = 0; i < vDetalle.length; i++) {
Detalle detalle = vDetalle[i];
System.out.printf("\t %s \t\t $%g \t %d
\n",detalle.Zapato.sModelo,detalle.Zapato.nPrecio,detalle.nCantidad
);
}

public int getnFolio() {


return nFolio;
}

public void setnFolio(int nFolio) {


this.nFolio = nFolio;
}

public ClienteFactura getCliente() {


return Cliente;
}

public void setCliente(ClienteFactura Cliente) {


this.Cliente = Cliente;
}

public String getsFecha() {


return sFecha;
}

public void setsFecha(String sFecha) {


this.sFecha = sFecha;
}

Departamento de Sistemas y Computación Página 61


public float getnTotal() {
return nTotal;
}

public float getnIva() {


return nIva;
}

public float getnSubtotal() {


return nSubtotal;
}

public Vendedor getVendedor() {


return Vendedor;
}

public void setVendedor(Vendedor Vendedor) {


this.Vendedor = Vendedor;
}
}

class Detalle {

Zapato Zapato;
int nCantidad;
}

Y por último editamos la clase principal, que se llama AplicacionZapateria:

AplicacionZapateria.java
package aplicacionzapateria;
public class AplicacionZapateria {
public static void main(String[] args) {
// Tener zapato
Zapato oZapato=new Zapato();

oZapato.setsModelo("Puma");
oZapato.nPrecio=300.5f;
oZapato.nTalla=23;
oZapato.sColor="Negro";

Zapato oZapato2=new Zapato();


oZapato2.setsModelo("Nike");
oZapato2.nPrecio=800.9f;
oZapato2.nTalla=26;
oZapato2.sColor="Azul";

//Tener Vendedor
Vendedor oVendedor=new Vendedor();
oVendedor.setsNombre("Mateo");

//Tener cliente
ClienteFactura oCliente=new ClienteFactura("MAT870512");
oCliente.setsNombre("Mateo");
oCliente.setnCredito(0f);

Departamento de Sistemas y Computación Página 62


oCliente.setnDescuento(0.1f);

//Hacer Factura
Factura oNota=new Factura(2);
oNota.setCliente(oCliente);
oNota.setVendedor(oVendedor);
oNota.setnFolio(1);
oNota.setsFecha("23-Dic-2018");

//Meter Detalle
oNota.vDetalle[0].Zapato=oZapato;
oNota.vDetalle[0].nCantidad=2;

oNota.vDetalle[1].Zapato=oZapato2;
oNota.vDetalle[1].nCantidad=5;

//Cobrar
oNota.Cobrar();

//Ver factura
oNota.verNota();
}
}

Ahora compilamos y ejecutamos el programa, dando clic en el icono , y obtenemos:

run:
Folio: 1
Cliente nombre: Mateo
Fecha: 23-Dic-2018
Total: 4808.142
Detalle:
Modelo Precio Cantidad
Puma $300.500 2
Nike $800.900 5

Reto:
Modifique el ejercicio para agregar la clase Persona y que de ella hereden las clases
Empleado y Clientes.

6.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
los diagramas de actividades, casos de uso, clases y de secuencias en PlantUML el
código fuente y capturas de pantalla de la ejecución del programa.

6.5 Resultados y Conclusiones


Con ésta práctica, el alumno comenzará a aplicar el paradigma del modelado
orientado a objetos, para, a partir de un problema del mundo real, realizar una
abstracción y llevarlo hasta la codificación en java.

Departamento de Sistemas y Computación Página 63


Practica 7. Generacion y aplicacion de
examenes (Herencia 3).
7.1 Introducción
La presente práctica ayuda a reforzar los contenidos de la Unidad III: Herencia de
los subtemas 3.1 Definición: clase base, clase derivada, 3.2 Clasificación: herencia
simple, herencia múltiple, 3.3 Reutilización de miembros heredados, 3.4
Referencia al objeto de la clase base, 3.5 Constructores y destructores en clases
derivadas y 3.6 Redefinición de métodos en clases derivadas, del programa de
estudios de la materia de Programación Orientada a Objetos, desarrollando la
competencia específica: “Identifica y aplica relaciones de herencia en clases
derivadas para reutilizar los miembros de una clase base en el desarrollo de
aplicaciones”.

7.2 Objetivo (Competencia)


Elaborar un programa que muestra las ventajas de la programación orientada a
objetos, desarrollando una solución para una escuela que apique exámenes. Analice
el problema de generar, aplicar y revisar exámenes de opción múltiple. Defina los
diagramas UML en PlantUml y escriba el código en NetBeans.

7.3 Fundamento
La fase del análisis es muy importante, así que repasaremos el análisis orientado a
objetos.

Definición.
El análisis orientado a objetos es el proceso que modela el dominio del problema
mediante la identificación y especificación de objetos semánticos que interaccionan
y se comportan de acuerdo a los requisitos del sistema [12]

Generalidades. [13]
 Permite describir el sistema en los mismos términos que el mundo real.
 Se centra en la comprensión del espacio (dominio) del problema.
 Difícil determinar dónde acaba el análisis orientado a objetos y dónde
comienza el diseño orientado a objetos.
 El objetivo es modelar la semántica del problema en términos de objetos
distintos pero relacionados.
 El análisis casa con el dominio del problema.
 Los objetos del dominio del problema representan cosas o conceptos
utilizados para describir el problema (objetos semánticos).
 Los objetos del dominio del problema tienen una equivalencia directa en el
entorno de la aplicación.

Departamento de Sistemas y Computación Página 64


 Se centra en la representación del problema.
 No existen reglas fijas para esta transformación.

7.4 Procedimiento (Descripción)


7.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

7.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java (IDE) NetBeans.
 Extensión (plugin) para netbeans plantUML.
 Herramienta Graphviz.

7.4.3 Desarrollo de la Práctica


Comenzaremos realizando un análisis con un enfoque orientado a objetos a la
descripción del sistema a modelar.

Descripción del proceso de aplicación de exámenes.


 Debemos tener materias definidas.
 Inscribimos algunos alumnos.
 Contratamos maestros.
 Generamos un examen de X unidad con N preguntas.
 Asociamos el examen con la materia, maestro y alumno.
 Creamos las preguntas con sus respectivos incisos y respuestas correctas.
 Creamos la hoja de respuestas para el respectivo examen.
 Aplicamos el examen.
 Revisamos el examen.
 Mostramos los resultados del examen.

Esquemas de aplicación de exámenes.

Ilustración 1. Elementos que intervienes y cómo interactúan.

Departamento de Sistemas y Computación Página 65


Ilustración 2.Identificación de objetos.

Ilustración 3. Relaciones entre objetos.

Ilustración 4. Analizando que atributos y métodos son necesarios.

Departamento de Sistemas y Computación Página 66


Ilustración 5. Reduciendo clases.

Ilustración 6. Descubriendo herencia, agregación y composición.

Departamento de Sistemas y Computación Página 67


Ilustración 7. Formalizando los tipos de datos y constructores

Ilustración 8. Revisión del modelo.

Ilustración 9. Reacomodo del diagrama inicial alineado con el diagrama de clases resultante.

Departamento de Sistemas y Computación Página 68


Codificación
Ahora codificamos las clases. Iniciamos netbeans, elegimos la opción “FileNew
Project”. Creamos una aplicación java. Le damos el nombre de
“aplicacionExamenes” al proyecto.

En el menú de proyectos que está a la izquierda, expandimos el proyecto hasta ver el


paquete aplicacionexamenes y sobre este damos clic derecho y del menú contextual
seleccionamos New y luego Java Class. Le damos el nombre de Materia a la nueva
clase y clic en el botón “Finish” y escribimos el siguiente código:

Materia.java
package appexamenes;

public class Materia {

String sTitulo;

public Materia(String sTitulo) {


this.sTitulo = sTitulo;
}

public String getsTitulo() {


return sTitulo;
}

public void setsTitulo(String sTitulo) {


this.sTitulo = sTitulo;
}
}

Agregamos la clase con el nombre de Persona. Después de crearla escribimos el


código:

Persona.java
package appexamenes;

public class Persona {


//Atributos
String sNombre;
String sRol;

//Constructor
public Persona(String sNombre, String sRol) {
this.sNombre = sNombre;
this.sRol = sRol;
}

//Métodos
public String getsNombre() {
return sNombre;
}

Departamento de Sistemas y Computación Página 69


public void setsNombre(String sNombre) {
this.sNombre = sNombre;
}

public String getsRol() {


return sRol;
}

public void setsRol(String sRol) {


this.sRol = sRol;
}
}

Agregamos la clase con el nombre de Pregunta. Después de crearla escribimos el


código:

Pregunta.java
package appexamenes;

public class Pregunta {


String sPregunta;
String sOpcion1;
String sOpcion2;
String sOpcion3;
int nOpcionCorrecta;

//Constructor
public Pregunta(String sPregunta, String sOpcion1, String
sOpcion2, String sOpcion3, int nOpcionCorrecta) {
this.sPregunta = sPregunta;
this.sOpcion1 = sOpcion1;
this.sOpcion2 = sOpcion2;
this.sOpcion3 = sOpcion3;
this.nOpcionCorrecta = nOpcionCorrecta;
}

//Métodos
public int getnOpcionCorrecta() {
return nOpcionCorrecta;
}

public void setnOpcionCorrecta(int nOpcionCorrecta) {


this.nOpcionCorrecta = nOpcionCorrecta;
}

public String getsOpcion1() {


return sOpcion1;
}

public void setsOpcion1(String sOpcion1) {


this.sOpcion1 = sOpcion1;
}

public String getsOpcion2() {


return sOpcion2;

Departamento de Sistemas y Computación Página 70


}

public void setsOpcion2(String sOpcion2) {


this.sOpcion2 = sOpcion2;
}

public String getsOpcion3() {


return sOpcion3;
}

public void setsOpcion3(String sOpcion3) {


this.sOpcion3 = sOpcion3;
}

public String getsPregunta() {


return sPregunta;
}

public void setsPregunta(String sPregunta) {


this.sPregunta = sPregunta;
}
}

Agregamos la clase con el nombre de Examen. Después de crearla escribimos el


código:

Examen.java
package aplicacionexamenes;

public class Examen {

int nUnidad;
int nTotalPreguntas;
Materia oMateria;
Persona oMaestro;
Persona oAlumno;
Pregunta[] vPregunta;

//Constructor
public Examen(int nUnidad, int nTotalPreguntas) {
this.nUnidad = nUnidad;
this.nTotalPreguntas = nTotalPreguntas;

vPregunta = new Pregunta[nTotalPreguntas];


for (int i = 0; i < vPregunta.length; i++) {
vPregunta[i] = new Pregunta("", "", "", "", 0);
}
}
}

Agregamos la clase con el nombre de HojaRespuesta. Después de crearla escribimos


el código:

Departamento de Sistemas y Computación Página 71


HojaRespuesta.java
package aplicacionexamenes;
import java.util.Scanner;

public class HojaRespuesta {

int[] vRespuestasAlumno;
float nCalificacion;
Examen oExamen;

public HojaRespuesta(Examen oExamen) {


this.oExamen = oExamen;
nCalificacion = 0;
vRespuestasAlumno = new int[5];

vRespuestasAlumno[0] = 0;
vRespuestasAlumno[1] = 0;
vRespuestasAlumno[2] = 0;
vRespuestasAlumno[3] = 0;
vRespuestasAlumno[4] = 0;
}

public float getnCalificacion() {


return nCalificacion;
}

public void setnCalificacion(float nCalificacion) {


this.nCalificacion = nCalificacion;
}

public Examen getoExamen() {


return oExamen;
}

public void setoExamen(Examen oExamen) {


this.oExamen = oExamen;
}

public int[] getvRespuestasAlumno() {


return vRespuestasAlumno;
}

public void setvRespuestasAlumno(int[] vRespuestasAlumno) {


this.vRespuestasAlumno = vRespuestasAlumno;
}

void aplicar() {
//Encabezado del examen
System.out.println("Materia: " + oExamen.oMateria.getsTitulo());
System.out.println("Maestro: " + oExamen.oMaestro.getsNombre());
System.out.println("Alumno: " + oExamen.oAlumno.getsNombre());
System.out.println("Unidad: " + oExamen.nUnidad);

//Aplicar las preguntas


Scanner teclado = new Scanner(System.in);
for (int i = 0; i < oExamen.nTotalPreguntas; i++) {

Departamento de Sistemas y Computación Página 72


System.out.println("Pregunta "+(i+1)+ ": " +
oExamen.vPregunta[i].getsPregunta());
System.out.println("\t 1) " +
oExamen.vPregunta[i].getsOpcion1());
System.out.println("\t 2) " +
oExamen.vPregunta[i].getsOpcion2());
System.out.println("\t 3) " +
oExamen.vPregunta[i].getsOpcion3());
System.out.print("\t ? : ");
this.vRespuestasAlumno[i] = teclado.nextInt();
}
}

void revisar() {
int buenas = 0;

// Comparar Clave vs resp del alumno


for (int i = 0; i < vRespuestasAlumno.length; i++) {
if (vRespuestasAlumno[i] ==
oExamen.vPregunta[i].nOpcionCorrecta) {
buenas++;
}
}
this.setnCalificacion(buenas);
}

void verResultado() {
System.out.println("Tuviste " + this.getnCalificacion() + "
aciertos!!!");
}
}

Y por último editamos la clase principal, que se llama AplicacionExamenes:

AplicacionExamenes.java
package aplicacionexamenes;

public class AplicacionExamenes {

public static void main(String[] args) {


// Definir Materia
Materia oMateria = new Materia("Historia de Dragon Ball");

// Definir Alumno
Persona oAlumno = new Persona("Gerardo Flores", "alumno");

// Definir Maestro
Persona oMaestro = new Persona("Roshi", "maestro");

// Crear examen de X unidad con N preguntas


Examen oExamen = new Examen(1, 5);

// Asociar el examen con la materia, alumno, maestro


oExamen.oMateria = oMateria;
oExamen.oAlumno = oAlumno;

Departamento de Sistemas y Computación Página 73


oExamen.oMaestro = oMaestro;

// Generar las N preguntas con sus respectivos incisos y


// respuestas correctas
oExamen.vPregunta[0].setsPregunta("¿Cuanto tardó en
aprender el kame-hame-ha?");
oExamen.vPregunta[0].setsOpcion1("10 años");
oExamen.vPregunta[0].setsOpcion2("30 años");
oExamen.vPregunta[0].setsOpcion3("80 años");
oExamen.vPregunta[0].setnOpcionCorrecta(3);

oExamen.vPregunta[1].setsPregunta("¿Nombre de la esposa de
Vegueta?");
oExamen.vPregunta[1].setsOpcion1("Milk");
oExamen.vPregunta[1].setsOpcion2("Bulma");
oExamen.vPregunta[1].setsOpcion3("Videl");
oExamen.vPregunta[1].setnOpcionCorrecta(2);

oExamen.vPregunta[2].setsPregunta("¿Quién le dio la esfera


de 4 estrellas ?");
oExamen.vPregunta[2].setsOpcion1("Piccolo");
oExamen.vPregunta[2].setsOpcion2("Son gohan");
oExamen.vPregunta[2].setsOpcion3("Ox Satan");
oExamen.vPregunta[2].setnOpcionCorrecta(2);

oExamen.vPregunta[3].setsPregunta("¿Que le regaló Roshi a Goku?");


oExamen.vPregunta[3].setsOpcion1("nube voladora");
oExamen.vPregunta[3].setsOpcion2("esfera del dragon");
oExamen.vPregunta[3].setsOpcion3("báculo sagrado");
oExamen.vPregunta[3].setnOpcionCorrecta(1);

oExamen.vPregunta[4].setsPregunta("¿Quién destruyó el
planeta Namekusein?");
oExamen.vPregunta[4].setsOpcion1("Cell");
oExamen.vPregunta[4].setsOpcion2("Mayimbu");
oExamen.vPregunta[4].setsOpcion3("Freezer");
oExamen.vPregunta[4].setnOpcionCorrecta(3);

// Crear Hoja de respuestas para el respectivo examen


HojaRespuesta oHoja = new HojaRespuesta(oExamen);

// Aplicar el examen
oHoja.aplicar();

// Revisar el examen
oHoja.revisar();

// Mostrar los resultados del examen


oHoja.verResultado();

} //Fin Main
} //Fin Clase

Departamento de Sistemas y Computación Página 74


Ahora compilamos y ejecutamos el programa, dando clic en el icono , y obtenemos:

run:
Materia: Historia de Dragon Ball
Maestro: Roshi
Alumno: Gerardo Flores
Unidad: 1
Pregunta 1: ¿Cuánto tardó en aprender el kame-hame-ha?
1) 10 años
2) 30 años
3) 80 años
? : 3
Pregunta 2: ¿Nombre de la esposa de Vegueta?
1) Milk
2) Bulma
3) Videl
? : 2
Pregunta 3: ¿Quién le dio la esfera de 4 estrellas?
1) Piccolo
2) Son gohan
3) Ox Satan
? : 1
Pregunta 4: ¿Que le regaló Roshi a Goku?
1) nube voladora
2) esfera del dragon
3) báculo sagrado
? : 1
Pregunta 5: ¿Quién destruyó el planeta Namekusein?
1) Cell
2) Mayimbu
3) Freezer
? : 3
Tuviste 4.0 aciertos!!!
BUILD SUCCESSFUL (total time: 30 seconds)

Reto.
Modifique el ejercicio para el examen consista en relacionar preguntas con respuestas.

7.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
los diagramas de actividades, casos de uso, clases y de secuencias en PlantUML el
código fuente y capturas de pantalla de la ejecución del programa.

7.5 Resultados y Conclusiones


Con ésta práctica, el alumno reforzará la aplicación del paradigma del modelado
orientado a objetos.

Departamento de Sistemas y Computación Página 75


Practica 8. Introduccion al uso de
Interfaces.
8.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad IV: Polimorfismo
de los subtemas 4.1 Definición, 4.2 Clases abstractas: definición, métodos
abstractos, implementación de clases abstractas, modelado de clases abstractas,
4.3 Interfaces: definición, implementación de interfaces, herencia de interfaces,
4.4 Variables polimórficas (plantillas): definición, uso y aplicaciones y 4.5
Reutilización de código del programa de estudios de la materia de Programación
Orientada a Objetos, desarrollando la competencia específica: “Aplica el concepto
de polimorfismo para la definición de clases abstractas e interfaces que permitan
reutilización de código”.
8.2 Objetivo (Competencia)
Elaborar un programa que muestre como atacar problemas que impliquen herencia
múltiple. Escriba un programa que genere la clase HombreAraña a partir de las
interfaces Hombre y Araña.

8.3 Fundamento
Herencia múltiple.
Se dice que hay herencia múltiple cuando una clase hereda de más de una clase. Así,
una clase hija hereda el comportamiento de varias clases padre. En ciertos casos, la
herencia múltiple puede simplificar los programas y proporcionar soluciones para
resolver problemas difíciles, aunque también son fuentes de múltiples problemas. [14]

A diferencia de C++, Java no permite herencia múltiple, esto es, no permite que una
clase derive de dos clases distintas heredando de ambas métodos y variables miembro.
Las interfaces de Java constituyen una alternativa a la herencia múltiple con
importantes ventajas prácticas y de “estilo de programación”. [6]

Interfaces.
Una interface es un conjunto de declaraciones de métodos (sin implementación, es
decir, sin definir el código de dichos métodos). Si una clase implementa una
determinada interface, debe dar una definición a todos los métodos de la interface.

modificador interface NombreInterface {


//declaración de constantes
//declaración de métodos. ¡Solo declaración!
}

modificador class NombreClase implements NombreInterface {


//métodos desde la interface
};

Departamento de Sistemas y Computación Página 76


Ejemplo:
public interface Lampara {
boolean encenderLampara();
}

public interface Telefono {


boolean modoAvion();
}

public class Celular implements Telefono, Lampara {


boolean encenderLampara(){
// Codificación…
return true;
}

boolean modoAvion(){
// Codificación…
return true;
}
}

La ventaja de las interfaces es que no están sometidas a las más rígidas normas de las
clases; por ejemplo, una clase no puede heredar de dos clases abstract, pero sí puede
implementar varias interfaces.

Una de las ventajas de las interfaces de Java es el establecer pautas o modos de


funcionamiento similares para clases que pueden estar o no relacionadas mediante
herencia. [6]

En efecto, todas las clases que implementan una determinada interface soportan los
métodos declarados en la interface y en este sentido se comportan de modo similar.
Las interfaces pueden también relacionarse mediante mecanismos de herencia, con
más flexibilidad que las clases.

8.4 Procedimiento (Descripción)


8.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

8.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java (IDE) NetBeans.

8.4.3 Desarrollo de la Práctica


En esta práctica modelaremos al super héroe Hombre-Aracnido (spiderman). Si Java
soportara herencia múltiple, bastaría con crear la clase Hombre y la clase Aracnido para
tomarlas como clases base de la clase HombraAracnido, como se muestra en el siguiente
diagrama:

Departamento de Sistemas y Computación Página 77


Pero como no tenemos herencia múltiple en java, lo haremos con interfaces:

Primer paso. Crear el proyecto.


Iniciamos nebeans, elegimos la opción “FileNew Project”. Creamos una
aplicación java. Le damos el nombre de “aplicacionSpiderman” al proyecto. Damos
clic en el botón “Finish” y el proyecto se ha creado.

Si es el único proyecto podemos saltar este paso. En otro caso, damos clic derecho
sobre el nombre del proyecto y en el menú contextual seleccionamos “Set as Main
Project”. El nombre del proyecto debe ponerse en negritas.

Segundo paso. Crear la interface Hombre.


En el menú de proyectos que está a la izquierda, expandamos el proyecto hasta ver el
paquete aplicacionspiderman y sobre este damos clic derecho y del menú contextual
seleccionamos New y luego Java Interface.

Departamento de Sistemas y Computación Página 78


Le damos el nombre de Hombre a la nueva interface y clic en el botón “Finish”:

Seleccionamos la pestaña de edición llamada “Hombre.java” y escribimos el código:

Departamento de Sistemas y Computación Página 79


Hombre.java
package aplicacionspiderman;

public interface Hombre {

String nombre = "";

void golpear();

void saludar();
}

Tercer paso. Crear la interface Aracnido.


En el menú de proyectos que está a la izquierda, expandamos el proyecto hasta ver el
paquete aplicacionspiderman y sobre este damos clic derecho y del menú contextual
seleccionamos New y luego Java Interface.

Le damos el nombre de Aracnido a la nueva interface y clic en el botón “Finish”.


Seleccionamos la pestaña de edición llamada “Aracnido.java” y escribimos el
código:

Aracnido.java
package aplicacionspiderman;

public interface Aracnido {

String especie = "violinista";

void trepar();

void lanzarTelaracnia();
}

Cuarto paso. Crear la clase HombreAracnido.


En el menú de proyectos que está a la izquierda, expandamos el proyecto hasta ver el
paquete aplicacionspiderman y sobre este damos clic derecho y del menú contextual
seleccionamos New y luego Java Class.

Le damos el nombre de HombreAracnido a la nueva interface y clic en el botón


“Finish”. Seleccionamos la pestaña de edición llamada “HombreAracnido.java” y
escribimos el código:

HombreAracnido.java
package aplicacionspiderman;

public class HombreAracnido implements Hombre, Aracnido {

@Override
public void saludar() {
System.out.println("Hola, que hay de nuevo!");
}

Departamento de Sistemas y Computación Página 80


@Override
public void golpear() {
System.out.println("Gancho izq");
System.out.println("Patada lateral");
System.out.println("Pellizco mortal");
}

@Override
public void trepar() {
System.out.println("Avanza mano izq, pie der");
System.out.println("Luego Avanza mano der, pie izq");

@Override
public void lanzarTelaracnia() {
System.out.println("Apuntar, estirar brazo");
System.out.println("Doblar muñeca, dispara!!!");
}
}

Quinto paso. Editar la clase principal.


Ahora debemos crear un objeto de la clase HombreAracnido, le damos valores
iniciales como nombre y especie y luego ejecutar algunos de sus métodos.

En el ejemplo, primero creamos nuestro superhéroe, luego lo hacemos saludar,


después lo ponemos a trepar y golpear, al final hacemos que lance su telaraña. Para
codificar el comportamiento antes descrito, seleccionamos la pestaña de edición
llamada “AplicacionSpiderman.java” y escribimos:

AplicacionSpiderman.java
package aplicacionspiderman;

public class AplicacionSpiderman {

public static void main(String[] args) {


HombreAracnido peter = new HombreAracnido();

peter.saludar();

peter.trepar();
peter.trepar();
peter.trepar();

peter.golpear();

peter.lanzarTelaracnia();
}
}

Departamento de Sistemas y Computación Página 81


Sexto paso. Compilar y Ejecutar.
Ahora compilamos y ejecutamos el programa, dando clic en el icono , y obtenemos:

Reto.
Ahora practique la herencia múltiple para crear un artículo que sirve como pluma,
apuntador laser y reloj.

8.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga los
diagramas de clases, el código fuente y capturas de pantalla de la ejecución del
programa.

8.5 Resultados y Conclusiones


Al realizar la presente práctica, el alumno tendrá una idea más clara de cómo usar las
interfaces para resolver problemas que impliquen herencia múltiple.

Departamento de Sistemas y Computación Página 82


Practica 9. Manejo de errores
9.1 Introducción
La presente práctica ayuda a reforzar los contenidos de la Unidad V: Excepciones
de los subtemas 5.1 Definición, 5.2 Tipos de excepciones, 5.3 Propagación de
excepciones, 5.4 Gestión de excepciones: manejo de excepciones, lanzamiento
de excepciones, 5.5 Creación y manejo de excepciones definidas por el usuario,
del programa de estudios de la materia de Programación Orientada a Objetos,
desarrollando la competencia específica: “Identificar, manejar, gestionar y crear
las condiciones de error que interrumpan el flujo normal de ejecución de un
programa.”.

9.2 Objetivo (Competencia)


Escribir un código que implemente un manejo de errores muy básico para atrapar el
error que se produce al intentar acceder a los elementos de un arreglo más allá de sus
límites.

9.3 Fundamento. [10][11]


El mejor momento para detectar los errores de codificación es durante la compilación.
Sin embargo, prácticamente sólo los errores de sintaxis son detectados durante este
periodo. El resto de problemas surgen durante la ejecución de los programas.

Una excepción es un evento que ocurre durante la ejecución del programa que
interrumpe el flujo normal de las sentencias.

En Java, una Exception es un tipo de error que se ha producido durante la ejecución


de un programa. Algunas excepciones son fatales y provocan que se deba finalizar la
ejecución del programa. En este caso conviene terminar ordenadamente y dar un
mensaje explicando el tipo de error que se ha producido.

Otras, como por ejemplo no encontrar un archivo en el que hay que leer o escribir
algo, pueden ser recuperables. En este caso el programa debe dar al usuario la
oportunidad de corregir el error (indicando una nueva localización del archivo no
encontrado). Considere utilizar principalmente excepciones para:

1. Arreglar el problema y llamar de nuevo al método que causó la excepción.


2. Arreglar todo y continuar sin volver a ejecutar el método.
3. Calcular algún resultado alternativo en vez de lo que se suponía que iba a
devolver el método.
4. Hacer lo que se pueda en el contexto actual y relanzar la misma excepción a
un contexto superior.
5. Hacer lo que se pueda en el contexto actual y lanzar una excepción diferente
a un contexto superior.

Departamento de Sistemas y Computación Página 83


6. Terminar el programa.
7. Simplificar. (Si tu esquema de excepción hace algo más complicado, es una
molestia utilizarlo.)
8. Hacer más seguros la biblioteca y el programa. (Ésta es una inversión a corto
plazo de cara a la depuración, y también una inversión a largo plazo de cara a
la fortaleza de la aplicación.)

Un buen programa debe gestionar correctamente todas o la mayor parte de los errores
que se pueden producir. El lenguaje Java cuenta con instrucciones para el manejo de
errores en tiempo de ejecución.

Tipos de excepciones
Existen varios tipos fundamentales de excepciones:

 Error: Excepciones que indican problemas muy graves, que suelen ser no
recuperables y no deben casi nunca ser capturadas.
 Exception: Excepciones no definitivas, pero que se detectan fuera del tiempo
de ejecución.
 RuntimeException: Excepciones que se dan durante la ejecución del
programa.

Todas las excepciones tienen como clase base la clase Throwable, que está incluida
en el paquete java.lang, y sus métodos son:

 Trowable( String mensaje ). Constructor. La cadena es opcional


 Throwable fillInStackTrace(). Llena la pila de traza de ejecución.
 String getLocalizedMessage(). Crea una descripción local de este objeto.
 String getMessage(). Devuelve la cadena de error del objeto.
 void printStackTrace( PrintStream_o_PrintWriter s ). Imprime este
objeto y su traza en el flujo del parámetro s, o en la salida estándar (por
defecto).
 String toString. Devuelve una breve descripción del objeto.

Ahora repasaremos como trabajar con los bloques y expresiones try, catch, throw,
throws y finally, cuándo se deben lanzar excepciones, cuándo se deben capturar y
cómo se crean las clases propias de tipo Exception.

Manejo de Excepciones
Para manejar una excepción se utilizan las palabras reservadas try y catch. El
bloque try es utilizado para definir el bloque de código en el cual una excepción pueda
ocurrir. El o los bloques catch son utilizados para definir un bloque de código que
maneje la excepción.

Las excepciones son objetos que contienen información del error que se ha
producido. Heredan de la clase Exception que a su vez hereda de la clase Throwable.

Departamento de Sistemas y Computación Página 84


Try…Catch
El código dentro del bloque try está “vigilado”: Si se produce una situación anormal
y se lanza por lo tanto una excepción el control salta o sale del bloque try y pasa al
bloque catch, que se hace cargo de la situación y decide lo que hay que hacer. Se
pueden incluir tantos bloques catch como sean necesarios, cada uno de los cuales
tratará un tipo de excepción.

try {
// Código que podría generar excepciones
}
catch(Tipo1 idl) {
// Manejo de excepciones de Tipo1
}
catch(Tipo2 id2) {
// Manejo de excepciones de Tipo2
}
catch(Tipo3 id3) {
// Manejo de excepciones de Tipo3
}

Throw
Cuando en un método se produce una situación anómala es necesario lanzar una
excepción. El proceso de lanzamiento de una excepción es el siguiente:
1. Se crea un objeto Exception de la clase adecuada.
2. Se lanza la excepción con la sentencia throw seguida del objeto Exception
creado.
// Código que lanza la excepción una vez detectado el error
MyException me = new MyException("MyException message");
throw me;

Esta excepción deberá ser capturada (catch) y gestionada en el propio método o en


algún otro lugar del programa (en otro método anterior en la pila o stack de llamadas).

Al lanzar una excepción el método termina de inmediato, sin devolver ningún valor.
Solamente en el caso de que el método incluya los bloques try/catch/finally se
ejecutará el bloque catch que la captura o el bloque finally (si existe).

Todo método en el que se puede producir uno o más tipos de excepciones (y que no
utiliza directamente los bloques try/catch/finally) debe declararlas en el encabezado
de la función por medio de la palabra throws. Si un método puede lanzar varias
excepciones, se ponen detrás de throws separadas por comas, por ejemplo:

public void leerFichero(String fich) throws EOFException,


FileNotFoundException {…}

Se puede poner solo una superclase de excepciones para indicar que se pueden lanzar
excepciones de cualquiera de sus clases derivadas. El caso anterior es equivalente a:

public void leerFichero(String fich) throws IOException {…}

Departamento de Sistemas y Computación Página 85


Las excepciones pueden ser lanzadas directamente por leerFichero() o por alguno de
los métodos llamados por leerArchivo(), ya que las clases EOFException y
FileNotFoundException derivan de IOException.

Se recuerda que no hace falta avisar de que se pueden lanzar objetos de las clases
Error o RuntimeException (excepciones implícitas). [11]

Como cualquier otro objeto en Java, las excepciones siempre se crean en el montículo
haciendo uso de new, que asigna espacio de almacenamiento e invoca a un
constructor. Hay dos constructores en todas las excepciones estándar: el primero es
el constructor por defecto y el segundo toma un parámetro string de forma que se
pueda ubicar la información pertinente en la excepción:

if (t == null)
throw new NullPointerException ("t = null");

Este string puede extraerse posteriormente utilizando varios métodos, como se verá
más adelante. La palabra clave throw hace que ocurran varias cosas relativamente
mágicas. Habitualmente, se usará primero new para crear un objeto que represente la
condición de error. Se da a throw la referencia resultante. En efecto, el método
"devuelve" el objeto, incluso aunque ese tipo de objeto no sea el que el método debería
devolver de forma natural.

Una manera natural de pensar en las excepciones es como si se tratara de un


mecanismo de retorno alternativo, aunque el que lleve esta analogía demasiado lejos
acabará teniendo problemas. También se puede salir del ámbito ordinario lanzando
una excepción. Pero se devuelve un valor, y el método o el ámbito finalizan. [10]

Throws
Existen algunos casos en los cuales el código de un método puede generar una
Exception y no se desea incluir en dicho método la gestión del error. Java permite
que este método pase o relance (throws) la Exception al método desde el que ha sido
llamado, sin incluir en el método los bucles try/catch correspondientes.

Esto se consigue mediante la adición de throws más el nombre de la Exception


concreta después de la lista de argumentos del método. A su vez el método superior
deberá incluir los bloques try/catch o volver a pasar la Exception. De esta forma se
puede ir pasando la Exception de un método a otro hasta llegar al último método del
programa, el método main(). [11]

Finally
A menudo hay algunos fragmentos de código que se desea ejecutar
independientemente de que se lancen o no excepciones dentro de un bloque try. Esto
generalmente está relacionado con operaciones distintas de recuperación de memoria
(puesto que de esto ya se encarga el recolector de basura).

Departamento de Sistemas y Computación Página 86


Para lograr este efecto, se usa una cláusula finally al final de todos los manejadores
de excepciones. El esquema completo de una sección de manejo de excepciones es,
por consiguiente:

try {
// La región protegida: Actividades peligrosas que
// podrían lanzar A o B
}
catch (A al) {
// Manejador para la situación A
}
catch (B bl) {
// Manejador para la situación B
}
finally {
// Actividades que se dan siempre
}

Ilustración 10. Jerarquía de clases de excepciones

Departamento de Sistemas y Computación Página 87


Ilustración 11. Propagación de excepciones

9.4 Procedimiento (Descripción)


9.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

9.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java NetBeans.

9.4.3 Desarrollo de la Práctica


En esta práctica trabajaremos con una excepción que ya está predefinida en las
librerías del JDK, la excepción ArrayIndexOutOfBoundsException.

Iniciamos netbeans, elegimos la opción “FileNew Project”. Creamos una


aplicación java. Le damos el nombre de “ejemploManejoError” al proyecto. Damos
clic en el botón “Finish” y el proyecto se ha creado.

Si es el único proyecto podemos saltar este paso. En otro caso, damos clic derecho
sobre el nombre del proyecto y en el menú contextual seleccionamos “Set as Main
Project”. El nombre del proyecto debe ponerse en negritas.

Primera versión.
Editamos la clase principal escribiendo la primera versión, que es un programa sin
errores. El código es:

EjemploManejoError.java
package ejemplomanejoerror;

Departamento de Sistemas y Computación Página 88


public class EjemploManejoError {

public static void main(String[] args) {


String[] animales = {"León", "Puma", "Delfín", "Tigre"};
int tam = animales.length;

//recorrer el arreglo e imprimir sus elementos


for (int i = 0; i < animales.length; i++) {
System.out.println(animales[i]);
}
}
}

Salida
run:
León
Puma
Delfín
Tigre
BUILD SUCCESSFUL (total time: 0 seconds)

Segunda versión.
En esta versión se introduce un error algo común: se hace referencia a un elemento
fuera de los límites del arreglo. El código es:

package ejemplomanejoerror;

public class EjemploManejoError {

public static void main(String[] args) {


String[] animales = {"León", "Puma", "Delfín", "Tigre"};
int tam = animales.length;

// Se introduce un error
for (int i = 0; i <= animales.length; i++) {
System.out.println(animales[i]);
}
}
}

Salida
run:
León
Puma
Delfín
Tigre
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
at
ejemplomanejoerror.EjemploManejoError.main(EjemploManejoError.java:11)
D:\Users\pgarcia\AppData\Local\NetBeans\Cache\8.2\executor-
snippets\run.xml:53: Java returned: 1
BUILD FAILED (total time: 0 seconds)

Departamento de Sistemas y Computación Página 89


Tercera versión.
Esta versión aún tiene el error, pero ya cuenta con el mecanismo para atraparlo e
informar al usuario. El código es:

package ejemplomanejoerror;

public class EjemploManejoError {

public static void main(String[] args) {


String[] animales = {"León", "Puma", "Delfín", "Tigre"};
int tam = animales.length;
try {
//recorrer el arreglo e imprimir sus elementos
for (int i = 0; i <= animales.length; i++) {
System.out.println(animales[i]);
}
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Error: fuera de los límites del arreglo");
}
}
}

Salida
run:
León
Puma
Delfín
Tigre
Error: fuera de los límites del arreglo
BUILD SUCCESSFUL (total time: 0 seconds)

Reto.
Escribe un programa que use la clase de la excepción "ArithmeticException" para
detectar una división por cero.

9.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
el código fuente y capturas de pantalla de la ejecución del programa.

9.5 Resultados y Conclusiones


Con ésta práctica, el alumno podrá hacer programas más robustos, pues al manejar la
mayor parte de las causas de error de un programa, será más fácil recuperarse de los
errores y además recibir mensajes que nos den pistas de como corregir los fallos, y
así reducir los tiempos de mantenimiento.

Departamento de Sistemas y Computación Página 90


Practica 10. Leer y escribir archivos de
texto.
10.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad VI: Flujos y
archivos de los subtemas 6.1 Definición y 6.2 Clasificación: Archivos de texto y
binarios del programa de estudios de la materia de Programación Orientada a
Objetos, desarrollando la competencia específica: “Comprende y aplica la
clasificación de archivos y operaciones básicas sobre éstos para manipular su
información”.
10.2 Objetivo (Competencia)
Elaborar un programa que guarde y lea archivo en java. Debe leer y escribir los datos
en un archivo de texto.

10.3 Fundamento
Persistencia de datos.
En general, en nuestros programas usamos variables para manipular información. Lo
común es que dichas variables se destruyen al finalizar el programa, pues el
almacenamiento de datos en variables y arrays (arreglos) es temporal; los datos se
pierden cuando una variable sale de su ámbito o alcance de influencia, o bien cuando
se termina el programa.

La mayoría de las aplicaciones requieren que la información se almacene de forma


persistente, es decir que no se borre o elimine cuando se termina la ejecución del
programa. Por otra parte, en numerosas aplicaciones se requiere utilizar grandes
cantidades de información que, normalmente, no caben en la memoria principal.

Debido a estas causas se requiere utilizar archivos para almacenar de modo


permanente grandes cantidades de datos, incluso después que los programas que crean
los datos se terminan.

Estos datos almacenados en archivos se conocen como datos persistentes y


permanecen después de la duración de la ejecución del programa.

Los diseñadores de la biblioteca de Java crearon muchas clases para el sistema de


E/S, como resultado hay que aprender un número de clases aceptable antes de
entender suficientemente un esbozo de la E/S de Java para poder usarla
adecuadamente. Pero trataremos de guardar y escribir datos en aun archivo de una
forma muy simple.

Para leer archivos de texto usaremos la FileReader y para escribir en un archivo de


texto usaremos FileWriter; ambas clases se encuentran en la librería java.io

Departamento de Sistemas y Computación Página 91


La clase FileReader tiene varios constructores, por ahora solo usaremos el siguiente:

public FileReader(String nombreArchivo)


throws FileNotFoundException

Donde:

Creamos un objeto FileReader, dando el nombre del archivo que leeremos.


Parámetros:
nombreArchivo - nombre del archivo que leeremos
Throws:
FileNotFoundException – En caso que el archivo no exista o por alguna
situación no podamos leerlo, se lanza esta excepción.

La clase FileWriter tiene varios constructores, por ahora solo usaremos el siguiente:

public FileWriter(Writer salida)


throws FileNotFoundException

Donde:

Creamos un objeto FileWriter, dando el nombre de un objeto Writer.


Parámetros:
salida - nombre del objeto Writer que usaremos para acceder al archivo.
Throws:
NullPointerException – Si la salida en null

10.4 Procedimiento (Descripción)


10.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

10.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java, el IDE NetBeans.

10.4.3 Desarrollo de la Práctica


Esta práctica la desarrollaremos en dos partes: en la primera crearemos y escribiremos
en un archivo, y en el segundo leeremos tal archivo.

Iniciamos netbeans, elegimos la opción “FileNew Project”. Creamos una


aplicación java. Le damos el nombre de “leerEscribirArchivo” al proyecto. Damos
clic en el botón “Finish” y el proyecto se ha creado.

Departamento de Sistemas y Computación Página 92


Si es el único proyecto podemos saltar este paso. En otro caso, damos clic derecho
sobre el nombre del proyecto y en el menú contextual seleccionamos “Set as Main
Project”. El nombre del proyecto debe ponerse en negritas.

Primera parte.
Editamos la clase principal escribiendo el método escribirArchivo(), y lo invocamos
desde el método main(). El código es:

leerEscribirArchivo.java
package leerescribirarchivo;

import java.io.FileWriter;
import java.io.IOException;

public class LeerEscribirArchivo {

// Manejamos la excepción IOException


void escribirArchivo() throws IOException {
// Creamos el objeto archivo.
// En caso que ya exista, se sobreescribe
FileWriter archivo = new FileWriter("datos.txt");

// Escribimos un texto en el archivo


archivo.write("Hola mundo!!!");

// Cerramos el archivo
archivo.close();
}

public static void main(String[] args) throws IOException {


LeerEscribirArchivo app = new LeerEscribirArchivo();
app.escribirArchivo();
app.leerArchivo();
}
}

Salida
run:
BUILD SUCCESSFUL (total time: 0 seconds)

Podemos ver que el programa no nos envía ningún mensaje, pero si vemos el
directorio del proyecto, veremos que se creó el archivo datos.txt.

Departamento de Sistemas y Computación Página 93


Vemos que nos marca que tiene un tamaño de 1kb, este es el tamaño real que ocupa
en disco. Pero si vemos sus propiedades, nos indica que tiene un tamaño de 13 bytes,
este se refiere al tamaño lógico, que es la cantidad de información que guarda.

Pero, ¿Qué pasa con los demás bytes? ¡Pues se desperdician!, esto se conoce como
fragmentación interna. Y es un precio que se tiene que pagar en favor del desempeño.
Pues para acelerar las velocidades de escritura y lectura, el mecanismo del hardware
solo puede leer y escribir bloques de bytes, en lugar de byte por byte.

Segunda parte.
Editamos la clase principal escribiendo el método leerArchivo(), y lo invocamos
desde el método main(), además ponemos entre comentarios la invocación a la
función escribirArchivo() para que solo leamos el archivo. El código es:

leerEscribirArchivo.java
package leerescribirarchivo;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class LeerEscribirArchivo {

// Manejamos la excepción IOException


void escribirArchivo() throws IOException {
// Creamos el objeto archivo.
// En caso que ya exista, se sobreescribe
FileWriter archivo = new FileWriter("datos.txt");

// Escribimos un texto en el archivo


archivo.write("Hola mundo!!!");

// Cerramos el archivo
archivo.close();
}

Departamento de Sistemas y Computación Página 94


// Manejamos la excepción IOException
void leerArchivo() throws IOException {
// Creamos el objeto archivo.
FileReader archivo = new FileReader("datos.txt");
int letra;

// Leemos el archivo byte por byte


do{
letra=archivo.read();
System.out.println("Byte: "+(char)letra);
} while(letra!=-1);

// Cerramos el archivo
archivo.close();
}

public static void main(String[] args) throws IOException {


LeerEscribirArchivo app = new LeerEscribirArchivo();
// app.escribirArchivo();
app.leerArchivo();
}
}

Salida
run:
Byte: H
Byte: o
Byte: l
Byte: a
Byte:
Byte: m
Byte: u
Byte: n
Byte: d
Byte: o
Byte: !
Byte: !
Byte: !
Byte:
BUILD SUCCESSFUL (total time: 0 seconds)

Reto.
Cree un programa que guarde 5 nombres de personas, luego escriba un código que
abra el archivo anterior y cuente e imprima la cantidad de vocales en el archivo.

10.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
el código fuente y capturas de pantalla de la ejecución del programa.

10.5 Resultados y Conclusiones


Al realizar esta sencilla práctica el alumno podrá guardar y recuperar información
desde un archivo.

Departamento de Sistemas y Computación Página 95


Practica 11. Guardar y recuperar
objetos.
11.1 Introducción
La presente práctica ayuda a asimilar los contenidos de la Unidad VI: Flujos y
archivos de los subtemas 6.3 Operaciones básicas y tipos de acceso y 6.4 Manejo
de objetos persistentes del programa de estudios de la materia de Programación
Orientada a Objetos, desarrollando la competencia específica: “Comprende y
aplica la clasificación de archivos y operaciones básicas sobre éstos para
manipular su información”.
11.2 Objetivo (Competencia)
Elaborar un programa que guarde y lea objetos de java. Debe crear la clase Persona
con los atributos de nombre, peso y estatura y con el método imc(), que calcula el
índice de masa corporal. Después debe crear un objeto de la clase persona y guardarla
en el archivo paciente.dat.

Al final, debe crear el objeto fulano a partir de la clase que esta guardada en el archivo
y usando este objeto imprimimos sus atributos e invocamos a su método imc().

11.3 Fundamento
En la práctica anterior guardamos y recuperamos texto, pero al ser java un lenguaje
orientado a objetos, resulta muy interesante dotar a los objetos de persistencia
(poderlos guardar en archivos). A esta funcionalidad se le conoce como serialización.

Serialización.
La serialización de objetos de Java permite tomar cualquier objeto que implemente
la interfaz Serializable y convertirlo en una secuencia de bits que puede ser
posteriormente restaurada para regenerar el objeto original.

El mecanismo de serialización compensa automáticamente las diferencias entre


sistemas operativos. Es decir, se puede crear un objeto en una máquina Windows,
serializarlo, y enviarlo a través de la red a una máquina Unix, donde será reconstruido
correctamente. No hay que preocuparse de las representaciones de los datos en las
distintas máquinas, al igual que no importan la ordenación de los bytes y el resto de
detalles.

Con la serialización logramos que el tiempo de vida de un objeto dure más allá de la
ejecución del programa que lo usa.

Un aspecto particularmente inteligente de la serialización de objetos es que, no sólo


salva la imagen del objeto, sino que también sigue todas las referencias contenidas en
el objeto, y salva esos objetos, siguiendo además las referencias contenidas en cada

Departamento de Sistemas y Computación Página 96


uno de ellos, etc. A esto se le suele denominar la "telaraña de objetos" puesto que un
único objeto puede estar conectado, e incluir arrays de referencias a objetos, además
de objetos miembro. Si se tuviera que mantener un esquema de serialización de
objetos propio, el mantenimiento del código para seguir todos estos enlaces sería casi
imposible. Sin embargo, la serialización de objetos Java parece encargarse de todo
haciendo uso de un algoritmo optimizado que recorre la telaraña de objetos. [10]

Para que una clase pueda utilizar la serialización, debe implementar la interface
Serializable, que no define ningún método. Casi todas las clases estándar de Java son
serializables. Para que una clase se pueda serializar se debe declarar como:

public class MiClase implements Serializable { }

Para escribir un objeto se utiliza la clase ObjectOutputStream, que cuentan con el


método writeObject(). Por ejemplo:

ObjectOutputStream objeto = new ObjectOutputStream(new


FileOutputStream("archivo.x"));
String texto = new String("Me van a serializar");
objeto.writeObject(texto);

Para leer objetos se utiliza la clase ObjectInputStream, que cuenta con el método
readObject(). Por ejemplo:

ObjectInputStream objeto = new ObjectInputStream(new


FileInputStream("archivo.x"));
String texto = (String)objeto.readObject();

Debe tener en cuenta que readObject() devuelve un Object sobre el que se deberá
hacer un casting para que el objeto sea útil. La reconstrucción necesita que el archivo
*.class esté al alcance del programa (como mínimo para hacer este casting). [11]

11.4 Procedimiento (Descripción)


11.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

11.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java, el IDE NetBeans.

11.4.3 Desarrollo de la Práctica


Esta práctica la desarrollaremos en dos partes: en la primera parte crearemos la clase
Persona para después crear un objeto de dicha clase y guardarlo en un archivo
llamado paciente.dat. En la segunda parte crearemos un objeto a partir de la clase
que esta guardada en el archivo.

Departamento de Sistemas y Computación Página 97


Iniciamos netbeans, elegimos la opción “FileNew Project”. Creamos una
aplicación java. Le damos el nombre de “aplicacionGuardarObjeto” al proyecto.
Damos clic en el botón “Finish” y el proyecto se ha creado.

Si es el único proyecto podemos saltar este paso. En otro caso, damos clic derecho
sobre el nombre del proyecto y en el menú contextual seleccionamos “Set as Main
Project”. El nombre del proyecto debe ponerse en negritas.

Primera parte.
Creamos la clase Persona, recuerde que debe implementar la interface Serializable,
para que podamos guardarla en un archivo.

Persona.java
package aplicacionguardarobjeto;
import java.io.Serializable;

public class Persona implements Serializable {


String nombre;
float peso;
float estatura;

public Persona(String nombre, float peso, float estatura) {


this.nombre = nombre;
this.peso = peso;
this.estatura = estatura;
}

float imc() {
return peso / (estatura * estatura);
}
}

En la clase principal escribiremos el código necesario para almacenar el objeto.


También debemos agregar el manejo de excepciones. El código es:

AplicacionGuardarObjeto.java
package aplicacionguardarobjeto;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class AplicacionGuardarObjeto {

public static void main(String[] args)


throws FileNotFoundException, IOException,
ClassNotFoundException {
Persona paciente = new Persona("Luis", 80f, 1.70f);
ObjectOutputStream registro =
new ObjectOutputStream(new FileOutputStream("paciente.dat"));
registro.writeObject(paciente);

Departamento de Sistemas y Computación Página 98


registro.close();
}
}

Salida
run:
BUILD SUCCESSFUL (total time: 0 seconds)

Podemos ver que el programa no nos envía ningún mensaje, pero si vemos el
directorio del proyecto, veremos que se creó el archivo paciente.dat.

Segunda parte.
Editamos la clase principal agregando el código que esta resaltado en amarillo:

leerEscribirArchivo.java
package aplicacionguardarobjeto;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class AplicacionGuardarObjeto {

public static void main(String[] args)


throws FileNotFoundException, IOException,
ClassNotFoundException {
Persona paciente = new Persona("Luis", 80f, 1.70f);
ObjectOutputStream registro =
new ObjectOutputStream(new FileOutputStream("paciente.dat"));
registro.writeObject(paciente);
registro.close();

// Segunda parte.
ObjectInputStream archivo =
new ObjectInputStream(new FileInputStream("paciente.dat"));
Persona fulano = (Persona)archivo.readObject();
System.out.println("Nombre: "+fulano.nombre);
System.out.println("Estatura: "+fulano.estatura);

Departamento de Sistemas y Computación Página 99


System.out.println("Peso: "+fulano.peso);
System.out.println("IMC: "+fulano.imc());
}
}

Salida
run:
Nombre: Luis
Estatura: 1.7
Peso: 80.0
IMC: 27.68166
BUILD SUCCESSFUL (total time: 1 seconds)

Reto.
Cree un programa que guarde dos objetos, uno de la clase Mascota (con los atributos
nombre, raza y edad) y otro de la clase Comida (con los atributos descripción,
cantidad y frecuencia). Después cree otro programa que pueda leer y los objetos antes
guardado e imprimir sus atributos. Recuerde copiar el archivo generado al directorio
de trabajo del segundo proyecto.

11.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
el código fuente y capturas de pantalla de la ejecución del programa.

11.5 Resultados y Conclusiones


Con ésta práctica, el alumno entenderá como guardar y recuperar objetos. Será capaz
de usar la persistencia de objetos de una manera muy básica pero efectiva.

Departamento de Sistemas y Computación Página 100


Practica 12. Almacenar vectores de
objetos en archivos
12.1 Introducción
La presente práctica ayuda a reforzar los contenidos de la Unidad VI: Flujos y
archivos de los subtemas 6.3 Operaciones básicas y tipos de acceso y 6.4 Manejo
de objetos persistentes del programa de estudios de la materia de Programación
Orientada a Objetos, desarrollando la competencia específica: “Comprende y
aplica la clasificación de archivos y operaciones básicas sobre éstos para
manipular su información.”

12.2 Objetivo (Competencia)


Elaborar un programa que use vectores y la serialización de objetos para almacenar
escenarios gráficos. Realizar un programa guarde objetos como líneas y círculos en
un Vector y guardar dicho vector en un archivo.

12.3 Fundamento
Los arreglos (arrays) en Java son suficientes para guardar tipos básicos de datos, y
objetos de una determinada clase cuyo número conocemos de antemano.

Algunas veces deseamos guardar objetos en un array pero no sabemos cuántos objetos
vamos a guardar. Una solución es la clase Vector. Un vector es similar a un array, la
diferencia estriba en que un vector crece automáticamente cuando alcanza la
dimensión inicial máxima. Además, proporciona métodos adicionales para añadir,
eliminar, e insertar elementos entre otros dos existentes. ¡Además, podemos
almacenar objetos de distintas clases en un mismo vector!

Crear un vector
Para usar la clase Vector escribimos al inicio del programa la sentencia:

import java.util.Vector;

Cuando creamos un vector u objeto de la clase Vector, podemos especificar su


dimensión inicial, y cuanto crecerá si rebasamos dicha dimensión. Por ejemplo, si
tenemos un vector con una dimensión inicial de 20 elementos y si rebasamos dicha
dimensión y guardamos 21 elementos la dimensión del vector crece a 25.

Vector vector=new Vector(20, 5);

Al segundo constructor, solamente se le pasa la dimensión inicial.

Vector vector=new Vector(20);

Departamento de Sistemas y Computación Página 101


Si se rebasa la dimensión inicial guardando 21 elementos, la dimensión del vector se
duplica.

Con el tercer constructor, se crea un vector cuya dimensión inicial es 10.

Vector vector=new Vector();

La dimensión del vector se duplica si se rebasa la dimensión inicial, por ejemplo,


cuando se pretende guardar once elementos.

Añadir elementos al vector


Hay dos formas de añadir elementos a un vector. Podemos añadir un elemento a
continuación del último elemento del vector, mediante la función miembro
addElement.

v.addElement("uno");

Podemos también insertar un elemento en una determinada posición, mediante


insertElementAt. El segundo parámetro o índice, indica el lugar que ocupará el nuevo
objeto. Si tratamos de insertar un elemento en una posición que no existe todavía
obtenemos una excepción del tipo ArrayIndexOutOfBounds. Por ejemplo, si
tratamos de insertar un elemento en la posición 9 cuando el vector solamente tiene
cinco elementos.

Para insertar el string "tres" en la tercera posición del vector v, escribimos

v.insertElementAt("tres", 2);

La clase java.util.Vector deriva de Object, implementa Cloneable (para poder sacar


copias con el método clone()) y Serializable (para poder ser convertida en cadena de
caracteres).

Como su mismo nombre sugiere, Vector representa un arreglo de objetos (referencias


a objeto de tipo Object) que puede crecer y reducirse, según el número de elementos.

Además, permite acceder a los elementos con un índice, aunque no permite utilizar
los corchetes []. El método capacity() devuelve el tamaño o número de elementos
que puede tener el vector. El método size() devuelve el número de elementos que
realmente contiene. [11]

12.4 Procedimiento (Descripción)


12.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

Departamento de Sistemas y Computación Página 102


12.4.2 Material de Apoyo
 SDK de java.
 Entorno de desarrollo para java (IDE), por ejemplo, NetBeans.
 Librería swing o javaFX.

12.4.3 Desarrollo de la Práctica


En esta práctica crearemos objetos como círculos y líneas, para guardarlos en un
vector. Luego guardamos el vector en un archivo llamado figuras.dat.

Iniciamos netbeans, elegimos la opción “FileNew Project”. Creamos una


aplicación java. Le damos el nombre de “AplicacionGuardarVector” al proyecto.
Damos clic en el botón “Finish” y el proyecto se ha creado.

Si es el único proyecto podemos saltar este paso. En otro caso, damos clic derecho
sobre el nombre del proyecto y en el menú contextual seleccionamos “Set as Main
Project”. El nombre del proyecto debe ponerse en negritas.

Este proyecto esta asociado al de la siguiente práctica, pues este proyecto genera el
archivo con los objetos y el de la siguiente práctica debe ser capaz de leerlos. Para
que esto sea posible, deben tener el mismo nombre del paquete. Así cambiamos el
nombre del paquete “aplicacionguardarvector” a “vectorconobjetos”.

Creamos las clases Circulo y Línea, recuerde que deben implementar la interface
Serializable, para que podamos guardar en un archivo los objetos que generemos a
partir de estas. Las respectivas clases son:

Circulo.java
package vectorconobjetos;

import java.awt.Graphics;
import java.awt.Point;
import java.io.Serializable;

public class Circulo implements Serializable {

Point centro;
int radio;

public Circulo(Point centro, int radio) {


this.centro = centro;

Departamento de Sistemas y Computación Página 103


this.radio = radio;
}

public double calculaArea() {


return java.lang.Math.PI * radio * radio;
}

public void dibujar(Graphics g) {


int x, y, largo, ancho;
x = centro.x - radio;
y = centro.y - radio;
largo = ancho = 2 * radio;
g.drawOval(x, y, largo, ancho);
}
}

Linea.java
package vectorconobjetos;

import java.awt.Graphics;
import java.awt.Point;
import java.io.Serializable;

public class Linea implements Serializable{

Point inicio;
Point fin;

public Linea(Point inicio, Point fin) {


this.inicio = inicio;
this.fin = fin;
}

public double longitud() {


int c1 = fin.x - inicio.x;
int c2 = fin.y - inicio.y;

return java.lang.Math.sqrt(c1 * c1 + c2 * c2);


}

public void dibujar(Graphics g) {


g.drawLine(inicio.x, inicio.y, fin.x, fin.y);
}

Ahora editamos la clase principal, donde crearemos dos círculos y dos líneas, las
guardamos en un vector y al final guardamos el vector en el archivo figuras.dat

AplicacionGuardarVector.java
package vectorconobjetos;

import java.awt.Point;
import java.io.FileNotFoundException;

Departamento de Sistemas y Computación Página 104


import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Vector;

public class ApliacionGuardarVector {

public static void main(String[] args) throws FileNotFoundException,


IOException {
Circulo a = new Circulo(new Point(100, 50), 20);
Circulo b = new Circulo(new Point(110, 140), 40);
Linea c = new Linea(new Point(10, 180), new Point(100, 30));
Linea d = new Linea(new Point(130, 10), new Point(180, 100));

Vector figuras = new Vector();


figuras.add(a);
figuras.add(b);
figuras.add(c);
figuras.add(d);

ObjectOutputStream registro=
new ObjectOutputStream(new FileOutputStream("figuras.dat"));
registro.writeObject(figuras);
registro.close();
System.out.println("El archivo figuras.dat se creó con éxito.");
}
}

Ahora compilamos y ejecutamos el programa, dando clic en el icono , y obtenemos:

run:
El archivo figuras.dat se creó con éxito.
BUILD SUCCESSFUL (total time: 0 seconds)

Reto.
Añade a este proyecto la clase Triangulo para, a partir de este crear dos triangulos y
guardarlo también en el vector.

12.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
el código fuente y capturas de pantalla de la ejecución del programa.

12.5 Resultados y Conclusiones


Ahora el alumno conoce una estrategia para guardar una gran cantidad de objetos,
que además pueden ser heterogéneos.

Departamento de Sistemas y Computación Página 105


Practica 13. Recuperar vectores de
objetos desde archivos.
13.1 Introducción
La presente práctica ayuda a reforzar los contenidos de la Unidad VI: Flujos y
archivos de los subtemas 6.3 Operaciones básicas y tipos de acceso y 6.4 Manejo
de objetos persistentes del programa de estudios de la materia de Programación
Orientada a Objetos, desarrollando la competencia específica: “Comprende y
aplica la clasificación de archivos y operaciones básicas sobre éstos para
manipular su información.”

13.2 Objetivo (Competencia)


Elaborar un programa que use vectores y la serialización de objetos para recuperar
escenarios gráficos. Realizar un programa en ambiente gráfico que lea el vector
anterior y dibuje los objetos leídos del archivo.

13.3 Fundamento
Es importante tener en cuenta que readObject() devuelve un Object sobre el que se
deberá hacer un casting para que el objeto sea útil. La reconstrucción necesita que el
archivo *.class esté al alcance del programa (como mínimo para hacer este casting).

Al serializar un objeto, automáticamente se serializan todas sus variables y objetos


miembro. A su vez se serializan los que estos objetos miembros puedan tener (todos
deben ser serializables). También se reconstruyen de igual manera. Si se serializa un
Vector que contiene varios Strings, todo ello se convierte en una serie de bytes. Al
recuperarlo la reconstrucción deja todo en el lugar en que se guardó.

Si dos objetos contienen una referencia a otro, éste no se duplica si se escriben o leen
ambos del mismo stream. Es decir, si el mismo String estuviera contenido dos veces
en el Vector, sólo se guardaría una vez y al recuperarlo sólo se crearía un objeto con
dos referencias contenidas en el vector. [11]

13.4 Procedimiento (Descripción)


13.4.1 Equipo necesario
Computadora con un sistema operativo que cuente con ambiente gráfico (Windows,
Linux, etc…)

13.4.2 Material de Apoyo


 SDK de java.
 Entorno de desarrollo para java (IDE) NetBeans.
 Librería swing.

Departamento de Sistemas y Computación Página 106


13.4.3 Desarrollo de la Práctica
Ahora debemos leer el archivo figuras.dat, que se generó en la práctica anterior. Para
facilitar esto, copiamos tal archivo al directorio de trabajo del proyecto actual:

Iniciamos netbeans, elegimos la opción “FileNew Project”. Creamos una


aplicación java. Le damos el nombre de “AplicacionLeerVector” al proyecto.
Damos clic en el botón “Finish” y el proyecto se ha creado.

Si es el único proyecto podemos saltar este paso. En otro caso, damos clic derecho
sobre el nombre del proyecto y en el menú contextual seleccionamos “Set as Main
Project”. El nombre del proyecto debe ponerse en negritas.

Recuerde que este proyecto esta asociado a la práctica anterior y deben tener el mismo
nombre del paquete. Así cambiamos el nombre del paquete “aplicacionleervector”
a “vectorconobjetos”.

Tambien debemos crear las clases Circulo y Línea, idénticas a las de la práctica
anterior (Puede copiarlas para ahorrar tiempo).

Circulo.java
package vectorconobjetos;

import java.awt.Graphics;
import java.awt.Point;
import java.io.Serializable;

public class Circulo implements Serializable {

Point centro;
int radio;

public Circulo(Point centro, int radio) {


this.centro = centro;
this.radio = radio;
}

Departamento de Sistemas y Computación Página 107


public double calculaArea() {
return java.lang.Math.PI * radio * radio;
}

public void dibujar(Graphics g) {


int x, y, largo, ancho;
x = centro.x - radio;
y = centro.y - radio;
largo = ancho = 2 * radio;
g.drawOval(x, y, largo, ancho);
}
}

Linea.java
package vectorconobjetos;

import java.awt.Graphics;
import java.awt.Point;
import java.io.Serializable;

public class Linea implements Serializable{

Point inicio;
Point fin;

public Linea(Point inicio, Point fin) {


this.inicio = inicio;
this.fin = fin;
}

public double longitud() {


int c1 = fin.x - inicio.x;
int c2 = fin.y - inicio.y;

return java.lang.Math.sqrt(c1 * c1 + c2 * c2);


}

public void dibujar(Graphics g) {


g.drawLine(inicio.x, inicio.y, fin.x, fin.y);
}

Ahora editamos la clase principal, donde crearemos la ventana para desplegar las
figuras, y llenamos el vector figuras con los objetos leidos del archivo figuras.dat.
Despues tenemos que recorrer el vector e ir obteniendo una figura a la vez y tenemos
que verificar de que clase es cada objeto y hacer el cast correspondiente para prodecer
a dibujar el objeto en turno.

AplicacionLeerVector.java
package vectorconobjetos;

Departamento de Sistemas y Computación Página 108


import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Vector;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class AplicacionLeerVector extends JFrame {

Pizarron p;

public AplicacionLeerVector() throws IOException,


FileNotFoundException, ClassNotFoundException {
p = new Pizarron();
p.setPreferredSize(new Dimension(280, 200));
Container cp = getContentPane();
cp.add(p);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pack();
setTitle("Práctica leer vectores");
setVisible(true);
}

public static void main(String[] args) throws IOException,


FileNotFoundException, ClassNotFoundException {
AplicacionLeerVector ventana = new AplicacionLeerVector();
ventana.setVisible(true);
}
}

class Pizarron extends JPanel {

Vector figuras;

public Pizarron() throws FileNotFoundException,


IOException, ClassNotFoundException {
ObjectInputStream archivo
= new ObjectInputStream(new FileInputStream("figuras.dat"));
figuras = new Vector();
figuras = (Vector) archivo.readObject();
}

@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);

for (Object fig : figuras) {


if ( fig.getClass().toString().
compareTo("class vectorconobjetos.Circulo") == 0) {
Circulo x = (Circulo) fig;
x.dibujar(g);
}

Departamento de Sistemas y Computación Página 109


if ( fig.getClass().toString().
compareTo("class vectorconobjetos.Linea")== 0) {
Linea x = (Linea) fig;
x.dibujar(g);
}
}
}
}

Ahora compilamos y ejecutamos el programa, dando clic en el icono , y obtenemos:

Reto.
Añade a este proyecto la clase Triangulo para lograr leerlo del vector y proceder a
dibujarlo.

13.4.4 Reporte
Al finalizar ésta práctica el alumno deberá generar un reporte en PDF que contenga
el código fuente y capturas de pantalla de la ejecución del programa.

13.5 Resultados y Conclusiones


Con ésta práctica, el alumno aplicará varias técnicas avanzadas muy interesantes,
como usar la librería awt para generar una interfaz gráfica, la recuperación de objetos
guardados en un vector y usar el objeto Genérico Object para después hacerles un
casting y tranformalos a la clase deseada.

Departamento de Sistemas y Computación Página 110


Bibliografía
[1] Tecnológico Nacional de México. Programa de estudios de Programación Orientada a
Objetos. Clave SCD-1020. Saltillo, Coahuila, México: s.n., febrero del 2010.

[2] —. Retícula de la carrera de ingeniería en sistemas computacionales ISIC-2010-224.


Ciudad de México, México: s.n., 2016.

[3] Schmuller, J. (2004). Sams teach yourself UML in 24 hours. Indianapolis, IN: Sams.

[4] Las mejores herramientas UML - Edición 2018. (2018, noviembre 14). Consultado en
mayo 1, 2019, desde https://ingenieriadesoftware.es/herramientas-uml/

[5] Límaco, D. S. (n.d.). UML en NetBeans. Consultado en mayo 1, 2019, desde


https://www.apuntesdejava.com/2015/12/uml-en-netbeans.html

[6] Drawing UML with PlantUML. Language Reference Guide (Version 8023). (2019). 1st ed.
[ebook] Disponible en: https://deepu.js.org/svg-seq-diagram/Reference_Guide.pdf
[Consultado en 1 mayo 2019].

[7] El Enfoque Orientado a Objetos - Paradigmas de la Ingeniería de Software. (n.d.).


Consultado en mayo 1, 2019, disponible en
https://sites.google.com/site/paradigmasdelais/4-2-el-enfoque-orientado-a-objetos

[8] Exes. (n.d.). Cursos oracle, cursos java, master oracle, master java, formaci. Consultado
en mayo 1, 2019, disponible en http://www.mundojava.net/definicion-de-constructores-de-
una-clase.html?Pg=java_inicial_4_4_5.html

[9] Lemay, L. & Perkins, C. (1996). Aprendiendo Java en 21 días. Mexico: Prentice Hall
Hispanoamericana.

[10] Eckel, B. (2002). Piensa en Java. Madrid: Prentice Hall.

[11] Jalón, J. G. (1999). Aprenda Java como si estuviera en primero. S.l.: S.n.

[12] Bibiana ROSSI, Paola BRITOS y Ramón GARCIA MARTINEZ. MODELADO DE


OBJETOS, CAPIS - Centro de Actualización Permanente en Ingeniería de Software
Escuela de Posgrado. ITBA.

[13] Booch, G., Rio, A. C., & Manuel, C. L. (1996). Análisis y diseño orientado a objetos con
aplicaciones. Argentina: Addison-Wesley/Díaz de Santos.

[14] Aguilar, L. (2003). Fundamentos de programación: algoritmos, estructura de datos y


objetos. Madrid: McGraw-Hill.

[15] Aguilar, L. (2008). Fundamentos de programación: algoritmos, estructuras de datos y


objetos. España: McGraw-Hill/Interamericana.

[16] César, Marín López. DOCPLAYER. Rúbrica para Evaluación de Proyectos de


Programación (Modelo T). [En línea] https://docplayer.es/16465320-Rubrica-para-
evaluacion-de-proyectos-de-programacion-modelo-t-ciencia-tecnologia-y-ambiente-
departamento-academico-desarrollo-tecnologico.html.

Departamento de Sistemas y Computación Página 111


[17] UNAM. portalacademico.cch.unam.mx. RUBRICA PARA EVALUAR EL REPORTE DE
LA PRÁCTICA. [En línea]
https://portalacademico.cch.unam.mx/materiales/prof/matdidac/sitpro/exp/quim/quim2/qui
micII/525542524943415f504152415f4556414c5541525f454c5f5245504f5254455f44455f
4c415f5f5052c3814354494341.pdf.

[18] Evaluación de prácticas de programación mediante rúbricas en Moodle. Vaca, Juan


Manuel, Agudo, J, Enrique y Sánchez, Héctor. Oviedo: s.n., 11 de julio de 2014, Actas de
las XX JENUI, págs. 107-114.

Departamento de Sistemas y Computación Página 112


Anexo A. Rubrica
Para la evaluación de esta práctica se recomienda la siguiente rúbrica [16][17][18],
que tiene una escala de 1% a 100%.

Criterios Deficiente Regular Bueno Muy Bueno


1% a 5% 6% a 10% 11% a 15% 16% a 20%
El documento El documento Además, no tiene Además, está bien
no cumple con cumple con la errores redactado y tiene
Documento la estructura y estructura y ortográficos y coherencia de
formato formato gramaticales. contenido.
explicitado explicitado por el
por el docente. docente.
1% a 7% 8% a 15% 16% a 23% 24% a 30%
Utiliza Utiliza Utiliza las Utiliza las
instrucciones instrucciones y instrucciones instrucciones
y algoritmos que no y algoritmos y algoritmos más
algoritmos que son necesarios adecuados para
Codificación no acordes para para resolver el resolver
resuelven el resolver el ejercicio, el ejercicio. Usa
ejercicio. ejercicio. aunque no son los buenas prácticas
más de codificación.
adecuados.
1% a 12% 13% a 24% 25% a 37% 38% a 50%
No funciona. El funcionamiento El funcionamiento El funcionamiento
Funcionamiento tiene fallos tiene fallos sin es completo.
importantes. importancia.

Departamento de Sistemas y Computación Página 113


Anexo B. Plantilla del reporte de
practicas.
PRÁCTICA [Número de práctica]. [Nombre de la práctica]
Lugar: [Nombre del laboratorio]

Duración: [Total de sesiones de n horas]

Grupo: [Materia, hora, año/mes, Profesor]

Integrantes: [Lista de los alumnos que realizaron la práctica]

1. Introducción
2. Objetivo (Competencia)
3. Fundamento
4. Procedimiento (Descripción)
4.1 Equipo necesario
4.2 Material de Apoyo
4.3 Desarrollo de la Práctica
4.4 Cálculos y reporte
5. Resultados y Conclusiones
6. Anexos
7. Bibliografía

Departamento de Sistemas y Computación Página 114


Anexo C. Reglamento interno para el
uso de laboratorios.
Con la finalidad de optimizar el uso del Laboratorio y acatando los lineamientos de
nuestras autoridades, hacemos de su conocimiento el siguiente:

REGLAMENTO

OBLIGACIONES DE LOS ALUMNOS:


1. Queda estrictamente prohibido introducir alimentos o bebidas al laboratorio
(incluyendo dulces y chicles).
2. Durante su permanencia en el laboratorio deberán mostrar su cultura no profiriendo
palabras obscenas y no dejando papeles o basura en las mesas o piso.
3. Queda estrictamente prohibido utilizar el laboratorio para estudiar o elaborar tareas,
ya que las salas están programadas únicamente para clases, cursos o prácticas. Para
estudiar y elaborar tareas el Centro de Información se encuentra debidamente
equipado para estos fines
4. A los alumnos que no tengan clase, curso o práctica en el laboratorio, les queda
estrictamente prohibido el acceso a dicha área. Únicamente pueden entrar al
laboratorio si el maestro está presente, ya que él es el responsable del grupo.
5. Al término de sus clases, cursos o prácticas, es obligación de todos los usuarios
apagar las computadoras (CPU, monitor) y acomodar las sillas en su lugar (una por
computadora y las restantes cerca de la pared).
6. Por ningún motivo pueden desconectar los cables de la computadora o de los
periféricos que se les asignó.
7. En caso de que no funcione correctamente el mouse, cables, teclado o CPU,
reportarlo inmediatamente al maestro, ya que ustedes son responsables de las
computadoras que se les asignó desde un principio, (para que éste a su vez nos lo
haga saber y arreglar el problema).
8. Los alumnos prestantes del Servicio Social cumplen con una función encomendada
por las autoridades escolares, por lo tanto, las posibles reclamaciones deberán
hacerlas los usuarios directamente a los coordinadores del laboratorio, por ningún
motivo sus compañeros de Servicio Social tolerarán un trato injustificado.
9. Sin excepción, cualquier usuario que sea sorprendido instalando juegos, utilizando
los juegos ya instalados, borrando o alterando la información que contengan las
máquinas, así como desconectándolas o haciendo uso indebido de ellas, será
suspendido definitivamente del laboratorio, y será reportado a las autoridades
escolares para que sea sancionado de acuerdo al reglamento del Instituto.

Es necesario recordar que estamos formando alumnos a un nivel profesional y que el


esfuerzo de la Institución a que pertenecemos es trabajo de muchas generaciones, por lo
cual te pedimos nos ayudes a conservar para tu propio beneficio en el mejor estado, la
infraestructura de que dispone el Instituto Tecnológico de San Luis Potosí.

Departamento de Sistemas y Computación Página 115

También podría gustarte