Automatic Extraction of Indoor Structural Information from Point Clouds

Abstract

We propose an innovative method with which to extract building interior structure information automatically, including ceiling, floor, and wall. Our approach outperforms previous methods in the following respects. First, we propose an approach based on principal component analysis (PCA) to find the ground plane, which is regarded as the new Cartesian plane. Second, to reduce the complexity of data processing, the data are projected into two dimensions and transformed into a binary image via the operation of an improved radius outlier removal (ROR) filter. Third, a traditional thinning algorithm is adopted to extract the image skeleton. Then, we propose a method for calculating slope through the nearest neighbor point. Moreover, the line is represented with the slopes to obtain information pertaining to the interior planes. Finally, the outline of the line is restored to a three-dimensional structure. The proposed method is evaluated in multiple scenarios, and the results show that the method is accurate (the maximum error of 0.03 m was in three scenarios) in indoor environments.

1. Introduction

In recent years, LiDAR (light detection and ranging) technology has developed rapidly due to its high accuracy, low cost, portability, and wide application range such as in autonomous driving [1,2,3,4,5], military fields [6,7,8,9], aerospace [10,11], and three-dimensional (3D) reconstruction [12,13,14]. In terms of 3D modeling, high-precision and high-density point cloud data are provided by LiDAR to accurately restore the surface model of an object that could be a trunk [15], a geological landform [16], or a building [17,18]. With the maturation of indoor navigation [19] technology, it is important to obtain precise building interior structures from the point cloud for accurate navigation. However, it is difficult and time consuming to extract indoor structures from the disorder and high density [20] of point clouds, and the complexity of data processing is greatly increased due to the noise caused by the algorithm and the scanning environment. Therefore, completing interior reconstruction is challenging under the influence of these negative factors.

To reconstruct the interior structure accurately, researchers have proposed advanced ideas [21,22] and frameworks. First of all, the raw data of the point cloud mainly come from a laser scanner. Valero et al. [23] used a laser scanner to attain neat point clouds and different algorithms to identify different objects. The point cloud from the laser scanner is precise and the point cloud that makes up the plane is projected vertically as a straight line, which results in great convenience in the subsequent processing. However, it is expensive and takes more time to measure. Therefore, we use LiDAR because the data from cheap and lightweight LiDAR are easily available and convenient. In some large-scale scenes, the data measured by LiDAR are integrated by a scan registration algorithm such as LeGO-LOAM (lightweight and ground-optimized LiDAR odometry and mapping) [24] or LIO-SAM (lidar inertial odometry via smoothing and mapping) [25], both of which cause point cloud noise.

After obtaining the initial data, indoor structure extraction from a point cloud can be divided into the following two aspects: one is to extract plane information directly from the point cloud, and the other is to extract the indoor plane contour by projecting or transforming it into an image. Ochmann et al. [26] transformed the problem into a linear programming problem of room contour under the prior knowledge that the room was segmented. On this basis, Ochmann et al. [27] also proposed the use of random sample consensus (RANSAC) [28] to automatically segment the room and then transform it into a linear programming problem. The RANSAC is robust and can be modified according to point cloud models of different shapes. Saval-Calvo et al. [29] optimized the RANSAC so that planar point clouds could be effectively extracted in the environment, and the performance was better than the original algorithm. Ambrus et al. [30] used the RANSAC to extract the floor and walls of each room, and then projected the walls onto the floor to extract the outlines of the room. Sanchez et al. [31] proposed a model based on model-fitting and RANSAC, which could effectively extract large-scale buildings and small-scale structures. In addition to this, Wang et al. [32] used the region-growing method to extract all plane frames and extracted the line structure of each plane to automatically generate complete building information models (BIMs). Mura et al. [33] proposed an efficient occlusion-aware process to extract the walls, which were projected onto a two-dimensional plane to extract profiles. Random algorithms often need to traverse every point, which leads to this method being time consuming but robust. Therefore, these algorithms with randomness and growth are effective but inefficient. Some researchers are also looking for other ways to reduce the cost of the algorithms. Oesau et al. [34] divided the initial data into chunks, extracted the outline with a Hough transform [35] in each block, and then integrated them. The time to process the data was greatly reduced by the chunking. Wu et al. [36] sliced the point cloud in different ways and then fitted the line using a RANSAC-based method. The amount of data can be greatly reduced but the loss of indoor data may be caused by the slicing operation. Wang et al. [37] reconstructed the buildings after classifying different objects, which reduced the processing of non-target point clouds. Xiong et al. [38] semantically segmented the interior environment and identified the plane with openings and the shape of openings. Due to the good visual effect and fast processing speed of images, three-dimensional information can also be restored through images [39,40]. Stojanovic et al. [41] used images to aid point cloud data for classifying indoor objects. Jung et al. [42] projected the data onto the ground and turned them into an image, and then detected the corners of the walls to determine their contours. After the data were projected and converted into an image, Jung et al. [43] extracted the two-dimensional skeleton of the wall with the image-thinning algorithm and restored it to a three-dimensional structure. Large point clouds are converted into image skeletons, which greatly reduces computational costs. Moreover, the point cloud changes from irregular points to regular pixels, which is very beneficial for the extraction of structural information. However, the reduction in the amount of data means that some details are lost if nothing is established to optimize the data.

In general, the direct processing of point clouds is time consuming but robust, while dimensionality reduction or image conversion is fast but will reduce accuracy. To inherit the advantages of the above methods and make up for their shortcomings, we present our ideas in this paragraph. In this work, we propose a hypothesis: the walls are perpendicular to the ground and the angles between the walls are only within 0°, 45°, 90°, and 135°. To reduce time consumption, our data are collected by LiDAR because our target scene is relatively large. In previous studies, it is usually taken as a prior condition that the ground is the x-y plane. Based on a large number of experiments, we find that the prior condition is sometimes untenable. Therefore, we propose a PCA-based framework to find the floor and ceiling plane equations. Then, we project the complete wall onto the ground in the previous step and convert it into images rather than slicing. To remove the sparse noise and improve the filtering speed, we optimize the radius filtering without changing the effect. Next, coordinates are enlarged and meshed to convert them into pixels. After conversion to an image, the width of the line is several pixels, which is not conducive for us to extract the structure, so we consider extracting the image skeleton using the thinning algorithm. Saeed et al. [44] proposed an image-thinning algorithm that can extract image skeletons effectively; however, this algorithm is not sensitive to corner points. Zhang and Suen [45] proposed a method that could quickly and accurately extract an image skeleton and reflect image corner information by setting several constraint conditions through the relationship between the target pixel and eight-neighborhood pixels. Therefore, the method [43] is more suitable for our data. Due to the error in scan registration, the intersection of two lines produces a radian instead of a right angle. Corner detection in our data is difficult with traditional corner detection operators such as the Harris operator [46] and the SUSAN operator [47]. Chen et al. [48] proposed to use the curvature of each point as a constraint to screen corner points, which could not find corner points very accurately. By observation, we find that the intersection of adjacent lines can be used as the exact value of corner points. As such, we propose a judgment method of a straight line based on slope and select corners from the intersection points of straight lines. Finally, we restore the three-dimensional model according to corner points and corresponding lines. The entire flowchart is shown in Figure 1.

