Juan Reyes Blog

Tracking usando filtro de partículas en OpenCV

2011-12-09T16:50:00.000-08:00

Una implementación muy simple de un tracker que usa filtro de partículas en OpenCV. Las partículas se generan mediante números aleatorios que siguen una distribución Gaussiana, se les asigna peso según distancia de histogramas HSV y frame a frame se van actualizando, conservando sólo las mejores partículas.

Puedes bajar el programa aca

Octave plot custom grid

2011-04-29T05:17:00.000-07:00

Necesitaba graficar algo, pero quería cambiar el espaciado de la rejilla a 0.25

P = dlmread("serial500.txt"," ");
plot(P(:,1),P(:,2),"*")
set(gca(),"xtick",[0:0.25:1])
set(gca(),"ytick",[0:0.25:1])
grid
xlabel("x")
ylabel("y")
title("500 pares de nums")

Un problema interesante

2011-03-12T17:48:00.000-08:00

El otro día me comentaron acerca de un problema muy interesante y quiero compartirlo con ustedes, por supuesto que no les daré el nombre del problema para que no lo busquen...

Hay tres cajas, de las cuales sólo una contiene un premio. Tú escoges una de estas cajas y luego se te muestra una de las cajas que no escogiste y no contiene premio. Se te da la posibilidad de cambiar la caja que escogiste por la que queda ¿Qué te conviene hacer?

Reflexiones acerca de nuestra grandeza

2011-02-22T18:39:00.000-08:00

La vida se agota, nada se puede hacer para evitarlo, nos parecen tan importantes y eternas ciertas cosas, como si nunca dejaremos de ver el sol llegar cada día, como si existiese alguna urgencia en este mundo. Cuando en realidad cada una de nuestras creaciones tiene como destino la destrucción, pero que más da, es preferible soñar con que tenemos asuntos muy importantes que atender, con que somos grandes y elocuentes, mucho mejores que aquellas rocas que agonizan en el espacio. Es preferible emitir un destello de luz antes de desaparecer, como intenando superar la inercia de lo interte, que no ha conseguido aún tener la más mínima inferencia en lo que le depara.

La Identidad de Euler

2010-11-15T18:16:00.000-08:00

Se dice que si se tuvieran que escoger los números más populares, sin duda alguna entre los primeros escogidos estarían π, e, i, 1 y 0.
Hay una bella identidad que los relaciona, seguramente conocida por más de alguno de ustedes, yo la ví en el documental universo matemático:

e^{i π} + 1 = 0

La identidad anterior es conocida como la Identidad de Euler.

Para corroborar su autenticidad sólo debemos recurrir a la famosa Fórmula de Euler:

e^{i θ} = cos (θ) + i sen(θ)

Donde se verifica fácilmente que si θ = π se obtiene:

e^{i π} = cos (π) + i sen(π) = -1

Pues cos(π) = -1 y sin(π) = 0

Tip Octave

2010-09-26T16:56:00.000-07:00

Cuando se carga una imagen en memoria usando imread se almacena como una matriz uint8, lo que significa que cada valor de la matriz es un número positivo de 1 byte, si se quiere trabajar con esos números hay que tener cuidado pues tomarán un valor máximo de 255.


     octave:>  img = imread("imagen.jpg");
     octave:>  img(1,1)      
     octave:>  ans = 44
     octave:>  img(1,1)*1000
     octave:>  ans=255
     octave:>  %para evitar esto hay que hacer un casting
     octave:>  double(img(1,1))*1000
     octave:>  ans=44000
     octave:>

Escribí esto aquí para que no se me olvide, pues me causó un gran dolor de cabeza mientras estaba probando un algoritmo de interpolación para un trabajo de la universidad.

Efecto para ser invisible, para variar en OpenCV

2010-09-20T16:37:00.000-07:00

El efecto mostrado en el post anterior es muy fácil de programar:
1.- Sacar una foto al fondo
2.- Reemplazar todos los pixeles color piel por su pixel correspondiente en la imagen tomada en 1.
Para detectar la piel humana en el espacio de colores RGB:

char isSkinPixel(IplImage *img, int x, int y) {

unsigned char R,G,B;

B = img->imageData[y*img->widthStep+x*img->nChannels];

G = img->imageData[y*img->widthStep+x*img->nChannels+1];

R = img->imageData[y*img->widthStep+x*img->nChannels+2];

if( R > 95 && G > 40 && B > 20 && ( max(R,G,B) - min(R,G,B) ) > 15 && abs( (int)(R-G) ) > 15 && R>G && R>B ) {

return 1;

}

return 0; 

}

La condición que se usa para detectar el color piel la ví en un paper, pero no lo pude encontrar para dejarlo aquí.

