geometry.h

Go to the documentation of this file.

#ifndef GEOMETRY_H
#define GEOMETRY_H
 
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <box2d/box2d.h>
#include <vector>
#include <string>
#include <tuple>
#include <utility>
#include <cstdint>
 
typedef std::vector<std::vector<b2Vec2>> arena_polygons_t;
 
float const VISUALIZATION_SCALE = 100.0f; // 1 Box2D unit = 100 pixels

extern float mm_to_pixels;
extern float visualization_x;
extern float visualization_y;

void adjust_mm_to_pixels(float delta);

b2Vec2 visualization_position(float x, float y);

b2Vec2 visualization_position(b2Vec2 pos);

std::vector<std::vector<b2Vec2>> read_poly_from_csv(const std::string& filename, float total_surface);

 
b2Vec2 generate_random_point_within_polygon(const std::vector<b2Vec2>& polygon);

bool is_point_within_polygon(const std::vector<b2Vec2>& polygon, float x, float y);

std::vector<b2Vec2> offset_polygon(const std::vector<b2Vec2>& polygon, float offset);
 

std::vector<b2Vec2> generate_random_points_within_polygon_safe(
        const std::vector<std::vector<b2Vec2>> &polygons,
        const std::vector<float> &reserve_radii,
        float max_neighbor_distance = std::numeric_limits<float>::infinity(),
        std::uint32_t attempts_per_point = 100U,
        std::uint32_t max_restarts = 100U);

std::vector<b2Vec2> generate_points_voronoi_lloyd(const std::vector<std::vector<b2Vec2>> &polygons,
                                                  std::size_t k,
                                                  std::size_t n_samples      = 20'000,
                                                  std::size_t kmeans_iterations = 20,
                                                  std::uint32_t max_restarts = 3);
 

std::vector<b2Vec2> generate_random_points_power_lloyd(
        const std::vector<std::vector<b2Vec2>> &polygons,
        const std::vector<float>               &reserve_radii,
        std::size_t        n_samples          = 25'000,
        std::size_t        kmeans_iterations  = 25,
        float              convergence_eps    = 1e-3f,
        std::uint32_t      max_restarts       = 3);
 

std::vector<b2Vec2> generate_random_points_layered(
        const std::vector<std::vector<b2Vec2>> &polygons,
        const std::vector<float> &reserve_radii,
        std::uint32_t attempts_per_point = 1'000U,
        std::uint32_t max_restarts       = 25U);
 

std::vector<b2Vec2> generate_chessboard_points(
        const std::vector<std::vector<b2Vec2>> &polygons,
        std::size_t                             n_points,
        float                                   pitch,
        bool                                    cluster_center = false);

std::pair<float, float> compute_polygon_dimensions(const std::vector<b2Vec2>& polygon);

float compute_polygon_area(const std::vector<b2Vec2>& poly);

b2Vec2 polygon_centroid(const std::vector<b2Vec2>& polygon);

float point_to_line_segment_distance(const b2Vec2& p, const b2Vec2& a, const b2Vec2& b);

std::vector<b2Vec2> generate_regular_disk_points_in_polygon( const std::vector<std::vector<b2Vec2>>& polygons, const std::vector<float>& reserve_radii);
 

std::tuple<std::vector<b2Vec2>, std::vector<float>>
import_points_from_file(const arena_polygons_t& scaled_arena_polygons,
                        const size_t nb_objects,
                        const std::string&      formation_filename,
                        const std::pair<float, float>& imported_formation_min_coords,
                        const std::pair<float, float>& imported_formation_max_coords);
 
 
#endif // GEOMETRY_H
 
// MODELINE "{{{1
// vim:expandtab:softtabstop=4:shiftwidth=4:fileencoding=utf-8
// vim:foldmethod=marker