The rest of this paper is organized as follows. Section 2.1 presents the principle of PCA and the framework that separates the walls based on PCA. In Section 2.2, we introduce how we can transform data into images, including point cloud projection, improved radius filtering, and data regularization. Section 2.3 presents the principle of the slope-based algorithm and some detailed processing and optimization. In Section 2.4, we organize the expression of straight lines and restore the three-dimensional structure of the interior environment. In Section 3.1, we introduce our equipment and the data extraction process. In Section 3.2, we use three different scenarios to verify our method and give the relevant evaluation parameters of three experimental results. Section 4 shows our discussion of the experimental results, including the advantages, disadvantages, and possible subsequent optimization of the experimental method. Finally, we summarize the whole paper and look ahead to future work in Section 5.

Algorithm 1 Principal Component Analysis (PCA)

Input:  $S_I\left(n\times 3 points\right)$

Output:  $S_O\left(n\times 2 points\right)$

1: $\mu =\left(\frac{1}{n}{\displaystyle \sum _{i=1}^n{x}_i},\frac{1}{n}{\displaystyle \sum _{i=1}^n{y}_i},\frac{1}{n}{\displaystyle \sum _{i=1}^n{z}_i}\right)$

2: for $p_i=\left(x_i,y_i,z_i\right)\in S_I$$,i=1,2,\dots ,n$ do

3:   $p_j=p_i-\mu$

4: end for

5: $p_j=\left(x_j,y_j,z_j\right)\in S_P,j=1,2,\dots ,n$

6: $\Gamma =\frac{1}{n}{S}_P{}^T{S}_P$

7: $U\Sigma V^T=SVD\left(\Gamma \right)$

8: $V=\left[v_1,v_2,v_3\right]$

9: $S_O=S_I\left[v_1,v_2\right]$

Algorithm 2 Wall extraction method

Input: $S_r\left(n\times 3 points\right)$

Output:  $S_c\left(n_1\times 3 points\right),S_g\left(n_2\times 3 points\right),S_w\left(n_3\times 3 points\right)$

1: $plane0\leftarrow S_r$ $\mathbf{do} PCA\left(fit\right)$

2: $S_1\leftarrow S_r on plane0$

3: $S_2\leftarrow S_r under plane0$

4: $P_1,P_2\leftarrow S_1,S_2$ $\mathbf{do} PCA\left(dimension reduction\right)$

5: $P_1,P_2$ $\mathbf{do} mesh\left(m\times n grid\right)$

6: for each grid do

7:   $reserve\leftarrow number of grid=1$

8:   $remove\leftarrow others$

9: end for

10: $P_1,P_2$ do SOR

11: $plane1,plane2\leftarrow P_1,P_2$ $\mathbf{do} PCA$

12: $S_c\leftarrow \left(distance from plane1\right)<threshold1 in S_r$

13: $S_g\leftarrow \left(distance from plane2\right)<threshold2 in S_r$

14: $S_w\leftarrow others$

Algorithm 3 Data format conversion method

Input:  $S_w\left(n_3\times 3 points\right)$

Output:  $S_p\left(n_4\times 3 points\right),S_{image}\left(m_0\times n_0 image\right)$

1: $S_{p_1}\leftarrow S_w\left(projected\right)$

2: $S_{p_1}$ $\mathbf{do} mesh$

3: for $each grid$ do

4:   $neighbors search by radius$

5: end for

6: $S_{p_2}\leftarrow remove noise by threshold3$

7: for $\left(x_i,y_i\right)\in S_{p_2}$ do

8:   $\left(x_i,y_i\right)=\left(\left(x_i,y_i\right)-\left(x_{min},y_{min}\right)\right)\times n_a$

9: end for

10: $S_{p_2}$ $\mathbf{do} mesh$

11: for $\left(x_i,y_i\right)\in S_{p_2}$ do

12:   $\left(x_j,y_j\right)=round\left(x_i,y_i\right)$

13: end for

14: $S_p\leftarrow \left(x_j,y_j\right),j=1,2,\dots ,n_{grid}$

15: $m_0=max\left(x_j\in S_p\right),n_0=max\left(y_j\in S_p\right)$

16: $S_{image}\leftarrow m_0\times n_0 image$

17: for $\left(x_j,y_j\right)\in S_p$ do

18:   $S_{image}\left(x_j,y_j\right)=0 or 1\left(against the background\right)$

19: end for

Algorithm 4 Line segment extraction method

Input: $S_{image}\left(m_0\times n_0\right)\left(background is 0 and others are 1\right)$

Output: $lines$

1: $S_{con}\leftarrow convolve the S_{image} with kernel1$

2: for $each pixel\left(x_p,y_p\right)\in S_{con}$ do

3:   $S_{image}\left(x_p,y_p\right)=0 \mathbf{if} S_{con}\left(x_p,y_p\right)<4$

4:   $S_{image}\left(x_p,y_p\right)=1 \mathbf{if} S_{con}\left(x_p,y_p\right)>4$

5: end for

6: $S_s\leftarrow S_{image} \mathbf{do} skeleton extracting$

7. for $random\left(x_i,y_i\right)\in S_s \mathbf{do}$

8:   $Calculate the nearest neighbor\left(x_{i1},y_{i1}\right)$

9:   $k\left(x_i,y_i\right)=\frac{y_{i1}-y_i}{x_{i1}-x_i}, k\left(x_{i1},y_{i1}\right)=k\left(x_i,y_i\right)$

10:   $k\left(x_{i1},y_{i1}\right) is the next \mathrm{seed}$

11: end for

12: if $two neighbors of k\left(x_i,y_i\right) is \mathrm{satis}fied with k_1=k_2$

13:   $k\left(x_i,y_i\right)=k_1$

14: end if

15: for $\left(x_j,y_j\right)\in S_s \mathbf{do}$

16:   if $\left(x_j,y_j\right) is \left(two neighbors \& k_1\ne k_2\right)or\left(one neighbor\right)or\left(no neighbor\right)$

