Captura de imagenes 3D

Modo de captura.

En este documento explicaremos como funciona el código para la captura de imágenes en 3D, guardarlas en un archivo .pcd y su representación gráfica para su visualización a través de librería VTK.

#include <iostream>
#include <pcl/io/pcd_io.h>
#include <pcl/point_types.h>
#include <pcl/io/openni_grabber.h>
#include <pcl/visualization/cloud_viewer.h>
#include <string>
#include <sstream>
#include<pcl/common/time.h> //este include para compilar en pcl1.7

#ifdef _WIN32
# define sleep(x) Sleep((x)*1000)
#endif

 class SimpleOpenNIViewer
 {
   public:
     SimpleOpenNIViewer () : viewer ("PCL OpenNI Viewer") {}

     void cloud_cb_ (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud)
     {

static unsigned count = 0;
static unsigned int pcd_count = 1;
static double last = pcl::getTime ();
if (++count == 30)
{
double now = pcl::getTime ();
std::cout << "distance of center pixel :" << cloud->points [(cloud->width >> 1) * (cloud->height + 1)].z << " mm. Average framerate: " << double(count)/double(now - last) << " Hz" << std::endl;
count = 0;
last = now;


std::string name("nube_");
std::ostringstream number;
number << pcd_count;
name.append(number.str());
name.append(".pcd");
pcl::io::savePCDFileASCII (name, *cloud);
std::cout<<"Saved PCD: "<< name << endl;
pcd_count++;
}
       if (!viewer.wasStopped())
         viewer.showCloud (cloud);
     }

     void run ()
     {
       pcl::Grabber* interface = new pcl::OpenNIGrabber();

       boost::function<void (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr&)> f =
         boost::bind (&SimpleOpenNIViewer::cloud_cb_, this, _1);

       interface->registerCallback (f);

       interface->start ();

       while (!viewer.wasStopped())
       {
         boost::this_thread::sleep (boost::posix_time::seconds (1));
       }

       interface->stop ();
     }

     pcl::visualization::CloudViewer viewer;
 };

 int main ()
 {
   SimpleOpenNIViewer v;
   v.run ();
   return 0;
 }

En el encabezado tenemos:


#include <iostream>
#include <pcl/io/pcd_io.h>
#include <pcl/point_types.h>
#include <pcl/io/openni_grabber.h>
#include <pcl/visualization/cloud_viewer.h>
#include <string>
#include <sstream>

Donde vemos que utilizamos los paquetes io y visualization de la librería PCL, el paquete de openni_grabber.h, servirá para comunicarse con el sensor de captura y convertir los datos en el formato que utiliza PCL, luego el pcd_io.h  servirá para operaciones de almacenamiento de la nube en archivos. Para visualizar la nube tenemos pcl/visualization/cloud_viewer.h. El resto de las librerías servirá para operaciones y declaración de variables sencillas.Es importante recordar que debemos añadir
#include<pcl/common/time.h> en el encabezado solo cuando compilemos con la nueva versión 1.7 en adelante.

Luego se declaran dos funciones dentro de una clase, la clase es llamada SimpleOpenNIViewer donde tiene dos funciones de llamada en las cuales se realizan las operaciones de adquisición de datos y almacenamiento en archivos.

Empecemos a ver lo que ocurre desde el cuerpo principal del código:

  int main ()
 {
   SimpleOpenNIViewer v;
   v.run ();
   return 0;
 }

Como vemos es un código muy corto en el cual primero se declara que vamos a realizar llamadas a la clase  objetos de SimpleOpenNIViewer lo declaramos como "v" y luego llamamos a la función run().

Ahora vamos a ver que sucede en la función run(), que está definida con el código:

  void run ()
     {
       pcl::Grabber* interface = new pcl::OpenNIGrabber();

       boost::function<void (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr&)> f =
         boost::bind (&SimpleOpenNIViewer::cloud_cb_, this, _1);

       interface->registerCallback (f);
       interface->start ();
       while (!viewer.wasStopped())
       {
         boost::this_thread::sleep (boost::posix_time::seconds (1));
       }
       interface->stop ();
     }
    
