點云數(shù)據(jù)——The Point Cloud Data

點云數(shù)據(jù)應(yīng)表示為具有N行和至少3列的numpy數(shù)組。每行對應(yīng)于單個點，其在空間（x，y，z）中的位置使用至少3個值表示。

如果點云數(shù)據(jù)來自LIDAR傳感器，那么它可能具有每個點的附加值，例如“反射率”，其是在該位置中障礙物反射多少激光光束的量度。在這種情況下，點云數(shù)據(jù)可能是Nx4陣列。

圖像與點云坐標——Image vs Point Cloud Coordinates

點云的軸與圖像中的軸具有完全不同的含義。下圖顯示了藍色的圖像軸和橙色的點云軸。

關(guān)于圖像需要注意的一些重要事項：

• 圖像中的坐標值始終為正。

• 原點位于左上角。

• 坐標是整數(shù)值。

有關(guān)點云坐標的注意事項：

• 點云中的坐標值可以是正數(shù)或負數(shù)。

• 坐標可以采用實數(shù)值。

• 正x軸表示向前。

• 正y軸表示左。

• 正z軸表示向上。

創(chuàng)建點云數(shù)據(jù)的Birdseye視圖

鳥瞰圖的相關(guān)軸 為了創(chuàng)建鳥眼視圖圖像，來自點云數(shù)據(jù)的相關(guān)軸將是x和y軸。

但是，正如我們從上圖所示，我們必須小心并考慮以下事項： x和y軸意味著相反的事情。 x和y軸指向相反的方向。 您必須移動值，以便（0,0）是圖像中可能的最小值。

1.限制矩形看——Limiting Rectangle to Look at

僅關(guān)注點云的特定區(qū)域通常很有用。因此，我們希望創(chuàng)建一個僅保留我們感興趣的區(qū)域內(nèi)的點的過濾器。 由于我們正在查看頂部的數(shù)據(jù)，并且我們有興趣將其轉(zhuǎn)換為圖像，因此我將使用與圖像軸更加一致的方向。下面，我指定我想要集中在相對于原點的值的范圍。原點左側(cè)的任何內(nèi)容都將被視為負數(shù)，而右側(cè)的任何內(nèi)容都將被視為正數(shù)。點云的x軸將被解釋為向前方向（這將是我們的鳥眼圖像的向上方向）。 下面的代碼將感興趣的矩形設(shè)置為在原點的兩側(cè)跨越10米，并在其前面20米處。

side_range=(-10, 10)     # left-most to right-most
fwd_range=(0, 20)       # back-most to forward-most

2.接下來，我們創(chuàng)建一個過濾器，僅保留實際位于我們指定的矩形內(nèi)的點。

# EXTRACT THE POINTS FOR EACH AXIS
x_points = points[:, 0]
y_points = points[:, 1]
z_points = points[:, 2]


# FILTER - To return only indices of points within desired cube
# Three filters for: Front-to-back, side-to-side, and height ranges
# Note left side is positive y axis in LIDAR coordinates
f_filt = np.logical_and((x_points > fwd_range[0]), (x_points < fwd_range[1]))
s_filt = np.logical_and((y_points > -side_range[1]), (y_points < -side_range[0]))
filter = np.logical_and(f_filt, s_filt)
indices = np.argwhere(filter).flatten()


# KEEPERS
x_points = x_points[indices]
y_points = y_points[indices]
z_points = z_points[indices]

3.將點位置映射到像素位置——Mapping Point Positions to Pixel Positions

目前，我們有一堆帶有實數(shù)值的點。為了映射這些值，將這些值映射到整數(shù)位置值。我們可以天真地將所有x和y值整合到整數(shù)中，但我們最終可能會失去很多分辨率。例如，如果這些點的測量單位是以米為單位，則每個像素將表示點云中1x1米的矩形，我們將丟失任何小于此的細節(jié)。如果你有一個類似山景的點云，這可能沒問題。但是如果你想能夠捕捉更精細的細節(jié)并識別人類，汽車，甚至更小的東西，那么這種方法就沒有用了。

但是，可以稍微修改上述方法，以便我們獲得所需的分辨率級別。在對整數(shù)進行類型轉(zhuǎn)換之前，我們可以先擴展數(shù)據(jù)。例如，如果測量單位是米，我們想要5厘米的分辨率，我們可以做如下的事情：

