POINT CLOUD SERVER (PCS) : POINT CLOUDS IN-BASE MANAGEMENT AND PROCESSING

In addition to the traditional Geographic Information System (GIS) data such as images and vectors, point cloud data has become more available. It is appreciated for its precision and true three-Dimensional (3D) nature. However, managing the point cloud can be difficult due to scaling problems and specificities of this data type. Several methods exist but are usually fairly specialised and solve only one aspect of the management problem. In this work, we propose a complete and efficient point cloud management system based on a database server that works on groups of points rather than individual points. This system is specifically designed to solve all the needs of point cloud users: fast loading, compressed storage, powerful filtering, easy data access and exporting, and integrated processing. Moreover, the system fully integrates metadata (like sensor position) and can conjointly use point clouds with images, vectors, and other point clouds. The system also offers in-base processing for easy prototyping and parallel processing and can scale well. Lastly, the system is built on open source technologies; therefore it can be easily extended and customised. We test the system will several billion points of point clouds from Lidar (aerial and terrestrial ) and stereo-vision. We demonstrate ∼400 million pts/h loading speed, user-transparent greater than 2 to 4:1 compression ratio, filtering in the approximately 50 ms range, and output of about a million pts/s, along with classical processing, such as object detection.


INTRODUCTION
The last decades have seen the rise of GIS data availability, in particular through the open data movement.Along with the traditional raster and vector data, point clouds have recently gained increased usage 1 .Sensors are increasingly cheap, precise, and available, and the point cloud complements images naturally.However, due to their massive unstructured nature and limited integration with other GIS data, the management of point clouds still remains challenging.This makes point cloud data barely accessible to non-expert users.
With many point clouds, data sets are commonly in the teraByte (TByte) range and have very different usages; therefore every aspect of their management is complex.The first difficulty is simply knowing which data-sets are available and where.Dealing with (extended) meta-data is difficult, especially without a standard data format.Because data is so big, it is essential to compress it, while maintaining a fast read and write access.Similarly, so much data cannot be duplicated and must be shared, which introduces concurrency issues.Efficiently extracting (filtering) only the part of the data needed is also important.Because displaying billions of points is not possible, visualising point clouds necessitates Level Of Details (LOD) strategies.Point clouds are geospatial data complementary to vectors and rasters.Thus, they need to be used conjointly to other data types, either directly or by converting point clouds to images or vectors.Lastly, some users need to design custom processing methods that must be fast and easy to design, scale well, and be robust.
In this article, we propose the investigation of the use of a point cloud server to solve some of these problems.The proposed server architecture provides perspective for metadata, scalability, concurrency, standard interface, co-use with other GIS data, and fast method design.We create an abstraction level over points 1 www.opentopography.orgclouds by dealing with groups of points rather than individual points.This results in compression, filtering, LOD, coverage, and efficient processing and conversion.
Historically, point clouds have been stored in files.To manage large volumes of these files, a common solution is to build a hierarchy of files (a tree structure) and access the data through a dedicated set of softwares.This approach is continuously improved (Hug et al., 2004;Otepka et al., 2012;Richter and Döllner, 2014) and a detailed survey of the features of such systems can be found in (Otepka et al., 2013).However, using a file-based system has severe limitations.These systems are usually built around one file format, and are not necessarily compatible.Recent efforts have been made towards format conversion 2 .Moreover, these systems are not adapted to share data and use it with several users simultaneously (concurrency).Hofle (2007) proposed to use DataBase Management System (DBMS) to cope with concurrency.The DBMS creates a layer of abstraction over the file-system, with a dedicated data retrieval language (SQL), native concurrency capabilities (supporting several users reading/writing data at the same time), and the wrapping of user interaction into transactions that can be cancelled in case of errors.The DBMSs have also been used with image and vector data for a long time, and the possibility to define relations in the RDBMSs (Relational DBMS) offers a simple way to create robust data models.Adding the capacity to create point clouds as services, DBMSs solve almost all the problems we face when dealing with point clouds.Usually, the database stores a great number of tables, and each table stores a point per row (Lewis et al., 2012;Rieg et al., 2014).Such a database can easily reach billions of rows.Nevertheless, storing this many rows is problematic because DBMSs have a non-negligible overhead per row, which reduces the scaling possibilities, regarding the time it takes to create it, to index it, or in the final space it takes.These limitations have been studied and inspired NoSQL databases.Again, the proposed NoSQL databases are used to store individual points (Martinez-Rubi et al., 2014, 2015;van Oosterom et al., 2015;Wang et al., 2014).NoSQL database are stripped DBMSs that have been specially tailored for massive and weakly relational data.They scale extremely well to many computers.However, this comes at a price.NoSQL databases must drop some guarantees on data, are not integrated with other GIS data, and have much less functionality.Indeed, NoSQL databases are closer to being a file-system distributed on many computers (with efficient indexing) than being DBMSs.Thus massive scaling still necessitates specialised hardware, and the people to maintain it.

