jueves, 16 de octubre de 2014

Desplegando una imagen en OpenCV

Ya teniendo OpenCV instalado y funcionando, es hora de ponerlo a trabajar. La mejor manera es cargar una imagen. OpenCV soporta varios tipos de imagenes, entre ellas las mas usadas (jpg, bmp, png). El formato común que no soporta es gif, creo que es debido a cuestiones  de las patentes que tiene este formato de imagen que impiden que se use sin pagar regalias.

  OpenCV esta constituido de varios modulos como Core, Highgui, Features2d, video, imgproc, etc. El modulo que nos va a servir para cargar la imagen es highgui. Este modulo contiene el metodo imread que pasa una imagen a formato soportado por OpenCV ( imread ).

   El codigo es sencillo para realizar la accion:
//Imports al inicio de la clase
import org.opencv.core.*;
import org.opencv.imgproc.*;
import org.opencv.ml.*;
import org.opencv.utils.*;
import org.opencv.highgui.*;
import org.opencv.objdetect.*;
import org.opencv.video.*;

//Metodo de carga de imagen mediante OpenCV
//param: rutaImagenEnPC es la ruta completa o relativa de la imagen que deseas cargar
public static Mat loadImage(String rutaImagenEnPC){
//Definir la matriz que contendra la imagen
Mat imData = null;
//Llenar la matriz con la imagen, tambien se le dice a openCV que la carge como imagen de color
imData = Highgui.imread(rutaImagenEnPC, Highgui.CV_LOAD_IMAGE_COLOR);
         // Forzamos a OpenCV tenga los datos como bytes sin signo
    //(valores de 0 a 255 por pixel por capa)
imData.convertTo(imData, CvType.CV_8UC3);
return imData;
}

Para poder desplegar la imagen en Java contamos con la clase BufferedImage. Esta clase puede ser desplegada en una aplicacion grafica de java usando AWT o Swing.

  Para ello podemos usar la siguiente funcion:

     public static BufferedImage convertImage(Mat baseImage) {
        //Optenemos el ancho y alto de la imagen
        int width = baseImage.width();
        int height = baseImage.height();
        //creamos una instancia de BufferedImage y le pasamos el ancho y alto
        //mas el formato de la imagen que sera RGB
        BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        // Se extrae la clase grafica de BufferedImage, ya que es la que nos permititra
        //copiar la imagen de OpenCV a BufferedImage
        Graphics2D graphics = (Graphics2D) bi.getGraphics();
        //Por default ponemos la imagen en negro
        graphics.setBackground(new Color(255, 255, 255, 0));
       //Limpiamos toda la imagen, no es necesario, pero solo para estar seguros
        graphics.clearRect(0,0, (int)bi.getWidth(), (int)bi.getHeight());
        //Ahora recorremos cada pixel de la imagen
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                //Extraemos el pixel, el pixel consta de 3 valores R, G y B
                double[] data = baseImage.get(i, j);
                int r = 0;
                int g = 0;
                int b = 0;              
                r = (int) data[2];
                g = (int) data[1];
                b = (int) data[0];
                //Se procede a crear un valor entero que contenga los 3
                //componentes mezclado de la siguiente manera:
                //   00RRGGBB
                //La anterior es una representacion hexadecimal de un entero
                //en java, cada byte ocupa 2 digitos.
                //Un entero en java tiene 4 bytes, solo necesitamos 3 para
                //poner los valores de R, G y B, asi que el primer byte se queda sin valor
                //La siguiente operacion realiza el acomodo de los byte de R, G y B
                int col = (r << 16) | (g << 8) | b;
                //El entero con la informacion de los colores es pasada a la
                //clase BufferedImage
                bi.setRGB(j, i, col);
            }
        }      
        return bi;
    }


Para crear un componente que podemos añadir a un elemento JPanel o JFrame podemos usar la siguiente funcion:

public static ImagePane createImagePanel(BufferedImage img){
//Solo se necesita crear el ImagePanel con BufferedImage como parametro
     ImagePanel panel = new ImagePanel(CoreManager.bi);
      return panel;
}


La clase ImagePanel esta diseñada para poderse usar directamente en swing como cualquier panel. Voy a omitir el codigo que hace la interface grafica, ya que la mayoria de los editores de java que existen hacen la creacion de interfaces JFrame de manera automatica y permiten la creacion de la interface mediante el arraste de figuras desde una ventana del mismo editor. Aqui un ejemplo de esto  por   dairXTRM :