La detección de piel humana funciona bien sólo si estamos capturando imágenes en un lugar con la luminosidad adecuada, pues si esta muy oscuro o muy iluminado el color de la piel se pierde. Además hay falsos positivos si el fondo no es el adecuado.

Código fuente del programa : invisible (necesita la biblioteca OpenCV)

Pastilla para hacerse invisible

2010-08-24T14:28:00.000-07:00

Hoy al fin probé la famosa pastilla para hacerse invisible, es impresionante la rapidez con que hace efecto. Os dejo un video, haber si alguien puede explicarme cómo es que funciona esta revolucionaria mezcla de ingredientes exóticos.

Implementación de k-means en OpenCV

2010-08-02T11:17:00.000-07:00

k-means o k-medias es un algoritmo de agrupamiento (clustering), lo que significa que es usado para dividir un conjunto de datos en grupos de tal forma que los datos pertenecientes a un grupo tengan propiedades en común. También se dice que este algoritmo es de aprendizaje no supervisado, pues es capaz de clasificar datos sin tener un supervisor que durante la etapa de entrenamiento le indique la clase a la que pertenece cada dato.
Se puede usar este algoritmo para segmentar una imagen por color, clasificando los pixeles que tienen colores parecidos en un mismo grupo.

k-means funciona de la siguiente manera:

Elige aleatoriamente k centros (uno por cada grupo)
Se etiqueta cada dato como perteneciente al grupo cuyo centro es más cercano
Se calcula el centro promedio de cada grupo y se repite el paso anterior.
El algoritmo se detiene cuando el promedio de cada centro de grupo no cambia o se alcanza el número máximo de iteraciones.

El centro de cada grupo y las distancias quedan definidos por el problema.
En el caso de las imagenes RGB se define el centro como una tripleta que contiene un valor para cada color:rojo, verde y azul. La distancia que se usará en este caso es la euclídea.
Sólo hay que imaginar los colores como una coordenada en el espacio 3D y la distancia entre dos puntos como el largo de la recta que los une.

El resultado del algoritmo dependerá de los centros iniciales, si estos son escogidos aleatoriamente probablemente se obtendrán resultados diferentes en cada ejecución.

OpenCV trae implementado este algoritmo, sin embargo yo programé mi propia implementación porque el algoritmo es sencillo y me pareció interesante hacerlo.
Un poco de código:


  //calculo de centroides y matriz de clasificacion
for(it=0; it < iterations;it++) {
    for(i=0;i<size;i++) {
        red[i] = 0;
        green[i] = 0;
        blue[i] = 0;
        count[i] = 0;
    }
    for(j=0; j < image->height; j++) {
        for(i=0; i < image->width; i++) {
            tcolor = getColor(image,i,j);            
            dist = distance(centroid[0], tcolor );
            label = 0;
            for(k=1; k<size; k++) {
                temp = distance(centroid[k], tcolor );
                if( temp < dist) {
                    dist = temp;
                    label = k;
                }
            }
            ++count[label];
            red[label]   += tcolor.r;
            green[label] += tcolor.g;
            blue[label]  += tcolor.b;
            if(it == (iterations-1)) {
                labeled[i][j] = (uchar)label;
            }
        }
    }
    //actualizar centroides
    for(i=0;i<size;i++) {
        if(count[i]==0) continue; //no actualizar centroide si no se hay colores que promediar
        centroid[i].r = (uchar)(red[i]/count[i]);
        centroid[i].g = (uchar)(green[i]/count[i]);
        centroid[i].b = (uchar)(blue[i]/count[i]);    
    }
                    
}
//dejar con color de centroide mas cercano a cada pixel de la imagen a mostrar
for(i=0; i < image->width; i++) {
    for(j=0; j < image->height; j++) {
        image2->imageData[j*image->widthStep + i*image->nChannels + 2] = centroid[labeled[i][j]].r;
        image2->imageData[j*image->widthStep + i*image->nChannels + 1] = centroid[labeled[i][j]].g;
        image2->imageData[j*image->widthStep + i*image->nChannels ] = centroid[labeled[i][j]].b;
    }
}

centroid[] : contiene un color por cada clase
size: cantidad de clases
labeled[][]: almacena los resultados de la clasificación, un número de 0 a (size-1) que relaciona cada pixel con su clase.
red[],green[],blue[],cout[]: variables usadas para calcular el color promedio

En el código anterior, dados los centroides de cada clase se procede a identificar cada pixel con la clase cuyo color se encuentre más cercano a su color.
Posteriormente se actualizan los centroides de cada clase, para ello se promedian los colores de los pixeles que fueron etiquetados como pertenecientes a la clase.
El proceso se repite hasta completar la cantidad de iteraciones especificada en la variable iterations.
Código fuente completo: kmeans-2010.tar.gz