LOAD
A possible workaround for this issue is to externalise the storage3 to cloud computing facilities, like Amazon S3, but it suffers from the same aggravated limitations as the NoSQL.
Figure 2: Simplified schema for "Server reads" data loading All the previous data management systems try to solve a very difficult problem, managing massive number of points.The solutions that scale well must focus on data storage and retrieval, and drop the rest of the management problem.Recently, a new approach was proposed by pgPointCloud (2014).The idea is to manage groups of points (called patches) rather than points in a RDBMS.Creating this abstraction layer over points allows retention of all the advantages of an RDBMS, but without the overhead due to a great number of rows.Moreover, the proposed abstraction offers new theoretical possibilities.In this article, we present a point cloud management system fully based on pgPointCloud ( 2014) and open source tools.We test this system in every aspects of point cloud management to prove that it answers all the global needs of point cloud users.
Following the IMRAD format (Wu, 2011), the remainder of this article is divided into three sections.Section 2. presents the proposed system principles and details each of its parts.Section 3. reports on the experiments that validate each part of the system.Finally, the details of the system and new potential applications are discussed in Section 4.

METHOD
The proposed solution relies on a PostgreSQL (2014) RDBMS server using the PostGIS (2014) and pgPointCloud (2014) extensions.The key idea is to store groups of points into the server table.Groups of points are called patches of point.An XML schema defines the size and nature of each attribute for each point type.
The user can load data into the server by several common means (using major programming languages, Bash, SQL, Python), from any format of point cloud that can be expressed as a list of values.Point clouds are stored without loss and are compressed.The very sophisticated database indexes allow efficient filtering of the points.Point clouds can be used with vector and rasters and other point clouds.Metadata are integrated and exploited.Furthermore, point clouds can be easily converted into other GIS data (vector/raster).Processing methods are directly accessible within the database; more can be added externally or internally.Attaining points from the database is also easy and can be done in several ways (whole files, specific points and streaming).
Briefly, storing groups of points offers the advantages of generalisation (potentially more complex semantic objects), reduces the number of rows by several orders of magnitude, reduces index sizes, allows efficient compression, and offers a common framework for different types of points.Working on groups of points separates the filtering and retrieving of points.Groups can also be easily split or fused at any point after data loading.However, to obtain an individual point, we need to get the full group first.This means that grouping points is only possible when points can be categorised into groups that are coherent for the intended applications.
Choosing to use groups of points instead of individual points creates a generalisation of the data.For instance, if a group of points locally forms a plan, geometrically representing this group of points by a plan provides many more opportunities than just reducing storage space.The plan is another representation of the underlying object that has been sensed, and could be further used as a semantical part of another, more complex object (a building fac ¸ade, for instance by Lafarge et al. (2013)).We propose several generalisations that are tailored to different needs (Figure 9).

Loading
Writing data in a PostgreSQL RDBMS is standard.There are conceptually two kinds of solutions.Either the database reads the data ('server reads'), or a client connects to the server and writes the data ('client writes').Clients exist in all major programming languages.DBMSs are build for concurrency, we illustrate both of these methods with parallelism.
Parallel loading ('server reads') Our first loading method (Figure 2) reads point cloud files, convert them to a stream of attributes and writes them to temporary tables in the database.The database groups points into patches and adds the patches to the final point cloud table.This method mixes 'server read' and 'client sends' approaches.
Distributed parallel loading ('Client sends') In previous method, the database performs the grouping of points into patches and the actual writing of patches into tables.We could lessen the workload of the server by allowing the client do the grouping.We design a loading method of type 'client sends' (Python).
It is similar to the method adopted by the PDAL 4 project.The clients read point cloud files, group points into patches, and send the patches to the database.The database compresses the patches and writes them into the final point cloud table.

