graphe/render.c

#include "structs.h"
#include <SDL2/SDL.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>

#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT 600
#define NODE_RADIUS 15
#define ITERATIONS 500 // layout simulation steps
#define COOLING 0.97 // temperature cooling rate

typedef struct {
	double x, y; // position
	double vx, vy; // velocity / displacement
} layout_node_t;

static void draw_circle(SDL_Renderer *renderer, int cx, int cy, int r)
{
	for (int dy = -r; dy <= r; dy++) {
		int dx = (int)sqrt((double)(r * r - dy * dy));
		SDL_RenderDrawLine(renderer, cx - dx, cy + dy, cx + dx,
				   cy + dy);
	}
}

// Fruchterman-Reingold force-directed layout
static layout_node_t *compute_layout(const graph_t *graph)
{
	int n = graph->n;
	layout_node_t *nodes = malloc(n * sizeof(layout_node_t));
	if (!nodes)
		return NULL;

	// Seed random positions
	srand((unsigned)time(NULL));
	for (int i = 0; i < n; i++) {
		nodes[i].x = (double)(rand() % (WINDOW_WIDTH - 100)) + 50;
		nodes[i].y = (double)(rand() % (WINDOW_HEIGHT - 100)) + 50;
		nodes[i].vx = 0;
		nodes[i].vy = 0;
	}

	double area = (WINDOW_WIDTH - 200) * (WINDOW_HEIGHT - 200);
	double k = sqrt(area / n); // optimal distance between nodes
	double temp = WINDOW_WIDTH * 0.1; // initial temperature

	for (int iter = 0; iter < ITERATIONS; iter++) {
		// Reset displacements
		for (int i = 0; i < n; i++)
			nodes[i].vx = nodes[i].vy = 0.0;

		// Repulsive forces (all pairs)
		for (int i = 0; i < n; i++) {
			for (int j = i + 1; j < n; j++) {
				double dx = nodes[i].x - nodes[j].x;
				double dy = nodes[i].y - nodes[j].y;
				double dist = sqrt(dx * dx + dy * dy);
				if (dist < 1.0)
					dist = 1.0;

				double force = (k * k) / dist;
				double fx = (dx / dist) * force;
				double fy = (dy / dist) * force;

				nodes[i].vx += fx;
				nodes[i].vy += fy;
				nodes[j].vx -= fx;
				nodes[j].vy -= fy;
			}
		}

		// Attractive forces (edges only)
		for (int i = 0; i < n; i++) {
			node_t *neighbor = graph->adj_lists[i];
			while (neighbor) {
				int j = neighbor->id;
				if (i < j) {
					double dx = nodes[i].x - nodes[j].x;
					double dy = nodes[i].y - nodes[j].y;
					double dist = sqrt(dx * dx + dy * dy);
					if (dist < 1.0)
						dist = 1.0;

					double force = (dist * dist) / k;
					double fx = (dx / dist) * force;
					double fy = (dy / dist) * force;

					nodes[i].vx -= fx;
					nodes[i].vy -= fy;
					nodes[j].vx += fx;
					nodes[j].vy += fy;
				}
				neighbor = neighbor->next;
			}
		}

		// Apply displacements, clamped to temperature
		for (int i = 0; i < n; i++) {
			double disp = sqrt(nodes[i].vx * nodes[i].vx +
					   nodes[i].vy * nodes[i].vy);
			if (disp < 1.0)
				disp = 1.0;

			double scale = fmin(disp, temp) / disp;
			nodes[i].x += nodes[i].vx * scale;
			nodes[i].y += nodes[i].vy * scale;

			// Keep nodes within window bounds with padding
			nodes[i].x = fmax(NODE_RADIUS + 10,
					  fmin(WINDOW_WIDTH - NODE_RADIUS - 10,
					       nodes[i].x));
			nodes[i].y = fmax(NODE_RADIUS + 10,
					  fmin(WINDOW_HEIGHT - NODE_RADIUS - 10,
					       nodes[i].y));
		}

		// Cool the temperature
		temp *= COOLING;
	}

	return nodes;
}

void render_graph(SDL_Renderer *renderer, const graph_t *graph)
{
	if (!renderer || !graph || !graph->adj_lists)
		return;

	int n = graph->n;

	layout_node_t *layout = compute_layout(graph);
	if (!layout)
		return;

	// Clear background
	SDL_SetRenderDrawColor(renderer, 200, 200, 200, 255);
	SDL_RenderClear(renderer);

	// Draw edges
	SDL_SetRenderDrawColor(renderer, 30, 30, 30, 255);
	for (int i = 0; i < n; i++) {
		node_t *neighbor = graph->adj_lists[i];

		while (neighbor) {
			int j = neighbor->id;
			if (i < j) {
				SDL_RenderDrawLine(renderer, (int)layout[i].x,
						   (int)layout[i].y,
						   (int)layout[j].x,
						   (int)layout[j].y);
			}
			neighbor = neighbor->next;
		}
	}

	// Draw nodes
	for (int i = 0; i < n; i++) {
		int x = (int)layout[i].x;
		int y = (int)layout[i].y;

		// Node fill
		SDL_SetRenderDrawColor(renderer, 100, 149, 237, 255);
		draw_circle(renderer, x, y, NODE_RADIUS);

		// Node border
		SDL_SetRenderDrawColor(renderer, 200, 220, 255, 255);
		for (int deg = 0; deg < 360; deg++) {
			double a = deg * M_PI / 180.0;
			SDL_RenderDrawPoint(renderer,
					    x + (int)(NODE_RADIUS * cos(a)),
					    y + (int)(NODE_RADIUS * sin(a)));
		}
	}

	free(layout);
	SDL_RenderPresent(renderer);
}