Resultados al aplicar a la imagen superior izquierda el algoritmo con 5 clases y 90 iteraciones:

Filtro de Sobel en OpenCV

2010-05-18T09:20:00.000-07:00

Una forma más elaborada de detectar bordes es el filtro de Sobel, dado que usa una mayor cantidad de píxeles de la vecindad para calcular el borde.


#include <opencv/highgui.h>
#include <opencv/cv.h>

void sobel(IplImage *img) {
  int i,j,indice;
  uchar *pixels = (uchar*)(img->imageData);
  uchar *new_pixels = (uchar*)malloc(img->widthStep*img->height*img->nChannels*sizeof(uchar));

    uchar sup;
    uchar sup_izq;
    uchar sup_der;
    uchar inf;
    uchar inf_izq;
    uchar inf_der;
    uchar izq;
    uchar der;
    int A;
    int B;
    double SUM;
  //el origen esta en esquina superior izquierda del pantalla
 for( i=1 ; i < (img->width-1) ; i++) {
   for( j=1 ; j < (img->height-1) ; j++) {
         indice = j*img->widthStep + i*img->nChannels;
         sup = pixels[indice - img->widthStep]; //pixel superior al actual
            inf = pixels[indice + img->widthStep]; //pixel inferior al actual
            izq = pixels[indice - img->nChannels]; //pixel izq al actual
            der = pixels[indice + img->nChannels]; //pixel der al actual
            sup_izq = pixels[indice -  img->nChannels - img->widthStep]; 
            sup_der = pixels[indice +  img->nChannels - img->widthStep];
            inf_izq = pixels[indice -  img->nChannels + img->widthStep]; 
            inf_der = pixels[indice +  img->nChannels + img->widthStep];
            A = sup_izq + 2*sup + sup_der - inf_izq - 2*inf - inf_der;
            B = sup_izq + 2*izq + inf_izq - sup_der - 2*der - inf_der;
            SUM = A*A + B*B;            
            new_pixels[indice] = 255-(uchar)sqrt(SUM);

   }
 }
 memcpy(pixels, new_pixels, img->widthStep*img->height*img->nChannels*sizeof(uchar));
 free(new_pixels);
  
}

int main() {
 CvCapture *cap = cvCreateCameraCapture(0);
 IplImage  *img;
 IplImage  *imgGray;
 int notCreated=1;
 while(1) {
  img = cvQueryFrame(cap);
  cvNamedWindow("hahaha",CV_WINDOW_AUTOSIZE);
  if(notCreated) {
   imgGray    = cvCreateImage( cvSize(img->width,img->height), IPL_DEPTH_8U, 1 );
   notCreated = 0;
  }
  cvCvtColor(img, imgGray, CV_RGB2GRAY);
  sobel(imgGray);  
  cvShowImage("hahaha",imgGray);
  char key = cvWaitKey(40);
  if(key == 27)
   break;
 }
    cvReleaseImage(&img);
    cvReleaseImage(&imgGray);
 cvReleaseCapture(&cap);
 cvDestroyWindow("hahaha");
    return 0;
}

Efecto fotocopia en tiempo real

2010-04-18T19:03:00.000-07:00

He estado jugando un poco con la librería de visión artificial de Intel, OpenCV. Programé el mismo efecto fotocopia que postie tiempo atrás, pero esta vez aplicandolo al video capturado por la webcam en tiempo real.
Esto no es difícil de lograr, sin embargo es interesante ver los resultados.

Aca el código:


#include  <opencv/highgui.h>
#include  <opencv/cv.h>

void fotocopia(IplImage *img, int difMax) {
    int i,j,difh,difw,indice;
    for( i=0 ; i < (img->width-1) ; i++) {
        for( j=0 ; j < (img->height-1) ; j++) {
            indice = j*img->widthStep + i*img->nChannels;
           /*diferencia brillo en pixeles de una misma columna
            widthStep es el tamaño de una fila en bytes, 
             ya que la imagen esta en un arreglo unidimensional.
              Al sumar widthStep estamos pasando a la siguiente fila
            */
            difh = ( (uchar*)(img->imageData) )[indice] - ( (uchar*)(img->imageData) )[indice+img->widthStep];
            if( difh < 0) {
                difh = difh * -1; 
            } 
        
            //diferencia brillo en pixeles de una misma fila
            
            difw = ( (uchar*)(img->imageData) )[indice] - ( (uchar*)(img->imageData) )[indice+1];
            if( difw < 0) {
                difw = difw * -1;
            }            
     
            //si hay mucha diferencia, es un contorno, hay que pintar el pixel negro
            if ( (difh + difw) > difMax) {        
                ( (uchar*)(img->imageData) )[indice] = 0 ;
            } else {
                ( (uchar*)(img->imageData) )[indice] = 255 ;
            }
        }
    }        
}

