Visualizzatore di nuvole di punti con GLFW e PCL

Per imparare un po' di librerie mi sono fatto il mio visualizzatore di nuvole di punti

Volevo includere ImGui o NanoGui per settare i valori delle variabili ma non riesco a trovare il modo di compilarli

 https://github.com/c1p81/cloudpoint_glfw

La visualizzazione si modifica con i tasti freccia/pg up-down ed il mouse

Realsense SDK con D435 in Debian

Dopo un po' di esperienza con i sensori a luce strutturata ho provata il sensore Intel RealSense D435 (attenzione manca la i finale....a differenza al D435i qui non e' presenta la IMU integrata) che funziona come sensore di profondita' usando la stereoscopia di due camere

Il sensore e' nato per applicazioni di robotica ed e' molto veloce nell'acquisizione/elaborazione (circa 30 fps) ma il risultato come dato di profondita' e' molto differente da quello che si ottiene da un sensore a luce strutturata

Oltre alle due camere per la stereoscopia e' presente un illuminatore IR per migliorare il dato di profondita' ed una camera RGB

La distanza massima operativa e' di circa 4m. Come si nota dal video il dato e' molto rumoroso

Un aspetto che mi ha lasciato molto perplesso e' che non risultano essere conservati gli angoli. Per esempio nella realta' l'angolo e' di 90 gradi mentre dalla mesh risulta essere di 105 gradi. Credo che questo sia dovuto al fatto che le lenti sono quasi dei fish-eye

Per quanto rigurda le lunghezza la porta in realta' e' larga 125 cm mentre il sensore la misura circa 105 cm

Diciamo che i dati al centro dell'immagine sono coerenti ma sui bordi 

l'SDK e' nato per Windows e Ubuntu ma si puo' installare su Debian utilizzando Snap

snap install librealsense

Oltre alle librerie si installa anche realsense-viewer da cui e' possibile anche effettuare l'upgrade del firmware della camera

Gli esempi si trovano a  https://dev.intelrealsense.com/docs/code-samples

Per compilare gli esempi ho dovuto installare anche la libreria StbEasyFont (e' presente nella directory third parts ma io la ho installata con apt per semplicita')

=================================================

cmake_minimum_required(VERSION 3.5)

project(realsense LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 11)

set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(realsense2 REQUIRED )

add_executable(realsense main.cpp)

target_link_libraries(realsense realsense2)

=================================================

=================================================

#include <iostream>
#include <librealsense2/rs.hpp> 

using namespace std;

int main()
{
    rs2::pipeline p;
    p.start();
    rs2::frameset frames = p.wait_for_frames();
    rs2::depth_frame depth = frames.get_depth_frame();
    float width = depth.get_width();
    float height = depth.get_height();
    float dist_to_center = depth.get_distance(width / 2, height / 2);
    std::cout << "The camera is facing an object " << 
dist_to_center << " meters away" << endl << endl;
    return 0;
}

=================================================

Multicam

Nell'esempio Multicam oltre alla libreria Realsense viene usata anche OpenGL con glfw

================================================

cmake_minimum_required(VERSION 3.5)

