Processing Un Lenguaje Al Alcance de Todos

Processing,un lenguaje al alcance de todos

Edicin 2014versin 03

Ignacio Buioli | Jaime Prez Marn

2

ndicendice......................................................................................................................................................................3 Introduccin............................................................................................................................................................5 Estructuras: Elementos del digo........................................................................................................................! "ormas: oordinadas # Primiti$as.......................................................................................................................%& 'atos: (aria)les...................................................................................................................................................%* Matem+ticas: "unciones ,ritmticas....................................................................................................................-% ontrol: 'ecisiones..............................................................................................................................................-. ontrol: /e0eticin...............................................................................................................................................3"ormas: (rtices..................................................................................................................................................3! Matem+ticas: ur$as............................................................................................................................................11 olor: olor 0or 23meros....................................................................................................................................14 Imagen: (isualizacin # 5inta...............................................................................................................................5! 'atos: 5e6to...........................................................................................................................................................& 'atos: on$ersin # 7)8etos.................................................................................................................................5i0ogra9a: (isualizacin........................................................................................................................................ Matem+ticas: 5rigonometra.................................................................................................................................!& Matem+ticas: ,leatoriedad...................................................................................................................................!* 5rans9ormaciones: Matrices # 5raslaciones.........................................................................................................*5rans9ormaciones: /otacin # Escala..................................................................................................................*5 Estructuras: ontinuidad......................................................................................................................................4& Estructuras: "unciones.........................................................................................................................................4. "ormas: Par+metros # /ecursin......................................................................................................................%&. (alores de Entrada: Mouse.................................................................................................................................%%% 'i)u8o: "ormas Est+ticas....................................................................................................................................%%* (alores de Entrada: 5eclado..............................................................................................................................%-% (alores de Entrada: E$entos..............................................................................................................................%-1 (alores de Entrada: Mouse II.............................................................................................................................%-4 (alores de Entrada: 5iem0o # "ec:as...............................................................................................................%35 Mo$imiento: ;neas # ur$as.............................................................................................................................%34 Mo$imiento: Mec+nicos # 7rg+nicos.................................................................................................................%1! 'atos: ,rra#s......................................................................................................................................................%5Imagen: ,nimacin.............................................................................................................................................%.% Imagen: P6eles..................................................................................................................................................%.5 5i0ogra9a: Mo$imiento.......................................................................................................................................%.4 5i0ogra9a: /es0uesta........................................................................................................................................%!3 olor: om0onentes..........................................................................................................................................%!. Imagen: "iltro< Mezcla< o0ia< M+scara............................................................................................................%*Imagen: Procesamiento de Imagen...................................................................................................................%*! 'atos de =alida: Im+genes................................................................................................................................%45 'atos de =alida: E60ortar ,rc:i$os....................................................................................................................%4* Estructuras: 7)8etos...........................................................................................................................................-&% 'i)u8os: "ormas inticas.................................................................................................................................-%3 E6tensin: Modos...............................................................................................................................................-%! E6tensin: "iguras 3'........................................................................................................................................--& E6tensin: >M;..................................................................................................................................................--4 ,0artados: E8ercicios..........................................................................................................................................-3% ,0artados: 'ocumentacin................................................................................................................................-3!


3

El 0resente li)ro< de ti0o manual actualiza)le< corres0onde al a0rendiza8e del so9t?are de Processing -.%.%. El :ec:o de 0oseer una $ersin anterior o 0osterior no entor0ece ni im0ide el a0rendiza8e con el 0resente manual. =in em)argo< se recomienda actualizarse a la 3ltima $ersin esta)le. @ante cualAuier duda< consultar en: :tt0:BB0rocessing.orgBdo?nloadBC. Dueda entendido Aue Processing es creado< en 0rinci0io< 0or ase# /eas # Ben "r#< # se trata de un so9t?are de cdigo a)ierto distri)uido )a8o una licencia E2F E;P @ General Public LicenseC.

Introduccin'ado el a$ance de los medios de 0roduccin multimedial< nace un 0otente so9t?are dedicado a la 0roduccin de im+genes< animaciones e interacti$os. El so9t?are denominado Processing. El 0ro#ecto da inicio en el -&&%< realizado 0or ase# /eas # Ben "r#< a 0artir de terminologas realizadas en el MI5 ;a)< dirigido 0or Jo:n Maeda< e in9luenciado 0or el 0ro#ecto Design by Numbers. Es as Aue Processing se con$ierte en un 0oderoso entorno de 0roduccin )asado en Ja$a. 2os 0areci im0ortante la creacin de un li)ro ti0o manual de introduccin a Processing Aue se encuentre dis0oni)le en es0aGol< 0uesto Aue la ma#ora de los manuales del mercado se encuentran 3nicamente en ingls # no :a# ninguna $ersin al castellano. 2o es de 0oca monta la cantidad de :is0ano:a)lantes Aue e6isten en el mundo< es0ecialmente interesados en a0render lengua8es de 0rogramacin orientados a entornos Ja$a. Por tal moti$o< este manual comenz< en 0rinci0io< como una traduccin de los manuales de Processing. 2o o)stante< la distri)ucin de los mismos no nos con$encan en cuanto a ductilidad de lectura< 0or lo tanto decidimos tomarlos de )ase 0ara crear nuestro 0ro0io manual Aue a#ude a aAuellos @Aue 0or di$ersos moti$os no sa)en leer en inglsC interesados en la 0roduccin multimedial Aue el so9t?are o9rece. En este li)ro< se o9rece< adem+s< a0ndices corres0ondientes a cada sector # e8em0los Aue muestran el 9uncionamiento de las estructuras # de los 0rogramas. =e recomienda Aue< una $ez conseguido el 0rograma< los e8em0los sean $istos desde a: # no solo desde la imagen Aue lo acom0aGa. omo se menciona anteriormente< este li)ro< 0rinci0almente< comienza como una traduccin del li)ro Processing: A programming Handbook for Visual Designer and Artist de ase# /eas # Ben "r#. 2o o)stante< se inclu#en conce0tos # material no 0resente en dic:o li)ro @as como tam)in se Auitan cosas del mismo Aue no nos :an 0arecido 0ertinentesC.

Software- !u" es Processing# Es un so9t?are de cdigo a)ierto< # cualAuier 0ersona 0uede contri)uir en su me8ora. 'es0ro$isto de inter9aces innecesarias< se $ale de un lengua8e de 0rogramacin @de igual nom)reC )asado en Ja$a 0ara realizar com0osiciones de gran inters. omo so9t?are< consiste )+sicamente en un sim0le editor de te6to 0ara escri)ir cdigo< un +rea de mensa8e< una consola de te6to< un sistema de 0estaGas 0ara mane8ar arc:i$os< una )arra de :erramientas con )otones de accionar com3n # una )arra de men3. uando el 0rograma se e8ecuta< se a)re una $entana de re0resentacin. ;os arc:i$os Aue se escri)en en Processing se denominan sketch. Esos sHetc: se escri)en en el editor de te6to. ,dmite las 9unciones de co0iarB0egar # )uscarBreem0lazar te6to. ;a consola muestra errores 0roducidos al e8ecutar el 0rograma. 5am)in< 0uede mostrar te6to a tra$s de las 9unciones print ! # println !. -$escarga El so9t?are de Processing 0uede descargarse del sitio ?e) :omnimo del 0rograma. 'esde un na$egador ?e)< ingresar a """.processing.org # )uscar la seccin de descarga @do"nloadC. ,dmite sistemas o0erati$os


4

de ;inu6< Macintos: # Iindo?s. En el sitio se encuentran las instrucciones mismas 0ara la descarga. -%onte&to

Barra de Men3: "ile: #Archi$o#. omandos 0ara mane8ar # e60ortar arc:i$os. Edit: #%ditar#. ontroles 0ara editar te6to. @ o0iar< 0egar< cortar< encontrar< reem0lezar< etc.C. =Hetc:: #&ketch#. ontrol 0ara e8ecutarB9renar el 0rograma # 0ara aGadir li)reras. 5ools: #Herramientas#. Jerramientas de asistencia 0ara Processing. Jel0: #Ayuda#. /e9erencias a arc:i$os # al lengua8e. Barra de Jerramientas: /un: #%'ecutar#. om0ila el cdigo< a)re una $entana de re0resentacin # muestra el 0rograma. =to0: #Parar#. 5ermina de correr el 0rograma. 2e?: #Nue$o#. rea un nue$o =Hetc:. 70en: #Abrir#. Pro$ee de o0ciones 0ara a)rir un sHetc: del li)ro de sHetc:< a)rir un e8em0lo< o un sHetc: en cualAuier sitio del ordenador. =a$e: #Guardar#. Euarda el actual sHetc: en la actual u)icacin. Para otra u)icacin usar el o0cion K=a$e asL. E60ort: #%(portar#. E60orta el actual sHetc: como un a00let de Ja$a unido a una arc:i$o J5M;.


'

(nidad 1

Estructuras) Ele*entos del %digoEle*entos +ue se introducen en esta (nidad)// (comentario), /* */ (comentario multilinea),;(terminador de accin), , (coma), print(), println()

El :ec:o de crear un 0rograma im0lica recurrir a la escritura # a0render un lengua8e. =imilar a cuando a0rendemos un nue$o lengua8e oral o escrito< necesitamos a0render una sinta6is # una lgica. Escri)ir en un lengua8e :umano es mu# com0licado. Posee am)igMedad en las 0ala)ras< # muc:a 9le6i)ilidad 0ara la construccin de 0+rra9os. En ese sentido< el lengua8e de m+Auina es m+s sencillo< 0ero 0osee una di9icultad clara: la lgica de la 0rogramacin. Fsualmente< un ser :umano 0uede 0ercatarse de un error de sinta6is # darlo 0or alto< rest+ndole 0arcial o com0leta im0ortancia. =in em)argo< en un lengua8e de m+Auina las cosas son de una 9orma o de otra: 7 est+ )ien< o est+ mal. -%o*entarios ;os comentarios son ignorados 0or los ordenadores< 0ero son *u, i*-ortantes 0ara los :umanos. Processing 0ermite agregar notas en cualAuier sector del cdigo. Pueden ser de solo una lnea o de muc:as lneas. Na Aue los 0rogramas usan signos mu# arcaicos # de di9cil identi9icacin< muc:as $eces es com0licado recordar Aue :aca cada sector indi$idualmente. Por lo tanto se recurre a la utilidad del comentario< mu# 3til a la :ora de re$isar el cdigo< #a sea 0or el 0ro0io 0rogramador como 0or otros. El siguiente 0rograma e60lica< 0or s solo< como se comenta:// // // // Dos barras laterales son usadas para comentar Todo el texto en la misma lnea es parte de un comentario No debe haber espacio entre las barras, por e emplo / /, de lo contrario el comentario no !uncionar"#

// $i desea muchas lneas // lo ideal es usar el m%todo multilinea# /* &na barra lateral se'uida por un asterisco permite el comentario de multilinea# */

-.unciones ;as 9unciones 0ermiten di)u8ar 9ormas< colores< realizar c+lculos matem+ticos< entre otras $ariadas acciones. Por lo general se escri/en en *in0sculas , seguidas -or -ar"ntesis . ,lgunas 9unciones ace0tan par)metros< los cuales se escri)en entre los 0arntesis. =i ace0ta m+s de uno< son se0arados 0or una coma @,C. , continuacin un 0rograma Aue inclu#e dos 9unciones: si(e() # bac)'round().//*on esta !uncin establecemos el tama+o de la ,entana de presentacin //-l primer par"metro corresponde al ancho de la ,entana //-l se'undo par"metro corresponde al alto# si(e(.//, 0//); //*on esta !uncin establecemos el color de !ondo de la ,entana //1cepta di,ersos par"metros, para una escala de 'rises bastar" con ,alores de / (ne'ro) a 233 (blanco)# bac)'round(/);

-E&-resiones , 1cciones =i us+ramos una analoga< la e60resin de un so9t?are es como una 9rase. ;as e60resiones< 0or lo general?&ND); line(2/, 0/, D/, 0/); stro)e*ap($L&1>-); line(2/, 3/, D/, 3/); stro)e*ap(A>?J-*T); line(2/, K/, D/, K/); smooth(); stro)eIei'ht(62); stro)eJoin(=-M-@); rect(62, 00, 63, 00); stro)eJoin(CBT->); rect(.2, 00, 63, 00); stro)eJoin(>?&ND); rect(K2, 00, 63, 00);

//@nea superior //@nea central //@nea in!erior

//Hi'ura i(Guierda //Hi'ura central //Hi'ura derecha