Despues de crear tu interface grafica puedes usar los metodos que publico para visualiza la imagen de OpenCV en Java

lunes, 22 de septiembre de 2014

OpenCV en java

OpenCV es una serie de librerias desarrolladas en un principio por intel para demostrar el poder de sus procesadores. Esto implicaba que solo funcionaba en procesadores de intel. Hoy en dia estas librerias son opensources y soportan diversos tipos de procesadores.


 OpenCV esta desarrolladpo en C/C++, pero afortunadamente existen wrappers (puentes o envoltorios) para diversos lenguajes. Por ello se pueden usar las librerias de OpenCV en Pyton, C#, o Java.

Setup

Para poder usar OpenCV en Java necesitamos bajar el paquete de librerias de OpenCV . En el sitio de OpenCV solo tenemos que bajar el pequete que corresponda a nuestro sistema. Este paquete pesa unos cuantos cientos de megas, así que necesitamos espacio en la computadora. En mi caso bajo un ejecutable para windows, que solo descomprime el contenido del archivo en una carpeta dada.

  Una vez que se extrajo el contenido, hay que ir a la carpeta donde se descomprimieron los datos.

  De la carpeta se requiere buscar los dll's y el jar que sirve de wrapper(usa JNI para hacer el enlace). Para poder saber que dll's son los que van a funcionar en windows, se necesita saber si nuestro sistema es de 32 o 64 bits. Esto se puede ver siguiendo estas indicaciones.

  Ya sabiendo el tipo de sistema elegimos la carpetas de donde tomaremos los dll's.

  Si es de 32 bits opencv\build\x86\
  Si es de 64 bits opencv\build\x64\


Ahi dentro debemos de ver una serie de carpetas. Estas carpetas contienen cada una los dll's, por lo que debemos de elegir la carpeta adecuada. El nombre de cada carpea se refiere a la version del compilador de C con el cual fueron creadas las librerias. Por ello se debe de elegir aquella carpeta con el compilado que pueda correr en nuestro equipo. Para saber esto, se debe de saber si contamos con algun VisualC runtime (librerias para ejecutar programas de visualC).

 Si no tenemos el runtime o no sabemos si la maquina lo tiene, podemos descargarlo de la pagina de microsoft , en esta pagina esta la ultima version y las anteriores del runtime. La carpeta que contiene los dll's es nombrada usando la siguiente norma: vcXX, donde XX corresponde a la version de las librerias de Visual C, asi de esta manera sabras cuales runtimes puedes instalar para que funcione OpenCV.

Despues de instalar el runtime o verificar la version que tenemos, entramos a la carpeta que corresponde y de ahi a la carpeta bin. En mi caso tengo sistema de 64 bits y tengo instalado el runtime de visualC version 12, Asi que mi ruta de dll's es 

opencv\build\x64\vc12\bin

Dentro vas a encontrar varias dll's, no se necesitan todas. Creo que las que tienen nombre xxxxxd.dll son para realizar debug, y no se necesitan. Ademas hay librerias especializadas en ciertas acciones que no se suelen usar y esas pueden omitirse. Pero si tenemos espacio, es preferible usar lo mas que podamos, por si en dado caso usamos alguna funcionalidad extra de OpenCV.

  Para instalar los dll's en nuestro equipo, basta con copiar los dll dentro de la carpeta Window\System32  o copiar los dll a donde va a correr el programa. Yo prefiero hacer la primera acción para evitar copiar dll's en todo proyecto que use OpenCV.

 Aparte de estos dll's, hay un dll adicional que se debe de copiar, este lo encuentras en 

opencv\build\java\x64  si tienes sistema de 64 bits
opencv\build\java\x86  si tienes sistema de 32 bits

Dentro esta un solo dll, este dll se copia en el mismo sitio donde se copiaron las otras dll's

una vez realizado esto, solo falta usar el jar que sirve de wrapper, este se encuentra en \opencv\build\java.

Netbeans setup

Para realizar el setup en netbeans se hace un proceso similar al que se realizo para registrar OpenGL, solo que el nombre de la libreria seria bueno cambiarlo a algo como OpenCV y solo usamos el jar que encontramos en \opencv\build\java.