project(multicam LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# finds OpenGL, GLU and X11
find_package(OpenGL REQUIRED)
if(NOT OPENGL_FOUND)
    message("ERROR: OpenGL not found")
endif(NOT OPENGL_FOUND)
set(GL_LIBRARY GL GLU X11)


find_package(realsense2 REQUIRED )

add_executable(multicam main.cpp)
target_link_libraries(multicam realsense2 glfw ${GL_LIBRARY} m)

================================================

PCL Library e Visual Studio 2019

 Per installare ed usare PCL su Windows la cosa piu' comoda e' utilizzare il pacchetto PCL-1.11.1-AllInOne-msvc2019-win64 

Una volta installato il file exe per esempio in C:\Program Files\PCL 1.11.1

Per creare un progetto in QT con le PCL si devono aggiungere nella path OpenNI2 (stranamente l'installer non la ha aggiunta nella PATH)

Ho sostituito la versione di CMAKE da quella di default di QT con l'installer di CMake  (modificabile dai Kit di Qt) ed come compilatore ho selezionato MSVC2019

il file CMAKE e' il seguente

===============================================

cmake_minimum_required(VERSION 3.5)

project(t3 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 11)

set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(PCL 1.3 REQUIRED COMPONENTS common io features)

include_directories(${PCL_INCLUDE_DIRS})

link_directories(${PCL_LIBRARY_DIRS})

add_definitions(${PCL_DEFINITIONS})

add_executable(t3 main.cpp)

target_link_libraries(t3 ${PCL_LIBRARIES})

===============================================

mentre un programma di esempio e' 

===============================================

#include <iostream>

#include <pcl/io/pcd_io.h>

#include <pcl/point_types.h>



#include <pcl/features/normal_3d.h>



using namespace std;



int main()

{

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



     if (pcl::io::loadPCDFile<pcl::PointXYZ> ("c://gabriele.pcd", *cloud) == -1) //* load the file

     {

       PCL_ERROR ("Couldn't read file test_pcd.pcd \n");

       return (-1);

     }

     //std::cout << "Loaded " << cloud->width * cloud->height << " data points from test_pcd.pcd with the following fields: " << std::endl;

     /*for (size_t i = 0; i < cloud->points.size (); ++i)

       std::cout << "    " << cloud->points[i].x << " "    << cloud->points[i].y << " "    << cloud->points[i].z << std::endl;

    */

     // Create the normal estimation class, and pass the input dataset to it



     pcl::NormalEstimation<pcl::PointXYZ, pcl::Normal> ne;

     ne.setInputCloud (cloud);

    // Create an empty kdtree representation, and pass it to the normal estimation object.

       // Its content will be filled inside the object, based on the given input dataset (as no other search surface is given).

       pcl::search::KdTree<pcl::PointXYZ>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZ> ());

       ne.setSearchMethod (tree);



       // Output datasets

       pcl::PointCloud<pcl::Normal>::Ptr cloud_normals (new pcl::PointCloud<pcl::Normal>);



       // Use all neighbors in a sphere of radius 3cm

       ne.setRadiusSearch (0.03);



       // Compute the features

       ne.compute (*cloud_normals);



       //std::cout << endl << cloud_normals->size() << endl;





       // cloud_normals->size () should have the same size as the input cloud->size ()*



       int i = 0;

       for (pcl::Normal n : *cloud_normals) {

           //std::cerr << i << " n = " << n.normal_x << ", " << n.normal_y << ", " << n.normal_z << "\n";

           std::cout << n.normal_x << "," << n.normal_y << "," << n.normal_z << "\n";

           i++;

       }







    return 0;

}

Matplot++ e QtCreator

Vista la necessita' di plottare in uno scatterplot 3D qualche decina di migliaia di punti ho cercato una libreria adeguata e l'ho trovata in Matplot++

Per integrarla con QtCreator (ma funziona cosi' anche con Visual Studio su Windows) dopo aver creato un progetto CMake nella root del progetto si digita

git clone https://github.com/alandefreitas/matplotplusplus/

successivamente si modifica il file CMakeLists.txt aggiungendo le righe evidenziate

add_subdirectory(matplotplusplus)

add_executable(grafico

  main.cpp

)

target_link_libraries(grafico PUBLIC matplot Qt${QT_VERSION_MAJOR}::Core)

#target_link_libraries(grafico PUBLIC matplot)

per la visualizzazione e' necessario che sia installato gnuplot

Primi passi con Point Cloud Library

Con l'arrivo del sensore lidar sugli IPhone (rip Project Tango) forse e' il caso di ritirare fuori le librerie per trattare le nuvole di punti come PCL 

Per installare la liberia su Debian e' sufficiente

apt-get install libpcl-dev

che si porta dietro un po' di dipendenze come boost

I primi passi sono ovviamente quelli di inserire la libreria in un progetto. Per questo sono partito da QTCreator con le varie opzioni di Make

Compilazione con CMake

per la compilazione si devono aggiungere le righe in giallo al file CMakeLists.txt. Attenzione che in PCL le funzioni sono distribuite in vari moduli che devono essere specificati in REQUIRED COMPONENTS

cmake_minimum_required(VERSION 3.5)

project(nuvola LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 11)

set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(PCL 1.3 REQUIRED COMPONENTS common io features)

include_directories(${PCL_INCLUDE_DIRS})

link_directories(${PCL_LIBRARY_DIRS})

add_definitions(${PCL_DEFINITIONS})

add_executable(nuvola main.cpp)

target_link_libraries(nuvola ${PCL_LIBRARIES})

Compilazione con QMake

Usando qmake, come prima, si devono modificare le righe in giallo.  Si deve anche specificare  c++14 

TEMPLATE = app

CONFIG += console c++14

CONFIG -= app_bundle

CONFIG -= qt

CONFIG += link_pkgconfig

PKGCONFIG += eigen3

INCLUDEPATH += /usr/include/pcl-1.11

LIBS += -L/usr/lib/x86_64-linux-gnu -lpcl_common -lpcl_io -lpcl_features -lpcl_search

QT += widgets

SOURCES += \

        main.cpp

Compilazione con Make

Per verificare quali sono gli switch di compilazione necessari per usare make si puo'usare

pkg-config --cflags --libs pcl_commons-1.7

anche in questo caso si deve ripetere l'operazione per ogni modulo utilizzato

Di seguito un semplice esempio di come leggere un file PCD, calcolare le normali e stampare i dati a schermo

===========================================

#include <iostream>

#include <pcl/io/pcd_io.h>

#include <pcl/point_types.h>

#include <pcl/features/normal_3d.h>

using namespace std;

int main()

{

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

     if (pcl::io::loadPCDFile<pcl::PointXYZ> ("/home/luca/gabriele.pcd", *cloud) == -1) //* load the file

     {

       PCL_ERROR ("Couldn't read file test_pcd.pcd \n");

       return (-1);

     }

     //std::cout << "Loaded " << cloud->width * cloud->height << " data points from test_pcd.pcd with the following fields: " << std::endl;

     /*for (size_t i = 0; i < cloud->points.size (); ++i)

       std::cout << "    " << cloud->points[i].x << " "    << cloud->points[i].y << " "    << cloud->points[i].z << std::endl;

    */

     // Create the normal estimation class, and pass the input dataset to it

     pcl::NormalEstimation<pcl::PointXYZ, pcl::Normal> ne;

     ne.setInputCloud (cloud);

    // Create an empty kdtree representation, and pass it to the normal estimation object.

       // Its content will be filled inside the object, based on the given input dataset (as no other search surface is given).

       pcl::search::KdTree<pcl::PointXYZ>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZ> ());

       ne.setSearchMethod (tree);

       // Output datasets

       pcl::PointCloud<pcl::Normal>::Ptr cloud_normals (new pcl::PointCloud<pcl::Normal>);

       // Use all neighbors in a sphere of radius 3cm

       ne.setRadiusSearch (0.03);

       // Compute the features

       ne.compute (*cloud_normals);

       //std::cout << endl << cloud_normals->size() << endl;

       // cloud_normals->size () should have the same size as the input cloud->size ()*

       int i = 0;

       for (pcl::Normal n : *cloud_normals) {

           //std::cerr << i << " n = " << n.normal_x << ", " << n.normal_y << ", " << n.normal_z << "\n";

           std::cout << n.normal_x << "," << n.normal_y << "," << n.normal_z << "\n";

           i++;

       }

    return 0;

}

Classi in C++ con CMake ed Eclipse

Questa cosa di CMake mi sta iniziando a dare fastidio....(devo ogni volta capire come sono cambiate le cose rispetto a make)

Diciamo di avere questa stupida classe
schermo.cpp
---------------------------------------------------
#include "schermo.h"

void schermo::aggiorna()
{
schermo::matrice[1] = 100;
}

schermo::schermo() {
schermo::matrice[1]=0;
}

schermo::~schermo() {
}
------------------------------------------------------

schermo.h
------------------------------------------------------

#ifndef SCHERMO_H_

#define SCHERMO_H_

class schermo {

public:

schermo();

void aggiorna();

virtual ~schermo();

int matrice [100];

private:

};

#endif /* SCHERMO_H_ */

------------------------------------------------------

ed un altro altrettanto stupido codice che chiama la classe

ad.cpp
------------------------------------------------------
#include <iostream>
#include <string>
#include "schermo.h"

using namespace std;

schermo ss;

int main(int argc, char **argv) {
int numero = ss.matrice[1];
auto s = std::to_string(numero);
cout << s << endl;
ss.aggiorna();
numero = ss.matrice[1];
s = std::to_string(numero);
cout << s << endl;
return 0;
}

------------------------------------------------------

per compilare la classe nella liberia esterna si deve modificare il file CMakeLists.txt come segue nella parte evidenziata (cioe' richiamando sia il sorgente che l'header della classe)

------------------------------------------------------

cmake_minimum_required (VERSION 2.6)

project (ad)

add_executable(ad ad.cpp schermo.cpp schermo.h)

------------------------------------------------------

Aggiungere libreria ad un progetto Cmake

Abituato a -L -I per includere una libreria in un progetto C (tipo qui) mi sono dovuto convertire a CMake. Per includere una libreria (sia in Eclipse che in KDevelop), per esempio NCurses, si deve editare il file  CMakeLists.txt e aggiungere la riga

target_link_libraries(nome_progetto ncurses)

CMake

Guardando un po' a giro mi sono reso conto di quanto sono arretrato ....ero rimasto al fatto che autotools e' una cosa figa mentre e' stata sorpassata da altri concorrenti come CMake ed ho deciso di provarlo con il programma descritto a questo post

Per provare Cmake (che non e' installato di default in Debian) si deve creare il file CMakeLists.txt dove sono contenute le informazioni di compilazione come nel Makefile come il link verso la libreria SDL

CMakeLists.txt
----------------------------------------

cmake_minimum_required(VERSION 2.8)
PROJECT(CMake_TEST)
FIND_PACKAGE(SDL REQUIRED)
ADD_DEFINITIONS(-Wall -O3)
INCLUDE_DIRECTORIES(${SDL_INCLUDE_DIR})
ADD_EXECUTABLE(cmake_test test.cpp)
TARGET_LINK_LIBRARIES(cmake_test ${SDL_LIBRARY})
----------------------------------------

a questo punto, con il solo file sorgente e il CMakeLists.txt nella directory, si lancia
cmake .   (attenzione al punto)
vengono generati automaticamente altri file e se non ci sono errori si puo' digitare
make 
per compilare l'eseguibile

L'aspetto piu' interessante di CMake e' di essere indipendente dalla piattaforma e dal compilatore e puo' generare file di compilazione di Linux e Windows per i diversi compilatori supportati

Ovviamente non ha senso di usare Cmake per un caso cosi' semplice come quello utilizzato nell'esempio (e' sempre piu' veloce utilizzare la linea di comando per lanciare gcc, anche bypassando make)