int main() {
    CvCapture *cap = cvCreateCameraCapture(0);
    IplImage  *img;
    IplImage  *imgGray;
    cvNamedWindow("hahaha",CV_WINDOW_AUTOSIZE);
    img = cvQueryFrame(cap);
    imgGray    = cvCreateImage( cvSize(img->width,img->height), IPL_DEPTH_8U, 1 );
    while(1) {
        img = cvQueryFrame(cap);
        cvCvtColor(img, imgGray, CV_RGB2GRAY);
        fotocopia(imgGray,5);        
        cvShowImage("hahaha",imgGray);
        char key = cvWaitKey(40);
        if(key == 27)
            break;
    }
    cvReleaseCapture(&cap);
    cvReleaseImage(&img);
    cvReleaseImage(&imgGray);
    cvDestroyWindow("hahaha");
}

Para compilar:

gcc `pkg-config --cflags opencv --libs opencv` fotocopia.c -o fotocopia

Aca un video de cómo se queda el efecto:

tarjeta de video Intel GMA X4500HD Ubuntu

2010-04-01T17:00:00.000-07:00

Problema:

Cuando abría alguna aplicación que hiciera uso de OpenGL esta veía con manchas negras o se pegaba y al ejecutar dmesg me aparecía lo siguiente:

[ 210.430986] [drm:i915_gem_object_pin_and_relocate] *ERROR* Relocation beyond target object bounds: obj f08cb9c0 target 23 delta 4096 size 4096.
[ 210.430992] [drm:i915_gem_execbuffer] *ERROR* Failed to pin buffers -22
[ 210.445817] [drm:i915_gem_object_pin_and_relocate] *ERROR* Relocation beyond target object bounds: obj f0a39180 target 23 delta 4096 size 4096.
[ 210.445827] [drm:i915_gem_execbuffer] *ERROR* Failed to pin buffers -22
....

Usando Ubuntu 9.10 the Karmic Koala con el paquete xserver-xorg-video-intel versión:
2:2.9.1~git-0ubuntu0tormod

Solución :

apt-get install libgl1-mesa-dri
Con lo cual se actualizaron los siguientes paquetes:
libdrm-intel1 a la versión 2.4.15~git-0ubuntu0tormod~jaunty
libgl1-mesa-dri a la versión 7.7.0~git20091114.57f40b18-0ubuntu0sarvatt~jaunty

La solución la encontré aquí.

Editando imagenes con Octave

2010-02-18T12:38:00.000-08:00

Me encanta el filtro fotocopia que trae el Gimp para dejar una foto como un dibujo, me dí cuenta de que es muy intuitivo hacer este efecto en Octave. Para ello sólo hace falta usar la función gradiente que toma una matriz y calcula la diferencia que hay entre dos elementos contiguos en cada fila y en cada columna.
Por ejemplo:

M =
1 2
3 4

[diffX, diffY] = gradient(M)

diffX =
1 1
1 1

diffY =
2 2
2 2

Se aprecia que diffX es la diferencia entre los elementos de las filas y diffY es la diferencia entre los elementos de las columnas.

Aplicando este concepto a las imagenes en escala de grises :


function fotocopia(imagen, salida)
im            = imread(imagen);
[diffX,diffY] = gradient(im);
fotocopia     = (diffX.^2 + diffY.^2).^(1/2);
fotocopia     = fotocopia * 3;
fotocopia     = 255 - fotocopia;
imwrite(fotocopia,salida);
endfunction

El operador . es para que se haga la operación a cada elemento de la matriz (elevar al cuadrado elemento por elemento)
La multiplicación por 3 es para realzar los bordes
La resta es para que el fondo quede blanco y el contorno oscuro (255 = blanco, 0 = negro).


fotocopia("plum.jpg","fotocopia.jpg");

Recuerdo

2010-02-16T17:34:00.001-08:00

El año 2005 programé un juego de naves en C con la librería ncurses, usando caracteres ASCII.
Aprendí muchas cosas y sentí gran satisfacción al ver mi jueguito terminado. No creo que el código sea un ejemplo, pero fue para mí una pequeña victoria.
Os dejo el link para descargar el código y el ejecutable.
PD: Las balas no se veen porque estan mal programadas, su velocidad depende del procesador.

Puntero void*

2010-01-11T17:58:00.000-08:00

