Total que como en mis ratos libres (Si, me sorprende que tenga ) me gusta programar al Procesing, me interesó y me lancé a ver de que iba la cosa el mes pasado. Como me gusto la cosa y ahora que por fin me gradué y tengo tiempo libre (si, ajá) me decidí a participar en el evento de este mes aquí la crónica de mi 9 minutos de fama como artista.

El mes pasado solo me lance a ver y me entere de que iba la cosa: la idea es escribir programas en vivo desde cero y contra reloj. Bueno, cual es el chiste. Para empezar lo llaman concierto . Pues en la modalidad en la que lo hacen en el Cenart, es que pasan por parejas, una persona escribe un programa para hacer audio y otra uno para hacer video. Tienen 9 minutos para escribir desde cero el código y mostrarlo. No se vale traer nada escrito ni copiar ni pegar de otro código existente, además como proyectan todo lo que haces en tu compu, el chiste es que los asistentes vean como lo escribes. Así que si haces trampa quedas en evidencia. En general, en su pagina se explican mejor.

Pues en la primera sesión me llevé varias impresiones:

• Eso de la formalidad a los artistas, no se les da. (Esto es un cumplido)
• Son endiabladamente rápidos y buenos para codificar, la neta me sorprendí bastante.
• ¿Como es posible que Scheme sirva para algo practico?
• Yo no puedo hacer eso, así de rápido.

Al terminar en evento hable con Tito y me dijo que no es tan live, como me pareció en un principio. Vamos la codificación es en live, pero no están improvisando (bueno no tanto) es decir ensayan el programa que van a escribir. Fijense que esto tiene todo el sentido del mundo, despues de todo antes de dar un concierto… ensayas, ¿no? . Luego, usan frameworks muy amigables, para hacerlo rápido. Por ejemplo el mismo Procesing, Fluxus y SuperColider. Por lo que sus primitivas son muy evolucionadas (chiste local).

Total que después de ver la sesión y como la verdad son un batos muy agradables (y en el Cenart hay chicas muy guapas) me decidí a participar. Bueno esto no fue tan inmediato, en realidad me tomo casi tres semanas decidirme a hacerlo, Eleutheria fue vital en convencerme y con la bendición de la bandita me apunte (mande correo confirmando mi participación).

Como algunos de ustedes ya saben, he estado un poco ocupado (malditos escuincles del demonio, que no quieren aprender Teoría de Grafos ). Por lo que fiel a mi costumbre un día antes en la mañana empecé a pensar que iba a hacer (e invité a la bandita a que me fuera a ver , total ya si voy a hacer el ridículo, si quiera que quede entre cuates (nótese la correcta anidación de los paréntesis)). Me tomo media hora programar por primera vez la idea (ya no me acordaba ni que era el Procesing, ni que era java, ni que era la POO, ni que era programar ).

Ok, ahí me empecé a asustar. Una vez que tenia la idea, borre mi código (no se imaginan lo difícil y antinatural que fué para mi hacerlo ) y lo codifique de nuevo desde ceros. Resultado esta vez tomo 10 minuto. Deje que pasaron unas horas y repetí proceso. Además investigue que partes de mi código eran prescindible (no se imaginan la cantidad de lineas que uno gasta haciendo safefall en los estados de default). Por ultimo el miércoles antes de dormir, lo volví a hacer una vez mas 6 minutos 35 seg (OK, now we are talking ).

Total que el jueves, me pasó todo. Fui a Acatlan, me entretuve platicando de mis aspiraciones políticas con alguien muy importante de la FESA, fui a la Universidad Anahuac del norte a pedir consejo espiritual a mi mentor y por azares del destino (y después de tomar un taxi). A las 4 y media estaba en el Cenart, con el estomago vacío y listo para la sesión.

Me fije que no había un orden estricto, tu te apuntas en el lugar que quieras, total que fiel a mi costumbre me apunte de segundo. Pero luego nadie se apunto al principio y se corrieron todos un lugar así que para aumentar mis nervios me tocó empezar. Con todo y el nervio termine mi programa como en 8min.

Fiel a la filosofía del blog y de mi persona y aprovechando que el Procesing es muy amigable para exportar cosas (es lo bueno de usar Java para programar, ¡Como las niñas! XD ) aquí esta mi código.

Source Code: LivecodingAtCenart.pde Neuron.pde

Built with Processing

Después del evento y relajarme, estas reflexiones cruzan mi mente:

• Aunque me fue bien para ser la primera vez, sin duda fui el peor participante en el rubro de video.
• Principalmente fue por que erré el paradigma, mi programa es muy estructurado y en general los demas son mucho, mucho menos convencionales y mas… artísticos. El error estuvo desde que planee que hacer.
• Esto no será la última vez que participe
• Me sorprende que haya mas participantes en el audio que en el video. El simple hecho de que haya mas gente que programa sonido, que gente que haga graficación por computadora me deja anonadado. Si en MAC y en el posgrado y en general entre toda la bandita, hay chingomil gente que quiere hacer gráficos y ninguna que conozco quisiera hacer audio. Me sorprende que en el gremio de los artistas sea justo al revés, para mi no tiene ningún sentido.
• Urge aprender Fluxus y reencontrarme con la programación funcional de graficos.
• No tengo ni la mas remota idea del sentido musical
• Eso ultimo explica también por que no puedo tocar ni el berimbau (instrumento musical con solo tres tonos)
• La aleatoriedad es lo de hoy
• Es mas fácil enseñarle a un artista a programar, que aun científico a … ¿cocinar? Este último es solo una conjetura.

Y como resultado de las conclusiones este es el trabajo futuro

• Invitar a la banda del Cenart al congreso de TI en FES Acatlan.
• Aprender Fluxus
• Como dijo MacArthur al abandonar las Filipinas. I shall return

La anécdota: Al final uno de ellos me pregunto “¿Como se te ocurrió escribir una clase en vivo?” Mi respuesta natural es: ¿Por que en la POO la base de todo desarrollo es el diseño de clases? ¿Por que la simple idea de un programa en un lenguaje de POO (como java) sin clases me es reprobable? Pero saben, ahora que lo reflexiono mas… el tenía toda la razón.

Antes que nada quiero aclarar que este truco es una mala practica, en la mayoría de los lugares donde lo he visto (mientras me documentaba para escribir este post) aconsejan no hacerlo. La razón, aunque el truco funciona (y como veremos adelante tiene un fundamento solido) es confuso. Es decir según los IS la ganancia en performance es muy poca comparada con la complicación en entender el código escrito. Además de que en computadoras modernas este truco puede ser mas lento que la solución estándar (estúpidos optimizadores de memoria).

Así que solo ocuparlo en código que quieran usar con fin de hacer faramalla, show e impresionar chicas. O en caso de que algún entrevistador para alguna chamba se pase de listo y les pregunte como hacerlo.

Entendiendo el problema

En muchos algoritmos (por ejemplo en ordenación) es necesario intercambiar los valores de dos variables. Para simplificar el resto de la explicación asumiré sin perdida de generalidad (como me gusta usar esa frase ) que se tienen valores numéricos y enteros.

Es decir al principio tenemos algo como.

A = 2
B = 4

Queremos llevar a cabo la operación de intercambio y obtener una situación como:

A = 4
B = 2

Como lo haría una persona normal

Pues como nos enseñaron en la escuela XD. En todos los lenguajes de programación al asignación es una operación destructiva. Es decir al momento de asignar un valor a una variable se pierde el contenido anterior. (¡Estúpidas limitantes físicas del computo!).

Por lo que la gente que no sabe el truco haría algo así:

TEMP = A
A = B
B = TEMP

De esta manera tenemos un espacio de memoria extra donde guardar el valor de A, por lo tanto podemos destruir el contenido de A sin tentarnos nuestro corazoncillo. Y recuperarlo después del buffer temporal.

Ahora lo interesante: ¿Cómo se hace sin usar ninguna variable TEMP?

La solución del matemático.

Ahora si ustedes son de esas personas que saben un montón de matemáticas, pero jamas han programado de a de veras (¡Como los hombres!) podrían sugerir esta solución. (No se hagan se que por ahí hay muchísimos).

A = A + B
B = A – B
A = A – B

Ahora sabemos que ésta es un caso particular de una solución mas general.