-;odos de di/ujo Por de9ecto< los 0ar+metros 0ara ellipse() de9inen la coordenada 6 del centro< la coordenada # del centro< el anc:o # el alto. ;a 9uncin ellipseCode() cam)ia la 9orma en Aue se usan estos 0ar+metros 0ara di)u8ar eli0ses. ;a 9uncin ellipseCode() reAuiere un 0ar+metro Aue 0uede ser *-NT->< >1DB&$< *?>N-> o *?>N->$. El modo 0or de9ecto es *-NT->. El modo >1DB&$ tam)in usa el 0rimer # segundo 0ar+metro de ellipse() 0ara esta)lecer el centro< 0ero el tercer 0ar+metro de)er ser la mitad del anc:o< # el cuarto 0ar+metro de)e ser la mitad del alto. El modo *?>N-> :ace Aue ellipse() 9uncione de manera 0arecida a rect(). ausa Aue el 0rimer # segundo 0ar+metro se trasladen a la esAuina su0erior izAuierda del rect+ngulo Aue circunscri)e la eli0se # usa el tercer # cuarto 0ar+metro 0ara de9inir la anc:ura # la altura. El modo *?>N->$ tiene un e9ecto similar a *?>N->< 0ero causa Aue el tercer # cuarto 0ar+metro de ellipse() se de9inan en la esAuina in9erior derec:a del rect+ngulo.


14

smooth(); no$tro)e(); ellipseCode(>1DB&$); !ill(62:); ellipse(00, 00, :/, :/); !ill(233); ellipseCode(*?>N->); ellipse(00, 00, :/, :/); !ill(/); ellipseCode(*?>N->$); ellipse(00, 00, :/, :/);

//-lipse 'ris //-lipse blanca //-lipse ne'ra

on un estilo similar< la 9uncin rectCode() a9ecta a cmo se di)u8an los rect+ngulos. /eAuiere un 0ar+metro Aue 0uede ser *?>N->< *?>N->$ o *-NT->. El modo 0or de9ecto es *?>N->< # *?>N->$ causa Aue el tercer # cuarto 0ar+metro de rect() se de9inan en la esAuina contraria a la 0rimera. El modo *-NT-> causa Aue el 0rimer # segundo 0ar+metro de rect() de9inan el centro del rect+ngulo # usa el tercer # cuarto 0ar+metro 0ara el anc:o # el alto.no$tro)e(); rectCode(*?>N->); !ill(62:); rect(./, ./, :/, :/); rectCode(*-NT->); !ill(233); rect(./, ./, :/, :/); rectCode(*?>N->$); !ill(/); rect(./, ./, :/, :/);

//>ect"n'ulo 'ris //>ect"n'ulo blanco //>ect"n'ulo ne'ro


1'

1-"ndice de Pri*itivas


12

(nidad 3

$atos) :aria/lesEle*entos +ue se introducen en esta (nidad)int,!loat, boolean, true, !alse, < (asi'nacin), Nidth, hei'ht

PDu son los datosQ ;os datos< con 9recuencia son caractersticas 9sicas asociadas a un algo. Por e8em0lo< cuando decimos Aue una 0ersona llamada Juan Prez< en su registro de conducir 9igura una M @0or gnero masculinoC sa)emos Aue ese $alor M esta asociado a la 0ersona Juan Prez. En los sistemas in9orm+ticos< los datos son guardados como n3meros # caracteres. Por e8em0lo< los ordenadores est+n constantemente reci)iendo datos del mouse # el teclado. uando se crea un 0rograma< 0ueden guardarse datos de< 0or e8em0lo< una 9orma< un color< o el cam)io constante de la 0osicin del mouse. ->?> O @a ,ariable x ;a existe

El sm)olo de igual @>?> O @o Gue se encuentre del lado i(Guierdo debe ser una //,ariable

Ja# Aue tener en cuenta el ti0o de datos Aue estemos mane8ando. 2o es 0osi)le asignar un ti0o de datos a una $aria)le Aue solo ace0te otra clase. Por e8em0lo< no 0odemos asignar $alores decimales a una $aria)le ti0o entero:int x < 62#D7; !loat ! < 62#D7; int ; < !; //->>?> O @a ,ariable es tipo entero ; se le est" asi'nando un //,alor decimal //->>?> O @a ,ariable es tipo entero ; se le est" asi'nando un //,alor decimal

;as $aria)les 0ueden tener nom)res Aue descri)an su contenido. Eso sim0li9ica muc:o la tarea a la :ora de 0rogramar. ,dem+s< esto 0odra a#udar a reducir la cantidad de comentarios. ,3n as< Aueda en el 0rogramador elegir Aue clase de nom)res utilizar. Por e8em0lo< 0ara $aria)les de tem0eratura< se 0odran utilizar los siguientes nom)res:t temp temperatura


16

temp*uarto temperatura*uarto

;a 0rimer letra tiene Aue ser un car+cter en min3sculas< las siguientes 0ueden ser 0r+cticamente cualAuier cosa. ,3n as< no se admiten acentos en ninguna 0arte del cdigo. -:aria/les de Progra*a Processing< como lengua8e< :a construido $aria)les mu# 3tiles Aue #a $ienen 0reO0rogramadas< a 9in de 9acilitarle el tra)a8o al usuario. =e las denomina $ariables del programa o $ariables del sistema. El anc:o # el alto de la $entana de re0resentacin est+n almacenadas como $aria)les denominadas Nidth #ancho# # hei'ht #alto#< res0ecti$amente. =i el 0rograma no inclu#e si(e()< 0or de9ecto Nidth # hei'ht adAuieren el $alor de %&&.println(Nidth 4 , 4 hei'ht); si(e(0//, 2//); println(Nidth 4 , 4 hei'ht); //Bmprime 6//, 6// en la consola //Bmprime 0//, 2// en la consola

"recuentemente son usadas cuando se reAuiere mantener la escritura del 0rograma en di9erentes escalas # Aue estas sean 0ro0orcionales.si(e(6//, 6//); ellipse(Nidth * /#3, hei'ht * /#3, Nidth * /#::, hei'ht * /#::); line(Nidth * /#3, /, Nidth * /#3, hei'ht);


18

(nidad 4

;ate*5ticas) .unciones 1rit*"ticasEle*entos +ue se introducen en esta (nidad)4 (suma), 5 (resta), * (multiplicacin), / (di,isin), P (mdulo), () (par%ntesis) 44 (incremento), O (decremento), 4< (asi'nar de suma), 5< (asi'nar resta), *< (asi'nar multiplicacin), /< (asi'nar di,isin), 5 (ne'ati,o) ceil(), !loor(), round(), min(), max()

5ener am0lios conocimientos en matem+ticas 0uede ser im0ortante a la :ora de 0rogramar. =in em)argo< no es necesario ser un )asto conocedor de la misma 0ara dis9rutar de la 0rogramacin. Ja# muc:as 9ormas # estilos 0ara 0rogramar< # cada Auien elige indi$idualmente a Aue as0ectos otorgarles un ma#o grado de minuciosidad # a cuales descuidarlos un 0oco. Es mu# com3n Aue aAuellos Aue tu$ieron una cantidad ele$ada de matem+ticas en la escuela @0or e8em0lo< en orientaciones en ciencias naturales o en alguna tcnicaC se sientan atrados al $er su matem+tica con$ertida en mo$imiento. 2o o)stante< no es necesario ser un $erdadero conocedor. Processing es un lengua8e Aue se 0resta a la matem+tica desde un as0ecto m+s tranAuilo. =i )ien 0ueden realizarse com0le8as o0eraciones< tam)in 0ueden lograrse resultados similares con una matem+tica m+s intuiti$a. En esta clase de manuales< se e60lican 9unciones aritmticas sencillas 0ara lograr grandes resultados< 0uesto 9unciones de ma#or com0le8idad caen 9uera de los o)8eti$os de este li)ro. -1rit*"tica En 0rogramacin< las 0ro0iedades $isuales de una imagen son asignadas 0or n0*eros. Esto Auiere decir Aue 0odemos controlarlas de 9orma aritmtica. El siguiente es un claro e8em0lo de eso:int 'risMal < 630; !ill('risMal); rect(6/, 6/, 33, 33); 'risMal < 'risMal 4 6/2; !ill('risMal); rect(03, 0/, 33, 33);

//Dibu a un rect"n'ulo 'ris //1si'na 233 a 'risMal //Dibu a un rect"n'ulo blanco

Ftilizando los o0eradores de suma< resta< multi0licacin # di$isin< 0odemos controlar< 0or e8em0lo< la 0osicin de los elementos. El signo 4 se utiliza 0ara la suma< el signo O 0ara la resta< el signo * 0ara la multi0licacin # el signo / 0ara la di$isin.int a < 0/; line(a, /, a, hei'ht); a < a 4 ./; //1si'na K/ a la ,ariable a stro)eIei'ht(.); line(a, /, a, hei'ht); int a < 0/; int b < ./; line(a, /, a, hei'ht); line(b, /, b, hei'ht); stro)eIei'ht(.); line(b 5 a, /, b 5 a, hei'ht);

//Aueden usarse c"lculos //entre ,ariables como //,alores


20

int a < D; int b < 6/; line(a, /, a, hei'ht); line(b, /, b, hei'ht); stro)eIei'ht(.); line(a * b, /, a * b, hei'ht); int a < D; int b < 6/; line(a, /, a, hei'ht); line(b, /, b, hei'ht); stro)eIei'ht(.); line(a / b, /, a / b, hei'ht); int ; < line(/, ; < ; 4 line(/, ; < ; 4 line(/, ; < ; 4 line(/, 2/; ;, Nidth, :; ;, Nidth, :; ;, Nidth, :; ;, Nidth,

;); ;); ;); ;); //1si'na 2: a la ,ariable ; //1si'na 02 a la ,ariable ; //1si'na 0D a la ,ariable ;

;os signos 4< 5< *< / # < 0osi)lemente sean mu# 9amiliares< 0ero el signo P es muc:o m+s e6tico. El o0erador P es el de mdulo. 'etermina cuando un n3mero es di$idido 0or otro< o sea< da como resultado el resto del mismo. El n3mero a la derec:a es di$idido 0or el Aue 0ongamos a la izAuierda. 'e$ol$er+ como resultado el resto de la o0eracin.E60resin7 P 0 7 P 2 03 P .

/esultado/ 6 0

E60licacin El 3 solo entra tres $eces en el 4< no so)ra nada. El - solo entra cuatro $eces en el 4< so)ra %. El 1 entra oc:o $eces en el 35< so)ra 3.

=in muc:os 0ro)lemas< 0uede e60licarse m+s claramente con un cuento. uatro 0ersonas est+n :am)rientas # $an a comer 0anes a un restaurante. =i :a# solo 35 0anes< entonces esas 1 0ersonas solo 0odr+n comer * 0anes cada uno< # so)rar+n 3 0anes. Eso Aue so)ra es el resultado del mdulo. Ja# muc:os usos 0ara el mdulo< como 0or e8em0lo sa)er cuando un n3mero es 0ar o im0ar. =in em)argo< en Processing es mu# com3n utilizarlo 0ara mantener a los n3meros en rango. Por e8em0lo< si una $aria)le sigue increment+ndose @%< -< 3< 1< 5< .< !< *...C< el mdulo 0uede con$ertirla en una secuencia. Fn incremento continuo 0uede con$ertirse en un ciclo entre & # 3 0or a0licar P 1:x 0 1 2 3 4 5 6 7 8 9 10 __________________________________________________________________________ x%4 0 1 2 3 0 1 2 3 0 1 2

Muc:os e8em0los a lo largo de las e60licaciones usar+n el mdulo de esta 9orma. ,l tra)a8ar con o0eraciones matem+ticas # $aria)les< es im0ortante tener en claro Aue ti0o de datos estamos mane8ando. ;a com)inacin de dos enteros @ intC nos dar+ como resultado otro entero. ;a com)inacin de dos decimales @!loatC siem0re nos dar+ como resultado un decimal. Pero la com)inacin de un entero @ intC con un decimal @!loatC siem0re nos dar+ un n3mero decimal< a 0esar de la o0eracin diera un resultado e6acto. Es im0ortante ser cuidadoso al momento de com)inar ti0os de datos 0ara e$itar errores:


21

int i < .; !loat ! < 0#/; int a < i / !; !loat b < i / !;

//->>?> O Bmposible asi'nar un nEmero decimal a una //,ariable tipo entero //1si'na 6#000000. a la ,ariable b del tipo !lotante

Es tam)in im0ortante 0restar atencin a algunos conce0tos matem+ticos< como 0or e8em0lo el conce0to de lmite< donde un n3mero di$idido 0or cero tiende a infinito. En esos casos el 0rograma 0roducir+ un error:int a < /; int b < 62 / a; //->>?> O -xcepcin Catem"ticaF producida por el cero#

-Prioridad en el 9-erador> 1gru-acin ;a 0rioridad del ordenador determina Aue o0eraciones se realizan antes +ue otras. Esto es de gran im0ortancia #a Aue 0uede ser determinante 0ara nuestro resultado. Por e8em0lo< la e60resin 0 4 . * 3< nos dar+ como resultado 20< 0uesto Aue tiene 0rioridad la multi0licacin. Primero< . * 3 resultar+ en 2/ # a continuacin se le sumar+ 0< dando 0or resultado 20. ;a 0rioridad 0uede ser cam)iada agregando 0arntesis. =i tu$iramos la e60resin (0 4 .) * 3< entonces la 0rioridad estara en la suma< dando como resultado 9inal 35.x < 0 4 . * 3; ; < (0 4 .) * 3 //1si'na 20 a la ,ariable //1si'na 03 a la ,ariable