En esta función primero se declara que vamos a utilizar funciones de pcl::Grabber y la declaramos como puntero.Luego con ayuda de la biblioteca boost declaramos los datos que se utilizaran para entregar los datos de recogida de las funciones de Grabber.  Finalmente vez declarados los datos que se utilizaran en la función, llamamos al sensor y entramos en el bucle hasta que se detenga por algún tipo de desbordamiento definido, y cada vez que entre ha este se detendrá un segundo, para refrescar la imagen.

Como vemos cada vez que entramos en el bucle no salimos por desbordamiento de variables ya explicadas, si no por la función viewer que no se ha ha explicado, pero es una etiqueta publica que esta descrita antes de entrar al cuerpo principal del código.

Luego que hemos activado la zona de visualizacion y activacion de adquisicion de la imagen, vamos a ver como funciona el algoritmo que guarda en un archivo pcd, y este esta enmascrado de la siguiente manera:

boost::function<void (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr&)> f =
         boost::bind (&SimpleOpenNIViewer::cloud_cb_, this, _1);

Donde la función enmascarada es llamada  cloud_cb_ el cual esta dentro de la clase definida en nuestro código:

  void cloud_cb_ (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud)
     {

static unsigned count = 0;
static unsigned int pcd_count = 1;
static double last = pcl::getTime ();
if (++count == 30)
{
double now = pcl::getTime ();
std::cout << "distance of center pixel :" << cloud->points [(cloud->width >> 1) * (cloud->height + 1)].z << " mm. Average framerate: " << double(count)/double(now - last) << " Hz" << std::endl;
count = 0;
last = now;


std::string name("nube_");
std::ostringstream number;
number << pcd_count;
name.append(number.str());
name.append(".pcd");
pcl::io::savePCDFileASCII (name, *cloud);
std::cout<<"Saved PCD: "<< name << endl;
pcd_count++;
}
       if (!viewer.wasStopped())
         viewer.showCloud (cloud);
     } 
 
 Como vemos se definen variables estáticas, para que no desaparezca la zona de memoria cada vez que salimos de la función, estas variables nos servirán para formar la cadena de caracteres que dará nombre al archivo y para definir el tiempo que tarda cada imagen ser llamada.

Luego se hace un pequeño calculo de la distancia del pixel centrar y lo que hemos tardado en refrescarlo.
Posteriormente montamos la cadena de caracteres que formará la nube, que guardaremos mediante la expresión: 

pcl::io::savePCDFileASCII (name, *cloud);

Por ultimo refrescamos los datos de la imagen que veremos mediantela consola de VTK.

Para poder compilar este archivo debemos de seguir las intruciones que se han dado en la entrada  como usar pcl en su proyecto.

Consideraciones a la hora de capturar imágenes

Antes de empezar a correr el ejecutable debemos tener un dispositivo de captura dee imagenes 3D, los que se han probado que funcionan son los siguiente:

- Microsoft Kinect.

-Asus XTionPRO.

 - PSDK Reference.
-Fuji w3 3D.

 -Minolta Range 5 3D.

-

-Trimble MX8.

 -Otros sensores de tipo láser ,estéreos o luz estructurada.

Los errores de medida serán generados por la tecnología y no por el algoritmos.
Cuando tomemos imágenes con la kinect debemos de tener en cuenta que tiene una precisión limitada de 1cm de error para distancias comprendidas entre 1 a 7 metros.

La kinect genera una imagen de 640x480, generando píxeles con coordenadas y colores, cuando las coordenadas generan error las almacena como NaN , esto sucede en bordes o en distancias que no es capaz de llegar(sup a 7 metros). 

Como usar PCL en su proyecto

Explicaremos los pasos que debemos hacer para emplear la biblioteca de Point Cloud Library.

Antes de empezar debemos estar seguros de haber descargado e instalado la biblioteca PCL.

Ajustes del proyecto

Una vez tengamos el código preparado para ser compilado, lo guardaremos en una carpeta en la cual crearemos un archivo nuevo llamado CMakeLists.txt, si nuestro código se llama codigo.cpp debemos copiar en el nuevo archivo de la siguiente manera:
 __________________________________________________

cmake_minimum_required(VERSION 2.8 FATAL_ERROR)