1. Combina los dos valores en la variable A por medio de una operación binaria bien portada (Es decir que sea invertible). En este momento en A están guardados de alguna manera los dos valores.
2. Usa la operación inversa de la operación binaria para extraer en la variable B el valor original de A a partir del valor actual de A. Recuerda que no hemos modificado B.
3. Usa la operación inversa para extraer ahora el viejo valor de B en A. Recordando que tenemos guardado en B el valor original de A.

El fallo de la solución anterior es que trabajamos con maquinas de memoria finita, es decir podría pasar que la operación bien portada que es la suma produzca un número tan grande que no quepa en la localidad de memoria que le guardamos. ¿No se acuerdan del molesto carry cuando nos enseñaron la suma en binario y  hacer circuitos sumadores? Pues es aquí donde nos vino a fastidiar la vida.

La solución del computólogo

Tan simple, tan elegante, tan parecida a la solución del matemático XD (Por ahí dicen que es la misma por que los computologos y los matemáticos son casi lo mismo ). Pues resulta que hay mas de una operación bien portada y una que tiene todo lo que necesitamos es el XOR.

x	y	xy
0	0	0
0	1	1
1	0	1
1	1	0

¡Muérete de envidia suma! ¡El XOR es una suma sin carry vean la tabla!. ¿Suficiente? El XOR (conocido también en los bajos mundos de la lógica como disyunción exclusiva) es una de las operaciones que pueden construir toda la lógica de primer orden, además es conmutativo, asociativo y es su propio inverso. Pueden ver aquí la lista de todo lo bello que es el XOR. Es mas: ¡XOR soy tu fan!

Es decir podemos usar el XOR que como no tiene carry y nunca se desborda para hacer

A = A B
B = B A
A = A B

¿Mencione que es conmutativo y que es su propio inverso? Además que en todo lenguaje decente como en C y C++ y en algunos no decentes (Java ) Tenemos un operador de XOR y tenemos una forma abreviada de hacer la asignación. ¿No me creen? Miren con sus propios ojos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
using namespace std;
 
int main (int argc, char* argv[]) {
 
	int a = 4, b = 2;
 
	cout << "Los valores son: a = " << a << " b = " << b << endl;
 
	swap(a, b);
 
	cout << "Después del swap:" << endl;
	cout << "Los valores son: a = " << a << " b = " << b << endl;
 
	return 0;
}
 
void swap (int &a, int &b) {
	a ^= b;
	b ^= a;
	a ^= b;
}

Y para que no digan que no pelo a la banda Javera, tomen no se vallan a enojar.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class TestSwaping {
 
	public static void main(String[] args) {
		int a = 4, b = 2;
 
		System.out.println("Los valores son: a = " + a + " b = " + b);
 
		a ^= b;
		b ^= a;
		a ^= b;
 
		System.out.println("Después del swap");
		System.out.println("Los valores son: a = " + a + " b = " + b);
	}
 
}

Mas información sobre la correctez y demás cosas de este truco esta en su pagina wikipedia.


Pasaron unos días y comente con otro amigo (Lalo Lemus) el truco de mi amigo Leo y me comento que era una forma muy primitiva de una área de las Ciencias de la computación conocida como Esteganografía (siempre me ha sorprendido la cantidad de cultura general de computólogo que posee Lalo).

La esteganografía es la rama de las ciencias de la computación que estudia la manera de transmitir mensajes ocultos embebidos en mensajes. Aquí hago un paréntesis, ya se que están pensando que eso es la criptografia, pero no, aunque son cosas muy parecidas la criptografía y la estagnografía son cosas diferentes.

Mientras que la criptografía estudia como cifrar mensajes para que cuando alguien los intercepte no sea capaz de entenderlos, la esteganografia estudia como oculta el mismo hecho de que un mensaje existe.

Vamos para la cirpto se asume que el enemigo conoce que se va a atransmitir un mensaje, y que ademas el enemigo va a interceptar el mensaje. Solo que el mensaje viene en clave y no va a poder entender su contenido (esta cifrado).

En el caso de la esteganografia, el enemigo se da cuenta que hay un intercambio de información. Pero no sabe que en la información; aparentemente inocente, hay un mensaje oculto.

Desde los tiempo de Herodoto (padre de la historia) hay indicios de esteganografía. Pues se describe una situación donde un general escribió un aviso donde prevenía de un ataque de los griegos en una tableta de madera, y después la encero y escribió otro mensaje sobre la cera (en esos tiempo era común mandar correspondencia en tabletas enceradas).

Herodoto también describe otro caso mas hardcore en donde le rapan la cabeza a un esclavo y le tatuan un mensaje, luego esperan a que el cabello del esclavo vuelva a crecer y lo mandan (sin conocimiento del mensaje) con el receptor.