Point Cloud and Context
The RDBMS has been designed to create relationships between data.Our system manages point clouds rather than points.In particular, our system can store the full meta-data model, as well as more indirect meta-data like the trajectory of the sensor.It is also possible to use several point clouds together as well as mix point clouds and other GIS data (raster and vector), directly or after converting point clouds to other GIS data types.
Figure 3: Example of a data model to store metadata.A more realistic data model is given by Hofle (2007, p. 15).

Managing metadata
The point cloud server offers the perfect space to regroup all the metadata concerning the point cloud.Unlike a file, it is possible to create a real relational model of the metadata and to enforce it (automatically).It guarantees coherency and enables searching points with a given set of characteristics.For instance, looking for stereo-vision points rather than Lidar points for an application based on colours.
Extended metadata We can extend the classical notion of metadata a step further and consider that it also concerns the raw information that was used to create the point cloud.For Lidar point clouds, this would be the trajectory and position of the sensing device, along with the raw sensing files.For stereo point clouds, this would be the camera poses for every image used to construct the point cloud, along with the images.This information can be stored in the server, and leveraged in filtering (see Section 3.5) or processing.
Using several point clouds and other GIS data Point clouds are created by different sources, like stereo-vision, aerial Lidar, terrestrial Lidar, RGBZ device (Kinect), etc.The point cloud server mixes all this data, along with other GIS data (rasters and vectors).Vectors and rasters are stored and exploited using Post-GIS (2014).We can use geo-referenced point clouds together.For instance, a user asks for points in a given area.The user obtains points from a large 1 pt/m 2 aerial Lidar point cloud automatically complemented by a more detailed but very local 10 kpts/m 2 stereo-vision point cloud.

www.pdal.io
Coverage map Using the server, we create metadata-like point clouds coverage (Figure 7, 8), similarly to (Lewis et al., 2012, Figure 8).With this map, one can instantaneously and easily check what type of point cloud is available in a given area using a colour code (for instance).
Point cloud as raster or vector In the spirit of generalisation (see Section 2.), it is advantageous for some applications to convert points to other GIS data types, such as raster or vectors, directly within the database.We propose several in-base groups of points vector representation, such as bounding box, oriented bounding box, concave envelope similar to alpha shape (Edelsbrunner et al., 1983), and 3D plans (Figure 9).These representations can be used to extract information at the patch level, accelerate filtering, enable large scale visualisation, etc.We also propose two in-base means to convert points to multi-band rasters by a Z projection.Rasterisation is a common first step in the literature because neighbourhood relations are explicit between pixels, unlike points.

conversion to raster bilateral filter gradient Line detection
Figure 4: A piece of a point cloud is converted to a raster.We use bilateral smoothing, gradient (Sobel), and line detection (RRANSAC by Chum and Matas (2002)) to reconstruct the pedestrian crossing.These operations are much faster and easier on rasters rather than points.

Filtering Point Cloud
Point clouds are big; yet, we often need a very small part (Figure 5, parameters in 3.5 ).Thus, the capacity to filter a point cloud is essential for many uses.Acceleration structures are the accepted solutions.This essentially creates indexes on the data to accelerate searches.Octree, B-tree, R-tree, and Morton-curves are popular acceleration structures.Designing and optimising these indexes is a major research subject (see (Kiruthika and Khaddaj, 2014), for instance) and is also the main designing factor in point cloud management systems.
Filtering strategy Because our system stores patches (groups of points), we can separate the filtering and the retrieving of data.
Our strategy is to first efficiently filter data at the patch level (reducing points from billions to millions, for instance), then, if necessary, further filter the remaining points.
Indexing Our system extensively uses indexes (BTree, RTree) that are native to PostgreSQL.We index patches (not points).
Basically, these indexes answer in about 10ms to any filtering, such as 'What are the patches with f between .. and ..'; f can be anything, a spatial position, an attribute of the points, a function, etc.
Indexes of functions are very powerful and can save a lot of space (no need to add an extra column).For instance, we may have a fast function f that gives a measure in [0; 1] of how much the patch looks like a vertical cylinder.Now, when looking for all the patches p that really resemble cylinder ( f (p) > 0.8), for PostgreSQL also determines whether to use the indexes or not.In some cases, it will be faster to simply read all the data (sequential vs. random access).This decision is based on statistics on tables and a genetic optimisation.