project(codigo)

find_package(PCL 1.6 REQUIRED)

include_directories(${PCL_INCLUDE_DIRS})
link_directories(${PCL_LIBRARY_DIRS})
add_definitions(${PCL_DEFINITIONS})

add_executable (codigo codigo.cpp)
target_link_libraries (codigo ${PCL_LIBRARIES}) 

____________________________________________________

Explicación

Explicamos a continuación lo que hemos hecho en cada una de las líneas.

cmake_minimum_required(VERSION 2.8 FATAL_ERROR)

En esta linea indicamos la versión de cmake que necesitamos, aunque nosotros hayamos solicitado una versión 2.8 si el proyecto es muy básico sera suficiente con una versión 2.6. aun así es necesario especificar la versión que requerimos para compilar.

project(codigo)

Aquí indicamos el nombre del proyecto, y también nos da la posibilidad de indicar a cmake el directorio de origen (MY_GRAND_PROJECT_SOURCE_DIR) y el directorio desde el que se invoca cmake (MY_GRAND_PROJECT_BINARY_DIR).

find_package(PCL 1.6 REQUIRED)

  
 Luego solicitamos los paquetes de PCL que necesitamos, si no indicamos ninguno por defecto los tomara todos, pero podríamos solicitar uno solo añadiendo al final los paquetes que deseamos utilizar, si además añadimos REQUIRED debemos  tener en cuenta que si no esta la versión de PCL que indicamos fallará la compilación.

include_directories(${PCL_INCLUDE_DIRS})
link_directories(${PCL_LIBRARY_DIRS})
add_definitions(${PCL_DEFINITIONS})

Cuando estamos en los paquetes de PCL, teneos las siguientes variables:

• PCL_FOUND: activado a 1si hemos encontrado PCL, de lo contrario desactivado.
• PCL_INCLUDE_DIRS: ajuste  de las rutas de acceso a las cabeceras y encabezados de dependencia de PCL.
• PCL_LIBRARIES: establecemos los  archivos de cabecera y encabezados instalados en la biblioteca  de PCL.
• PCL_LIBRARY_DIRS: establecemos las rutas de acceso de la biblioteca PCL y otras dependencias.
• PCL_VERSION: la versión de PCL que hemos encontrado.
•  PCL_COMPONENTS: lista  de todos los componentes disponibles.
• PCL_DEFINITIONS: enumera las definiciones de preprocesador necesarios y opciones del compilador.

 Para que cmake reconozca  los encabezados externos que incluimos en nuestro proyecto, es necesario utilizar include_directories (macro). En nuestros caso PCL_INCLUDE_DIRS , contiene exactamente lo que necesitamos, por lo tanto le pedimos cmake  buscar los caminos que contiene un encabezado potencialmente incluido.

add_executable (codigo codigo.cpp)

Aquí tratamos de que cmake, a partir del código inicial que es el archivo codigo.cpp en nuestro caso, cree un archivo ejecutable que el propio cmake se encargará de crear la extensión que necesaria  según en el sistema operativo, para window .exe y para UNIX vacío.

target_link_libraries (codigo ${PCL_LIBRARIES}) 

El ejecutable que estamos construyendo hace llamada a funciones de PCL. Hasta ahora, sólo hemos incluido los encabezados PCL por lo que el compilador tiene los métodos que estamos llamando. También tenemos que hacer que el enlazador conozca las bibliotecas que se están incluyendo. Como se dijo antes ,se encontró las referencias a la biblioteca PCL usando las variables  PCL_LIBRARIES, todo lo que queda es para activar la operación de enlace haciendo la llamada target_link_libraries (macro). PCLConfig.cmake utiliza una característica especial CMake llamado "EXPORT", que permite el uso de proyectos de objetivos de otros como si ellos mismos lo construyeran. Cuando se utiliza este tipo de objetivos que se llaman metas y actúa igual que toda otra meta importada.

Compilación del proyecto.

Si utilizamos la consola de Linux, lo normal es utilizar Ubuntu, tendremos que proceder  de la siguiente manera:

• Entramos en el archivo donde tenemos el proyecto (codigo.cpp) y el archivo CMakeLists.txt mediante el comando $cd ruta/carpeta
• Creamos una carpeta nueva cualquier nombre sirve en nuestro caso construcion con el comando $cd mkdir contrucion
• Luego entramos en la carpeta que hemos creado con el siguiente comando      $cd construcion
• Luego preparamos la carpeta con los archivos necesarios para la compilación del proyecto mediante el comando $cmake ..

Por tanto en consola tendremos que proceder de la siguiente manera:

$cd ruta/carpeta
$cd mkdir contrucion
$cd construcion
$cmake ..

Si tenemos todo bien nos deberá de aparecer por consola lo siguiente:
-- The C compiler identification is GNU
-- The CXX compiler identification is GNU
-- Check for working C compiler: /usr/bin/gcc
-- Check for working C compiler: /usr/bin/gcc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- checking for module 'eigen3'
--   found eigen3, version 3.0.5
-- Found eigen: /usr/include/eigen3
-- Boost version: 1.46.1
-- Found the following Boost libraries:
--   system
--   filesystem
--   thread
--   date_time
--   iostreams
-- checking for module 'flann'
--   found flann, version 1.7.1
-- Found Flann: /opt/ros/groovy/lib/libflann_cpp_s.a
-- checking for module 'openni-dev'
--   found openni-dev, version 1.5.2.23~precise
-- Found openni: /usr/lib/libOpenNI.so
-- Found libusb-1.0: /usr/include
-- Found qhull: /usr/lib/libqhull.so
-- looking for PCL_COMMON
-- Found PCL_COMMON: /opt/ros/groovy/lib/libpcl_common.so
-- looking for PCL_KDTREE
-- Found PCL_KDTREE: /opt/ros/groovy/lib/libpcl_kdtree.so
-- looking for PCL_OCTREE
-- Found PCL_OCTREE: /opt/ros/groovy/lib/libpcl_octree.so
-- looking for PCL_SEARCH
-- Found PCL_SEARCH: /opt/ros/groovy/lib/libpcl_search.so
-- looking for PCL_SAMPLE_CONSENSUS
-- Found PCL_SAMPLE_CONSENSUS: /opt/ros/groovy/lib/libpcl_sample_consensus.so
-- looking for PCL_IO
-- Found PCL_IO: /opt/ros/groovy/lib/libpcl_io.so
-- looking for PCL_GEOMETRY
-- Found PCL_GEOMETRY: /opt/ros/groovy/include/pcl-1.6
-- looking for PCL_FEATURES
-- Found PCL_FEATURES: /opt/ros/groovy/lib/libpcl_features.so
-- looking for PCL_FILTERS
.
.
.
-- Configuring done
-- Generating done
-- Build files have been written to: /ruta/construcion

Luego para compilar el archivo debemos de ejecutar el siguiente comando en la consola:

$make

donde nos deberá aparecer los errores si los tenemos y por tanto no se producirá el ejecutable, o si toda esta correcto, nos deberá de aparecer las siguientes lineas:

Scanning dependencies of target codigo
[100%] Building CXX object CMakeFiles/cubo.dir/codigo.cpp.o
Linking CXX executable codigo
[100%] Built target codigo

Finalmente para poder utilizar el  proyecto que hemos compilado debemos ejecutar de la siguiente  manera:

$./codigo

Luego procederá según hayamos escrito el código.

Para el caso de window no procedemos por consola, por que tenemos que indicar donde y que archivos vamos a introducir, teniendo en cuenta que debemos introducir el archivo CMakeLists.txt como source code y en binary el código que tenemos en Visual Studio.




fuentes:

Tutorial para generar y visualizar una nube de puntos

En este tutorial explicaremos las diferentes posibilidades para generar un archivo en el que tengamos una nube de puntos.

Como se ha explicado en artículos anteriores, la librería trabaja con un formato de extensión ".pcd". Para poder generar un archivo de este tipo tenemos dos posibilidades :

-Algoritmo: realizando un código mediante el cual se generen puntos que luego serán guardados en un archivo con la extensión. 

-Captura: mediante un dispositivo de captura de imágenes 3D, podemos tomar una nube de puntos y luego guardarlos en un archivo.Este método lo desarrollaremos en otra publicación.