res = 0.05
# CONVERT TO PIXEL POSITION VALUES - Based on resolution
x_img = (-y_points / res).astype(np.int32)  # x axis is -y in LIDAR
y_img = (-x_points / res).astype(np.int32)  # y axis is -x in LIDAR

您會注意到x軸和y軸交換，方向反轉(zhuǎn)，以便我們現(xiàn)在可以開始處理圖像坐標。

更改坐標原點——Shifting to New Origin

x和y數(shù)據(jù)仍未準備好映射到圖像。我們可能仍然有負x和y值。所以我們需要將數(shù)據(jù)移位到（0,0）最小值。

# SHIFT PIXELS TO HAVE MINIMUM BE (0,0)
# floor and ceil used to prevent anything being rounded to below 0 after shift
x_img -= int(np.floor(side_range[0] / res))
y_img += int(np.ceil(fwd_range[1] / res))

現(xiàn)在數(shù)據(jù)值都為正值

>>> x_img.min()
7
>>> x_img.max()
199
>>> y_img.min()
1
>>> y_img.max()
199

像素值——Pixel Values

我們已經(jīng)使用點數(shù)據(jù)來指定圖像中的x和y位置。我們現(xiàn)在需要做的是指定我們想要用這些像素位置填充的值。一種可能性是用高度數(shù)據(jù)填充它。要做的兩件事
請記住：
像素值應(yīng)為整數(shù)。
像素值應(yīng)該是0-255范圍內(nèi)的值。

我們可以從數(shù)據(jù)中獲取最小和最大高度值，并重新縮放該范圍以適應(yīng)0-255的范圍。另一種方法，這里將使用的方法是設(shè)置我們想要集中的高度值范圍，并且高于或低于該范圍的任何內(nèi)容都被剪切為最小值和最大值。這很有用，因為它允許我們從感興趣的區(qū)域獲得最大量的細節(jié)。

height_range = (-2, 0.5)  # bottom-most to upper-most


# CLIP HEIGHT VALUES - to between min and max heights
pixel_values = np.clip(a = z_points,
                           a_min=height_range[0],
                           a_max=height_range[1])

在下面的代碼中，我們將范圍設(shè)置為原點下方2米，高于原點半米。接下來，我們將這些值重新縮放到0到255之間，并將類型轉(zhuǎn)換為整數(shù)。

def scale_to_255(a, min, max, dtype=np.uint8):
    """ Scales an array of values from specified min, max range to 0-255
        Optionally specify the data type of the output (default is uint8)
    """
    return (((a - min) / float(max - min)) * 255).astype(dtype)


# RESCALE THE HEIGHT VALUES - to be between the range 0-255
pixel_values  = scale_to_255(pixel_values, min=height_range[0], max=height_range[1])

創(chuàng)建圖像陣列——Create the Image Array

現(xiàn)在我們準備實際創(chuàng)建圖像，我們只是初始化一個數(shù)組，其尺寸取決于我們在矩形中所需的值范圍和我們選擇的分辨率。然后我們使用我們轉(zhuǎn)換為像素位置的x和y點值來指定數(shù)組中的索引，并為這些索引分配我們選擇的值作為前一小節(jié)中的像素值。

# INITIALIZE EMPTY ARRAY - of the dimensions we want
x_max = 1+int((side_range[1] - side_range[0])/res)
y_max = 1+int((fwd_range[1] - fwd_range[0])/res)
im = np.zeros([y_max, x_max], dtype=np.uint8)


# FILL PIXEL VALUES IN IMAGE ARRAY
im[y_img, x_img] = pixel_values

預(yù)覽——Viewing

目前，圖像存儲為numpy數(shù)組。如果我們希望將其可視化，我們可以將其轉(zhuǎn)換為PIL圖像，并查看它。

# CONVERT FROM NUMPY ARRAY TO A PIL IMAGE
from PIL import Image
im2 = Image.fromarray(im)
im2.show()

我們作為人類并不善于分辨灰色陰影之間的差異，因此它可以幫助我們使用光譜顏色映射來讓我們更容易分辨出價值差異。我們可以在matplotlib中做到這一點。（實際無法正常顯示）

import matplotlib.pyplot as plt
plt.imshow(im, cmap="spectral", vmin=0, vmax=255)
plt.show()

