diff --git a/roads.c b/roads.c
index 0c4534e..4dac2c3 100644
--- a/roads.c
+++ b/roads.c
@@ -1,4 +1,5 @@
 #include <stdio.h>
+#include <stdlib.h>
 
 typedef struct Vertex {
 	int x;
@@ -26,19 +27,80 @@ void roads(Polygon* quartier) {
 	svg_line(&center, &(quartier[0]));
 }
 
+/* Fonctions de Yoann suffixée par "Y" */
+typedef struct roadNodeY {
+	Vertex *v;
+	struct roadNodeY *next;
+	struct roadNodeY *previous;
+} roadNodeY;
+
+const int maxSubDivision = 6;	// Nombre de subdivisions max en hauteur et largeur.
+
+// TODO Fusionner les deux fonctions et retourner une paire de valeurs.
+// Transforme des coordonnées du plan en coordonées du tableau sur x.
+int toX(int x) {
+	return x/maxSubDivision;
+}
+
+// Transforme des coordonnées du plan en coordonées du tableau sur y.
+int toY(int y) {
+	return y/maxSubDivision;
+}
+
+void carreY() {
+	roadNodeY ***nodesGrid = (roadNodeY***) malloc(sizeof(roadNodeY**)*maxSubDivision);
+	int i = 0;
+	int j = 0;
+	int size = 500;
+	for(i=0;i<maxSubDivision;i++) {
+		nodesGrid[i] = (roadNodeY**) malloc(sizeof(roadNodeY*)*maxSubDivision);
+		for(j=0;j<maxSubDivision;j++) {
+			roadNodeY *rn = (roadNodeY*) malloc(sizeof(roadNodeY));
+			rn->v = (Vertex*) malloc(sizeof(Vertex));
+			rn->v->x = i*size/maxSubDivision;
+			rn->v->y = j*size/maxSubDivision;
+			rn->next = NULL;
+			rn->previous = NULL;
+			nodesGrid[i][j] = rn;
+		}
+	}
+	
+	int a,b;
+	for(i=0;i<maxSubDivision;i++) {
+		for(j=0;j<maxSubDivision;j++) {
+			roadNodeY *rn = nodesGrid[i][j];
+			while(rn != NULL) {
+				for(a=i-1;a<=i+1;a++) {
+					for(b=j-1;b<=j+1;b++) {
+						if(a >= 0 && a < maxSubDivision && b >= 0 && b < maxSubDivision) {
+							svg_line(rn->v,nodesGrid[a][b]->v);
+						}
+					}
+				}
+				rn = NULL;
+			}
+		}
+	}
+}
+
 int main() {
 	Vertex points[] = {
 		{ .x=10, .y=10 },
 		{ .x=790, .y=10 },
+		{ .x=600, .y=300 },
 		{ .x=790, .y=590 },
 		{ .x=10, .y=590 },
 	};
+	int n = 5;
 	svg_start(800,600);
-	int i;
-	for (i = 0; i < 4; i++) {
-		svg_line(&(points[i]), &(points[(i+1)%4]));
-	}
-	roads(points);
+	carreY();
+	//int i;
+	//for (i = 0; i < n; i++) {
+//		svg_line(&(points[i]), &(points[(i+1)%n]));
+//	}
+n=n;
+	//roads(points);
+	points[0] = points[0];
 	svg_end();
 	return 0;
 }
diff --git a/roads.md b/roads.md
index f8b7cbe..5ab81e8 100644
--- a/roads.md
+++ b/roads.md
@@ -25,7 +25,8 @@ Algo 1
 
 * Choisir un angle.
 * Tracer des routes suivant cet angle et cet angle + 90°.
-* Les routes doivent pouvoir être assez longues (le tracé doit survivre à une intersection).
+* Les routes doivent pouvoir être assez longues (le tracé doit
+  survivre à une intersection).
 
 Algo 2
 
@@ -58,11 +59,11 @@ Comme une grille, mais les angles ne sont pas vraiment à 90°, et il y
 a beaucoup de longues rues dans l'une ou l'autre des directions.
 
     .________________________.
-	|   |        |      |    |
-	|___|________|______|____|
-	|         |       |______|
-	|_________|_______|      |
-	|______|__________|______|
+    |   |        |      |    |
+    |___|________|______|____|
+    |         |       |______|
+    |_________|_______|      |
+    |______|__________|______|
 
 TODO : trouver un algo pour générer des « murs »
 
@@ -86,7 +87,7 @@ monter ou descendre très légèrement pour rejoindre une autre ligne.
 
 * Partir d'un point, et choisir le point à X de distance qui minimise
   le dénivellé
-* Condinuer à partir du point ainsi créé, en s'interdisant les retours
+* Continuer à partir du point ainsi créé, en s'interdisant les retours
   en arrière trop brutaux
 * Arrêter la ligne quand le dénivellé devient trop important, ou quand
   on rejoint une autre ligne.
@@ -142,4 +143,14 @@ exemple).
 Angles et vecteurs
 ------------------
 
-Pouvoir ajouter un vecteur à un point, appliquer une rotation sur le vecteur…
+Pouvoir ajouter un vecteur à un point, appliquer une rotation sur le
+vecteur…
+
+Algo déformation de coordonées
+==============================
+
+Partir d'une grille idéale carrée et appliquer des déformations de
+coordonnées dessus, plus une fonction de densité de points (taille des
+bâtiments). Dé-transformer la fonction de densité de points,
+l'utiliser pour générer la grille parfaite avec des densités
+différentes, puis transformer cette grille.