Pero como dije, debo pasar del modo amateur, al modo PRO (pro-fe-sio-nal). Lo cual implica dejarse de tonterias y comenzar a usar cámaras decentes. Y poner todo el equipo de procesamiento de imágenes en un server-room, a una distancia prudente. En una instalación profesional lo único que queda expuesto es lo estrictamente necesario, el resto está profesionalmente instalado en un rack, en un cuarto seguro y con aire acondicionado.

Lo anterior choca directamente con los 4.5 metros de distancia máxima de una cámara Firewire (USB tiene el mismo problema). Entonces se comienza a usar equipo para extensión firewire. Se adquiere equipo extensor firewire de alta calidad, como los que hace Kramer. Y repentinamente la aplicacion hace segfaults, simplemente no se puede abrir la cámara.

• ¿El extender esta dañado?  No porque es nuevo, y los otros 4 pares de extenders nuevos tampoco sirven.
• ¿El cable es de baja calidad?  Compramos una bobina de CAT6 blindado, y aún no funciona.
• ¿Los cables firewire estan mal?  Los 10 cables probados son nuevos, y con recubrimiento de oro, asi que no.
• ¿Las cámaras estan dañadas? TODAS camaras funcionan directo, pero no con extenders
• ¿Alguna otra cámara sirve? Sospechosamente las cámaras baratas no-pro sí sirven.

¿Que sucede?

Continuará…

Noté que la interfaz habia cambiado desde la ultima vez que fui a ese banco a hacer algun movimiento. En una vez que volteo el monitor para que yo certificara ciertos datos noté el theme de su OS un tanto familiar. Era el theme Crux que a continuacion se ve. Es un theme clasico y muy viejo recuerdo haberlo visto desde hace muchos años en los escritorios de Gnome, aun en estos dias viene en casi todas las distros de Linux.

Se me hizo raro ver un OS con theme, pero ya que el theme es software libre, pensé que podrian haberlo puesto en su Windows.También noté que su Ambiente de Escritorio sospechosamente se parecia a XFCE, aunque un tanto modificado y bloqueado en ciertos aspectos.

Minutos despues, se activó el screensaver, que era la pura pantalla negra. Luego cuando la fulana regresó y movio el ratón se vio la clásica pantalla de XScreensaver:

Algo es seguro, esa compu ya no usaba Windows. Y a pesar que pudo haber usado Solaris, o algun otro clon de Unix, sospecho que usaba alguna distribucion de Linux ya que es el mejor soportado por empresas privadas y el mas popular (mas que los BSD, y Solaris). Pienso que la eleccion de Linux con XFCE pudo haberse hecho para lograr ahorros en equipo, ya que XFCE es un escritorio muy ligero. Y ahora que recuerdo, la compu que estaba usando no se veia muy nueva que digamos (CRT, floppy, eeek!!).

En definitiva, la ejecutiva no usaba windows  y por lo que vi, no se extrañaba de usar ese OS que le dieron y seguramente ella ni cuenta se daba que usaba Linux en lugar de Windows. Lo que si seguramente sabia era que con ese nuevo sistema ya no tiene que instalar antivirus, antispam, antispyware, antimalware, anti rootkits, anti adware, ni ninguno de esos miles de programitas que se instalan para mantener relativamente “seguro” a Windows.

# sudo apt-get install gcc-4.1
# sudo apt-get install g++-4.1
# cd /usr/bin
# sudo rm cpp gcc g++
# sudo ln -s cpp-4.1 cpp
# sudo ln -s gcc-4.1 gcc
# sudo ln -s g++-4.1 g++

Y listo, ya compila todo lo del nvcc, yo usé la version de CUDA 2.1 para Ubuntu 8.04 porque la de 8.10 aún no sale. Y al final lo más facil es hacer lo siguiente para generar el proyecto de KDevelop3:

# cd build/
# cmake ../ -G KDevelop3

$ svn co https://emesene.svn.sourceforge.net/svnroot/emesene/trunk/emesene emesene
$ cd emesene
$ ./emesene

Y la forma larga, pero que deja instalado todo bien es:

$ svn co https://emesene.svn.sourceforge.net/svnroot/emesene/trunk/emesene emesene
$ cd emesene
$ python setup.py build
$ sudo python setup.py install
$ exit
$ emesene

