DIVISIÓN DE INGENIERÍAS CAMPUS IRAPUATO - SALAMANCA

UNIVERSIDAD DE GUANAJUATO

TP01:

Generación de Imágenes de Patrones en Blanco y Negro

Alumno: Murrieta Camargo Oscar Andrés

Instructor : Dr. Carlos Hugo Garcı́a Capulı́n.

1 de Febrero de 2018
1. Introducción
Una imagen, matemáticamente, es una matriz de pixeles. Un pixel es un dato de un byte, donde se almacena infor-
mación numérica dentro del rango de 0 a 255. Esta escala indica el nivel de color que se encuentra en el pixel, donde
el cero representa el color negro y el 255 el blanco, si la imagen se encuentra en escala de grises. Existen diversos
formatos de imágenes, y en esta tarea se utiliza el formato .bmp.

En esta actividad, se crearán una serie de imágenes con el objetivo de modificar cada uno de los pixeles y formar
ası́ una figura en escala de grises. La herramienta a utilizar para llevar a cabo la actividad, es el lenguaje de
programación C, donde se ha facilitado el código capáz de generar, abrir, guardar y editar imágenes en formato
.bmp en escala de grises. De la misma manera, mediante código se crearán las imágenes encomendadas.

2. Desarrollo
Dado que sólo se implementó un código ya realizado para el procesamiento de una imagen, se explicarán las fun-
ciones creadas por el alumno para llevar a cabo la tarea.

