utils.hpp

Go to the documentation of this file.

/* Copyright (c) 2025 Otto Link. Distributed under the terms of the GNU General
   Public License. The full license is in the file LICENSE, distributed with
   this software. */
#pragma once
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
 
#include "point_sampler/point.hpp"
 
namespace ps
{
 
template <typename T, size_t N>
bool save_points_to_csv(const std::string              &filename,
                        const std::vector<Point<T, N>> &points,
                        bool                            write_header = true)
{
  std::ofstream out(filename);
  if (!out.is_open())
    return false;
 
  if (write_header)
  {
    for (size_t i = 0; i < N; ++i)
    {
      out << "x" << i;
      if (i < N - 1)
        out << ",";
    }
    out << "\n";
  }
 
  for (const auto &point : points)
  {
    for (size_t i = 0; i < N; ++i)
    {
      out << point[i];
      if (i < N - 1)
        out << ",";
    }
    out << "\n";
  }
 
  return true;
}
 
template <typename T>
bool save_vector_to_csv(const std::string    &filename,
                        const std::vector<T> &values,
                        bool                  write_header = true,
                        const std::string    &header_name = "value")
{
  std::ofstream out(filename);
  if (!out.is_open())
    return false;
 
  if (write_header)
    out << header_name << "\n";
 
  for (const auto &val : values)
    out << val << "\n";
 
  return true;
}
 
template <typename T, size_t N>
std::vector<Point<T, N + 1>> add_dimension(const std::vector<Point<T, N>> &points,
                                           const std::vector<T>           &new_dimension)
{
  if (points.size() != new_dimension.size())
    throw std::runtime_error(
        "add_dimension: size mismatch between points and new dimension data");
 
  std::vector<Point<T, N + 1>> result;
  result.reserve(points.size());
 
  for (size_t i = 0; i < points.size(); ++i)
  {
    std::array<T, N + 1> coords{};
    std::copy(points[i].coords.begin(), points[i].coords.end(), coords.begin());
    coords[N] = new_dimension[i];
    result.emplace_back(coords);
  }
 
  return result;
}
 
template <typename T, size_t N>
std::vector<std::vector<Point<T, N>>> extract_clusters(
    const std::vector<Point<T, N>> &points,
    const std::vector<int>         &labels)
{
  if (points.size() != labels.size())
    throw std::runtime_error("extract_clusters: mismatch between points and labels size");
 
  // find max cluster id
  int max_cluster_id = -1;
  for (int lbl : labels)
    if (lbl >= 0)
      max_cluster_id = std::max(max_cluster_id, lbl);
 
  std::vector<std::vector<Point<T, N>>> clusters(max_cluster_id + 1);
 
  for (size_t i = 0; i < points.size(); ++i)
  {
    int lbl = labels[i];
    if (lbl >= 0)
      clusters[lbl].push_back(points[i]);
  }
 
  return clusters;
}
 
template <typename T, size_t N>
std::vector<Point<T, N>> merge_by_dimension(
    const std::array<std::vector<T>, N> &components)
{
  if constexpr (N > 0)
  {
    std::size_t count = components[0].size();
    for (std::size_t i = 1; i < N; ++i)
    {
      if (components[i].size() != count)
        throw std::invalid_argument("All component vectors must have the same size");
    }
 
    std::vector<Point<T, N>> points(count);
    for (std::size_t i = 0; i < count; ++i)
    {
      for (std::size_t j = 0; j < N; ++j)
        points[i][j] = components[j][i];
    }
 
    return points;
  }
  else
  {
    return {};
  }
}
 
template <typename T, size_t N> void normalize_points(std::vector<Point<T, N>> &points)
{
  if (points.empty())
    return;
 
  std::array<T, N> min_vals;
  std::array<T, N> max_vals;
 
  // Initialize min/max arrays
  for (size_t dim = 0; dim < N; ++dim)
  {
    min_vals[dim] = points[0].coords[dim];
    max_vals[dim] = points[0].coords[dim];
  }
 
  // Find min/max for each axis
  for (const auto &p : points)
  {
    for (size_t dim = 0; dim < N; ++dim)
    {
      min_vals[dim] = std::min(min_vals[dim], p.coords[dim]);
      max_vals[dim] = std::max(max_vals[dim], p.coords[dim]);
    }
  }
 
  // Normalize each point
  for (auto &p : points)
  {
    for (size_t dim = 0; dim < N; ++dim)
    {
      T range = max_vals[dim] - min_vals[dim];
      if (range != T(0))
        p.coords[dim] = (p.coords[dim] - min_vals[dim]) / range;
      else
        p.coords[dim] = T(0); // Avoid NaN if all values
                              // are equal
    }
  }
}
 
template <typename T, size_t N>
std::array<std::vector<T>, N> split_by_dimension(const std::vector<Point<T, N>> &points)
{
  std::array<std::vector<T>, N> components;
 
  for (const auto &point : points)
    for (size_t i = 0; i < N; ++i)
    {
      components[i].push_back(point[i]);
    }
 
  return components;
}
 
} // namespace ps