Mediante algoritmo

 En este apartado vamos a realizar un código en el cual generamos puntos de forma aleatoria. el código se muestra a continuación:

#include <iostream>
#include <pcl/io/pcd_io.h>
#include <pcl/point_types.h>
#include <cmath>
#include <cstring>
#include <pcl/visualization/cloud_viewer.h>
#include <pcl/visualization/pcl_visualizer.h>

int main (int argc, char** argv)
{
  pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud  (new pcl::PointCloud<pcl::PointXYZRGB>);
  int i;

  cloud->width    = 40;
  cloud->height   = 1;
  cloud->is_dense = false;
  cloud->points.resize (cloud->width * cloud->height);
      
   for (i = 0; i < 39; ++i)
          {
            cloud->points[i].x = (1024 * rand () / (RAND_MAX + 1.0f));
            cloud->points[i].y =  (1024 * rand () / (RAND_MAX + 1.0f));
            cloud->points[i].z  =(1024 * rand () / (RAND_MAX + 1.0f));
         }
//  guardar los puntos en el archivo
  pcl::io::savePCDFileASCII ("archivo.pcd", *cloud);
  std::cerr << "Saved " << cloud->points.size () << " data points to archivo.pcd." << std::endl;
//visualizar la nube de puntos
 pcl::visualization::CloudViewer viewer("Cloud Viewer");
  viewer.showCloud(cloud);
  while (!viewer.wasStopped ())
    {
    }
 return (0);
}

Para iniciar el código debemos de indicar las librerías que utilizaran las funciones de nuestro código, en nuestro caso tenemos los siguientes includes:

#include <iostream> 
B0ásico para trabajar en C++.

#include <pcl/io/pcd_io.h>
 Esta librería se encarga de la escritura, apertura y lectura de archivos de extensión pcd.

#include <pcl/point_types.h>
 Esta librería nos permite utilizar los tipos de datos que se utilizan en PCL evitando la tediosa tarea de asignar memoria para cada tipo de dato.

#include <cmath>
Esta biblioteca es básica en C++ y la utilizamos para la función en la que pedimos numeros aleatorios.

#include <cstring>

En esta biblioteca se incluyen rutinas de manipulación de cadenas de caracteres y de memoria.


#include <pcl/visualization/cloud_viewer.h>

#include <pcl/visualization/pcl_visualizer.h>

Esta librerías nos permiten visualizar las nubes de puntos.

Luego en el cuerpo principal, lo primero que se debe hacer es introducir las zonas de memoria, en nuestros caso solo necesitamos un entero y un puntero para nube de puntos de la siguiente manera:

pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud  (new pcl::PointCloud<pcl::PointXYZRGB>);

 Como podemos ver es un puntero en el cual podemos hacer una nube de puntos con coordenadas en los ejes cartesianos, y componentes de color rojo(R), verde(G) y azul(B).

Una vez asignada la zona de memoria de la nube, debemos de dar las dimensiones que deseamos que tenga la nube de puntos, como es un ejemplo hemos dado dimensiones pequeñas, aunque puede llegar a tener millones de puntos.El fragmento que exponemos es imprescindible si  creamos nosotros la nube, no así si la leemos, por lo que tenemos:

  cloud->width    = 40;
  cloud->height   = 1;
  cloud->is_dense = false;
  cloud->points.resize (cloud->width * cloud->height);

Luego simplemente tenemos que generar una serie de puntos de forma aleatoria, aunque también podríamos hacerlo de forma ordenada y consiguiendo planos, o diferentes formas geometrías. Para generar los puntos de forma aleatoria lo hemos realizado de la siguiente manera:

  for (i = 0; i < 39; ++i)
          {
            cloud->points[i].x = (1024 * rand () / (RAND_MAX + 1.0f));
            cloud->points[i].y =  (1024 * rand () / (RAND_MAX + 1.0f));
            cloud->points[i].z  =(1024 * rand () / (RAND_MAX + 1.0f));
         }

Una vez creada la nube de puntos podemos guardarla en un archivo .pcd, en formato binario o ASCII, nosotros lo tenemos en el código como ASCII, la forma de guardarlo seria:

-Código ASCII: pcl::io::savePCDFileASCII ("archivo.pcd", *cloud);
-Binario: pcl::io::savePCDFileBinary ("test_pcd4.pcd", *cloud);

 También podemos visualizar nube de puntos, hemos utilizado el siguiente código que entra en un bucle infinito.

 pcl::visualization::CloudViewer viewer("Cloud Viewer");
  viewer.showCloud(cloud);
  while (!viewer.wasStopped ())
    {
    }

Para visualizar un archivo pcd también lo podemos hacer mediante consola con el siguiente comando:

$pcd_viewer archivo.pcd

nota: para ver los puntos mas grandes pulsar la tecla de (+)

 

Herramientas de la Libreria PCL

 

La herramienta conocida como PCL (Point Cloud Library), la cual consiste en una librería desarrollada para el tratamiento completo de nubes de puntos 3D,  liberada bajo licencia BSD, que cuenta con varios métodos de alta eficiencia computacional.

PCL surgió ante la necesidad de que los robots tengan la capacidad de percibir el mundo tal cual y como lo hacemos los seres humanos, es decir, que puedan determinar las diferentes características y detalles que el ojo humano puede observar. Esta librería se ha potencializado debido al gran al gran avance y al biblioteca bajo costo de los sensores de adquisición de imágenes 3D, en el que cabe destacar en sensor Kinect® de la compañía Microsoft el cual se basa en la tecnológica PrimeSense.

Herramientas de PCL

PCL se encuentra dividido en módulos para facilitar su compilación, las cuales son:

Filtros (libpclfilters)

Debido a los errores generados en la medida, es necesario utilizar herramientas que permitan eliminar datos atípicos  con el fin de obtener mayor fiabilidad en los procesos a desarrollar con la información obtenida. Para esta labor se utilizan los filtros digitales. PCL posee métodos de filtrado  digital como por ejemplo eliminadores de datos atípicos, filtro tipo voxel, eliminador con condición, suavizado, índices de extracción y proyecciones.Debido al volumen de datos que genera una nube de puntos también existe la posibilidad de utilizar filtros que además de eliminar valores atípicos, hacen una gran reducción de datos y permitiendo así una mayor rapidez en la computación. También existe la posibilidad de aplicar filtros de paso, donde tomando como criterio una distancia se eliminan los valores que no cumplan la restricción indicada.

KdTree (libpclKdtree)

Esta biblioteca consiste en una estructura tipo árbol que almacena un conjunto de puntos k-dimensional con el fin de realizar búsquedas eficientes del vecino más cercano. Esta  herramienta se puede utilizar para encontrar las correspondencias entre grupos de puntos para los métodos de características geométricas, o en descriptores para definir la zona  local alrededor de un punto o puntos.

Octree (libpcloctree)

La biblioteca octree proporciona métodos eficaces para la creación de una estructura de datos tipo árbol jerárquico, y subdividir nubes de puntos en conjuntos para realizar el procesamiento de forma eficiente. La aplicación ofrece rutinas
eficientes de búsqueda de vecinos, tales como "Búsqueda de vecinos Voxel", "El vecino más cercano a buscar determinado por un radio K", entre otros. Estos algoritmos tienen la gran ventaja de que se ajustan automáticamente a la dimensión del conjunto de puntos.

Características (libpclfeatures)

PCL permite estimar parámetros de funciones que determinan si un conjunto de datos representa una función geométrica en el espacio. Esta biblioteca contiene funciones de las estructuras de datos y métodos para la estimación de la función en tres dimensiones a partir de los datos de una nube de puntos. La biblioteca también posibilita la extracción de características tridimensionales (como las tradicionales en las superficies y curvaturas), estimación de bordes, descripciones PFH (Point Feature Histograms) y FPFH (Fast Point Feature Histograms), rotación de imágenes, entre otras.

Puntos de Interés (libpclkeypoints)

Esta biblioteca permite determinar los puntos clave en una escena tridimensional creada con una nube de puntos. Normalmente el número de puntos de interés en una nube es menor al total de datos, permitiendo optimizar el procesamiento de los datos.

Registro (libpclregistration)

