Hello Admin,

I am new to eigen, not to c++. I need to re-implement a complex linear algebra code in C++. So I need to use eigen library.

Here is the code:

Code: Select all

shifted_coord = point_cloud[:, :3] + lidar_coord   //shape (60000,3)  dynamic matrix
    # reverse the point cloud coordinate (X, Y, Z) -> (Z, Y, X)
    voxel_index = np.floor(
        shifted_coord[:, ::-1] / voxel_size).astype(np.int)

    bound_x = np.logical_and(
        voxel_index[:, 2] >= 0, voxel_index[:, 2] < grid_size[2])
    bound_y = np.logical_and(
        voxel_index[:, 1] >= 0, voxel_index[:, 1] < grid_size[1])
    bound_z = np.logical_and(
        voxel_index[:, 0] >= 0, voxel_index[:, 0] < grid_size[0])

    bound_box = np.logical_and(np.logical_and(bound_x, bound_y), bound_z)

    point_cloud = point_cloud[bound_box]
    voxel_index = voxel_index[bound_box]

    # [K, 3] coordinate buffer as described in the paper
    coordinate_buffer = np.unique(voxel_index, axis=0)

    K = len(coordinate_buffer)
    T = max_point_number

    # [K, 1] store number of points in each voxel grid
    number_buffer = np.zeros(shape=(K), dtype=np.int64)

    # [K, T, 7] feature buffer as described in the paper
    feature_buffer = np.zeros(shape=(K, T, 7), dtype=np.float32)

    # build a reverse index for coordinate buffer
    index_buffer = {}
    for i in range(K):
        index_buffer[tuple(coordinate_buffer[i])] = i

    for voxel, point in zip(voxel_index, point_cloud):
        index = index_buffer[tuple(voxel)]
        number = number_buffer[index]
        if number < T:
            feature_buffer[index, number, :4] = point
            number_buffer[index] += 1

    feature_buffer[:, :, -3:] = feature_buffer[:, :, :3] - \
        feature_buffer[:, :, :3].sum(axis=1, keepdims=True)/number_buffer.reshape(K, 1, 1)


It is highly complicated code in numpy, that's why.

Can you please let me know whether it is possible to achieve above linear algebra code in EIgen in a fast way?

Thanks in advance

Eigen::Map and Eigen::Select can emulate pythonic lvalue and rvalue, boolean- and index- based array slicing in some ways and not others.
Casting an Eigen matrix/vector to an Eigen::Array enables element-wise operations (in-place and as an rvalue).

Eigen::AlignedBox lets you have that grid-aligned bounding box functionality to see if points are contained.
I'm not familiar with Eigen's Geometry module, so I don't know if you can get the python-vectorized syntax of np.logical_and.

I don't think Eigen's templates support the generic boolean and numeric container interface that np.array does, or has anything like np.unique.
And I don't think it supports the dynamic reshaping found in "point_cloud = point_cloud[bound_box]".
You may need to manage temporaries and other memory on your own, where python would convienently do it for you before.
And you'll probably benefit from using standard c++ containers and algorithms in some places, like an std::unordered_set or std::unique.

Are there any other features you're worried about?