17:      $\left(x_j,y_j\right) is the see{d}_0$

18:   end if

19:   for $see{d}_1\left(x_j,y_j\right)\in lin{e}_j \mathbf{do}$

20:      $\left(x_{j_0},y_{j_0}\right) is the neighbor of \left(x_j,y_j\right) \& k\left(x_{j_0},y_{j_0}\right) =k\left(x_j,y_j\right)$

21:      $lin{e}_j\leftarrow \left(x_{j_0},y_{j_0}\right)$

22:      $\left(x_{j_0},y_{j_0}\right) is the new see{d}_1$

23:   end for

24: end for

25: for $each lin{e}_{j1},lin{e}_{j2}\in lines \mathbf{do}$

26:   $endpoint p_{j1},p_{j2}\in lin{e}_{j1},lin{e}_{j2}$

27:   if $only one endpoint is \mathrm{satis}fied with distance\left(p_{j1},p_{j2}\right) \& k_{lin{e}_{j1}}=k_{lin{e}_{j2}}$

28:      $same line\leftarrow lin{e}_{j1},lin{e}_{j2}$

29:   end if

30: end for

31: for $each lin{e}_j \mathbf{do}$

32:   $endpoint\left(x_1,y_1\right),\left(x_2,y_2\right),midpoint x_0={\displaystyle \sum _{i=1}^n{x}_i},y_0={\displaystyle \sum _{i=1}^n{y}_i},slope k_j$

33:   $new endpoint\left(x_1^{\prime },y_1^{\prime }\right)=\left(\frac{y_1+k_j{x}_0-y_0+x_1{k}_j}{2k_j},\frac{x_1{k}_j-k_j{x}_0+2y_0}{2}\right)$

34:   $new endpoint\left(x_2^{\prime },y_2^{\prime }\right)=\left(\frac{y_2+k_j{x}_0-y_0+x_2{k}_j}{2k_j},\frac{x_2{k}_j-k_j{x}_0+2y_0}{2}\right)$

35: end for

36: $lines\leftarrow each endpoint\left(x_{i_1}^{\prime },y_{i_1}^{\prime }\right),\left(x_{i_2}^{\prime },y_{i_2}^{\prime }\right)$

2. Methods

In this section, we detail the principle of our approach in four steps: (1) A wall extraction method based on PCA; the data are divided into three sections: floor, ceiling, and other data. (2) Conversion from 3D to 2D data, including projection, filtering, and voxelization. (3) Extraction of line segments based on the image; the image is skeletonized and we propose a line segment-extraction algorithm based on the slope of adjacent points. (4) Reconstruction of the indoor structure; we reconstruct the interior structure using linear information.

2.1. Extraction of Wall Based on PCA

PCA can be used to extract the principal components of data, reduce the dimensionality of data, or fit planes or lines. In this section, we use the theory of PCA to find the floor and ceiling of the data and solve the problem that the floor may not be the x-y plane in the x-y-z frame.

The principle of PCA is shown in Algorithm 1. The input $S_I\in {ℝ}^{n\times 3}$ is the three-dimensional point cloud. Then, the average $\mu$ of the point clouds is calculated. For the point $p_i\in S_I$, the deviation $p_j$ of $p_i$ and $\mu$ is calculated, and the deviation matrix $S_P\in {ℝ}^{n\times 3}$ consists of $p_j$. Next, the covariance matrix $\Gamma$ is calculated by $S_P$ and we obtain the transformation matrix $V=\left[v_1,v_2,v_3\right]\in {ℝ}^{3\times 3}$ by singular value decomposition (SVD). $v_1$ and $v_2$ are taken as vectors of the fitting plane, and $v_3$ is taken as a normal vector to that plane. Finally, we project the raw 3D data to obtain the 2D data by matrix operation $S_O=S_I\left[v_1,v_2\right]$.

Our first step is the process of finding the plane based on PCA. The main flow of this method is shown in Figure 2 and Algorithm 2. $S_r\in {ℝ}^{n\times 3}$ is used as the raw data for Algorithm 2.

$S_r\in {ℝ}^{n\times 3}$ is used as the raw data in Algorithm 2. To better represent the effect of the algorithm, we use test data to verify our algorithm, as shown in Figure 3a. The sum $s$ of the distances of all points $\left(x_i,y_i,z_i\right)$ from the plane $\mathrm{A}x+By+Cz+D=0$ is minimum by fitting regular data as follows:

$$s=min\left\{{\displaystyle \sum _{i=1}^n\frac{\left|A{x}_i+B{y}_i+C{z}_i+D\right|}{\sqrt{A^2+B^2+C^2}}}\right\}$$

(1)

Therefore, the plane fitted by the symmetric point cloud is in the middle of the data, as shown in Figure 3b. Due to indoor noise and other objects, the position of the plane is changed, but the data are also divided into upper and lower parts. The upper part $S_1$ contains the ceiling and the lower part $S_2$ contains the floor, as shown in Figure 3c,d.

Then, $S_1$ and $S_2$ are projected on planes and converted into two-dimensional $P_1\in {ℝ}^{n_1\times 2}$ and $P_2\in {ℝ}^{n_2\times 2}$. $P_1$ and $P_2$ are processed by the grid threshold method and we introduce the method using $P_1$ as an example. The method is shown in Figure 4.

We set the number $n_{grid}$ of grids, and then calculate the horizontal resolution $\mathsf{\Delta }x$ and vertical resolution $\mathsf{\Delta }y$ of the grid according to the maximum values $x_{max}$ and $y_{max}$ of $P_1$ in two directions as follows:

$$\mathsf{\Delta }\mathrm{x}=\frac{x_{max}}{n_{grid}},\mathsf{\Delta }y=\frac{y_{max}}{n_{grid}}$$

(2)

Points $\left(x_i,y_i\right)$ in the same grid $\left(i_{grid},j_{grid}\right)$ are assigned the same number:

$$i_{grid}=round\left(\frac{x_i-x_{min}}{\mathsf{\Delta }x}\right),j_{grid}=round\left(\frac{y_i-y_{min}}{\mathsf{\Delta }y}\right)$$

(3)

Some edge problems are caused by rounding the number of points. Therefore, we take some measures as follows:

$$i_{grid},j_{grid}=\{\begin{array}{l}1, i_{grid},j_{grid}=0\\ n_{grid},i_{grid},j_{grid}>n_{grid}\end{array}$$

(4)

For the number $\left(i_{grid},j_{grid}\right)$ of each point, we replace 0 with 1 and replace the points that are larger than $n_{grid}$ with $n_{grid}$. The data whose number corresponds to one point are taken as the plane points. However, due to the interference of noise, we use the SOR filter to obtain the exact plane points. These points are fitted into a plane by PCA, and $P_1$ and $P_2$ correspond to the plane:

$$\begin{array}{l}plane1:A_{1}x+B_{1}y+C_{1}z+D_1=0\\ plane2:A_{2}x+B_{2}y+C_{2}z+D_2=0\end{array}$$

(5)

Since the ceiling and floor are parallel, we take the average of the normal vectors of the two planes as our new normal vector:

$$\begin{array}{l}plane1:\frac{A_1+A_2}{2}x+\frac{B_1+B_2}{2}y+\frac{C_1+C_2}{2}z+D_1=0\\ plane2:\frac{A_1+A_2}{2}x+\frac{B_1+B_2}{2}y+\frac{C_1+C_2}{2}z+D_2=0\end{array}$$

(6)

Finally, we set $threshold1$ and $threshold2$ of the distance from the point to the planes to determine the ceiling $S_c$ and the floor $S_g$, and the wall $S_w$ is the data $S_r$ except for $S_c$ and $S_g$. The entire process is shown in

Table 1. The process of extracting the wall: Project the initial data onto a plane, and then the ground data are screened by the grid threshold method. The ground is restored to a three-dimensional form and treated with the SOR filter. The ground and ceiling are fitted into a plane; then, the wall data are extracted by setting thresholds.

	Ceiling	Ground
raw data
2D project
grid threshold method
3D recovery
SOR
fit plane
extract the wall

.

2.2. Data Format Conversion

The point cloud data are so dense and disordered that it is difficult to extract information from them. However, point cloud slicing leads to the loss of the contour, which increases the difficulty of subsequent processing. Therefore, to improve the efficiency of the algorithm, we projected the wall onto the ground and meshed it. The entire process is shown in Figure 5 and Algorithm 3.

$S_w\in {ℝ}^{n_3\times 3}$ is used as the raw data in Algorithm 3, and $S_w$ is projected into $S_{p_1}$ on the ground plane. Due to the influence of noise, the points of a line have a certain width, and we extract the line features from these points. First, we need to remove the noise of the two-dimensional points, as shown in Figure 6.

The radius outlier removal (ROR) [49] filter is an effective tool for noise removal. If the ROR filter is not optimized in any way, this method is very inefficient. Therefore, we use the GROR (grid radius outlier removal) filter to optimize the ROR filter. We mesh the data and then search for the nearest neighbor points in a specific way. The results show that the efficiency of this method is greatly improved without affecting the accuracy of the ROR filter. At the same time, due to the high density of the vertical wall point and the low density of other sundries points after projection, some sundries points are removed by the GROR filter. The principle of this method is shown in Figure 7.

First, the raw data $S_{p_1}$ are divided into grids, and the resolutions in the two directions are, respectively, $x_{grid}$ and $y_{grid}$. The points in each grid are searched for their nearest neighbors. If only the points in the grid are used as the search scope, some of the nearest neighbors will be lost at the edge of the grid. Therefore, we have expanded the area to ensure the accuracy of the search. For the grid $\left(i_{grid},j_{grid}\right)$, we use the number $n_c$ of adjacent grids to expand the region. $n_c$ is determined by the search radius $r_0$ and resolutions:

$$n_c=ceil\left(\frac{r_0}{min\left(x_{grid},y_{grid}\right)}\right)$$

(7)

The radius $r_0$ divided by the minimum resolution and ceiled is called $n_c$. Therefore, the search area ${\Omega }_i$ for the grid $\left(i_{grid},j_{grid}\right)$ is as follows:

$$\mathsf{\Omega }=\left[\begin{array}{ccc}\left(i_{grid}-n_c,j_{grid}-n_c\right)& \dots & \left(i_{grid}-n_c,j_{grid}+n_c\right)\\ \dots & \left(i_{grid},j_{grid}\right)& \dots \\ \left(i_{grid}+n_c,j_{grid}-n_c\right)& \dots & \left(i_{grid}+n_c,j_{grid}+n_c\right)\end{array}\right]$$

(8)

Since the mesh size $n_{grid}\times n_{grid}$ is fixed, edge suppression is added as follows:

$$\{\begin{array}{l}{i}_{grid}-n_c=1 if \left(i_{grid}-n_c\right)<1\\ i_{grid}+n_c=n_{grid} if \left(i_{grid}+n_c\right)>n_{grid}\\ j_{grid}-n_c=1 if\left(j_{grid}-n_c\right)<1\\ j_{grid}+n_c=n_{grid} if \left(j_{grid}+n_c\right)>n_{grid}\end{array}$$

(9)

Finally, the points whose number of neighbors is less than $threshold3$ are removed. After removing the noise, we need to expand the coordinates of the points $S_{p_2}$. We chose a large multiple $n_a$ to make the details of the data more obvious as follows:

$$\left(x_i,y_i\right)=\left(\left(x_i,y_i\right)-\left(x_{min},y_{min}\right)\right)\times n_a$$

(10)

For each point $\left(x_i,y_i\right)\in S_{p_2}$, we subtract the minimum value $\left(x_{min},y_{min}\right)$ of the point to make sure the points are positive and use the multiple $n_a$ to expand the coordinate of these points. Since the coordinates need to be rounded after expanding, and then restored after processing, the details can be better reflected and the error can be reduced by a larger multiple. Assume a point is $x_s=a_0.a_1{a}_2{a}_3$, and when it expands 100 times it becomes $x_s=a_0{a}_1{a}_2.a_3$. We round it to $x_s=a_0{a}_1{a}_2$ and then restore it to $x_s=a_0.a_1{a}_2$. The error before and after treatment was less than 0.01.

Then, we use the grid subsampling method to round the coordinates and eliminate the repeated coordinates of the same position. The benefit of this method is that the data become regular and the amount of data is greatly reduced. The principle of the method is shown in Figure 8.

For the raw data $\left(x_i,y_i\right)\in S_{p_2}$ and integer points $\left(x_i^{int},y_j^{int}\right)\in S_{int eger}$, $\left(x_i,y_i\right)$ is replaced by the point $\left(x_i^{int},y_j^{int}\right)$ nearest to $\left(x_i,y_i\right)$. Then, the overlapping points are removed. Finally, we obtain the data $S_p\in {ℝ}^{n_4\times 3}$ after the subsampling. For each point $\left(x_i,y_i\right)\in S_p$, we need to replace 0 with 1 as follows:

$$\{\begin{array}{l}{x}_i=1 if x_i=0\\ y_i=1 if y_i=0\end{array}, i=1,2,\dots ,n_4$$

(11)

Since the coordinates of the data $S_p$ are all positive integers, the data can be converted into images to prepare for the next step. This process is shown in Figure 9. The size $m_0\times n_0$ of the image $S_{image}$ is determined by the maximum value of the coordinates in the two directions of the point $\left(x_i,y_i\right)\in S_p$ as follows:

$$\begin{array}{l}{m}_0=max\left(x_j\in S_p\right)\\ n_0=max\left(y_j\in S_p\right)\end{array}$$

(12)

Additionally, the pixel of the position corresponding to $S_p$ in the image $S_{image}$ is replaced by $\alpha$:

$$S_{image}\left(x_j,y_j\right)=\alpha$$

(13)

where the parameter $\alpha$ is against the background; for example, the parameter $\alpha$ is 0 and the background is 1 in the image.

Therefore, we obtain two sets of data: the two-dimensional points with a grid structure and the corresponding images of the two-dimensional points. The shape of the raw data is retained and the scattered points are regularized by the two data. The experimental procedure in this section is shown in

Table 2. Projection and transformation of data. First, the raw data are projected onto the ground plane. Then, the noise is removed by the GROR filter. We enlarge the coordinates 70 times and the grid subsampling method is used to make the data regular. The regular data can be converted to an image, which is prepared for the next section.

	Result	Details
the raw data are projected to the ground
GROR filter
grid subsampling method (the coordinates are magnified 70 times)
convert to the image

.

2.3. Extraction of Line Segments

For the image in the previous section, we need to extract line segment information from it. Since straight lines are composed of points with a certain thickness in the data, it is difficult to extract multiple lines directly from the data. Therefore, we first use the thinning algorithm to extract the skeleton of the image. Then, the corresponding slope of each point is calculated based on the nearest neighbor point. Finally, we propose a slope-based search method to extract the line segments. We give the flow of the algorithm as shown in Figure 10 and Algorithm 4.

The image $S_{image}$ is the input in Algorithm 4. We assume that the background is 0 and the points are 1 in the image, and we convolve the image $S_{image}$ with a kernel to remove the burr, which is influential in extracting the skeleton. Then, the image $S_{image}$ is updated by the convolution value $S_{con}$:

$$\{\begin{array}{l}{S}_{image}\left(x_p,y_p\right)=0 if S_{con}\left(x_p,y_p\right)<4\\ S_{image}\left(x_p,y_p\right)=1 if S_{con}\left(x_p,y_p\right)>4\end{array},\left(x_p,y_p\right)\in S_{image}$$

(14)

The pixel value is updated by comparing the convolution value $S_{con}$ with the number 4, as shown in Figure 11.

To better reflect the contour features of the wall, we consider refining the image. If the pixel representing the line is refined into a single pixel, the feature of the line is more obvious in the skeleton. Therefore, we use a suitable thinning algorithm to extract the two-dimensional skeleton information of the wall through experiments. The results are shown in

Table 3. Image skeleton extraction. The contour of the image is extracted by the skeleton extraction algorithm and lines are refined into single pixels. Similarly, the skeleton made up of two-dimensional points is reduced by the image skeleton.

	Data	Details
raw image
image skeleton
points skeleton

.

The image skeleton $S_s$ is a single-pixel structure; we find that the characteristics of the lines are obvious, and the corners of the data affected by the error have a certain radian. Therefore, it is very difficult to extract the exact corners from the data; thus, we consider extracting the lines and determining the corners from the lines. We propose a line extraction method based on the nearest neighbor slope, and then introduce this method in detail.

First, the random point $\left(x_i,y_i\right)\in S_s$ is the starting point; its nearest neighbor $\left(x_{i1},y_{i1}\right)$ is found and the slope of the two points is calculated. In this section, the neighbor points are all found in the 8 neighborhoods. If there are multiple nearest neighbor points, select one as the nearest neighbor point at random. Then, their slope $k$ is calculated as follows:

$$k=\frac{y_{i1}-y_i}{x_{i1}-x_i}$$

(15)

The slope of these two points is represented by the slope $k$. Since the pixel positions in the image are all integers, there are only four cases for the slope of two adjacent points: 0, 1, −1, and the slope that does not exist is replaced by 2, as shown in Figure 12.

Then, the point $\left(x_{i1},y_{i1}\right)$ is the next seed and its nearest neighbor $\left(x_{i2},y_{i2}\right)$ is found to calculate the next slope, and the points whose slopes have already been calculated are not considered next neighbor search objects. The starting point $\left(x_i,y_i\right)\in S_s$ is randomly selected until the seed point $\left(x_{in},y_{in}\right)$ has no neighbors. If the slopes of all points are calculated, the algorithm stops. The process of calculating the slopes is shown in Figure 13.

After calculating the slope at all points, we need to eliminate the fault in the line, as shown in Figure 14. For each point, if it only has two neighbors and the two neighbors have the same slope $k$, update the slope of that point to $k$.

When the slope of all the points is calculated, we look for lines based on the slope. The idea is to start at one endpoint of each line as a seed point and grow until the line is completely extracted. Therefore, we first need to look for endpoints as seed points. We use the following three conditions to determine the seed point $\left(x_j,y_j\right)$: (1) the number of neighbors is two and the slopes of the neighbors are satisfied with $k_1\ne k_2$; (2) the number of neighbors is one; (3) no neighbors. The point $\left(x_j,y_j\right)$ that satisfies any of these conditions is considered a seed. Next, we extract points on the same line from the seed, as shown in Figure 15. For a straight line, look for a point $\left(x_{j_0},y_{j_0}\right)$ within the 8 neighborhoods of the seed $\left(x_j,y_j\right)$ that has the same slope as the seed. In these data, the number of the point $\left(x_{j_0},y_{j_0}\right)$ is only 1 or 0. If the number is 1, the point $\left(x_{j_0},y_{j_0}\right)$ is the next new seed, and the raw point $\left(x_j,y_j\right)$ is removed. If the number is 0, the points we calculated before form a line. Keep picking seed points until all the points are divided into lines.

When all the lines are categorized, we need to set thresholds to eliminate non-line points. Due to our conditions applied to individual points and short line segments, lines containing fewer points are removed. Since the same line is divided into sections by noise, we propose a method to solve this problem. As shown in Figure 16, for two endpoints $\left(p_{j1},p_{j2}\right)$ of each line, two lines are the same line only if the distance of two endpoints is less than the threshold and the two lines have the same slope. For the line $l_i$, we compare the line $l_1$ to the lines $l_2,l_3,\dots ,l_n$, then compare the line $l_2$ to the lines $l_3,l_4,\dots ,l_n$, until, finally, we compare the line $l_{n-1}$ to the line $l_n$. When all lines have been identified, repeat the steps until the number of lines is changeless.

For these lines, due to the points that make them up not being in a line, we need to figure out their slopes and endpoints to update the lines. The principle of updating the endpoints is shown in Figure 17. We know the parameter of the line $l_i$: two endpoints $\left(x_{i1},y_{i1}\right),\left(x_{i2},y_{i2}\right)$, midpoint $\left(x_{i0}={\displaystyle \sum _{j=1}^n{x}_{ij}},y_{i0}={\displaystyle \sum _{j=1}^n{y}_{ij}}\right)$, and slope $k_i$. If the slope is 1 or −1, we can obtain new endpoints based on these parameters as follows:

$$\{\begin{array}{l}\left(x_{i1}^{\prime },y_{i1}^{\prime }\right)=\left(\frac{y_{i1}+k_i{x}_{i0}-y_{i0}+x_{i1}{k}_i}{2k_i},\frac{x_{i1}{k}_i-k_i{x}_{i0}+2y_{i0}}{2}\right)\\ \left(x_{i2}^{\prime },y_{i2}^{\prime }\right)=\left(\frac{y_{i2}+k_i{x}_{i0}-y_{i0}+x_{i2}{k}_i}{2k_i},\frac{x_{i2}{k}_i-k_i{x}_{i0}+2y_{i0}}{2}\right)\end{array}$$

(16)

If the slope is 0, we obtain new endpoints as follows:

$$\{\begin{array}{l}\left(x_{i1}^{\prime },y_{i1}^{\prime }\right)=\left(x_{i1},y_{i0}\right)\\ \left(x_{i2}^{\prime },y_{i2}^{\prime }\right)=\left(x_{i2},y_{i0}\right)\end{array}$$

(17)

If the slope is 2, we obtain new endpoints as follows:

$$\{\begin{array}{l}\left(x_{i1}^{\prime },y_{i1}^{\prime }\right)=\left(x_{i0},y_{i1}\right)\\ \left(x_{i2}^{\prime },y_{i2}^{\prime }\right)=\left(x_{i0},y_{i2}\right)\end{array}$$

(18)

Therefore, the line is determined by the midpoint and the slope, and the range of the line is determined by the new endpoints. Finally, we show the process of finding the straight lines and drawing them all, as shown in

Table 4. The process of finding lines. In these images, each line segment is represented by a separate color except black. First, we find points that belong to the same line by using neighboring points. In detail, we can see that points that originally belong to the same line are divided into multiple lines due to noise and algorithm. Then, by optimizing the line based on endpoint and slope, we solve the problem. Finally, we draw the lines by slope, midpoint, and new endpoints.

	Result	Details
find the line according to the nearest neighbor
update lines based on endpoint and slope
update the endpoints and draw the line segments

.

2.4. Structure Reconstruction

In this part, we optimize the lines and reduce them to three-dimensional planes. In the last section, due to the error of scan registration, we removed the smooth intersection of the adjacent segments. Therefore, we propose a method to connect the lines. The basic steps of this method are as follows:

• Assuming that the known condition is the endpoint $p_1$, the nearest endpoint $p_2$ of the other lines is calculated. Additionally, we then calculate the distance $d$ between the two endpoints.
• The distance threshold is set to avoid two lines that are far apart from each other being connected. Then, we compare the distance $d$ to the threshold.
• If the distance is less than the threshold and the two lines are perpendicular, the lines corresponding to the two endpoints are connected and the endpoints $p_1$ and $p_2$ are replaced by the intersection. For the slopes $k_1$ and $k_2$ of the two lines, we think these two lines are perpendicular if they satisfy the condition:

  $$\left|k_1-k_2\right|=2 or \Vert k_1|-|k_2\Vert =1$$

  (19)

The results are shown in Figure 18. To better demonstrate the accuracy of the experimental results, we spliced and compared the lines with the raw data, as shown in Figure 19.

Finally, we reconstruct the three-dimensional plane from the resulting lines. Now, we need to figure out the height of each line. In the previous section, we calculated the ground plane and calculated the height of each point above the ground. Before we achieve this, the endpoints are restored by Equation (10). We calculate the nearest neighbors of the midpoints of each line segment and choose the height of the line as the maximum distance between these neighbors and the ground. If the height is close to the distance between the ceiling and the floor, the height changes to that distance. The result is shown in Figure 20. At this point, we have introduced the principle of the whole algorithm in detail. In the next section, we will evaluate the performance of the algorithm with multiple sets of data.

3. Experimental Results

3.1. Preparation of Experimental Data

The equipment used to collect data is shown in Figure 21. The experimental equipment was a backpack system integrating LiDAR, an inertial measurement unit (IMU), a wireless module, and an upper computer. The surroundings are sensed by a 16-line mechanical LiDAR at a frequency of 0.5 s and surface information about surrounding objects is scanned by the LiDAR. The IMU is used to measure the attitude information of LiDAR and we fuse it with each frame point cloud by the robotic operating system (ROS) in the upper computer. The processed data are transmitted to a computer for display through the wireless module.

We adopted LeGO-LOAM to implement the scan registration of data. In the algorithm, the attitude $\left[t_z,{\theta }_{roll},{\theta }_{pitch}\right]$ is obtained from the ground features, and the attitude $\left[t_x,t_y,{\theta }_{yaw}\right]$ is calculated according to the remaining point cloud features. Therefore, the matching error is caused by too few ground features, and another error is caused by the Euler angles turning too fast in a short time. In the following experimental results, these two aspects may be the causes of the error. Finally, we present some important parameters for the next three scenarios: the number $n_{fac}$ of grids for the floor and ceiling is extracted in Section 2.1. Radius $r_{GROR}$ and threshold $n_{GROR}$ of the GROR filter, magnification $n_{moc}$ of the coordinates, the distance $d_p$ that connects parallel lines, and the distance $d_v$ between the vertical lines are shown in

Table 5. Some important parameter settings for the scenarios.

	${\mathit{n}}_{\mathit{f}\mathit{a}\mathit{c}}$	${\mathit{r}}_{\mathit{G}\mathit{R}\mathit{O}\mathit{R}}$	${\mathit{n}}_{\mathit{G}\mathit{R}\mathit{O}\mathit{R}}$	${\mathit{n}}_{\mathit{m}\mathit{o}\mathit{c}}$	${\mathit{d}}_{\mathit{p}}$	${\mathit{d}}_{\mathit{v}}$
Scene 1	200	0.01	10	100	10	40
Scene 2	600	0.03	10	10	5	8
Scene 3	300	0.03	10	10	15	5

.

3.2. Results

In this section, we use three real scenarios to test our algorithm. We carried the equipment on our backs and the LiDAR was about 1.8 m away from the ground. We followed a fixed trajectory and tried to keep the posture of the device stable as we moved. Finally, three data points are prepared: a room, a floor, and some rooms.

3.2.1. Experiment Scene 1

We extracted the structure of a single room in the first data point; the room was about 7.69 m $\times$ 6.35 m $\times$ 3 m (length $\times$ width $\times$ height). The experimental scene is shown in Figure 22a, and the two-dimensional plan of the scene is shown in Figure 22b. To better show the interior structure, we removed the ceiling in the second section. The measured point cloud data are shown in Figure 22c, and the final result is shown in Figure 22d.

It can be seen from the experimental results that the basic structure of the room has been restored, but we can see that there are some flaws in the results. There are gaps between some adjacent planes. In the previous sections, we joined planes if they were adjacent and the distance between them was less than the threshold. In real scene 1, due to the glass between the curtains not being sensed by the LiDAR, we kept the gaps in the result. At the same time, the large gaps due to measurement errors were preserved.

3.2.2. Experiment Scene 2

We chose the floor of the school building as the second scenario to test the method. The point cloud we collected is shown in Figure 23a and the result of algorithm processing is shown in Figure 23b. Similarly, we present the two-dimensional plan of the floor in Figure 23c, and we provide real photos of the two positions on the floor and the corresponding reconstruction results, as shown in Figure 23d–g.

Comparing the results with the real scene, we can see that all the walls are well restored. At the time of measurement, we did not enter any rooms. Some of the doors were open and others were closed, which is why some of the doors were empty in our results. At the same time, due to the attention to detail in our method, uneven sampling and the error of the matching algorithm may result in faults in the same plane.

3.2.3. Experiment Scene 3

In scene 3, we chose an interior environment with multiple rooms. The raw data are shown in Figure 24a, and the result is shown in Figure 24b. We drew the two-dimensional plan of the data as shown in Figure 24c and a comparison of the result with the real world as shown in Figure 24d,e.

We entered most of the rooms during the measurement and all the doors were closed. Due to the complexity of the scene corresponding to the data, there was a major difference between the two frames when the device entered the room, which led to a major error in scan registration. Therefore, the error of our results is larger than that of the first two data points. However, all the rooms were restored well, so the result was satisfactory.

3.2.4. Relevant Parameters of the Experiment

We aim to obtain indoor structural information in a fast and efficient way, so we list running time, data volume, and distance parameters. In our approach, we employed a series of ways to reduce the amount of data. Therefore, on the premise of ensuring the authenticity and validity of parameters, and to demonstrate the efficiency of our method, we calculated the time of the following parts in

Table 6. The running time of several algorithms.

	${\mathit{t}}_{\mathit{c}-\mathit{g}}$	${\mathit{t}}_{\mathit{f}-\mathit{v}}$	${\mathit{t}}_{\mathit{i}-\mathit{r}}$
Scene 1	4.064 s	45.432 s	1.995 s
Scene 2	7.735 s	57.559 s	2.037 s
Scene 3	5.644 s	78.373 s	2.034 s

: the time $t_{c-g}$ of fitting the ceiling and ground, the time $t_{f-v}$ of projection, filtering, and voxelization, and the time $t_{i-r}$ from image to three-dimensional reconstruction. To reflect the changes in the amount of data in the process, we counted the number $n_{raw}$ of initial points, the number $n_{wall}$ of wall points, the number $n_{voxel}$ of two-dimensional points after projection and voxelization, and the size $i_{image}\times j_{image}$ of the image, as shown in

Table 7. The data volume statistics of several steps algorithm.

	${\mathit{n}}_{\mathit{r}\mathit{a}\mathit{w}}$	${\mathit{n}}_{\mathit{w}\mathit{a}\mathit{l}\mathit{l}}$	${\mathit{n}}_{\mathit{v}\mathit{o}\mathit{x}\mathit{e}\mathit{l}}$	${\mathit{i}}_{\mathit{i}\mathit{m}\mathit{a}\mathit{g}\mathit{e}}\times {\mathit{j}}_{\mathit{i}\mathit{m}\mathit{a}\mathit{g}\mathit{e}}$
Scene 1	720,224 × 3	537,721 × 3	26,349 × 2	701 × 776
Scene 2	1,804,574 × 3	768,450 × 3	7858 × 2	406 × 571
Scene 3	1,568,974 × 3	756,038 × 3	2143 × 2	187 × 52

. To verify the accuracy of the algorithm, we compare it with the actual data using the following aspects in

Table 8. Fitting the parameters of the ceiling and floor equations.

	${\mathit{A}}_{\mathit{c}}$	${\mathit{B}}_{\mathit{c}}$	${\mathit{C}}_{\mathit{c}}$	${\mathit{D}}_{\mathit{c}}$	${\mathit{A}}_{\mathit{g}}$	${\mathit{B}}_{\mathit{g}}$	${\mathit{C}}_{\mathit{g}}$	${\mathit{D}}_{\mathit{g}}$
Scene 1	−0.015	0.1674	0.9858	−1.3243	−0.0181	0.1523	0.9882	1.6697
Scene 2	0.2833	−0.0893	0.9549	−0.7801	0.2807	−0.0877	0.9558	1.7295
Scene 3	−0.0039	0.0277	0.9996	−1.1052	−0.0125	0.0325	0.9994	1.4702

and

Table 9. Parameter comparison between the actual scenario and the predicted scenario.

	${\mathit{n}}_{\mathit{p}\mathit{l}\mathit{a}\mathit{n}\mathit{e}}$	${\mathit{l}}_{\mathit{s}}$	${\mathit{w}}_{\mathit{s}}$	${\mathit{h}}_{\mathit{s}}$	${\mathit{l}}_{\mathit{r}}$	${\mathit{w}}_{\mathit{r}}$	${\mathit{h}}_{\mathit{r}}$	${\mathit{\sigma }}_{\mathit{l}}$	${\mathit{\sigma }}_{\mathit{w}}$	${\mathit{\sigma }}_{\mathit{h}}$	$\mathit{\xi }$
Scene 1	53	7.652 m	6.337 m	2.994 m	7.690 m	6.350 m	3.000 m	0.038 m	0.013 m	0.006 m	0.019 m
Scene 2	86	56.360 m	39.390 m	2.510 m	56.400 m	39.435 m	2.500 m	0.040 m	0.045 m	0.010 m	0.030 m
Scene 3	46	61.444 m	15.815 m	2.575 m	61.400 m	15.800 m	2.560 m	0.044 m	0.015 m	0.015 m	0.025 m

: ceiling equation $A_{c}x+B_{c}y+C_{c}z+D_c=0$ and ground equation $A_{g}x+B_{g}y+C_{g}z+D_g=0$ after first calculation, the number $n_{plane}$ of planes, the length $l_s$, width $w_s$, height $h_s$ of the building simulation data, the length $l_r$, width $w_r$, height $h_r$ of the building real data, the error between the actual value and the predicted value of the three aspects ${\sigma }_l$, ${\sigma }_w$, ${\sigma }_h$, and the mean precision $\xi$. In

Table 10. Comparison of the characteristics of several different methods. Aspect 1: sources of data; Aspect 2: ground calculation; Aspect 3: filtering; Aspect 4: data optimization; Aspect 5: the manifestation of doors and windows; Aspect 6: accuracy of the number of planes.

	Aspect 1	Aspect 2	Aspect 3	Aspect 4	Aspect 5	Aspect 6
Ochmann et al.	laser scanner	✗	✓	✗	✗	✓
Ambrus et al.	laser scanner	✗	✗	✓	✓	✓
Jung et al.	laser scanner	✗	✓	✓	✓	✓
Wang et al.	laser scanner	✗	✓	✓	✓	✓
Xiong et al.	laser scanner	✗	✓	✗	✓	✓
Sanchez et al.	laser scanner	✗	✓	✗	✓	✗
Oesau et al.	laser scanner	✗	✗	✓	✓	✓
Mura et al.	laser scanner	✗	✓	✗	✓	✓
ours	LiDAR	✓	✓	✓	✓	✓

, we list the characteristics of different reconstruction methods in recent years. The function and purpose of each method are not completely the same. To reflect the innovation of our method and solve the problem, we evaluate it while considering the following aspects: (1) sources of data; the effect of the algorithm can be affected by different data; (2) ground calculation; the ground is found as the base by our method without any conditions such as LiDAR attitude; (3) filtering; if no filtering is used, the algorithm has strong robustness; (4) data optimization; data optimization shows that the algorithm has high processing performance; (5) the manifestation of doors and windows; the details show the precision of the algorithm; (6) accuracy of the number of planes; if all planes are found, the accuracy of the algorithm is high.

4. Discussion

First, we evaluated the experimental results of the three scenarios. In scenario 1, all vertical planes of the room are created and the basic structure is restored. Because of the curtain, the curved part is removed by our algorithm, which leads to gaps in the plane formed by the curtain. In our algorithm, we expand the coordinates of the data, and the uneven sampling areas and the walls with windows contain fewer points. These areas are removed by our method. Therefore, our method can better restore the details of the room by enlarging the coordinates, while the room is restored to a rectangle if normal processing is used. In scenario 2, due to the large area of the scene, we stretched the result vertically for better detail. We can see that all the open doors are identified as gaps between the planes, and by comparing the coordinates in the result, we can ensure that the plane precision is high; for example, the width of the door is about 1 m. The whole floor is well restored, although there are still a few errors in the plan. This is where our method will need to be optimized at a later stage. In scenario 3, we went into some rooms selectively, and the results show that the reconstruction is better. All the rooms are perfectly reproduced, though there are some errors due to scan registration.

Second, we analyze and discuss the parameters in five tables. In Table 6, although we optimized the filtering, we can see that most of the time is still spent on filtering and voxelization. However, in terms of the time and effect of restoring the image to a three-dimensional plane, the time $t_{i-r}$ of about 2 s shows that our slope-based algorithm is efficient and fast. Therefore, we will try other filtering approaches to improve the performance of the program in subsequent work. In Table 7, we can see a gradual decrease in the amount of data, such as in scene 3, the number of points is reduced to 187 × 52 from 1,568,974 × 3, which is why our approach is efficient. In Table 8, by comparing the parameters of the ceiling and ground planes, we note that they are parallel. The error of the room height calculated from these two planes is small (the maximum error does not exceed 0.015), so our method of finding the plane is accurate. We want to restore a model from the point cloud that is the same size as in the actual scene. In Table 9, by comparing the calculated length, width, and height with the actual value, the error between the predicted value and the actual value is, respectively, less than 0.044 m, 0.045 m, and 0.015 m. The mean error of 0.024 m proves that our algorithm is accurate within the error tolerance. In Table 10, we overcome the difficulty of LiDAR data processing and achieve similar results compared with some current methods. The data from LiDAR are easy to obtain but difficult to process, laser scanner data are difficult to obtain but high precision. We summarize the advantages and disadvantages of some algorithms. Then, we propose some methods to optimize and solve these problems in terms of prior knowledge, noise removal, data optimization, structure extraction, algorithm efficiency, and accuracy. Compared with existing methods, our method is superior to current algorithms in some respects.

Finally, there are still some shortcomings in our experiment. To make the initial data tidier, we will test other algorithms to replace the current algorithm for scan registration, such as LIO-SAM. Our method is currently only applicable to the reconstruction of interior vertical walls, and circles are recognized as polygons by the method. Therefore, we will modify the algorithm to accommodate more complex cases and make it more robust.

5. Conclusions

The method proposed in this paper can restore basic interior structure on an equal scale. In this method, the ceiling and the floor of the room are segmented and fitted, and the ground plane is used as the reference plane. Then, the wall is projected onto the reference plane. We filter, regularize, and transform the resulting two-dimensional data into an image. We extract the skeleton of the image and calculate the slope for each point. The slope that characterizes a line expands by growing until all points of the line are found. These lines are optimized and corrected by our method to produce more accurate lines. Finally, these lines are restored to three-dimensional vertical planes by applying height information. From the experimental results, the reconstruction effect and parameter analysis all show that our method is accurate (mean error of 0.024 m at an average measuring range of 40 m). In the whole algorithm, we pay attention to the improvement of computing speed and innovation of the algorithm. Therefore, we made a lot of data optimization and algorithm improvement, and we proposed a new framework to solve the problem of indoor reconstruction. However, there are some limitations and errors in this method. For example, parameters need to be adjusted to obtain the best results, and indoor sundries cannot be reconstructed. Therefore, we will focus on algorithm optimization and detail processing to make the algorithm more practical in the future.