En la esteganografia moderna se trata de esconder archivos dentro de otros archivos (de apariencia inocente) por ejemplo imágenes, musica o vídeos. Una de la técnicas mas comunes es la de modificar el LSB (Bit menos significativo) en los datos de algún archivo (por ejemplo los píxeles de una imagen). De esta manera la imagen no cambia mucho (no es perceptible al ojo humano y tiene un mensaje oculto entre sus píxeles.

Una buena esteganografia, debe cumplir con:

• El archivo no sea sospechoso.
• Un usuario normal no debe notar el cambio entre un archivo común y un archivo con un mensaje oculto
• El tamaño del archivo no debe variar.

Como la mayoría de las buenas técnicas de esteganografia requieren un cierto conocimiento de teoría de la información y de programación, por lo que la mayoría de los usuarios mortales no podemos usarlas tan fácil.

Aquí es donde se vuelve valioso el truco de mi amigo Leo

Esteganografía para principiantes

Este truco no es una buena esteganografia, pues no cumple con los requisitos arriba expuestos. pero digamos que tiene la enorme ventaja que no requiere nada mas que el ambiente estándar de usuario (sin conocimientos de programación) y en un sistema operativo decente sin ser nada del otro mundo (vamos con cualquier GNU/Linux – Unix basta).

El truco en cuestión es el siguiente (me dio permiso de escribirlo :p )

cat imagen.jpg mensaje.zip > imagenConMensaje.jpg
du -b imagen.jpg
tail -c +4012558 imagenConMensaje.jpg > mensajeRecuperado.zip

Expliquemos paso a paso. Se tiene una imagen: imagen.jpg y se quiere ocultar el mensaje contenido en el zip: mensaje.zip. Se le añaden a la imagen los bytes del mensaje al final. Esto forma una nueva imagen (que mide el tamaño de la imagen mas el tamaño del mensaje). Ahora si queremos recuperar el mensaje debemos de saber cual era el tamaño original del mensaje (por eso lo calculamos con du) y extraemos los ultimo bytes de la imagen y les damos forma en un nuevo archivo .zip.

En el caso de mi imagen el tamaño resulto ser 4012558, pero obviamente esa cantidad debe sustituirse con el tamaño de la imagen que ustedes usen (el resultado del comando previo).

¿Por que funciona?

Recordemos que en las imagenes .jpg hay un cabecero y luego vienen los datos y en el cabecero esta guardado el tamaño de la imagen. Al añadir el mensaje al final del archivo con el comando cat, le estamos poniendo bytes al final de los datos sin modificar el cabecero. Por esta razón la nueva imagen con los datos puede ser vista y leída en cualquier SW como si fuera una imagen normal. Aun cuando tiene los datos ocultos.

Si nosotros supiéramos el tamaño de la imagen original, podemos restarle a la imagen modificada ese tamaño (tail) y el resultado deben ser los bytes que contienen el mensaje, como ese era originalmente un zip lo direccionamos en nuevo zip y tendremos el mensaje de vuelta.

Como ejemplo aquí hay una imagen de Emma Watson.

Ahora aquí esta la misma imagen, junto con todos los libros de Narnia escondidos en un zip.

Nótese el cambio de tamaño de la imagen a mas del doble (como ya dijimos esta no es una buena técnica de esteganografía).

Nota Las miniaturas son links a las verdaderas imágenes que usé.

Prácticamente dependíamos de un programa comercial (privativo) que el Dr tenia en su laboratorio para guardar una copia de la imagen en algún formato mas universal. No contentos con llevar nuestro GB de imágenes en raw con los datos de la practica, teníamos que viajar con una copia de la imagen en jpg para poder escribir nuestro reporte.

Fue entonces cuando mi amiga Etna, me presento con ImageMagick.

Y que es ImageMagick…

Es un conjunto de programas libres que sirven para convertir, transformar, y procesar imágenes en casi cualquier formato (y lo digo en serio). Lo que lo hace tan poderoso y flexible es que su interfaz es en linea de comandos, por lo que es ideal para desarrollar programas que ocupen ImageMagick y procesen imágenes (de hecho hay bindings para varios lenguajes de programación).

Una de las chucherias de ImageMagick es convertir de formato raw a cualquier formato.

Por que lo querría usar uno normalmente.

La segunda vez que me encontré con la necesidad de procesar un montón de imágenes y que me motivo a escribir este post fue regresando de las vacaciones en Oaxaca. Yo no llevaba mi cámara, pero Erika y Mag me pasaron sus fotos.

Ya saben tenia cientos de imágenes con títulos bien descriptivos como IMG_2379.JPG que pesaban algo así como 600Kb y median como 3072×2304 píxeles. Lo cual si hubiera querido subir en mi blog, conllevan un montón de trafico de red, y además seria un desperdicio, por que quien tiene un monitor con esa resolución (Vamos los que las vieran las tendrían que rescalar antes de verlas).

La solución de nuevo es ImageMagick

Como se usa ImageMagik

Pues el comando convert (que no es el único que conforma ImageMagick), nos da toda la versatilidad que queremos.

Escalando una imagen

Al escalar una imagen debemos de tener cuidado de hacerlo de una manera de que conserve su proporción (su aspect ratio), la mayoría del SW nos deja hacerlo si le decimos que no queremos deformaciones, también se puede hacer en ImageMagick

convert -resize 50% input.jpg output.jpg

Al darle en porcentaje el tamaño, Imagemagick sabe que no debe modificar el aspect ratio.

Reduciendo la calidad de la imagen

Hay dos tipos de compresión una donde no se pierde información llamada lossless, y otra llamada lossy compresión que es cuando un imagen pierde parte de su información al comprimirse. Cuando guardamos una imagen en formato jpg se esta haciendo una compresión con pérdida (lossy). El algoritmo del jpg es lo suficientemente flexible para dejarnos controlar la perdida con un parámetro de calidad. Mientras menos sea la calidad menor sera la perdida y mayor el tamaño de la imagen.

Sin embargo el algoritmo es tan bueno que bajar un poco la calidad de la imagen, suele bajar en mucho el tamaño (en bytes) de la misma, aproximadamente una imagen al 90% de calidad mide una cuarta parte que la imagen original. El estándar para publicar en una web es del 85%.

Para hacerlo en ImageMagick se ocupa el siguiente comando

convert -quality 85% input.jpg output.jpg

Corrigiendo la orientación

Otra cosa interesante es que ImageMagick puede corregir la orientación de una imagen de una cámara si los metadatos de la foto tienen esa orientación con el comando

convert -auto-orient input.jpg output.jpg

Ojo esto no siempre funciona (a veces los metadatos de la cámara no están bien), por lo que siempre es bueno darle una checada a la imagen de salida. También recuerda que en muchos navegadores de archivos se aplica esta corrección, pero eso no quiere decir que la imagen este volteada, si no que el visor de imágenes la esta transformando para que la veas.

Eso puede provocar que en tu máquina tu veas la imagen al derecho y cuando la subas a un sitio web, la veas al revés. La única forma de saberlo es viendo el tamaño de la imagen y ver si es mas alta que ancha o viceversa.

Y desde luego todos estos pasos se pueden llevar a cabo al mismo tiempo. Por ejemplo:

convert -auto-orient -quality 85% -resize 50% input.jpg output.jpg

Y poniendo todo en un script

Aprovechando que tuve que aprender un poco de bash, para un programa de la tesis, escribí el siguiente scrip en bash, para hacer las operaciones antes descritas sobre una carpeta con muchas imágenes.

El script tiene las siguientes características:

• Siempre trata de hacer la corrección de orientación
• Acepta opcionalmente los siguientes parámetros
• -q quality Para reducir de calidad las imágenes, el parámetro debe ser entero y estar en el intervalo (0, 100)
• -s size Para reducir el tamaño en un porcentaje, (en ImageMagick esto no necesariamente tiene que especificarse así, pero en el scrip valido que solo se pueda cambiar el tamaño en un porcentaje) que acepta enteros en el intervalo (0, 100)
• -n name Para especificar un patrón de nombre de la imagen de salida, en caso de que este parámetro no se le proporcione, las imágenes de salida tendrán el mismo nombre que las de salida (puede que las sobrescriban), con la única excepción que valido que en la imagen de salida la extensión siempre sea en minúsculas (odio que en la mayoría de las cámaras, las extensiones de las imágenes estén en mayúsculas DSC_001.JPG)

En resumen el scrip corrido en su forma completa por ejemplo:

photo2wp.sh -q 85 -s 50  –name Vacaciones

Tomara todas las imágenes con extensión jpg ó JPG que haya en el directorio actual. A cada una de ellas las escalará al 50% respetando su aspect ratio, las comprimirá en jpg, con el 85% de calidad y las imágenes de salida tendrán el nombre VacacionesXXX.jpg. Donde XXX es un numero progresivo que depende de la cantidad de imágenes que haya en la carpeta.

Es posible pasar mas de una palabra en el nombre pero entonces hay que encerrarlo en comillas:

photo2wp.sh -q 85 -s 50  –name “Mis Vacaciones”

Todos los argumentos son opcionales:

photo2wp.sh -q 85  –name Vacaciones

Por ejemplo comprime todas las imágenes al 85% y las renombra como VacacionesXXX.jpg, sin escalar su tamaño.

En un abuso de las opciones, puede usarse sin argumentos

photo2wp.sh

Que toma todas las imágenes, trata de corregir su orientación, y las guarda con el mismo nombre pero asegurándose que la extensión sea en minúsculas (si las imágenes originales tienen su extensión en minúsculas, las va a sobrescribir)

Por ultimo algunas recomendaciones:

• No he testeado el script al 100%, así que siempre ten una copia de tus imágenes originales. (Aún cuando no uses mi script esto es buena practica)
• Recuerda que el script solo funciona cuando ya tienes instalado el ImageMagick en tu maquina.
• Si quieres usar el script, recuerda que antes que nada debes darle permisos de ejecución.
• Recuerda que el script solo actúa sobre el directorio en el que esta siendo ejecutado. No se mete recursivamente en carpetas.

Finalmente el script esta aqui (copia y pega en un archivo de texto yo lo llame photo2wp.sh, pero pon el nombre que quieras):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

#!/bin/bash
 
#Este scrip toma todas las fotos de la carpeta donde se ejecute y las
#procesa. Primero la pone al derecho dependiendo de los metadatos, 
#les cambia de nombre y las guarda con un tamaño y una calidad 
#determinadas por las opciones
 
 
function dameNumero {
 
	if [ $total -lt 100 ]; then
 
		if [ $cont -lt 10 ]; then
			number="0$cont"
		else
			number="$cont"
		fi
 
	elif [ $total -lt 1000 ]; then
 
		if [ $cont -lt 10 ]; then
			number="00$cont"
		elif [ $cont -lt 100 ]; then
			number="0$cont"
		else
			number="$cont"
		fi
 
	else
 
		if [ $cont -lt 10 ]; then
			number="000$cont"
		elif [ $cont -lt 100 ]; then
			number="00$cont"
		elif [ $cont -lt 1000 ]; then
			number="0$cont"
		else
			number="$cont"
		fi
 
	fi 
 
}
 
#Aqui parseamos las opciones
qflag=0
sflag=0
nflag=0
 
while getopts 'q:s:n:' OPTION
do
  case $OPTION in
  q)	qflag=1
		quality="$OPTARG"
		;;
  s)	sflag=1
		size="$OPTARG"
		;;
  n)	nflag=1
		nameBase="$OPTARG"
		;;
  *)	printf "Usage: photo2wp.sh [-q <quality>] [-s <size>] [-n <name>]" >&2
		exit 2
		;;
  esac
done
 
#Si no nos dieron quality asume el 100
if [ $qflag -ne 1 ]; then
	quality=100
fi
 
#Si no nos dieron size asume el 100
if [ $sflag -ne 1 ]; then
	size=100
