next up previous contents
Next: Lista de Figuras Up: Programas gráficos desarrollados en Previous: ACOSXM   Contenido

Construcción del programa ACOSXM

Para poder desarrollar una aplicación con WebObjects se emplean dos herramientas importantes, la primera de ellas es el Project Builder Figura A.6 que permite manejar todos los recursos que usaremos a través de la construcción del proyecto.

Figura A.6: Project Builder
\includegraphics[width= 4.0in]{imagenes/apendice/proyecto/1.eps}

La segunda herramienta importante es el Interface Builder Figura A.7 que permite crear nuestra interface gráfica de una manera muy sencilla.

Figura A.7: Interface Builder
\includegraphics[width= 2.0in]{imagenes/apendice/proyecto/2.eps}

Primero abriremos el Project Builder y crearemos un proyecto nuevo de tipo aplicación como se ilustra en la Figura A.8.

Figura A.8: Proyecto de tipo aplicación
\includegraphics[width= 4.0in]{imagenes/apendice/proyecto/3.eps}

El Project Builder creará un folder con el nombre que se le dio a la aplicación que contendrá todos los archivos necesarios que necesatará el proyecto, en el primer browser de izquierda a derecha nos muestra la clasificación de recursos que podemos usar, para empezar a construir la interface gráfica daremos un click en Interfaces y doble click en el archivo life2dm.nib, esto provocará que se abra automáticamente el Interface Builder como se muestra en la Figura A.9.

Figura A.9: Interface Builder inicial
\includegraphics[width= 4.0in]{imagenes/apendice/proyecto/4.eps}

Emplearemos dos ventanas de tipo NSWindow y arrastraremos los objetos de las paletas del Interface Builder que necesitemos hacia nuestras ventanas, para obtener dos ventanas como el de la Figura A.10 y sus atributos serán definidos a través del Inspector, que se encuentra en Tools $ \rightarrow$ Inspector.

Figura A.10: Ventanas Panel principal y Espacio de evoluciones en dos dimensiones
\includegraphics[width= 6.5in]{imagenes/apendice/proyecto/5.eps}

La ventana de Panel principal tendrá 512 botones de tipo NSButton que cambiarán de la etiqueta 0 a 1 y viceversa, esta matriz de botones se hace seleccionando un botón con la etiqueta 0 y con la tecla Alt le damos un clik a la esquina inferior derecha y sin soltar el ratón lo arrastramos hasta crear una matriz de $ 16 \times32$ botones, despues emplearemos 6 botones que controlarán las acciones de dibujar una configuración aleatoria (Configuración aleatoria), evolucionar paso a paso (Evolución paso a paso), evolucionar de manera continua (Evolución), limpiar el espacio de evoluciones (Limpiar vista), poner reglas aleatorias (Regla aleatoria), limpiar los botones de la regla (Limpiar regla) y finalmente dibujar una configuración como la regla 110 en el espacio de evoluciones (Regla 110). El botón con la etiqueta Evolución deberá tener una etiqueta alterna que se llamará Parar evolución y sera de tipo Toggle con el Inspector. Un objeto view para dibujar la vecindad que representará cada botón, un campo de texto (Células vivas) que contará el número de células vivas en cada generación, un campo de texto (Generaciones) de tipo NSTextField que contará el número de generaciones que se vayan produciendo, dos campos de texto (x, y) que nos indicará la posición cuando una célula sea introducida o borrada en el espacio de evoluciones y un campo de texto (Densidad) que nos indicará la densidad de células en el espacio de evoluciones en una configuración aleatoria, a su vez este campo de texto será manipulado por un objeto de tipo NSSlider. Despues creamos cuatro tipos de subclases en la carpeta Classes de nuestra ventana life2dm.nib, una subclase de tipo NSObject llamada control, dos subclases de tipo NSView llamadas vecindad y life2dM y otra subclase de tipo NSMatrix llamada matriz.

Una vez creadas las clases se crearán sus archivos de código situandonos en el menú Classes $ \rightarrow$ Create Files..., creará los archivos control.h, vecindad.h, matriz.h y life2dm.h en la carpeta Headers del Project Builder, también se crearán los archivos control.m, vecindad.m, matriz.m y life2dm.m en la carpeta Classes del Project Builder. En los archivos Headers se definirán los objetos y las acciones a las que respoderán los objetos que estan en la interface gráfica. La subclase matriz será conectada a la matriz de botones, vecindad al view que se encuentra en el Panel principal, life2dm será conectada al view que representará el espacio de evoluciones y la subclase control controlará la comunicación con todas las demás subclases como se ilustra en la Figura A.11