Un puntero void* es un puntero genérico que se puede usar para hacer funciones que pueden recibir y/o devolver distintos tipos de datos según sea el caso. O sea que usando este tipo de puntero puedes hacer por ejemplo una función que trabaje con enteros si se le pasan punteros a enteros o con una estructura si se le pasan punteros a la estructura.
En el siguiente ejemplo se hace un casting a otro tipo de puntero para que así el compilador sepa cuantos bytes debe sumar a la dirección base, en este caso el casting es a char* por lo tanto el compilador sumará tamElem*k*sizeof(char) bytes a la dirección base.
Esta función recibe de argumento la función de comparación y busca en un arreglo el argumento llamado valor, en caso de hallarlo retorna el indice del elemento en el arreglo, si no encuentra al elemento en el arreglo retorna -1.


int busquedaLineal(void *valor, void *dirBase, int tamElem, int cantElem, int (*comparacion) (void*,void*)) {
    int k;
    for(k=0; k <  cantElem; k++) {
        void *elemActual = (char*)dirBase + tamElem*k;
        if( comparacion(valor,elemActual) == 0 ) {
            return k;
        }
    }
    return -1;
}

Editando sonido con Octave

2009-12-15T14:41:00.000-08:00

Octave es un software muy parecido a Matlab, pero libre. Trae consigo un sin fin de funciones matemáticas, sobre todo para trabajar con matrices.
Una de las muchas cosas interesantes que se pueden hacer con este software es cargar un archivo de audio en una matriz y editarlo.

Un archivo de audio tiene tres propiedades :

Muestras por segundo (Hz)
Número de bits por muestra
Cantidad de canales.

Usando la función wavread se puede leer un archivo WAV. Un sonido monofónico se guardará en una matriz de una columna, un sonido stereo una matriz de dos columnas, etc.

Sonido original:

Efecto de eco :


#archivo entrada, archivo salida, sample rate(ej. 44100,22050,etc)
function ecoAudio(nombre_wav, salida_wav, samplerate_hz)
 wav_matrix = wavread(nombre_wav); #leer wav
 desp = int32( size(wav_matrix)(1)/20 );
 m2         = shift(wav_matrix,desp);
 wav_matrix = wav_matrix + m2;
 wavwrite(wav_matrix,samplerate_hz,salida_wav);
endfunction

Aplicando efecto de eco:

Cambio de rapidez :


#archivo entrada, archivo salida,sample rate,rapidez
function rapidezAudio(nombre_wav, salida_wav, samplerate_hz, rapidez)
 wav_matrix = wavread(nombre_wav);
 wavwrite(wav_matrix, samplerate_hz*rapidez, salida_wav);
endfunction

Reproduciendo a la mitad de su velocidad:

Reproduciendo al doble de su velocidad:

Reproducir al revés :


#archivo entrada, archivo salida, sample rate
function revertirAudio(nombre_wav, salida_wav,samplerate_hz)
 wav_matrix = wavread(nombre_wav);
 wav_matrix = flipud(wav_matrix); #revertir filas
 wavwrite(wav_matrix,samplerate_hz,salida_wav);
endfunction

Reproduciendo al revés:

Usando un entero como un arreglo de caracteres

2009-12-02T20:12:00.000-08:00

Si tenemos una variable de tipo int por lo general ocupará 4 bytes de memoria, los que podremos usar literalmente a nuestro antojo. Por ejemplo podemos usar este espacio como un arreglo de 4 elementos de 1 byte cada uno.

Ejemplo uso de un entero como un arreglo de caracteres:



#include <stdio.h> 

int main() {

    int num;
    num=0;
    ( (char *)&num )[0] = 7;
    ( (char *)&num )[1] = 3;
    printf("%i %i\n",( (char*)&num )[0],( (char*)&num )[1]);
    *( (char *)&num ) = 2;
    *( (char *)&num + 1) = 4;
    printf("%i %i\n",( (char*)&num )[0],( (char*)&num )[1]);
    printf("%d\n",num);
}

Lo anterior imprime :

7 3
2 4
1026

La variable num queda como 1026 porque:
| 0000 0000 |0000 0000 | 0000 0100 | 0000 0010 |
| 0 | 0 | 4 | 2 |

La idea de este ejemplo es comprender mejor cómo funciona el lenguaje porque en la práctica usar un entero como un arreglo de char no hace que el código sea más simple.

Problema de ingenio

2009-11-05T18:18:00.000-08:00

Vas por un camino en medio de la selva que luego se dividirá en dos caminos, uno lleva a una tribu amigable y el otro lleva a una tribu canibal. Te encuentras con dos aborígenes de los cuales uno es de la tribu canibal y el otro es de la tribu amigable. El canibal NUNCA dice la verdad y el amigable SIEMPRE dice la verdad, no sabes cual de los dos es el canibal y sólo puedes hacer una pregunta que será respondida por los dos aborígenes.
¿Qué pregunta debes hacer para saber cuál es el camino que te conviene seguir?

Programación y ajedrez

2009-10-11T19:39:00.000-07:00