La librería de registro permite la construcción de un modelo tridimensional por medio de las correspondencias en n vistas del objeto evaluado. La combinación de n-conjuntos de datos (nubes de puntos) en un modelo global consistente, generalmente se realiza mediante una técnica llamada registro, la cual consiste en hallar la correspondencia entre cada nube puntos y realizar una transformación para minimizar el error de alineación (tal como se puede observar en la Figura), y así visualizar todas las nubes de puntos como un conjunto global que posee el modelo con toda sus vistas.

Segmentación (libpclsegmentation)

Esta biblioteca contiene algoritmos especialmente desarrollados para la segmentación de nubes de puntos. Estos algoritmos son los más adecuados para el procesamiento de datos, los cuales se componen de un número de regiones espacialmente aisladas. En tales casos, el agrupamiento se utiliza a menudo para romper la nube en sus partes constituyentes y luego procesar cada grupo de forma independiente. Estos algoritmos se realizan a través de métodos de consenso y son útiles para una variedad de modelos paramétricos (planos, cilíndricos, esferas, líneas, etc.).

Sample_consensus (libpclsample_consensus)

La biblioteca sample_consensus contiene herramientas para estimación de modelos específicos en una nube de puntos, tales como líneas, planos, cilindros y esferas. Esta librería utiliza métodos de ajuste y estimación, como por ejemplo RANSAC, y modelos como planos, cilindros, etc.

Reconstrucción de Superficies (libpclsurface)

Esta biblioteca se utiliza para mejorar la visualización de un modelo tridimensional procesando los puntos de una nube para obtener una representación en malla o una superficie alisada como se puede observar en la Figura 4. La complejidad de la estimación de la superficie se puede ajustar, y normales se puede estimar en la misma etapa si es necesario.

Imágenes de Rango (libpcl_rangeimage)

Esta biblioteca permite transformar una nube de puntos en una imagen de rango, la cual consiste en una representación en 3D común. Este tipo de imágenes se generan con frecuencia en sistemas estéreo o dispositivos de tiempo de vuelo. Con el conocimiento de los parámetros intrínsecos de la cámara por medio de su calibración, una imagen de rango se puede transformar en una nube de puntos para su posterior procesamiento en PCL.

IO (libpclio)

Consiste en una biblioteca que permite operaciones de lectura y escritura de archivos PCD (Point Cloud Data). También cuenta con una interfaz denominada OpenNI Grabber Framewor, la cual permite acceder y controlar tanto el Kinect (Microsoft) como el Xtion-PRo (ASUS).

Visualización (libpclvisualization)

Esta librería permite la rápida visualización de algoritmos que operan sobre nubes de puntos 3D. Cuenta con métodos de procesamiento configuración de propiedades visuales como colores, tamaños de punto y opacidad. También cuenta con algoritmos para dibujar formas básicas en la pantalla y provee un módulo de visualización de histogramas.


citar: Calvo Salcedo, Andrés Felipe, Bejarano Martínez, Arley, Quintero Salazar, Edwin Andrés. Procesamiento de nubes de puntos por medio de la librería PCLScientia Et Technica [en linea] 2012, XVII (Diciembre-Sin mes) : [Fecha de consulta: 12 de diciembre de 2013] Disponible en:<http://www.redalyc.org/articulo.oa?id=84925149019> ISSN 0122-1701

Bienvenida a Point Cloud Library en Castellano

Este blog será realizado por un estudiante de ingeniería Industrial de la Universidad Carlos III de Madrid, sobre la librería en C++ de Point Cloud Library (PCL). Esta librería está  diseñada por un gran grupo de investigadores y desarrolladores en tratamiento y procesado de  imágenes 3D, dicho grupo forman parte de un proyecto de software libre.

He decidido empezar a realizar este blog para ayudar a divulgar este proyecto de software libre a todas aquellas personas que estén interesadas en introducirse en el mundo de las imágenes 3D. Espero llegar a todos aquellos alumnos que con pequeños conocimientos en programación en C++, y deseen introducirse en este campo emergente.

