PCL e Tango tablet

Ho ritirato fuori il mio tablet Google Yellowstone Tango per provare il trattamento dati delle nuvole dei punti con PCL

I dati reali sono stati presi presso la cava di Maiano (Fiesole) che e' la palestra di geologia per numerose generazioni di geologi fiorentini 

Ho ripreso con lo scanner del tablet questo dettaglio 

in particolare volevo vedere se riuscivo a misurare l'angolo tra i due piani indicati nella foto sottostante

(quello in blu e' il piano del fronte di scavo, quello in rosso e' relativo ad una frattura)

Usando la app Clino Fieldmove e Innstereo 

a posteriori la scelta delle superfici non e' stata felicissima perche' sono tutte ad alto angolo e si distinguono poco sullo stereoplot

Con il tablet la distanza massima a cui era possibile avere risposta dallo scanner era di circa 3 m. Per prova la superficie e' stata bagnata per vedere se il laser infrarosso era influenzato dall'umidita' della parete ma non si verifiche significative tra superficie asciutta e bagnata

I dati sono stati salvati in PLY e sono stati elaborati con PCL in QtCreator

Il programma dopo aver caricato il file PLY fa un sottocampionamento dei dati con VoxelGrid (passando da oltre 200.000 superfici a poco oltre 50 superfici) e calcola le  normali. I dati sono visualizzati con il visualizzatore interno a PLC

leggermente modificato da https://github.com/jeffdelmerico/pointcloud_tutorial

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

cmake_minimum_required(VERSION 3.5)

project(maiano LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 11)

set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(PCL 1.3 REQUIRED COMPONENTS common io features visualization)

include_directories(${PCL_INCLUDE_DIRS})

link_directories(${PCL_LIBRARY_DIRS})

add_definitions(${PCL_DEFINITIONS})

add_executable(maiano main.cpp)

target_link_libraries(maiano ${PCL_LIBRARIES})

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

#include <iostream>

#include <pcl/point_types.h>

#include <pcl/point_cloud.h>

#include <pcl/io/ply_io.h>

#include <pcl/io/pcd_io.h>

#include <pcl/filters/voxel_grid.h>

#include <pcl/kdtree/kdtree_flann.h>

#include <pcl/features/normal_3d.h>

#include <pcl/visualization/pcl_visualizer.h>

using namespace std;

void

downsample (pcl::PointCloud<pcl::PointXYZRGB>::Ptr &points, float leaf_size,

            pcl::PointCloud<pcl::PointXYZRGB>::Ptr &downsampled_out)

{

    cout << "PointCloud before filtering: " << points->width * points->height

           << " data points (" << pcl::getFieldsList (*points) << ")." << std::endl;

  pcl::VoxelGrid<pcl::PointXYZRGB> vox_grid;

  vox_grid.setLeafSize (leaf_size, leaf_size, leaf_size);

  vox_grid.setInputCloud (points);

  vox_grid.filter (*downsampled_out);

  cout << "PointCloud after filtering: " << downsampled_out->width * downsampled_out->height

         << " data points (" << pcl::getFieldsList (*downsampled_out) << ")." << std::endl;

}

void compute_surface_normals (pcl::PointCloud<pcl::PointXYZRGB>::Ptr &points, float normal_radius,

                                    pcl::PointCloud<pcl::Normal>::Ptr &normals_out)

{

  pcl::NormalEstimation<pcl::PointXYZRGB, pcl::Normal> norm_est;

  // Use a FLANN-based KdTree to perform neighborhood searches

  norm_est.setSearchMethod (pcl::search::KdTree<pcl::PointXYZRGB>::Ptr

                            (new pcl::search::KdTree<pcl::PointXYZRGB>));

  // Specify the size of the local neighborhood to use when computing the surface normals

  norm_est.setRadiusSearch (normal_radius);

  // Set the input points

  norm_est.setInputCloud (points);

  // Estimate the surface normals and store the result in "normals_out"

  norm_est.compute (*normals_out);

}

void visualize_normals (const pcl::PointCloud<pcl::PointXYZRGB>::Ptr points,

                        const pcl::PointCloud<pcl::PointXYZRGB>::Ptr normal_points,

                        const pcl::PointCloud<pcl::Normal>::Ptr normals)

{

  // Add the points and normals to the vizualizer

  pcl::visualization::PCLVisualizer viz;

  viz.addPointCloud (points, "points");

  viz.addPointCloud (normal_points, "normal_points");

  viz.addPointCloudNormals<pcl::PointXYZRGB, pcl::Normal> (normal_points, normals, 1, 0.01, "normals");

  // Give control over to the visualizer

  viz.spin ();

}

int main (int argc, char** argv)

{

    // Load data from pcd

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

    //if (pcl::io::loadPCDFile<pcl::PointXYZRGB> ("../data/robot1.pcd", *cloud) == -1) //* load the file

    if (pcl::io::loadPLYFile<pcl::PointXYZRGB> ("maiano.ply", *cloud) == -1) //* load the file

    {

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

        return (-1);

    }

    // Point Clouds to hold output

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

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

    // Downsample the cloud

    const float voxel_grid_leaf_size = 1.0;

    downsample (cloud, voxel_grid_leaf_size, downsampled);

    // Compute surface normals

    const float normal_radius = 1.0;

    compute_surface_normals (downsampled, normal_radius, normals);

    visualize_normals(cloud, downsampled, normals);

    int i = 0;

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

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

        i++;

    }

    return(0);

}

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

Plottando le normali si ha questo risultato

Al di la' dell'orientamento verso il Nord (che lo scanner non registra in quanto non calibra i dati con la bussola) il programma estra sia le suprfici ad alto angolo che alcun suborizzontali.. non so quanto i dati alla fine siano corretti....i dati delle normali vengono forniti come componenti x,y,z di un versore con origine 0,0,0....non so se ho fatto qualche sbaglio nella conversione in strike e dip