Figura A.11: Conexión de objetos
\includegraphics[width= 5.0in]{imagenes/apendice/proyecto/6.eps}

La subclase control será instanciada en Classes $ \rightarrow$ Instantiate, los botones mandarán mensajes a la instancia control y estos mandarán mensajes a la subclase que pueda responder. Los objetos tienen asignados métodos a los cuales pueden responder, las clases pueden tener varios métodos que responderán a un mensaje dado, la conexión entre objetos y métodos se hará una vez que se haya realizado la programación correspondiente en cada una de las clases. Finalmente para construir la aplicación en el Project Builder iremos a Tools $ \rightarrow$ ProjectBuild $ \rightarrow$ Build $ \&$ Run y se creará el archivo life2dm.app que es el archivo ejecutable de la aplicación, en los sistemas Acua, Rhapsody y OpenStep, en el caso de Windows NT el archivo se llama life2dm.exe. La transportación únicamente consiste en redefinir el archivo life2dm.nib en el Inspector del Project Builder que está en Tools $ \rightarrow$ Inspector... y compilar en la nueva plataforma, aunque en Windows NT se debe reconstruir en life2dm-windows.nib de lo contrario fallará la construcción del archivo life2dm.exe, en el sistema Acua es recomendable revisar si la Interface no ha sido alterada ya que Mac OS X cuenta con mas objetos y la jerarquía de clases es mas extensa, además a diferencia de las otras plataformas Acua ya no emplea funciones PostScript para dibujar, mas bien objetos que responden a métodos de dibujo. Acontinuación mostraremos la codificación de cada una de las clases. 





/****************** control.h ********************/ 




$ \char93 $import $ <$AppKit/AppKit.h$ >$ 

$ \char93 $import "matriz.h" 

$ \char93 $import "life2dM.h" 

$ \char93 $import "vecindad.h" 




$ @$interface control : NSObject 


$ \{$ 


		 /*Conecta a la clase NSMatrix matriz*/ 


id vista_matriz; 


		 /*Conecta a la clase life2dM*/ 


id vista_view; 


		 /*Conecta a la clase vecindad*/ 


id vista_vecindad; 


$ \}$ 




/*Manda el tag y la posicion de la celula*/ 

-(void)mandarPosicionTag:(id)sender; 


/*Boton paso a paso*/ 

-(void)evolPaso:(id)sender; 


/*Boton evolucion*/ 

-(void)evol:(id)sender; 


/*Limpiar regla*/ 

-(void)limpiarRegla:(id)sender; 


/*Regla aleatoria*/ 

-(void)reglaAleatoria:(id)sender; 




$ @$end 




/****************** control.m ********************/ 




$ \char93 $import "control.h" 


int matriz_regla1[16][32]; 




$ @$implementation control 




/*Manda el tag y la posicion de la celula*/ 

-(void)mandarPosicionTag:(id)sender 


$ \{$ 


int renglon; 


int columna; 


int identificador; 


int estado; 

/*Captura el tag de la celula*/ 


identificador=[[sender selectedCell] tag]; 

/*Captura el renglon y la columna de la matriz*/ 


renglon=[sender selectedRow]; 


columna=[sender selectedColumn]; 

/*Captura el estado*/ 


estado=[[[vista_matriz cellAtRow:renglon column:columna] title] intValue]; 

/*Le manda la posicion, el estado y el identificadora a la clase matriz*/ 
; 

/*Le manda la vecindad a a la clase vecindad*/ 
; 

$ \}$ 




/*Boton paso a paso*/ 

-(void)evolPaso:(id)sender 

$ \{$ 


int i,j; 

/*Llamar a pasoaPaso de la clase life2dM*/ 


for(i=0;i$ <$16;i++) 


for(j=0; j$ <$32; j++) 


matriz_regla1[i][j]=[vista_matriz traerVecindad:i:j]; 

/*Traer la regla de control*/ 


for(i=0;i$ <$16;i++) 


for(j=0;j$ <$32;j++) 
[j]]; 

/*Ejecuta el metodo paso a paso de la clase life2dM*/ 
; 

$ \}$ 




/*Boton evolucion*/ 

-(void)evol:(id)sender 

