peak_icv_point_cloud_xyzi.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_icv/algorithms/calibration/peak_icv_calibration_result.hpp>
#include <peak_icv/exceptions/detail/peak_icv_exception_helpers.hpp>
#include <peak_icv/types/detail/peak_icv_point_cloud.hpp>
#include <peak_icv/types/geometry/peak_icv_point_xyz.hpp>
#include <peak_icv/types/geometry/peak_icv_point_xyzi.hpp>
#include <peak_icv/types/peak_icv_xyz_image.hpp>
#include <peak_icv/utils/peak_icv_defines.hpp>
#include <peak_icv/utils/peak_icv_type_traits.hpp>
#include <peak_icv_c/types/peak_icv_point_cloud.h>
#include <algorithm>
#include <memory>
#include <vector>
 
namespace peak
{
namespace icv
{
 
namespace experimental
{
 
class PointCloudXYZI : public detail::PointCloud<PointCloudXYZI, PointXYZI>
{
 
public:
    PointCloudXYZI(const XYZImage& xyzImage, const Image& intensityImage);
 
    PointCloudXYZI(const peak::icv::experimental::UndistortedImage& undistortedDepthMap, const Image& intensityImage);
 
    explicit PointCloudXYZI(const std::string& filePath, peak::common::PixelFormat pixelFormatName);
 
    explicit PointCloudXYZI(const std::vector<PointXYZI>& points, peak::common::PixelFormat pixelFormatName);
 
protected:
    PointCloudXYZI() = default;
 
private:
    friend peak::common::detail::BackendAccessor<PointCloudXYZI>;
#ifndef DOXYGEN_SHOULD_SKIP_THIS // skip this as doxygen cannot handle friended base
    friend detail::PointCloud<PointCloudXYZI, PointXYZI>;
#endif                           /* DOXYGEN_SHOULD_SKIP_THIS */
 
    static peak_icv_point_cloud_handle CreatePointCloudHandle(const XYZImage& xyzImage, const Image& intensityImage);
    static peak_icv_point_type PointTypeFromPixelFormat(peak::common::PixelFormat pixelFormatName);
    static peak_icv_point_cloud_handle LoadFromFile(const std::string& filePath, peak::common::PixelFormat pixelFormatName);
    static peak_icv_point_cloud_handle CreateFromPoints(
        const std::vector<PointXYZI>& points, peak::common::PixelFormat pixelFormatName);
};
 
inline PointCloudXYZI::PointCloudXYZI(const XYZImage& xyzImage, const Image& intensityImage)
    : PointCloud<PointCloudXYZI, PointXYZI>{ CreatePointCloudHandle(xyzImage, intensityImage) }
{}
 
inline PointCloudXYZI::PointCloudXYZI(const peak::icv::experimental::UndistortedImage& undistortedDepthMap, const Image& intensityImage)
    : PointCloudXYZI(XYZImage(undistortedDepthMap), intensityImage)
{}
 
inline PointCloudXYZI::PointCloudXYZI(const std::string& filePath, peak::common::PixelFormat pixelFormatName)
    : PointCloud<PointCloudXYZI, PointXYZI>{ LoadFromFile(filePath, pixelFormatName) }
{}
 
inline PointCloudXYZI::PointCloudXYZI(const std::vector<PointXYZI>& points, peak::common::PixelFormat pixelFormatName)
    : PointCloud<PointCloudXYZI, PointXYZI>{ CreateFromPoints(points, pixelFormatName) }
{}
 
inline peak_icv_point_cloud_handle PointCloudXYZI::CreatePointCloudHandle(const XYZImage& xyzImage, const Image& intensityImage)
{
    auto* const xyzImageHandle = peak::common::detail::BackendAccessor<Image>::BackendHandle(xyzImage);
    auto* const intensityImageHandle = peak::common::detail::BackendAccessor<Image>::BackendHandle(intensityImage);
 
    peak_icv_point_cloud_handle handle{};
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_PointCloud_CreateFromXYZImageAndIntensityImage(
            &handle, xyzImageHandle, intensityImageHandle);
    });
    return handle;
}
 
inline peak_icv_point_type PointCloudXYZI::PointTypeFromPixelFormat(peak::common::PixelFormat pixelFormatName)
{
    switch (pixelFormatName)
    {
    case peak::common::PixelFormat::Mono8:
        return PEAK_ICV_POINT_TYPE_XYZ_I8;
    case peak::common::PixelFormat::Mono10:
        return PEAK_ICV_POINT_TYPE_XYZ_I10;
    case peak::common::PixelFormat::Mono12:
        return PEAK_ICV_POINT_TYPE_XYZ_I12;
    default:
        throw peak::icv::NotSupportedException("The given pixel format is not supported!");
    }
}
 
inline peak_icv_point_cloud_handle PointCloudXYZI::LoadFromFile(
    const std::string& filePath, peak::common::PixelFormat pixelFormatName)
{
    peak_icv_point_cloud_handle handle{};
 
 
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_PointCloud_CreateFromFile(
            &handle, PointTypeFromPixelFormat(pixelFormatName), filePath.c_str());
    });
    return handle;
}
 
inline peak_icv_point_cloud_handle PointCloudXYZI::CreateFromPoints(
    const std::vector<PointXYZI>& points, peak::common::PixelFormat pixelFormatName)
{
    std::vector<peak_icv_point_xyzi> pointsC{};
    pointsC.reserve(points.size());
 
    std::transform(points.begin(), points.end(), std::back_inserter(pointsC), [](const PointXYZI& point) -> peak_icv_point_xyzi {
        return { point.GetX(), point.GetY(), point.GetZ(), point.GetIntensity() };
    });
 
    peak_icv_point_cloud_handle pointCloudHandle{};
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_PointCloud_CreateFromPoints(
            &pointCloudHandle, pointsC.data(), pointsC.size(), PointTypeFromPixelFormat(pixelFormatName));
    });
    return pointCloudHandle;
}
} /* namespace experimental */
 
 
} /* namespace icv */
} /* namespace peak */