xyzn.hpp

 
#ifndef UFO_CLOUD_IO_XYZN_HPP
#define UFO_CLOUD_IO_XYZN_HPP
 
// UFO
#include <ufo/cloud/point_cloud.hpp>
#include <ufo/core/normal.hpp>
#include <ufo/io/cloud_properties.hpp>
#include <ufo/io/file_handler.hpp>
#include <ufo/numeric/vec.hpp>
 
// STL
#include <cstdio>
#include <filesystem>
#include <print>
 
namespace ufo
{
[[nodiscard]] CloudProperties cloudPropertiesXYZN(std::filesystem::path const& file);
 
template <std::size_t Dim, class T, class... Ts>
bool readXYZN(std::filesystem::path const& file, PointCloud<Dim, T, Ts...>& pc)
{
    FileHandler fp(file.c_str(), "rb");
 
    if (!fp) {
        std::println(stderr, "[UFO | Read XYZN] Failed to open file: {}", file.string());
        return false;
    }
 
    pc.clear();
 
    for (char line[1024]; nullptr != std::fgets(line, sizeof line, fp.get());) {
        Vec3d  p;
        Normal n;
        if (6 ==
            std::sscanf(line, "%lf %lf %lf %f %f %f", &p.x, &p.y, &p.z, &n.x, &n.y, &n.z)) {
            if constexpr (std::disjunction_v<is_normal<Ts>...>) {
                pc.push_back(convert<Vec<Dim, T>>(p), n);
            } else {
                pc.push_back(convert<Vec<Dim, T>>(p));
            }
        }
    }
 
    return true;
}
 
template <std::size_t Dim, class T, class... Ts>
bool writeXYZN(std::filesystem::path const& file, PointCloud<Dim, T, Ts...> const& pc)
{
    FileHandler fp(file.c_str(), "wb");
 
    if (!fp) {
        std::println(stderr, "[UFO | Write XYZN] Failed to create file: {}", file.string());
        return false;
    }
 
    std::size_t const size    = pc.size();
    auto              points  = view<Vec<Dim, T>>(pc);
    auto              normals = view<Normal>(pc);
    for (std::size_t i{}; size > i; ++i) {
        auto p = convert<Vec<3, T>>(points[i]);
        auto n = normals[i];
        if constexpr (std::is_same_v<T, float>) {
            std::print(fp.get(), "{:.6} {:.6} {:.6}", p.x, p.y, p.z);
        } else if constexpr (std::is_floating_point_v<T>) {
            std::print(fp.get(), "{:.10} {:.10} {:.10}", p.x, p.y, p.z);
        } else {
            std::print(fp.get(), "{} {} {}", p.x, p.y, p.z);
        }
        if constexpr ((is_normal_v<Ts> || ...)) {
            std::println(fp.get(), " {:.6} {:.6} {:.6}", n.x, n.y, n.z);
        } else {
            std::println(fp.get(), " 0 0 0");
        }
    }
 
    return true;
}
}  // namespace ufo
 
#endif  // UFO_CLOUD_IO_XYZN_HPP