$ \{$ 


int i,j; 

/*Llamar a pasoaPaso de la clase life2dM*/ 


for(i=0;i$ <$16;i++) 


for(j=0;j$ <$32;j++) 


matriz_regla1[i][j]=[vista_matriz traerVecindad:i:j]; 

/*Traer la regla de control*/ 


for(i=0;i$ <$16;i++) 


for(j=0;j$ <$32;j++) 
[j]]; 

/*Ejecuta el metodo paso a paso de la clase life2dM*/ 
; 

$ \}$ 




/*Limpiar regla*/ 

-(void)limpiarRegla:(id)sender 

$ \{$ 


int i,j; 


for(i=0;i$ <$16;i++) 


for(j=0;j$ <$32;j++) 


matriz_regla1[i][j]=0; 
; 

$ \}$ 




/*Regla aleatoria*/ 

-(void)reglaAleatoria:(id)sender 

$ \{$ 


int i,j; 


float y,flag=0.4; 


time_t segundos; 


time($ \&$segundos); 


srand((unsigned)(segundos $ \%$ 65536)); 


for(i=0;i$ <$16;i++) 

$ \{$ 


for(j=0;j$ <$32;j++) 

$ \{$ 


y = rand()/pow(2,31); 


if(y$ >=$flag) 


matriz_regla1[i][j]=0; 


else 


matriz_regla1[i][j]=1; 
[j]]; 

$ \}$ 

$ \}$ 

$ \}$ 




$ @$end 




/****************** life2dm.h ********************/ 




$ \char93 $import $ <$AppKit/AppKit.h$ >$ 

$ \char93 $import "control.h" 




$ @$interface life2dM : NSView 

$ \{$ 


		 /*Cuenta el numero de celulas vivas por cada generacion*/ 


id cellvivas; 

/*Cuenta el numero de iteraciones calculadas*/ 


id generaciones; 

/*Determina la cantidad de celulas vivas al inicio*/ 


id densidad; 

/*Captura coordenada directa del view*/ 


id posicionx; 


id posiciony; 


NSTimer *linesTimer; 


BOOL running; 

$ \}$ 




/*Inicializa la grafica*/ 

- initWithFrame:(NSRect)rects; 

/*Dibuja la grafica*/ 

-(void)drawRect:(NSRect)rects; 

/*Dibuja una celula*/ 

-(void)dibujaPunto:(int)x:(int)y:(float)rojo:(float)verde:(float)azul; 

/*Dibuja una linea*/ 

-(void)dibujarLinea:(int)x1:(int)y1:(int)x2:(int)y2:(float)rojo:(float)verde:(float)azul; 

/*Dibuja la malla*/ 

-(void)dibujaMalla:(id)sender; 

/*Configuracion aleatoria*/ 

-(void)configuracionAleatoria:(id)sender; 

/*Configuracion aleatoria*/ 

-(void)dibujaConfiguracion:(id)sender; 

/*Traer regla de control*/ 

-(void)establecerRegla:(int)renglon:(int)columna:(int)estado; 

/*Evolucion paso a paso*/ 

-(void)pasoaPaso:(id)sender; 

/*Utiliza regla 110 para llenar el plano inicial*/ 

-(void)regla110:(id)sender; 

/*Limpia la vista*/ 

-(void)limpiarVista:(id)sender; 

/*Limpia todo*/ 

-(void)limpiarTodo:(id)sender; 

/*Activa el mouse con mouse down*/ 

-(void)mouseDown:(NSEvent *)event; 

- (void)dealloc; 

- (void)toggleRun:sender; 

- (void)animate:(NSTimer *)timer; 




$ @$end 




/****************** life2dm.m ********************/ 




$ \char93 $import "life2dM.h" 

$ \char93 $define LINES 600 

$ \char93 $define RING 600 

$ \char93 $define FACTOR 8 

$ \char93 $define NUM 50 


int longx,longy; 


int arreglo[LINES/FACTOR][RING/FACTOR],inicial[LINES/FACTOR][RING/FACTOR]; 


int auxiliar[RING/FACTOR],matriz_aux[16][32]; 


int iteraciones; 


int neighborhood[8]; 


int FLAG; 


int ring,lines,lineas; 




/*Convierte decimal en binario*/ 


int rule_binary(int ruleaux) 

$ \{$ 


int modulo; 


int divisor; 


int i=0; 


do 

$ \{$ 


modulo = fmod(ruleaux,2); 


divisor = ruleaux/2; 


neighborhood[i] = modulo; 


ruleaux = divisor; 


i++; 

$ \}$while(i$ <$8); 


return 0; 

$ \}$ 