fi
 
 
#Checamos que quality sea valido
if [[ $quality =~ ^[0-9]+$ ]]; then
    if [ $quality -gt 100 -o $quality -lt 0 ]
    then
		echo "El parámetro quality debe se un número entero en el intervalo [0, 100]" >&2
		exit 3
    fi
else 
	echo "El parámetro quality debe se numérico y entero" >&2
    exit 3
fi
 
#Ahora validamos el valor de size
if [[ $size =~ ^[0-9]+$ ]]; then
    if [ $size -gt 100 -o $size -lt 0 ]
    then
		echo "El parámetro size debe se un número entero en el intervalo [0, 100]" >&2
		exit 3
    fi
else 
	echo "El parámetro size debe se numérico y entero" >&2
    exit 3
fi
 
#Contamos cuantas imagenes hay
total=`ls *.[jJ][pP][gG] 2>/dev/null | wc -l`
 
if [ $total -eq 0 ]; then
	echo "No hay imagenes que procesar en esta carpeta"
	exit 1
fi
 
#Calculemos las opciones y avisemos al usuario que vamos a hacer
opciones="-auto-orient"
 
echo "Hay $total fotos"
 
if [ $sflag -eq 1 ]; then
	echo "Se van a escalar a un tamaño de: $size%"
	opciones="$opciones -resize $size%"
fi
 
if [ $qflag -eq 1 ]; then
	echo "Se van a comprimir con una calidad de: $quality%"
	opciones="$opciones -quality $quality%"
fi
 
if [ $nflag -eq 1 ]; then
	echo "Se guardaran con el nombre: $nameBase[XXX].jpg"
fi
 
#Todo correcto empezamos a procesar
cont=0
number=""
output_file=""
images=*.[jJ][pP][gG]
 
#Ciclo principal sobre todas las imagenes de entrada
for input_file in $images
do
	#Calculamos el nombre de la imagen de salida
	cont=`expr $cont + 1`
	dameNumero
	if [ $nflag -eq 1 ]; then
		output_file="$nameBase$number"
	else
		output_file=${input_file%%.*}
	fi
 
	#Realizamos la conversion
	if convert $opciones "$input_file" "$output_file.jpg" 2>/dev/null ; then
		echo "Imagen $cont de $total"
	else
		echo "$input_file no pudo ser procesada..." >&2
	fi
 
done
 
exit 0

Eso no fue todo, Fatima me hizo la corrección y me sorprende tanto, es un código que a todas luces es equivalente al mio (o debería de ser para cualquier programador) y pues resulta que lo es en una maquina que no tenga procesador intel (o bueno al menos es mi conjetura).

El caso es que Pixie, solo lo acepta de una forma y que en Ometochtli (la maquina servidor en la que trabajamos), con un procesador AMD chorrocientas veces mas poderoso funciona a la perfección de ambas maneras).

Para no enojarme mas reduzco mi programa mas grande a un caso de prueba, para que vean de lo que hablo:

int factor = 1000;
 
cout << "factor * 1.345 = " << (int)(factor * 1.345) << endl;
cout << "factor * 2.344 = " << (int)(factor * 2.344) << endl;
 
cout << "1000 * 1.345 = " << (int)(1000 * 1.345) << endl;
cout << "1000 * 2.344 = " << (int)(1000 * 2.344) << endl;

La cosa es que las primeras lineas escriben:

factor * 1.345 = 1344
factor * 2.344 = 2343

Mientras que las segundas escriben:

1000 * 1.345 = 1345
1000 * 2.344 = 2344

Este error parece que solo esta presenta cuando los números en cuestión tienen en su parte decimal y 3 seguido de un cuatro. Es increíble pero si cambian el numero por 1.253, todo funciona perfectamente. Desde luego con cualquier caso en un procesador AMD parece que funciona bien.

!!!Es cierto!!! se que no me lo van a creer así que pongo el pantallazo, se que con todo y eso algunos no me van a creer. Pero ya no hay mas que pueda hacer.

Y eso no es lo mas triste del asunto, lo mas triste es la manera como lo corrigió Fatima:

double aux;
aux = (double)(factor * 1.345);
cout << "factor * 1.345 = " << (int)(aux) << endl;

¡¡¡Y así si funciona!!!, Aun cuando el código es equivalente al mio. Desde luego el programa que queremos hacer es mucho mas extenso que esto, pero no me deja de molestar, que cosas así pasen, me pone muy nervioso.

Ya para seguir en el tono pongo un poema que vi en mi clase de ingles, que escribió Lord Cromer, que seguro en su momento se sintió como yo ahora.

Our Queer Language

When the English tongue we speak,
Why is “break” not rhymed with “freak”?
Will you tell me why it’s true
We say “sew” but likewise “few”;

And the maker of a verse
Cannot cap his “horse” with “worse”?
“Beard” sounds not the same as “heard”;
“Cord” is different from “word”;
Cow is “cow,” but low is “low”;
“Shoe” is never rhymed with “foe.”

Think of “hose” and “dose” and “lose”;
“Doll” and “roll” and “home” and “some.”
And since “pay” is rhymed with “say,”
Why not “paid” with “said,” I pray?

We have “blood” and “food” and “goo d”;
“Mould” is not pronounced as “could.”
Wherefore “done” but “gone” and “lone”?
Is there any reason known?
And, in short, it seems to me,
Sounds and letters disagree.

Al principio me gustó la idea, después de todo, traía fresco lo de la graficada y el programa parecía ser muy sencillo, le dije que solo preparara la recurrencia matemática y que después pasaría a ayudarle, después de una semana pase a verlo y como suele suceder no había hecho nada ni yo ni el, sin embargo el programa resulto ser lo bastante simple para que solo me llevara un par de horas terminarlo.

Pueden descargar el código aquí. Y para probar mis últimos dos plugines agregados al blog me decidí a escribir este post. los dos plugines de los que hablo son el WP-sintax que permite poner código de algún lenguaje de programación en tus post y el WP-LaTeX que agregar una fórmula escrita en LaTeX, (en forma de imagen) a tus post.

Copo de Koch

La primeras lineas solo incluyen las dos bibliotecas que vamos a usar, la primera es la glut estandar para levantar OpenGL y la otra es math.h, para hacer cálculos.

Veamos después de eso que hay:

6
7
8

typedef struct {
	float x, y, z;
}Punto;

Con estas lineas definimos un nuevo tipo de dato, lo bautizamos como Punto y tiene adentro tres flotantes, para representar coordenadas, aunque el programa es en esencia bidimensional, como el OpenGL trabaja en 3D, me gusta declarar todo como si estuviera dibujando en 3D.

Después se declaran algunas variables globales, y el prototipo de las funciones, las variables globales son:

• xMax, yMax: Guardan el tope de las coordenadas del mundo, es decir de donde a donde corre la parte visible de la ventana en X y en Y, con respecto al origen (situada al centro de la ventana)
• vertices: Es un arreglo de tres puntos, que guardara la única información que necesitamos para empezar a generar el copo de nieve, la posición de tres vértices.
• numPtos: Este guarda el número de vértices proporcionados por el usuario, es un contador para poner la siguiente lógica: “Si ya tienes tres puntos, empieza a hacer el fractal, si tienes menos de tres puntos, continua esperando…”
• fondo: Otro entero que guardará la profundidad máxima para hacer el fractal, donde un cero, pinta un triangulo, un uno la estrella de David y así en adelante. Es si lo quieren ver así el numero de veces que se manda a llamar recursivamente el fractal.

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

int main(int argc, char** argv) {
 
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGBA);
   glutInitWindowSize (640, 480);
   glutInitWindowPosition (100, 105);
   glutCreateWindow (argv[0]);
   inicializar();
 
   glutDisplayFunc(dibuja);
   glutReshapeFunc(redimensiona);
   glutKeyboardFunc(teclado);
   glutSpecialFunc(tecladoEspecial);
   glutMouseFunc(raton);
 
   glutMainLoop();
 
   return 0;
}

La función main, no mucho que decir, es muy estándar en el estilo glut, pone la maquina de estados en el estado adecuado, manda llamar a inicializar, registra cinco funciones de callback y por ultimo manda al loop principal de glut. Utilizo un solo buffer por que no voy a hacer animación, y ocupo el nombre del programa para el titulo de la ventana.

47
48
49
50
51
52

void inicializar () {
   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
   glPointSize(5.0);
   numPtos = 0;
   fondo = 1;
}