;a siguiente ta)la< a modo e60licati$o< muestra Aue elementos tiene 0rioridad so)re otros. =iendo< 0ues< Aue los Aue se encuentran mas arri)a< tiene mas 0rioridad Aue los Aue est+n de)a8o:Multi0licati$os ,diti$os ,signacin * 4 < / 5 P

-1tajos uando 0rogramamos< recurrimos muc:o a estructuras cclicas. Muc:as $eces es necesario utilizar ata8os de escritura 0ara reducir el tamaGo del cdigo # Aue sea mas legi)le. El o0erador de incremento es 44< mientras Aue el de decremento es 55. ,m)os son usados como ata8os de suma # resta.int x < 6; x44; println(x); int ; < 6; ;55; println(;); //-Gui,ale a x < x 4 6; //Bmprime 2 //-Gui,ale a ; < ; 5 6; //Bmprime /

=i dese+ramos Aue se actualic el $alor antes de la e60resin< solo cam)iaremos de lugar el o0erador de incrementoBdecremento:int x < 6; println(44x); println(x); //Bmprime 2 //Bmprime 2

,l asignar el o0erador de suma con el o0erador de asignacin @ 4 0roduce re0eticiones en una dimensin. ,nidando iteraciones 0odemos crear e9ectos sumamente interesantes. Por e8em0lo< teniendo tan solo dos coordenadas de 0untos< si los anidamos en una estructura H?>< 0odemos cam)iar una sim0le dimensin a una 9igura de dos dimensiones.!or (int ; < 6/; ; 9 6//; ; 4< 6/) R point(6/, ;); S

!or (int x < 6/; x 9 6//; x 4< 6/) R point(x, 6/); S


32

!or (int ; < 6/; ; 9 6//; ; 4< 6/) R !or (int x < 6/; x 9 6//; x 4< 6/) R point(x, ;); S S

;a tcnica es mu# 3til 0ara crear 9ondos< te6turas # los conocidos patterns. ;os n3meros 0roducidos 0or las $aria)les de control de re0eticiones 0ueden a0licarse a la 0osicin< al color< al tamaGo< a la trans0arencia o a cualAuier otra cosa de atri)uto $isual.!ill(/, K:); no$tro)e(); smooth(); !or (int ; < 56/; ; 9< 6//; ; 4< 6/) R !or (int x < 56/; x 9< 6//; x 4< 6/) R ellipse(x 4 ;/D#/, ; 4 x/D#/, 63 4 x/2, 6/); S S no$tro)e(); !or (int ; < /; ; 9 6//; ; 4< 6/) R !or (int x < /; x 9 6//; x 4< 6/) R !ill((x4;) * 6#.); rect(x, ;, 6/, 6/); S S !or (int ; < 6; ; 9 6//; ; 4< 6/) R !or (int x < 6; x 9 ;; x 4< 6/) R line(x, ;, x4:, ;4:); line(x4:, ;, x, ;4:); S S

-.or*ato de las Estructuras Es im0ortante el es0acio entre las estructura 0ara Aue sea legi)le # clara la lectura de las mismas. ;as lneas de cdigo dentro de las mismas suelen lle$ar ta)ulaciones. uando el 0rograma se :ace largo una clara lectura es ideal en esta clase de estructuras. En este li)ro utilizamos la siguiente con$encin de es0acios en )lanco:int x < 3/; i! (x 8 6//) R line(2/, 2/, D/, D/); S else R line(D/, 2/, 2/, D/); S

;a siguiente es una alternati$a de 9ormato usada mu# 9recuentemente:int x < 3/; i! (x 8 6//) R


33

line(2/, 2/, D/, D/); S else R line(2/, D/, D/, 2/); S

Es esencial utilizar un 9ormato lim0io 0ara mostrar la 8erarAua del cdigo. El entorno de Processing tratar+ de a8ustar su cdigo a medida de Aue escri)e. ,3n as< en la seccin ,ools siem0re 0uede utilizarse la :erramienta -Auto .ormat/ 0ara lim0iar el cdigo cuando se lo necesite.


34

1-"ndice de Estructura .9A


3'

(nidad 3

.or*as) :"rticesEle*entos +ue se introducen en esta (nidad)be'in$hape(), end$hape(), ,ertex(), cur,eMertex(), be(ierMertex()

;as 9iguras geomtricas introducidas en la unidad .ormas: 0oordenadas y Primiti$as1 consiguen un e9ecto $isual altamente 0otente. 2o o)stante< un 0rogramador 0uede $alerse de sim0les ecuaciones Aue le 0ermiten crear 9iguras mas com0le8as. Na no estamos :a)lando de 9iguras 0rimiti$as< Aue solo reci)en coordenadas en 6 # en #< sino de 9iguras de ma#or com0le8idad construidas a )ase de $rtices.

Estas 9iguras son realmente sim0les en com0aracin a las 0osi)ilidades Aue o9rece. En los $ideoO8uegos actuales< se utilizan a0ro6imadamente una media de 1'000 $rtices< lo Aue con$ierte a esta :erramienta como una 9uncin im0rescindi)le en 0rogramacin. -:"rtice Para crear una 9igura :ec:a con $rtices< utilizaremos< en 0rinci0io< la 9uncin be'in$hape()< des0us de9iniremos cada 0unto @$rticeC con la 9uncin ,ertex()1 #< 9inalmente< com0letaremos la 9igura con end$hape(). ;as 9unciones de be'in$hape() # end$hape() siem0re de)en usarse en 0ares. ;os 0arntesis de la 9uncin ,ertex() ace0tan dos 0ar+metros< una coordenada de 6 e #:,ertex(x, ;)

Por de9ecto< la 9igura Aue se 9orme tendr+ un relleno )lanco con contorno en negro. ;as 9unciones !ill()< stro)e()1 noHill()1 no$tro)e() # stro)eIei'ht()< introducidas en la unidad .ormas: 0oordenadas y Primiti$as< son 3tiles 0ara controlar la $isualizacin de la 9igura. Para cerrar la 9igura< 0uede usarse la constante *@?$- en la 9uncin end$hape().noHill(); be'in$hape(); ,ertex(0/, 2/); ,ertex(D3, 2/); ,ertex(D3, K3); ,ertex(0/, K3); end$hape(); noHill(); be'in$hape(); ,ertex(0/, 2/); ,ertex(D3, 2/); ,ertex(D3, K3); ,ertex(0/, K3); end$hape(*@?$-);

El orden en Aue se escri)en los $rtices ca*/ia la 9orma en la Aue la 9igura es di)u8ada. El siguiente e8em0lo es e6actamente igual Aue el e8em0lo anterior< solo Aue se :an in$ertido el tercer $rtice 0or el cuarto:


32

noHill(); be'in$hape(); ,ertex(0/, 2/); ,ertex(D3, 2/); ,ertex(0/, K3); ,ertex(D3, K3); end$hape();

,Gadiendo mas $rtices # 9ormatos se 0uede 0otenciar de manera incre)le la 0otencia $isual. 5am)in< como se $io antes< se 0uede utilizar la estructura H?> 0ara me8orar el sistema.!ill(/); no$tro)e(); smooth(); be'in$hape(); ,ertex(6/, /); ,ertex(6//, 0/); ,ertex(7/, K/); ,ertex(6//, K/); ,ertex(6/, 7/); ,ertex(3/, ./); end$hape(); noHill(); smooth(); stro)eIei'ht(2/); be'in$hape(); ,ertex(32, 27); ,ertex(K., 03); ,ertex(:/, 32); ,ertex(:6, K3); ,ertex(./, :7); ,ertex(67, K3); end$hape(); no$tro)e(); !ill(/); be'in$hape(); ,ertex(./, 6/); !or (int i < 2/; i 9< 6//; i 4< 3) R ,ertex(2/, i); ,ertex(0/, i); S ,ertex(./, 6//); end$hape();

Fna 9igura com0le8a 0uede ser com0uesta 0or miles de $rtices< 0ero :a# Aue tener en cuenta Aue muc:os $rtices 0odran :acer m+s lento al 0rograma. -Puntos , ?Bneas ;a 9uncin be'in$hape() 0uede ace0tar di$ersos 0ar+metros Aue sir$en 0ara de9inir datos en los $rtices. ;os mismos $rtices 0ueden ser usados 0ara crear 9iguras sin relleno o lneas continuas. ;as constantes A?BNT$ # @BN-$ son usadas 0ara de9inir la con9iguracin de 0untos # lneas dentro de una 9igura.


33

//Dibu a un punto en cada ,%rtice be'in$hape(A?BNT$); ,ertex(0/, 2/); ,ertex(D3, 2/); ,ertex(D3, K3); ,ertex(0/, K3); end$hape(); //Dibu a una lnea ente cada par de ,%rtices be'in$hape(@BN-$); ,ertex(0/, 2/); ,ertex(D3, 2/); ,ertex(D3, K3); ,ertex(0/, K3); end$hape();

-.or*as 2o solo 0odemos con9igurar 0untos # lneas< sino Aue tam)in for*as. Ftilizando las constantes T>B1NX@-$1 T>B1NX@-Y$T>BA1 T>B1NX@-YH1N1 L&1D$< # L&1DY$T>BA con la 9uncin be'in$hape(). En estos casos necesitaremos ser muc:o m+s cuidadoso en el +m)ito es0acial de la 9igura # el orden en Aue 0onemos los $rtices.//*onecta cada 'rupo de tres ,%rtices be'in$hape(T>B1NX@-$); ,ertex(K3, 0/); ,ertex(6/, 2/); ,ertex(K3, 3/); ,ertex(2/, :/); ,ertex(7/, K/); ,ertex(03, D3); end$hape(); //*omien(a con el tercer ,%rtice, conecta todos los //,%rtices subsecuentes a los dos primeros be'in$hape(T>B1NX@-Y$T>BA); ,ertex(K3, 0/); ,ertex(6/, 2/); ,ertex(K3, 3/); ,ertex(2/, :/); ,ertex(7/, K/); ,ertex(03, D3); end$hape(); be'in$hape(T>B1NX@-YH1N); ,ertex(6/, 2/); ,ertex(K3, 0/); ,ertex(K3, 3/); ,ertex(7/, K/); ,ertex(6/, 2/); end$hape(); be'in$hape(L&1D$); ,ertex(0/, 23); ,ertex(D3, 0/); ,ertex(D3, 3/); ,ertex(0/, .3); ,ertex(0/, :/); ,ertex(D3, :3);


36

,ertex(D3, D3); ,ertex(0/, D/); end$hape(); be'in$hape(L&1DY$T>BA); ,ertex(0/, 23); ,ertex(D3, 0/); ,ertex(0/, .3); ,ertex(D3, 3/); ,ertex(0/, :/); ,ertex(D3, :3); ,ertex(0/, D/); ,ertex(D3, D3); end$hape();

-%urvas ;a 9uncin ,ertex() 9unciona mu# )ien 0ara crear 9iguras a )ase de lneas< 0ero si Aueremos crear una cur$a< necesitamos $alernos de las 9unciones cur,eMertex() # be(ierMertex(). Estas 9unciones 0ueden usarse entre be'in$hape() # end$hape()< siem0re # cuando be'in$hape() no tenga ning3n 0ar+metro. ;a 9uncin cur,eMertex() es usada 0ara conectar dos 0untos con una cur$a. =e le en$an dos 0ar+metros:cur,eMertex(x, ;)

El 0rimero # el 3ltimo cur,eMertex()< 8unto con be'in$hape() # end$hape()< act3an como 0untos de control. ;a cur$atura de cada segmento es calculada 0or los cur,eMertex() Aue :a# en medio de los 0untos de control:smooth(); noHill(); be'in$hape(); cur,eMertex(2/, cur,eMertex(2/, cur,eMertex(0/, cur,eMertex(./, cur,eMertex(D/, end$hape();

D/); ./); 0/); D/); D/);

//*6 //M6 //M2 //M0 //*2