/*Reviza frontera superior*/ 


int check_sup(int k) 

$ \{$ 


int help; 


help=k; 


if(k$ <$0) 


help=ring-1; 


if(k$ >$ring-1) 


help=k-ring; 


return(help); 

$ \}$ 




/*Reviza frontera inferior*/ 


int check_inf(int l) 

$ \{$ 


if(l$ >$ring-1) 


l -= ring; 


return(l); 

$ \}$ 




/*Reviza frontera izquierda*/ 


int check_izq(int k) 

$ \{$ 


int help; 


help=k; 


if(k$ <$0) 


help=ring-1; 


if(k$ >$ring-1) 


help=k-ring; 


return(help); 

$ \}$ 




/*Reviza frontera derecha*/ 


int check_der(int l) 

$ \{$ 


if(l$ >$ring-1) 


l -= ring; 


return(l); 

$ \}$ 




$ @$implementation life2dM 




/*Inicializa la grafica*/ 

- initWithFrame:(NSRect)rects 

$ \{$ 


int i,j; 
; 
; 


FLAG=FACTOR; 


ring=RING/FACTOR; 


lines=LINES/FACTOR; 


iteraciones=0; 

/*Limpiar arreglos*/ 


for(i=0;i$ <$ring;i++) 

$ \{$ 


auxiliar[i]=0; 


for(j=0;j$ <$lines;j++) 

$ \{$ 


inicial[i][j]=0; 


arreglo[i][j]=0; 

$ \}$ 

$ \}$ 

addObserver:self selector:$ @$selector(appWillHide:) 


name:NSApplicationWillHideNotification object:[NSApplication sharedApplication]]; 

addObserver:self selector:$ @$selector(windowWillMiniaturize:) 


name:NSWindowWillMiniaturizeNotification object:nil]; 


running = NO; 


return self; 

$ \}$ 




/*Dibuja la grafica*/ 

-(void)drawRect:(NSRect)rects 

$ \{$ 

/*Limites del cuadro*/ 


NSRect limites=[self bounds]; 

/*Largo y ancho del cuadro y el incremento en radianes*/ 


longx=limites.size.width; 


longy=limites.size.height; 

set]; 


NSRectFill([self bounds]); 

/*Dibuja la malla*/ 
; 

$ \}$ 




- (void)dealloc 

$ \{$ 


if (running) 

$ \{$ 
; 
; 

$ \}$ 

removeObserver:self]; 
; 

$ \}$ 




- (void)toggleRun:(id)sender 

$ \{$ 


if (running) 

$ \{$ 
; 
; 


running = NO; 

$ \}$ 


else 

$ \{$ 


linesTimer = [[NSTimer scheduledTimerWithTimeInterval:0.0 target:self selector: 

@selector(animate:) userInfo:nil repeats:YES] retain]; 


running = YES; 

$ \}$ 

$ \}$ 




- (void)animate:(NSTimer *)timer 

$ \{$ 


int i,j; 


int identificador,cociente,modulo; 


for(i=0;i$ <$lines;i++) 

$ \{$ 


for(j=0;j$ <$ring;j++) 

$ \{$ 


identificador=(pow(2,0)*inicial[i-1][j-1]) + (pow(2,1)*inicial[i-1][j]) + 

(pow(2,2)*inicial[i-1][j+1]) +  (pow(2,3)*inicial[i][j-1]) + (pow(2,4)*inicial[i][j]) + 

(pow(2,5)*inicial[i][j+1]) + (pow(2,6)*inicial[i+1][j-1]) + (pow(2,7)*inicial[i+1][j]) + 

(pow(2,8)*inicial[i+1][j+1]); 


cociente=identificador/32; 


modulo=fmod(identificador,32); 


arreglo[i][j]=matriz_aux[cociente][modulo]; 

$ \}$ 

$ \}$ 

/*Actualiza la siguiente configuracion*/ 


for(i=0;i$ <$lines;i++) 


for(j=0;j$ <$ring;j++) 


inicial[i][j]=arreglo[i][j]; 


for(i=0;i$ <$lines;i++) 


for(j=0;j$ <$ring;j++) 


arreglo[i][j]=0; 

/*Dibuja la nueva configuracion*/ 
; 


iteraciones++; 

$ \}$ 




- (void)windowWillMiniaturize:(NSNotification *)notification 