Filtering example
The following query illustrates possible filtering.

Output
Similarly to Section 2.1, we divide the methods into two categories.The first family of solutions is that the server writes the points somewhere ('server writes').The second family of solution is when the client reads the data from the server and do something with it ('client reads').
Using PostgreSQL drivers/connector ('client reads') PostgreSQL can be accessed using many programming languages, thus any PostgreSQL driver can be used to connect to the server and output points.This work-flow is very similar to what a classical processing program would do, 'open point cloud file, read points, do processing, write results' becomes 'connect to server, read points, do processing, write results on the server or elsewhere'.
The additional capabilities are that the user does not have to read a whole file (or any files) if the user is interested in only a few points.Using the point cloud server, the user can directly filter the point cloud to obtain only the points desired, and even use in-base processing or LOD to further change the points obtained.
PLY File As a Service (PLYFAS) 'server writes' Our system can be used transparently with a file-based workflow.Indeed, users may already have legacy processing tools that work with files.Of course, these tools could be easily adapted to read points from the database and not from files, but users may want to use their usual tools as-is.For this case, we propose PLYFAS, an easy means to export points from the database and create a .plyfile.
The user can use the small PLYFAS API to request the database to create a ply file from any set of points.The user may simply want one of the exact original point cloud files that were loaded into the point cloud server.However, the user has also access to much more power and can request a file with filtered points by any means introduced in Section 2.3, or with the additional processing results of Section 2.5.For instance, the user can request all the points in a given area that have been classified as 'building parts' with a given confidence, and that were sensed during the second week of March 2014.
Massive parallel export ('client reads') We also designed a Python method to perform massive parallel export.Similarly to Section 2.1, the goal is to reduce the work done on the server and increase the work done on the clients.In this version, the server sends raw binary uncompressed patches (groups of points), and the transformation to points is done by the client.

Asynchronous point cloud streaming to browser ('client reads')
The last output possibility is to stream points in a web context.The goal is to display a point cloud into a web browser with background loading (i.e., the points are displayed as they arrive, the user keeps browsing and the loading is non-blocking).
For this, we use a Node.jsserver between the client and the point cloud server, which enables non-blocking interactions.From a point cloud server perspective, the task is standard (give points that are at a given place).

Processing Point Cloud with the Server
Processing point clouds We think it is important to offer both points and adapted tools to users.Our system can be used for processing in two ways.The most classical is out-of-base processing.A client obtains the points, does something, and writes the results in the server.However, our system also offers in-base processing.Processing methods become very close to the data and can be reused or combined to create more complex methods.It is also more practical because the client does not have to install anything (all methods are on the server).
An advantage of in-base processing is that it is easy to add new processing methods.These methods can be written for efficiency (C, Cpp) or using high level languages (Python, R) for very fast prototyping.The most useful in-base processing functions are fast and simple.This way, the newly written functions can be used in other aspects of the point cloud server, such as indexing, or be combined directly in SQL queries.For instance, SELECT t r a i n c l a s s i f i e r ( e x t r a c t p l a n ( p a t c h ) , e x t r a c t f e a t u r e 1 ( p a t c h ) , e x t r a c t f e a t u r e 2 ( p a t c h ) , . . . ) FROM p a t c h e s WHERE c o m p u t e v e r t i c a l i t y i n d e x ( p a t c h ) >0.8