En cam)io< cada be(ierMertex() de9ine la 0osicin de dos 0untos de control # de un 0unto de ancla8e.be(ierMertex(cx6, c;6, cx2, c;2, x, ;)

El 0rimer be(ierMertex() se u)ica 8unto con el be'in$hape(). ,nteriormente al be(ierMertex()< de)emos 0oner un ,ertex()< Aue de9inir+ el 0rimer 0unto ancla. ;a cur$a se 9orma entre 0unto ,ertex() # las coordenadas x e ; Aue se le en$an a be(ierMertex(). ;os 0rimeros cuatro 0ar+metros restantes de be(ierMertex() corres0onden al control de la cur$atura de la 9igura.noHill(); be'in$hape(); ,ertex(02, 2/); be(ierMertex(D/, 3, end$hape();

D/, K3,

0/, K3);

//M6 //*6, *2, M2


38

Para cur$as mas com0le8as< es necesario agregar una ma#or cantidad de be(ierMertext()< # 0ar+metros de 9ormato:smooth(); noHill(); be'in$hape(); ,ertex(63, 0/); be(ierMertex(2/, 53, K/, 3, ./, 03); be(ierMertex(3, K/, .3, 6/3, K/, K/); end$hape(); smooth(); no$tro)e(); be'in$hape(); ,ertex(7/, 07); be(ierMertex(7/, 07, 3., 6K, 2:, D0); be(ierMertex(2:, D0, 7/, 6/K, 7/, 07); end$hape(); smooth(); noHill(); be'in$hape(); ,ertex(63, ./); be(ierMertex(3, /, D/, /, 3/, 33); ,ertex(0/, .3); ,ertex(23, K3); be(ierMertex(3/, K/, K3, 7/, D/, K/); end$hape();

//M6 //*6, *2, M2 //*0, *., M0

//M6 //*6, *2, M2 //*0, *., M0

//M6 //*6, *2, M2 //M0 //M. //*0, *., M3

El tra)a8o con cur$as del ti0o Bzier suele ser mu# com0licado< tan solo 0ara di)u8ar unas 0ocas cur$as. 'e0endiendo la di9icultad de lo Aue se 0retenda di)u8ar< a $eces es 0re9eri)le o0tar 0or la o0cin Aue sea m+s sencilla. =in em)argo< :a# contri)uciones de usuarios mu# 3tiles Aue 0odran ser de gran a#uda. Entre una de ellas se encuentra la Bzier 5ool @Aue 0uede descargarse desde http:##processing.org#reference#tools# C la cual nos da un sim0le entorno de tra)a8o $isual< donde 0odemos di)u8ar cur$as Bzier como si 9uese un 0rograma de gr+9icos $ectoriales @como ,do)e Illustrator o InHsca0eC. ,l 9inalizar nuestro di)u8o< 0odemos co0iarlo # 0egarlo en nuestro entorno de tra)a8o en 9orma de cdigo. ;o con$ierte en una :erramienta de suma utilidad cuando se 0retende tra)a8ar con cur$as del ti0o Bzier.


40

1-"ndice de :"rtices


41

1-"ndice de %urvas


42

(nidad 6

;ate*5ticas) %urvasEle*entos +ue se introducen en esta (nidad)sG(), sGrt(), poN(), norm(), lerp(), map()

;as ecuaciones de matem+tica )+sica 0ueden ser usadas 0ara di/ujar la -osicin , varios atri/utos de una 9orma. Esas ecuaciones :an sido discutidas 0re$iamente. Estas ecuaciones se utilizan 0ara acelerar o desacelerar las 9ormas en mo$imiento # su recorrido a )ase de cur$as. -E&-onentes , AaBces ;a 9uncin sG() se utiliza 0ara calcular el cuadrado de un n3mero. 7 sea< ese mismo n3mero multi0licado 0or s mismo. omo )ien se sa)e< aunAue el n3mero sea negati$o< de$ol$er+ un resultado 0ositi$o. ,ce0ta solo un $alor como 0ar+metro:sG(,alor)

El $alor 0uede ser cualAuier n3mero. uando sG() es usado< el $alor 0uede ser asignado a una $aria)le:!loat a < sG(6); !loat b < sG(53); !loat c < sG(7); //1si'na 6 a la ,ariable aF -Gui,ale a 6 * 6 //1si'na 23 a la ,ariable bF -Gui,ale a 53 * 53 //1si'na D6 a la ,ariable cF -Gui,ale a 7 * 7

;a 9uncin sGrt() se utiliza 0ara calcular la raiz cuadrada de un n3mero. 7 sea< el numero Aue multi0licado 0or s mismo da determinado $alor. =olo 0ermite $alores 0ositi$os. =i el n3mero ingresado es negati$o< Processing de$ol$er+ un NaN @2ot a 2um)erC. Esto se de)e a Aue< matem+ticamente< no es 0osi)le o)tener la raz cuadrada de un n3mero negati$o. ,ce0ta solo un $alor como 0ar+metro:sGrt(,alor)

El $alor 0uede ser cualAuier n3mero. uando sGrt() es usado< el $alor 0uede ser asignado a una $aria)le:!loat a < sGrt(:3:6); !loat b < sGrt(:23); !loat c < sGrt(6); //1si'na D6 a la ,arible a //1si'na 23 a la ,ariable b //1si'na 6 a la ,ariable c

;a 9uncin poN() es usada 0ara calcular un n3mero ele$ado 0or el e60onente Aue uno desee. ,ce0ta dos 0ar+metros:poN(nEmero, exponente)

El n2mero es aAuel n3mero a multi0licar. El e(ponente es la cantidad de $eces Aue se $a a multi0licar.!loat !loat !loat !loat a b c d < < < < poN(6, 0); poN(0, .); poN(0, 52); poN(50, 0); //1si'na //1si'na //1si'na //1si'na 6#/ a la ,ariable aF -Gui,ale a 6*6*6 D6#/ a la ,ariable bF -Gui,ale a 0*0*0*0 /#66 a la ,ariable cF -Gui,ale a 6 / 0*0 52K#/ a la ,ariable dF -Gui,ale a 50*50*50

ualAuier n3mero @e6ce0to &C Aue es ele$ado a la & da como resultado %. =i se ele$a 0or % da como resultado el mismo n3mero:!loat a < poN(D, /); !loat b < poN(0, 6); !loat c < poN(., 6); //1si'na 6 //1si'na 0 //1si'na .


43

-@or*ali7acin , ;a-eo Ja# $eces en Aue necesitamos con$ertir una serie de n3meros en un rango de &.& a %.&. Esto es a lo Aue se denomina Normali3aci*n. uando n3meros entre &.& # %.& son multi0licados entre s< nunca dar+ un resultado menor a &.& ni ma#or a %.&. Esto 0ermite multi0licar un n3mero 0or otro o 0or s mismo tantas $eces como Aueramos sin Aue se salga del rango. omo la normalizacin suele de$ol$er n3meros decimales< utilizaremos $aria)les del ti0o !loat si lo reAuerimos. Para normalizar un n3mero< de)eremos di$idirlo 0or el m+6imo $alor del rango:(alor Inicial/#/ 6/2#/ 233#/ /#/ / 233#/ 6/2#/ / 233#/ 233#/ / 233#/

+lculo

(alor 2ormalizado/#/ /#. 6#/

Podemos< 0ues< sim0li9icar la tarea con la 9uncin norm(). Esta ace0ta tres 0ar+metros:norm(,alor, menor, ma;or)

El $alor es el n3mero a normalizar en uno entre &.& # %.&. El menor # el mayor son el n3mero menor # el ma#or Aue com0onen el rango a utilizar. =i el resultado est+ 9uera de rango resultar+ en n3mero menor Aue & o ma#or Aue %.!loat x < norm(/#/, /#/, 233#/); !loat ; < norm(6/2#/, /#/, 233#/); !loat ( < norm(233#/, /#/, 233#/); //1si'na /#/ a x //1si'na /#. a ; //1si'na 6#/ a (

;uego de Aue un $alor es normalizado entre &.& # %.&< ese mismo $alor -uede convertirse en un $alor normalizado de otro rango. Por e8em0lo< si normalizamos un n3mero su $alor se encontrar+ entre &.& # %.&< al multi0licar ese n3mero 0or 5&&.& o)tendremos un $alor normalizado entre un rango de &.& # 5&&.&. Para normalizar n3meros Aue est+n entre &.& # %.&< a un rango de -&&.& # -5&.&< es necesario multi0licar 0rimero 0or 5& # luego sumarle -&&./ango Inicial/#/ a 6#/ /#/ a 6#/ /#/ a 6#/

/ango 'eseado

/#/ a 233#/ 56#/ a 6#/ 52/#/ a :/#/

x * 233#/ (x * 2#/) 5 6#/ (x * D/#/) O 2/#/

+lculo

;a 9uncin lerp() es usada 0ara sim0li9icar esos c+lculos. 5iene tres 0ar+metros:lerp(,alor6, ,alor2, amt)

El $alor4 # el $alor5 de9inen el rango al cual se Auiere normalizar un $alor normalizado entre &.& # %.&. El amt es aAuel $alor normalizado entre &.& # %.&. Es decir< :ace Aue las con$ersiones $istas en la ta)la anterior sean mas r+0idas # sencillas 0ara el usuario.!loat x < lerp(52/#/, :/#/, /#/); !loat ; < lerp(52/#/, :/#/, /#3); !loat ( < lerp(52/#/, :/#/, 6#/); //1si'na 52/#/ a x //1si'na 2/#/ a ; //1si'na :/#/ a (

Por otro lado< la 9uncin map() 0ermite con$ertir directamente un n3mero Aue est+ en un rango< a otro rango. Esta 9uncin utiliza tres 0ar+metros:map(,alor, menor6, ma;or6, menor2, ma;or2)


44

El $alor es el n3mero a reOma0ear. =imilar a la 9uncin norm !< menor4 # mayor4 de9inen el rango en Aue se encuentra ese $alor. El menor5 # mayor5 de9inen el nue$o rango.!loat x < map(2/#/, /#/, 233#/, 56#/, 6#/); !loat ; < map(/#/, /#/, 233#/, 56#/, 6#/); !loat ( < map(233#/, /#/, 233#/, 56#/, 6#/); // 1si'na 5/#D. a x // 1si'na 56#/ a ; // 1si'na 6#/ a (

-%urvas Si*-les ;as 9unciones e60onenciales son 3tiles 0ara crear cur$as mu# sim0les # r+0idamente. ,l normalizar $alores de la 9uncin poN()< 0odemos o)tener r+0idamente cur$as ascendentes # descendentes< con n3meros Aue no e6ceden el $alor de %. ;a ecuacin tendra la siguiente 9orma:; < xn

'onde el $alor de ( sera un $alor normalizado entre &.& # %.&< # el $alor de n un n3mero entero. El siguiente es un sim0le e8em0lo de como se u)ican estos $alores en una grilla de e8es cartesianos:Z /#/ /#2 /#. /#: /#D 6#/ V /#/ /#//6: /#/23: /#627: /#./7: 6#/

, continuacin se muestran una serie de e8em0los de la ca0acidad de las ecuaciones e60onenciales< con normalizacin # utilizando ciclos H?>.!or (int x < /; x 9 6//; x44) R !loat n < norm(x, /#/, 6//#/); //>an'o de /#/ a 6#/ !loat ; < poN(n, .); //*alcula la *ur,a ; *< 6//; //>an'o de /#/ a 6//#/ point(x, ;); S !or (int x < /; x 9 6//; x44) R !loat n < norm(x, /#/, 6//#/); //>an'o de /#/ a 6#/ !loat ; < poN(n, /#.); //*alcula la *ur,a ; *< 6//; //>an'o de /#/ a 6//#/ point(x, ;); S //Dibu a crculos de puntos alrededor de la cur,a ; < x[. noHill(); smooth(); !or (int x < /; x 9 6//; x 4< 3) R !loat n < norm(x, /#/, 6//#/); //>an'o de /#/ a 6#/ !loat ; < poN(n, .); //*alcula la *ur,a ; *< 6//; //-scala ; ran'o de /#/ a 6//#/ stro)eIei'ht(n * 3); //Bncrementa ellipse(x, ;, 62/, 62/); S


4'

//Dibu a una lnea de arriba a los puntos de //la cur,a ; < x[. de x en un ran'o de 56#/ a 6#/ !or (int x < 3; x 9 6//; x 4< 3) R !loat n < map(x, 3, 73, 56, 6); !loat p < poN(n, .); !loat ;pos < lerp(2/, D/, p); line(x, /, x, ;pos); S //*rea un 'radiente de ; < x ; de ; < x[. !or (int x < /; x 9 6//; x44) R !loat n < norm(x, /#/, 6//#/); !loat ,al < n * 233#/; stro)e(,al); line(x, /, x, 3/); !loat ,al$Guare < poN(n, .) * 233#/; stro)e(,al$Guare); line(x, 3/, x, 6//); S


42

1-"ndice de %urvas ;ate*5ticas


43

(nidad 8

%olor) %olor -or @0*erosEle*entos +ue se introducen en esta (nidad)color, color(), colorCode()

5ra)a8ar con colores a tra$s de una 0antalla es di9erente a :acerlo en 0a0el o lienzo. Mientras Aue se a0liAuen las mismas reglas< el conocimiento de los 0igmentos 0ara 0intar @ro8o cadmio< azul 0rusiano< ocre tostadoC # 0ara im0rimir @cian< amarillo< magentaC no necesitan ser traducidos 0ara crear colores digitales. Por e8em0lo< unir todos los colores en un monitor de ordenador tiene como resultado el color )lanco< mientras Aue unir todos los colores con 0intura tiene como resultado el color negro @o un marrn e6traGoC. Fn monitor de ordenador mezcla los colores con luz. ;a 0antalla es una su0er9icie negra # se aGade luz coloreada. Esto se conoce como colores aditi$os< en contraste con el modelo de color sustracti$o 0ara tinta en 0a0el # lienzo. Esta imagen e60one la di9erencia entre los dos modelos:

*olor aditi,o

*olor sustracti,o

;a 9orma m+s com3n de es0eci9icar un color en el ordenador es mediante $alores /EB. Fn $alor /EB a8usta la cantidad de luz ro8a< $erde # azul en un 06el de la 0antalla. =i miras de cerca la 0antalla de tu tele$isor o el monitor de tu ordenador< $er+s Aue cada 06el se com0one de tres elementos inde0endientes de luz ro8a< $erde # azulR 0ero de)ido a Aue nuestros o8os slo 0ueden $er una cantidad limitada de detalle< los tres colores se mezclan 0ara 9ormar uno solo. ;a intensidad de cada elemento de color est+ es0eci9icada con $alores entre & # -55< donde & es el mnimo # -55 el m+6imo. O1juste de color En Processing< los colores est+n de9inidos 0or los 0ar+metros de las 9unciones bac)'round()< !ill() # stro)e():bac)'round(,alor6, ,alor2, ,alor0) !ill(,alor6, ,alor2, ,alor0) !ill(,alor6, ,alue2, ,alor0, al!a) stro)e(,alor6, ,alor2, ,alor0) stro)e(,alor6, ,alor2, ,alor0, al!a)

Por de9ecto< el 0ar+metro $alue4 de9ine el com0onente de color ro8o< $alor5 el com0onente $erde # $alue6 el azul. El 0ar+metro o0cional al9a 0ara !ill() o stro)e() de9ine la o0acidad. El $alor -55 del 0ar+metro alfa indica Aue el color es totalmente o0aco< # el $alor & indica Aue es totalmente trans0arente @no ser+ $isi)leC.bac)'round(6K., 226, :/);


46

=elector de color Podemos seleccionar el color con el cursor sim0lemente introducir los $alores Aue deseamos.

bac)'round(627, 60/, DK); no$tro)e(); !ill(6K., 226, :/); rect(6K, 6K, ::, ::); bac)'round(627, 60/, DK); noHill(); stro)eIei'ht(.); stro)e(6K., 226, :/); rect(67, 67, :2, :2); bac)'round(66:, 670, 2/:); no$tro)e(); !ill(627, 60/, DK, 6/2); rect(2/, 2/, 0/, :/); !ill(627, 60/, DK, 2/.); rect(3/, 2/, 0/, :/);