La primer función en ser ejecutada, pone el color del fondo en negro, a los puntos les da tamaño 5, inicializa el contador de puntos y a profundidad.

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

void redimensiona (int ancho, int alto) {
   float aspect;
 
   glViewport (0, 0, ancho, alto);
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
 
   if (alto == 0){
   	  alto = 1;
   }
 
   aspect = (float) ancho / (float) alto;
 
   if (ancho <= alto) {
   	  glOrtho(-MUNDO, MUNDO, -MUNDO/aspect, MUNDO/aspect, -MUNDO, MUNDO);
   	  xMax = MUNDO;
   	  yMax = MUNDO / aspect;
 
   } else {
   	  glOrtho(-MUNDO * aspect, MUNDO * aspect, -MUNDO, MUNDO, -MUNDO, MUNDO);
   	  xMax = MUNDO * aspect;
   	  yMax = MUNDO;
   }
 
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
}

La función redimensiona, es llamada al inicio del programa, (el estándar de glut así lo indica) y cada vez que hay un evento de resize a la ventana. es una función muy común en estilo glut, lo único raro, quizás es que guarda en variables globales el valor de la máxima coordenada Y y la máxima coordenada X. Por lo demás es muy normal, da una proyección ortogonal, i.e: pone el sistema de referencia.

82
83
84
85
86
87
88
89
90
91
92
93

void teclado (unsigned char key, int cx, int cy) {
 
	switch (key) {
		case 27:
		   exit(0);
		break;
 
		default: break;
	}
 
	glutPostRedisplay();
}

La función teclado es muy simple, si detecta un evento de la tecla “Esc”, termina el programa con codigo 0.

95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

void tecladoEspecial (int key, int cy, int cx) {
 
	switch (key) {
		case GLUT_KEY_PAGE_UP:
		   fondo++;
		break;
 
		case GLUT_KEY_PAGE_DOWN:
		   if (fondo > 1) fondo--;
		break;
 
		default: break;
	}
 
	glutPostRedisplay();
}

Está función sirve para cachar eventos de las teclas PgUp y PgDn, y en respuesta aumenta el valor de la variable global fondo, es decir hace que el fractal itere mas o menos veces, después de poner el nuevo valor en fondo, avisa a la ventana que necesita volver a dibujarse.

112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

void raton (int boton, int estado, int cx, int cy) {
	float x, y;
 
	/* Calculamos las coordenadas de mundo (relativas) apartir de 
	 * las de ventana (absolutas) */
 
	x = ((GLfloat)cx * 2.0 * xMax) / glutGet(GLUT_WINDOW_WIDTH) - xMax;
	y = yMax - ((GLfloat)cy * 2.0 * yMax) / glutGet(GLUT_WINDOW_HEIGHT);
 
	if (boton == GLUT_LEFT_BUTTON && estado == GLUT_DOWN) {
 
		if (numPtos < 3) {
		   vertices[numPtos].x = x;
		   vertices[numPtos].y = y;
		   vertices[numPtos].z = 0.0;
		   ++numPtos;
	    }
	    else {
	       numPtos = 0;
	       vertices[numPtos].x = x;
		   vertices[numPtos].y = y;
		   vertices[numPtos].z = 0.0;
		   numPtos++;
	    }
	}
 
	glutPostRedisplay();
}

Este código cacha las acciones del ratón, las lineas 118 y 119, calculan la posicion en x y en y en donde el usuario realizo el click, recordemos que el glut, nos pasa como parámetros dos enteros que representan el pixel en el que se hizo el click, pero para la lógica de nuestro programa lo queremos en coordenadas de mundo.

En las lineas siguientes, se pregunta si el mouse dio click izquierdo de ser así, preguntamos cuantos puntos llevamos, si son menos de tres, seguimos esperando si no que este sea el primero, de esta manera cada cuarto punto se resetea, el estado del programa, así que si después de pintar un fractal queremos pintar otro simplemente damos un nuevo click y ese es el primer punto de un nuevo fractal.

142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

void dibuja (void) {
	int i;
 
	glClear(GL_COLOR_BUFFER_BIT);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
 
 
	if (numPtos != 3) {
	   glColor3f(1.0, 1.0, 1.0);
	   glBegin(GL_POINTS);
	      for (i = 0; i <numPtos; i++) {
	   	     glVertex3f(vertices[i].x, vertices[i].y, vertices[i].z);
	      }
	   glEnd();
	}
 
	if (numPtos == 3) {
	   glColor3f(1.0, 1.0, 0.0);
	   glBegin(GL_LINE_STRIP);
	      koch(vertices[0], vertices[1], 0);
	      koch(vertices[1], vertices[2], 0);
	      koch(vertices[2], vertices[0], 0);
	   glEnd();
	}	
 
	glFlush();
}

Esta función se encarga de dibujar el fractal, primero limpia la pantalla, luego pone el estado de dibujar y pregunta si tenemos algún numero de puntos que no sea tres (por la lógica de la función anterior esto solo puede pasar cuando son menos que tres) de ser así solo pone los puntos que llevamos. En caso contrario se prepara a dibujar el fractal, para esto hace uso de la función auxiliar koch, que da los vértices de una curva de koch, así que para hacer el copo de koch, pinta tres curvas de koch: Una del vértice 0, al vértice 1, otra del vértice 1 al vértice 2 y por ultimo una que cierra el copo del vértice 2 al vértice 0.

Dibujando la curva de Koch

Ahora viene la parte mas interesante: ¿Como se dibuja la curva de Koch?
La función encargada de hacerlo es la función koch, pide como argumento dos puntos y un entero, que es el nivel de profundidad en la recursividad del algoritmo, es decir: la primera vez que se llame tendrá valor 0, la segunda vez que se llame tendrá valor 1 y así sucesivamente. Aquí esta el código de la función:

173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202

void koch (Punto p0, Punto p1, int profundidad) {
	Punto a, b, p2;
 
	if (profundidad < fondo) {
		a.x = 2.0 / 3.0 * p0.x + 1.0 / 3.0 * p1.x;
		a.y = 2.0 / 3.0 * p0.y + 1.0 / 3.0 * p1.y;
		a.z = 0.0;
 
		b.x = 1.0 / 3.0 * p0.x + 2.0 / 3.0 * p1.x;
		b.y = 1.0 / 3.0 * p0.y + 2.0 / 3.0 * p1.y;
		b.z = 0.0;
 
		p2.x = 0.5 * p0.x + 0.5 * p1.x + a.y - b.y;
		p2.y = 0.5 * p0.y + 0.5 * p1.y + b.x - a.x;
		p2.z = 0.0;
 
		glVertex3f(p0.x, p0.y, p0.z);
		koch(p0, a, profundidad + 1);
		glVertex3f(a.x, a.y, a.z);
		koch(a, p2, profundidad + 1);
		glVertex3f(p2.x, p2.y, p2.z);
		koch(p2, b, profundidad + 1);
		glVertex3f(b.x, b.y, b.z);
		koch(b, p1, profundidad + 1);
		glVertex3f(p1.x, p1.y, p1.z);
 
	} 
 
	return;
}

En la linea 176, se pregunta cuantas veces se ha ejecutado esta función en la recursión, si es mas que lo que vale la variable fondo, regresa sin hacer ninguna operación, poniendo fin a la recursión. Sin embargo si aun es menor, se ejecutan los cálculos necesarios (se hace otra iteración) y dentro del procedimiento se llama recursivamente la función koch aumentando el nivel de profundidad.

La lógica de la función koch se explica a continuación:

La idea principal es que como entrada tenemos dos puntos (p0 y p1), los cuales representan un segmento y queremos a partir de ellos calcular tres puntos mas (a, b y p2). Como se ve en la figura:

Segmento de recta

Para calcular cada uno de estos puntos, se hace uso de la ecuación paramétrica de un segmento de recta. Si tenemos dos puntos p y q entonces la ecuación paramétrica en t, del semento de recta entre p y q es: con con esta ecuación podemos calcular fácilmente tanto a, como b. Sin embargo para calcular p2 tendremos que hacer algunas cosas mas.

Puntos a calcular en el nuevo segmento de koch