General System
We design several experiments to test all parts of our point cloud server.All experiments have ample room for optimisation, and can be easily reproduced (open source tools).We use PostgreSQL 9.3, PostGIS 2.2, PgPointCloud 1.0, Python 2.7, and a recent (2014) version of Numpy and Scipy.
Result at the system level Overall, we load several billion points into the point cloud server, perform several processing in and out of base (s to hour), extensively use simple and complex filtering (ms and s), convert points to images and vectors, and output points (≥ 100k pts/s).The entire system works as intended and is efficient and powerful enough to be used in research settings.
Data sets used For this article, we use three data sets (including (IQmulus, 2014)).(See Figure 6).They were chosen to be as different as possible to further evaluate how proposed methods can generalise on different data (Figure 1).We emphasize that the Vosges dataset is a massive aerial Lidar point cloud covering mountains and forests.

Experiments Hardware
We tested all our methods on two settings.The development settings are portable (the point cloud server is hosted on a virtual box on an external drive), the server settings is powerful and offers much more storage place (12 cores, 20 Go RAM, SSD for OS, regular disk for storage, Ubuntu 12.04).
We try to provide timing, but these are orders of magnitude because of influence of caching and configuring.

Input
Parallel loading ('server reads') In one night, we aim at loading the data sensed by a Lidar system during one day, which is a practical Lidar management requirement.The points are stored in files, over a gigabyte network.We uses a dedicated program to convert the points file into ASCII values (CSV).We modified the RPly library5 for the .PLY point cloud, and use Lastool 6 for .lasfiles.The ASCII values are streamed to a 'psql' process that is connected to the database.The 'psql' executes a 'COPY' SQL command that reads the ASCII streams and creates and fills a table with the values from the ASCII stream.When the file has been fully streamed, we use an SQL query to create points from attributes and group them into patches.These patches are inserted into the final patch table.This pipeline (Figure 2) is executed several times in parallel, each pipeline working on a different file.
Distributed parallel loading ('client sends') In this experiment, we use clients to send uncompressed patches to the server.The clients read point cloud files (.ply in our experiment, using the plyfile 7 Python module ).Then, each client groups the points into patches using a custom Python module.The patches are sent to the server through Python.The server compresses these patches and adds them to the final point cloud table.This experiment is a proof of concept; therefore, we limit the number of clients to one computer, using seven threads.
Result We load Vosges and Paris data set through 'massive parallel loading', and stereo through 'out of database grouping' (Table 2 ).For both methods, the bottleneck is not the CPU but the input/output (I/O).Indeed, the point files are read over the network, and the point tables are stored on the SSD, but the final patch table is stored on the regular disk, which also limits how many threads can write data on it at the same time.
Result We load Vosges and Paris data set through 'massive parallel loading', and stereo through 'out of database grouping' (Table 2).For both methods, the bottleneck is not the CPU but the input/output (I/O).Indeed, the point files are read over the network, and the point tables are stored on the SSD, but the final patch table is stored on the regular disk, which also limits how many threads can write data on it at the same time.

Storing Point Cloud in Table
Grouping points Points must be categorised into groups that will make sense for subsequent uses of the point cloud.Groups   of points must be big enough to have a tractable number of rows, but not too big because getting only one point still necessitates obtaining the entire group.We designed grouping rules so that the number of rows is less than a few millions -i.e., fitting in server memory (Table 3).Moreover, this range of numbers of rows is classical for GIS software.We can afford to have very large groups as a result of the PostgreSQL TOAST8 storage system.
Grouping is done at data loading but can be changed at any time.Index creation is very fast (a few seconds to a few minutes), and the index size is ≤ 1 % of the point cloud size.
Indexes are built on the patches and not on the points, and thus are several orders of magnitude smaller and much faster to build.We estimate the size of indexes if we were to store one point per row rather than one patch per row (extrapolating index size and build time observed on 0.01 to 10 million-row tables).See Table 3.
Compressing point clouds Patches are compressed before storage.We compare loaded data-set space occupation on the server with original binary files on the disk.In our case, patches are compressed attribute-wise, with either a run-length, common bit removal, or zip strategy.Compressing efficiency widely varies depending on the data and the kind of attributes of the points.See Table 3.4.
Compressing and decompressing data introduces an overhead on data access.We estimate it by profiling the uncompress and compress functions.Again, the overhead is dependent on the type and number of attributes.For instance stereo contains double attributes that are compressed with the zip strategy, which is slower in compression.See Table 5.