//Cenos opacidad //C"s opacidad

bac)'round(66:, 670, 2/:); int x < /; no$tro)e(); !or (int i < 36; i 9< 233; i 4< 36) R !ill(627, 60/, DK, i); rect(x, 2/, 2/, :/); x 4< 2/; S bac)'round(3:, 7/, 7.); smooth(); stro)eIei'ht(62); stro)e(2.2, 2/., .K, 6/2); line(0/, 2/, 3/, D/); stro)e(2.2, 2/., .K, 2/.); line(3/, 2/, K/, D/); bac)'round(3:, 7/, 7.); smooth(); int x < /; stro)eIei'ht(62);

//Cenos opacidad //C"s opacidad


48

!or (int i < 36; i 9< 233; i 4< 36) R stro)e(2.2, 2/., .K, i); line(x, 2/, x42/, D/); x 4< 2/; S

;a o0acidad se 0uede usar 0ara crear nue$os colores mediante su0er0osicin de 9ormas. ;os colores originados de0enden del orden en Aue se di)u8en las 9ormas.bac)'round(/); no$tro)e(); smooth(); !ill(2.2, 2/., .K, 6:/); ellipse(.K, 0:, :., :.); !ill(6K., 226, :/, 6:/); ellipse(7/, .K, :., :.); !ill(66:, 670, 2/:, 6:/); ellipse(3K, K7, :., :.); bac)'round(233); no$tro)e(); smooth(); !ill(2.2, 2/., .K, 6:/); ellipse(.K, 0:, :., :.); !ill(6K., 226, :/, 6:/); ellipse(7/, .K, :., :.); !ill(66:, 670, 2/:, 6:/); ellipse(3K, K7, :., :.);

//1marillo //Merde //1(ul

//1marillo //Merde //1(ul

-$ato de color El ti0o dato de color se usa 0ara almacenar colores en un 0rograma< # la 9uncin color() se usa 0ara asignar una $aria)le de color. ;a 9uncin color() 0uede crear $alores de gris< $alores de gris con o0acidad< $alores de color # $alores de color con o0acidad. ;as $aria)les del ti0o dato de color 0uede almacenar todas estas con9iguraciones:color('ris) color('ris, al!a) color(,alor6, ,alor2, ,alor0) color(,alor6, ,alor2, ,alor0, al!a)

;os 0ar+metros de la 9uncin color() de9ine un color. El 0ar+metro gris usado slo o con alfa< de9ine un rango de tonos de )lanco a negro. El 0ar+metro alfa de9ine la o0acidad con $alores de entre & @trans0arenteC a -55 @o0acoC. ;os 0ar+metros $alor4< $alor5 # $alor6 de9inen $alores 0ara los distintos com0onentes. ;as $aria)les del ti0o de dato de color se de9inen # se asignan de la misma 9orma Aue los ti0os de dato int # !loat discutidos en la unidad 'atos: (aria)les.color color color color c6 c2 c0 c. < < < < color(36); //*rea color(36, 2/.); //*rea color(36, 6/2, 630); //*rea color(36, 6/2, 630, 36); //*rea 'ris# 'ris con opacidad# a(ul# a(ul con opacidad#

'es0us de Aue una $aria)le color se :a#a de9inido< se 0uede usar como 0ar+metro 0ara las 9unciones bac)'round()< !ill() # stro)e().


'0

color rub; < color(266, 2., 2., 6:/); color pin) < color(20K, 637, 6K:); bac)'round(pin)); no$tro)e(); !ill(rub;); rect(03, /, 2/, 6//);

AC4, DS4 Processing usa el 9ormato de color /EB como 0redeterminado 0ara tra)a8ar< 0ero se 0uede usar en su lugar la es0eci9icacin J=B 0ara de9inir colores en 9uncin del matiz< saturacin # )rillo. El matiz de un color es lo Aue normalmente 0iensa la gente del nom)re del color: amarillo< ro8o< azul< naran8a< $erde< $ioleta. Fn matiz 0uro es un color sin diluir mu# intenso. ;a saturacin es el grado de 0ureza en un color. (a desde el matiz sin diluir :asta el matiz com0letamente diluido< donde el color no tiene )rillo. El )rillo de un color es su relacin de luz # oscuridad. ;a 9uncin colorCode() esta)lece el 9ormato de color 0ara un 0rograma:colorCode(modo) colorCode(modo, ran'o) colorCode(modo, ran'o6, ran'o2, ran'o0)

;os 0ar+metros de colorCode() cam)ian la 9orma en Aue Processing inter0reta el dato de color. El 0ar+metro modo 0uede ser tanto /EB como J=B. El rango de 0ar+metros 0ermite a Processing usar $alores di9erentes al 0redeterminado @& a -55C. En los gr+9icos de ordenador se usa 9recuentemente un rango de $alores entre &.& # %.&. 5anto si un 0ar+metro de un slo rango esta)lece el rango 0ara todos los colores< como si los 0ar+metros rango4< rango5 # rango6 esta)lecen el rango de cada uno S tanto ro8o< $erde< azul como matiz< saturacin< )rillo< de0endiendo del $alor del 0ar+metro modo.//-stablece el ran'o para los ,alores ro o, ,erde ; a(ul de /#/ a 6#/ colorCode(>X=, 6#/);

Fn a8uste 3til 0ara el 9ormato J=B es esta)lecer los 0ar+metros de rango4< rango5 # rango6 res0ecti$amente a 3.&< %&& # %&&. ;os $alores de matiz desde & a 3.& son los grados alrededor de la rueda de color< # los $alores de saturacin # )rillo desde & a %&& son 0orcenta8es. Este a8uste coincide con los $alores usados en muc:os selectores de color #< 0or tanto< :ace m+s sencilla la transicin de dato de color entre otros 0rogramas # Processing://-stablece el ran'o para el mati( con ,alores desde / a 0:/ ; la //saturacin ; el brillo con ,alores entre / ; 6// colorCode(\$=, 0:/, 6//, 6//);

;os siguientes e8em0los re$elan la di9erencia entre matiz< saturacin # )rillo.//*ambia el mati(; saturacin ; brillo constante colorCode(\$=); !or (int i < /; i 9 6//; i44) R stro)e(i*2#3, 233, 233); line(i, /, i, 6//); S //*ambia la saturacin; mati( ; brillo constante colorCode(\$=); !or (int i < /; i 9 6//; i44) R stro)e(602, i*2#3, 2/.); line(i, /, i, 6//); S


'1

//*ambia el brillo; mati( ; saturacin constante colorCode(\$=); !or (int i < /; i 9 6//; i44) R stro)e(602, 6/D, i*2#3); line(i, /, i, 6//); S //*ambia la saturacin ; el brillo; mati( constante colorCode(\$=); !or (int i < /; i 9 6//; i44) R !or (int < /; 9 6//; 44) R stro)e(602, *2#3, i*2#3); point(i, ); S S

Es 9+cil :acer transiciones sua$es entre colores cam)iando los $alores 0ara color()< !ill() # stro)e(). El 9ormato J=B tiene una enorme $enta8a so)re el 9ormato /EB cuando tra)a8amos con cdigos< 0orAue es m+s intuiti$o. am)iando los $alores de los com0onentes ro8o< $erde # azul< a menudo o)tenemos resultados ines0erados< mientras Aue estimando los resultados de los cam)ios del matiz< saturacin # )rillo seguimos un camino m+s lgico. ;os siguientes e8em0los muestran la transicin del $erde al azul. El 0rimer e8em0lo :ace la transicin usando el 9ormato /EB. /eAuiere calcular los tres $alores de color< # la saturacin del color cam)ia ines0eradamente en el centro. El segundo e8em0lo :ace la transicin usando el 9ormato J=B. =lo es necesario alterar un n3mero< # el matiz cam)ia sua$emente e inde0endientemente de las otras 0ro0iedades del color.//*ambio del a(ul al ,erde en !ormato >X= colorCode(>X=); !or (int i < /; i 9 6//; i44) R !loat r < :6 4 (i*/#72); !loat ' < 63: 4 (i*/#.D); !loat b < 2/. O (i*6#.0); stro)e(r, ', b); line(i, /, i, 6//); S // *ambio del a(ul al ,erde en !ormato \$= colorCode(\$=, 0:/, 6//, 6//); !or (int i < /; i 9 6//; i44) R !loat neN\ue < 2// O (i*6#2); stro)e(neN\ue, K/, D/); line(i, /, i, 6//); S

-De&adeci*al ;a notacin :e6adecimal @:e6C es una notacin alternati$a 0ara de9inir el color. Este mtodo es 0o0ular entre diseGadores Aue tra)a8an en la Ie) 0orAue est+ndares como J#0er5e6t MarHu0 ;anguage @J5M;C # ascading =t#le =:eets @ ==C usan esta notacin. ;a notacin Je6 0ara el color codi9ica cada n3mero desde el & al -55 en un $alor de dos dgitos usando los n3meros de & a 4 # las letras de , a ". 'e esta 9orma< tres $alores /EB desde & a -55 se 0ueden escri)ir como un solo $alor :e6 de seis dgitos. Fnas 0ocas con$ersiones de e8em0lo demuestran esta notacin:/EB233, 233, 233 /, /, /

Je6

]HHHHHH ]//////


'2

6/2, 630, 2/. 673, 2.., 37 66:, 2/:, 2/:

]::77** ]*0H.0= ]K.*-*-

;a con$ersin de los $alores /EB a notacin :e6 no es intuiti$a. , menudo< el $alor se toma del selector de color. Por e8em0lo< 0uedes co0iar # 0egar un $alor :e6 desde el selector de color de Processing en tu cdigo. uando se usan $alores de color codi9icados en notacin :e6< de)emos colocar un T antes del $alor 0ara distinguirlo dentro del cdigo.// *di'o del tercer e emplo reescrito usando nEmeros hex bac)'round(]D6D23K); no$tro)e(); !ill(]1-DD0*); rect(6K, 6K, ::, ::);