它實際上編碼與PIL繪制的圖像完全相同的信息量，因此機器學(xué)習(xí)學(xué)習(xí)算法例如仍然能夠區(qū)分高度差異，即使我們?nèi)祟惒荒芊浅Ｇ宄乜吹讲町悺?/span>

   import cv2
   #通過cv2顯示
    cv2.imshow("im",im)
    cv2.waitKey()
    cv2.destroyAllWindows()

完整代碼——Complete Code

為方便起見，我將上面的所有代碼放在一個函數(shù)中，它將鳥瞰視圖作為一個numpy數(shù)組返回。然后，您可以選擇使用您喜歡的任何方法對其進行可視化，或者將numpy數(shù)組插入到機器學(xué)習(xí)算法中。

import numpy as np


# ==============================================================================
#                                                                   SCALE_TO_255
# ==============================================================================
def scale_to_255(a, min, max, dtype=np.uint8):
    """ Scales an array of values from specified min, max range to 0-255
        Optionally specify the data type of the output (default is uint8)
    """
    return (((a - min) / float(max - min)) * 255).astype(dtype)


# ==============================================================================
#                                                         POINT_CLOUD_2_BIRDSEYE
# ==============================================================================
def point_cloud_2_birdseye(points,
                           res=0.1,
                           side_range=(-10., 10.),  # left-most to right-most
                           fwd_range = (-10., 10.), # back-most to forward-most
                           height_range=(-2., 2.),  # bottom-most to upper-most
                           ):
    """ Creates an 2D birds eye view representation of the point cloud data.


    Args:
        points:     (numpy array)
                    N rows of points data
                    Each point should be specified by at least 3 elements x,y,z
        res:        (float)
                    Desired resolution in metres to use. Each output pixel will
                    represent an square region res x res in size.
        side_range: (tuple of two floats)
                    (-left, right) in metres
                    left and right limits of rectangle to look at.
        fwd_range:  (tuple of two floats)
                    (-behind, front) in metres
                    back and front limits of rectangle to look at.
        height_range: (tuple of two floats)
                    (min, max) heights (in metres) relative to the origin.
                    All height values will be clipped to this min and max value,
                    such that anything below min will be truncated to min, and
                    the same for values above max.
    Returns:
        2D numpy array representing an image of the birds eye view.
    """
    # EXTRACT THE POINTS FOR EACH AXIS
    x_points = points[:, 0]
    y_points = points[:, 1]
    z_points = points[:, 2]
    # FILTER - To return only indices of points within desired cube
    # Three filters for: Front-to-back, side-to-side, and height ranges
    # Note left side is positive y axis in LIDAR coordinates
    f_filt = np.logical_and((x_points > fwd_range[0]), (x_points < fwd_range[1]))
    s_filt = np.logical_and((y_points > -side_range[1]), (y_points < -side_range[0]))
    filter = np.logical_and(f_filt, s_filt)
    indices = np.argwhere(filter).flatten()
    # KEEPERS
    x_points = x_points[indices]
    y_points = y_points[indices]
    z_points = z_points[indices]
    # CONVERT TO PIXEL POSITION VALUES - Based on resolution
    x_img = (-y_points / res).astype(np.int32)  # x axis is -y in LIDAR
    y_img = (-x_points / res).astype(np.int32)  # y axis is -x in LIDAR
    # SHIFT PIXELS TO HAVE MINIMUM BE (0,0)
    # floor & ceil used to prevent anything being rounded to below 0 after shift
    x_img -= int(np.floor(side_range[0] / res))
    y_img += int(np.ceil(fwd_range[1] / res))
    # CLIP HEIGHT VALUES - to between min and max heights
    pixel_values = np.clip(a=z_points,
                           a_min=height_range[0],
                           a_max=height_range[1])
    # RESCALE THE HEIGHT VALUES - to be between the range 0-255
    pixel_values = scale_to_255(pixel_values,
                                min=height_range[0],
                                max=height_range[1])
    # INITIALIZE EMPTY ARRAY - of the dimensions we want
    x_max = 1 + int((side_range[1] - side_range[0]) / res)
    y_max = 1 + int((fwd_range[1] - fwd_range[0]) / res)
    im = np.zeros([y_max, x_max], dtype=np.uint8)
    # FILL PIXEL VALUES IN IMAGE ARRAY
    im[y_img, x_img] = pixel_values


    return im

審核編輯 ：李倩