Point Clouds and Context
Our point cloud server manages point clouds, as opposed to sets of points.First, we demonstrate the construction of several twodimensional (2D) vectorial visualisations of point clouds.We demonstrate the possibility to work on all point clouds at the same time, transparently for the user.Point clouds can also be used conjointly with other GIS data (raster and vector).Lastly, we demonstrate an example of use of the sensor trajectory meta-data.We created several visualisations for the Paris dataset, ranging from 5MByte to 100kByte, each adapted to a different scale.(see Figure 7) • 1:25 to 1:1500: Precise, occlusions visible (∼1m).
• 1:1500 to 1:15k: Help to understand road network structure (∼8m).As a proof of concept, we propose a coverage hexagonal grid (see Figure 8), conceptually identical to regular grid, with some benefits (see (Sahr, 2011)).The idea is to visualise both what was sensed and what remains to be sensed in a given area (here the whole of Paris), to help plan data-sensing missions.We fabricate an hexagonal grid over the extent of Paris (about30s), and remove the hexagons that are in buildings or too far from road (about 60s).Then we colour the hexagon depending on whether the point clouds cover it or not(about 30s) (Red is not sensed, blue is sensed).Such visualisation are easy to create (about 30 minutes), and could be tailored to more specific needs.Conjoint use with other GIS data We commonly used vector data with point clouds for various research projects.Here, the scenario is to provide points for a pedestrian crossing detection algorithm, at a given intersection of the road network (see Figure 5).

Using several point clouds
To demonstrate the possibilities, we use the following: • Corrected version of ODParis 9 building layer (350 k rows) • Lidar sensor trajectory (42 k points regrouped in 900 rows) • Road network data of BDTopo 10 (32 k rows) • Aerial photo of the area in a PostGIS raster table (110k rows, each 30 × 30 pixels), base pixel of 10 cm We simultaneously filter the massive Paris point cloud to obtain patches that include the following: • close to the intersection of street 'Palatine' and 'Servandoni' (≤ 10 m+ road width) • close to Lidar acquisition centre trajectory (≤ 3 m) • far from buildings (≥ 1 m) • with high density (≥ 1000 points /m 3 ) • where the aerial view has a colour compatible with street markings (240 ≤ mean intensity ≤ 350) The point cloud server finds all the patches concerned in 60ms (with index and optimally written query) (see Figure 5 and Table 6).
Point cloud as a raster or vector We construct abstract representations of patches that are sufficient for one task, and are much more efficient than using the points, including the following:  These generalisations are about 0.5% of the compressed patch size.
We also tested 3D generalisations, either by extracting primitives or using LOD.Lafarge et al. (2013) showed that the urban point clouds can be accurately represented by primitives.For instance, a dozen plans accurately explains (≤ 1cm) 70 % of this scene (Figure 9).We extensively tested an orthogonal approach, where instead of making a new object to generalise a group of points, we represent it by a subset of well chosen points of this group.The method and its applications (adaptive LOD, density analysis, and classification using density features) are explained in details in an article to be published.

Using trajectory with point clouds
We imported the Paris trajectory data (successive position of the Lidar sensor every few ms).In fact, using a constrained data model resulted in discovering errors in the raw trajectory data.Trajectory can be used for filtering point clouds (for instance, 3.5).
We demonstrate the use of trajectory for processing in the following scenario.The goal is to localise all the pedestrian crossings of the Paris dataset (few minutes).We (conceptually) walk along the trajectory, and every three metres we retrieve the patches closest to the trajectory.We use a crude marking-detection function on these patches (percent of points in given intensity range).Based on the score of the detection, we can favour recall or precision.
The diminution factor illustrates how much less data we would need to process with the pedestrian crossing method that would follow detection (Table 7).

Point Cloud Filtering
Filtering overview Overall, filtering is very fast on the point cloud server (about 100ms).Finding the points is almost always much faster than actually retrieving them.
Because of caching and the influence of how the query is written, we only provide order of magnitude here.Filtering patches using indexed function takes about 10ms, even when using many conditions at the same time.This includes filtering with spatial (2D and 2D+Z), temporal, any attributes, density, volume, etc.This also includes using vector generalisation.Filtering with other GIS data (vector) is slower (10s), except when special care is taken to optimise the query (10ms).This includes using distance to other vector layers, using other vector layer attributes (height of building), using time associated with vectors, etc. Lastly, very complex filtering may take from 10s up to several minutes depending on the number of patches concerned.