-:alores de grises ;os e8em0los $istos anteriormente :an usado el 9ondo 0or de9ecto de color gris claro< lneas negras< # 9iguras )lancas. Para cam)iar estos $alores< es necesario introducir sinta6is adicional. ;a 9uncin bac)'round() esta)lece el color de la $entana de re0resentacin con un n3mero entre & # -55. Este rango 0uede ser incmodo si no est+s 9amiliarizado con 0rogramas de di)u8o en el ordenador. El $alor -55 es )lanco # el $alor & es negro< con un rango de $alores de grises en medio. =i no se de9ine un $alor 0ara el 9ondo< se usa el $alor 0or de9ecto -&1 @gris claroC. ;a 9uncin !ill() de9ine el $alor del relleno de las 9iguras< # la 9uncin stro)e() de9ine el $alor del contorno de las 9iguras di)u8adas. =i no se de9ine un $alor de relleno< se usa el $alor 0or de9ecto -55 @)lancoC. =i no se de9ine un $alor de contorno< se usa el $alor 0or de9ecto & @negroC.rect(6/, 6/, !ill(2/.); stro)e(6/2); rect(2/, 2/, !ill(630); stro)e(630); rect(0/, 0/, !ill(6/2); stro)e(2/.); rect(./, ./, 3/, 3/); 3/, 3/); 3/, 3/); 3/, 3/);

uando se :a de9inido un $alor de relleno o contorno< se a0lica a todas las 9iguras di)u8adas des0us. Para cam)iar el $alor de relleno o contorno< usamos la 9uncin !ill() o stro)e() de nue$o. Fn 0ar+metro o0cional adicional 0ara !ill() o stro)e() regula la trans0arencia. 'e9iniendo el 0ar+metro a -55 :ace Aue la 9igura sea totalmente o0aca< # a & totalmente trans0arente:bac)'round(/); !ill(233, 22/); rect(63, 63, 3/, 3/); rect(03, 03, 3/, 3/);

El relleno # el contorno de una 9igura se 0uede eliminar. ;a 9uncin noHill() detiene a Processing de rellenar 9iguras< # la 9uncin no$tro)e() detiene la creacin de lneas # contornos de las 9iguras. =i usamos noHill() # no$tro)e() no di)u8aremos nada en la 0antalla. -1tri/utos de di/ujo ,dem+s de cam)iar los $alores de relleno # contorno de las 9iguras< tam)in es 0osi)le cam)iar atri)utos de


'3

la geometra. ;as 9unciones smooth() # no$mooth() acti$an # desacti$an el sua$izado @conocido como 9iltro antialiasingC. uando usamos una de estas 9unciones< a9ectar+ a todas las 9unciones di)u8adas des0us. =i usamos 0rimero smooth()< usar no$mooth() cancelar+ el a8uste< # $ice$ersa.smooth(); ellipse(0/, .D, 0:, 0:); no$mooth(); ellipse(K/, .D, 0:, 0:);

;os atri)utos de la lnea< est+n controlados 0or las 9unciones stro)eIei'ht()< stro)e*ap() # stro)eJoin(). ;a 9uncin stro)eIei'ht() tiene un 0ar+metro numrico Aue de9ine el grosor de todas las lneas di)u8adas des0us de usar esta 9uncin. ;a 9uncin stro)e*ap() reAuiere un 0ar+metro Aue 0uede ser >?&ND< $L&1>- o A>?J-*T. >?&ND redondea los 0untos 9inales< # $L&1>- los cuadra. A>?J-*T es una mezcla de am)os: redondea las esAuinas cuadradas sua$emente. Esta 9uncin se usa en lneas. ;a 9uncin stro)eJoin() tiene un 0ar+metro Aue 0uede ser =-M-@< CBTT-> o >?&ND. Estos 0ar+metros determinan la 9orma del contorno de la 9igura. =-M-@ corta en diagonal las esAuinas cuadradas< CBTT-> cuadra las esAuinas @es el $alor 0or de9ectoC # >?&ND redondea las esAuinas.smooth(); stro)eIei'ht(62); stro)e*ap(>?&ND); line(2/, 0/, D/, 0/); stro)e*ap($L&1>-); line(2/, 3/, D/, 3/); stro)e*ap(A>?J-*T); line(2/, K/, D/, K/); smooth(); stro)eIei'ht(62); stro)eJoin(=-M-@); rect(62, 00, 63, 00); stro)eJoin(CBT->); rect(.2, 00, 63, 00); stro)eJoin(>?&ND); rect(K2, 00, 63, 00);

//@nea superior //@nea central //@nea in!erior

//Hi'ura i(Guierda //Hi'ura central //Hi'ura derecha

;odos de di/ujo Por de9ecto< los 0ar+metros 0ara ellipse() de9ine la coordenada 6 del centro< la coordenada # del centro< la anc:ura # la altura. ;a 9uncin ellipseCode() cam)ia la 9orma en Aue se usan estos 0ar+metros 0ara di)u8ar eli0ses. ;a 9uncin ellipseCode() reAuiere un 0ar+metro Aue 0uede ser *-NT->< >1DB&$< *?>N-> o *?>N->$. El modo 0or de9ecto es *-NT->. El modo >1DB&$ tam)in usa el 0rimer # segundo 0ar+metro de ellipse() 0ara esta)lecer el centro< 0ero el tercer 0ar+metro de)er ser la mitad del anc:o< # el cuarto 0ar+metro de)e ser la mitad del alto. El modo *?>N-> :ace Aue ellipse() 9uncione de manera 0arecida a rect(). ausa Aue el 0rimer # segundo 0ar+metro se trasladen a la esAuina su0erior izAuierda del rect+ngulo Aue circunscri)e la eli0se # usa el tercer # cuarto 0ar+metro 0ara de9inir la anc:ura # la altura. El modo *?>N->$ tiene un e9ecto similar a *?>N->< 0ero causa Aue el tercer # cuarto 0ar+metro de ellipse() se de9inan en la esAuina in9erior derec:a del rect+ngulo.smooth(); no$tro)e(); ellipseCode(>1DB&$); !ill(62:); ellipse(00, 00, :/, :/); !ill(233);

//-lipse 'ris


'4

ellipseCode(*?>N->); ellipse(00, 00, :/, :/); !ill(/); ellipseCode(*?>N->$); ellipse(00, 00, :/, :/);

//-lipse blanca //-lipse ne'ra

on un estilo similar< la 9uncin rectCode() a9ecta a cmo se di)u8an los rect+ngulos. /eAuiere un 0ar+metro Aue 0uede ser *?>N->< *?>N->$ o *-NT->. El modo 0or de9ecto es *?>N->< # *?>N->$ causa Aue el tercer # cuarto 0ar+metro de rect() se de9inan en la esAuina contraria a la 0rimera. El modo *-NT-> causa Aue el 0rimer # segundo 0ar+metro de rect() de9inan el centro del rect+ngulo # usa el tercer # cuarto 0ar+metro 0ara la anc:ura # la altura.no$tro)e(); rectCode(*?>N->); !ill(62:); rect(./, ./, :/, :/); rectCode(*-NT->); !ill(233); rect(./, ./, :/, :/); rectCode(*?>N->$); !ill(/); rect(./, ./, :/, :/);

//>ect"n'ulo 'ris //>ect"n'ulo blanco //>ect"n'ulo ne'ro


''

(nidad 10

I*agen) :isuali7acin , ?> 5 $in comillas, n es una ,ariable //->>?> 5 @as comillas dobles (W W) de!inen a n como un //$trin', no un char //->>?> O @as ,ariables tipo char pueden almacenar //solo un car"cter

El siguiente e8em0lo crea una nue$a $aria)le ti0o char< asigna $alores # los im0rime en la consola:char letra < ^1^; println(letra); letra < ^=^; println(letra); //Declara una ,ariable letra ; asi'na el ,alor de ^1^ //Bmprime 1 en la consola //1si'na ^=^ a la ,ariable letra //Bmprime = en la consola

Muc:os $alores char tienen un $alor n3mero Aue les corres0onde 0or el cdigo de la ta)la ,= II. Por e8em0lo< , es .5< B es ..< es .!< # as. Puede 0ro)ar cada cdigo usando la 9uncin println():char letra < ^1^; println(letra); //Bmprime 1 en la consola int n < letra; //1si'na el ,alor num%rico de 1 a la ,arible n println(n); //Bmprime :3 en la consola

Es 0osi)le articular 9unciones matem+ticas con $alores al9a)ticos. En el siguiente e8em0lo se utiliza un ciclo H?> 0ara im0rimir el al9a)eto de la , a la W< 0or aumentar los $alores char con la 9uncin de incremento:char letra< ^1^; //Declara una ,ariable tipo char ; asi'na el ,alor de 1 !or (int i < /; i 9 2:; i44) R print(letra); //Bmprime un car"cter en la consola letra44; //$uma 6 al ,alor del car"cter S println(^#^); //1're'a un punto al !inal del al!abeto


'8

-Pala/ras , 9raciones ,l utilizar un o)8eto de ti0o $trin' 0ueden almacenarse 0ala)ras # oraciones com0letas. Para distinguir los datos $trin' del resto del 0rograma se utilizan comillas do)les @ WWC. ;as do)les comillas di9erencian ^^s^^ como $trin' de ^s^ como car+cter. ;os datos ti0os $trin' son di9erentes a los del ti0o int1 !loat o char< #a Aue se trata de un ob'eto1 o sea un ti0o de dato Aue 0uede almacenar muc:os elementos # 9unciones. 'e igual manera< ABma'e # AHont tam)in son o)8etos. ;os o)8etos ti0o $trin' se declaran # se asignan como cualAuiera:$trin' $trin' $trin' strin' a b c d < < < < W1nnimoW; ^-^; W-W; W-W; //1si'na W1nnimoW a la ,ariable a //->>?> O @as comillas ^ ^ deben ser dobles# //1si'na W-W a c //->>?> 5 $trin' debe comen(ar con ma;Esculas

;os siguientes e8em0los muestran algunos usos )+sicos de los o)8etos ti0o $trin'://@os datos tipo $trin' pueden contener lar'os textos $trin' s6 < W>a)ete bee bee_W; $trin' s2 < W>rrrrrrrrrrrrrrrummmmmp!!!! till!!!! tooooo_W; println(s6); //Bmprime W>a)ete bee bee_W println(s2); //Bmprime W>rrrrrrrrrrrrrrrummmmmp!!!! till!!!! tooooo_W //Datos tipo $trin' combinados con el operador 4 $trin' s0 < W>a)ete W; $trin' s. < Wrinn(e)eteW; $trin' s3 < s0 4 s.; println(s3); //Bmprime W>a)ete rinn(e)eteW


20

(nidad 12

$atos) %onversin , 9/jetosElementos que se introducen en esta Unidad:boolean(), b;te(), char(), int(), !loat(), str() # (Aunto como ?perador) ABma'e#Nidth, ABma'e#hei'ht $trin'#len'th(), $trin'#startsIidth(), $trin'#endsIidth(), $trin'#char1t(), $trin'#to*har1rra;(), $trin'#sub$trin'(), $trin'#to@oNer*ase(), $trin'#to&pper*ase() $trin'#eGuals()

uando creamos una $aria)le< es0eci9icamos el ti0o de datos con el Aue $a a tra)a8ar. =i la $aria)le almacena n3meros< su utilizar+ una $aria)le ti0o int o ti0o !loat. =i la $aria)le almacena te6to< se usar+ el ti0o $trin' o< si se tratara de solo un car+cter< del ti0o char. ,s< $aria)les Aue almacenan $alores true o !alse son del ti0o boolean< 0ara almacenar una imagen digital ser+ un o)8eto del ti0o ABma'e # 0ara almacenar una ti0ogra9a del ti0o AHont. ;uego de ser declarada< se le asigna un $alor del ti0o de la $aria)le. =in em)argo< muc:as $eces es necesario con$ertir una $aria)le de determinado ti0o en otro ti0o. ;os ti0os de datos int1 !loat1 char # boolean son llamadas $aria)les 0rimiti$as< #a Aue almacenan un si*-le elemento. En cam)io< $trin'1 ABma'e # AHont son di9erentes< las $aria)les Aue se crean son en realidad o/jetos. ;os o)8etos son usualmente com0uestos 0or muc:as $aria)les 0rimiti$as # otros o)8etos< # 0ueden 0oseer 9unciones dentro de ellos mismos. ;os o)8etos se distinguen 0or comenzar siem0re la 0rimer letra en ma#3sculas. -%onversin de $atos ,lgunos ti0os de datos 0ueden con$ertirse en otro ti0o autom+ticamente con solo se reasignados a una $aria)le de otro ti0o. Por e8em0lo< una $aria)le del ti0o int 0uede con$ertirse autom+ticamente en una del ti0o !loat< 0ero una del ti0o !loat no 0uede con$ertirse autom+ticamente en una del ti0o int.!loat ! int i < ! < i; i < !; < 62#:; 62K; //*on,ierte 62K en 62K#/ //->>?> O No se puede con,ertir autom"ticamente un !loat en un int

PDu ocurre si necesitamos con$ertir otra clase de $aria)le en otros ti0osQ Para esto e6isten una gran cantidad de 9unciones de con$ersin de un ti0o de dato a otro. =in em)argo< :a# Aue aclarar Aue< como los datos almacenan di9erentes cantidad de )it< es mu# 0ro)a)le Aue en algunos 0ases se 0ierda una gran cantidad de in9ormacin @mu# 3til 0ara a:orrar memoria del 0rogramaC. ;as 9unciones de con$ersin son las siguientes: boolean()1 b;te()1 char()1 !loat()1 int()< # str(). ada una trans9orma cualAuier clase de dato en el corres0ondiente a cada 9uncin. ;a 9uncin boolean() con$ierte el n3mero & en un $alor !alse # cualAuier otro n3mero en un $alor true.int i < /; boolean b < boolean(i); int n < 62; b < boolean(n); $trin' s < W!alseW; b < boolean(s); //1si'na !alse a b //1si'na true a b //1si'na !alse a b