OpenCV Hola mundo

Una vez agregada la libreria de opencv en algun proyecto (puede ser nuevo o uno ya existente, en mi caso el mismo que use para opengl).



En una clase nueva TestOpenCV, agregamos el siguiente codigo

import org.opencv.core.*;
import org.opencv.imgproc.*;
import org.opencv.ml.*;
import org.opencv.utils.*;
import org.opencv.highgui.*;
import org.opencv.objdetect.*;
import org.opencv.video.*;

public class TestOpenCV{    
    public static void main(String[] args) {
        //Preguntamos el numero de la version
        System.out.println("Bienvenido a OpenCV " + Core.VERSION);  
        //Cargamos las librerias
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
        //Obtenemos mediante OpenCV el numero de cpu's
        System.out.println("Numero de CPU's: " + Core.getNumberOfCPUs());
    }    
}

Esto si realizamos lo anterior adecuadamente, nos dara como salida algo como:

Bienvenido a OpenCV X.X.X.X
Numero de CPU's: X

La X son solo para indicar algun numero. lo mas importante es que no de be de darnos error. Si vemos algo similar, en hora buena, ya esta funcionando lo basico de OpenCV. 
 

sábado, 6 de septiembre de 2014

Pruebas con JOGL-OpenGL


 Crear el Hola Mundo

  No se puede empezar a hacer algo en un nuevo programa o librería sin antes realizar el hola mundo. En caso deJOGL- OpenGL, en realidad no vamos a escribir algo, sino dibujar algo. En las paginas de tutoriales y demos sugieren empezar con el dibujo de un triángulo multicolor.

  JOGL-OpenGL funciona de forma  de una maquina de estados, es decir que es un proceso que pasar por una serie de etapas completando ciclos. Esto no pone una limitante, no podemos dibujar con JOGL-openGL cuando lo deseamos, sino que debemos de esperar al momento en que JOGL-OpenGL llega a la etapa o fase donde escribe en el buffer gráfico.

  Debido a lo anterior debemos de espera el momento oportuno para dar la indicación a JOGL-OpenGL a dibujar nuestro contenido. Para nuestra fortuna, OpenGL-JOGL nos proporciona una implementación de un listener (notificado de eventos) de las etapas que recorre OpenGL-JOGL.

Etapas o fases en JOGL



La primera etapa es inicio (init), en la cual se hace la inicialización de la libraría, realmente no se usa para el ejercicio del hola mundo y probablemente se usa para modificar la manera en como se debe de comportar OpenGL.

Las siguientes etapas son donde realmente se debe de realizar el el dibujado de los gráficos. La primera de ellas es  Display, es cuando OpenGL esta listo para dibujar en el buffer gráfico en la superficie o ventana asignada para este proposito. Le llamo buffer a aquel espacio en memoria destinado a almacenar la información gráfica que se mostrara en pantalla. Por esto, es en esta etapa cuando debemos de dibujar nuestro contenido.

La etapa de reshape (modificar), siguiere que es cuando OpenGL ha detectado alguna modificacion de la ventana o lugar donde imprime el buffer gráfico. Esta modificacion puede ser el cambio de tamaño de la ventana.

No voy entrar en detalles sobre OpenGL, ya que solo necesito que sirva para escribir un contenido grafico.

Setup


  Lo primero que se debe de hacer es ir al sitio de JOGL y descargar la version actual, archivo
(jogamp-all-platforms.7z)
Este archivo se abre con el programa 7-Zip, que se consigue gratuitamente. Dentro están contenidos librerías para diferentes sistemas operativos así como los jar que interactuán con al librerías. También existen una colección de jars que se les conoce como jars nativos. Estos jars contienen en su interior las librerías nativas para usar OpenGL.

En mi caso uso Windows y Netbeans. Después de bajar el archivo extraigo de este los archivos:

  • gluegen-rt-natives-windows-amd64.jar
  • jogl-all-natives-windows-amd64.jar
  • jogl-all.jar
  • gluegen-rt.jar
  • gluegen.jar
Las dos primeras son jars nativos con las librerías dll para interactuar con OpenGL. El resto son librerías de java que se encargan de la interacción con los jars nativos y crean la estructura de objetos java para poder trabajar con los gráficos.
Ahora se debe de registrar las librerías en Netbeans. Se da click derecho al proyecto y se selecciona Properties.