Para aquellas personas que duden sobre si es una buena opción emplear su tiempo en conocer esta librería, pueden estar seguros de que cuentan con un código abierto, por lo que sí queréis saber lo que sucede en cada una de las funciones, investigar e incluso modificar a vuestro gusto. Además contáis con  una plataformas web que os ayudaran a realizar el código, empleando un lenguaje sencillo y presentado de forma intuitiva, foros de gran actividad donde se  responden de forma rápida, y en gran medida con mucha efectividad.

El aprendizaje de esta librería, que en la plataforma que la promueve la ha orientado al campo de la robótica, podría ser enfocado para los usuarios en otros muchos campos, es nuestra labor encontrar otros posibles nichos donde poder desarrollarla.

El que visite el blog podrá encontrar una introducción sobre temas relacionados con PCL, además de información interesante sobre documentos relacionados con algoritmos y procesamientos, noticias destacadas, y también y como punto fuerte para que los visitantes puedan experimentar, muchos tutoriales con explicaciones del funcionamiento de los diferentes algoritmos.

Debemos agradecer a la comunidad de desarrolladores de la Point Cloud Library(PCL) y felicitarles por el excelente trabajo que están realizando.

SOBRE PCL

¿Que es PCL?

La Point Cloud Library(Librería de nube de puntos) es un proyecto  abierto[1] a gran escala para el procesamiento de imagen en 2D/3D.La estructura de PCL contiene numerosos algoritmos para el tratamiento y procesamiento.

La librería PCL es liberado bajo los términos de la Licencia BSD  y es un software de código abierto. Es gratuito para el uso comercial y la investigación.

PCL es multiplataforma, que ha sido compilado e implementado en Linux, MacOS, Windows y Android / iOS con éxito. Para simplificar el desarrollo, PCL se ha dividido en una serie de bibliotecas de código más pequeñas, que puede ser compilado por separado. Esta modularidad es importante para la distribución de PCL en plataformas con reducidas limitaciones computacionales o tamaño (para más información sobre cada módulo de ver la página de documentación). Otra forma de pensar acerca de PCL es como un gráfico de librerías de código, similar al conjunto de las bibliotecas Boost C + +. He aquí un ejemplo:

¿Quién está desarrollando PCL? 

El proyecto está siendo desarrollado por un gran número de ingenieros y científicos de muchas organizaciones diferentes, distribuidos geográficamente en todo el mundo, incluyendo:

 
 

¿Quién está apoyando financieramente PCL?

El proyecto está financiado por Open Percepción, Willow Garage, NVidia, Google (GSOC 2011,2012), Toyota, Trimble, Urban Robótica, Instituto de Investigación de Honda, Sandia Sistemas Inteligentes y Robótica, Dinast, Optronic, Velodyne, Spectrolab, Fotónicos, Leica Geosystems, el Instituto Nacional de Estándares y Tecnología, Instituto de Investigación del Suroeste y Ocular Robotics. También el Ministerio de Conocimiento y Economía (MKE) de Corea del Sur,  ha concedido generosamente a PCL  el Primer Premio en el Open Source Software World Challenge en 2011.

¿Qué es una nube de puntos?

Una nube de puntos es una estructura de datos utilizada para representar una colección de puntos multidimensionales y se utiliza comúnmente para representar los datos en tres dimensiones. En una nube de puntos 3D, los puntos por lo general representan los ejes X, Y y Z coordenadas geométricas de una superficie muestreada subyacente. Cuando la información de color está presente (ver las figuras de abajo), la nube de puntos se convierte en 4D.




Las nubes de puntos se pueden adquirir a partir de sensores como cámaras estéreo, escáneres 3D,  cámaras de tiempo de vuelo o generados a partir de un programa de ordenador de forma sintética. PCL admite de forma nativa las interfaces OpenNI 3D, por lo que puede adquirir y procesar datos de dispositivos tales como las cámaras PrimeSensor 3D, el Kinect de Microsoft, o el Asus XTionPRO.


Referencia:
[1] @InProceedings{Rusu_ICRA2011_PCL, author = {Radu Bogdan Rusu and Steve Cousins}, title = {{3D is here: Point Cloud Library (PCL)}}, booktitle = {{IEEE International Conference on Robotics and Automation (ICRA)}}, month = {May 9-13}, year = {2011}, address = {Shanghai, China} }