;a 9uncin b;te() con$ierte cualAuier $alor en una re0resentacin de )#te. ;a 0ro9undidad numrica es tan solo de O%-! a %-*. =in em)argo< si el n3mero esta 9uera del rango< la 9uncin lo con$ierte en una re0resentacin en )#te.


21

!loat ! < :3#/; b;te b < b;te(!); char c < ^-^; b < b;te(c); ! < 60/#/; b < b;te(!);

//1si'na :3 a b //1si'na :7 a b //1si'na 562: a b

;a 9uncin char() con$ierte cualAuier $alor numrico en un car+cter. El numero corres0onde a una re0resentacin de la ta)la ,= II.int i < :3; b;te ; < K2#/; char c < char(i); c < char(;);

//1si'na ^1^ a c //1si'na ^\^ a c

;a 9uncin !loat() con$ierte cualAuier clase de dato en un n3mero decimal. Es usado 9recuentemente cuando :acemos c+lculos matem+ticos.int i int !loat !loat < 2; < 0; !6 < i/ ; //1si'na /#/ a !6 !2 < i/!loat( ); //1si'na /#::::::K a !2

;a 9uncin int() con$ierte cualAuier clase de datos en un n3mero entero. Es mu# utilizado 0ara redondear un resultado !loat # as este no ocu0e demasiada memoria innecesariamente. En muc:as casos :a# 9unciones Aue de$uel$en $alores !loat # en necesario con$ertirlos.!loat ! < :3#0; int i < int(!); char c < ^-^; i < int(c); //1si'na :3 a i //1si'na :7 a i

;a 9uncin str() con$ierte cualAuier clase de datos en una re0resentacin $trin'.int i < 0; $trin' s < str(i); !loat ! < 562#:; s < str(!); boolean b < true; s < str(b); //1si'na W0W a s //1si'na W562#:W a s //1si'na WtrueW a s

;a 9uncin n!() @Aue se $er+ m+s adelanteC 0ro$ee de mas control cuando con$ertimos un int o un !loat a un $trin'. -9/jetos ;as $aria)les ti0o $trin'< ABma'e # AHont son del ti0o o)8eto. ;as $aria)les dentro de un o)8eto se denominan campos # las 9unciones se denominan m7todos. =e 0uede acceder a los cam0os # a los mtodos con el o0erador punto @.C. El o0erador 0unto 9unciona como 0uente entre el nom)re del o)8eto # el elemento dentro del mismo. ABma'e1 AHont # $trin' son o)8etos< # 0or tanto 0oseen elementos. ;os o)8eto ti0o ABma'e 0oseen dos 9unciones Aue almacenan el anc:o # el alto de la imagen cargada. =e llaman< de manera a0ro0iada< Nidth @anc:oC # hei'ht @altoC. Para acceder a ellas< se escri)e el nom)re del o)8eto seguido 0or el o0erador 0unto # el nom)re de la 9uncin.


22

ABma'e im' < loadBma'e(WbuenosYaires# p'W); pixeles int N < im'#Nidth; int h < im'#hei'ht; println(N); println(h);

//*ar'a una Bma'en de 02/ x 2./ //1si'na 02/ to N //1si'na 2./ to h //Bmprime W02/W //Bmprime W2./W

M+s adelante< se discutir+n una gran $ariedad de 9unciones del o)8eto ABma'e. Por otro lado< el o)8eto $trin' 0osee tam)in una gran cantidad de elementos Aue lo com0onen. Fno de ellos es el mtodo len'th()1 el cual regresa de $alor la cantidad de caracteres Aue lo com0onen:$trin' s6 < WTocar AianoW; $trin' s2 < WTW; println(s6#len'th()); println(s2#len'th());

//Bmprime W66W //Bmprime W6W

;os mtodos startsIith() # endsIith() e$al3an cuando un $trin' em0ieza o termina< siem0re # cuando se utilice el 0ar+metros adecuados:$trin' s6 < W=uenos 1iresW; println(s6#startsIith(W=W)); println(s6#startsIith(W1iresW)); println(s6#endsIith(W1iresW)); //Bmprime WtrueW //Bmprime W!alseW //Bmprime WtrueW

El mtodo char1t() es usado 0ara leer un solo car+cter de un &tring. /eci)e como 0ar+metro un n3mero Aue indica la u)icacin del mismo:$trin' s < WMerdeW; println(s#char1t(/)); println(s#char1t(2)); println(s#char1t(.)); //Bmprime WMW //Bmprime WrW //Bmprime WeW

El mtodo to*har1rra;() crea un nue$o arra# de caracteres del contenido del $trin':$trin' s < W1(ulW; char`a c < s#to*har1rra;(); println(c`/a); println(c`6a);

//Bmprime W1W //Bmprime W(W

El mtodo substrin'() es usado 0ara leer a 0orcin del $trin'. , di9erencia de char1t() Aue solo lee un car+cter< substrin'() 0uede leer un $trin' de caracteres. =e utiliza de 0ar+metro un n3mero Aue indica la 0osicin de un car+cter # de$uel$e un $trin' desde esa 0osicin 0ara delante. =i se utilizan dos 0ar+metros determina una 0orcin es0ec9ica.$trin' s < WXialloW; println(s#substrin'(2)); println(s#substrin'(.)); println(s#substrin'(6, .)); println(s#substrin'(/, s#len'th()56)); //Bmprime //Bmprime //Bmprime //Bmprime WalloW WloW WialW WXiallW

El mtodo to@oNer*ase() 0uede usarse 0ara de$ol$er una co0ia del $trin' com0letamente en min3sculas. 'e la misma 9orma< to&pper*ase() :ace lo mismo 0ero de$uel$e el te6to en ma#3sculas.


23

$trin' s < WNe'roW; println(s#to@oNer*ase()); println(s#to&pper*ase());

//Bmprime Wne'roW //Bmprime WN-X>?W

omo un $trin' es un o)8eto< no es 0osi)le com0arar resultados con el o0erador relacional de igualdad @^, :2, K/); //-scribe ^>^ en la posicin (:2,K/) AHont !ont; !ont < loadHont(W1ressence562#,lNW); textHont(!ont); !ill(/); $trin' s < WArocessin' est" escribiendo TextoW; text(s, 6/, 2/, D/, 3/); AHont !ont; !ont < loadHont(W1ressence502#,lNW); textHont(!ont); !ill(233); //=lanco text(WD1VW, /, ./); !ill(/); //Ne'ro text(W*MXW, /, K/); !ill(6/2); //Xris text(W1T@W, /, 6//); AHont !ont; !ont < loadHont(W1ressence5K2#,lNW); textHont(!ont); !ill(/, 6:/); //Ne'ro con ba a ?pacidad text(W6W, /, D/); text(W2W, 63, D/); text(W0W, 0/, D/); text(W.W, .3, D/); text(W3W, :/, D/);

5am)in 0ueden utilizarse dos 9uentes distintas en el mismo 0rograma< 0ero de)er+n crearse dos $aria)les ti0o AHont Aue las almacenen:AHont !ont6, !ont2; !ont6 < loadHont(W1ressence502#,lNW); !ont2 < loadHont(W1rhermann502#,lNW); !ill(/); textHont(!ont6); text(WXN&W, :, .3); textHont(!ont2); text(WXN&W, :, D/);

-1tri/utos de educcin del tama+o de la letra AHont !ont; !ont < loadHont(W1ressence502#,lNW); textHont(!ont); !ill(/); text(W@NbW, /, ./); //Xrande text$i(e(6D); text(W$TNW, /, K3); //Cediano text$i(e(62); text(W=?$W, /, 6//); //AeGue+o //1'randar tama+o de letra AHont !ont; !ont < loadHont(W1ressence562#,lNW); textHont(!ont); text$i(e(02); !ill(/); text(W@NbW, /, ./); //Xrande text$i(e(6D); text(W$TNW, /, K3); //Cediano text$i(e(62); text(W=?$W, /, 6//); //AeGue+o

;a 9uncin text@eadin'() 0ermite alterar el es0acio entre lineas:text@eadin'(dist)

;a 0ro0iedad dist de9ine la distancia del es0acio en unidad de 0i6eles.AHont !ont; !ont < loadHont(W1ressence562#,lNW); textHont(!ont); $trin' lines < W@6 @2 @0W; text@eadin'(6/); !ill(/); text(lines, 3, 63, 0/, 6//); text@eadin'(2/); text(lines, 0:, 63, 0/, 6//); text@eadin'(0/); text(lines, :D, 63, 0/, 6//);

,dem+s< el te6to 0uede ser marginado al centro< a la izAuierda o a la derec:a utilizando la 9uncin text1li'n():text1li'n(C?D?)

En este caso< el modo es una constante Aue 0uede ser *-NT-> @centroC< >BX\T @derec:aC # @-HT


23

@izAuierdaC< # se re9iere sim0lemente a la alineacin Aue tendr+ el te6to mostrado en 0antalla.AHont !ont; !ont < loadHont(W1ressence562#,lNW); textHont(!ont); line(3/, /, 3/, 6//); !ill(/); text1li'n(@-HT); text(WB(GuierdaW, 3/, 2/); text1li'n(>BX\T); text(WDerechaW, 3/, ./); text1li'n(*-NT->); text(W*entroW, 3/, D/);

;a 9uncin textIidth() calcula # regresa el anc:o de 0i6el de un car+cter o te6to. El calculo se realiza de0endiendo de las 0ro0iedades de textHont() # text$i(e(). Na Aue cada car+cter 0osee un anc:o di9erente entre s< es im0osi)le sa)er la medida e6acta de una cadena de caracteres. Para esos casos donde necesitamos una medida es0ec9ica< o conocer el tamaGo de nuestra cadena< se utiliza esta 9uncin.AHont !ont; !ont < loadHont(W1ressence502#,lNW); textHont(!ont); !ill(/); char c < ^&^; !loat cN < textIidth(c); text(c, 22, ./); rect(22, .2, cN, 3); $trin' s < W&*W; !loat sN < textIidth(s); text(s, 22, K:); rect(22, KD, sN, 3);


26

(nidad 14

;ate*5ticas) T->YAB, \1@HYAB, TI?YAB, radians(), de'rees() sin(), cos(), arc()

;a trigonometra 0ermite de9inir relaciones entre lados # +ngulos de los tri+ngulos. ;a 9unciones trigonomtricas de seno # coseno nos 0ermiten generar n3meros re0etiti$os 0ara di)u8ar ondas< arcos< crculos # es0irales. -Engulos , 9ndas ;os grados son una 9orma com3n de medir +ngulos. Fn +ngulo recto es de 4&Y< a mitad de camino< alrededor de un crculo< es %*&Z< # el crculo com0leto es de 3.&Z. ,l tra)a8ar con trigonometra< los +ngulos se miden en unidades llamadas radianes. Ftilizando los radianes< el +ngulo de un $alor se e60resa en relacin con el $alor de [ de matem+tica< escrito en caracteres latinos como \0i\. En trminos de unidades radianes< el +ngulo recto es [B-< a mitad de camino alrededor de un crculo es sim0lemente [ < # el 0unto de 0artida es -[.

El $alor numrico de [ es una constante Aue es in9initamente larga # sin ning3n 0atrn de re0eticin. Es la razn de la circun9erencia de un crculo en relacin a su di+metro. ,l escri)ir el cdigo en Processing< se 0uede utilizar la constante matem+tica AB 0ara re0resentar a este n3mero. 7tros $alores de uso de [ se e60resa con las constantes L&1>T->YAB1 \1@HYAB # TI?YAB. =i se e8ecuta la siguiente lnea de cdigo< se 0odr+ $er el $alor de [ con sus * dgitos signi9icati$os:println(AB); //Bmprime el ,alor de c en la consola

En el uso cotidiano< el $alor numrico de [ suele denominarse como 3:!or (!loat an'le < /; an'le 9 TI?YAB; an'le 4< AB/2.#/) R println(sin(an'le)); S

omo los $alores de seno son entre O%.& # %.& son mu# 9+ciles de usar en una com0osicin. Por e8em0lo< al multi0licarlos 0or 5&< o)tendremos un rango de entre O5&.& # 5&.&:!or (!loat an'le < /; an'le 9 TI?YAB; an'le 4< AB/2.#/) R println(sin(an'le) * 3/#/); S

Para con$ertir $alores de seno en n3meros 0ositi$os< :a# Aue sumar el $alor %.& 0ara Aue el rango 0ase a ser de &.& a -.&. ;uego< al di$idir esos $alores 0or -.& o)tendremos un rango entre &.& # %.&. ;a 9uncin de map() tam)in 0uede utilizarse 0ara sim0li9icar el tra)a8o. En el siguiente e8em0lo se 0onen los $alores de seno en un rango entre & # %&&&:


30

!or (!loat an'le < /; an'le 9 TI?YAB; an'le 4< AB/2.#/) R !loat neNMalue < map(sin(an'le), 56, 6, /, 6///); println(neNMalue); S

=i utiliz+ramos estos $alores seno en una coordenadaO#< 0ara di)u8ar una serie de 0untos< o)tendremos como resultado una onda.

si(e(K//, 6//); no$tro)e(); !ill(/); !loat an'le < /#/; !or (int x < /; x 9< Nidth; x 4< 3) R !loat ; < 3/ 4 (sin(an'le) * 03#/); rect(x, ;, 2, .); an'le 4< AB/./#/; S

,l reem0lazar algunos n3meros con $aria)les< 0ermiten controlar la 9orma de onda de una 9orma m+s e6acta. ;a $aria)le offset controla la coordenadaO# de la onda< la $aria)le scaleVal controla el anc:o de a onda # la $aria)le angle9nc controla la $elocidad con la cual aumenta el +ngulo de la onda< creando una onda de ma#or o menor 9recuencia.

si(e(K//, 6//); no$tro)e(); smooth(); !ill(/); !loat o!!set < 3/#/; //*ompensacin en V !loat scaleMal < 03#/; //-scala el ,alor de la ma'nitud de ?nda !loat an'leBnc < AB/2D#/; //Bncremento entre "n'ulos !loat an'le < /#/; //-l "n'ulo recibe ,alores desde / !or (int x < /; x 9< Nidth; x 4< 3) R !loat ; < o!!set 4 (sin(an'le) * scaleMal); rect(x, ;, 2, .); an'le 4< an'leBnc; S

En el caso de la 9uncin cos()< regresa el coseno de un +ngulo. En otras 0ala)ras< son los mismos $alores Aue en seno< con la di9erencia Aue :a# una com0ensacin de 4&Y.


31

si(e(K//, 6//); no$tro)e(); smooth(); !loat o!!set < 3/#/; !loat scaleMal < 2/#/; !loat an'leBnc < AB/6D#/; !loat an'le < /#/; !or (int x < /; x 9< Nidth; x 4< 3) R !loat ; < o!!set 4 (sin(an'le) * scaleMal); !ill(233); rect(x, ;, 2, .); ; < o!!set 4 (cos(an'le) * scaleMal); !ill(/); rect(x, ;, 2, .); an'le 4< an'leBnc; S

;os siguientes e8em0los muestran una manera de generar 9ormas utilizando la 9uncin sin().

si(e(K//, 6//); !loat o!!set < 3/; !loat scaleMal < 0/#/; !loat an'leBnc < AB/3:#/; !loat an'le < /#/; be'in$hape(T>B1NX@-Y$T>BA); !or (int x < . ; x 9< Nidth43; x 4< 3) R !loat ; < sin(an'le) * scaleMal; i! ((x P 2) ate(.); println(!rame*ount); S

on cam)iar alg3n 0ar+metro dentro de la estructura draN()< 0roduciremos un sim0le e9ecto de mo$imiento. Por e8em0lo< a tra$s de una $aria)le< cam)iar la 0osicin en la Aue se encuentra una lnea.!loat ; < /#/; ,oid draN() R !rame>ate(0/); line(/, ;, 6//, ;); ; < ; 4 /#3; S

uando este cdigo es e8ecutado< las $aria)les son reem0lazadas con los $alores actuales # $uel$e a correr las acciones en este orden:


68

!loat ; < /#/ !rame>ate(0/) 555555555555555555555555555555555555555555555555 -ntra al draN() line(/, /#/, 6//, /#/) ; < /#3 !rame>ate(0/) 555555555555555555555555555555555555555555555555 -ntra al draN() por se'unda ,e( line(/, /#3, 6//, /#3) ; < 6#/ !rame>ate(0/) 555555555555555555555555555555555555555555555555 -ntra al draN() por tercera ,e( line(/, 6#/, 6//, 6#/) ; < 6#3 -tc###

;a $aria)le de control mostrada anteriormente @llamada ;C de)e ser declarada 9uera del )loAue draN(). 'e otro modo< cada $ez Aue el )loAue se actualice $ol$er+ a crear la $aria)le< es decir< es como si es $alor se restear). omo se 0uede com0ro)ar anteriormente< el 9ondo del 0rograma no se actualiza autom+ticamente con cada $uelta del )loAue draN(). Esto 0roduce un e9ecto de )arrido. =in em)argo< PAu 0asa si lo Aue Aueremos es solo una lnea mo$indose< en lugar de una es0ecie de )arridoQ. /ecurriremos a declararlo como una de las -ri*eras lBneas dentro del draN() # con un color en es0ec9ico. ;a solucin se 0iensa como si se estu$iese di)u8ando cada cuadro a mano. =i Aueremos Aue la 0osicin antigua de una 9igura desa0arezca< $ol$emos a 0intar el 9ondo< este 0intar+ la 9igura #< 0osteriormente< se di)u8ar+ la 9igura en la 0osicin actualizada.!loat ; < /#/; ,oid draN() R !rame>ate(0/); bac)'round(2/.); ; < ; 4 /#3; line(/, ;, 6//, ;); S

;a $aria)le Aue controla la 0osicin de la lnea 0uede ser usada 0ara otros 0ro0sitos. Por e8em0lo< alterar el color del 9ondo:!loat ; < /#/; ,oid draN() R !rame>ate(0/); bac)'round(; * 2#3); ; < ; 4 /#3; line(/, ;, 6//, ;); S

Pasado unos 0ocos segundos del 0rograma< la lnea desa0arece 0or de)a8o. on una sim0le estructura BH solucionamos ese 0ro)lema:

!loat ; < /#/; ,oid draN() R


80

!rame>ate(0/); bac)'round(; * 2#3); ; < ; 4 /#3; line(/, ;, 6//, ;); i! (; 8 6//) R S S ; < /;

-%ontrolando el .lujo Ja# 9unciones Aue< incluso en 0rogramas din+micos< solo reAuieren ser e8ecutadas una $ez. El )loAue setup() 0ermite Aue cualAuier 9uncin Aue se escri)a dentro de el se e8ecute solo una $ez. Mu# 3til 0ara 9unciones como si(e() o loadBma'e()< Aue suelen ser e8ecutadas 3nicamente la 0rimera $ez. El )loAue setup() se escri)e siem0re antes Aue el )loAue draN() #< al igual Aue con el )loAue draN()< 0uede :a)er solo un )loAue setup() 0or 0rograma. uando un 0rograma es e8ecutado< 0rimero se lee lo Aue est+ 9uera de los )loAues setup() # draN()< luego se lee todo lo Aue est+ dentro del setup() #< 9inalmente< lo Aue est+ dentro del draN(). En el siguiente e8em0lo< el tamaGo de la $entana< el 9iltro de sua$izado # el relleno no cam)iar+n< as Aue se incluir+n en el )loAue setup().!loat ; < /#/; ,oid setup() R si(e(6//, 6//); smooth(); !ill(/); S ,oid draN() R bac)'round(2/.); ellipse(3/, ;, K/, K/);


81

; 4< /#3; i! (; 8 63/) R ; < 53/#/; S S

uando este cdigo es e8ecutado< las $aria)les son reem0lazadas con los $alores actuales # $uel$e a correr las acciones en este orden:!loat ; < /#/ si(e(6//, 6//) 55555555555555555555555555555555555555555555555 smooth() !ill(/) bac)'round(2/.) 55555555555555555555555555555555555555555555555 ellipse(3/, /#/, K/, K/) ; < /#3 bac)'round(2/.) 55555555555555555555555555555555555555555555555 ellipse(3/, /#3, K/, K/) ; < 6#/ bac)'round(2/.) 55555555555555555555555555555555555555555555555 ellipse(3/, 6#/, K/, K/) ; < 6#3 -tc####

-ntra al setup()

-ntra al draN()

-ntra al draN() por se'unda ,e(

-ntra al draN() por tercera ,e(

uando el $alor de y es ma#or a %5&< el cdigo en la estructura I" con$ierte el $alor a O5&. ;a $aria)le Aue cam)ia con cada re0eticin del )loAue draN() de)e ser declarada fuera de los )loAues setup() # draN(). =i est+ es declarada dentro del draN()< se estar+ reOcreando con cada re0eticin del mismo< 0or lo tanto su $alor nunca cam)iara. Por otro lado< 9uera de los )loAues setup() # draN() solo 0ueden declararse # asignarse $aria)les. =i se declarara una 9uncin< causar+ un error. =i un 0rograma solo di)u8ar+ un cuadro< este 0uede declararse en el setup(). ;a 3nica di9erencia entre setup() # draN() es Aue el setup() se e8ecuta solo una ve7.,oid setup() R si(e(6//, 6//); smooth(); !ill(/); ellipse(3/, 3/, ::, ::); S

Ftilizando la 9uncin no@oop()< 0odemos :acer Aue el draN() de8e de re0etir # sim0lemente di)u8e un cuadro. El siguiente e8em0lo es similar al anterior< con la di9erencia Aue la eli0se es di)u8ada en el draN():,oid setup() R si(e(6//, 6//); smooth(); !ill(/); no@oop(); S ,oid draN() R ellipse(3/, 3/, ::, ::); S


82

-E&tensin de la :aria/le uando tra)a8amos con los )loAues setup() # draN() es necesario tomar consciencia de donde declaramos # asignamos cada $aria)le. ;a localizacin de la $aria)le determina su e(tensi*n. ;a regla 0ara conocer la e6tensin Aue 0osee una $aria)le es mu# sim0le: su la $aria)le est+ dentro de una estructura< esa $aria)le es local # 0uede usarse solamente dentro de esa estructuraR si la $aria)le est+ en el 0rograma< 9uera de cualAuier estructura< esa $aria)le es glo)al # 0uede usarse en cualAuier estructura. ;as $aria)les declaradas en el setup() 0ueden usarse solo en el setup(). ;as $aria)les declaradas en el draN() 0ueden usarse solo en el draN().int d < 36; ,oid setup() R si(e(6//, 6//); int ,al < d * 2; !ill(,al); S ,oid draN() R int ; < :/; line(/, ;, d, ;); ; 5< 23; line(/, ;, d, ;); S //@a ,ariable d es 'lobal, puede ser usada donde sea //@a ,ariable local ,al, puede ser usada solo en el //setup() //@a ,ariable local ;, puede ser usada solo en el draN()

uando una $aria)le es creada dentro de un )loAue< al salir del )loAue< esa $aria)le es destruida. Esto signi9ica Aue no 0uede utilizarse 9uera de ese )loAue.,oid draN() R int d < D/; //-sta ,ariable puede usarse donde sea en el draN() i! (d 8 3/) R int x < 6/; //-sta ,ariable puede usarse solo en este bloGue BH line(x, ./, x4d, ./); S line(/, 3/, d, 3/); line(x, :/, x4d, :/); //->>?>Q No se puede leer esta ,ariable !uera del S //bloGue ,oid draN() R !or (int ; < 2/; ; 9 D/; ; 4< :) R //@a ,ariable puede usarse line(2/, ;, 3/, ;); //solo en el bloGue H?> S line(;, /, ;, 6//); //->>?>Q No se puede acceder a ; !uera del H?> S

;a im0lementacin de $aria)les locales # glo)ales 0ermite Aue se 0ueda tener dos o m+s $aria)les con el mismo nom)re. ,3n as< no se recomienda el tra)a8o con $aria)les del mismo nom)re #a Aue 0uede 0roducir con9usin en Auien 0rograma.int d < .3; ,oid setup() R si(e(6//, 6//); int d < 7/; rect(/, /, 00, d); S ,oid draN() R rect(00, /, 00, d); S //1si'na .3 a la ,ariable d //1si'na 7/ a la ,ariable local d //&sa la ,ariable local d con //,alor 7/ //&sa d con ,alor de .3


83

Fna $aria)le dentro de un )loAue con el mismo nom)re Aue una $aria)le 9uera del )loAue es< com3nmente< un error mu# di9cil de encontrar.


84

(nidad 18

Estructuras) .uncionesElementos que se introducen en esta Unidad:,oid, return

Fna 9uncin contiene en s misma un modulo de modi9icacin de 0rograma. =e :an utilizado :asta a:ora 9unciones Aue $ienen incluidas en Processing< tales como si(e()< line()< stro)e()< # translate()< 0ara escri)ir los 0rogramas. =in em)argo< es 0osi)le escri)ir nuestras 0ro0ias 9unciones. ;as 9unciones :acen Aue el cdigo redundante sea mas conciso al mostrarlo en 9orma de )loAue< 0or e6

Date post:	19-Jul-2015
Category:	Documents
Upload:	ignacio-buioli
View:	5,884 times
Download:	11 times

Processing Un Lenguaje Al Alcance de Todos

Documents