Se selecciona la sección de Libraries, y se presiona Add Library 


Aqui se presiona Create



Se le da un nombre se presiona OK

En la siguiente ventana se añaden los jars antes mencionados

Presionamos OK en las siguientes ventanas y ya tenemos registrado JOGL-OpenCV en nuestro proyecto.


Se añade un jframe al proyecto, se puede usar el nombre  y el paquete que se quiera


Añadimos un Panel y un botón

En el código, depués de la clase principal añadimos la siguiente clase interna (no es buena practica, pero, esto es solo un demo). Se deben de arreglas los import o dependencias

  
 class SimpleScene implements GLEventListener {    
   private double theta = 0.0f; // rotational angle    
   @Override   
   public void init(GLAutoDrawable drawable) {    
   }   
   @Override   
   public void dispose(GLAutoDrawable drawable) {   
   }   
 //Este metodo se ejecuta cuando OpenGL esta listo para dibujar  
   @Override   
   public void display(GLAutoDrawable drawable) {   
    update(); //Se actualiza el angulo de dibujo del triangulo  
   render(drawable); // Se dibuja el triangulo  
   }   
 //Este metodo modifica el angulo del seno y coseno, que hacen que gire el triangulo  
   private void update() {   
   theta += 0.01;   
  }   
  private void render(GLAutoDrawable drawable) {   
 // El parametro drawable que recibimos, representa el espacio de dibujo listo para usarse  
 // de drawable se obtiene GL que la representacion de OpenGL, para despues indicar la version   
 //de OpenGL que se quiere usar, esto al usar un objeto especifico a la version.   
 //Se usa la dos por tratar de abarcar una version soportada por  
 //la mayoria de las tarjetas graficas, pero si se desea se puede usar alguna otra version  
   GL2 gl = drawable.getGL().getGL2();   
   gl.glClear(GL.GL_COLOR_BUFFER_BIT); // Se limpia el espacio de dibujo   
   gl.glLoadIdentity();     // Se resetea la matriz usada para la vista de los gráficos     
   // Calculo del seno y coseno para la animacion del triangulo   
    float sine = (float)Math.sin(theta);   
    float cosine = (float)Math.cos(theta);    
   // SE empieza a dibujar el triangulo   
   gl.glBegin(GL.GL_TRIANGLES);   
   gl.glColor3f(1, 0, 0); //Esto representa el color en estilo RGB, en esta caso rojo  
   gl.glVertex2d(-cosine, -cosine); //Esta es la coordenada de una orilla de triangulo  
   gl.glColor3f(0, 1, 0); //Esto representa el color en estilo RGB, en esta caso verde  
   gl.glVertex2f(0, cosine); //segunda orilla del triangulo  
   gl.glColor3f(0, 0, 1); //Esto representa el color en estilo RGB, en esta caso azul  
   gl.glVertex2f(sine, -sine); //tercera orilla del triangulo  
   gl.glEnd(); // se termina la animacion  
  }   
   @Override   
   public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {     
   }   
  }   

La clase anterior esta preparada para interactuar con las etapas de la máquina de estado de OpenGL, por eso se usa la interface GLEventListener.  Dentro del código hay documentación sobre lo que sucede en el código.

Se crea un método para la acción de pulsado del botón.



en el método que se creo se añade el siguiente código


 private void jButton1MouseClicked(java.awt.event.MouseEvent evt) {  
 //Se obtiene el tipo de OpenGL del equipo  
 GLProfile glp = GLProfile.getDefault();  
 //Se ven las caracteristicas del openGL del equipo  
 GLCapabilities caps = new GLCapabilities(glp);  
 //Se crea un espacio para que se pueda dibujar  
 javax.media.opengl.awt.GLCanvas canvas = new javax.media.opengl.awt.GLCanvas(caps);  
 //Se añade un listener para tener interaccion con lase tapas de la máquina de estado de OpenGL  
 canvas.addGLEventListener(new SimpleScene());  
 //Se crea una rutina o animador, que hace que el espacio de dibujo se integre en la máquina de estados de OpenGL  
 //Se puede especificar con este animador cada cuando se va a dibujar algo en el espacio, de esta manera se pueden realizar animaciones  
 //canvas –lugar de dibujo, 60- son los cuadros por segundo, true – ajustar temporizador  
 FPSAnimator animator = new FPSAnimator(canvas, 60, true);  
 //Se añade el espacio de dibujo OpenGL al panel  
 this.jPanel1.add(canvas);  
 //Se ajusta el espacio al tamaño del frame  
 canvas.setBounds(0,0,this.jPanel1.getWidth(),this.jPanel1.getHeight());  
 //Se inicia la rutina de animacion  
 animator.start();  
 }  