El verano del 2008 comencé a programar un motor de ajedrez en C, que probablemente será un chimpacé al lado de cualquier otro motor. Aún no lo termino, pues le dedico tiempo solo los veranos y unos escazos días.
En los primeros programas de ajedrez el tablero se representaba usando un arreglo, luego se comenzó a usar una técnica que revolucionó el mundo del ajedrez, los bitboards.
Un bitboard es una representación del tablero usando un entero de 8 bytes, dado que cada byte tiene 8 bits se pueden representar los 64 casilleros del tablero con un bitboard.
La ventaja de esta representación es que los cálculos son mucho menos costosos en memoria y CPU porque un bitboard pesa mucho menos que un arreglo de 64 carácteres y se usan operaciones a nivel de bit como el AND,OR,XOR y shift para muchos de los cálculos.

Verificar si un casillero del tablero se encuentra ocupado por una pieza usando bitboards:


typedef uint64_t bitboard;
...
/*  square number 0-63 (a1-h8) */ 
int isOccuped(bitboard board, int square) {
    
    if( board & (1<< square) ) {
        return 1;    
    }
    return 0;
}

Para revisar si una casilla del tablero esta ocupada usando un arreglo tendriamos que recorrer el arreglo e ir revisando casilla por casilla, lo cual resulta más costoso y menos elegante.

Aritmética de punteros

2009-10-07T20:19:00.000-07:00

Estaba indeciso acerca de que escribir en mi descuidado blog y decidí que a partir de hoy comenzaré a postear algunos fragmentos de código.
Sé que es muy fácil encontrar buenos ejemplos acerca del tema de hoy, pero más de alguno lo habrá olvidado y lo recordará por casualidad al llegar aquí.
C permite sumar o restar números enteros a un puntero, desplazando la dirección a la que este apunta la cantidad de bytes que ocupa el tipo de dato del puntero multiplicada por el número entero que se le ha sumado o restado.


#include <stdio.h> 
#include <stdlib.h> 

int main() {

    int* intArray;
 /*  (int *) indica al compilador que en la memoria reservada 
     se almacenaran enteros
     malloc (memory allocate) reserva (sizeof(int)*3) bytes de memoria 
     sizeof(int) retorna la cantidad de bytes que ocupa un int 
     (en mi caso 4 bytes)
     inicialmente intArray apunta al primer byte de memoria reservada
 */
    intArray  = (int *) malloc(sizeof(int)*3); 
   *intArray = 1;  //equivalente a intArray[0] = 1
//desplazar direccion apuntada por intArray sizeof(int) bytes
    intArray  = intArray + 1; 
   *intArray = 2;  
    intArray  = intArray +1; 
   *intArray = 3; 
    printf("%i %i %i\n",*(intArray - 2),*(intArray - 1),*intArray);
 /* si llamamos inmediatamente a free(intArray) obtendremos un error 
    en tiempo de ejecucion pues intArray ya no apunta al primer byte 
    de memoria reservada*/

 //intArray debe apuntar al 1er byte de la memoria reservada 
    intArray = intArray - 2; 
    free(intArray);

}

Muestra en pantalla:
1 2 3

Almacenando tus imagenes en Flickr

2009-02-27T07:31:00.000-08:00

Estoy usando Joomla y el componente Morfeoshow para referenciar a un album de Flickr desde otro sitio web, lo cual me evita usar el ancho de banda y espacio de hosting para mostrar una galería de imagenes, además de darme la comodidad de administrar las fotos en flickr, que tiene una interfaz muy comoda.
Me cree una cuenta en Flickr, cree un album, y llené un formulario para solicitar un application key que es una clave que tienes que poner en la aplicación que accederá a las fotos de un album flickr, el uso de la API de Flickr es gratuito cuando no es con fines comerciales.
En cuanto al componente Morfeoshow, que sirve para hacer galerías fotográficas en Joomla, tuve un pequeño problema por un molesto boton "retroceder" que salía abajo de la galería. En mi caso no lo necesitaba asi que lo desactivé.
Para desactivar el boton retroceder se debe cambiar la línea:
if ($params_morfeo['back'] == 0) por if ($params_morfeo['back'] == 1)
Que está en components/com_morfeoshow/morfeoshow.html.php en la línea 552 (versión 1.2.0 de morfeoshow).

Virtualbox, que maravilla

2009-02-21T19:08:00.000-08:00