Primero calculamos el punto medio del segmento, a ese vector hay que sumarle la elevación del nuevo punto, para calcularla necesitamos sumarle un nuevo vector que sea perpendicular al segmento, para esto utilizamos el hecho de que el producto punto de dos vectores perpendiculares entre si, siempre es cero. Así que construimos el vector que va de a a b y de ahí lo volteamos es decir:

Dado un vector:

Es perpendicular a el vector v dado por:

Por lo que podemos encontrar el punto p2 de la siguiente manera:

Recordemos que el vector que va de a a b se puede ver como b-a.

Descargas

• Código fuente el programa
• Ejecutable de win32

¿Por que solo pongo el ejecutable para Windows, si yo siempre uso GNU/Linux?, por que los usuarios del lado luminoso de la fuerza les conviene mas compilar el fuente, que al cabo es solo uno, recuerden que deberán tener instalado OpenGL y glut.

Pantallazos

[Show as slideshow]

Otra prueba:

Una prueba mas:

Puta Madre estoy que no me la acabo, es cierto hay un plugin que no requiere de todos los hacks del anterior plugin, me funciono de inmediato, esto es la wea!!!!

Se puede escribir en wordpress con LaTeX

Me cacho que no me la acabo, es la neta del planeta

Aqui el enlace que me funciono, ahhhh sigo en shock.

Estoy usando WP 2.6, en un servidor estandar.

Aunque la clase pinta ser bastante interesante, por que ha tomado un poco el tinte de cátedra, no pude evitar mi decepción cuando nos dijeron que el curso giraría en torno al desarrollo en Java.

El primer profesor es la Dra. Amparo Lopez, su clase ha sido un poco aburrida para mi, por que ella misma admitió que seria un curso introductorio y que los que ya supiéramos programar en Java podríamos saltarnos su parte de la cátedra, (vía un proyecto en Java).

Como he decidido quedarme, y se que para las demás partes de la cátedra sera importante tener un entorno de desarrollo completo en Java he decidido escribir este post.

Este post debería de servirle a cualquier estudiante que quiera (o tenga) que aprender java

¿Que es lo que entiendo por entorno de desarrollo Java?

Queremos tener un compilado Java, para esto usar el JDK de sun, es decir no queremos la alternativa libre.

Queremos tener un IDE muy eficiente. Para esto usaremos eclipse, por ser software libre y por ser a mi juicio y el de muchas personas que conozco, el mejor IDE para desarrollar en Java (propietarios incluidos).

Queremos un servidor/contenedor de servlets y JSP’s, para esto utilizaremos uno de los mejores: apache tomcat por aquello de que también es software libre.

En resumen:

• JDK de sun (vía repositorios).
• Eclipse EE para desarrollo en Java (descargado del web).
• Servidor Web Tomcat (descargado del web).

De donde partimos

Hago las siguientes suposiciones:

Que tienes ya instalado Ubuntu (Yo estoy probando en 8.04, pero pienso que puedes adaptar estos pasos a tus necesidades fácilmente).

Que vamos a levantar Tomcat no como servicio, si no dentro de Eclipse, y por el puerto 8080, esto con el fin de que si ya tenemos otro servidor web (por ejemplo un LAMP) no tengan conflictos. Y además si es un entorno de desarrollo, probablemente tengas un servidor dedicado en algún otro lado.

Asumimos que no tenemos instalado el Eclipse de los repositorios. Por que al instalarlo también instala el java libre y lo usara en vez de usar el de sun.

Advertencia: Considero que eclipse es el mejor IDE de Java, pero eso no quiere decir que sea ligero, no recomiendo instalarlo en maquinas de menos de 512MB de RAM y al menos otro tanto de swap

Instalando Java JDK de Sun

Este es el único paquete que nos traeremos de los repositorios, por su sencillez y que no esta tan atrasado respecto a las versiones disponibles del web. Además así nos evitamos setear un montón de variables de entorno manualmente. Así que instalamos ya sea vía apt o synaptic los siguientes paquetes:

• sun-java6-bin
• sun-java6-demo
• sun-java6-jdk
• sun-java6-jre
• sun-java6-doc

El paquete sun-java6-doc es opcional si queremos tener la documentación. Desgraciadamente este es un metapaquete que no contiene la documentación. Así que si deseamos instalarlo, tendremos que ir a la pagina de sun, descargar la documentación de java, una archivo llamado jdk-6-doc.zip, luego cambiarle de dueño a root, y moverlo a /tmp. Después decirle a synaptic o apt que instalen el paquete.

Asumiendo que estamos parados en donde esta el archivo descargado:

sudo chown root:root jdk-6-doc.zip
mv jdk-6-doc.zip /tmp
sudo apt-get install sun-java6-doc

Instalamos Eclipse

Lo descargamos del sitio oficial, queremos la versión que dice: Eclipse IDE for Java EE Developers por que es el mas completo para nuestros propósitos.

Podríamos usar cualquier otro y después instalarle los paquetes adicionales que nos hagan falta, pero ¿Para que molestarnos? Si podemos descargar uno que ya viene listo para usarse con Java.

Una vez que lo descarguemos, solo hace falta descomprimirlo en algún lado, lo mas recomendable es ponerlo en alguna carpeta usada comúnmente para guardar programas, yo ocupe /opt pero también podría funcionar /usr/local por aquello de la buena educación.

Supongamos que estamos parados donde se hizo la descarga:

tar -xzvf eclipse-jee-ganymede-linux-gtk.tar.gz
sudo mv eclipse/ /opt

Ahora sólo nos hace falta crear un lanzador para usar Eclipse, asumiedo que usamos Gnome, vamos a Sistema -> Preferencias -> Menú Principal. Se abrira alacarte seleccionamos un el menú donde queremos crear el lanzador, un buen lugar es Programación, y de ahi le damos Elemento nuevo.

Llenamos los datos que nos piden: el tipo es Aplicación, el nombre Eclipse, en comando le damos examinar y buscamos el ejecutable se llama eclipse, y esta dentro de la carpeta eclipse.. El eclipse EE para java al parecer viene sin icono, puedes buscar alguno en la web, aqui pongo uno por si te sirve.

Un pantallazo de la de como le hize yo:

Instalando Apache Tomcat

Primero vamos al sitio de Apache tomcat, y de ahí descargamos la ultima versión, cuando escribí esto era la rama 6.x la versión 6.0.18 y de ahí descargamos la distribución .tar.gz. (en realidad cualquiera hubiera servido, pues son multiplataforma, pero por costumbre en Linux el usamos la que viene compresa .gz).

Ahora descomprimimos tomcat y lo movemos a algún directorio apropiado, de nuevo yo uso /opt.

tar -xzvf apache-tomcat-6.0.18.tar.gz
sudo mv apache-tomcat-6.0.18 /opt/apache-tomcat

Liiisto esa es la instalación de tomcat, si queremos probarlo, podemos ejecutar el archivo start.sh para arrancar Tomcat y shutdown.sh para detenerlo. Ambos viven en el directorio bin, dentro del directorio de Tomcat.

/opt/apache-tomcat/bin/startup.sh
/opt/apache-tomcat/bin/shutdown.sh

Para probar podemos arrancar Tomcat y abrir nuestro navegador en el sitio http://localhost:8080, donde nos debe contestar Tomcat dándonos la bienvenida. Si quieres ver que hace, puedes navegar a Miscellaneous y de ahí ejecutar alguno de los JSP o de los Servlets que trae de ejemplo. También recomendaría editar el archivo $CATALINA_HOME/conf/tomcat-users.xml y añadir a un usuario con privilegios de administración para usar el manager.

Aquí hay un ejemplo de como hacer una edición básica del archivo: tomcat-users.xml

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
  <role rolename="manager"/>
  <role rolename="admin"/>
  <user username="jorge" password="secreto" roles="admin,manager"/>
</tomcat-users>

Poniendo todo junto

Ahora viene lo divertido, hay que decirle a Eclipse, donde esta Tomcat, esto tiene la enorme ventaja que así él podrá arrancarlo cuando lo use y pararlo cuando no. Es decir prácticamente administra él.

Primero ejecutamos eclipse, al lanzarlo por primera vez se ve una pantalla de bienvenida: En esta pantalla podemos leer la documentación y ver algunos tutoriales de eclipse, es muy recomendable leerlos en algún momento. Por ahora vamos directamente al workbench.

En la parte superior del workbench el primer icono que encontramos de izquierda a derecha es el de New, lo presionamos y abre un submenu, ahí le damos la ultima opción la que dice Other.

