Extractie van vlakken in grote 3D puntwolken voor het gebruik in cartografie

Transcriptie

1 Extractie van vlakken in grote 3D puntwolken voor het gebruik in cartografie Jeroen Penninck Promotoren: prof. dr. ir. Wilfried Philips, prof. dr. ir. Sidharta Gautama Begeleiders: dhr. Werner Goeman, dr. ir. Ljubomir Jovanov Masterproef ingediend tot het behalen van de academische graad van Master of Science in de ingenieurswetenschappen: computerwetenschappen Vakgroep Telecommunicatie en Informatieverwerking Voorzitter: prof. dr. ir. Herwig Bruneel Faculteit Ingenieurswetenschappen en Architectuur Academiejaar

2 Toelating tot bruikleen De auteur geeft de toelating deze masterproef voor consultatie beschikbaar te stellen en delen van de masterproef te kopiëren voor persoonlijk gebruik. Elk ander gebruik valt onder de beperkingen van het auteursrecht, in het bijzonder met betrekking tot de verplichting de bron uitdrukkelijk te vermelden bij het aanhalen van resultaten uit deze masterproef. Jeroen Penninck 2 juni 2014 i

3 Dankwoord Graag zou ik iedereen willen bedanken die heeft bijgedragen tot de verwezenlijking van dit eindwerk, in het bijzonder dank ik: alle personen die aanwezig waren op de proefpresentaties, voor de feedback die ervoor gezorgd heeft dat deze thesis nog sterk veranderd is. Grontmij voor het scheppen van de mogelijkheid om dit onderzoek te verrichten. mijn thesisbegeleiders ir. W. Goeman en dr. ir. L. Jovanov, voor de begeleiding en feedback tijdens het schrijven van deze thesis. ii

4 Extractie van vlakken in grote 3D puntwolken voor het gebruik in cartografie. door Jeroen Penninck Afstudeerwerk ingediend tot het behalen van de graad van Master of science in de ingenieurswetenschappen: computerwetenschappen Academiejaar Universiteit Gent Faculteit Ingenieurswetenschappen en Architectuur Promotor: prof. dr. ir. Wilfried Philips, prof. dr. ir. Sidharta Gautama Samenvatting In het gebied van Mobile Mapping wordt met een speciaal uitgerust voertuig door de straten gereden om informatie over die straat te verzamelen. Deze informatie kan dan gebruikt worden om kaarten te maken. De opkomst van laserscanners, die op het dak van zo een voertuig kunnen geplaatst worden, heeft er voor gezorgd dat er nu puntwolken van volledige straten, dorpen en steden gegenereerd kunnen worden in een korte tijd. Deze puntwolken bevatten enorm veel interessante informatie maar moeten momenteel nog voornamelijk manueel verwerkt worden. In deze thesis wordt gewerkt naar een systeem dat automatisch gevels selecteert uit deze puntwolken en de gevonden gevels vergelijkt met een bestaande kaart. Om dit te verwezenlijken wordt er gewerkt in verschillende stappen. Eerst wordt er onderzocht op welke manier deze puntwolken het best kunnen verwerkt worden en worden de voor- en nadelen van bestaande algoritmen voor vlakkendetectie bekeken. Een eerste stap is namelijk het zoeken van vlakken in deze gigantische puntwolken. In deze thesis zal de puntwolk eerst opgedeeld worden in een rooster en zal op elk roosterstuk een variant van het voxel growing algoritme worden toegepast. Bij voxel growing wordt de puntwolk onderverdeeld in kubussen genaamd voxels en worden gelijke vlakken uit naburige kubussen samengevoegd. Er wordt in deze thesis een alternatieve lokale en globale vergelijking van deze vlakken gebruikt tijdens het samenvoegen. Nadat de vlakken gekend zijn wordt er ook onderzocht of en hoe het mogelijk is om de gevels te selecteren uit deze vlakken. Er zal gewerkt worden met een aantal heuristieken die als doel hebben om zoveel mogelijk vlakken die geen gevels zijn te verwijderen of om de gedetecteerde gevels te corrigeren. Natuur zal zo verwijderd worden door een nieuwe natuurdetectie heuristiek en er is ook een nieuwe heuristiek die de gevel inkort als er een stuk van de puntwolk teveel aan de gevel toegevoegd werd. Tot slot wordt onderzocht of het mogelijk is om deze gevonden gevels op een automatische manier te vergelijken met een bestaande kaart en hoe goed dit werkt. Trefwoorden: Vlakkendetectie, grote puntwolken, cartografie, natuurdetectie, gevels, automatisatie iii

5 Facade detection in large 3D point clouds for the use in cartography Jeroen Penninck Supervisor(s): prof. dr. ir. W. Philips, prof. dr. ir. Sidharta Gautama, dhr. W. Goeman & dr. ir. L. Jovanov Abstract By using laser scanners in the area of Mobile Mapping it is possible to collect point clouds of entire cities in a short time. These point clouds contain large amounts of useful information but are still processed manually, which is very labour-intensive. In this paper we will present a new method that can process these point clouds in an automated way. In the first step of this system the planes in the point cloud should be detected. We will propose a technique that can detect planes in these point clouds based on voxel growing. This method works on point clouds of any size and uses a different local and global planarity constraint than the original algorithm. Once the planes are detected we proceed with the detection of the facades. This process consists of multiple steps. In one of the steps we will also introduce a technique called nature detection. This technique will help in avoiding false facades by detecting and removing nature first. Keywords point clouds, Mobile Mapping, facade detection, nature detection I. INTRODUCTION IN the area of Mobile Mapping, the information needed to make maps is collected by driving through the streets with special vehicles. These vehicles are equipped with all kinds of sensors. The introduction of laser scanners however made it possible to collect huge amounts of data in a very short time. Laser scanners can be placed on the roof of such a vehicle and collect the information needed to generate a point cloud of the whole street. These point clouds contain a large amount of information about the street but are unfortunately manually processed in most cases. In this paper we will investigate possibilities to automatically select facades from these point clouds. We will work towards a system that can tell the user which areas of an existing map are out of date. This way the user can focus on those areas of the map. II. EXISTING TECHNIQUES FOR PLANE DETECTION IN POINT CLOUDS In the literature there already exist a number of techniques to detect planes in point clouds. Most of these algorithms however are based on one of three techniques: region growing, the Hough transformation [1] or the RANSAC algorithm [2]. Region growing starts by estimating the normal in each point of the point cloud. After that neighbouring points that lie on the same plane are grouped together. For this technique to work, the neighbours of each point in the point cloud should be known. For this reason this technique is often used on range images where neighbouring pixels are neighbours in the point cloud. A variation of the region growing algorithm segments the point cloud by also looking at the color of an area like in [3]. J. Penninck is a Software Engineering student at Ghent University (UGent), Gent, Belgium. Jeroen.Penninck@gmail.com. Another variation named voxel growing [4] works on point clouds instead of range images. In this variation the point cloud is first divided into voxels. For each of these voxels a normal and a score is calculated. Planes in neighbouring voxels are then merged together if they match. Inside a voxel, noise is removed by removing points where the normal deviates too much from the normals of the surrounding points. The second technique, the Hough transformation was originally developed for detecting shapes and patterns in 2D images. This technique can also be applied to point clouds. To use the Hough transformation a model must be selected for the shape the algorithm needs to find. The parameters in this model must have a limited range. All possible instantiations of this model can then be represented in a matrix, the accumulator, where each dimension of the matrix represents one of the parameters in the model. The algorithm then runs through all the points in the point cloud. For each point all the possible instances of the model that go through that point are listed and the algorithm increases all the matching positions in the matrix by one. At the end the algorithm searches a cell in the matrix with the highest value. This cell will represent the instantiation of the model with the most points that go through it. The Hough transformation has a large number of variations that try to solve problems of the algorithm. Some of these variations are presented in [5]. One group aims at the reduction of the execution time of the Hough transformation. In the original version for each point in the point cloud almost all the positions in the matrix need to be modified. Reducing the size of the matrix also reduces the precision of the result, which is undesirable. These variations try to decrease the number of cells that need to be accessed for each point. Another group of variations focus on solving problems with the representation of the accumulator. The accumulator is not uniform for each model, in other words not every position in the matrix has an equal chance of containing an instantiation of the model. Other algorithms based on the Hough transform aim at the reduction of noise. In [6] for example, the normals in each point of the point cloud are estimated first to improve efficiency. Furthermore a hierarchical accumulator is used to save space and a Gaussian filtering is used to reduce the influence of noise. The last technique, RANSAC, tries to find a correct model for the points in the point cloud by selecting a random minimal set of points needed to fill in the model. This random instantiation of the model is then tested against the other points of the point cloud. RANSAC selects multiple random instantiations of the model and keeps the one that matches with the most points in

6 the point cloud. RANSAC can also be used to detect multiple planes in a point cloud by using the sequentially RANSAC variant from [7]. This variant applies RANSAC and removes the points from the point cloud that belong to the detected plane. After that RANSAC is reapplied and this loop continues until a certain stop condition is fulfilled. A large number of algorithms based on the above approaches exists in the literature. However, most of the proposed approaches offer only small incremental improvements. Multiple planes can be detected by removing the ones that where already found from the point cloud and applying the algorithm again. Estimating normals in each point of the point cloud can allow some operations to go faster and RANSAC works better by working hierarchically when the point cloud contains multiple planes. Other variations use information that is specific for a certain application to improve the efficiency of the algorithm or try to get specific information from the point cloud. III. THE PROPOSED APPROACH A. Detection of planes in a large point cloud Since we will work with point clouds of entire cities, it is not possible to keep the complete point cloud in memory. Therefore the point cloud will be divided into a grid. Each cell of the grid will be processed independently. This way we only have to keep one cell in memory at each time. Another option would be to stream the point cloud. However, this is more complex because areas can be visited multiple times and the information from the previous visit might already have been removed from memory. This is not a problem when using a grid which results in a more efficient approach. Merging planes would also be more complex because it is not clear what the boundaries are of the points that are in memory at each moment. When using a grid the boundaries of the point cloud that is currently in memory are very clear. The main drawback of the approach based on a grid is the introduction of a preprocessing step needed to divide the point cloud into subsets corresponding to each cell. To detect the planes in one cell of the grid we use a technique from the literature called voxel growing combined with the sequential variant of RANSAC. We split the point cloud from the cell into voxels. Voxels are the 3D version of pixels and are used the same way in voxel growing as the pixels of a range image are used in region growing. Instead of estimating one normal in each voxel however, we allow multiple normals in each voxel. Voxels that are on the corner of a building for example will contain two normals. To detect the normals of the planes in a voxel we will use the sequential variant of RANSAC. When all planes in a cell are found, the points belonging to these planes are written into files and only the normal and position of the plane are kept in memory. This information is enough to merge planes in neighbouring cells in the grid. After the complete grid is processed and all planes are merged, it is possible to loop through the planes and read the points belonging to them from one or multiple files. A.1 Comparing planes in two voxels Testing which planes in neighbouring voxels can be merged also occurs in a different way than in the original voxel growing algorithm. Points belonging to the plane are not used in this merging step, only the normal and position information of a plane is used. First the angle between the planes is tested. The angle between the planes has to be smaller than a certain small angle α. This is tested using the dot product between the two normals n plane1 and n plane2. We assume the normals have a unit length. The test can be written as: Planes equal based on angle n plane1 n plane2 > cos(α) (1) Next the distance between the two planes is tested. If two planes are parallel but the distance between them is large, they should not be merged. Because the planes are not necessary parallel, the distance between two planes is not clearly defined. The planes could intersect, but it is the distance between the planes at the border of the two voxels that interests us. We estimate this distance as follows. First we take a point at the border between the two voxels, for example the centre point of the border. Then we calculate the distance from both planes to that point. This distance is calculated perpendicular to the plane and because the planes are approximately parallel these distances will be measures along approximately the same line to the same point. The difference of these distances to that point results in a good estimation of the distance between the two planes in the area around the border of the two voxels. Formally we can write this as: with planes equal based on distance dist(v 1, p) dist(v 2, p) < t dist dist(v 1, p) = d 1 + a 1 p x + b 1 p y + c 1 p z where a 1 x + b 1 y + c 1 z + d 1 = 0 is the equation of the first plane v 1 = (a 1, b 1, c 1, d 1 ) T and a 2 x + b 2 y + c 2 z + d 2 = 0 is the equation of the second plane v 2 = (a 2, b 2, c 2, d 2 ) T. The centre point between the two voxels is p = (p x, p y, p z ) T. Parameter t dist contains the maximum allowed distance between two planes. A.2 Parameters For the size of the grid we use 20 metres by 20 metres. Depending on the resolution of the point cloud it might be necessary to choose an even lower value for one cell to fit in memory. The allowed angle between two planes is set at 15 and the allowed distances between two planes in neighbouring voxels is 1 dm. Another parameter is the voxel size. This size depends mostly on the used point cloud. In this paper we use a value of 2 metres. The main motivation for such a choice of this parameter is the fact that some areas in the used point cloud contain gaps of 1 metres between two lines of points.

7 Fig. 2. The first selection of facades: A) all the planes that are perpendicular to the ground B) the planes that also have more than 30 points C) the planes that are also higher than 2.5 metres a Fig. 1. The results of the plane detection for four cells in the grid. a) Planes in different voxels before merging b) Resulting segments in the point cloud It is also necessary to define the parameters for using RANSAC in a voxel. We set the number of iterations to 30 and the inlier distance to 5 cm. 5 cm is twice the precision of the Riegl LMS-Q120 laser scanner 1. A.3 Results The result after the plane detection can be seen in figure 1. In the left side of the figure, red and blue represent the biggest planes that are found in respectively the even and odd voxels. The second planes found in a voxel are coloured yellow and light blue. On the right side we see the resulting segments in the point cloud. We can see that the segmentation works very well. Facades of buildings are segmented as single plane. In the algorithm above we merge planes in two neighbouring voxels based on a local comparison. However, because of this, walls that are curved a little over a long distance are detected as planes while they are not. In the original voxel growing paper the authors used a method to take the global planarity into _DataSheet_LMS-Q120_ pdf b account. The technique used in the paper however assumes that the points belonging to the plane are available when merging, which is not always the case in our method. In our algorithm, when two neighbouring voxels in different cells of the grid are merged, the point clouds of neither one of the cells are in memory. Local merging works fine without these points, but because the points are no longer available, it is difficult to test for global planarity. Global planarity can however be applied in a post processing step quite easily. After the plane detection method has found all the planes, we can loop through them and read the points from file. The number of points belonging to a single semi plane should be a lot smaller than the number of points in a point cloud containing a city. One plane should fit in memory. Then we can reprocess these semi planes and split them in multiple planes based on the global planarity. It is for example possible to regrow the plane using the voxel growing technique. This time however, all points are available and the global planarity can be tested. B. Finding the facades In the previous section we segmented the point cloud and detected the planes in it. In this section we will select the facades from the planes we found. B.1 A first selection We first preform an initial selection of facades. In the first step the angle between the facade and the ground is checked. To test the angle we can use the dot product like in equation (1). In this case however, the formula can be simplified to: plane perpendicular to ground n z < cos(90 α) where n z is the z-component of the plane normal and α is the allowed variation of the angle between the facade and the ground.

8 In this paper we choose a value of 20 for α. Besides the angle, it is also necessary to check if the candidate facade contains a sufficient number of points and if it is higher than the minimal height. A facade should contain at least 30 points. The minimal height is used to remove small walls. This parameter is set to 2.5 metres. The results of this very simple first selection can be seen in figure 2. As we can see in this figure a lot of the planes are already removed by applying this first selection. From the wrong planes in 2 A only 22 % remain in C. The filter on height also removed 2 correct facades. B.2 Displaying walls on the map To display the segments on the map (see figure 2) we represent each point in the point cloud of the plane as a linear combination of the vectors n, q and u = e z, where n = (x, y, 0) is the normal of the plane in the XY-plane, e z is the unit vector in the z direction and q is the other vector needed to make a basis and is calculated as q = e z n. The last formula can be simplified as q = (y, x, 0) T. Each point can be written as a linear combination of these previous vectors by calculating q point = p q q q n point = p n n n u point = p u u u To determine the bounds of the wall we have to calculate the minimum and maximum values for q point, n point and u point for the points belonging to the wall. The height of the wall can then be calculated as u max u min. The length of the wall as q max q min and the width of the wall can be calculated as n max n min. On the map the line is drawn from A = n c n + q min q to B = n c n + q max q. B.3 Wrong facades after the first selection Some planes are still wrongly classified as facades. We can group these erroneous planes in a number of different categories. Some examples can be seen in figure 3. The first group of wrong planes is called random detected planes. These errors are most frequent and occur in the areas where a large number of points lie in an unstructured piece of the point cloud. These areas are caused mostly by bushes and trees, which we will further refer as nature. The proposed plane detection method detects some false planes in these areas. If a falsely detected plane in such an area is perpendicular to the ground, high enough and has enough points, we detect a facade. Examples of these problems can be seen in figure 3, part A and B. Another group of errors occur because of poles in the point cloud. Poles are not facades, but they are also high and perpendicular to the ground and could contain enough points to be detected as a facade by the first selection. There are some problems with the calculation of the line of a facade. Some facades are drawn too long on the map like the Fig. 3. This figure shows some of the planes that are not removed by the first selection. example in figure 3 D where some points cause the line on the map to go past the corner of the building. Examples of the last group can be seen in figure 3 C. We call this group standing walls. In this figure we can see walls that are much alike facades. Some planes in the point cloud can not be differentiated from real facades by only looking at the properties of the planes. The first selection is not perfect. In the following paragraphs we will look at some of those errors and propose a method to remove them from the result. B.4 Nature detection As explained in the previous section, the largest amount of wrong facades are caused by random detected planes. These planes are mostly caused by trees or other natural objects. We propose a new method that detects voxels containing nature and removes them from the point cloud. The proposed approach is inspired by the fact that the areas containing facades are typically composed of only a few planes in the observed voxels. The largest part of a facade is contained in one plane. Corner of buildings can have up to three planes that contain almost all the points in the voxel. When looking at a tree we may observe something different. There are many

9 Fig. 4. Result of the first version of the nature detection heuristic with a = In this figure the voxels that are detected as nature are shown in green. Other voxels are displayed in red or blue. a Fig. 6. a) the result of the nature detection the previous heuristic b b) the difference with the result of planes are also part of the sum. The decision criterion then becomes: Voxel with nature k v i + i=1 c j=k+1 test(n i ) v j < a v Fig. 5. Another result of the first version of the nature detection heuristic. On the corner of the house there are two voxels that are detected as nature which is unwanted. planes in the tree, but most of them are very small and only contain a fraction of the points in the voxel. We test this by looking at the fraction of the points in the voxels that lie in the two biggest planes. Based on this observation we write: voxel with nature voxel with facades k v i << v i=1 k v i v i=1 where v i is the i-th plane in the voxel with j (j < i v j v i ), i [1, c] and v is the total amount of points in the voxel and k = 2. With the introduction of a parameter a the decision becomes: voxel with nature k v i < a v i=1 This heuristic criterion performs very good at detecting nature in a point cloud as we can see in figure 4. However at some places the corners of buildings are erroneously detected as nature like in figure 5. This happens for the windows of the particular house because the windows are detected as a different plane than the rest of the wall. In the corner region this results in four planes with an equal number of points: two windows and two walls. To solve this problem we use a variation of the proposed approach where planes that are parallel or perpendicular to the two biggest with test(n i ) = k i=1 ( n i n j > cos(α) n i n j < cos(90 α)) where α is the allowed deviation of the angle and n i is the normal of the plane v i. The results can be seen in figure 6. It can be seen that most of the planes that were part of this group are successfully removed from the result. Table I shows that 70% of the remaining errors are removed by the nature detection technique. B.5 Removing poles and standing walls The second group of errors ( poles ) can be removed easily by looking at the width of a wall. In table I the walls less than 0.75 metres wide are removed. After applying this heuristic only 6 wrongly detected facades remain. These remaining errors are all examples of the standing walls category. The remaining falsely detected walls could be removed by observing that these walls do not occur in groups like facades of buildings do. C. Results For each filter step, the results can be seen in table I where the row named angle contains the number of planes with a certain angle from the ground. In the row # points the planes which do not have enough points are removed, height is the result of looking at the height of the planes, nature shows the result of the nature detection and width shows the number of planes that are removed by looking at their width. The first row in the table contains the number of planes detected in the point cloud by using the proposed plane detection technique. In this table we can see that the combination of all these filters results in the removal of 1481 planes or 99.6% of the planes that were detected while only resulting in 2 wrongly removed walls. In the final result only 6 walls are still wrongly classified as facades.