Hoy probé virtualbox, un software de virtualización que te permite crear una maquina virtual para instalar algún sistema operativo y probarlo desde el sistema que estas usando sin necesidad de reiniciar ni finalizar ningún proceso.
Me impresionó su facilidad de uso, tiene un asistente esplendido con el cual en menos de 2 minutos tienes una maquina virtual configurada, porque te pregunta cuanta memoria ram y disco le asignaras a la nueva maquina, sin entrar en mayores detalles. Luego puedes cargar el sistema operativo a instalar desde la unidad de dvd o una imagen ISO.
Yo le instalé windows xp profesional sin necesidad de salir de ubuntu, sin configurar nada pude navegar en internet explorer y escribir este artículo.
Hace años que no uso vmware, asi que no puedo comparar, pero si puedo recomendar esta fabulosa herramienta llamada virtualbox.

Notebook nuevo

2009-02-11T15:01:00.000-08:00

Estoy posteando desde mi nuevo notebook. Un Lenovo N500, con un diseño parecido al de mi antiguo IBM t23 que me acompañó por 3 años.
Necesitaba con urgencia actualizarme, pues mi antiguo notebook me tenía muy limitado.
¡Muy feliz con la compra!

Palabras

2009-02-09T18:55:00.000-08:00

Nuestra lengua es bella y abundante, he oído decir una y otra vez, es una afirmación atrevida para alguien que no habla más de dos idiomas, cuando en el mundo hay más de 6000.
Tal vez la belleza radica en nuestras ideas y por ende cada ser humano ama su idioma. Por mi parte no hablo ningún idioma a la perfección, pues desconozco una gran parte de los recursos disponibles y mal utilizo otros.
Que compleja, que deslumbrante y que útil es nuestra capacidad para comunicarnos. Aumentemos nuestro vocabulario, abramos nuevas puertas en el laberinto del lenguaje.

profiláctico, ca.

(Del gr. προφυλακτικός; de προφυλάσσειν, prevenir, precaver).

1. adj. Med. Dicho de una persona o de una cosa: Que puede preservar de la enfermedad.

2. m. preservativo.

3. f. Med. Parte de la medicina que tiene por objeto la conservación de la salud y la preservación de la enfermedad.

moción.

(Del lat. motĭo, -ōnis).

1. f. Acción y efecto de mover o ser movido.

2. f. Alteración del ánimo.

3. f. Inspiración interior que Dios ocasiona en el alma.

4. f. Proposición que se hace o sugiere en una junta que delibera.

5. f. En las lenguas semíticas, nombre que se da a las vocales y a los signos que las representan.

6. f. Gram. Expresión del género mediante un cambio de terminación.

díscolo, la.

(Del lat. dyscŏlus, y este del gr. δύσκολος).

1. adj. Desobediente, que no se comporta con docilidad. U. t. c. s.

Fuente: www.rae.es

¿Cómo se impulsan los cohetes?

2009-02-04T07:31:00.000-08:00

Los cohetes se impulsan gracias a la aplicación de la tercera ley de Newton: Para cada acción ocurre siempre una reacción igual y opuesta (en cuanto a fuerza). Por ejemplo si tu ejerces un golpe fuerte sobre una pared, tu mano a su vez recibe un golpe de igual magnitud y de dirección opuesta al golpe recibido por la pared.
El ejemplo clásico para explicar como se impulsa un cohete es el de un globo que se desinfla. El aire que es expulsado del globo empuja al aire que esta fuera del globo y el aire que esta fuera del globo empuja al globo hacia adelante.
En el caso de un cohete que va en el espacio, no tenemos aire que empujar, pues esta en el vacío, pero el cohete al quemar combustible produce gases que a su vez son empujados por los nuevos gases que van siendo producidos al instante, produciendo un par de acción reacción entre el gas que fue producido y el que está siendo producido.

Referencias:

Artículo de www.selecciones.com
Ebook de Paul A. Tipler

Mis refranes favoritos

2009-01-18T19:29:00.000-08:00

Ningún viento es favorable a quien no sabe donde va.
Lo que no te mata, te hace más fuerte.
Cuando realmente deseas algo, todo el universo conspira para que puedas conseguirlo.
No hay mal que dure cien años.
Todo tiene solución, menos la muerte.
Al pobre no des el pescado. Enseñale a pescar.
Dicen que la fe mueve montañas, pero la dinamita ha demostrado ser más efectiva.
El mentiroso y el ladrón, siempre salen pillados.

mysql error 1045

2009-01-15T09:31:00.000-08:00

Hoy instalé mysql y obtuve un error al intentar acceder como root con los parametros -u root -p. La única forma de poder acceder a una base de datos era invocando mysql desde una consola con root.
Para solucionar el problema probe restablecer la contraseña de root, crear otro usuario, etc.
Sucedía una y otra vez lo siguiente:

mysql -u root -p
Enter password:
ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: YES)

Donde obviamente yo tipeaba la contraseña correcta.

Finalmente la forma de evitar el problema fue desinstalar mysql con la opción --purge para que remueva todos los ficheros de configuración, e instalarlo de nuevo.