$ \{$ 


if (running $ \&\&$ ([notification object] == [self window])) 
; 

$ \}$ 




- (void)appWillHide:(NSNotification *)notification 

$ \{$ 


if (running) 
; 

$ \}$ 




/*Dibuja una linea*/ 

-(void)dibujarLinea:(int)x1:(int)y1:(int)x2:(int)y2:(float)rojo:(float)verde:(float)azul 

$ \{$ 


PSsetrgbcolor(rojo,verde,azul); 


PSmoveto(x1,y1); 


PSlineto(x2,y2); 

$ \}$ 




/*Dibuja una celula*/ 

-(void)dibujaPunto:(int)x:(int)y:(float)rojo:(float)verde:(float)azul 

$ \{$ 

/*Activa la accion del cuadro */ 
; 


PSnewpath(); 

/*Dibujar Punto*/ 


PSsetrgbcolor(rojo,verde,azul); 


PSarc(x,y,2,0,360); 


PSfill(); 

/*Desactiva el cuadro*/ 


PSstroke(); 
; 

$ \}$ 




/*Dibuja la malla*/ 

-(void)dibujaMalla:(id)sender 

$ \{$ 


int i; 


PSnewpath(); 

/*Lineas verticales*/ 


for(i=0;i$ <$RING;i+=FACTOR) 
; 

/*Lineas horizontales*/ 


for(i=0;i$ <$LINES;i+=FACTOR) 
; 


PSstroke(); 

$ \}$ 




/*Configuracion aleatoria*/ 

-(void)configuracionAleatoria:(id)sender 

$ \{$ 


int i,j; 


float y,flag; 


time_t segundos; 


iteraciones=0; 

/*Calcular valores aleatorios*/ 


time($ \&$segundos); 


srand((unsigned)(segundos $ \%$ 65536)); 


flag=[densidad floatValue]; 


for(i=0;i$ <$lines;i++) 

$ \{$ 


for(j=0;j$ <$ring;j++) 

$ \{$ 


y = rand()/pow(2,31); 


if(y$ >=$flag) 


inicial[i][j] = 0; 


else 


inicial[i][j] = 1; 

$ \}$ 

$ \}$ 

/*Dibuja la nueva configuracion*/ 
; 

$ \}$ 






/*Dibuja configuracion*/ 

-(void)dibujaConfiguracion:(id)sender 

$ \{$ 


int i,j,aux_x=0,aux_y=0,contador=0; 

/*Activa la accion del cuadro */ 
; 

/*Limpia el view*/ 
; 

/*Dibujar la configuracion inicial*/ 


for(i=0,aux_y=3;i$ <$lines;i++,aux_y+=FACTOR) 

$ \{$


for(j=0,aux_x=5;j$ <$ring;j++,aux_x+=FACTOR) 

$ \{$ 


if(inicial[i][j]==1) 

$ \{$ 
; 


contador++; 

$ \}$ 

$ \}$ 

$ \}$ 

/*Pinta el momento de generar el punto*/ 

flushWindow]; 
; 

/*Dice cuantas celulas estan vivas*/ 
; 
; 

$ \}$ 




/*Utiliza regla 110 para llenar el plano inicial*/ 

-(void)regla110:(id)sender 

$ \{$ 


int i,j,tmp; 


float y,flag; 


time_t segundos; 

/*Limpiar arreglos*/ 


for(i=0;i$ <$lines;i++) 

$ \{$ 


for(j=0;j$ <$ring;j++) 

$ \{$ 


inicial[i][j]=0; 


auxiliar[j]=0; 

$ \}$ 

$ \}$ 

/*Calcular valores aleatorios*/ 


time($ \&$segundos); 


srand((unsigned)(segundos $ \%$ 65536)); 


flag=[densidad floatValue]; 


for(j=0;j$ <$ring;j++) 

$ \{$ 


y = rand()/pow(2,31); 


if(y$ >=$flag) 


inicial[0][j] = 0; 


else 


inicial[0][j] = 1; 

$ \}$ 

/*Configuracion inicial lineal*/ 


for(j=0;j$ <$ring;j++) 


auxiliar[j]=inicial[0][j]; 

/*Transforma la regla en binario*/ 


rule_binary(110); 

/*Calcula la evolucion*/ 


for(i=1;i$ <$lines;i++) 

$ \{$ 

/*Calcula la siguiente evolucion*/ 


for(j=0;j$ <$ring;j++) 

$ \{$ 


tmp = auxiliar[check_inf(j-1)]*4 + auxiliar[j]*2 + auxiliar[check_sup(j+1)]; 


inicial[i][j]=neighborhood[tmp]; 

$ \}$ 


for(j=0;j$ <$ring;j++) 


auxiliar[j]=inicial[i][j]; 

$ \}$ 

/*Dibuja la nueva configuracion*/ 
; 

$ \}$ 