10 Filter Correct planes after Total planes after Incorrectly removed planes Correctly removed planes no filter angle # points height nature width TABLE I THE RESULTS OF THE DIFFERENT SELECTION STEPS ON THE NUMBER OF WRONGLY CLASSIFIED FACADES. The results of the facade selection on a larger area can also be seen in figure 7. In this figure we can see that the proposed method also works good for other areas of the map. IV. CONCLUSIONS In this paper we propose a technique for detecting planes in large 3D point clouds based on voxel growing. This technique used a different local and global planarity requirement to support working with large 3D point clouds. Instead of calculating the normals in a voxel, we have used a different approach based on RANSAC. This allows us to detect multiple planes in a voxel. The results of this segmentation were very good. Facades were clearly segmented in the point cloud. The next step was the selection of facades. For this task we propose five filters, which performs the classification of the planes based on angle with the ground, the number of points and the width and the height. One of the filters named nature detection performs the detection of nature objects in the point cloud. We propose this filter in order to prevent false detections of natural objects as facades. Together these filters managed to remove 99.6% of the erroneous facades while resulting in only two false negatives. The results in this paper show that it is possible to automatically process point clouds of cities and select useful information from them. Further development could focus on improving the facade detection even more or on comparing the facades that were found with the facades on an existing map. This comparison could allow the algorithm to inform the user which areas of the map are outdated. ACKNOWLEDGEMENTS This paper is based on the thesis Extraction of planes in large 3D point clouds for the use in cartography. The authors would like to acknowledge the suggestions of many people during the creation of this paper and the thesis. The point clouds where provided by Grontmij Belgium and the maps are from the Grootschalig Referentie Bestand (GRB, agiv.be/). REFERENCES [1] Paul VC Hough, Method and means for recognizing complex patterns, Dec , US Patent 3,069,654. Fig. 7. The result of the facade selection on a larger part of the map. The red lines represent the facades that were found by the algorithm. An existing map can be seen in the background. [2] Martin A Fischler and Robert C Bolles, Random sample consensus: a paradigm for model fitting with applications to image analysis and automated cartography, Communications of the ACM, vol. 24, no. 6, pp , [3] Johannes Strom, Andrew Richardson, and Edwin Olson, Graph-based segmentation for colored 3d laser point clouds, in Intelligent Robots and Systems (IROS), 2010 IEEE/RSJ International Conference on. IEEE, 2010, pp [4] Jean-Emmanuel Deschaud and François Goulette, A fast and accurate plane detection algorithm for large noisy point clouds using filtered normals and voxel growing, in Proceedings of 3D Processing, Visualization and Transmission Conference (3DPVT2010), [5] Dorit Borrmann, Jan Elseberg, Kai Lingemann, and Andreas Nüchter, The 3d hough transform for plane detection in point clouds: A review and a new accumulator design, 3D Research, vol. 2, no. 2, pp. 1 13, [6] Rostislav Hulik, Michal Spanel, Pavel Smrz, and Zdenek Materna, Continuous plane detection in point-cloud data based on 3d hough transform, Journal of Visual Communication and Image Representation, vol. 25, no. 1, pp , [7] Hakim Boulaassal, Tania Landes, Pierre Grussenmeyer, Fayez Tarsha- Kurdi, et al., Automatic segmentation of building facades using terrestrial laser data, International Archives of Photogrammetry, Remote Sensing and Spatial Information Systems, pp , 2007.

11 Inhoudsopgave 1 Inleiding 1 2 Situering 3 3 Probleemstelling 5 4 Werkopstelling Voorbeelddata Referentiedata Het Grootschalig Referentie Bestand raadplegen liblas Point Cloud Library (PCL) Literatuur: detecteren van vlakken en andere geometrische vormen Soorten technieken Gebiedsuitbreiding ( Region growing ) Hough transformatie RANSAC (RANdom SAmple Consensus) Variaties in de literatuur Variaties op de gebiedsuitbreidingstechniek Variaties op de Hough transformatie Variaties op de RANSAC techniek Conclusie Voor- en nadelen van de algoritmen x

12 6 Detectie van vlakken in een grote puntwolk Te grote puntwolken Algoritme Benodigde componenten van het voorgestelde algoritme Parameters kiezen Vlakken vergelijken Parameters kiezen Vlakkendetectie binnen één roosterstuk Parameters kiezen Opmerking over vlakheid Resultaten Gevelclassificatie Een eerste heuristiek: basis gevel selectie Hoek met de grond Minimale hoogte & Minimaal aantal punten Keuze waarden parameters Resultaat Weergeven gevels op kaart Fout gedetecteerde gevels met de simpele heuristiek Verbeterde gevelclassificatie Verbetering: palen verwijderen Verbetering: muren inkorten Verbetering: onzekere positionering gevels Verbetering: natuurdetectie Verbetering: negeren losstaande muren Verbetering: opsplitsen van kromme muren Conclusie en resultaten van de gevelclassificatie Vergelijken van de gevonden gevels met een kaart Op een efficiënt manier zoeken van naburige lijnen: het lijnzoekrooster xi

13 8.2 Vergelijken van gevonden lijnen met lijnen in het GRB Inlezen van de GRB data Vergelijken gevels GRB en puntwolk De kans op een nieuwe en verwijderde gevel Beslissen nieuwe gevel, verwijderde gevel en gevel met afwijking Resultaten Totaalbeeld Schematische voorstelling van volledige methode Uitvoering op een grote puntwolk Uitvoering op een grote puntwolk met een hoge dichtheid Bespreking uitvoeringstijd Besluit 71 xii

14 Lijst van figuren 2.1 Voertuig gebruikt in Mobile Mapping Een voorbeeld van een laserscanner (Riegl Q-120) Puntwolk met zeer veel detail Gegeven puntwolk met lage densiteit Een stuk kaart uit het Grootschalig Referentie Bestand Vlaanderen Logo van de liblas bibliotheek Logo van de Point Cloud Library Stappen in gebiedsuitbreidingsalgoritme Hough transformatie: lijnruimte Hough transformatie op 2D lijn: stap Hough transformatie op 2D lijn: stap Hough transformatie op 2D lijn: stap Schematische weergave van het RANSAC algoritme Analogie van gebiedsuitbreiding en voxel growing Algoritme opsplitsing puntwolk in een rooster De hoek tussen twee vlakken vergelijken De afstand tussen twee vlakken vergelijken Schematische weergave van het verwerken van een roosterstuk Minimum grootte voxels Maximum grootte voxels Gekozen voxelgrootte Opsplitsing van een puntwolk in een rooster xiii

15 6.9 Gedetecteerde vlakken in de voxels Gedetecteerde vlakken in de roosterstukken Vlakken in de puntwolk die loodrecht op de grond staan Schematische weergave van het bepalen van een lijnstuk voor een segment Door toeval foutief gedetecteerde gevels Palen worden soms foutief als gevel gedetecteerd Losstaande muren, verkeersborden en reclameborden worden soms foutief als gevel aanzien Sommige stukken gevel die aanwezig zijn in de puntwolk worden niet gedetecteerd Overige problemen met de eerste versie van de geveldetectie Palen worden nu niet meer foutief gedetecteerd als gevels Schematische voorstelling van een muur die te breed wordt weergegeven op de kaart Resultaat van de heuristiek voor het inkorten van een lijn Onzekere positionering van gevels Resultaat van de eerste versie van het natuurdetectie algoritme Foutief verwijderde voxel op de hoek van een gebouw met de eerste versie van de natuurdetectie Het verschil tussen de eerste en tweede versie van de natuurdetectie heuristiek De resultaten van de natuurdetectie heuristiek De resultaten voor en na het splitsen van gevels Het eindresultaat van de gevelclassificatie Een voorbeeld van een lijn in het lijnzoekrooster Vergelijking van de gevonden gevels en de gevels in het GRB Voorbeeld van een densiteitsrooster Het resultaat van het vergelijken van de gevonden gevels met de gevels op de kaart Het algoritme slaagt erin om huizen te detecteren die niet op de kaart aanwezig waren Het algoritme slaagt er ook in om muren te detecteren die van de kaart verwijderd moeten worden Schema volledige methode: deel 1, vlakkendetectie xiv

16 9.2 Schema volledige methode: deel 2, gevelclassificatie Schema volledige methode: deel 3, vergelijking met kaart Het resultaat van het algoritme op een ander deel van de gebruikte dataset Tijdsmeting op de gebruikte dataset Voorbeeld van een roosterstuk in de puntwolk met hoge resolutie Voorbeeld van een stuk kaart in de puntwolk met hoge resolutie: eerste versie In deze puntwolk met hoge resolutie worden ook aan de binnenzijde van een gebouw zeer veel punten gedetecteerd Resultaat van het algoritme op een puntwolk met hoge resolutie Een tweede resultaat van het algoritme op een puntwolk met hoge resolutie Tijdsmeting op de Velodyne laserscanner dataset xv

17 Lijst van tabellen 7.1 De resultaten van de verschillende heuristieken wat het aantal fout geclassificeerde gevels betreft De tijdsmetingen van de uitvoering van het volledige algoritme op de puntwolk met lage resolutie De tijdsmetingen van de uitvoering van het volledige algoritme op de puntwolk met hoge resolutie xvi

18 Hoofdstuk 1 Inleiding Deze thesis gaat over de extractie van vlakken uit grote 3D puntwolken voor het gebruik in cartografie. Dit onderzoek gebeurt in samenwerking met Grontmij Belgium. Deze thesis begint met een situering van het onderwerp in hoofdstuk 2. In dat hoofdstuk wordt uitgelegd wat Mobile Mapping is en waarom er veel puntwolken gegenereerd worden in deze industrie. Het volgende hoofdstuk, hoofdstuk 3 Probleemstelling, legt uit wat het problemen exact zijn. Dit hoofdstuk legt ook uit welke problemen opgelost zullen worden in deze thesis en welke onderzoeksvragen zullen bekeken worden. Daarna volgt de Werkopstelling. Dit hoofdstuk gaat over de voorbeeld- en referentiedata die beschikbaar zijn en de bibliotheken die in deze thesis werden gebruikt. Daarna volgt hoofdstuk 5 Literatuur: detecteren van vlakken en andere geometrische vormen. In dit hoofdstuk wordt gekeken naar de technieken in de literatuur die gebruikt worden om vlakken te detecteren in puntwolken. In dit hoofdstuk worden de drie basistechnieken uitgelegd en worden een aantal variaties op deze technieken bekeken. Daarna worden de voor- en nadelen van de verschillende technieken opgesomd om later een beslissing te kunnen nemen over welke techniek het best gebruikt zal worden. In hoofdstuk 6 Detectie van vlakken in een grote puntwolk wordt een techniek gekozen om vlakken te detecteren. Er wordt ook bepaald wat de beste manier is om om te gaan met gigantische puntwolken. Naast de technieken worden ook goede waardes voor de parameters van de verschillende algoritmes vermeld. Na dit hoofdstuk kan de puntwolk opgesplitst worden in vlakken. De resultaten hiervan kunnen gezien worden in de laatste sectie van dat hoofdstuk. In hoofdstuk 7 Gevelclassificatie, wordt geprobeerd deze gevonden vlakken dan te classificeren. Welke vlakken zijn gevels en welke vlakken zijn deel van struiken of andere niet belangrijke voorwerpen? Dit hoofdstuk bouwt verder op de gedetecteerde vlakken en zal als resultaat een groep gevonden gevels overhouden. De resultaten van de verschillende stappen zijn doorheen het hoofdstuk verspreid zodat de vooruitgang gevolgd kan worden. Daarna volgt hoofdstuk 8 Vergelijken van de gevonden gevels met een kaart. In dat hoofdstuk worden de gevonden gevels vergeleken met bestaande gevels op een kaart. Als resultaat worden dan op de kaart Nieuwe gevels, Afwijkend geplaatste gevels en Verwijderde gevels 1

19 aangeduid. Het voorlaatste hoofdstuk Totaalbeeld wordt het volledige algoritme bekeken. Eerst geeft dit hoofdstuk een schematische voorstelling van het volledige algoritme waarna de volledige methode wordt uitgevoerd op een aantal puntwolken en de resultaten hiervan bekeken worden. In dit hoofdstuk wordt ook kort iets vermeld over de uitvoeringstijd van het programma. Tot slot is er het besluit in hoofdstuk 10. 2

20 Hoofdstuk 2 Situering Deze thesis situeert zich in het gebied van Mobile Mapping ([Bel14]). Deze industrie focust zich op de productie van kaarten. Informatie wordt verzameld door rond te rijden in een speciaal voertuig uitgerust met meetsensoren door de straten van het in kaart te brengen gebied. Op dit voertuig zijn allerlei meetapparaten aangebracht. Zo is er meestal een Global Positioning System (GPS) aanwezig om de positie te bepalen en is er een Inertial Navigation System (INS - [Dar14]) om relatieve positionering te gebruiken als er tijdelijk slechte GPS ontvangst is (bijvoorbeeld in een tunnel). Verder zijn er meestal meerdere camera s gemonteerd op het dak om de omgeving te filmen. Deze apparaten laten toe om voldoende informatie te verzamelen om nadien niet meer naar de plaats terug te hoeven keren. Voor een voorbeeld van zo een voertuig dat gebruikt wordt door Grontmij, zie afbeelding 2.1. Een bekend voorbeeld van het gebruik van Mobile Mapping is Google Street View. Figuur 2.1: Een voertuig dat gebruikt wordt door Grontmij voor Mobile Mapping. Bron: be Naast de camera wordt tegenwoordig ook een laserscanner geplaatst op zo een voertuig. Een laserscanner zend licht met een bepaalde frequentie uit naar de omgeving en meet hoe lang het duurt voor het licht terugkeert. Deze meting laat toe om de afstanden tot punten in de omgeving te bepalen 1. Samen met informatie over de hoek waarin deze laserstraal werd uitgezonden en 1 Als de tijd gekend is die de laserstraal erover doet om terug te keren kan de afstand bepaald worden met de formule afstand = (tijd c)/2 met c de snelheid van het licht in lucht. We delen door 2 omdat de laserstraal de 3