Se abre una ventana pidiéndote que selecciones el asistente, buscamos en la carpeta de Servers, aquel que dice Server y le damos Next

Una aclaración: eclipse solo puede tener un servidor de cada tipo y versión corriendo a la vez, así que si ya definiste algún servidor Tomcat 6.0 antes, no te dejará hacerlo de nuevo hasta que lo borres y lo vuelvas a crear (o cambies de workspace)

En la siguiente pantalla te pide que digas que tipo de Servidor seleccionas la carpeta de Apache y el servidor tipo Tomcat v6.0 Server, es importante también que le digas que el nombre del host es localhost. Y en el nombre del servidor le puedes poner lo que quieras el default esta bien.

En donde dice Server Runtime enviroment le damos Add y se abre otro cuadro de dialogo, aquí lo importante es que le digamos donde esta instalado el Tomcat como se ve en la pantalla.

Si todo esta bien le puedes dar Finish y se “crea” el Server dentro de eclipse.

Probando la instalación

Cada que quieras hacer un nuevo proyecto con JSP’s o Servlets, creas un nuevo proyecto de tipo Web y luego Dinamic Web Project y te fijas que el Target Runtime Enviroment sea el servidor que recién creamos.

Para efectos de prueba, puedes descargarte este proyecto de prueba, e intentar ejecutarlo. Desde el menú File, Import, General, Existing Proyect into Workspace, Select Archive File y seleccionar el zip recién descargado.

Una vez importado desde la pestaña de servers arrancas el Servidor Tomcat, luego navegas dentro del proyecto recién importando y le pides que te muestre el JSP de prueba debes ver algo parecido a esto:

Mas información

Este post fue escrito basándome un poco en el libro de Orelly, un poco en la documentación del mismo eclipse y bastante en este sitio.