/*Traer regla de control*/ 

-(void)establecerRegla:(int)renglon:(int)columna:(int)estado 

$ \{$ 

/*Traer regla de control*/ 


matriz_aux[renglon][columna]=estado; 

$ \}$ 




/*Evolucion paso a paso*/ 

-(void)pasoaPaso:(id)sender 

$ \{$ 


int i,j; 


int identificador,cociente,modulo; 

/*Aplicar funcion de transicion*/ 


for(i=0;i$ <$lines;i++) 

$ \{$ 


for(j=0;j$ <$ring;j++) 

$ \{$ 


identificador=(pow(2,0)*inicial[i-1][j-1]) + (pow(2,1)*inicial[i-1][j]) + 

(pow(2,2)*inicial[i-1][j+1]) +  (pow(2,3)*inicial[i][j-1]) + (pow(2,4)*inicial[i][j]) + 

(pow(2,5)*inicial[i][j+1]) + (pow(2,6)*inicial[i+1][j-1]) + (pow(2,7)*inicial[i+1][j]) + 

(pow(2,8)*inicial[i+1][j+1]); 


cociente=identificador/32; 


modulo=fmod(identificador,32); 


arreglo[i][j]=matriz_aux[cociente][modulo]; 

$ \}$ 

$ \}$ 

/*Actualiza la siguiente configuracion*/ 


for(i=0;i$ <$lines;i++) 


for(j=0;j$ <$ring;j++) 


inicial[i][j]=arreglo[i][j]; 


for(i=0;i$ <$lines;i++) 


for(j=0;j$ <$ring;j++) 


arreglo[i][j]=0; 

/*Dibuja la nueva configuracion*/ 
; 


iteraciones++; 

$ \}$ 




/*Limpia el view*/ 

-(void)limpiarVista:(id)sender 

$ \{$ 

set]; 


NSRectFill([self bounds]); 
; 

$ \}$ 




/*Limpia todo*/ 

-(void)limpiarTodo:(id)sender 

$ \{$ 


int i,j; 
; 

/*Limpiar arreglos*/ 


for(i=0;i$ <$lines;i++) 

$ \{$ 


auxiliar[i]=0; 


for(j=0;j$ <$ring;j++) 

$ \{$ 


inicial[i][j]=0; 


arreglo[i][j]=0; 

$ \}$ 

$ \}$ 


iteraciones=0; 
; 
; 

/*Dibuja la nueva configuracion*/ 
; 

$ \}$ 




/*Activa el mouse con mouse down*/ 

-(void)mouseDown:(NSEvent *)event 

$ \{$ 


int cuenta_multiplo=0,auxiliar1=0; 


int m_der=0,m_izq=0,m_inf=0,m_sup=0,pos_x=0,pos_y=0,coor_x=0,coor_y=0; 
.x]; 
.y]; 

/*Restringuiendo valores para X*/ 


if([posicionx intValue]$ <=$0) 
; 


if([posicionx intValue]$ >$(longx-7)) 
; 

/*Restringuiendo valores para Y*/ 


if([posiciony intValue]$ <=$0) 
; 


if([posiciony intValue]$ >$(longy-7)) 
; 

/*Determina el lugar adecuado de la celula para el eje X*/ 


cuenta_multiplo=[posicionx intValue]/FACTOR; 


coor_x=cuenta_multiplo; 


auxiliar1=cuenta_multiplo+1; 


m_der=cuenta_multiplo*FACTOR; 


m_izq=auxiliar1*FACTOR; 


if([posicionx intValue]$ >=$m_der $ \&\&$ [posicionx intValue]$ <=$m_izq) 


pos_x=m_der+5; 

/*Limpia variables de conteo*/ 


cuenta_multiplo=0; 


auxiliar1=0; 

/*Determina el lugar adecuado de la celula para el eje Y*/ 


cuenta_multiplo=[posiciony intValue]/FACTOR; 


coor_y=cuenta_multiplo; 


auxiliar1=cuenta_multiplo+1; 


m_inf=cuenta_multiplo*FACTOR; 


m_sup=auxiliar1*FACTOR; 