Output
Using PostgreSQL drivers/connector ('client reads') We create a Python methods that works on a client computer.It reads uncompressed patches from the server and directly writes them to disk (saving it as Numpy double array).Using seven parallel workers, the result is in Table 8.Client reads data: Streaming to browser We performed a test of point cloud streaming to a WebGL application, using a Node.jsserver as the 'man in the middle'.The browser is set to a geographical position, and then requests the points around this position to the Node.jsserver.The Node.js server connects to the point cloud database to request the points.The point cloud server uses indexes to find patches and extract points that are then streamed to Node.js server through cursor use.The Node.js server compresses the point stream and sends it to the web browser.The web browser parses the stream, puts the points into buffers, sends the points to the graphic card and display them through shaders.We observed a reduced throughput ( 20 k points/s) because data is inefficiently transmitted as text, and is serialised/deserialised multiple times.

Processing
We demonstrate how easy it is to create new in-base processing methods.As such the methods are only cited to illustrate this.Some details may be found in Cura (2014).
In-base processing Fast prototyping is vital for wider point cloud use.We demonstrate the potential of using high level languages within the database to write simple processing methods.The experiment is not to create state-of-the-art processing methods, but to measure what a Python/R beginner can do in two weeks (designing methods and implementing).
• * clustering points using Minimum Spanning Tree • * clustering points with DBSCAN (Ester et al., 1996) • * extracting primitives (plans and cylinder) • * extracting a verticality index (using Independent Component Analysis) • # detecting fac ¸ade footprint • # detecting cornerstones • # detecting road markings (*: directly working on patches, can be used out of the box on all point clouds; #: working on rasterised point clouds, need to use a point cloud to raster conversion method first) We also used the server for complex out-of-base processing (classifications).

DISCUSSIONS
Storage in base Currently point cloud types are strongly constrained, thus adding or removing attributes is not immediate.2) shows that data loading could be much faster.Most notably, directly reading the raw sensor data and streaming it to the database using PostgreSQL binary format would be much more efficient.We emphasise that a relatively recent initiative, PDAL11 has gained maturity, and would be the ideal candidate to solve these two limitations.
The PostgreSQL rule system would be the perfect candidate to use thousands of point clouds together.Metadata can be stored in our server, but a standard minimal data model would be necessary to facilitate exchanges, similar in spirit to the INSPIRE12 European directive.
Conjointly using vectors, rasters and point clouds offers a new world of possibilities.We face data fusion issues, like difference in precision, generalisation, fuzziness, etc.Moreover, vector, raster and point cloud data may be acquired at different dates.

Filtering point clouds
The point cloud server offers a powerful filtering structure, especially when using other GIS data.It would be possible to go much further towards complex filtering, by performing algebra between several rasters, using attributes of vectors to filter patches, etc.Our entire strategy relies on filtering patches first, then filtering points.In cases when the patch filtering condition does not filter much, the system is much less interesting.
Output The point cloud server can output data in many ways and thus be easily integrated into any work-flow.We, however, feel that the current speed (100 k points /s, around 2 MByte /s) is too low.It could be easily accelerated using binary outputs and by decompressing patches directly on clients.Perhaps the true evolution of the point cloud server would be to stop delivering points, and instead deliver a service that could be queried through standard mechanisms.For instance, the transactional Web Feature Service (WFS-t) format could be used to send points out of the box, simply using a geo-server between the client and the point cloud server.This could be a revolution in point cloud availability, similar to what happened to geo-raster data (e.g., google map WFS).
Processing In-base processing offers many opportunities because it is close to the data and can be written with many programming languages.Yet, it is also intricately limited to one thread and the amount of memory allowed for PostgreSQL.The execution is also within one transaction.It may also be hard to control the execution-flow, during the execution.However, the Python access both from within and outside the database shows the possibility to write more ambitious processing methods with several parts executing in parallel as well as communicating, dealing properly with errors, etc.
Perspective for applications Patches and their generalisations are perfect candidates to perform fast and efficient registration (cloud-to-cloud, cloud-to-raster, etc.).Indeed, the classical solution for registering a massive point cloud is to sub-sample it.Using extracted primitives would be better.Having all the meta-data, the trajectory (or camera position matrices), and the raw data, it would be possible to change the trajectory (matrices) and regenerate the point cloud with updated coordinates, all of this from within the database.Processing of point clouds would extract landmarks, which could be matched with a landmark database.It would be possible to mix PostGIS Topology (2D partition of the space) for graph queries.

