xyz.hpp

 
#ifndef UFO_IO_XYZ_HPP
#define UFO_IO_XYZ_HPP
 
// UFO
#include <ufo/cloud/point_cloud.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 cloudPropertiesXYZ(std::filesystem::path const& file);
 
template <std::size_t Dim, class T, class... Ts>
bool readXYZ(std::filesystem::path const& file, PointCloud<Dim, T, Ts...>& pc)
{
    FileHandler fp(file.c_str(), "rb");
 
    if (!fp) {
        std::println(stderr, "[UFO | Read XYZ] Failed to open file: {}", file.string());
        return false;
    }
 
    pc.clear();
 
    for (char* line = fp.readline(); nullptr != line; line = fp.readline()) {
        Vec3d p;
        if (3 == std::sscanf(line, "%lf %lf %lf", &p.x, &p.y, &p.z)) {
            pc.push_back(convert<Vec<Dim, T>>(p));
        }
    }
 
    return true;
}
 
template <std::size_t Dim, class T, class... Ts>
bool writeXYZ(std::filesystem::path const& file, PointCloud<Dim, T, Ts...> const& pc)
{
    FileHandler fp(file.c_str(), "wb");
 
    if (!fp) {
        std::println(stderr, "[UFO | Write XYZ] Failed to create file: {}", file.string());
        return false;
    }
 
    for (auto points = view<Vec<Dim, T>>(pc); auto const& point : points) {
        auto p = convert<Vec<3, T>>(point);
        if constexpr (std::is_same_v<T, float>) {
            std::println(fp.get(), "{:.6} {:.6} {:.6}", p.x, p.y, p.z);
        } else if constexpr (std::is_floating_point_v<T>) {
            std::println(fp.get(), "{:.10} {:.10} {:.10}", p.x, p.y, p.z);
        } else {
            std::println(fp.get(), "{} {} {}", p.x, p.y, p.z);
        }
    }
 
    return true;
}
}  // namespace ufo
 
#endif  // UFO_IO_XYZ_HPP