if([posiciony intValue]$ >=$m_inf $ \&\&$ [posiciony intValue]$ <=$m_sup) 


pos_y=m_inf+3; 

/*Visualiza las coordenadas*/ 
; 
; 

/*Almacena arreglo de celulas*/ 


if(inicial[coor_y][coor_x]==0) 

$ \{$ 


inicial[coor_y][coor_x]=1; 

/*Activa la accion del cuadro */ 
; 


PSnewpath(); 

/*Dibujar punto*/ 


PSsetrgbcolor(0,0,0); 


PSarc(pos_x,pos_y,2,0,360); 


PSfill(); 

/*Desactiva el cuadro*/ 


PSstroke(); 

/*Pinta el momento de generar el punto*/ 

flushWindow]; 
; 

$ \}$ 


else 

$ \{$ 


inicial[coor_y][coor_x]=0; 

/*Activa la accion del cuadro */ 
; 


PSnewpath(); 

/*Dibujar punto*/ 


PSsetrgbcolor(1,1,1); 


PSarc(pos_x,pos_y,2,0,360); 


PSfill(); 

/*Desactiva el cuadro*/ 


PSstroke(); 

/*Pinta el momento de generar el punto*/ 

flushWindow]; 
; 

$ \}$ 

$ \}$ 




$ @$end 




/****************** matriz.h ********************/ 




$ \char93 $import $ <$AppKit/AppKit.h$ >$ 




$ @$interface matriz : NSMatrix 

$ \{$ 

$ \}$ 




/*Inicializa la matriz de botones*/ 

- initWithFrame:(NSRect)rects; 

/*Captura la posicion de la celula y el tag*/ 

-(void)capturarPosicion:(int)renglon:(int)columna:(int)identificador:(int)estado; 

/*Determina la vecindad en base el tag de la celula que va a evolucionar*/ 

-(int)traerVecindad:(int)renglon:(int)columna; 

/*Limpia el arreglo*/ 

-(void)limpiarArreglo:(id)sender; 

/*Arreglo aleatorio*/ 

-(void)arregloAleatoria:(int)renglon:(int)columna:(int)estado; 




$ @$end 




/****************** matriz.m ********************/ 




$ \char93 $import "matriz.h" 

/*Matriz que guarda la regla de evolucion*/ 


int matriz_regla[16][32]; 




$ @$implementation matriz 




/*Inicializa la matriz de botones*/ 

- initWithFrame:(NSRect)rects 

$ \{$ 


int i,j; 
; 

/*Inicializa la matriz_regla en ceros*/ 


for(i=0;i$ <$16;i++) 


for(j=0;j$ <$32;j++) 


matriz_regla[i][j]=0; 


return self; 

$ \}$ 




/*Captura la posicion de la celula y el tag*/ 

-(void)capturarPosicion:(int)renglon:(int)columna:(int)identificador:(int)estado 

$ \{$ 

/*Determina el estado en la posicion capturada*/ 


if(estado==0) 

$ \{$ 

setTitle: [NSString stringWithFormat:$ @$"$ \%$d",1]]; 

/*Almacenar valores en la matriz original*/ 


matriz_regla[renglon][columna]=1; 

$ \}$ 


if(estado==1) 

$ \{$ 

setTitle: [NSString stringWithFormat:$ @$"$ \%$d",0]]; 

/*Almacenar valores en la matriz original*/ 


matriz_regla[renglon][columna]=0; 

$ \}$ 

$ \}$ 




/*Determina la vecindad en base el tag de la celula que va a evolucionar*/ 

-(int)traerVecindad:(int)renglon:(int)columna 

$ \{$ 

/*Le mando el arreglo matriz_regla a control*/ 


return matriz_regla[renglon][columna]; 

$ \}$ 




/*Limpia el arreglo*/ 

-(void)limpiarArreglo:(id)sender 

$ \{$ 


int i,j; 


for(i=0;i$ <$16;i++) 

$ \{$ 


for(j=0;j$ <$32;j++) 

$ \{$ 

setTitle: [NSString stringWithFormat:$ @$"$ \%$d",0]]; 


matriz_regla[i][j]=0; 

$ \}$ 

$ \}$ 

$ \}$ 




/*Arreglo aleatorio*/ 

-(void)arregloAleatoria:(int)renglon:(int)columna:(int)estado 

$ \{$ 


matriz_regla[renglon][columna]=estado; 


if(matriz_regla[renglon][columna]==0) 

setTitle: [NSString stringWithFormat:$ @$"$ \%$d",0]]; 