apt-get remove --purge mysql-server-5.0
apt-get install mysql-server-5.0

Diferencia entre Voltaje y Amperaje

2009-01-06T07:23:00.000-08:00

La unidad de voltaje o potencial es el [volt] y la unidad del amperaje es el amperio [A].
Un volt = J/C, Un Joule por cada Coulomb, donde Joule es energía y Coulomb es carga.
Un Amperio = C/s, Un Coulomb por cada segundo.
Sabemos que la electricidad es el flujo de electrones, donde cada electrón aporta con una porción diminuta de carga.
Luego podríamos hacer la siguiente analogía: Imaginemos un ejercito de soldados, donde cada uno lleva una mochila con energía en su espalda.
La cantidad de soldados que pasa por unidad de tiempo es equivalente a los amperios. La cantidad de energía que lleva cada soldado en su mochila es correspondiente al voltaje o potencial.
Cuando un soldado pasa por un pantano pierde energía, entonces se gasta el voltaje, luego el pantano sería una resistencia.

pcmcia usb 2.0

2009-01-03T22:24:00.000-08:00

Me han regalado un disco duro externo Simpletech de 500 GB , un regalo muy útil, pues con 30 GB de disco poco podía tener.
Al conectar el disco al pcmcia de 4 puertos usb 2.0 que tengo instalado en mi IBM t23, este no era detectado ni encendía su luz, buscando un poco me percate de que para los dispositivos que requieren mayor potencia debo conectar un transformador a la tarjeta pcmcia.
Dejé el transformador que venía con la pcmcia y que nunca usé en Valparaíso; Estoy a 10 horas de distancia de allí.
Googleando un poco me encontré con que la tarjeta pcmcia necesita una fuente de 5V y por lo menos 2A para poder alimentar dispositivos que gastan más energía. Entonces se me ocurrió la idea de usar una vieja fuente AT para resolver el problema. Pues dispone de una salida de 5V (cable rojo) y 12V (cable amarillo).
Con mis pobres conocimientos de electrónica me armé de un cable con un jack dc que saqué de un eliminador de pilas y lo conecté a los cables rojo y negro de la fuente (cables de los conectores que se usan para alimentar discos duros y lectores de dvd). Además cómo la fuente no tenía el interruptor, uní los cables negro con cafe y blanco con azul para que al enchufar la fuente encienda.
Gracias a lo anterior he podido usar mi disco externo y ahorrarme comprar un transformador de 5V.
Algunas moralejas que aprendí acerca de fuentes de alimentación:
El voltaje de la fuente debe ser el mismo que el requerido por el circuito a alimentar.
El amperaje de la fuente debe ser mayor o igual al requerido por el circuito a alimentar, entre más amperaje tenga la fuente más útil puede resultar, pues puede entregar una mayor potencia y alimentar una mayor gama de aparatos.
Recordando lo que aprendí en física:

V = R*I (V = Volts, R=Ohms I=Amperios)
Si despejamos la corriente tenemos que:
I = V/R
La resistencia depende del circuito que estamos alimentando y el voltaje depende de la fuente de alimentación. Luego la corriente requerida por el circuito se ajusta al voltaje de la fuente y a la resistencia del circuito, por lo tanto solo importa que el voltaje de la fuente sea igual al requerido. Pues el circuito pide los amperios que necesita a la fuente.
Si la fuente tiene menos amperios que los necesitados por el circuito, no sirve, pues se puede estropear la fuente y el circuito no obtendrá los amperios
necesarios para su correcto funcionamiento.
P = V*I, viendo las unidades, se tienen J/c * c/s =J/s=Watts!
La tarjeta pcmcia requiere 5V y 2A, por lo tanto gasta 10 Watts.

Apagar pc speaker

2008-12-26T03:35:00.000-08:00

Para terminar para siempre con el beep en todas las aplicaciones!
Ese molesto sonido que se puede escuchar al apretar tab reiteradas veces en la consola o al intentar bajar cuando ya estas en la última linea de un documento en gedit.

Hay que descargar el modulo pcspkr.

Como root tipear:

modprobe -r pcspkr

Si se quiere que no se cargue más el modulo:

añadir la siguiente linea al fichero blacklist que esta en /etc/modprobe.d/

blacklist pcspkr

Un descanso para el oído.

De vuelta al mundo de los sueños

2008-12-18T06:28:00.001-08:00

Hace mucho tiempo que dejé de escribir, hoy decidí comenzar de nuevo.
Muchas cosas bellas puede hacer un ser humano, mundos desbordantes de fantasía puede llevar en su interior, pero aparte de él nadie puede saberlo; A menos que sus creaciones cobren vida a través de un hilo de palabras, cuan trozo de ADN da a un ser vivo sus cualidades, nuestras frases nos personifican en la mente de los demás.