CONCLUSION
In this paper, we presented a complete point cloud server system based on groups of points (patches).Using these patches as generalisations, we fulfil all point cloud user needs (loading, storing, filtering, exporting and processing).The system is fully open source and thus easily extensible and customisable using many programming languages (C, C++, Python, R, etc.).Our system opens new possibilities because of intricate synergy with other geo-spatial data.Lastly, we proved through real-life uses that this system works with various point cloud types (Lidar, stereo-vision), not only for storing point clouds, but also for processing.As perspective, we could explore in-base re-registration from trajectory and raw data, in-base cloud-to-cloud registration, in-base classification, and point streaming, as well as scaling to thousands of billions of points.

Figure 1 :
Figure 1: In-base point cloud management pipeline.

Figure 5 :
Figure 5: Among billions of points, only those respecting complex filtering conditions are kept.Results are shown in QGIS.Parameters in 3.5 SELECT g i d , p a t c h FROM tmob 20140616 .r i e g l p c p a t c h s p a c e WHERE / * f i l t e r i n g c o n d i t i o n * / / * s p a t i a l f i l t e r i n g * / S T I n t e r s e c t s ( p a t c h : : g e o m e t r y , . . . ) = TRUE / * f i l t e r i n g on a f u n c t i o n * / AND P c N u m P o i n t s ( p a t c h ) BETWEEN 10 AND 1000 / * f i l t e r i n g on an a t t r i b u t e r a n g e * / AND r c c o m p u t e r a n g e f o r a p a t c h ( p a t c h , ' g p s t i m e ' ) && numrange ( 1 3 , 1 4 ) / * f i l t e r i n g on o r i g i n a l s o u r c e f i l e name w i t h r e g e x p * / AND f i l e n a m e ILIKE E ' .* TerMob .* 2 .p l y ' / * k e e p i n g o n l y p o i n t s t h a t a r e i n s i d e b u i l d i n g s ( v e c t o r l a y e r ) * / AND EXISTS ( SELECT 1 FROM o p d a r i s c o r r e c t e d .v o l u m e b a t i WHERE S T I n t e r s e c t s ( p a t c h : : g e o m e t r y , v o l u m e b a t i .geom ) )

Figure 7 :
Figure 7: Successive visualisations of point cloud coverage, see 3.5 for details • 1:15k to 1:200k: Use the trajectory.If not available, fabricate a trajectory-ersatz through basic straight skeleton • ≥1:200k: A simple point with text attributes for details.

Figure 8 :
Figure 8: Visualisation of to-do hexagonal map.Blue when sensing data, red otherwise
Inheritance between point types would solve this.Our point cloud server is based on only one computer.To scale over the 10 trillionpoints range, we would need to use supplementary PostgreSQL sharding and clustering capabilities.Input Examining (Martinez-Rubi et al. (2014), Table

Table 1 :
Point cloud data-sets used, with some figures.AL stands for aerial lidar, TL for terrestrial lidar and SPC for stereo point cloud.

Table 2 :
Loading time for each point cloud data set.

Table 3 :
Creating and indexing patches for the test data set compared to non-grouped scenario.Grouping rules are: 50 =

Table 5 :
Analysing compression and decompression computing cost.

Table 6 :
Result of filtering.
As a proof of concept of integration of several point clouds, we demonstrate the conjoint use of stereovision point cloud and Lidar point cloud.For this experiment, we choose to use PostgreSQL inheritance mechanism.The idea is to create a 'parent' table.We set the Lidar table and stereo-vision table to be a 'child' of the 'parent' table.Then we can query the 'parent' table as if it was a super-point cloud comprised of all the others.Querying the 'parent' point cloud is as fast as querying one point cloud, and we correctly attain points from both point clouds.

Table 7 :
Result of pedestrian crossing detection.