else 

setTitle: [NSString stringWithFormat:$ @$"$ \%$d",1]]; 

$ \}$ 




$ @$end 




/****************** vecindad.h ********************/ 




$ \char93 $import$ <$AppKit/AppKit.h$ >$ 




$ @$interface vecindad : NSView 

$ \{$ 

$ \}$ 




/*Inicializa la grafica*/ 

- initWithFrame:(NSRect)rects; 

/*Dibuja la grafica*/ 

-(void)drawRect:(NSRect)rects; 

/*Dibuja una linea*/ 

-(void)dibujarLinea:(int)x1:(int)y1:(int)x2:(int)y2:(float)rojo:(float)verde:(float)azul; 

/*Dibuja la malla*/ 

-(void)dibujaMalla:(id)sender; 

/*Dibuja la vecindad*/ 

-(void)dibujarVecindad:(int)vecino; 




$ @$end  




/****************** vecindad.m ********************/ 




$ \char93 $import "vecindad.h" 


int vecin[9]; 


int largox,largoy; 




/*Convierte decimal en binario para la vecindad de Moore*/ 


int vecindad_binary(int vecino) 

$ \{$ 


int modulo; 


int divisor; 


int i=0; 


do 

$ \{$ 


modulo = fmod(vecino,2); 


divisor = vecino/2; 


vecin[i] = modulo; 


vecino = divisor; 


i++; 

$ \}$while(i$ <$9); 


return 0; 

$ \}$ 




$ @$implementation vecindad 




/*Inicializa la grafica*/ 

- initWithFrame:(NSRect)rects 

$ \{$ 
; 
; 


return self; 

$ \}$ 




/*Dibuja la grafica*/ 

-(void)drawRect:(NSRect)rects 

$ \{$ 

/*Limites del cuadro*/ 


NSRect limites=[self bounds]; 


largox=limites.size.width; 


largoy=limites.size.height; 

set]; 


NSRectFill([self bounds]); 
; 

$ \}$ 




/*Dibuja una linea*/ 

-(void)dibujarLinea:(int)x1:(int)y1:(int)x2:(int)y2:(float)rojo:(float)verde:(float)azul 

$ \{$ 


PSsetrgbcolor(rojo,verde,azul); 


PSmoveto(x1,y1); 


PSlineto(x2,y2); 

$ \}$ 




/*Dibuja la malla*/ 

-(void)dibujaMalla:(id)sender 

$ \{$ 


int i,j,flag; 


flag=largox/3; 


PSnewpath(); 

/*Lineas verticales*/ 


for(i=0,j=flag;i$ <$3;i++,j=j+flag) 
; 

/*Lineas horizontales*/ 


for(i=0,j=flag;i$ <$3;i++,j=j+flag) 
; 


PSstroke(); 

$ \}$ 




/*Dibuja la vecindad*/ 

-(void)dibujarVecindad:(int)vecino 

$ \{$ 


char s[5]; 

/*Transformar de decimal a binario*/ 


vecindad_binary(vecino); 

/*Limpiar view*/ 
; 

/*Poner texto*/ 
; 


PSsetrgbcolor(0,0,0); 


PSnewpath(); 


PSselectfont("Times-Roman",18); 


sprintf(s,"$ \%$d",vecin[0]); PSmoveto(13,76); PSshow(s); 


sprintf(s,"$ \%$d",vecin[1]); PSmoveto(46,76); PSshow(s); 


sprintf(s,"$ \%$d",vecin[2]); PSmoveto(79,76); PSshow(s); 


sprintf(s,"$ \%$d",vecin[3]); PSmoveto(13,43); PSshow(s); 


sprintf(s,"$ \%$d",vecin[4]); PSmoveto(46,43); PSshow(s); 


sprintf(s,"$ \%$d",vecin[5]); PSmoveto(79,43); PSshow(s); 


sprintf(s,"$ \%$d",vecin[6]); PSmoveto(13,11); PSshow(s); 


sprintf(s,"$ \%$d",vecin[7]); PSmoveto(46,11); PSshow(s); 


sprintf(s,"$ \%$d",vecin[8]); PSmoveto(79,11); PSshow(s); 
; 

$ \}$ 



$ @$end

next up previous contents
Next: Lista de Figuras Up: Programas gráficos desarrollados en Previous: ACOSXM   Contenido
ice 2001-08-30