Emesene se integra mejor con Gnome pues está programado con Python GTK, a diferencia de aMSN que está programado con un toolkit viejo (Tcl/tk). Emesene tiene soporte de emoticons, emoticons personalizados, pizarra, zumbidos, MSN Plus y hasta Winks. La versión del Subversion ya tiene soporte de Webcam.

La solución: Se debe indicar a gcc en donde estan las librerias usando -L<dir>, luego enlazarlas como librerías normales usando -l<name>. Por ejemplo para enlazar la librería /home/user/tmp/libtrompete.a:

gcc -L/home/user/tmp/ -ltrompete main.cpp

Nota que solo se le indica el nombre trompete, porque gcc le agrega lib+trompete = libtrompete. GCC también busca automáticamente si es .o, .so o si es una AR .a.

Directo del repositorio

$ svn merge -r START:END http://repo/svn/trunk /directorio/branch

De una copia local:

$ svn up /directorio/trunk
$ svn merge -r START:END /directorio/trunk   /directorio/branch

Cualquiera de las dos anteriores te hace un merge a la copia local que está en /directorio/branch.

Para finalmente subir (a la branch) los cambios obtenidos

$ svn ci -m "Merge del trunk a mi branch START:END"  /directorio/branch

Si no se pusieron de acuerdo tus programadores, probablemente salgan conflictos, arreglalos.

Listo.

La verdad es que esto es culpa del driver beta de nVidia que aun no soporta bien mi 280 GTX. Y cada vez que entro a ver el blog del Lhuerta mi Firefox simplemente muere y se lleva consigo al servidor Xorg. El resultado es que me regresa a la pantalla de login.

Querido Nvidia:

Me estas provocando dolores de cabeza horribles ¡¡¡arregla ya el driver de Linux!!!!

Creación automática de un proyecto de KDevelop con CMake

Usaré exactamente lo que se describe en el post anterior. Lo único que debe tenerse precaución es en eliminar todo lo que pudiera quedar dentro del directorio build/ de generaciones pasadas. El directorio build/ debe estar vacío.

$ cd build/
$ cmake -G KDevelop3 ../
-- Check for working C compiler: /usr/bin/gcc
-- Check for working C compiler: /usr/bin/gcc -- works
-- Check size of void*
-- Check size of void* - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Configuring done
-- Generating done
-- Build files have been written to: /home/ariel/Documentos/holaMundoCMake/build

Y listo. Nota la opcion “-G KDevelop3“. En el directorio build/ se auto genera un proyecto de KDevelop llamado HELLO.kdevelop pues HELLO es el nombre del proyecto que definimos en CMakeLists.txt. Ahora se puede abrir con KDevelop (C/C++). Project->Open Project y elegimos HELLO.kdevelop.

El proyecto compila, ejecuta y tenemos el arbol de inclusiones. Tambien podemos usar el debugger y el completador de código. Todo lo de KDevelop funciona porque es un proyecto nativo.

Ah, para que el completador de código funcione, debes tener KDevelop 3.5.2 al menos.

CMake es una excelente herramienta para generar Makefiles, y no solo eso tambien genera soluciones de Visual Studio, Code::Blocks, Kdevelop entre muchas otras. Así que me puse a investigar y resulta que CMake es trivial de usar, hasta un newbie como yo lo puede usar (por lo tanto otros newbies también podrían usarlo).

1. Hello World: El código fuente

Usaremos este código que muestra CMake para compilar y enlazar un programa principal con una librería extra generada por nosotros mismos. La siguiente estructura de directorios es la que hay que crear:

holaMundoCMake
|-- CMakeLists.txt
|-- build
`-- src
    |-- hola.cpp
    `-- milib
        |-- CMakeLists.txt
        |-- milib.cpp
        `-- milib.h

La idea aqui es que vamos a generar un pequeño programita a partir del codigo en hola.cpp y de la libreria milib.cpp, el código de hola.cpp es muy sencillo:

hola.cpp:

#include "milib.h"
int main(int argc, char* argv){
printf("\n Hola mundo desde main");
hola(2);
printf("\n");
}

Y lo que hace es cargar el header milib.h que es donde está definida la función hola().

milib.h:

#include <stdio.h>
//Prototipo de funcion
void hola(int);

milib.c:

#include "milib.h"
// Implementacion de la funcion
void hola(int veces){
  int i=0;
  while (i<veces){
    printf("\n [%u] Hola Mundo, desde 'milib'" , i);
    i++;
  }
}

El código es realmente trivial (si no lo comprendes mejor ni sigas leyendo). Hasta este punto no hemos usado nada de CMake ni hemos creado Makefiles ni nada. El código bien podríamos compilarlo a mano.

2. Hello World: Las CMakeLists.txt para CMake

Hay un archivo de CMake en holaMundoCMake/CMakeLists.txt y hay otro en holaMundoCMake/src/milib/CMakeLists.txt, éstos son los archivos clave para CMake. Con los comentarios se explican solos.

holaMundoCMake/CMakeLists.txt:

# El nombre del proyecto "HELLO".
# CMake genera automaticamente una variable llamada
# HELLO_SOURCE_DIR que puede llamarse usando
# ${HELLO_SOURCE_DIR} con la ruta del codigo
# lo mismo con ${HELLO_BINARY_DIR} para binarios

project (HELLO)

# Le decimos donde poner los binarios de librerias y ejecutables
# CMake admite instrucciones partidas en varias lineas
SET (LIBRARY_OUTPUT_PATH    ${HELLO_BINARY_DIR}/bin
	CACHE PATH "Directory for Libraries")
SET (EXECUTABLE_OUTPUT_PATH ${HELLO_BINARY_DIR}/bin
	CACHE PATH "Directory for Executables")

# Decimos a CMake que haga recursion a los siguientes directorios
# en orden de aparicion
add_subdirectory (src/milib)

# Directorios que debe incluir, ademas de los estandar.
include_directories (${HELLO_SOURCE_DIR}/src/milib/)

# Directorios para el enlazador, ademas de los estandar
# Para este ejemplo no los necesitamos ya que la unica libreria
# adicional es 'milib' y ya sabe donde encontrarla pues el mismo
# la genera
#link_directories (aqui pones mas rutas separadas por espacios)

# Decirle que queremos un ejecutable llamado holaMundo
# y le decimos el source para que lo compile
add_executable (holaMundo src/hola.cpp)

# Tenemos una libreria adicional llamada milib, enlazarla
target_link_libraries (holaMundo milib)

El segundo CMakeLists sirve para compilar la libreria “milib” y es mucho mas corto:

holaMundoCMake/src/milib/CMakeLists.txt

# Agregar una libreria llamada milib generada poru un cpp
# se pueden agregar muchas librerias con varios add_library
# Se deben listar todos los archivos fuente
add_library (milib milib.cpp milib.h)

3. Hello World: Generar Makefiles con CMake y compilar

En linux el modo por default es generar Makefiles, así que entramos al directorio build que actualmente está vacío y generamos los Makefiles:

~/Documentos$ cd holaMundoCMake
~/Documentos/holaMundoCMake/$ cd build
~/Documentos/holaMundoCMake/build$ cmake ../
-- Check for working C compiler: /usr/bin/gcc
-- Check for working C compiler: /usr/bin/gcc -- works
-- Check size of void*
-- Check size of void* - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Configuring done
-- Generating done
-- Build files have been written to: /home/ariel/Documentos/holaMundoCMake/build

Listo, ya estan los Makefiles generados, ahora a compilar con make:

~/Documentos/holaMundoCMake/build$ make
Scanning dependencies of target milib
[ 50%] Building CXX object src/milib/CMakeFiles/milib.dir/milib.o
Linking CXX static library ../../bin/libmilib.a
[ 50%] Built target milib
Scanning dependencies of target holaMundo
[100%] Building CXX object CMakeFiles/holaMundo.dir/src/hola.o
Linking CXX executable bin/holaMundo
[100%] Built target holaMundo
ariel@surfer:~/Documentos/eclipse/holaMundoCMake/build$ make clean
ariel@surfer:~/Documentos/eclipse/holaMundoCMake/build$ make
[ 50%] Building CXX object src/milib/CMakeFiles/milib.dir/milib.o
Linking CXX static library ../../bin/libmilib.a
[ 50%] Built target milib
[100%] Building CXX object CMakeFiles/holaMundo.dir/src/hola.o
Linking CXX executable bin/holaMundo
[100%] Built target holaMundo

En el directorio build/bin se encuentra el binario holaMundo,

~/Documentos/holaMundoCMake/build$ cd bin/
~/Documentos/holaMundoCMake/build$ ./holaMundo
Hola mundo desde main
[0] Hola Mundo, desde 'milib'
[1] Hola Mundo, desde 'milib'

¡Listo! ¿Quién dijo que habría que generar Makefiles a mano? Generar CMakeLists.txt es mucho mas fácil y mas intuitivo.