Cuando se copia el código Netbeans nos debe de ayudar a solucionar los problemas de referencias o imports.

Despues de solucionar los problemas, solo se debe de presionar shift+F6 y debemos de ver algo como lo siguiente, donde el triangulo esta girando:


viernes, 5 de septiembre de 2014

OpenCV conce a OpenGL mediante Java

OpenCV


 Opencv en un conjunto de librerías para el manejo y procesamiento de gráficos. Esta librería esta desarrollada originalmente en C/C++, pero hay implementaciones de estas para varios lenguajes, incluyendo Java. Aunque ciertamente no es una implementación como tal, es mas bien un wraper al compilado resultante del código  de C/C++. Este wraper  en java es realizado por medio de JNI (Java Native interface)

  Enlace: OpenCv


OpenGL

  OpenGL es un conjunto de librerías que permiten una interacción con mejor desempeño hacia los dispositivos gráficos, así como manejo de entornos tridimensionales. Esto al igual que OpenCV cuanta con wrapers para diversos lenguajes. a diferencia de OpenCV, los encargados de mantener los wrapers, no son las mismas gente que desarrollan las librerías, así que no se debe de esperar una compatibilidad del 100% en esta librería. El wraper mas usado de java es JOGL, este tiene soporte hasta el momento para la versión 4.1 de openGL.

Enlaces: OpenGl

               JOGL


Trabajando con OpenCV
 
  La unidad principal de trabajo de OpenCV es la estructura llamada Mat, la cual encapsula la representación de una imagen. Cuando se maneja OpenCV en C/C++, se puede recurrir a unas ventanas existentes dentro de las librearías de OpenCV. Esta ventanas no estan presentes dentro del wraper de Java.

  La manera en que se puede visualizar la imagen contenida dentro de una estructura Mat, se debe de recurrir a la oferta gráfica dentro de Java. En esta oferta esta AWT y Swing.

  Aunque en las ultimas versiones de java se ha mejorado el rendimiento de las implementaciones de las librerías gráficas, esto aun queda algo abajo de las implementaciones hechas en C/C++. Parte del problema es la cantidad y tipo de objetos que se deben de crear y manipular. Esto hace trabajar bastante al Garbage Collector de java y por ende cause un deterioro en el desempeño.

  Una solución ideal seria extraer directamente el contenido de la imagen como un arreglo de bytes e inyectarlo directamente al buffer de video. Esto teóricamente mejoraría el desempeño de la representación gráfica de la estructura Mat dentro de java.

  El problema anterior puede ser resuelta si se aprovecha el refinamiento del manejo gráfico conseguido por las librerías de OpenGL. Lo anterior es posible debido al wraper existente para java. Próximamente estaré reportando los hallazgos realizados al integrar ambos wrapers dentro de Java.

martes, 21 de julio de 2009

Netbeans+Qt


He estado navegando por varios sitios y tutoriales, pero ninguno es capaz de explicar a detalle como es el proceso de la integracion de Qt y Netbeans en entorno windows. Por lo anterior voy a dar unos tips sobre como fue este proceso para mi.

Netbeans es un IDE el cual ha estado creciendo bastante en los ultimos años, esto debido a su facilidad de uso y numerosos API's que soporta. Este IDE esta diseñado escencialmente para programar en lenguaje Java, pero se le han incorporado varios plug-ins para poder soportar otros lenguajes como C/C++, phyton, PHP.

Qt es una colleccion de librerias principalmente graficas realizadas para C++. Qt estaba diseñada principalmente para Linux (es la base del sistema KDE), pero esta ha sido portada a diversas plataformas en las cuales esta windows. El sitio de Qt es este.

Primero es prudente instalar algunos requisitos previos:

*-Java JDK de preferencia la version 6 con el ultimo update (al escribir esto es el update 14)

