peak_icv_point_cloud_xyz.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_image.hpp>
#include <peak_icv/types/peak_icv_undistorted_image.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 PointCloudXYZ : public detail::PointCloud<PointCloudXYZ, PointXYZ>
 
{
 
public:
    explicit PointCloudXYZ(const XYZImage& image);
 
    explicit PointCloudXYZ(const UndistortedImage& undistortedDepthMap);
 
    explicit PointCloudXYZ(const std::string& filePath);
 
    explicit PointCloudXYZ(const std::vector<PointXYZ>& points);
 
protected:
    PointCloudXYZ() = default;
 
private:
#ifndef DOXYGEN_SHOULD_SKIP_THIS // skip this as doxygen cannot handle friended base
    friend detail::PointCloud<PointCloudXYZ, PointXYZ>;
#endif                           /* DOXYGEN_SHOULD_SKIP_THIS */
 
    friend peak::common::detail::BackendAccessor<PointCloudXYZ>;
 
    static peak_icv_point_cloud_handle CreatePointCloudHandle(const XYZImage& image);
    static peak_icv_point_cloud_handle LoadFromFile(const std::string& filePath);
    static peak_icv_point_cloud_handle CreateFromPoints(const std::vector<PointXYZ>& points);
};
 
inline PointCloudXYZ::PointCloudXYZ(const XYZImage& image)
    : PointCloud<PointCloudXYZ, PointXYZ>{ CreatePointCloudHandle(image) }
{}
 
inline PointCloudXYZ::PointCloudXYZ(const UndistortedImage& undistortedDepthMap)
    : PointCloudXYZ{ XYZImage{ undistortedDepthMap } }
{}
 
inline PointCloudXYZ::PointCloudXYZ(const std::string& filePath)
    : PointCloud<PointCloudXYZ, PointXYZ>{ LoadFromFile(filePath) }
{}
 
inline PointCloudXYZ::PointCloudXYZ(const std::vector<PointXYZ>& points)
    : PointCloud<PointCloudXYZ, PointXYZ>{ CreateFromPoints(points) }
{}
 
inline peak_icv_point_cloud_handle PointCloudXYZ::CreatePointCloudHandle(const XYZImage& image)
{
    auto* const imageHandle = peak::common::detail::BackendAccessor<Image>::BackendHandle(image);
 
    peak_icv_point_cloud_handle pointCloudHandle{};
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_PointCloud_CreateFromXYZImage(&pointCloudHandle, imageHandle);
    });
    return pointCloudHandle;
}
 
inline peak_icv_point_cloud_handle PointCloudXYZ::LoadFromFile(const std::string& filePath)
{
    peak_icv_point_cloud_handle handle{};
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_PointCloud_CreateFromFile(&handle, PEAK_ICV_POINT_TYPE_XYZ, filePath.c_str());
    });
    return handle;
}
 
inline peak_icv_point_cloud_handle PointCloudXYZ::CreateFromPoints(const std::vector<PointXYZ>& points)
{
    std::vector<peak_icv_point_xyz> pointsC(points.size());
 
    std::transform(points.begin(), points.end(), pointsC.begin(), [](const PointXYZ& point) -> peak_icv_point_xyz {
        return { point.GetX(), point.GetY(), point.GetZ(), {} };
    });
 
    peak_icv_point_cloud_handle pointCloudHandle{};
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_PointCloud_CreateFromPoints(
            &pointCloudHandle, pointsC.data(), pointsC.size(), PEAK_ICV_POINT_TYPE_XYZ);
    });
    return pointCloudHandle;
}
} /* namespace experimental */
 
} /* namespace icv */
} /* namespace peak */