21 de gps locatie kunnen zeer precieze coördinaten van zo n punt bepaald worden. Aangezien een laserscanner makkelijk punten per seconde 2 kan scannen kan hiermee een zeer gedetailleerde puntwolk van de omgeving gegenereerd worden. Om hiervan een idee te krijgen kan u kijken naar afbeelding 2.3. Laserscanners zijn beschikbaar in vele vormen en formaten maar maken allemaal gebruik van hetzelfde principe. Een laserscanner kan er uitzien zoals in figuur 2.2. Figuur 2.2: Een laserscanner geproduceerd door Riegl. Bron: Figuur 2.3: Laserscanners genereren puntwolken met zeer veel detail. Met deze puntwolk is het mogelijk om afstandsmetingen te doen van allerlei zaken of de coördinaten te bepalen van gevels, lantaarnpalen, verkeersborden,... De meeste van deze taken moeten echter manueel gebeuren en zijn dus zeer arbeidsintensief. Een ander mogelijk gebruik van zo een puntwolk is het bekijken waar kaarten nog aangepast moeten worden. Het is echter niet zo eenvoudig en extreem veel werk om deze gigantische puntwolken te vergelijken met bestaande kaarten. afstand dubbel aflegt metingen per seconde is de snelheid van de laserscanner uit figuur 2.2. ( uploads/tx_pxpriegldownloads/10_datasheet_lms-q120_ pdf) De laserscanner uit figuur 2.3 is nog een 70 maal sneller. ( 4

22 Hoofdstuk 3 Probleemstelling Puntwolken gegenereerd door een Mobile Mapping systeem bevatten dus veel nuttige informatie en zijn daarom dan ook zeer snel ingeburgerd in deze industrie. Maar hoewel uit deze puntwolken veel informatie kan afgeleid worden, gebeurt de extractie van deze informatie nog handmatig. Dit is een zeer arbeidsintensieve taak en het is dan ook nuttig om deze taak te automatiseren. Zo zou het interessant zijn als het mogelijk was om de computer op een automatische wijze te laten controleren of een kaart nog overeen komt met de gegenereerde puntwolk. Als de puntwolk dan op bepaalde plaatsen afwijkt kan dit gemeld worden en kan dit stukje kaart dan nog manueel verwerkt worden. Aangezien er maar zelden een huis bijgebouwd wordt zou dit voor de persoon die de kaart moet updaten een zeer groot hulpmiddel zijn. In deze thesis willen we onderzoeken of het mogelijk is om puntwolken en bestaande kaarten op een geautomatiseerde wijze te vergelijken. Meer bepaald willen we eerst onderzoeken welke methodes het best geschikt zijn om deze gigantische puntwolken te verwerken: hoe splitsen we deze puntwolk op in stukken en in welke volgorde verwerken we de stukken of verwerken we de puntwolk punt per punt? Daarna kijken we naar bestaande methodes voor vlakkendetectie en bepalen we welke methode het meest geschikt is voor het gebruik in dit probleem. Eens de vlakken gedetecteerd zijn zullen we onderzoeken op welke manier we de gevels uit deze vlakken kunnen selecteren. Voor deze classificatie zullen we werken met verschillende heuristieken. Tenslotte willen we deze gedetecteerde gevels nog op een automatische manier vergelijken met een bestaande kaart en onderzoeken of deze techniek goed werkt. 5

23 Hoofdstuk 4 Werkopstelling 4.1 Voorbeelddata De data nodig voor deze thesis werden aangeleverd door Grontmij Belgium. Hierbij was de informatie die geproduceerd werd door de laserscanner al gecombineerd met de positioneringsinformatie (GPS, INS) en waren deze data omgezet in een puntwolk. Deze puntwolken waren beschikbaar in het las-formaat. Het las-formaat is gemaakt om puntwolken gegenereerd door laserscanners in op te slaan. De hoofding van het bestand bevat informatie over het aantal punten maar geeft ook aan welke dimensies volgen. Zo zijn er natuurlijk de X, Y en Z dimensies, maar in een las bestand kan ook informatie over bijvoorbeeld de scanhoek bijgehouden worden. Daarnaast kan er ook informatie over een classificatie of informatie over de intensiteit in opgeslagen worden. De voorbeelddata geleverd door Grontmij bevat echter alleen de X, Y, Z en intensiteitsinformatie, maar dit is in de meeste gevallen meer dan genoeg. Er werden twee datasets aangeleverd, enerzijds een dataset met lage densiteit die gebruikt werd in het grootste deel van deze thesis. Een voorbeeld hiervan ziet u in figuur 4.1. De andere dataset is opgenomen met een gloednieuwe Velodyne laserscanner en heeft een zeer hoge densiteit. Figuur 2.3 in hoofdstuk Situering is hiervan een voorbeeld. Aangezien we de informatie in puntwolk willen vergelijken met een kaart is het ook belangrijk om te weten in welk coördinatenstelsel de coördinaten zijn uitgedrukt. In Europa is het meest gebruikte coördinatensysteem in de landmeetkunde het Europese Terrestrische Referentiesysteem (ETRS89) [Ref14]. In België wordt echter meestal gewerkt met Lambert 2008 [NGI14] als coordinatenstelsel. Coördinaten in deze referentiestelsels kunnen wel eenvoudig naar elkaar omgezet worden. Coördinaten in Lambert 2008 worden uitgedrukt in meter en liggen tussen en In het oudere Lambert72 coördinatenstelsel liggen de coördinaten tussen 0 en Kijken we naar de data dan zien we dat de coördinaten liggen tussen 0 en Na verdere vergelijking van de puntwolk met het Grootschalig Referentie Bestand (GRB) zien we dat de coördinaten inderdaad zijn uitgedrukt in het iets oudere Lambert72 coördinatenstelsel. 6

24 Figuur 4.1: Een stuk van de dataset die het meeste gebruikt werd doorheen deze thesis. 4.2 Referentiedata Zoals eerder vermeld willen we deze puntwolken vergelijken met bestaande kaarten. Deze kaarten kunnen we gebruiken om de correctheid van het algoritme te testen. Kaarten van Vlaanderen zijn beschikbaar in het Grootschalig Referentie Bestand Vlaanderen (GRB) en kunnen online geraadpleegd worden op de site van het Agiv: aan-de-slag. Het GRB gebruiken in toepassingen is betalend. Een van de uitzonderingen is echter het gebruik door Vlaamse onderwijsinstellingen voor het gebruik in onderwijs- of onderwijsdoeleinden. Voor deze thesis is het dus toegelaten om de GRB-data gratis raad te plegen Het Grootschalig Referentie Bestand raadplegen Om het GRB te raadplegen zijn er verschillende methodes. Zo zijn er webservices die afbeeldingen van een bepaald gebied teruggeven of is het ook mogelijk om een xml (.svg) formaat te verkrijgen dat een bepaald stuk beschrijft. De webservice om de basiskaart te raadplegen bevindt zich op: Als u de lagen apart wilt kunnen raadplegen gebruikt u GRB/wms. Deze webservice volgt een standaard, gedefiniëerd voor het ophalen van kaarten: de Web Map Service ([Spa14]). Deze webservice bevat dus een aantal gestandaardiseerde oproepen. Zo is het mogelijk om de parameters die meegegeven kunnen worden aan de webservice te bekijken door?request=getcapabilities&service=wms aan de url toe te voegen. Voor het ophalen van de kaart moet als request getmap worden gebruikt en moeten de volgende parameters ingeven worden: layers - de lagen van de kaart die geëxporteerd moet worden 7

25 CRS - het coördinatenstelsel waarin gewerkt wordt (Coordinate Reference System) BBOX - het gebied dat geëxporteerd moet worden (Bounding BOX) format - het formaat (bv. image/png of image/svg+xml) width - de breedte van de afbeelding en height - de hoogte van de afbeelding Hierbij zou het handig zijn om als coördinatenstelsel Lambert72 te kunnen gebruiken. De opties voor CRS voor de voorgaande service zijn: EPSG:31370, CRS:84, EPSG:3043, EPSG:3812, EPSG:3857, EPSG:4258, EPSG:4326, EPSG:25831, EPSG:32631, EPSG: EPSG:31370 is gewoon een andere naam voor Lambert72 en dus het coördinatenstelsel dat we willen gebruiken ([But]). Bij BBOX vullen we het gebied in dat overeenkomt met de puntwolk. Dit gebied kan bepaald worden door gewoon het minimum en maximum te bepalen van de x- en y-waarden van de punten in de puntwolk. De width en height waardes zijn uitgedrukt in pixels en de waardes die ingevuld kunnen worden in de layers parameter zijn duidelijk beschreven in de uitvoer van de GetCapabilities request. Een volledige url om een kaart op te halen ziet er dus uit als volgt: service=wms&version=1.3.0&layers=grb_basiskaart&crs=epsg:31370&bbox=219600,185400, ,185800&WIDTH=800&HEIGHT=800&FORMAT=image/png Figuur 4.2: Een voorbeeld van een stuk kaart uit het Grootschalig Referentie Bestand Vlaanderen. 8

26 4.3 liblas liblas (Figuur 4.3) is een C/C++ bibliotheek die het.las formaat kan lezen. Deze bibliotheek wordt in deze thesis gebruikt omdat de voorbeeldpuntwolken in het.las formaat gegeven zijn. Deze bibliotheek is beschikbaar onder de BSD licentie. Meer informatie vindt u op liblas.org/. Figuur 4.3: Logo van de liblas bibliotheek. 4.4 Point Cloud Library (PCL) Voor de verwerking van puntwolken bestaan in de literatuur al heel wat algoritmen. Typische operaties op puntwolken zijn registratie 1, segmentatie, het schatten van normalen, het bepalen van vlakken, het filteren van de data, enz... Een van de meest gebruikte bibliotheken voor de verwerking van puntenwolken is de Point Cloud Library (Figuur 4.4). Deze bibliotheek heeft een groot aantal geïmplementeerde functies en bevat implementaties van vele interessante algoritmen. Het gebruik van deze bibliotheek kan de tijd van ontwikkeling veel korter maken. De Point Cloud Library is beschikbaar onder de BSD licentie. Voor deze thesis is gebruik gemaakt van versie Website: Figuur 4.4: Logo van de Point Cloud Library. Voor deze thesis zullen zeker de volgende delen van de PCL bibliotheek goed kunnen worden gebruikt: Sample Consensus: bevat algoritmes voor vlakdetectie en detectie van andere objecten. Voor meer informatie over deze algoritmes zie hoofdstuk 5 en meer bepaald het onderdeel over RANSAC. 1 Registratie is het samenvoegen van twee puntwolken die een stuk overlappen. Dit gebeurt meestal door opvallende punten (features) te zoeken in beide puntwolken en dan deze features uit beide puntwolken te proberen koppelen met elkaar. 2 Op het moment van schrijven is versie de laatste versie waarvan een Windows build beschikbaar is. Om gebruik te maken van versie op Windows is het dus noodzakelijk om PCL zelf te bouwen via de code. Aangezien de API relatief sterk gewijzigd is sinds versie en alle tutorials van versie verdwenen zijn moet PCL gebouwd worden van de code als er gewerkt wordt op Windows. Door de vele afhankelijkheden is dit niet eenvoudig. 9

27 IO: voor het inlezen en wegschrijven van puntwolken. De Point Cloud Library gebruikt het.pcd formaat om puntwolken in op te slaan. Dit bestandsformaat ondersteunt zowel binaire opslag als opslag in een leesbaar formaat. Meer informatie vindt u op pointclouds.org/documentation/tutorials/pcd_file_format.php Visualization: laat toe om op een eenvoudige manier puntwolken te visualiseren en te bekijken vanuit alle hoeken of om een afbeelding van de puntwolk weg te schrijven naar een bestand. Verschillende delen van een puntwolk kunnen ook met andere kleuren aangeduid worden. Daarnaast bevat deze module ook een klasse waarmee afbeeldingen kunnen getoond worden waarop zaken aangeduid kunnen worden. Andere modules: De Point Cloud Library bevat nog andere delen die soms kunnen worden gebruikt. In deze thesis werd de Filters module gebruikt voor het afsplitsen van gedetecteerde vlakken van de puntwolk. 10

28 Hoofdstuk 5 Literatuur: detecteren van vlakken en andere geometrische vormen In dit hoofdstuk worden bestaande algoritmen voor de detectie van vlakken en andere geometrische vormen in puntwolken beschreven. Daarnaast worden ook de voor- en nadelen voor het gebruik in deze thesis van enkele van deze technieken besproken. 5.1 Soorten technieken In de literatuur zijn er verschillende soorten technieken om vlakken te detecteren in 3D puntwolken, maar de meeste artikels bouwen verder op één van volgende drie technieken: gebiedsuitbreiding ( region growing ), de Hough transformatie [Hou62] of het RANSAC algoritme [FB81] Gebiedsuitbreiding ( Region growing ) Bij deze techniek wordt eerst de normaal in elk punt in de puntwolk geschat en worden steeds naburige punten die waarschijnlijk op eenzelfde vlak liggen gegroepeerd. Voor deze techniek moet elk punt weten wat zijn buren zijn. Bij diepteafbeeldingen is deze informatie beschikbaar en wordt deze techniek dus regelmatig gebruikt. In diepteafbeeldingen komt elke pixel overeen met een punt in de puntwolk en kan bepaald worden wat naburige punten zijn door te kijken naar de overeenkomstige pixels. Deze eerste techniek, gebiedsuitbreiding, wordt schematisch voorgesteld in figuur 5.1. Hierbij moeten we een burenfunctie hebben (1), waarna we alle normalen berekenen (2) en we tot slot punten samenvoegen die op hetzelfde vlak liggen (3) Hough transformatie De Hough transformatie werd origineel beschreven in [Hou62] en was oorspronkelijk ontwikkeld voor het detecteren van vormen in afbeeldingen (2D). Deze techniek kan echter ook gemakkelijk toegepast worden op 3D puntwolken. 11

29 Figuur 5.1: De verschillende stappen in het gebiedsuitbreidingsalgoritme. Diepteafbeelding van http: // Voorstelling van te detecteren vormen Om de Hough transformatie te kunnen gebruiken moet het mogelijk zijn om de objecten die herkend moeten worden te beschrijven met een voorstelling die uniek is en waar alle parameters in het model begrensd kunnen worden. Een invulling van het model zal dan bestaan uit een vector van x getallen waarbij elk getal een beperkt bereik heeft. Voorbeeld voorstelling vlak in 3D: Op deze manier is het mogelijk om bijvoorbeeld een vlak in 3D voor te stellen aan de hand van een normaal en de afstand van het nulpunt. Deze parameters zijn dan allemaal te begrenzen als volgt: de normaal kunnen we normaliseren (dus de x,y en z waarde tussen 0 en 1) en de afstand van het nulpunt kunnen we beperken door eerst de grenzen van de puntwolk te bepalen. 1 Een mogelijke invulling van dit vlakmodel is dan ( 3, 1 3, 1 vlak 3 x y z + 3 = , 3) wat overeen komt met het De accumulator Zo een model komt dus overeen met een x dimensionale ruimte waarbij elke dimensie begrensd is. Een punt in deze ruimte komt overeen met een invulling van het model. Aangezien alle dimensies begrensd zijn kunnen we een matrix met x dimensies maken die overeenkomt met deze ruimte. Elke parameter in het model wordt dan een dimensie van de matrix. Deze matrix wordt ook wel de accumulator genoemd. Als we dan een invulling van het model hebben dan zal dat op een unieke plaats in deze matrix afgebeeld worden. 12

30 Voorbeeld accumulator voor lijn in 2D: Een 2D lijn kan analoog aan een vlak in 3D voorgesteld worden aan de hand van een normaal en een afstand 1. Een lijn zal dan dus overeenkomen met een invulling van het model en dus een punt in de lijnruimte zoals in figuur 5.2. Deze ruimte kan dan eenvoudig afgebeeld worden op een 3D matrix. 1 lijn 0.7x + 0.7y + 0 = 0 a c b 1 Figuur 5.2: Hough transformatie: lijnruimte. Het algoritme We weten nu dus hoe de accumulator eruit ziet. Het algoritme werkt dan als volgt: Initialisatie ( 1): Maak een lege accumulator die overeenkomt met het model. Overloop de puntwolk ( 2): Bepaal voor een punt alle mogelijke invullingen van het model ( lijnen ) door dat punt. Tel voor elk van deze invullingen van het model 1 op bij de juiste positie in de accumulator. Maximum zoeken ( 3): Op het einde zal in de matrix een soort van warmtekaart voorstellen waarbij de maxima ontstaan zijn door punten die allemaal op hetzelfde model liggen. Het zoeken van de best passende invulling van het model komt dan overeen met het zoeken van het maximum in de matrix. Listing 5.1: Pseudocode Hough transformatie Dit algoritme wordt hierna verduidelijkt met een voorbeeld. 1 Voor het voorbeeld gebruiken we een voorstelling met drie parameters. In praktijk zal er meestal een andere voorstelling gebruikt worden om een lijn in 2D te detecteren. Er bestaat namelijk een evenwaardige voorstelling met twee parameters: een hoek en een afstand. 13

31 Voorbeeld algoritme voor lijn in 2D: In figuur 5.3 tot 5.5 is schematisch weergegeven hoe het algoritme werkt voor het detecteren van een lijn in 2D. 1 1 a c b -1 b 1 c a Figuur 5.3: Eerst wordt er voor de lijnenruimte een matrix gemaakt: de accumulator a b 1 c Figuur 5.4: Voor elk punt in de puntwolk overlopen we dan alle lijnen die door dat punt gaan. Voor elke lijn tellen we 1 op in de juiste plaats in de accumulator. 1 Figuur 5.5: Nadat we alle punten overlopen hebben zoeken we het maximum in de matrix. Dat maximum komt dan overeen met de lijn waardoor het meeste punten gaan. a b 1 c Om met ruis om te gaan is het best om tijdens het zoeken naar een maximum te sommeren over kleine gebieden rond een bepaald punt in de matrix RANSAC (RANdom SAmple Consensus) Een laatste groep technieken baseert zich op het RANSAC ( RANdom SAmple Consensus ) algoritme dat initieel ontwikkeld werd door Fischler en Bolles [FB81]. Dit algoritme is gebaseerd op de kans om een model correct in te vullen door een willekeurige minimale set van informatie te gebruiken. Het laat toe om parameters van modellen in te vullen zonder alle opties af te gaan. Bijvoorbeeld om een vlak te detecteren in RANSAC worden 3 willekeurige punten uit de puntenwolk gekozen. Door deze drie punten gaat dan exact 1 vlak. Daarna wordt naar de rest van de punten gekeken en wordt een score berekend voor dit vlak. Het vlak met de hoogste score wordt overgehouden. RANSAC is dus zeer goed in het ontdekken van een groot vlak in puntwolken met veel ruis. (De kans om 3 punten op dat vlak te vinden is groot) Maar RANSAC zal zeer slecht presteren als er veel kleine vlakken zijn in een puntenwolk. De werking van het algoritme is schematisch weergegeven in figuur

32 Schematisch: Stap 1: Kies 3 willekeurige punten. Stap 2: Door 3 punten gaat juist 1 vlak. Doe k keer en hou beste resultaat bij Stap 3: Geef een score aan het vlak. (Bepaal hoeveel procent van alle punten op het vlak liggen en hoe goed ze ermee overeen komen.) Figuur 5.6: Schematische weergave van het RANSAC algoritme. 5.2 Variaties in de literatuur In de literatuur zijn veel varianten op de drie basistechnieken te vinden Variaties op de gebiedsuitbreidingstechniek Voxel growing : Een eerste techniek om vlakken te detecteren is beschreven in [DG10]. Deze maakt gebruik van een aangepaste versie van gebiedsuitbreiding: voxel growing. Hierbij worden verschillende punten aan de hand van een rooster samengevoegd in voxels om zo sneller te kunnen werken. Voor elk van deze voxels wordt dan een normaal en een score bijgehouden. Ruis wordt uit de normaal gefilterd door te kijken naar de normalen in de naburige punten en bepaalde punten te verwijderen. In elk punt wordt dan met behulp van de naburige punten gekeken welk vlak het meest waarschijnlijk is en wordt er een score gegeven die ook rekening houdt met de verwachte densiteit van de puntenwolk in dat punt. Deze techniek laat dus toe om gebiedsuitbreiding toe te passen op een willekeurige puntwolk door te werken met voxels. Analoog aan gebiedsuitbreiding worden vlakken in naburige pixels/voxels samengevoegd tot één groot vlak. Schematisch is dit weergegeven in figuur 5.7. Ook segmenteren op kleur: In [SRO10] segmenteren de auteurs een puntwolk door niet enkel naar de normalen te kijken (zoals alle andere methoden), maar ook naar de kleur. Ze verdelen de diepteafbeelding eerst in een graafstructuur waarbij elke knoop een aantal zeer gelijkaardige punten bevat. De bogen tussen de knopen bevatten twee gewichten: het verschil in de hoek tussen de normalen en het verschil in kleur. Het algoritme segmenteert de puntwolk dan door 15

33 Figuur 5.7: Het voxel growing algoritme laat toe om gebiedsuitbreiding toe te passen op een willekeurige puntwolk en niet enkel op diepteafbeeldingen. A: Gebiedsuitbreiding: vlakken in naburige pixels worden samengevoegd tot 1 vlak. B: Voxel growing : vlakken in naburige voxels worden samengevoegd tot 1 vlak. telkens de boog met het laagste kleurverschil te zoeken en als beide gewichten voor die boog lager zijn dan een bepaalde grens, deze boog te verwijderen en beide segmenten samen te voegen Variaties op de Hough transformatie Eenvoudige variaties op de Hough transformatie: Er zijn heel wat papers die varianten voorstellen op de Hough transformatie. In [BELN11] worden een aantal bestaande variaties op de 3D Hough transformatie bekeken, waarna ze zelf een variant voorstellen. Een eerste groep varianten probeert om de rekentijd van de Hough transform te verminderen. Het probleem met de Hough transform is dat er voor elk punt zeer veel vakjes aangesproken moeten worden. Om het aantal operaties te verminderen kan de matrix verkleind worden wat ten koste gaat van nauwkeurigheid, of kan het aantal bekeken punten verminderd worden. Het aantal bekeken punten verminderen wordt gedaan door de Probabilistic Hough Transform variant [KEB91] waarbij er maar naar een deel van alle punten gekeken wordt. Hoever hierin kan worden gegaan hangt sterk af van de invoerdata (ruis, densiteit data). Deze parameter bepalen is niet altijd even eenvoudig. Daarom wordt in [YJK94] gekeken naar een methode (Adaptive Probabilistic Hough Transform) om deze parameter dynamisch te bepalen. Er wordt hierbij gestart van een zeer kleine deel van puntwolk. Deze deelverzameling van bekeken punten wordt daarna steeds uitgebreid tot de resulterende maxima stabiel genoeg zijn. Hiervoor moeten de maxima wel steeds opnieuw bepaald worden. Nog een andere manier om deze parameter dynamisch te bepalen is de Progressive Probabilistic Hough Transform [MGK + 98]. Deze gebruikt ook steeds meer punten tot een bepaald vakje in de accumulator hoger is dan een bepaalde procentuele grens. Dit vakje komt dan overeen met een gedetecteerd vlak. Alle punten op dat vlak worden dan uit de dataset verwijderd zodat er uiteindelijk minder punten in de accumulator geplaatst worden. De methode Randomized Hough Transform uit [XOK90] werkt op een andere manier. In plaats van voor elk punt alle mogelijke vlakken in de accumulator op te tellen, kiest deze methode 3 willekeurige punten en telt dan enkel een op voor dat vlak in de accumulator. Deze laatste variant is een stuk efficiënter dan de voorgaande doordat deze telkens maar één vakje aanpast. Naast varianten die de rekentijd van de transformatie proberen te beperken zijn er ook varianten mogelijk op de voorstelling van de accumulator. Zo merken de auteurs van [ZP02] op dat de manier van voorstellen (normaal en lengte) sommige vlakken bevoordeeld doordat proportioneel meer vlakken in hetzelfde vakje van de accumulator horen dan in andere vakjes. Dit zorgt er dan voor dat die vakjes sneller een bepaalde grens bereiken. Zowel [ZP02] als [BELN11] proberen dit op te lossen en stellen elk een methode voor om een meer uniform verdeelde ruimte te verkrijgen. 16

34 Toepassen op rotsen & vlakken met een dikte: In [ST02] wordt de Hough transformatie toegepast om vlakke scheuren aan te duiden in rotsen. De spatiale distributie van deze scheuren bevat namelijk heel wat informatie. Van deze scheuren willen de auteurs de positie, oriëntatie, lengte en dikte weten. Deze paper legt in veel detail uit hoe de Hough transformatie werkt en stelt dan twee aanpassingen voor om betere resultaten te krijgen in deze toepassing. Een eerste aanpassing is nodig om ook scheuren op te merken die deels overlappen. Daarom worden de kleinste scheurtjes eerst gezocht en worden ze uit de data verwijderd nadat ze gevonden zijn. Een tweede aanpassing is nodig omdat scheuren een bepaalde dikte hebben. Daarom wordt op vlakken eens ze gevonden zijn nog lokale lineaire regressie toegepast. Normalen schatten, hiërarchische accumulator en Gaussiaanse vervaging: Ook [HSSM14] bouwt verder op de Hough transformatie. Deze paper introduceert heel wat optimalisaties. Als eerste wordt er gestart met het schatten van de normalen in alle punten. Op deze manier hebben we in elk punt al een schatting van het vlak dat door dat punt gaat en zijn niet alle vlakken meer mogelijk. We kunnen dan enkel dat vlak aanduiden in de accumulator en moeten niet voor elk punt alle mogelijke vlakken door dat punt overlopen. Deze aanpak is gelijkaardig aan de Randomized Hough Transform uit [KHXO94] of [XOK90]. Een tweede aanpassing die ze voorstellen is een hiërarchische voorstelling van de accumulator. Met deze voorstelling slagen ze erin om ruimte te besparen en toch precisie te bewaren. Om met ruis om te gaan passen ze op de Hough ruimte een Gaussiaanse vervaging toe en werken ze met een verschuivend venster om maxima te zoeken. Hun onderzoek is bedoeld voor het gebruik in bewegende robots. De diepteafbeeldingen geproduceerd door deze robots zullen in opeenvolgende frames meestal informatie over eenzelfde gebied bevatten. Om ruis tegen te gaan zullen ze dan ook gebruik maken van vorige frames om zo tot een beter resultaat te proberen komen. Multi-resolutie aanpak met Hough transformatie en RANSAC: In [OSW + 11] wordt gebruik gemaakt van meerdere resoluties waarbij vertrokken wordt van grote structuren en naar kleine structuren wordt toegewerkt. Op elke resolutie wordt gezocht of een stuk van de hiërarchie (genaamd surfel ) zich op een vlak bevindt dat al op een grotere resolutie werd gedetecteerd. Met de overige surfels wordt dan via de Hough transformatie gezocht naar nieuwe vlakken. Op het einde wordt het vlak door de geconnecteerde componenten dan opnieuw berekend via het RANSAC algoritme om een betere nauwkeurigheid te bereiken. Op elk niveau van de hierarchische structuur moet een normaal beschikbaar zijn. Deze normalen kunnen op een efficiente manier berekend worden blijkt uit het artikel. Nadien vergelijken de auteurs hun algoritme ook met andere algoritmen zoals dat uit [VGSR04] of het RANSAC gebaseerd algoritme dat geïmplementeerd is in de PCL bibliotheek en beschreven is in [RC11] Variaties op de RANSAC techniek Sequentiële RANSAC: In [BLG + 07] wordt een laserscan van een gebouw genomen en wordt dit gebouw onderverdeeld in verschillende vlakke delen zoals ramen, een vlak stuk gevel en de stukken muur rond de ramen van het gebouw. Om het gebouw onder te verdelen wordt gebruik gemaakt van het RANSAC algoritme, met de aanpassing dat als een vlak gevonden wordt, alle punten op dat vlak worden verwijderd en er verder gewerkt wordt met de rest van de data. Deze variant wordt sequentially RANSAC genoemd. De techniek beschreven in deze paper focust zich op het segmenteren van één gebouw. Daarna moeten deze vlakke delen nog geclassificeerd worden om nuttige informatie uit deze segmentatie te verkrijgen. 17

35 RANSAC en Minimum description length: In [YF10] proberen de auteurs om de output van RANSAC te verbeteren en foute vlakken te vermijden door het Minimum description length (MDL) principe toe te passen. Dit principe probeert uitsluitsel te bieden als er meerdere mogelijkheden zijn voor een vlak door een bepaalde groep punten te laten gaan Conclusie In de literatuur bestaan er heel wat variaties op de basisalgoritmen, maar de ideeën zijn meestal wel dezelfde. Zo kan de Hough transformatie geöptimaliseerd worden door te zorgen dat er minder aanpassingen in de matrix gebeuren wat kan door minder punten te bekijken of minder vlakken te bekijken per punt. Ook het schatten van normalen in punten in een puntwolk gebeurt regelmatig om daarmee snel een vlak te kunnen schatten in zo een punt. Daarnaast kan RANSAC (en potentieel andere algoritmen) verbeterd worden door hiërachisch te werken en kunnen meerdere vlakken gedetecteerd worden in een puntwolk door de daarvoor gevonden vlakken te verwijderen uit de puntwolk en opnieuw te beginnen. Daarnaast zijn er natuurlijk nog de aanpassingen die specifiek zijn voor de verschillende toepassingen doordat er bijvoorbeeld meer informatie beschikbaar is over de puntwolk. Het kan ook zijn dat bepaalde toepassingsspecifieke informatie uit de puntwolk gehaald moet worden. 5.3 Voor- en nadelen van de algoritmen Nu we de literatuur bestudeerd hebben zullen de voor- en nadelen van de verschillende algoritmen vermelden. Gebiedsuitbreiding: simpel algoritme: bestaat uit 3 eenvoudige stappen. efficiënt: complexiteit O(2n) met n het aantal punten uitbreidbaar naar andere vormen: cilinder,... burenfunctie nodig: buren van een punt moeten gekend zijn. Hough transformatie: efficiënt: complexiteit O(kn) (met k=grootte matrix) Voor elk punt in de puntwolk moeten alle vlakken erdoor overlopen worden en dus moet voor elk punt bijna de volledige matrix aangepast worden. k is dus constant maar wel zeer groot. complexer algoritme: bevat meer stappen en wordt zeker complexer als geprobeerd wordt om rekening te houden met de ruis of als geprobeerd wordt om de verdeling van de invulling van modellen in de matrix uniform te maken. geheugengebruik versus precisie: als er meer precisie vereist is moeten de dimensies in de matrix in meer stukken opgedeelt worden en wordt er dus meer geheugen gebruikt. 18

36 moeilijker uitbreidbaar naar andere vormen : andere vormen hebben meer parameters. De matrix wordt dan exponentieel groter. Voorbeeld: Een 3D vlak detecteren zal gebruik maken van een 4D matrix met r 4 cellen. Een 3D cilinder zal een 7D matrix met r 7 velden gebruiken. (r=resolutie) Als r = 200 dan zal een vlak dus cellen in de matrix hebben, terwijl een cilinder een matrix met cellen nodig heeft. geeft voorrang aan bepaalde vlakken: de kansen dat een instantiatie van het model in een bepaald vakje van de matrix valt is meestal niet uniform verdeeld. Zo zullen afhankelijk van de voorstelling bepaalde combinaties van waarden met een grotere waarschijnlijkheid voorkomen dan andere. Hierdoor zal bij het zoeken van het maximum een licht vertekend beeld gevormd worden. Er bestaan hiervoor oplossingen in de literatuur, maar het algoritme wordt dan nog complexer om uit te leggen. RANSAC: invloed van ruis op het maximum: Kan opgelost worden door met lopende sommen te werken of door eerst Gaussiaanse vervaging toe te passen op de matrix. Er bestaan hiervoor oplossingen in de literatuur. efficiënt: O(kn) met k=aantal iteraties. simpel algoritme: bestaat uit 1 lus met 2 stappen. werkt slecht op een puntwolk met veel verschillende vlakken: er is een kleine kans dat 3 willekeurige punten die geselecteerd worden op zelfde vlak liggen. Een variant op gebiedsuitbreiding, voxel growing lost het probleem van de burenfunctie in een puntwolk op. Voxel growing kan op een eenvoudige manier toegepast worden op een puntwolk en bevat dezelfde voordelen als gebiedsuitbreiding. Om het probleem met RANSAC op te lossen wordt RANSAC best toegepast op kleine gebieden in de puntwolk die slechts enkele vlakken bevatten. De puntwolk wordt dus best vooraf opgesplitst in kleinere stukken. Hough transformatie bevat heel wat nadelen. Hoewel sommige van deze nadelen wel op te lossen zijn zal de Hough transformatie niet gebruikt worden in deze thesis. Eenzelfde resultaat kan namelijk eenvoudiger bereikt worden met voxel growing of RANSAC. Kortom, voor deze thesis zijn de meest geschikte methodes RANSAC of gebiedsuitbreiding omdat deze algoritmes efficiënt zijn en de eenvoudigste algoritmes zijn die op de puntwolken in deze thesis een correct resultaat genereren. Beide technieken zijn ook uitbreidbaar naar andere vormen. De Hough transformatie heeft heel wat meer nadelen voor het gebruik in deze thesis zoals hierboven te zien is. Hiermee gaat dus niet verder gewerkt worden. 19

37 Hoofdstuk 6 Detectie van vlakken in een grote puntwolk 6.1 Te grote puntwolken Een van de voornaamste zaken waar we rekening mee moeten houden in deze thesis is het feit dat de invoer puntwolken zeer groot kunnen zijn. Het is zeer eenvoudig om grote puntwolken te verzamelen en dus is de kans groot dat zo een puntwolk niet in het geheugen past. Zulke puntwolken kunnen namelijk volledige steden en dorpen bevatten. We moeten daar dus zeker rekening mee houden in het algoritme. Temporeel opsplitsen: Een van de methoden die dit probleem zou kunnen oplossen zou het inlezen met een zoekvenster zijn. We zouden dan beginnen met een stuk in te lezen en de gevels daarin zoeken. Dan lezen we het volgende stuk in, zoeken we de gevels, en voegen we de gevonden gevels samen met de gevels uit het vorige stuk. Dit zou goed werken behalve als er teruggekeerd wordt naar een bepaald gebied. Als teruggekeerd wordt naar eenzelfde gebied of eenzelfde stuk dubbel gescand wordt op compleet verschillende tijdstippen dan bevindt de vorige informatie over dat stuk zich op dat moment niet meer in het geheugen en is het moeilijk om deze informatie samen te verwerken. Spatiaal opsplitsen: Een andere optie zou zijn om in plaats van temporeel, spatiaal te werken. De puntwolk kan dan opgedeeld worden in een rooster en de punten kunnen op voorhand onderverdeeld worden per roosterstuk. Op deze manier werken heeft heel wat voordelen, zo is perfect geweten waar het stuk puntwolk dat momenteel bekeken wordt eindigt en waar het volgende stuk begint. Dit maakt het makkelijker om de gevels op de randen samen te voegen. Bij het temporeel werken was dit niet gekend en was het zelfs waarschijnlijk dat twee stukken die na elkaar opgenomen werden een groot stuk overlappen. Die onzekerheid maakt het zeer moeilijk om vlakken samen te voegen. Een ander voordeel is dat alle informatie over een bepaald stuk samen kan verwerkt worden. Terugkeren naar eenzelfde plaats in dus geen probleem als spatiaal gewerkt wordt. 20

38 Voordelen en nadelen van spatiaal versus temporeel te werken: Grenzen gekend, overlappen niet: Het spatiaal werken heeft natuurlijk als voordeel dat de grenzen van het ingelezen stuk puntwolk duidelijk gekend zijn, het is namelijk op die manier gesplitst. Nog belangrijker is echter het feit dat de gebieden niet overlappen. Bij het temporeel werken kunnen zelfs gebieden die in de tijd na elkaar liggen een stuk overlappen. Eenvoudiger samenvoegen gevels uit verschillende stukken: Doordat de gebieden niet overlappen en de grenzen gekend zijn wordt het veel eenvoudiger om vlakken samen te voegen over de verschillende stukken heen. Het is namelijk duidelijk in welk stuk puntwolk er moet gezocht worden naar een ander mogelijk stuk van het vlak. Alle informatie over een gevel in een keer te verwerken: Terugkeren naar eenzelfde gebied of gewoon rond een rond punt rijden is nu geen probleem meer. Alle informatie over een bepaalde gevel wordt gegroepeerd en kan in één keer gebruikt worden om een gevel beter te schatten. Voorverwerkingstap: De puntwolk moet op voorhand opgesplitst worden in een rooster om zo makkelijk spatiaal te kunnen werken. We hebben er in deze thesis dus voor gekozen om met een rooster te werken aangezien dit eenvoudiger is en hetzelfde resultaat geeft. Verder is het ook interessanter aangezien alle informatie voor een gevel in één keer verwerkt kan worden en er dus geen dubbel werk gedaan wordt. Ook de randen van een stuk puntwolk zijn duidelijker afgebakend waardoor het samenvoegen van vlakken efficiënter kan gebeuren. 21

39 6.1.1 Algoritme Het algoritme werkt dan als volgt. Opsplitsen in een rooster De eerste stap bestaat erin om de puntwolk op te splitsen in een rooster. Apart verwerken roosterstukken Na het opsplitsen wordt elk stuk van het rooster apart in het geheugen geladen en worden de vlakken in dat stuk gezocht. Eens de puntwolk in verschillende vlakken gesplitst is, wordt voor elk vlakje de segmentatie naar een bestand weggeschreven. Daarna moet de puntwolk niet meer in het geheugen gehouden worden, maar moet enkel nog de normaal en positie van een vlak bijhouden worden. Met deze informatie is het mogelijk om het vlak samen te voegen met een vlak uit een naburig roosterstuk. Samenvoegen van de vlakken in verschillende roosterstukken Eens voor alle roosterstukken de vlakken gedetecteerd zijn, moeten deze nog samengevoegd worden over de verschillende roosterstukken heen. Verdere verwerking van de vlakken Nadat de vlakken gevonden zijn kunnen deze verder verwerkt worden. Voor elk vlak kan een puntwolk samengesteld worden door de segmenten uit verschillende roosterstukken in te lezen en samen te voegen. Er moet hierbij wel op gelet worden dat dit vlak niet volledig ingelezen wordt als het te veel punten bevat. (Bijvoorbeeld de straat zal een vlak zijn dat door zeer veel roosterstukken gaat en dus potentieel zeer veel punten bevat.) Figuur 6.1: Schematische weergave dat het algoritme uitlegt dat omgaat met gigantische puntwolken door een rooster te gebruiken waarvan op elk moment maar 1 stuk in het geheugen gehouden worden. 22

40 6.1.2 Benodigde componenten van het voorgestelde algoritme Het schema uit het vorige deel geeft een overzicht van de werking van het algoritme. In de volgende secties zullen we de benodigde componenten van het voorgestelde algoritme verder beschrijven. In deel 6.2 gaan we verder in op de manier waarop vlakken in naburige roosterstukken vergeleken worden en wanneer ze samengevoegd worden. In deel 6.3 zullen we in detail beschrijven hoe de vlakken gezocht worden binnen één roosterstuk. We willen uiteindelijk gevels in de puntwolk vergelijken met een kaart. Deze verdere verwerking wordt echter niet besproken in dit hoofdstuk, maar is het onderwerp van een volgend hoofdstuk Parameters kiezen In bovenstaand algoritme is er maar één belangrijke parameter die we kunnen kiezen: de resolutie van het rooster. Deze parameter is ingebouwd om ervoor te kunnen zorgen dat de puntwolk verwerkt kan worden zelfs al past de volledige puntwolk niet in het geheugen. Op het moment van schrijven is het op sommige computers niet mogelijk om meer dan 10 miljoen punten op een moment in het RAM geheugen te houden. Om deze redenen en om de snelheid van verwerking hoog te houden zetten we de bovengrens op het aantal punten die zich in één roosterstuk mogen bevinden op 5 miljoen punten. Hoe groot een stuk van het rooster dus mag zijn hangt sterk af van de puntwolk. Als we de puntwolk met veel detail bekijken (zie figuur 2.3) dan merken we dat voor een roosterstuk van 10 op 10 meter sommige stukken toch nog meer dan 10 miljoen punten bevatten 1. Deze stukken bevatten dan echter zoveel punten dat het amper zou te merken zijn als de helft verwijderd werd. De meeste roosterstukken van zo een puntwolk bevatten duidelijk minder dan 10 miljoen punten. Na de analyse van alle factoren hebben we voor deze parameter een waarde van 10 meter gekozen. Als er dan toch te veel punten zijn verwijderen we een deel. Voor puntwolken met een lagere densiteit kan gekozen worden. Het algoritme zal blijven werken als er voor een rooster van 10 meter gekozen wordt, maar er kan evengoed voor een groter rooster gekozen worden. In de voorbeelden in deze thesis wordt een rooster van 20 meter gebruikt. Ideaal zou zijn als de grootte van een roosterstuk geen invloed heeft op de uitkomst van het algoritme. Dit is niet vanzelfsprekend aangezien het samenvoegen van vlakken op roosterniveau gebeurt. In sectie 6.3 kiezen we het algoritme voor vlakken te detecteren in een roosterstuk echter zo dat het resultaat gelijk blijft als we een andere roostergrootte kiezen. De roostergrootte zal dan geen invloed meer hebben op het resultaat. 1 Op de geteste puntwolk had 0, 4% van de roosterstukken meer dan punten waarvan 0, 2% meer dan punten. Met andere woorden, 99, 6% van de roosterstukken in de puntwolk had minder dan punten. 23

41 Er is nog een tweede minder belangrijke parameter die gekozen kan worden, namelijk de bovengrens voor het aantal punten die ingelezen worden door een segment. Als er meer punten in zo een segment zitten worden deze verwijderd. In deze thesis is deze parameter ingesteld op punten. Uit een vlak met punten kunnen we al meer dan genoeg informatie halen. De keuze van deze parameter heeft geen grote invloed op het resultaat maar deze begrenzing is nodig om niet te veel informatie in het geheugen te laden. 6.2 Vlakken vergelijken We moeten kunnen bepalen of twee vlakken in naburige roosterstukken samengevoegd kunnen worden. Om twee vlakken te vergelijken is het logisch om te beginnen met de hoek tussen de twee vlakken. Eens we bepaald hebben dat de vlakken bijna evenwijdig zijn willen we ook bepalen of ze in elkaars verlengde liggen, of ver van elkaar verwijderd zijn. Hiervoor willen we dus eigenlijk de afstand tussen de twee vlakken bepalen op de grens tussen beide roosterstukken. Stap 1: Hoek vergelijken We willen de hoek vergelijken tussen twee vlakken. Dit is gelijk aan de hoek tussen de twee normaalvectoren behalve dat de normalen van de twee vlakken ook tegengesteld zijn aan elkaar mogen zijn. Neem α als de toegelaten hoek tussen beide vlakken en β als de hoek tussen de normaalvectoren (tussen 0 en 180 ), dan zijn de twee vlakken gelijk als: β < α of (180 β) < α roosterstuk 1 roosterstuk 2 α Of met andere woorden, als de hoek tussen beide vlakken niet groter wordt dan α. Figuur 6.2: De hoek tussen twee vlakken vergelijken. De cosinus van de hoek tussen 0 en 180 tussen de twee vlakken kunnen we berekenen door het inwendig product van de twee normaalvectoren te nemen. β = cos 1 (n vlak1 n vlak2 ) Aangezien de cosinus van een hoek gewoon een minteken verschilt voor de tegengestelde hoek kunnen we de formule vereenvoudigen tot: vlakken gelijk qua hoek n vlak1 n vlak2 > cos(α) De hoek tussen twee vlakken kunnen we dus op een efficiënte manier vergelijken door het inwendig product tussen de normaalvectoren te nemen. 24

42 Stap 2: Afstand vergelijken Nadat we weten dat de vlakken ongeveer evenwijdig zijn moeten we de afstand tussen de twee vlakken nog bepalen. Vlakken die te ver van elkaar liggen willen we niet samenvoegen. Er is niet echt een unieke correcte manier om dit te doen aangezien de afstand tussen twee vlakken maar echt duidelijk gedefinieerd is als de vlakken evenwijdig zijn wat hier niet noodzakelijk het geval is. Ze zijn wel ongeveer evenwijdig waardoor de afstand gewoon een benadering zal zijn. De afstand die we bepalen moet de afstand zijn in de buurt van de grens tussen de twee roosterstukken. d grens Figuur 6.3: De afstand tussen twee vlakken vergelijken. Daarom stellen we de volgende manier voor om de afstand tussen twee vlakken te bepalen. Eerst wordt het punt in het midden van de grens tussen de roosterstukken berekend. Daarna wordt de loodrechte afstand tot dit punt van beide vlakken bepaald. Aangezien de vlakken ongeveer evenwijdig zijn zal deze loodrechte afstand ook ongeveer evenwijdig gemeten worden. De afstand tussen beide vlakken is dan het verschil tussen de vorige afstanden. Formeel, zij a 1 x + b 1 y + c 1 z + d 1 = 0 de vergelijking van het eerste vlak v 1 = (a 1, b 1, c 1, d 1 ) T en zij a 2 x + b 2 y + c 2 z + d 2 = 0 de vergelijking van het tweede vlak v 2 = (a 2, b 2, c 2, d 2 ) T. Het centrumpunt van de twee roosterstukken is p = (p x, p y, p z ) T. De loodrechte afstand van het eerste vlak tot het centrumpunt wordt dan berekend door: d(v 1, p) = d 1 + a 1 p x + b 1 p y + c 1 p z Analoog kan de afstand berekend worden tot het tweede vlak. Met deze afstanden kan dan een benadering berekend worden voor de afstand tussen beide vlakken in de buurt van de grens tussen de roosterstukken. We voeren ook een parameter t dist in die de maximale afstand tussen twee vlakken voorstelt. vlakken gelijk qua afstand d(v 1, p) d(v 2, p) < t dist Met deze aanpak is het inderdaad zo dat als de vlakken evenwijdig zijn de berekende afstand de werkelijke afstand tussen beide vlakken is. Verder is de afstand in de overige gevallen gemeten in de buurt van de grens door gebruik te maken van het centrumpunt Parameters kiezen Voor de vlakken te vergelijken zijn er twee parameters die gekozen moeten worden: de toegelaten hoek tussen twee vlakken. de toegelaten afstand tussen twee vlakken. 25

43 De toegelaten hoek tussen twee vlakken De toegelaten hoek willen we natuurlijk zo klein mogelijk kiezen. In een ideale puntwolk zouden stukken vlak die elkaars verlengde zijn exact dezelfde hoek hebben. Een puntwolk bevat echter ruis, waardoor de bepaling van de normaal niet perfect gebeurt. Er zit dus een afwijking op beide normalen waardoor we een afwijking op de hoek moeten toelaten. We zijn in deze thesis gestart met een hoek van 30. Door de berekening van de normalen nog te verbeteren door de parameters in de overige algoritmes te optimaliseren hebben we dit kunnen terugdringen tot 15. We gebruiken dan ook 15 als waarde voor deze parameter. De toegelaten afstand tussen twee vlakken Voor de afstand gebruiken we een waarde van 1 dm. Deze waarde is misschien wat groter dan verwacht, maar door deze parameter iets groter te kiezen kunnen we een gevel als een vlak zien. Zo worden ramen (die een beetje dieper in de muur zitten) ook gezien als hetzelfde vlak als de muur. Uiteindelijk willen we toch op gevels werken en hoeven we niet te weten waar de ramen zich bevinden. We hebben dus gekozen om een volledige gevel als 1 vlak te segmenteren en dus een iets grotere waarde voor de afstand toe te laten: 1 dm. 6.3 Vlakkendetectie binnen één roosterstuk. Alles wat we nu nog nodig hebben is een methode om vlakken te detecteren binnen één roosterstuk. In sectie 5.3 van het vorige hoofdstuk hebben we een aantal voor- en nadelen opgesomd van de verschillende methoden. RANSAC zou voor dit probleem niet zo goed werken aangezien de kans dat twee punten op eenzelfde vlak liggen zeer klein is in dit soort puntwolken. Er zijn namelijk veel kleine vlakjes. Als we de punten echter lokaal zouden kiezen zou dit al beter werken. Hough transformatie had heel wat problemen en het algoritme zou een stuk complexer worden als we ook met al deze problemen rekening zouden moeten houden. Voor gebiedsuitbreiding hebben we een burenfunctie nodig. Een variant uit de literatuur voxel growing heeft geen van deze nadelen. Het is een efficiënt en simpel algoritme en het is uitbreidbaar naar andere vormen indien dat vereist is. Het heeft geen problemen met puntwolken met veel verschillende vlakken. Er is ook geen afweging tussen geheugengebruik en precisie en het geeft geen voorrang aan bepaalde invullingen van parameters. Dat is dan ook de reden waarom we voor dit algoritme gekozen hebben. Voxel growing werd al uitgelegd in sectie Kort samengevat is voxel growing een variant op gebiedsuitbreiding waarbij de puntwolk wordt onderverdeeld in voxels. In deze voxels wordt dan eerst een normaal bepaald waarna naburige voxels samengevoegd worden als ze op hetzelfde vlak liggen. In plaats van een normaal te schatten per voxel hebben we er echter voor gekozen om RANSAC te 26

44 gebruiken. Het voordeel hiervan is dat RANSAC een vlak teruggeeft en dat dus naast de normaal ook de positie van het vlak en de punten op het vlak gekend zijn. Verder kan RANSAC ook makkelijk iteratief toegepast worden en zo is het dus mogelijk om meerdere vlakken te detecteren in één voxel. Dit is voornamelijk interessant als de voxel bijvoorbeeld op een hoek van een huis ligt en er dus meerdere vlakken zijn in één voxel. Voor het vergelijken van twee vlakken in naburige voxels kunnen we dezelfde techniek gebruiken als voor het vergelijken van vlakken in naburige roosterstukken (zoals beschreven in sectie 6.2). Vlakken in naburige roosterstukken zullen we op dezelfde manier samenvoegen als vlakken in naburige voxels. Hierdoor kunnen we de puntwolk dus zien als één groot voxelrooster. De grootte van een roosterstuk zal dus geen enkel effect hebben op de uitkomst van het algoritme. In het originele voxel growing algoritme wordt een andere test gebruikt om te testen of vlakken samengevoegd kunnen worden. Deze test maakt echter gebruik van de punten die op het vlak liggen. Onze methode werkt door enkel naar de parametervoorstelling van het vlak te kijken wat ervoor zorgt dat er amper geheugen nodig is om vlakken in naburige voxels en zelfs naburige roosterstukken samen te voegen. Onze methode laat wel zeer licht krommende vlakken toe, meer info daarover is te vinden in sectie 6.4. Het algoritme is schematisch weergegeven in figuur 6.4. Puntwolk van een roosterstuk Splits in voxels Per voxel Zoek vlakken in voxels RANSAC Vlakken in een roosterstuk Voeg vlakken in naburige voxels samen Zoek meerdere vlakken Figuur 6.4: Schematische weergave van het verwerken van een roosterstuk Parameters kiezen Het algoritme heeft verschillende parameters. In deze sectie proberen we voor al deze parameters redelijke waarden te vinden. De grootte van een voxel Een eerste parameter is natuurlijk de grootte van een voxel. We willen de voxelgrootte zo kiezen dat die net groot genoeg is om voor een voxel die een vlak bevat, dat vlak er nog correct uit te kunnen halen. Bekijken we als voorbeeld figuur 6.5. We kiezen de voxelgrootte best zodat een voxel zeker twee lijnen van eenzelfde vlak bevat. Anders zal het dak van het huis of de grond verkeerd gesegmenteerd worden. Een kleinere voxelgrootte zal er namelijk voor zorgen dat de normaal van bepaalde stukken puntwolk compleet verkeerd bepaald wordt en dat het samenvoegen van die stukken dan ook faalt. 27

45 Figuur 6.5: Waarop te letten bij het kiezen van de parameter voxelgrootte: de minimumgrootte wordt best gekozen in functie van de afstand tussen twee lijnen op een plaats met minimale densiteit. Toch willen we de voxelgrootte ook niet te groot kiezen. De voornaamste reden om een zo klein mogelijke voxelgrootte te kiezen is om vlakken - bijvoorbeeld twee gevels - die een eindje van elkaar verwijderd zijn niet samen te voegen. Als er genoeg ruimte tussen is willen we het inderdaad ook zien als twee verschillende vlakken. Zie figuur 6.6. Kortom om deze parameter te beslissen wordt er best gekeken naar interessante gebieden met de kleinste densiteit. Figuur 6.6: Waarop te letten bij het kiezen van de parameter voxelgrootte: de voxelgrootte wordt best zo klein mogelijk gekozen om te voorkomen dat naburige gevels aan elkaar geplakt worden. Voor de puntwolk met lage densiteit die ook te zien is in figuur 6.5 hebben we de voxelgrootte vastgelegd op 2 meter. Dit lijkt waarschijnlijk vrij groot, maar op figuur 6.7 is te zien dat dit inderdaad net groot genoeg is. Voor puntwolken met een hogere densiteit kan een kleinere voxelgrootte gekozen worden. In de dataset met hoge densiteit (figuur 2.3) kan de voxelgrootte zeer klein gekozen worden. Een voxelgrootte van 2 meter zal hier echter ook werken. 28

46 Figuur 6.7: De verschillende voxels bij een voxelgrootte van 2 meter. Deze figuur laat zien dat 2 meter inderdaad net groot genoeg is zodat in elke voxel tenminste 2 lijnen liggen en dus de correcte vlakken gedetecteerd kunnen worden. Parameters voor toepassing RANSAC in voxel Het toepassen van RANSAC in een voxel brengt verschillende parameters met zich mee. Aantal iteraties: Een eerste parameter is het aantal iteraties. Deze parameter geeft aan hoeveel keer we drie willekeurige punten kiezen en testen of het beter is dan het huidige beste vlak. Na deze iteraties geeft het algoritme het beste gevonden vlak terug. Aangezien een voxel klein is en maar een beperkt aantal vlakken zal bevatten is de kans groot dat er zelfs van de eerste iteratie al een goede schatting is voor een vlak in de voxel. We kunnen het aantal iteraties dus zeer klein houden. De waarde die gebruikt wordt in deze thesis is 30. Afstand van punt tot vlak: Een tweede parameter is de afstand die de andere punten in de voxel mogen afwijken van een vlak om op dat vlak te liggen. Door ruis kan het zijn dat punten wat afwijken van een vlak. Deze parameter zal aangeven op welke afstand een punt maximaal van een vlak mag liggen om toch aanzien te worden als deel van het vlak. Als een punt meer dan deze afstand van een vlak ligt dan zal het niet tot het vlak behoren. We hebben een aantal waarden voor deze parameter getest en ben tot de conclusie gekomen dat 5 cm een goede waarde is voor deze parameter in de puntwolk met lage densiteit. Een iets grotere waarde kiezen heeft als gevolg dat de normaal soms iets minder nauwkeurig geschat wordt. Een kleinere waarde kiezen zorgt ervoor dat de punten die behoren tot een vlak slecht gedetecteerd worden. Als we deze waarde dan vergelijken met de aangegeven nauwkeurigheid van de gebruikte laserscanner zien we dat de gekozen waarde net het dubbele is. De nauwkeurigheid van de Riegl LMS-Q120 is volgens de specificaties 2,5 cm 2. Voor andere laserscanners zal het dubbele van de 2 Bron: Het is niet duidelijk uit de bron, maar deze waarde is waarschijnlijk de standaardafwijking van de distributie 29

47 nauwkeurigheid waarschijnlijk ook een goede waarde zijn voor deze parameter. Stopcriteria: Een laatste keuze die we moeten maken is het stopcriterium, of met andere woorden wanneer we stoppen met het detecteren van nieuwe vlakken in een voxel. We kunnen namelijk iteratief vlakken blijven zoeken tot alle punten in een voxel tot een vlak behoren. Dat willen we niet, de laatste punten (uitschieters) zullen dan waarschijnlijk vlakken van 3 punten vormen. We hebben ervoor gekozen om te stoppen als meer dan 90% van de punten al op een vlak liggen of als er minder dan 5 punten overblijven in de voxel. Het is dan niet meer nuttig om nog vlakken te zoeken in die voxel aangezien we de grootste vlakken al gevonden hebben of er gewoon te weinig punten zijn om nog correcte vlakken te vinden. 6.4 Opmerking over vlakheid Het algoritme dat besproken werd in dit hoofdstuk kijkt lokaal of vlakken in twee naburige voxels met elkaar samengevoegd kunnen worden. Door enkel naar de lokale eigenschappen te kijken kan het zijn dat een gedetecteerd vlak wat krom is over een lange afstand. In het originele voxel growing algoritme hielden de auteurs wel rekening met de globale vlakheid. De techniek die ze gebruikten ging er echter vanuit dat het volledige vlak in het geheugen aanwezig was op het moment dat dit samengevoegd werd met een ander stuk vlak. Dit is niet altijd het geval in deze thesis. In ons algoritme is het zelfs zo dat er zich geen enkel punt in het geheugen bevindt op de moment dat twee stukken vlak uit verschillende roosterstukken samengevoegd worden. Het is dan ook niet mogelijk om in deze toepassing de test van globale vlakheid uit het voxel growing artikel toe te passen tijdens het samenvoegen. Het controleren van de globale vlakheid kan echter op een eenvoudige manier als een naverwerkingsstap gebeuren. Nadat alle bijna vlakken in de volledige puntwolk gevonden zijn kan elk vlak apart overlopen worden en kunnen de punten die behoren tot dat vlak uit één of meerdere bestanden gelezen worden. Deze puntwolken bevat veel minder punten dan de puntwolk van een volledige stad en kunnen dus in het geheugen gehouden worden. Deze naverwerkingsstap kan dan gebeuren door de voxel growing techniek nogmaals toe te passen op dit vlak maar deze keer mét toepassing van de globale test voor vlakheid. Het is ook mogelijk om een andere manier te gebruiken om een krom vlak op te splitsen in meerdere rechte vlakken. De methode die gebruikt wordt in deze thesis om kromme muren op te splitsen is beschreven in sectie Resultaten In het voorbije hoofdstuk is er een techniek besproken om vlakken te detecteren in grote puntwolken. In deze sectie tonen we enkele resultaten van dit algoritme. Een eerste stap uit het algoritme bestaat erin om de puntwolk op te splitsen in een rooster. Daarbij werd een resolutie van 20 meter gebruikt. De opsplitsing is te zien in figuur 6.8. Eens deze opsplitsing is gebeurd wordt elk roosterstuk apart verwerkt. Binnen een roosterstuk wordt de puntwolk opgedeeld in voxels. In deze voxels wordt RANSAC toegepast om stukken van een vlak te detecteren. Enkele van deze roosterstukken zijn weergegeven in figuur 6.9. Hierbij van de ruis. 95% van de punten liggen dan binnen een afwijking van 2σ of dus 5cm. 30

48 Figuur 6.8: Opsplitsing van een puntwolk in een rooster. zijn verschillende kleuren gebruikt voor vlakken in naburige voxels. Rood is bijvoorbeeld een eerste vlak gedetecteerd in een even voxel. Figuur 6.9: Gedetecteerde vlakken in de voxels. Deze figuur toont vijf roosterstukken. Rood = eerste vlak in even voxel Geel = tweede vlak in even voxel Blauw = eerste vlak in oneven voxel Lichtblauw = tweede vlak in oneven voxel De volgende stap in het algoritme is dan het samenvoegen van de stukken vlak in verschillende voxels. Na deze stap zien we binnen een roosterstuk duidelijk de verschillende vlakken. Een voorbeeld hiervan bevindt zich in figuur Zoals te zien is op die figuur werkt de segmentatie 31

49 zeer goed. Vlakken worden correct gesegmenteerd. Dit is een goede basis om in volgende hoofdstukken op verder te werken om gevels te detecteren. Figuur 6.10: Gedetecteerde vlakken in de roosterstukken. Deze figuur toont vijf roosterstukken waarin verschillende vlakken met een andere kleur worden aangeduid. De laatste stap in het algoritme, het samenvoegen over de verschillende roosterstukken heen, werkt op dezelfde manier als het samenvoegen binnen één roosterstuk. De resultaten zijn dus analoog als in figuur

50 Hoofdstuk 7 Gevelclassificatie Als resultaat van de voorgaande hoofdstukken is het nu mogelijk om puntwolken van volledige steden te segmenteren. De segmenten zijn geschreven naar bestanden en kunnen vlak per vlak ingelezen worden om verder te verwerken. In dit hoofdstuk gaan we uit deze vlakken de gevels proberen te selecteren. We moeten weten welke vlakken gevels zijn om deze later te vergelijken met een bestaande kaart. Dit hoofdstuk start met het maken van een eerste selectie. Daarna zullen we bekijken welke fouten gebeuren door deze eerste selectie. We zullen deze fouten ook onderverdelen in groepen. Voor enkele van deze groepen proberen we dan in het deel erna een oplossing te zoeken. 7.1 Een eerste heuristiek: basis gevel selectie Hoek met de grond Om gevels te herkennen is de meest logische eerste stap natuurlijk de hoek die het vlak maakt met de grond. Een gevel staat namelijk altijd loodrecht op de grond. Analoog aan het vergelijken van de hoek in sectie 6.2 kunnen we hier ook gebruik maken van het inwendig product om dit makkelijk te testen. De formule in die sectie was: vlakken gelijk qua hoek n vlak1 n vlak2 > cos(α) Analoog kunnen we nu een formule opstellen voor vlakken die loodrecht op elkaar staan: vlakken loodrecht n vlak1 n vlak2 < cos(90 α) Waarbij α de toegestane afwijking is (in graden). Het ene vlak is in dit geval het grondvlak. Van het grondvlak kennen we de normaal n grond = (0, 0, 1) T = e z. Als we dit invullen in de formule vereenvoudigt deze tot: vlak loodrecht op grond n z < cos(90 α) Met n z de z-component van de normaal van het vlak. 33

51 Om de normaal van het volledige segment te bepalen passen we op het segment in het geheel RANSAC toe. Het toepassen van RANSAC op het volledige segment zorgt ervoor dat we een nauwkeurigere normaal hebben dan de normalen die bepaald waren in de individuele voxels. Het volledige segment bevat veel meer punten waardoor de ruis beter uitgemiddeld kan worden Minimale hoogte & Minimaal aantal punten Sommige kleine stukjes struik of gras of andere objecten zoals kleine paaltjes kunnen ook loodrecht op de grond staan. De hoek alleen kan dus zeker niet voldoende zijn om de gevels eruit te filteren. Deze kleine objecten verschillen voornamelijk van gevels door hun grootte. Gevels zijn een stuk groter en hoger dan deze kleine objecten. Twee extra parameters die we ingevoerd hebben om gevels te kunnen selecteren zijn dus een minimale hoogte en een minimaal aantal punten. Deze parameters kunnen we dan zo kiezen zodat heel wat van de kleinere objecten al in deze eerste stappen weggefilterd worden Keuze waarden parameters Hoek met de grond: Voor de eerste parameter, de afwijking op de hoek die het vlak maakt met de grond gebruiken we een waarde van 20. Een vlak mag dus 20 afwijken van perfect loodrecht. Deze waarde moet groter zijn dan 0 omdat muren misschien niet perfect loodrecht staan, maar voornamelijk omdat de normaalberekening van een vlak niet altijd perfect gebeurt. Er zit namelijk ruis op de puntwolk en zeker als het gedetecteerde vlak niet zoveel punten bevat zal de normaal niet echt duidelijk zijn. In figuur 7.1 A zien we dat de hoek alleen inderdaad niet genoeg is om de gevels eruit te kunnen filteren. Minimaal aantal punten: De waarde die gebruikt wordt voor het minimaal aantal punten is 30. Met deze parameter willen we zeer kleine vlakken uit de puntwolk halen. Het resultaat na deze filteroperatie is weergegeven in figuur 7.1 B. Deze filter bouwt verder op het vorige resultaat uit figuur 7.1 A. Er zijn heel wat vlakken verwijderd door deze extra stap toe te passen, maar geen van deze vlakken was echt belangrijk. Toch is een minimaal aantal punten op een vlak ook nog niet genoeg om enkel de gevels over te houden. Minimale hoogte: Naast het minimaal aantal punten is er nog een andere manier om de grootte van een gevel uit te drukken: de hoogte. Het is mogelijk om een gevel te onderscheiden van een muurtje of de binnenzijde van een inrit door de hoogte van het vlak te bekijken. Een goede waarde voor deze parameter is 2,5 meter. Het resultaat daarvan is weergegeven in figuur 7.1 C. We zien dat er heel wat van de foutieve gevels verdwenen zijn sinds het vorige resultaat in figuur 7.1 B. Bij één huis zijn er echter ook twee stukken gevel verdwenen. Dit huis bevindt zich achter een haag waardoor deze gevels amper zichtbaar zijn. Deze fout is dus moeilijk te vermijden. De voordelen wegen echter op tegen de nadelen. Naast deze twee correcte gevels die verwijderd zijn, zijn 78% wat alle foutieve gevels die er nog waren correct verwijderd. totaal vóór totaal na foutieve vóór foutieve na % foutieve verwijderd 167 vlakken 49 vlakken 149 vlakken 33 vlakken 78 % 34

52 Figuur 7.1: A: Alle vlakken in de puntwolk die loodrecht op de grond staan. B: Alle vlakken in de puntwolk die loodrecht op de grond staan en meer dan 30 punten bevatten. C: Alle vlakken in de puntwolk die loodrecht op de grond staan en meer dan 30 punten bevatten en een hoogte hebben die groter is dan 2,5 meter Resultaat Deze eerste heuristiek slaagt er al zeer goed in om gevels te selecteren zoals we kunnen zien in figuur 7.1 C. In deze figuur blijven er maar 33 foutieve vlakken meer over van de 960 vlakken uit figuur 7.1 A. 7.2 Weergeven gevels op kaart In figuur 7.1 zijn de verschillende segmenten als lijnen weergegeven op de kaart. Hoe dit gebeurt hebben we nog niet besproken. Daarvoor moeten we voor een puntwolk van een segment een lijn bepalen. De techniek die we gebruiken staat hieronder in detail uitgelegd. In het kort bepaalt de methode eerst een vector in het XY-vlak die langs de lijn loopt. Alle punten in het segment worden dan overlopen en geprojecteerd op deze vector. De minimum- en maximumwaarden worden bijgehouden. Dit zijn de uiterste punten langs deze vector en dus de uiteinden van het lijnstuk. Schematisch is dit weergegeven op figuur 7.2. Op de normaalvector van het vlak wordt dezelfde techniek toegepast om de positie van de lijn in de andere richting te bepalen. De hoogte van de muur wordt bepaald door deze techniek toe te passen langs de eenheidsvector in z-richting e z. Voor de z-richting bijvoorbeeld hebben we dan u min en u max als 35

53 minimum en maximum langs de vector e z en loopt het vlak dan van u min e z tot u max e z langs de z-as. min max zijvector normaal Figuur 7.2: Schematische weergave van het bepalen van een lijnstuk voor een segment. We kennen normaal n XY Z = (x 1, y 1, z 1 ) van het segment dat we bekijken. Dit hebben we bepaald met behulp van RANSAC, zoals beschreven in sectie We veronderstellen dan een muur loodrecht op de grond staat. Als eerste stap zullen we de normaal dus projecteren in het XY-vlak. n XY = (x 1, y 1, 0) T n = n XY = n XY n XY = (x 1, y 1, 0) T We hebben nu de normaal van de lijn die we zullen tekenen op de kaart. We bepalen nu ook de zijvector q. Deze zijvector kan berekend worden door het kruisproduct te nemen tussen de vector n en de omhoogvector u = (0, 0, 1) T = e z. Dit kan vereenvoudigd worden tot: q = u n q = (y 1, x 1, 0) Voor elk punt p in het segment bepalen we nu hoe dat punt kan geschreven worden als een lineaire combinatie van de vectoren n, q en u. q punt = p q q q n punt = p n n n u punt = p u u u Over alle punten heen bepalen we nu het minimum en maximum van deze waarden: q min, q max, n min, n max, u min, u max. Langs de normaal leggen we de lijn nu op n c = nmax+n min 2. Langs de zijvector start de lijn op q min en eindigt deze op q max. Door nu terug een lineaire combinatie te nemen met deze waarden kunnen we de twee uiterste punten van de lijn bepalen: A = n c n + q min q B = n c n + q max q We hebben nu een lijnstuk AB dat overeenkomt met het segment dat we ingelezen hebben. Dit kunnen we nu tekenen op de kaart. 36

54 7.3 Fout gedetecteerde gevels met de simpele heuristiek De eerste selectie van de gevels zoals beschreven in sectie 7.1 werkt al zeer goed. Heel veel van de vlakken die geen gevels zijn worden door die heuristiek al correct verwijderd. We denken dat de selectie van gevels echter nog beter kan. Daarom zullen we in deze sectie kijken naar een aantal foute vlakken die nog niet verwijderd zijn met de bestaande gevelselectieheuristiek. De eerste selectie hield in om enkel vlakken te tonen die een hoek maken van meer dan 70 met de grond, meer dan 2,5 meter hoog zijn en meer dan 30 punten bevatten. In dit geval krijgen we een resultaat als in figuur 7.1 C. We zien dat bijna alle gevels inderdaad aanwezig zijn in de figuur maar dat er ook nog een aantal andere vlakken zijn die aan deze eigenschappen voldoen. We hebben alle overgebleven foute vlakken bekeken en gesorteerd in categorieën. Een eerste soort van fouten noemen we de toevallige vlakdetectie. Van deze categorie komen zeer veel fouten voor en het zou zeer nuttig zijn om hier een goede oplossing voor te vinden. Bij deze soort bevinden zich een hele hoop punten in een ongestructureerde groep. De vlakdetectie vindt hierin dan toevallig een vlak dat voor een heel aantal van deze punten een correct vlak vormt. Dit komt bijvoorbeeld voor in bomen en struiken. Als dit gedetecteerde vlak dan toevallig recht genoeg staat, hoog genoeg is en genoeg punten bevat wordt er een gevel gedetecteerd. Voorbeelden hiervan vindt u in figuur 7.3. Zoals in de voorbeelden is te zien, worden heel wat van deze vlakken veroorzaakt door bomen. Het zou nuttig kunnen zijn om bomen te proberen detecteren en apart te behandelen om het probleem op te lossen. Figuur 7.3: Door toeval foutief gedetecteerde gevels. Dit probleem komt voor in ongestructureerde stukken puntwolk. 37

55 Een andere soort fout die voorkomt zijn palen. Lantaarnpalen bijvoorbeeld kunnen ook gedetecteerd worden als een gevel. Deze zijn meestal hoog genoeg en staan loodrecht op de grond. Deze vlakken bevatten ook genoeg punten doordat deze zich dicht bij de scanner op de auto bevinden en daardoor met een hoge resolutie gescand worden. Voorbeelden hiervan zijn weergegeven in figuur 7.4. Figuur 7.4: Palen worden soms foutief als gevel gedetecteerd. Daarnaast zijn er nog de losstaande muren. Deze fouten bevatten duidelijke rechte vlakken die aanwezig zijn naast de straat en geen deel uitmaken van een huis. Zoals te zien is in figuur 7.5 worden bijvoorbeeld bepaalde soorten verkeersborden soms aanzien als een muur. Ook de infoborden van een tankstation en de tankautomaten zelf voldoen blijkbaar aan de eisen van de eerste heuristiek. Deze categorie kan waarschijnlijk niet eenvoudig geëlimineerd worden door naar de vlakken zelf te kijken. Daarnaast zijn er met de huidige heuristiek toch nog gevels die verwijderd worden hoewel ze zich wel in de puntwolk bevinden. De meeste van deze gevels zijn echter wel amper aanwezig in de puntwolk. Ook deze soort fouten zal niet zo eenvoudig op te lossen zijn aangezien er van deze gevels te weinig zichtbaar is in de puntwolk. Voorbeelden van zo n gevels zijn te vinden in figuur 7.6. De meest voorkomende problemen hebben we nu wel al gehad. Er zijn echter nog een aantal fouten die in een kleiner aantal gevallen voorkomen. Deze minder voorkomende gevallen hebben we gegroepeerd in figuur 7.7. Een eerste probleem (zie figuur 7.7 A) is dat sommige gevels doorlopen ook al is er een garage of andere aangebouwd. De geveldetectie is hier eigenlijk wel correct, maar de lijn die op de kaart 38

56 Figuur 7.5: Losstaande muren, verkeersborden en reclameborden worden soms foutief als gevel aanzien. aangeduid wordt komt niet overeen met het eigenlijke grondplan van het gebouw. Het is de bedoeling om de omtrek van een gebouw te vinden. Een gevel die in het grondplan loopt zouden we eigenlijk willen negeren. Bij het vergelijken met de kaart zou dit soort gevel wel eens voor een probleem kunnen zorgen. Een probleem dat hiermee misschien deels te maken heeft is het tweede stuk van de afbeelding (B). Bij dit gebouw is de bovenverdieping meer naar achter gebouwd. De gevel van de bovenverdieping voldoet echter ook aan de eisen van de heuristiek. De bovenverdieping wordt dus op de kaart aangeduid als een andere gevel dan de benedenverdieping. Probleem C is compleet verschillend. Hierbij is de lijn die op de kaart wordt aangeduid veel langer dan dat de gevel in werkelijkheid is. In de puntwolk is er namelijk een soort uiteinde verbonden aan de gevel. Deze groep punten werd ook opgenomen als een deel van de gevel. Aangezien de lijn die op de kaart getoond wordt berekend wordt door het minimum en maximum te nemen heeft dit uiteinde een grote invloed op het uiteinde van de lijn terwijl dit niet zou mogen. Als laatste deel van deze figuur hebben we probleem D. In dit probleem is de gevel op de kaart verkeerd geplaatst. De gevel is relatief veel naar achter geplaatst op de kaart. Als we kijken naar de puntwolk zien we dat de gevel van het huis inderdaad sterk verschilt qua diepte. Het is dan ook moeilijk om te bepalen waar de gevel nu juist moet geplaatst worden. Het zou interessant zijn om hier rekening mee te kunnen houden bij de automatische vergelijking met de kaart. We willen dus voor een gevel bijhouden hoe onzeker de positionering ervan is. Een laatste soort fouten werden al besproken in sectie 6.4. Deze fouten bestaan doordat de vlakkendetectie uit het eerste hoofdstuk ook licht kromme vlakken teruggeeft. 39

57 Figuur 7.6: Sommige stukken gevel die aanwezig zijn in de puntwolk worden niet gedetecteerd. Deze gevels zijn echter meestal amper aanwezig in de puntwolk. Figuur 7.7: Overige problemen met de eerste versie van de geveldetectie. 40

58 7.4 Verbeterde gevelclassificatie In de vorige sectie hebben we de verschillende soorten fouten die nog voorkomen in de gevelclassificatie bekeken. In deze sectie gaan we voor elk van deze groepen proberen een oplossing te vinden. Uiteindelijk is het de bedoeling om zoveel mogelijk van deze foute gevels te detecteren en te verbeteren. In sectie gaan we de eenvoudigste groep problemen aanpakken: palen. Palen zijn op een eenvoudige manier te detecteren en kunnen dus makkelijk verwijderd worden. In sectie proberen we het probleem uit figuur 7.7 C aan te pakken. In dat probleem werd de muur te lang aangeduid op de kaart. Een ander probleem met de gevelclassificatie zoals ze nu gebeurt is dat het niet altijd duidelijk af te leiden is uit de puntwolk waar de gevel op een kaart moet geplaatst worden. Er is dus onzekerheid over de positionering van een gevel. In sectie wordt hier verder op ingegaan en wordt een manier beschreven om met deze onzekerheid rekening te houden. De volgende sectie, sectie pakt de meest voorkomende fout aan: Toevallige muren. Hierbij worden in ongestructureerde delen van de puntwolk toevallig gevels gedetecteerd. Deze sectie introduceert een techniek genaamd natuurdetectie om deze vlakken te verwijderen. In het voorlaatste deel, sectie wordt nog kort vermeld hoe de categorie van losstaande muren kan verwijderd worden. Tot slot wordt er in sectie een techniek voorgesteld die krom gedetecteerde muren (zie sectie 6.4) kan opsplitsen Verbetering: palen verwijderen Van de vorige problemen zijn de palen wel de eenvoudigste om op te lossen. Deze lantaarnpalen hebben namelijk een eigenschap die hen duidelijk onderscheidt van de rest van de vlakken. Deze kunnen eenvoudig weggefilterd worden door de breedte van een vlak te controleren. We hebben dus een extra filterstap ingebouwd waarin gefilterd wordt op breedte. Als we alle vlakken wegfilteren die kleiner zijn dan 1,5 dm dan wordt maar 1 van de twee lantaarnpalen in het voorbeeld weggefilterd. Met een parameter van 3 dm worden beide lantaarnpalen weggefilterd zonder dat er voor de rest zaken veranderen. Het effect van deze eenvoudige aanpassing is te zien in figuur 7.8. Figuur 7.8: Palen worden nu niet meer foutief gedetecteerd als gevels. 41

59 7.4.2 Verbetering: muren inkorten Een volgend probleem dat we zullen oplossen is dat van in figuur 7.7 C. In dat probleem werd de gevel te breed getekend op de kaart doordat er een aantal punten buiten de gevel lagen die toch meegerekend werden. Deze groepen punten kunnen sterk gestructureerd zijn en het is dus niet gewoon mogelijk om deze als ruis te zien of als outliers. We kunnen wel een andere eigenschap zien van deze punten. Meestal zijn dit kleinere structuren dan de muur zelf. Er zal dus voor dat stuk van de gedetecteerde muur minder punten aanwezig zijn. Als we de muur dan vanuit bovenaanzicht bekijken en op elk stuk van de lijn het aantal punten bepalen zal het stuk van de lijn dat we te veel hebben een veel kleinere densiteit hebben. Schematisch ziet u dit in figuur 7.9. Op deze manier kunnen we dan dat stuk van de lijn elimineren. Bepaal dichtheid punten langs de muur Veel punten per afstand Weinig punten Figuur 7.9: Schematische voorstelling van een muur die te breed wordt weergegeven op de kaart. In de praktijk pakken we dit aan door eerst het gemiddeld aantal punten per afstandseenheid langs de muur te bepalen. Dit doen we door het totaal aantal punten te delen door de lengte van het lijnstuk. verwachte densiteit = totaal aantal punten in vlak lengte van gevonden lijnstuk (7.1) Eens we dit gemiddelde hebben moeten we stukken aan de uiteindes van het lijnstuk zoeken waar de densiteit veel kleiner is dan de verwachte waarde. Dit doen we door een klein gebiedje aan het uiteinde van de lijn te kiezen. Daarin tellen we dan alle punten en bepalen we of dit overeenkomt met het verwachte aantal punten. Als dit veel lager ligt verwijderen we dit stuk van de muur. 42

60 Formele beschrijving van de methode Formeel hebben we een lijn AB met een lengte l AB = q max q min. We bouwen hierbij verder op de definities van q max, q min en q punt zoals deze gedefinieerd zijn in sectie 7.2 Met deze lijn komt ook een puntwolk W overeen die we opsplitsen in c = lab l partities p i waarbij elke partitie overeenkomt met een lengte l langs de lijn AB. l is hierbij een parameter die gekozen kan worden. (i [1, c]) Een punt behoort dan tot een partitie p i als de positie langs de zijvector q, q punt ligt tussen: [ [ q min + (i 1) qmax q min, q min + i qmax q min c c Als de punten mooi even verspreid zouden zijn over alle partities zou elke partitie ongeveer d := W c punten bevatten. Dit is nu echter niet het geval waardoor er partities zijn die veel minder dan d punten bevatten. We beslissen dat een partitie p i voldoet aan de densiteitsvoorwaarden als t i = waar met t i gedefinieerd als: t i := p i > (d d frac ) Hierbij hebben we een factor d frac geïntroduceerd die toelaat om de voorwaarde dat de punten even verspreid zijn over de partities minder strikt toe te passen. We bepalen nu de indices van de uiterste partities die voldoen aan de densiteitsvoorwaarden: i min = arg min(t i = waar ) i i max = arg max(t i = waar ) i We kijken naar de uiterste partities die voldoen aan de densiteitsvoorwaarden en verwijderen de partities die erbuiten liggen. De nieuwe puntwolk W kunnen we dan als volgt bepalen: W = {p p p i i min i i max } We kunnen ook eenvoudig de nieuwe q min en q max berekenen q min = q min + (i min 1) qmax q min c q max = q min + i max qmax q min c en zo dus eenvoudig het lijnstuk AB opnieuw bepalen. Resultaten In figuur 7.10 ziet u het resultaat van het algoritme. Stukken lijn werden verwijderd per decimeter (l = 0, 1) en enkel als er vijf keer zo weinig punten waren als verwacht (d frac = 0, 2). We zullen eerst de pijltjes op de figuur bespreken. We zien dat er bij de foute vlakken een aantal wat ingekort zijn. Dit is natuurlijk geen probleem aangezien we deze toch nog willen verwijderen. Meestal zijn dit ook zeer kleine stukken. We zien ook dat er bij de de gevels van 43

61 Figuur 7.10: De heuristiek voor het inkorten van de randen van een lijn lost het probleem van figuur 7.7 C op. De gevolgen voor andere vlakken zijn beperkt. Figuur 7.11: Deze figuur geeft de onzekerheid van de positionering van de gevels weer. De dikte van een lijn op de kaart geeft aan waar de muur zich potentieel allemaal kan bevinden. sommige gebouwen zeer kleine inkortingen gebeurt zijn. Dit zijn allemaal aanpassingen die niet zo belangrijk zijn. De twee belangrijke wijzigingen zijn aangeduid met A en B. Zoals we zien in A zijn we er inderdaad in geslaagd om het probleem dat we hadden op te lossen. De tweede belangrijke verandering echter (B) toont een gevel die foutief ingekort is. Deze gevel was echter al niet volledig te detecteren in de puntwolk en het maakt dus uiteindelijk ook niet zo veel verschil dat deze een beetje is ingekort aan die kant. Kortom, dit algoritme lost het probleem op en de overige gevolgen die het heeft zijn zeer beperkt Verbetering: onzekere positionering gevels Het probleem in figuur 7.7 D was dat het niet duidelijk was uit de puntwolk waar de gevel in de diepte kwam te staan. Dit is niet echt een fout in het algoritme, maar het zou nuttig zijn om hier rekening mee te kunnen houden bij het vergelijken van de gevels met de kaart in een later stadium. Het bepalen van de positie van de lijn voor een gevel gebeurt momenteel door het minimum n min 44

62 en maximum n max langs de normaal van de lijn te bepalen. De lijn wordt dan geplaatst op het midden tussen beide nmax+n min 2. Dit is in meer detail beschreven in sectie 7.2. We kiezen de lijn dus door het midden van de puntwolk, maar het is niet zeker dat de lijn daar ook hoort te staan op de kaart. We kunnen wel veronderstellen dat de lijn sowieso door de puntwolk moet gaan. De gevel kan dus liggen tussen n min en n max langs de normaalvector n. Er zijn speciale regels over hoe gevels aangeduid moeten worden op een kaart maar deze zijn niet het onderwerp van deze thesis. Tijdens het vergelijken met de kaart zullen we dus toelaten dat de gevel ergens tussen n min en n max ligt. Op figuur 7.11 is de dikte van de lijn een indicatie van waar deze gevel allemaal kan liggen. Dunnere lijnen zijn dus gevels in de puntwolk die weinig variatie hebben in de diepte. Dikkere lijnen stellen muren voor met meer variatie in de diepte in de puntwolk. Het algoritme is daar dus onzekerder over de correcte positionering van de gevel. Op de figuur zien we echter wel dat het probleem dat we probeerden aan te pakken niet opgelost is door deze aanpassing. De gevonden gevels van het huis dat linksonder in de figuur staat komen nog steeds niet overeen met de gevels op de kaart. De gevonden muren liggen iets meer naar binnen dan verwacht. Dit kan zijn doordat de muur verkeerd aangeduid is op de kaart of doordat de gevels op de kaart op een andere manier gemeten zijn. Het rekening houden met de onzekere positionering van een muur zorgt sowieso voor meer betrouwbare resultaten tijdens het vergelijken met de kaart. Meer info over het vergelijken met de kaart is te vinden in het volgende hoofdstuk, hoofdstuk Verbetering: natuurdetectie Zoals in het eerste deel van dit hoofdstuk vermeld werd was de grootste oorzaak van fouten echter de bomen of andere natuur die toevallig genoeg punten op een verticaal vlak hadden om als gevel gedetecteerd te worden. Op figuren zien we echter een duidelijk verschil tussen deze toevallige vlakken en echte gevels als we kijken naar de onmiddellijke omgeving. Er worden in deze gevallen namelijk vlakken gedetecteerd in stukken waarin veel punten liggen die bijna willekeurig verspreid zijn. De vraag is natuurlijk hoe we deze willekeurigheid uitdrukken en hoe we het verschil duidelijk maken met gewone ruis. Een idee dat we hadden was om per voxel te kijken. Aangezien de vlakken een beetje willekeurig gedecteerd worden in deze stukken met natuur is het zeer onwaarschijnlijk dat zo een vlak veel punten van de voxel bevat. Bij gevels is dit echter wel het geval, de een of twee grootste vlakken zullen daar het merendeel van de punten van de voxel bevatten. Dit leek ons dus een interessant idee om van te vertrekken om bomen en andere natuur te detecteren in voxels. Kortom, onze aanname is als volgt: gebieden met natuur bevatten veel (willekeurige) vlakjes met weinig punten (relatief gezien). gebieden met gevels en andere vlakke objecten daarentegen bevatten weinig vlakken die een zeer groot deel van de punten in die omgeving vertegenwoordigen. Formeel kunnen we dit als volgt schrijven. Zij v i het i-de vlak in de voxel waarbij j (j < i v j v i ) en i [1, c]. De grootste vlakken hebben dus de kleinste index. Zij v het totaal 45

63 aantal punten in de voxel. Dan kunnen we onze veronderstelling uitdrukken als: voxel met natuur voxel met gevels (geen natuur) 2 v i << v i=1 2 v i v i=1 In deze formule gebruiken we << om aan te duiden dat de ene waarde veel kleiner is dan de andere. Om dit te kunnen gebruiken in een programma moeten we echter beslissen hoeveel kleiner. Met duiden we aan dat we verwachten dat in een voxel met een gevel de grootste twee vlakken bijna alle punten in de voxel zullen bevatten. Om vast te leggen wanneer de waarde veel kleiner is dan de andere voeren we een extra parameter in: a. Ook hoeveel van de grootste vlakken gebruikt worden maken we variabel door een parameter k in te voeren. De beslissing wordt dan: voxel met natuur voxel met gevels (geen natuur) k v i < a v i=1 k v i a v i=1 Om te testen of deze aanname een correcte eerste schatting maakt van het onderscheid tussen natuur en gevels hebben we deze gevisualiseerd. Resultaten van deze visualisatie zijn te zien in figuur Hierbij is factor 0,77, ofwel de grootste twee vlakken moeten 77 % van alle punten in een voxel bevatten. Op de figuur zien we duidelijk dat deze aanname inderdaad geldt voor de correcte gebieden in de puntwolk. Bomen en struiken worden geselecteerd terwijl de rest van de puntwolk gewoon behouden blijft. Voor enkele gevels wordt er echter soms ook een voxel verwijderd. Soms komt dit door een zeer oneffen stuk in de gevel wat moeilijk te vermijden is, maar er is ook een stuk gevel waar dit een andere oorzaak heeft. Het probleem is te zien in figuur Deze gevel is opgebouwd uit verschillende dieptes, zo zitten bijvoorbeeld de ramen dieper in de gevel. Verder bevindt dit stuk zich ook op de hoek. Hierdoor beslaan de twee grootste vlakken niet het grootste deel van de punten in de voxel. Als we echter ook de vlakken die evenwijdig zijn of loodrecht staan op de twee grootste vlakken zouden meerekenen zou deze voxel wel als gevel worden aanzien. We hebben het algoritme dan ook aangepast om rekening te houden met deze evenwijdige of loodrecht staande vlakken. Formeel: Zij v i het i-de vlak in de voxel waarbij j (j < i v j v i ) en i [1, c]. Zij v het totaal aantal punten in de voxel. De beslissing wordt dan: Voxel met natuur k v i + i=1 c j=k+1 k i=1 ( n i n j > cos(α) n i n j < cos(90 α)) v j < a v 46

64 Figuur 7.12: Resultaat van het natuurdetectie algoritme met factor 1.3. In deze figuur zijn de voxels in groen aangeduid als het algoritme deze detecteert als natuur. Voxels in het rood of het blauw zijn voxels die niet als natuur gedetecteerd worden. Hierin is α de toegelaten afwijking qua hoek en is ni de normaal die overeenkomt met vlak vi. Hoeken worden hierbij vergeleken door te kijken naar de absolute waarde van het inwendig product van de normalen tussen beide vlakken. Deze aanpassing aan het algoritme heeft weinig invloed op de gebieden met natuur die in de vorige versie correct gedetecteerd werden, maar deze aanpassing lost het probleem uit figuur 7.13 wel op. Dit is ook weergegeven in figuur Voxels die nu op een hoek van een gebouw liggen worden toch correct behouden. Vlakken die evenwijdig zijn of loodrecht staan op de twee grootste vlakken worden nu namelijk ook meegeteld. We kunnen nu de gedetecteerde vlakken in deze voxels verwijderen voor deze samengevoegd worden met andere vlakken. Aangezien deze vlakken natuur voorstellen en dus relatief willekeurig geplaatst zijn verwachten we dat er toch niet veel nuttige informatie uit zou komen. Nadat we dan terug alle andere stappen toepassen in de geveldetectie krijgen we een resultaat zoals in figuur We gebruiken hierbij 15 als maximale hoek tussen twee evenwijdige vlakken en 0,65 als factor in het algoritme. Op de figuur zien we duidelijk dat de natuurdetectie goed werk levert. Heel wat van de fout gedetecteerde vlakken die behoorden tot deze foutcategorie zijn verwijderd en alle gevels zijn intact gebleven. Er schieten wel nog een tweetal zeer kleine vlakjes over op de figuur. Deze komen overeen met de stammen van bepaalde bomen of met kleine paaltjes. We zouden deze op dezelfde manier kunnen verwijderen als de manier waarop palen verwijderd worden door gewoon de parameter van die heuristiek nog iets hoger te zetten. Het verwijderen van palen 47

65 Figuur 7.13: Foutief verwijderde voxel op de hoek van een gebouw met de eerste versie van de natuurdetectie. De eerste versie van de natuurdetectie maakt soms nog fouten op de hoeken van gebouwen. Figuur 7.14: Het verschil tussen de eerste en tweede versie van de natuurdetectie heuristiek. werd besproken in sectie Als we de parameter van de paaldetectie verhogen tot 7 dm dan verdwijnen inderdaad ook deze kleine vlakjes. Zie figuur

66 Figuur 7.15: De resultaten van de natuurdetectie heuristiek. De linkse afbeelding toont het resultaat zoals het was vóór het toepassen van de natuurdetectie. De middelste afbeelding toont het resultaat na de natuurdetectie en de rechtse afbeelding geeft aan wat het verschil is tussen beide. Er zijn heel wat foutieve vlakken verwijderd Verbetering: negeren losstaande muren Het is niet altijd duidelijk of een muur die zich alleen bevindt in de puntwolk deel is van een huis of niet. Meestal zal het algoritme echter ook andere gevels van een huis detecteren. De foutcategorie van losstaande muren zou er dus uitgefilterd kunnen worden door te kijken naar de directe omgeving van de muur en te zien of er zich nog andere muren rond bevinden. Meestal zullen deze andere muren loodrecht staan op deze muur of er parallel mee zijn. In deze thesis hebben we ervoor gekozen om deze muren niet te verwijderen in dit hoofdstuk. Het kan namelijk zijn dat we maar één zijde van een gebouw kunnen detecteren in de puntwolk. In hoofdstuk 8 negeren we deze gevels echter wel als deze niet op de kaart voorkomen. De manier waarop dit bepaald wordt is besproken in sectie Het voordeel hiervan is dat we de afwijking kunnen bepalen als de gevels wel zouden voorkomen op de kaart, maar geen probleem hebben als deze toch niet voorkomen Verbetering: opsplitsen van kromme muren. De techniek voor het opsplitsten van een gevel werkt door de gevel in stukken van een bepaalde lengte te splitsen. Dit gebeurt op een gelijkaardige manier als voor het inkorten van de muren in sectie De gevel wordt opgesplitst in stukken van 2 meter. Voor elk stuk van deze gevel 49

67 wordt een normaal berekend via RANSAC. Het algoritme start dan van één van beide zijden en overloopt alle stukjes. Er wordt getest of zo een stukje voldoende evenwijdig is met het allereerste stuk in de rij. Verder wordt ook de afstand getest door de afstanden te bepalen vanaf beide uiteinden van het stuk naar het verlengde van de lijn van het eerste stukje in de rij. Als een van beide niet voldoet aan de eisen zullen de voorgaande stukken afgesplitst worden in een apart vlak en doet het algoritme verder met de rest van de stukken. Formeel wordt een stukje s i als volgt vergeleken met het eerste stukje s 1. Hoek ok n 1 n i > cos(α) Afstand ok max (d(a i, s 1 ), d(b i, s 1 )) < a Hierbij is n i de normaal van stukje s i, is a i het eerste uiteinde van s i en b i het andere uiteinde van s i, is α de toegelaten afwijking op de hoek, is a de toegelaten afwijking van het verlengde van de lijn voorgesteld door s 1 en is d(p, l) de loodrechte afstand van een punt p tot een lijn l. In deze thesis hebben we een waarde van 30 gebruikt voor α en een waarde van 5 dm voor de toegelaten afwijking a. De resultaten van deze techniek zijn te vinden in figuur De gevel in de figuur wordt met de nieuwe techniek correct gesplitst in meerdere aparte gevels. Voor Na Figuur 7.16: De resultaten voor en na het splitsen van gevels. 7.5 Conclusie en resultaten van de gevelclassificatie In figuur 7.17 is het resultaat van de gevelclassificatie te zien. De gevelclassificatie werkt vrij goed en in het resultaat blijven bijna enkel nog echte gevels over. De gevels zijn verder ook vrij 50

68 correct afgebakend. Enkele gevels lopen te ver door, maar dit komt doordat deze gevel ook in de realiteit door het gebouw loopt. Figuur 7.17: Het eindresultaat van de gevelclassificatie. Rechts in het resultaat van het algoritme te zien op een ander deel van de kaart. Om dit resultaat te bereiken zijn er heel wat heuristieken toegepast. Er is begonnen met een controle op de hoek met de grond. Daarna is er een minimum opgelegd voor het aantal punten in een vlak en een minimum voor de hoogte van een vlak. Deze eerste selectie van vlakken hebben we dan proberen verbeteren door een aantal heuristieken te bedenken en toe te passen. In een eerste techniek houden we ook rekening met de breedte van een muur. De minimale breedte wordt geplaatst op 3 dm om lantaarnpalen weg te filteren uit het resultaat. In een latere sectie verhogen we deze parameter naar 7 dm om ook enkele boomstammen te kunnen wegfilteren. De volgende aanpassing die we gemaakt hebben zorgt ervoor dat sommige kleine stukjes puntwolk verwijderd worden uit een muursegment als deze daar niet thuishoren. Om te beslissen welke stukjes verwijderd moeten worden, wordt de gevel onderverdeeld in een aantal partities en wordt de densiteit van elk van deze partities getest. 51

69 Een verdere aanpassing bepaalt hoe onzeker de plaatsing van een muur op de kaart is. Deze onzekerheid is groter als het niet duidelijk is uit de puntwolk waar de gevel exact zou moeten worden getekend op een kaart. Dit heeft geen rechtstreeks effect op het resultaat in figuur 7.17 maar zal in een volgend hoofdstuk gebruikt worden om gevels beter te kunnen vergelijken met een kaart. In de volgende heuristiek wordt de grootste categorie aan fouten aangepakt. Deze categorie bestaat uit vlakken die toevallig gedetecteerd worden doordat dat stuk puntwolk zeer veel willekeur bevat. Deze gebieden kunnen bijvoorbeeld ontstaan door de kruin van een boom. Het doel van deze heuristiek is om deze toevallige vlakken te detecteren en te verwijderen. Deze natuurdetectie probeert de willekeur van die vlakken uit te drukken en op basis van die uitdrukking dan een beslissing te maken. Het algoritme slaagt hier goed in. De voorlaatste sectie (7.4.5) merkt op dat losstaande muren ook weggefilterd zouden kunnen worden, maar dat er in deze thesis geopteerd wordt om deze gewoon te negeren als dit nuttig is. De laatste sectie (7.4.6) beschrijft een heuristiek die kromme muren kan splitsen. We zien aan het resultaat in die sectie dat deze heuristiek ook goed werkt. In tabel 7.1 zijn het aantal fouten die elk van de heuristieken oplost weergegeven. De heuristieken die de gevels aanpassen worden niet in deze tabel getoond. Heuristiek Aantal correcte gevels na toepassing Totaal aantal vlakken na toepassing geen heuristiek toegepast Incorrect verwijderde gevels Correct verwijderde vlakken 1 hoek testen ,6% 2 minimaal aantal punten ,2% 3 minimale hoogte ,9% 4 natuurdetectie ,7% 5 minimale breedte ,0% Tabel 7.1: De resultaten van de verschillende heuristieken wat het aantal fout geclassificeerde gevels betreft. De procenten in de laatste kolom geven aan hoeveel procent van het aantal foutieve vlakken dat nog overbleef verwijderd werd door de heuristiek. In het volgende hoofdstuk zal op het resultaat van deze gevelclassificatie verder gewerkt worden. De gevonden gevels zullen in dat hoofdstuk vergeleken worden met een kaart. 52

70 Hoofdstuk 8 Vergelijken van de gevonden gevels met een kaart In hoofdstuk 6 Detectie van vlakken in een grote puntwolk hebben we gezocht naar methoden om op een efficiënte manier vlakken te zoeken in zeer grote puntwolken. Met deze vlakken hebben we dan verder gewerkt in hoofdstuk 7 Gevelclassificatie. In dat hoofdstuk hebben we gevels gezocht in deze vlakken. Dit hoofdstuk bouwt ook daarop verder. Nu we de gevels in de puntwolk gevonden hebben, willen we deze ook vergelijken met bestaande kaarten. Dit zou toelaten om het verwerken van puntwolken sterk te versnellen. Personen hoeven dan niet meer elke gevel manueel te controleren, maar kunnen enkel naar de gebieden kijken waarvan het algoritme zegt dat deze waarschijnlijk foutief op de kaart zijn aangeduid. Terminologie: In dit hoofdstuk zullen we lijnen die we gevonden hebben in de puntwolk vergelijken met lijnen die aanwezig zijn in het GRB. We zullen spreken over gevonden lijnen als we het hebben over lijnen die door het algoritme gevonden zijn in de puntwolk. In het andere geval zullen we het hebben over lijnen uit het GRB of lijnen van de kaart. Een lijn uit de puntwolk wordt teruggevonden als er een lijn gevonden wordt in het GRB die dezelfde gevel voorstelt. 8.1 Op een efficiënt manier zoeken van naburige lijnen: het lijnzoekrooster Een operatie die we veel gaan toepassen tijdens het vergelijken van de gevonden gevels met de gevels op de kaart is het zoeken naar lijnen die in de buurt liggen van een andere lijn. Het is natuurlijk mogelijk om alle lijnen te overlopen en de afstand te bepalen tot de lijn waarnaar we de afstand willen kennen. Dit is echter totaal niet efficiënt. Daarom plaatsen we alle lijnen op voorhand in een roosterstructuur. Deze roosterstructuur heeft een bepaalde resolutie r en omvat het volledige te verwerken gebied. Een lijn behoort dan tot 53

71 een cel in het rooster als deze door dit gebied gaat. Een lijn kan ook door meerdere delen van het rooster gaan. In dat geval wordt de lijn ook aan meerdere cellen in het rooster toegevoegd. Een voorbeeld hiervan is te vinden in figuur 8.1. Figuur 8.1: Een lijn wordt in het zoekrooster toegevoegd aan alle vakjes waar het doorgaat. Tijdens het zoeken naar lijnen die in een bepaald gebied rond een andere lijn liggen kunnen we dan van deze structuur gebruikmaken en hoeven we enkel de lijnen te bekijken die liggen in de vakjes in en rond het gebied waar we zoeken. Voor het lijnzoekrooster gebruiken we een resolutie r van 1 meter. Deze keuze van deze parameter heeft geen invloed op de resultaten van het algoritme. Zonder het lijnzoekrooster zou het zoeken naar naburige lijnen echter veel trager gaan. 8.2 Vergelijken van gevonden lijnen met lijnen in het GRB Het vergelijken van de gevonden lijnen met de lijnen in het GRB gebeurt in een aantal stappen. In de volgende deelsecties overlopen we deze stappen Inlezen van de GRB data Een eerste stap is het inlezen van de GRB data. Zoals vermeld in sectie is het mogelijk om deze data als svg/xml te exporteren. Deze stap is dus eenvoudig. Na het inlezen voegen we de lijnen ook toe aan een lijnzoekrooster zodat we deze makkelijk kunnen opzoeken Vergelijken gevels GRB en puntwolk Er zijn waarschijnlijk heel wat mogelijke manieren om een groep lijnen met een andere groep lijnen te vergelijken. Er is dan ook niet één unieke oplossing. De manier die we gebruiken is hieronder beschreven. De methode wordt ook toegepast op een klein voorbeeld in figuur

72 Figuur 8.2: Schematische voorstelling van het vergelijking van de gevonden gevels en de gevels in het GRB. Hierbij zijn de rode lijnen de gevels van een gebouw in het GRB en is de blauwe lijn een in de puntwolk gevonden gevel. De verschillende delen in deze figuur worden besproken in sectie Afstand vergelijken Voor een gevonden lijn (in de puntwolk) zoeken we eerst alle lijnen uit het GRB die binnen een afstand l van die lijn liggen. Hiervoor moeten we dus de afstand tussen twee lijnstukken berekenen. We maken hierbij gebruik van het lijnzoekrooster uit sectie 8.1 om dit op een efficiënte manier te doen. Lijnen die verder dan een afstand l van de gevonden lijn liggen zijn worden in de volgende stappen niet meer in rekening gebracht. In het voorbeeld (figuur 8.2 A-B) bevindt één van de rode lijnen zich te ver van de blauwe lijn. Deze wordt dus niet meer bekeken in de volgende stappen. Om de afstand te berekenen tussen twee lijnstukken AB en CD moeten we eerst de afstand berekenen tussen A en CD, B en CD, C en AB en D en AB. Als de lijnstukken niet snijden is het minimum van deze afstanden de afstand tussen beide lijnstukken. Als de lijnstukken wel snijden is de afstand natuurlijk 0. De afstand tussen twee lijnstukken is dus even eenvoudig als het berekenen van de afstand tussen een punt en een lijnstuk of het testen of twee lijnstukken snijden. De parameter l die de afstand voorstelt waarin gezocht wordt naar lijnen in het GRB hebben we ingesteld op 2 meter. Als een muur 2 meter verkeerd geplaatst is op de kaart zal het algoritme dat nog opmerken. Hoek vergelijken Verder zoeken we enkel lijnen die min of meer evenwijdig zijn met de gevonden lijn. Anders zullen die lijnen zeker niet over dezelfde gevel gaan. Deze hoek wordt vergeleken door net zoals in stap 1 in sectie 6.2 te kijken naar het inwendig product tussen de gevonden gevel en de gevel in het GRB. Hierbij hebben we een parameter α die aangeeft welke afwijking we toelaten. Het resultaat van deze operatie is dus dat enkel evenwijdige lijnen uit het GRB overblijven zoals we kunnen zien in het voorbeeld (figuur 8.2 B-C). De parameter α is ingesteld op 10. Overlap bepalen Eens we alle lijnen hebben die binnen een bepaalde afstand van de gevonden lijn liggen en er parallel mee zijn, moeten we nog bepalen welk deel van zo een lijn met de gevonden lijn overeen komt. Een gevel die in het verlengde van de gevonden lijn ligt voldoet namelijk ook aan de voorwaarden voor de afstand en de hoek, maar is bijvoorbeeld de gevel van het aangrenzende 55

73 huis. In het voorbeeld is er ook een lijn die overeenkomt met een andere gevel maar wel binnen een correcte afstand en hoek ligt. Het zou ook interessant zijn om te bepalen hoeveel procent van de gevel gedetecteerd is in de puntwolk. Een manier om dit te bepalen is door de overblijvende lijnen in het GRB te projecteren op de gevonden lijn en visa versa. (figuur 8.2 D) Door de lijnen uit het GRB (rode lijnen in het voorbeeld) te projecteren op de gevonden lijn kan het algoritme bepalen dat de gevonden lijn inderdaad bestaat in het GRB en dus een echte gevel is. Omgekeerd zal voor de ene gevel uit het GRB de gevonden gevel volledig op de lijn geprojecteerd worden, terwijl voor de andere gevel de gevonden lijn er volledig naast geprojecteerd wordt. Dit is dus een goede manier om te bepalen welke lijnen met elkaar overeenkomen en voor hoeveel procent ze overeenkomen. Een lijnstuk projecteren op een andere lijnstuk is eenvoudig. Het houdt gewoon in om beide uiteinden van het ene lijnstuk te projecteren op het andere. In de praktijk houden we zowel per lijn in het GRB als per gevonden lijn bij welk deel van de lijn al gevonden is. Dit doen we door het linkerkant en rechterkant van het gevonden stuk bij te houden. Als er aan beide zijden van een gevel dus een stuk lijn matcht aanzien we de volledige gevel als gevonden. Merk op dat het dus perfect kan voorvallen dat een lijn in het GRB overeenkomt met meerdere gevonden lijnen in de puntwolk of omgekeerd. In die gevallen zal deze methode nog steeds correct werken. Grootte fout bepalen Nu we weten welke lijnen met elkaar overeenkomen en voor hoeveel procent kunnen we ook bepalen hoe verkeerd deze gevel aangeduid is op de kaart. Deze fout komt overeen met de afstand van de gevonden lijn tot de werkelijke positie op de kaart. Dit is opnieuw de afstand tussen twee lijnstukken zoals in Aangezien er meerdere gevonden lijnen kunnen overeenkomen met een lijn uit het GRB zijn er voor sommige gevels meerdere foutafstanden mogelijk. We gebruiken dan een gewogen gemiddelde om de echte fout te bepalen. Hierbij gebruiken we als gewicht de afstand die de gevonden lijn samenvalt met de gevel. Gevonden lijnen die dus meer overeenkomen met de gevel uit het GRB zullen dus meer invloed hebben op de uiteindelijke foutafstand. Formeel kunnen we dit schrijven als: fout voor gevel = i M d i o i i M o i Waarbij d i de afstand is die het i-de gevonden vlak afwijkt van de gevel in het GRB en o i de lengte die beide gevels samenvallen als ze op elkaar geprojecteerd worden. M is de verzameling van de indices van de gevonden vlakken die voldoen aan de criteria voor de afstand en de hoek en dus dicht genoeg bij de gevel in het GRB liggen. Tijdens het berekenen van de foutafstand zal ook rekening gehouden worden met de vage positionering van de muur zoals beschreven in sectie De afstand d i zal gewoon verminderd worden met (n max n min )/2. 56

74 8.2.3 De kans op een nieuwe en verwijderde gevel We weten nu welke gevonden lijnen in de puntwolk overeenkomen met welke lijnen in op de kaart en voor hoeveel procent. We kunnen ook een foutafstand voor die gevels bepalen. We willen echter ook kunnen beslissen wanneer een gevonden lijn een nieuw gebouw voorstelt op de kaart. Eigenlijk moeten we van een lijn dus een score kunnen bepalen die zegt hoeveel kans er is dat deze gevonden lijn inderdaad ook deel is van een gebouw. Als deze lijn dan niet op de kaart gevonden wordt en de lijn een score heeft die groot genoeg is, zal dit meegedeeld worden aan de gebruiker. Verder willen we het ook kunnen detecteren als er gevels op de kaart voorkomen die in de realiteit niet meer aanwezig zijn. We willen dus ook een score geven aan elke gevel die we lezen uit het GRB. Deze score zal aangeven hoeveel kans er is dat deze gevel zich in de puntwolk bevindt. Als deze kans groot is en deze gevel toch niet in de puntwolk gevonden wordt, dan is de gevel waarschijnlijk verwijderd... Score voor een gevonden lijn in de puntwolk Met deze score willen we uitdrukken hoe waarschijnlijk het is dat dit stukje lijn ook deel is van een huis. Het is niet noodzakelijk om echt een score te berekenen. Zolang er maar een antwoord kan gegeven worden op de vraag of een bepaalde lijn genoeg is om te veronderstellen dat daar een nieuw huis staat. Deze vraag moet enkel kunnen beantwoord worden voor een lijn die gevonden werd in de puntwolk maar niet voorkomt op de kaart. Voor deze beslissing is het logisch om rekening te houden met de lengte van het lijnstukje. Een klein lijnstukje kan al snel toevallig gedetecteerd worden. Een groot stuk lijn daarentegen zal minder snel toevallig voorkomen. De grootte alleen laat ons echter niet toe om het onderscheid te maken tussen een verkeersbord of een losstaande muur en een echte gevel van een gebouw. Het is toch mogelijk om hier een onderscheid tussen te maken. Zo zal een huis uit meerdere gevels bestaan. Het tweede criteria dat we invoeren is dus of er zich in de buurt van de lijn nog een tweede lijn bevindt die loodrecht op deze lijn staat. Het volledige criterium hebben we als volgt vastgelegd: Een lijnstuk AB is zeer waarschijnlijk deel van een gevel d(a, B) + d(c, D) > s CD L Met L de verzameling van lijnstukken gedefinieerd door: L = {CD d(ab, CD) < t p i p j < cos(90 α)} Hierbij is AB het lijnstuk dat we momenteel verwerken. Hierbij is s de minimale lengte van de gevel plus alle gevels die er loodrecht op staan binnen een bepaalde afstand t. De parameter α geeft aan wat de toegelaten afwijking is op de hoek tussen het vlak en een vlak dat er loodrecht op zou moeten staan. d(a, B) berekent de afstand tussen punten A en B en d(ab, BC) de afstand tussen de lijnstukken AB en BC. 57

75 Met deze formules leggen we dus vast of een muur die gedetecteerd werd in de puntwolk en niet teruggevonden wordt op de kaart een nieuw gebouw voorstelt of gewoon een muur is. De parameter t die bepaalt hoe ver in de omgeving gezocht wordt naar lijnstukken is in deze thesis ingesteld op 4 dm. α is vastgelegd op 10 en de minimale lengte s van de groep gevels is bepaald op 7 meter. Als een groep gedetecteerde gevels minder dan 7 meter lang zijn zullen deze niet als een nieuwe gevel aanzien worden. Score voor een lijn in het GRB Ook bij een lijn in het GRB willen we kunnen bepalen hoe waarschijnlijk het is dat we deze vinden in de puntwolk. Als we deze dan niet zouden terugvinden melden we aan de gebruiker dat de gevel niet meer bestaat. Er moet dus gekeken worden naar de puntwolk om deze score te bepalen. We zouden in de omgeving rond de lijn moeten kijken naar de densiteit van de puntwolk. Als er zich punten in die omgeving bevinden weten we dat de laserscanner tot dat punt kon scannen. We bepalen deze densiteit door tijdens het overlopen van de verschillende stukken rooster ook een densiteitsafbeelding op te stellen. In figuur 8.3 wordt deze densiteit visueel weergegeven. Deze informatie wordt bijgehouden in een rooster met een bepaalde resolutie r d. Zoals ook op de figuur te zien is geeft deze densiteitsinformatie een goed idee welke gevels in de puntwolk gevonden kunnen worden. We stellen deze densiteitsafbeelding echter voornamelijk op voor de gebieden die een gemiddelde densiteit hebben. Een gebied met een gemiddelde densiteit geeft namelijk aan dat de laserscanner tot die positie kon scannen wat we willen weten. We houden bij deze beslissing ook rekening met de grootte van een gevel. Bij kleine stukken gevel is het altijd mogelijk dat deze per ongeluk niet gedetecteerd worden of in één van de stappen uit de gevelclassificatie verwijderd worden. De score voor de lijn wordt dan bepaald door de som te nemen van de densiteit in de omgeving en deze uit te middelen over de lengte. Formeel: (i,j) O min(d i,j, a) l Hierbij is O de verzameling van coördinaten van vakjes in het densiteitsrooster waar de lijn doorgaat, D i,j is de densiteit van het vakje (i, j) en l is de lengte van de lijn. Het minimum zorgt ervoor dat één vakje met een zeer hoge densiteit niet genoeg is om een hoge score te halen. Een groot stuk van de omgeving van de lijn zou een gemiddelde densiteit moeten hebben. Er zijn voor deze beslissing dus nog drie extra parameters die we moeten invullen: de minimale lengte van de lijn u, de bovengrens voor de densiteit in een vakje voor het gebruik in de score a. De lijn wordt dan aanzien als een verwijderde gevel als de score groter is dan een bepaalde drempel b. De resolutie van het densiteitsrooster r d is ingesteld op 1 meter. Voor de minimale lengte van een lijn u is de waarde 3 meter gebruikt. De gebruikte bovengrens voor de densiteit a staat op 12 punten/meter 2 en de drempel b is ingesteld op 10 punten/meter 2. Deze laatste twee parameters zijn kunnen hoger ingesteld worden voor puntwolken met een hogere densiteit. 58

76 Figuur 8.3: kaart. Voorbeeld van een densiteitsrooster. In B zijn ook de gevels uit het GRB aangeduid op de Beslissen nieuwe gevel, verwijderde gevel en gevel met afwijking In sectie werd beschreven hoe bepaald wordt welke gevels zullen worden gesignaleerd aan de gebruiker als deze niet teruggevonden worden. De bepaling is dus al een groot stuk gebeurd. Het enige wat nog beslist moeten worden is wanneer een lijn al dan niet als teruggevonden in het GRB aanzien kan worden. Als een lijn voor 80% gevonden wordt kan met overtuiging gezegd worden dat deze inderdaad gevonden is. Dit is minder duidelijk als een lijn maar voor 10% gevonden wordt. Een gevel kan per toeval een zeer klein stukje overlappen met de gevel van een ander naburig huis. We melden pas aan de gebruiker dat een muur op een afwijkende positie staat als meer dan 20% van de muur gevonden werd in de dataset. Een verwijderde muur kan nog wat overlappen met een muur van een naburig huis. Bij het melden van een verwijderde muur laten we toe dat een muur toch nog voor 1% gevonden wordt. Ook bij een nieuwe gevel laten we toe dat deze lijn voor 1% overeenkomt met een gevel in het GRB. Verder duiden we een afwijkende muur pas aan op de kaart als deze een afwijking heeft die groter is dan 2 dm. De keuze van deze parameter is natuurlijk sterk afhankelijk van de toepassing waarin dit algoritme gebruikt wordt. 59

77 8.3 Resultaten Legende: gevonden afwijking grote gevonden afwijking nieuwe gevel gedetecteerd gevel niet meer aanwezig in puntwolk muur uit puntwolk gevel op kaart Figuur 8.4: Het resultaat van het vergelijken van de gevonden gevels met de gevels op de kaart. In figuur 8.4 is het resultaat getoond van de vergelijking van de gevonden gevels met de gevels op de kaart. Bij de meeste huizen zien we dat de afwijking 0 is. Bij het huis linksonder zien we een afwijking van 4 dm staan. Dat de positie van de gevonden gevel afwijkt hadden we al opgemerkt in sectie Dat deze afwijking duidelijk aangeduid wordt op de kaart geeft aan dat ons algoritme goed in staat is om afwijkingen te detecteren. Ook de positie van één van de gevels van het huis linksboven wijkt blijkbaar wat af van de positie op het GRB. Op deze kaart zijn ook twee rode stippen te zien. Dit zijn gevels waarvan het algoritme verwachtte dat deze gevonden zouden worden in de puntwolk. Dit is inderdaad ook zo. In sectie 7.1 werden deze lijnen foutief weggefilterd. Dit zijn de enige twee gevels die foutief weggefilterd werden in hoofdstuk 7. Deze gevels bevinden zich in de puntwolk echter wel voor het grootste deel in de schaduw. Er zijn geen nieuwe gevels gedetecteerd op figuur 8.4. Dit is correct, alle huizen in de puntwolk 60

78 Figuur 8.5: Het algoritme slaagt erin om huizen te detecteren die niet op de kaart aanwezig waren. De kaart die meegegeven wordt aan het algoritme bevat in dit voorbeeld geen enkel huis. Figuur 8.6: Het algoritme slaagt er ook in om muren te detecteren die van de kaart verwijderd moeten worden. In dit voorbeeld is een extra stuk gevel toegevoegd aan een huis om te testen. We zien het algoritme inderdaad correct detecteert dat deze gevel niet meer aanwezig is in de puntwolk. zijn ook aanwezig op de kaart. Het algoritme werkt ook correct als er wel huizen zijn die niet aanwezig zijn op de kaart. Een voorbeeld is te vinden in figuur 8.5. In deze figuur hebben we alle huizen van de kaart verwijderd (er zijn dus geen paarse lijnen aanwezig op de kaart) en dan het algoritme toegepast. Het algoritme werkt zeer goed. Alle gevels worden aangeduid op de kaart met een groene cirkel. Een persoon die de kaart moet controleren zal deze groene cirkels snel opmerken en hoeft niet de volledige puntwolk te bekijken om te weten waar er een huis moet toegevoegd worden. In figuur 8.6 hebben we op het GRB een stuk huis extra aangeduid. Het algoritme detecteert ook dit correct. De methode in dit hoofdstuk slaagt er dus vrij goed in om de gevonden lijnen te vergelijken met een kaart. 61

79 Hoofdstuk 9 Totaalbeeld In dit voorlaatste hoofdstuk ronden we deze thesis af met een schema van de volledige methode. Daarnaast wordt er ook een overzicht gegeven van de tijd die de methode nodig heeft om te werken en wordt de methode gedemonstreerd op een grote kaart. 9.1 Schematische voorstelling van volledige methode In deze sectie wordt de volledige methode nog eens schematisch samengevat. Het eerste deel (zie figuur 9.1) geeft aan hoe de vlakkendetectie in de puntwolk werkt. Dit is in meer detail besproken in hoofdstuk 6. De puntwolk wordt opgesplitst in een rooster en op elk roosterstuk wordt voxel growing toegepast. Het tweede deel (zie figuur 9.2) gaat over de gevelclassificatie. Dit is besproken in hoofdstuk 7 en bouwt verder op de gevonden vlakken in de puntwolk uit het eerste deel van het schema. Deze selectie gebeurt door een reeks opeenvolgende heuristieken die de foute vlakken eruit filtert. Tot slot hebben we het laatste deel van het schema (zie figuur 9.3) waarin deze gevonden gevels vergeleken worden met de kaart. Dit deel leest de kaart in. Er wordt ook gebruik gemaakt van een densiteitsrooster dat opgebouwd werd in deel 1 om de waarschijnlijkheid van een verwijderde gevel te kunnen bepalen en er wordt gebruik gemaakt van lijnzoekroosters om op een snelle manier lijnen te kunnen opzoeken in een bepaalde omgeving. Dit deel werd besproken in hoofdstuk 8. 62

80 Puntwolk van stad Vlakkendetectie Opsplitsen in rooster Elk roosterstuk apart inlezen Samenvoegen vlakken over verschillende roosterstukken Elk vlak apart inlezen 1 Voxel Growing Opsplitsen in voxels Per voxel RANSAC toepassen 2 Samenvoegen vlakken in voxels Segmenten naar bestand Gevonden vlakken in puntwolk Figuur 9.1: Schema volledige methode: deel 1, vlakkendetectie. ( 1 verwijst naar figuur 9.3, 2 naar figuur 9.2) Gevelclassificatie Minimale hoek met grond Bepalen 2D lijn op kaart Minimale breedte vlak Minimaal aantal punten in vlak Minimale hoogte vlak Inkorten muren Onzekere positionering muren 2 Natuurdetectie Figuur 9.2: Schema volledige methode: deel 2, gevelclassificatie. De natuurdetectie heuristiek ( 2 ) wordt toegepast op voxelniveau in het eerste deel van dit schema (figuur 9.1). 63

81 Gevonden gevels in puntwolk Bestaande kaart Vergelijken kaart Vergelijking met kaart Opzoeken vlakken binnen afstand Vergelijken hoek Bepalen overlap vlakken 3 Inlezen kaart GRB Toevoegen aan lijnzoekrooster 1 Densiteitsrooster Berekenen afwijking Bepalen waarschijnlijkheid verwijderde gevel Resultaten vergelijking met kaart 3 Toevoegen aan lijnzoekrooster Bepalen waarschijnlijkheid nieuwe gevel Afwijking gevonden gevels Nieuwe gevels Verwijderde gevels Figuur 9.3: Schema volledige methode: deel 3, vergelijking met kaart. 9.2 Uitvoering op een grote puntwolk In het grootste deel van deze thesis hebben we gebruik gemaakt van een deel van dezelfde dataset. Dit deel van deze dataset is bijvoorbeeld te zien in figuur 8.4. Deze dataset bevat een te groot gebied aan informatie om weer te kunnen geven in deze thesis. Het algoritme werkt echter ook goed op andere delen van de puntwolk zoals te zien is in figuur 9.4. Die afbeelding bevat een ander deel van de kaart. De tijd die het algoritme hiervoor nodig heeft is te vinden in figuur 9.5 en tabel 9.1. uitvoeringstijd van het algoritme wordt besproken in sectie 9.4. Deze 64

82 Figuur 9.4: Het resultaat van het algoritme op een ander deel van de gebruikte dataset. ID Operatie Totale tijd (millisec.) Aantal uitvoeringen 1 Inlezen roosterstuk Densiteit bijhouden Vlakken zoeken in roosterstuk Gevonden segmenten wegschrijven naar bestand Samenvoegen vlakken over roosterstukken heen Verzamelen vlakken in array Inlezen vlakken voor verdere verwerking Gevelclassificatie Vergelijken gevonden lijnen met kaart Tabel 9.1: De tijdsmetingen van de uitvoering van het volledige algoritme op de puntwolk met lage resolutie. 65

83 Figuur 9.5: Tijdsmeting op de gebruikte dataset. 9.3 Uitvoering op een grote puntwolk met een hoge dichtheid Naast de dataset die gebruikt werd in het grootste deel van deze thesis gaan we in deze sectie ook kort de uitvoering op een andere dataset bekijken. Deze dataset is opgenomen door een nieuwere Velodyne laserscanner en heeft een enorm hoge resolutie zoals ook kon gezien worden in figuur 2.3. Zoals ook vermeld werd in sectie zullen we voor deze puntwolk werken met stukken rooster van 10 op 10 meter. Er werd in die sectie ook vermeld dat een roosterstuk best maar 5 miljoen punten bevat om in het geheugen te passen. We hebben echter besloten om nog verder te gaan en maar maximaal punten per roosterstuk te gebruiken. Dit is nog altijd veel zoals te zien is in figuur 9.6. Het roosterstuk in die afbeelding bevat niet eens punten. De resolutie van het voxelrooster is verlaagd tot 1 meter. Deze aangepaste parameters zijn meer geschikt voor deze puntwolk met hoge resolutie. Figuur 9.6: Voorbeeld van een roosterstuk in de puntwolk met hoge resolutie. Zoals ook te zien is op figuur 9.6 werkt het algoritme voor segmentatie vrij goed op deze puntwolk met dezelfde instellingen. 66

84 Wat de gevelselectie betreft werkt het algoritme echter minder goed. Dit is te zien op figuur 9.7. In deze figuur worden er te veel gevels gedetecteerd, voornamelijk in gebouwen. Als we kijken naar zo een roosterstuk (zie figuur 9.8) zien we direct wat hier de oorzaak van is. Op de figuur kunnen we zien dat deze laserscanner meer kan dan de laserscanner met een lage resolutie. Deze laserscanner genereert ook een puntwolk voor de binnenzijde van een gebouw. Dit is iets wat het algoritme niet verwachtte. Hierdoor worden dus ook de muren aan de binnenzijde van een gebouw als gevels gedetecteerd. Figuur 9.7: Voorbeeld van een stuk kaart in de puntwolk met hoge resolutie: eerste versie. Om het algoritme goed te laten werken moeten de parameters voor gevelsegmentatie wat verhoogd worden. Een aanpassing die een groot stuk van de problemen oplost is de verhoging van de minimale hoogte van een muur naar 4 meter. Deze parameter zorgt ervoor dat muren in een gebouw niet als gevels gezien worden. Het resultaat van de uitvoering op deze puntwolk is weergegeven in figuur 9.9. We zien dat de meeste gevels op deze kaart correct gedetecteerd worden, de lichtblauwe lijnen volgen mooi de omlijning van de gebouwen. Op de figuur zien we echter ook veel rode en oranje stippen. Rode stippen duiden aan dat de een muur wel op de kaart staat maar zich niet in de puntwolk bevindt. De meeste rode stippen op de figuur zijn correct. Veel van deze stippen duiden namelijk een grens aan tussen twee gebouwen. Dit is inderdaad geen gevel en deze muur komt dus ook niet voor in de puntwolk. Het algoritme merkt dit correct op. Meestal is dit echter niet gewenst. Dit probleem is eenvoudig op te lossen door muren tussen twee gebouwen op voorhand te verwijderen van de kaart. Een aantal van deze oranje stippen hebben dezelfde oorzaak. Er komen ook een beperkt aantal groene stippen voor op de kaart. De meeste van deze stippen zijn ook foutief aangeduid en bevinden zich ook binnen een gebouw. Dit soort fouten blijft echter beperkt. Het algoritme werkt dus ook vrij goed op deze puntwolk. De plaatsing van stippen op de kaart kan nog verbeterd worden maar werkt al vrij goed. De voornaamste oorzaak van fouten voor deze puntwolk is dat het algoritme niet verwachtte dat binnenzijden van gebouwen ook gescand zouden worden. In een ander deel van de puntwolk is er een echte afwijking aanwezig op de kaart of in de 67

85 Figuur 9.8: In deze puntwolk met hoge resolutie worden ook aan de binnenzijde van een gebouw zeer veel punten gedetecteerd. puntwolk. Dit is weergegeven in figuur Deze afwijking valt duidelijk op door de lange rij oranje stippen. Waarschijnlijk is deze afwijking ontstaan doordat het GPS signaal tijdelijk verloren werd. In deze thesis zijn grote stukken van deze kaart getoond in één afbeelding. In praktijk zijn de resultaten echter gegenereerd in vectorformaat waardoor er zeer sterk kan ingezoomd worden op de kaart en de gevonden gevels. De uitvoeringstijd op deze grote puntwolk is weergegeven in figuur 9.11 en tabel 9.2. uitvoeringstijd van het algoritme wordt besproken in sectie 9.4. Deze 68

86 Figuur 9.9: Resultaat van het algoritme op een puntwolk met hoge resolutie. ID Operatie Inlezen roosterstuk Densiteit bijhouden Vlakken zoeken in roosterstuk Gevonden segmenten wegschrijven naar bestand Samenvoegen vlakken over roosterstukken heen Verzamelen vlakken in array Inlezen vlakken voor verdere verwerking Gevelclassificatie Vergelijken gevonden lijnen met kaart Totale tijd (millisec.) Aantal uitvoeringen Tabel 9.2: De tijdsmetingen van de uitvoering van het volledige algoritme op de puntwolk met hoge resolutie. 69

87 Figuur 9.10: Een tweede resultaat van het algoritme op een puntwolk met hoge resolutie. Figuur 9.11: Tijdsmeting op de Velodyne laserscanner dataset. 9.4 Bespreking uitvoeringstijd Real-time verwerking is zeker niet het onderwerp van deze thesis. Toch is het nuttig om eens naar de uitvoeringstijd te kijken. In figuur 9.5 en 9.11 zijn de tijden te zien die het algoritme nodig heeft om de verschillende stappen uit te voeren, respectievelijk voor de puntwolk met een lage en die met een hoge resolutie. We zien dat het globale beeld hetzelfde is in beide gevallen. Het grootste deel van de tijd wordt gebruikt om de verschillende roosterstukken te verwerken en de vlakken in elk roosterstuk te zoeken (3 in de figuren). Het aanpassen van het densiteitsrooster (2) toont aan dat zelfs e e n enkele keer de puntwolk overlopen al duidelijk zien op in de uitvoeringstijd. Het grootste deel van de tijd gaat dus waarschijnlijk naar lees- en schrijfbewerkingen. Het lezen van een puntwolk uit het bestand, het lezen van de puntwolk uit het geheugen, het wegschrijven van een segment naar een bestand,... Het is dan ook een zeer data-intensief programma. Manieren om het algoritme te versnellen worden dus best gericht op het versnellen van lees- en schrijfbewerkingen. Een nieuwe CPU zal niet zo veel helpen. Een andere manier om het algoritme te versnellen is het parallelliseren van het zoeken van vlakken in een roosterstuk. Elk roosterstuk wordt momenteel namelijk volledig onafhankelijk, maar wel sequentieel verwerkt. We gaan hier niet verder op in. 70