Primero, se declararon seis punteros por separado para cada una de las imágenes a realizar. Se observó que se
pueden reducir y simplificar la manipulación de dichos punteros mediante una estructura de punteros a la clase.
Después se procede a asignar un espacio suficiente en la memoria de la máquina para guardar la imagen del tamaño
requerido. Las indicaciones descritas se muestran en el código siguiente:
i n t main ( v o i d )
{ /∗ D e c l a r a r un Puntero a imagen
D e c l a r a c i o n de p u n t e r o s a e s t r u c t u r a s de i m a g e n e s
S e i s p u n t e r o s en t o t a l , cada uno r e g e r e n t e a cada ∗/
gcIMG ∗Img2 ;
gcIMG ∗Img3 ;
gcIMG ∗Img4 ;
gcIMG ∗Img5 ;
gcIMG ∗Img6 ;
gcIMG ∗Img7 ;
unsigned i n t i , j , k , l ;
unsigned i n t col w , c o l h ;
i n t aux , aux2 ;

/∗ F u n c i o n e s para c r e a r l a s i m a g e n e s n e c e s a r i a s para l a t a r e a ∗/
Img2 = gcNewImg ( 6 4 0 , 4 8 0 ) ;
Img3 = gcNewImg ( 6 4 0 , 4 8 0 ) ;
Img4 = gcNewImg ( 6 4 0 , 4 8 0 ) ;
Img5 = gcNewImg ( 6 4 0 , 4 8 0 ) ;
Img6 = gcNewImg ( 6 4 0 , 4 8 0 ) ;
Img7 = gcNewImg ( 6 4 0 , 4 8 0 ) ;
// mensaje en p a n t a l l a .
p r i n t f ( ” \n\ t \ t Generando im \ ’ a g e n e s \n\n” ) ;

2.1. Barras Horizontales y Verticales

La primera función realizada fue la de realizar un algoritmo para crear una imagen que se seccionará en siete
segmentos a lo ancho de la imagen, creando barras y pintándolas de blanco y negro alternadamente. Para esto, se
utilizó la operación módulo para verificar si el ancho es múltiplo de siete, para el caso particular. De no ser ası́, se
resta el sobrante con el resultado que da la operación mencionada y el resultado se guarda en una variable llamada
col w. El operador ? : es utilizado para evaluar dicha condición.

Tres ciclos for anidados se utilizaron para llenar cada pixel de un número, ya sea 0 (negro) o 255 (blanco). El
primero realiza el barrido vertical en la imagen. El segundo es un ciclo de control, para ir contando la cantidad de
barras verticales que se han trazado. Ası́ mismo se utiliza la variable auxiliar aux para contar el número de pixeles
que se han coloreado. Y el tercer ciclo se utiliza para hacer el barrido horizontal. En este último ciclo se encuentra
nuevamente el operador ? : quien evalúa si la variable i es par o impar, con el fin de saber si se pintaran los cuadros

1
de blanco o negro.

El código implementado se muestra a continuación:

c o l w = ( Img2−>ancho % 7 ) == 0 ? Img2−>ancho / 7 : ( Img2−>ancho − ( Img2−>ancho % 7 ) ) / 7 ;

f o r ( k = 0 ; k < Img2−>a l t o ; k++)
f o r ( i = 0 ; i < 7 ; i ++)
{
aux = i ∗ c o l w ;
f o r ( j = 0 ; j < c o l w ; j ++)
Img2−>imx [ k∗Img2−>ancho+aux+j ] = ( i %2) ? 0 : 2 5 5 ;
}

Para hacer trazados de barras horizontales se hizo un procedimiento similar. Sólo que en este ejercicio el ciclo
exterior es el de control, y los dos interiores para hacer los barridos vertical y horizontal. Nuevamente se utiliza la
variable de cotrol aux para llevar el conteo de los pixeles coloreados. La condición para el cambió de color es la
misma descrita en el proceso anterior.

El algoritmo de esta función es el siguiente:

c o l h = ( Img3−>a l t o % 6 ) == 0 ? Img3−>a l t o / 6 : ( Img3−>a l t o − ( Img3−>a l t o % 6 ) ) / 6 ;

f o r ( i = 0 ; i < 6 ; i ++)
f o r ( k = 0 ; k < c o l h ; k++)
{
aux = i ∗ c o l h ;
f o r ( j = 0 ; j < Img3−>ancho ; j ++)
Img3−>imx [ ( k+aux ) ∗Img3−>ancho + j ] = ( i %2) ? 255 : 0 ;
}

2.2. Tablero de Ajedrez

Del mismo modo que en las imágenes anteriores, se divide la imagen en partes iguales a lo largo y a lo ancho,
guardándolas en las variables auxiliares col h y col w. En este caso se utilizarán cinco ciclos for anidados.

El ciclo externo se utiliza para llevar un conteo de las columnas que ya se han asignado un valor. Esto mediante la
variable de control aux que guarda dicho dato. El segundo ciclo es para hacer el barrido vertical, según el número
guardado en col h. El tercer ciclo realiza un conteo de cuadros a lo ancho, guardando el número de pixeles colorea-
dos en la variable de control aux2. El cuarto ciclo realiza el barrido horizontal, según la variable auxiliar col w. En
este último se encuentra un operador de condición if-else que varı́a el color según el número de filas pintadas y el
operador ? : para controlar el número de columnas pintadas, también para alternar el color.

El código es el que se muestra a continuación:

c o l w = ( Img4−>ancho % 4 ) == 0 ? Img4−>ancho / 4 : ( Img4−>ancho − ( Img4−>ancho % 4 ) ) / 4 ;
c o l h = ( Img4−>a l t o % 5 ) == 0 ? Img4−>a l t o / 5 : ( Img4−>a l t o − ( Img4−>a l t o % 5 ) ) / 5 ;
f o r ( i = 0 ; i < 5 ; i ++){
aux = i ∗ c o l h ;
f o r ( j = 0 ; j < c o l h ; j ++){
f o r ( k = 0 ; k < 4 ; k++){
aux2 = k∗ c o l w ;
f o r ( l = 0 ; l < c o l w ; l ++){
i f ( i %2)
Img4−>imx [ ( aux + j ) ∗Img4−>ancho + aux2 + l ] = ( k %2) ? 0 : 2 5 5 ;
else
Img4−>imx [ ( aux + j ) ∗Img4−>ancho + aux2 + l ] = ( k %2) ? 255 : 0 ;
}
}
}
}

2
2.3. Diagonales
Dos ciclos anidados se utilizaron para esta tarea. El primero hace el barrido a lo alto e inicializa dos variables de
control i, k. El segundo realiza el barrido a lo ancho. Dentro de este ciclo se realiza una condición donde se evalúa
si k tiene un número cuyo módulo sea igual a cero y si k es diferente de cero. En dado caso que ambas condiciones
sean ciertas, k es incrementado en uno, en caso contrario no se modifica su valor. Esto con objetivo de tener una
diagonal de esquina a esquina de la imagen. Por último, tenemos la operación para llenar donde está otra condición
que evalúa si el número de pixeles que va coloreando a lo ancho es menor que k, de ser cierto se pinta el pixel de
negro, de lo contrario se asigna el blanco.

A continuación podemos observar el código.

f o r ( i = 0 , k = 0 ; i < Img5−>a l t o ; i ++,k++)

{
f o r ( j = 0 ; j < Img5−>ancho ; j ++)
{
k = ( ( ( k %4==0)&&(k !=0) ) ? k+1 : k ) ;
Img5−>imx [ i ∗Img5−>ancho + j ] = ( ( j < k ) ? 0 : 2 5 5 ) ;
}
}

La otra imagen con una diagonal, se señalo que tiene una pendiente invertida a la primera, por lo que la variable k
inicia en su valor máximo que es el ancho de la imagen y se decrementa con cada ciclo.

El código es el siguiente:

f o r ( i = 0 , k = Img6−>ancho ; i < Img5−>a l t o ; i ++,k−−)

{
f o r ( j = 0 ; j < Img5−>ancho ; j ++)
{
k = ( ( ( k %4==0)&&(k !=0) ) ? k−1 : k ) ;
Img5−>imx [ i ∗Img5−>ancho + j ] = ( ( j < k ) ? 255 : 0 ) ;
}
}

2.4. Espiral
La última imagen creada fue una espiral. El primer paso fue seccionar la imagen a lo largo y ancho, guardando los
resultados en las variables col h, col w y a su vez aux y aux2, respectivamente.

Se implementan tres ciclos anidados y dos if de las lı́neas 169 - 188 del código, para crear las lı́neas horizontales de
la parte inferior a la mitad a lo largo. En la lı́nea 190 se encuentra un else para crear las lı́neas horizontales restantes.

Al terminar las lı́neas horizontales, se terminan los ciclos dando lugar a un par de ciclos for anidados, quienes se
encargan de hacer los trazos verticales cerrando ası́ la espiral.

El código es el que se muestra a continuación

c o l h = ( Img7−>a l t o − ( Img7−>a l t o %12) ) / 1 2 ;

c o l w = ( Img7−>ancho − ( Img7−>ancho %16) ) / 1 6 ;
aux = c o l w ;
aux2 = c o l h ;

3
f o r ( i =0; i <Img7−>a l t o ; i ++)
{
i f ( i <=(aux ∗ 6 ) )
{
f o r ( j =0 , l =0; j <Img7−>ancho ; j ++)
{
Img7−>imx [ i ∗ Img7−>ancho + j ] = 2 5 5 ;
i f ( ( i==c o l h )&&( j ==(c o l w −aux ) ) )
{
do {
Img7−>imx [ i ∗ Img7−>ancho + j ] = 0 ;
j ++;
} w h i l e ( ( j <(Img7−>ancho−c o l w ) ) ) ;
l = 1;
}
}
}
else
f o r ( j =0 , l =0; j <Img7−>ancho ; j ++) // c i c l o para h a c e r b a r r i d o a l o ancho
{
Img7−>imx [ i ∗ Img7−>ancho + j ] = 2 5 5 ;
i f ( ( i==c o l h )&&( j ==(c o l w ) ) )
{
do {
Img7−>imx [ i ∗ Img7−>ancho + j ] = 0 ;
j ++;
} w h i l e ( ( j <(Img7−>ancho−c o l w ) ) ) ;
l = 1;
}
}
if (l )
{
c o l w = ( ( i >=(aux2 ∗ 6 ) ) ? c o l w −aux : c o l w + aux ) ;
c o l h += aux2 ;
}
}
c o l h =aux2 ;
c o l w = aux ;
f o r ( i = 0 ; i < 5 ; i ++)
{
f o r ( j = c o l h ; j <(Img7−>a l t o −c o l h ) ; j ++)
{
Img7−>imx [ ( j+aux2 ) ∗Img7−>ancho + c o l w ] = ( ( ( ( j+aux2 ) >= c o l h )&&( j < ( Img7−>a l t o − c o l h −aux2
+1) ) ) ? 0 : 2 5 5 ) ;
Img7−>imx [ ( j ) ∗Img7−>ancho + Img7−>ancho−c o l w ] = 0 ;
}
c o l h +=aux2 ;
c o l w +=aux ;
}

2.5. Guardar y Liberar

La última tarea hacer es guardar las imágenes y liberar las mismas, como se muestra en la siguiente fracción de
código:

gcPutImgBmp ( ” Ejemplo2 . bmp” , Img2 ) ;

gcPutImgBmp ( ” Ejemplo3 . bmp” , Img3 ) ;
gcPutImgBmp ( ” Ejemplo4 . bmp” , Img4 ) ;
gcPutImgBmp ( ” Ejemplo5 . bmp” , Img5 ) ;
gcPutImgBmp ( ” Ejemplo6 . bmp” , Img6 ) ;
gcPutImgBmp ( ” Ejemplo7 . bmp” , Img7 ) ;

gcFreeImg ( Img2 ) ;
gcFreeImg ( Img3 ) ;
gcFreeImg ( Img4 ) ;
gcFreeImg ( Img5 ) ;

4
 gcFreeImg ( Img6 ) ;
gcFreeImg ( Img7 ) ;

El código total quedó de la siguiente forma:

i n t main ( v o i d )
{ // D e c l a r a r un Puntero a imagen
// D e c l a r a c i o n de p u n t e r o s a e s t r u c t u r a s de i m a g e n e s
// S e i s p u n t e r o s en t o t a l , cada uno r e f e r e n t e a cada
gcIMG ∗Img2 ;
gcIMG ∗Img3 ;
gcIMG ∗Img4 ;
gcIMG ∗Img5 ;
gcIMG ∗Img6 ;
gcIMG ∗Img7 ;
unsigned i n t i , j , k , l ;
unsigned i n t col w , c o l h;
i n t aux , aux2 ;

// F u n c i o n e s para c r e a r l a s i m a g e n e s n e c e s a r i a s para l a t a r e a
Img2=gcNewImg ( 6 4 0 , 4 8 0 ) ;
Img3=gcNewImg ( 6 4 0 , 4 8 0 ) ;
Img4=gcNewImg ( 6 4 0 , 4 8 0 ) ;
Img5=gcNewImg ( 6 4 0 , 4 8 0 ) ;
Img6=gcNewImg ( 6 4 0 , 4 8 0 ) ;
Img7=gcNewImg ( 6 4 0 , 4 8 0 ) ;
// mensaje en p a n t a l l a .
p r i n t f ( ” \n\ t \ t Generando im \ ’ a g e n e s \n\n” ) ;
// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
// Codigo para g e n e r a r b a r r a s b l a n c a s y n e g r a s a l t e r n a d a s v e r t i c a l e s .

// Se v e r i f i c a que l a s b a r r a s te ng an e s p e s o r i g u a l
c o l w = ( Img2−>ancho % 7 ) == 0 ? Img2−>ancho / 7 : ( Img2−>ancho − ( Img2−>ancho % 7 ) ) / 7 ;
// Primer c i c l o f o r para h a c e r e l b a r r i d o v e r t i c a l .
f o r ( k = 0 ; k < Img2−>a l t o ; k++)
// segundo f o r a l t e r n a l a s columnas
f o r ( i = 0 ; i < 7 ; i ++)
{
// V a r i a b l e a u x i l i a r aux que guarda e l numero de p i x e l donde i n i c i a e l c o l o r b l a n c o / n e g r o .
aux = i ∗ c o l w ;
f o r ( j = 0 ; j < c o l w ; j ++)
// Funcion que a l t e r n a l o s c o l o r e s
Img2−>imx [ k∗Img2−>ancho+aux+j ] = ( i %2) ? 0 : 2 5 5 ;
}

// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// Codigo para g e n e r a r b a r r a s b l a n c a s y n e g r a s a l t e r n a d a s h o r i z o n t a l e s .

// Se v e r i f i c a que l a s b a r r a s te ng an e s p e s o r i g u a l
c o l h = ( Img3−>a l t o % 6 ) == 0 ? Img3−>a l t o / 6 : ( Img3−>a l t o − ( Img3−>a l t o % 6 ) ) / 6 ;
// Primer f o r a l t e r n a l a s columnas
f o r ( i = 0 ; i < 6 ; i ++)
// segundo f o r para c o n t r o l a r e l numero e x a c t o de p i x e l e s en e l a l t o de cada columna
f o r ( k = 0 ; k < c o l h ; k++)
{
// V a r i a b l e a u x i l i a r aux que guarda e l numero de p i x e l donde i n i c i a e l cambio de c o l o r b l a n c o / n e g r o
.
aux = i ∗ c o l h ;
f o r ( j = 0 ; j < Img3−>ancho ; j ++)
// Funcion que a l t e r n a l o s c o l o r e s
Img3−>imx [ ( k+aux ) ∗Img3−>ancho + j ] = ( i %2) ? 255 : 0 ;
}

// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// c o d i g o para g e n e r a r un t a b l e r o de a j e d r e z
// D i m e n s i o n e s de l o s c u a d r o s , ancho y a l t o , r e s p e c t i v a m e n t e .

5
 c o l w = ( Img4−>ancho % 4 ) == 0 ? Img4−>ancho / 4 : ( Img4−>ancho − ( Img4−>ancho % 4 ) ) / 4 ;
c o l h = ( Img4−>a l t o % 5 ) == 0 ? Img4−>a l t o / 5 : ( Img4−>a l t o − ( Img4−>a l t o % 5 ) ) / 5 ;

// C i c l o s f o r a n i d a d o s p a r a c o l o r e a r c u a d r o s d e l ancho y a l t o s c a l c u l a d o s en b l a n c o y n e g r o
f o r ( i = 0 ; i < 5 ; i ++) // C i c l o que i n d i c a e l numero de c u a d r o s por f i l a .
{
aux = i ∗ c o l h ; // V a r i a b l e a u x i l i a r aux para l l e v a r c o n t e o d e l numero de p i x e l e s y de
a l t u r a de l o s c u a d r o s
f o r ( j = 0 ; j < c o l h ; j ++) // c i c l o para l l e n a r segun l a a u l t u r a c a l c u l a d a
{
f o r ( k = 0 ; k < 4 ; k++) // c i c l o que i n d i c a en numero de c u a d r o s por columna .
{
aux2 = k∗ c o l w ; // V a r i a b l e a u x i l i a r aux2 para l l e v a r c o n t e o d e l numero de p i x e l e s y
de ancho de l o s c u a d r o s
f o r ( l = 0 ; l < c o l w ; l ++) // C i c l o para l l e n a r segun e l ancho de l o s c u a d r o s
{
i f ( i %2) // c o l o r e a una f i l a empezando por n e g r o
Img4−>imx [ ( aux + j ) ∗Img4−>ancho + aux2 + l ] = ( k %2) ? 0 : 2 5 5 ;
e l s e // c o l o r e a una f i l a empezando por b l a n c o
Img4−>imx [ ( aux + j ) ∗Img4−>ancho + aux2 + l ] = ( k %2) ? 255 : 0 ;
}
}
}
}
// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// Funcion para t r a z a r un t r i a n g u l o en una imagen

// p r i m e r c i c l o f o r para h a c e r b a r r i d o en f i l a s
f o r ( i = 0 , k = 0 ; i < Img5−>a l t o ; i ++,k++)
{
// segundo c i c l o f o r para h a c e r b a r r i d o en columnas .
f o r ( j = 0 ; j < Img5−>ancho ; j ++)
{
// s e e n c o n t r o l a r e l a c i o n de l a r e c t a y = ( 3 / 4 ) x , l o que i n d i c a que s e avanzan 3 p i x e l e s en l o
alto
// m i e n t r a s que en l o ancho 4 .
k = ( ( ( k %4==0)&&(k !=0) ) ? k+1 : k ) ; // f u n c i o n que e n c u e n t r a numeros d i v i s i b l e s e n t r e
// 4 y l l e v a r l a r e l a c i o n de l a r e c t a .
Img5−>imx [ i ∗Img5−>ancho + j ] = ( ( j < k ) ? 0 : 2 5 5 ) ; // Asigna e l c o l o r de l o s p i x e l e s .
}
}

// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// Funcion para t r a z a r un t r i a g u l o en una imagen

// p r i m e r c i c l o f o r para h a c e r b a r r i d o en f i l a s
f o r ( i = 0 , k = Img6−>ancho ; i < Img6−>a l t o ; i ++,k−−)
{
// segundo c i c l o f o r para h a c e r b a r r i d o en columnas .
f o r ( j = 0 ; j < Img6−>ancho ; j ++)
{
// s e e n c o n t r o l a r e l a c i o n de l a r e c t a y = −(3/4) x + 4 8 0 , l o que i n d i c a que s e avanzan 3 p i x e l e s
en l o a l t o
// m i e n t r a s que en l o ancho 4 .
k = ( ( ( k %4==0)&&(k !=0) ) ? k−1 : k ) ; // f u n c i o n que e n c u e n t r a numeros d i v i s i b l e s e n t r e
// 4 y l l e v a r l a r e l a c i o n de l a r e c t a .
Img6−>imx [ i ∗Img6−>ancho + j ] = ( ( j < k ) ? 255 : 0 ) ; // Asigna e l c o l o r de l o s p i x e l e s .
}
}

// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// Funcion para c r e a r un e s p i r a l .

// s e c c i o n a a l o l a r g o y a l o ancho l a imagen para l a e s p i r a l .

c o l h = ( Img7−>a l t o − ( Img7−>a l t o %12) ) / 1 2 ;
c o l w = ( Img7−>ancho − ( Img7−>ancho %16) ) / 1 6 ;

// V a r i a b l e s a u x i l i a r e s aux y aux2 para g u a r d a r l a s e p a r a c i o n e n t r e l i n e a s

6
 aux = c o l w ;
aux2 = c o l h ;

// S e c c i o n para c r e a r l a s l i n e a s h o r i z o n t a l e s .

// C i c l o para h a c e r b a r r i d o a l o a l t o
f o r ( i =0; i <Img7−>a l t o ; i ++)
{
// S e c c i o n que g e n e r a l a p r i m e r a mitad de l a s l i n e a s h o r i z o n t a l e s
i f ( i <=(aux ∗ 6 ) )
{
// C i c l o f o r para h a c e r b a r r i d o a l o ancho
f o r ( j =0 , l =0; j <Img7−>ancho ; j ++)
{
Img7−>imx [ i ∗ Img7−>ancho + j ] = 2 5 5 ; // cambia de c o l o r a b l a n c o t o d o s l o s p i x e l e s
i f ( ( i==c o l h )&&( j ==(c o l w −aux ) ) ) // C o n d i c i o n para e n c o n t r a r l a s c o o r d e n a d a s
precisas
// para t r a z a r l a l i n e a
{
do { // C i c l o do−w h i l e para p i n t a r de n e g r o l a l i n e a h o r i z o n t a l d e l e s p i r a l
Img7−>imx [ i ∗ Img7−>ancho + j ] = 0 ;
j ++;
} w h i l e ( ( j <(Img7−>ancho−c o l w ) ) ) ;
l = 1 ; // v a r i a b l e de c o n t r o l l para v e r i f i c a r que s e t r a z o una l i n e a d e l
espiral
}
}
}
// C o n d i c i o n e l s e para t r a z a r l a s l i n e a s s u p e r i o r e s h o r i z o n t a l e s
else
f o r ( j =0 , l =0; j <Img7−>ancho ; j ++) // c i c l o para h a c e r b a r r i d o a l o ancho
{
Img7−>imx [ i ∗ Img7−>ancho + j ] = 2 5 5 ; // cambia de c o l o r a b l a n c o t o d o s l o s p i x e l e s
i f ( ( i==c o l h )&&( j ==(c o l w ) ) ) // C o n d i c i o n para e n c o n t r a r l a s c o o r d e n a d a s p r e c i s a s
{
do { // C i c l o do−w h i l e para p i n t a r de n e g r o l a l i n e a h o r i z o n t a l d e l e s p i r a l
Img7−>imx [ i ∗ Img7−>ancho + j ] = 0 ;
j ++;
} w h i l e ( ( j <(Img7−>ancho−c o l w ) ) ) ;
l = 1 ; // v a r i a b l e de c o n t r o l l para v e r i f i c a r que s e t r a z o una l i n e a d e l e s p i r a l
}
}
if (l )
{
c o l w = ( ( i >=(aux2 ∗ 6 ) ) ? c o l w −aux : c o l w + aux ) ; // Ai , emta o decrementa e l e s p a c i o
// e n t r e l i n e a s a l o ancho .
c o l h += aux2 ; // I n c r e m e n t a e l e s p a c i o e n t r e l i n e a s a l o l a r g o .
}
}

// S e c c i o n d e l programa para t r a z a r l a s l i n e a s v e r t i c a l e s d e l e s p i r a l .
c o l h =aux2 ; // i n i c i a l i z a c i o n de l a v a r i a b l e c o l h a s i g n a n d o e l v a l o r d e l e s p a c i o e n t r e
// l i n e a s v e r t i c a l e s
c o l w = aux ; // i n i c i a l i z a c i o n de l a v a r i a b l e c o l w a s i g n a n d o e l v a l o r d e l e s p a c i o e n t r e
// l i n e a s h o r i z o n t a l e s

// C i c l o f o r que hace un c o n t e o de l i n e a s v e r t i c a l e s de un l a d o .
f o r ( i = 0 ; i < 5 ; i ++)
{
// C i c l o f o r para h a c e r un b a r r i d o v e r t i c a l
f o r ( j = c o l h ; j <(Img7−>a l t o −c o l h ) ; j ++)
{
// c o d i g o para t r a z a r l a s l i n e a s v e r t i c a l e s de l a d e r e c h a de l a imagen .
Img7−>imx [ ( j+aux2 ) ∗Img7−>ancho + c o l w ] = ( ( ( ( j+aux2 ) >= c o l h )&&( j < ( Img7−>a l t o −
c o l h −aux2 +1) ) ) ? 0 : 2 5 5 ) ;
// c o d i g o para t r a z a r l a s l i n e a s v e r t i c a l e s de l a i z q u i e r d a de l a imagen .
Img7−>imx [ ( j ) ∗Img7−>ancho + Img7−>ancho−c o l w ] = 0 ;
}
// v a r i a b l e s de c o n t r o l para i n d i c a r l a s e p a r a c i o n e n t r e l i n e a s .
c o l h +=aux2 ;
c o l w +=aux ;

7
 }
// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
gcPutImgBmp ( ” Ejemplo2 . bmp” , Img2 ) ;
gcPutImgBmp ( ” Ejemplo3 . bmp” , Img3 ) ;
gcPutImgBmp ( ” Ejemplo4 . bmp” , Img4 ) ;
gcPutImgBmp ( ” Ejemplo5 . bmp” , Img5 ) ;
gcPutImgBmp ( ” Ejemplo6 . bmp” , Img6 ) ;
gcPutImgBmp ( ” Ejemplo7 . bmp” , Img7 ) ;
// L i b e r a l a Imagen u t i l i z a d a
gcFreeImg ( Img2 ) ;
gcFreeImg ( Img3 ) ;
gcFreeImg ( Img4 ) ;
gcFreeImg ( Img5 ) ;
gcFreeImg ( Img6 ) ;
gcFreeImg ( Img7 ) ;
return 0;
}

3. Pruebas y resultados
Se hicieron varias pruebas en cada imagen, ya que el resultado no fue el esperado en primera instancia. Algunos
fueron a prueba y error y otros realizando nuevamente algún algoritmo

En la imagen con barras verticales, se seccionaron en siete segmentos alternando los colores entre negro y blanco.
Esto se muestra en la Figura 1.

Figura 1: Imagen con siete barras verticales.

La segunda imagen fue un procedimiento similar al anterior, pero ahora las barras son verticales y son 6, como se
visualiza en la Figura 2

8
 Figura 2: Imagen con seis barras horizontales.

La tercer imagen contiene algo similar a un tablero de ajedrez, pero con veinte casillas en total. Se observa el
resultado en la Figura 3

Figura 3: Tablero de ajedrez.

En la cuarta imagen se creó una diagonal con pendiente positiva, donde cada mitad es de diferente color (Figura 4).

Figura 4: Diagonal con pendiente positiva.

Y la imagen con una pendiente negativa se aprecia en la Figura 5

9
 Figura 5: Diagonal con pendiente negativa.

Por último se generó una espiral dentro de la imagen, con el fondo blanco y la espirar en negro. Esta imagen fue la
más complicada de implementar. Se muestra en la Figura 6

Figura 6: Espiral.

4. Conclusión
A simple vista los ejercicios parecı́an sencillos de realizar, sin embargo son algoritmos que necesitan mucha lógica
para llevarlos a cabo. En un principio se pensaba que el barrido comenzaba en la parte superior izquierda de la
imagen, lo cual no fue ası́, sino comienza en la parte inferior izquierda, observación que fue de gran ayuda para
corregir errores en la programamción. Por último el tema de procesamiento de imágenes es muy interesante, el poder
manipular y sacar información de una imagen es un tema de mucha aplicación.

10