• Suponemos que la instalación se va a realizar en Ubuntu, esto significa que el servidor va a vivir en Ubuntu.
• Que queremos que los repositorios sean visibles vía web, que el servidor web sea Apache de la rama 2.x (Subversión tiene su propio servidor, nosotros mejor ocuparemos Apache).
• Que el protocolo para comunicarse sea SSL, la información viaje encriptada (es decir que el URL sea https://algo).
• Que se podría hospedar mas de un repositorio.
• Que para conectarse un usuario tenga que proporcionar un password.
• Que tengamos políticas de acceso, es decir que no todos los usuarios puedan ver todas las carpetas, habrá algunos que puedan ver, otros que puedan escribir, y a cada carpeta le podemos poner diferentes atributos (permisos).

Cuando aprendimos a hacer esta instalación leímos el tutorial de Viktor Zigo, que esta libre bajo una licencia Creative Commons, sin embargo me decido a aumentar algunas cosas como la política de acceso, además dado que no hay mucha documentación en español sobre este tema, me imagino que este documento le ayudara a alguien.

Paquetes necesarios

Hay que instalar, o verificar que estén instalados los siguientes paquetes:

• subversion
• libapache2-svn
• libapache-mod-dav
• apache2

En ubuntu 7.10 el paquete libapache-mod-dav, no existe simplemente continuamos sin el pues mod-dav ya esta incluido en apache2

Habilitar el modulo de SSL en apache

Para hacer este paso primero hay que habilitar el modulo de apache que deja comunicarse via SSL, luego hay que editar un archivo de configuración de apache para decirle que escuche por el puerto 443, que es el default de SSL

Habilitar el modulo de apache2 de SVN

sudo a2enmod ssl

Editar el archivo de configuración /etc/apache2/ports.conf del apache.

Agregando al final la linea: “Listen 443”. Es decir deben haber dos lineas, la del 80 y la del 443

Nota me acabo de dar cuenta de que en Ubuntu 7.10, no es necesaria la edición del archivo, pues el comando anterior a2enmod, ya edita el archivo por nosotros, lo que se debe de hacer es fijarnos en este archivo y que escuche el 443.

Generar un certificado

Para hacer un certificado hay que ocupar una herramienta, desde Ubuntu Festy en adelante esta herramienta es: make-ssl-cert, antes de eso la herramienta era: apache2-ssl-certificate.

Sea cual sea el caso, hay que hacer un certificado, el certificado es un archivo .pes y una llave, que es un archivo con números raros de nombre.

Para hacer el certificado la herramienta nos hace algunas preguntas, como quienes somos, donde se ubica el servidor físicamente, a que organización pertenecemos, etc.

Es importante usar el nombre real de nuestro servidor, cuando lo pida, por que de lo contrario cada vez que un usuario quiera acceder al repositorio, su cliente le marcara un warning diciendo que el servidor y el emisor del certificado no corresponden.

Si el servidor va a ser accesible por un dominio, el dominio es el nombre del servidor, si va a ser accedido por una IP fija, la IP es el nombre del servidor, si va a ser accedido dentro de una red interna el nombre en la red de la maquina es el nombre del servidor.

La herramienta debe generar ambos archivos el apache.pem y el de la llave, lo mas recomendable es que estos se encuentren en la carpeta ssl, dentro de la carpeta de apache. Puede que sea necesario que nosotros tengamos que mover los archivos manualmente.

La herramienta antes de Festy 7.04 se usaba asi:

sudo apache2-ssl-certificate

Desde Festy en adelante se usa así:

sudo /usr/sbin/make-ssl-cert /usr/share/ssl-cert/ssleay.cnf /etc/apache2/ssl/apache.pem

En donde el primer argumento es el comando a invocar en este caso make-ssl-cert, el segundo es una plantilla de certificado en este caso se ubica en /usr/share/ssl-cert/ssleay.cnf, y el tercero el lugar donde se pone el certificado /etc/apache2/ssl/apache.pem. Es decir que lo único que podría cambiar es el tercer argumento aunque no se recomienda. Es importante que antes se cree la carpeta donde va a vivir el certificado

Crear un host virtual

En apache2 hay posibilidad de que un solo servidor maneje muchos sitios, lo mas recomendable es hacer un sitio aparte para nuestros repositorios de SVN.

Copiamos el sitio de default, para ocuparlo de plantilla

sudo cp /etc/apache2/sites-available/default /etc/apache2/sites-available/$NOMBRESITIO

En donde $NOMBRESITIO, es el nombre que queremos que tenga nuestro sitio que maneja los repositorios. por ejemplo podemos ponerle repos.

Editamos configuración del sitio

Abrimos con nuestro editor de textos plano favorito el recién creado archivo de configuración del sitio y lo editamos:

Cambiamos la parte que dice:

NameVirtualHost *
<VirtualHost *>

Por:

NameVirtualHost *:443
<VirtualHost *:443>

Y añadimos las siguientes lineas:


SSLEngine on
SSLCertificateFile /etc/apache2/ssl/apache.pem
SSLProtocol all
SSLCipherSuite HIGH:MEDIUM

Dentro de las etiquetas VirtualHost, pero fuera de cualquier etiqueta Directory

Habilitamos el nuevo host virtual

Primero le decimos a apache que ya hay un nuevo sitio

sudo a2ensite $NOMBRESITIO

Y reiniciamos apache

sudo /etc/init.d/apache2 restart

Si hubo errores al editar el archivo, ahora se quejara, corregimos hasta que apache arranque, si hay un warning de que no puede determinar el nombre de dominio calificado, es normal.

Y se puede arreglar añadiendo ServerName $NOMBREDELSERVIDOR al archivo de configuración principal de apache: /etc/apache2/apache2.conf (el nombre del servidor es el nombre de la maquina que lo hospeda)

Creando los repositorios:

Suponemos que queremos tener varios repositorios, creamos una carpeta donde ponerlos todos, un buen lugar para hacerlo es en: /var/svn, luego hacemos los repositorios y le cambiamos los permisos a los repositorios para que el usuario de apache (www-data), tenga total control sobre ellos.

Por ejemplo:

sudo mkdir /var/svn
sudo svnadmin create /var/svn/$REPOS
sudo chown -R www-data:www-data /var/svn/$REPOS
sudo chmod -R g+ws /var/svn/$REPOS

Donde $REPOS, es el nombre del repositorio a crear, se pueden hacer varios repositorios. Que deberían vivir bajo la mima carpeta, en este caso /var/svn.

Agregar usuarios al repositorio

Para que un usuario pueda consultar el repositorio, debe de tener un password, el encargado de hacer la validación sera Apache, y la manera como lo hará sera verificando que el usuario y el password, estén en un archivo de texto plano.

Creando el archivo de password

Hay que ocupar la herramienta htpasswd, en versiones de Ubuntu anteriores a 7.04, la herramienta se llama htpasswd2, ambas son la misma herramienta, solo le quitaron el 2, en el nombre, así que es cuestión de usar el que nos corresponda.

Ejemplo:

sudo htpasswd -c -m /etc/apache2/svn-auth-file $NOMBREUSUARIO

En este momento nos preguntara cual va a ser el password del para el usuario $NOMBREDEUSUARIO y se crea el archivo de nombre svn-auth-file. El nombre del archivo puede ser cualquiera pero se sugiere algo que nos recuerde que son los passwords del svn, y puede vivir en cualquier lado, pero se recomienda que viva donde el apache lo hace.

El modificador -c, es para que cree el archivo de passwords y el modificador -m para que encripte el password.

Importante: Si queremos agregar un nuevo usuario usamos el comando sin el modificador -c y lo apuntamos al archivo que ya creamos, de esta manera los passwords de ambos usuarios están guardados en el mismo archivo. En nuestro ejemplo seria:

sudo htpasswd -m /etc/apache2/svn-auth-file $NOMBRENUEVOUSUARIO

Agregando políticas de acceso

Vamos a hacer una archivo de control de acceso, lo mas simple es usar como plantilla alguno de los que viene en cualquier repositorio. Por ejemplo podemos ir al repositorio que acabamos de hacer y dentro de su directorio conf, hay un archivo de ejemplo: authz

Podemos tomar este archivo de ejemplo como plantilla. Y copiarlo al directorio de apache, cambiarle por los permisos adecuados y después editarlo con nuestras preferencias. Podemos ponerle cualquier nombre yo aquí lo llamo svn-authz-file.

sudo cp /var/svn/$REPOS/conf/authz /etc/apache2/svn-authz-file
sudo chmod 644 /etc/apache2/svn-authz-file
sudo gedit /etc/apache2/svn-authz-file

Editar el archivo no es difícil y podemos ver que la plantilla ya trae un ejemplo con la sintaxis. Yo por ejemplo solo le agrego algo como esto:

[$REPOS:/]
$NOMBREUSUARIO = rw
$NOMBRENUEVOUSUARIO = r
En donde $NOMBREUSUARIO puede leer y escribir el repositorio $REPOS y $NOMBRENUEVOUSUARIO solo puede leerlo.

Poniendo todas las opciones de configuración a nuestro repositorio

Ahora solo resta decirle a apache que sirva de interfaz a nuestro repositorio con todas las opciones que le acabamos de dar.

Para hacer esto editamos el archivo dav_svn_conf que se encuentra dentro de la carpeta mods-available del directorio de apache.

sudo gedit /etec/apache2/mods-available/dav_svn_conf

Este archivo tiene de nuevo un ejemplo de llenado, cada repositorio tiene sus opciones dentro de las etiquetas location. Podemos repetir la que ya tiene por defecto y agregarle nuestras opciones.

<Location /$REPOS>
DAV svn
# our access control policy
AuthzSVNAccessFile /etc/apache2/svn-authz-file
SVNPath "/var/svn/$REPOS"
AuthType Basic
AuthName "Subversion repository"
AuthUserFile /etc/apache2/svn-auth-file
Require valid-user
SSLRequireSSL
</Location>

De estas opciones debemos modificar dentro de la etiqueta de apertura de location el nombre de nuestro repositorio. En donde dice SVPath ponemos el lugar donde esta el repositorio. En la opción de AuthzSVNAccessFile el archivo que creamos de políticas de control de acceso. Y en la opción de AuthUserFile el archivo donde están las contraseñas de los usuarios. No olvidemos añadir tambien la linea SSLRequireSSL

Reiniciamos apache

Por ultimo para que todos los cambios surtan efecto:

sudo /etc/init.d/apache2 restart

Si algún archivo no quedo bien editado ahora se quejara, de no ser así podemos proceder a probarlo:

Abrimos nuestro navegador web favorito y visitamos las dirección http://localhost/$REPOS y debe de contestarnos algo así como 403: Forbiden. Ahora visitamos el sitio https://localhost/$REPOS y debe pedirnos usuario y contraseña, en caso de que la contraseña sea incorrecta o que el usuario que introducimos no tenga permiso de lectura sobre $REPOS volverá a contestarnos 403: Forbiden.

Si el usuario se autentifica correctamente y tiene los permisos necesarios, debe mostrarnos el repositorio si aun no hemos hecho ningún import o commit, debe ser un repositorio vacío en la revisión 0.

He probado que estos pasos funcionan en Ubuntu 6.10, 7.04 y 7.10

Mas conocimientos

Recuerden que el mejor lugar para aprender mas de subversion es el libro oficial, que ademas es libre y existe una traducción al español.

Instalar Geany, no debe de dar mayor problema, pues se encuentra en los repositorios oficiales de Ubuntu, lo podemos hacer via apt-get, o synaptic, o incluso se encuentra disponible en agregar o quitar programas bajo la categoría de desarrollo, si su sistema esta en español (el Ubuntu), geany también vendrá en español.

Bueno, por que querría yo usar un editor de texto aparte de gedit? Pues por que geany me da ciertas ventajas que no me da por ejemplo gedit, al escribir código, estoy hablando a que nos da mas ventajas que el simple sintax highlight

Pues aquí viene lo bonito del asunto, si queremos usar Geany para escribir código de OpenGL y glut en Ubuntu, y ya sabemos hacer nuestros propios makefiles, como lo explique en el post anterior.

Ahora podemos usar todo esto a nuestro favor para tener un entorno de desarrollo muy amigable, para empezar guardemos todos nuestros archivos fuentes y makefile en una sola carpeta luego iniciamos geany.

Ahora suponemos que en nuestro makefile, define cierto nombre para el ejecutable por ejemplo “Modelo3D”, y que definimos un make all, de defualt, y que también pusimos un “make destroy”, que elimina los objetos y el ejecutable.

Pues abrimos Geany, de ahí abrimos todos nuestros archivos fuentes, Archivo -> abrir y luego nos vamos al menú que dice: construir

En la ultima opción se encuentra Selecciona Inclusiones y Argumentos, al entrar a esta opción vemos una ventana como esta:

Ahora vemos que Geany ya ha dado valores de default, pues sabe que estamos escribiendo código en C, por que abrimos un archivo .c, sin embargo como nosotros ya hicimos nuestro propio makefile, la vamos a cambiar esas opciones, para que llame a nuestro make.

Lo que tenga escrito en la primer caja de de compilar es lo que se va a ejecutar, cuando apretemos el botón de compilar, ahora nosotros queremos que antes de compilar elimine todos los objetos y el ejecutable, y luego intente compilar todo, es decir queremos que ejecute “make destroy” y luego “make all”, y como esta instrucción se va a mandar al shell tal como la escribimos podemos escribir:
make destroy; make
Ahora lo que escribamos en argumentso para el programa, es lo que ejecuta cuando presionamos el boton de ejecutar, así que podemos poner ahi ./nombre_de_ejecutable o para nuestro ejemplo:
./modelo3D

Y listo, ahora podemos programar cómodamente en Geany, usando glut y OpenGL, cada que queramos compilar, solo presionamos el botón de compilar y al ejecutar el botón de ejecutar.

Algunas observaciones

• Geany es muy ligero y tiene la enorme ventaja que no hace archivos de proyecto, o de configuración, esto es una ventaja para programas pequeños.
• La ventaja de tener total control de los argumentos con nuestro propio makefile.
• También se puede importar código muy fácil, ya que geany, nos da lo mínimo, para poder escribir entre Windows y GNU/Linux, es decir nos deja cambiar el carácter de terminación de linea de los archivos fuentes y la codificación de caracteres, la codificación de GNU/Linux y en particular de Ubuntu es UTF8, la codificación en Windows es depende del idioma en que lo tengamos, pero seguro aparece en el menú de geany. La terminación de linea en Windows es CRLF y en GNU/Linux es LF.
• Tenemos las opciones que mas comúnmente se usan al programar en un Editor muy ligero y que no para instalar no necesitamos traer montones de librerías como en los casos de editores mas poderosos.