*-Compilador de C. En este caso se puede usar el MinGW el cual viene como instalarse en esta liga.Una opcion que yo suelo usar es instalar el Dev-CPP y usar el compilador que este trea, para ello hay que bajar este archivo: Dev-C++ 5.0 beta 9.2 (4.9.9.2) (9.0 MB) with Mingw/GCC 3.4.2 . La opcion más recomendada es usar el compiador que viene junto con el Qt.

*-Ambiente y librerias de Qt. Estas se pueden descargar de esta liga, aqui hay que seleccionar la opcion "LPGL/Free" y bajar el SDK para windows. La instalacion por lo general queda en C:\Qt, dentro de este directorio esta un compilador MinGW esta es la mejor opcionpara compilar el codigo de Qt.

IMPORTANTE.- una vez instalado Qt hay que agregar la ruta de donde esta instalado a la variable de ambiente PATH.

Para hace esto vamos al escritorio de nuestra computadora y damos click derecho en el icono de "Mi computadora" o "My Computer".


Del menu que aparece seleccionamos "propiedades".
En la ventana que se abre se seleeciona la pestaña que dice avanzado


y ahi damos click en el boton de "variables de ambiente".



Dentro del la ventana que aparece buscamos la variable Path



Damos doble click sobre la variable y agregamos al final del valor de la variable la ruta donde esta instalado el qt, por lo general sera algo como "C:\Qt\2009.03\qt\bin".



Se da ok a todas las ventanas y ahora esta registrado Qt.

*- El ultimo requerimento viene de algunos problemas que existen con un ejecutable llamado Make. Por lo que se tienen que instalar unas utilerias llamadas MSYS estan en esta liga. Esta utilerias ayudan a netbeans durante la compilacion y la ejecucion del codigo.

Despues es bajar Netbeans, la version que uso es la 6.7 (es mejor usar la version mas nueva, ya que corrigen varios detalles). La direccion para bajar lo es : esta es mejor seleccionar la version con todos los plugins. La instalacion de Netbean solo pide cual JDK va a usar, solo deben de revisar que este seleccionado el que se instalo (debe ser JDK version 6).

Ya instalado iniciamos netbeans.

Esto suele tardar un poco. Dentro de netbean creamos un nuevo proyecto "File>New Project" y seleccionamos una aplicacionde "C/C++ Qt Application"


se presiona en el boton de Next y se sconfiguran datos como nombre del proyecto y carpeta donde guardarlo para finalmente presionar Finish.


Despues de creado el proyecto nos vamos a "Tool>Options", esto abre una ventana en cual presionamos el icono que dice C/C++



Y damos click en "Add" (ignoren lo que dice de gcc en la imagen), en la ventana seleccionamos la ruta donde esta instalado el minGW de Qt (para mi la ruta es "C:\Qt\2009.03\mingw\bin"), y automaticamente se detecta el tipo de compilador, y ya podemos dar click en Ok.



Despues se ve una pantalla similar a la imagen donde se ve que ya tomo las rutas de lo ejecutables que se necesitan




sin cerrar la ventana de cofiguarcion e C/C++ procedemos a añadir los archivos que tienen los encabezados de las librerias, asi netbean nos dara ayuda almomento de programar :) . Esto se hace en la pestaña que dice "code asistance". En la opcion de de Tool Collection debemos fijarnos que diga MinGW, que es el compilador que registramos de Qt. Depues vemos un poco mas abajo que hay dos pestañas, una para C Compiler y otra para C++ Compiler, como Qt es orientado a objetos, entonces seleccionamos la pestaña de C++ Compiler. Dentro de esta pestaña debemo de añadir los include de Qt para mi caso estan en "C:\Qt\2009.03\qt\include"

ya con esto configurado damos click en ok para cerrar la ventana. A continuacion damos click derecho en el panel de la izquierda donde esta el proyecto de Qt que creamos, y seleccionamos "properties"



Aqui seleccionamos la opcion de build y debemos de asegurarnos de que en "Tools Collections" diga MinGW

presionamos apply y despues ok.

Y Listo ahora Netbeans esta configurado para poder realizar el tutorial que esta en la pagina oficial . Lo que sigue ya no voy a escribir mas, por seria repetir lo que esta en la pagina.

lunes, 22 de junio de 2009

equilibrio con bioloid

En este vido se puede aprecia parte de mi trabajo de tesis, el cual trata sobre el equilibrio en robots humanoides :)