From: Karryanna <karry@karryanna.cz>
Date: Thu, 16 Apr 2015 15:36:04 +0000 (+0200)
Subject: Labelling: Kind of backup before clean-up :D
X-Git-Url: http://mj.ucw.cz/gitweb/?a=commitdiff_plain;h=eadd63b657be979276b0f7bab89f76a632473ab4;p=leo.git

Labelling: Kind of backup before clean-up :D
---

diff --git a/labeller.c b/labeller.c
index 32577bf..f740b49 100644
--- a/labeller.c
+++ b/labeller.c
@@ -1,3 +1,5 @@
+#include <errno.h>
+
 #include <ucw/lib.h>
 #include <ucw/gary.h>
 #include <ucw/mempool.h>
@@ -5,6 +7,7 @@
 
 #include "leo.h"
 #include "sym.h"
+#include "map.h"
 #include "labeller.h"
 
 #define HASH_NODE struct graph_node
@@ -18,6 +21,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
+#include <fcntl.h>
 
 #define BLOCK_SIZE 4096
 
@@ -37,6 +41,9 @@ struct eltpool *ep_individuals;
 struct individual **population1;
 struct individual **population2;
 
+int page_width_int;
+int page_height_int;
+
 int num_edges_dbg;
 int num_nodes;
 int num_edges = 0;
@@ -66,6 +73,9 @@ int conf_mutate_chvar_bound = 0.1;
 
 int conf_elite_perc = 5;
 
+double conf_max_section_length = 100;
+double conf_max_section_overlay = 10;
+
 int old_best = 0; // FIXME: Shall be int max
 int iteration = 0;
 int pop2_ind;
@@ -79,7 +89,7 @@ int num_requests = 0;
 
 void dump_graph(void);
 void bfs2(void);
-void bfs_edge(struct graph_edge *e, struct graph_node *node, struct graph_node *anode, int dir);
+void bfs_edge(struct graph_edge *e, struct graph_node *node, struct graph_node *anode, enum edge_dir dir);
 void bfs_wrapper(void);
 void oldbfs(void);
 void dump_longlines(void);
@@ -87,6 +97,37 @@ void dump_linelabel_requests(void);
 void dump_individual(struct individual *individual);
 void print_label(struct symbol *sym);
 
+double gen_movement(void);
+void gen_coords(struct placement *p);
+void gen_coords_point(struct placement *p);
+void gen_coords_segment(struct placement *p);
+void gen_coords_area(struct placement *p);
+
+int max2(int a, int b);
+int min2(int a, int b);
+int max4(int a, int b, int c, int d);
+int min4(int a, int b, int c, int d);
+
+int max2(int a, int b)
+{
+  return (a > b ? a : b);
+}
+
+int min2(int a, int b)
+{
+  return (a < b ? a : b);
+}
+
+int max4(int a, int b, int c, int d)
+{
+  return max2(max2(a, b), max2(c, d));
+}
+
+int min4(int a, int b, int c, int d)
+{
+  return min2(min2(a, b), min2(c, d));
+}
+
 void print_label(struct symbol *sym)
 {
   switch (sym->type)
@@ -108,6 +149,9 @@ void labeller_init(void)
   GARY_INIT(buffer_line, 0);
   GARY_INIT(buffer_linelabel, 0);
   ep_individuals = ep_new(sizeof(struct individual), 1);
+
+  page_width_int = floor(page_width);
+  page_height_int = floor(page_height);
 }
 
 void make_bitmap_icon(struct point_variant *v, struct sym_icon *si)
@@ -126,8 +170,31 @@ void make_bitmap_point(struct point_variant *v, struct sym_point *sp)
   for (int i=0; i<sp->size*sp->size; i++) v->bitmap[i] = 1;
 }
 
-void make_bitmap_label(struct point_variant *v UNUSED, struct sym_text *text UNUSED)
+void make_bitmap_label(struct point_variant *v, struct sym_text *text)
 {
+  int x_ld = 0;
+  int y_ld = 0;
+  int x_lu = 0;
+  int y_lu = 0;
+  int x_rd = 0;
+  int y_rd = 0;
+  int x_ru = 0;
+  int y_ru = 0;
+
+  v->width = max4(x_ld, x_lu, x_rd, x_ru) - min4(x_ld, x_lu, x_rd, x_ru);
+  v->height = max4(y_ld, y_lu, y_rd, y_ru) - min4(y_ld, y_lu, y_rd, y_ru);
+  //v->bitmap = malloc((int) (ceil(v->width) * ceil(v->height) * sizeof(bool)));
+
+  v->width = ceil(text->tw);
+  v->height = ceil(text->th);
+  v->bitmap = malloc(v->width * v->height * sizeof(bool));
+  printf("Allocated bitmap of %d bools for %d x %d label\n", v->width * v->height, v->width, v->height);
+  for (int i=0; i<v->height; i++)
+    for (int j=0; j<v->width; j++)
+    {
+      v->bitmap[i*v->width + j] = 1;
+      printf("Writing at %d\n", i*v->width + j);
+    }
 }
 
 void labeller_add_point(struct symbol *sym, struct osm_object *object, z_index_t zindex)
@@ -177,12 +244,12 @@ printf("Adding point\n");
       return;
   }
 
-  printf("Inited point to [%.2f; %.2f]\n", r->x, r->y);
+  printf("Inited point to [%.2f; %.2f] on %u\n", r->x, r->y, r->zindex);
 }
 
 void labeller_add_line(struct symbol *sym, z_index_t zindex)
 {
-printf("Adding line\n");
+printf("Adding line on %u\n", zindex);
   struct buffer_line *b = GARY_PUSH(buffer_line);
   b->line = (struct sym_line *) sym;
   b->zindex = zindex;
@@ -197,7 +264,7 @@ void labeller_add_linelabel(struct symbol *sym, struct osm_object *o, z_index_t
     return;
   }
 
-  printf("[LAB] Labelling way %ju\n", o->id);
+  printf("[LAB] Labelling way %ju on %u\n", o->id, zindex);
   struct buffer_linelabel *ll = GARY_PUSH(buffer_linelabel);
   ll->way = (struct osm_way *) o;
   ll->label = sym;
@@ -206,7 +273,7 @@ void labeller_add_linelabel(struct symbol *sym, struct osm_object *o, z_index_t
 
 void labeller_add_arealabel(struct symbol *sym, struct osm_object *o, z_index_t zindex)
 {
-printf("Adding area\n");
+printf("Adding area on %u\n", zindex);
   struct request_area *r = GARY_PUSH(requests_area);
 
   r->request.type = REQUEST_AREA;
@@ -223,9 +290,11 @@ printf("Adding area\n");
   switch (sym->type)
   {
     case SYMBOLIZER_ICON:
+      printf("DEBUG: Icon label\n");
       make_bitmap_icon(v, (struct sym_icon *) sym);
       break;
     case SYMBOLIZER_TEXT:
+      printf("DEBUG: Text label\n");
       make_bitmap_label(v, (struct sym_text *) sym);
     default:
       // FIXME
@@ -272,14 +341,14 @@ void make_graph(void)
       e->id = buffer_line[i].line->s.o->id;
       e->color = buffer_line[i].line->color;
       e->length = hypot(abs(o_prev->x - o_node->x), abs(o_prev->y - o_node->y));
-      e->visited = 0;
+      e->visited = -1;
       e->prev = NULL;
       e->next = NULL;
       e->n1 = g_prev;
       e->n2 = g_node;
       e->longline = (uns) -1;
       e->line = buffer_line[i].line;
-      e->dir = 0;
+      e->dir = DIR_UNSET;
       e->label = NULL;
 
       struct graph_edge **edge = GARY_PUSH(g_prev->edges);
@@ -291,6 +360,8 @@ void make_graph(void)
       o_prev = o_node;
     }
   }
+
+  printf("Made graph with %d edges\n", num_edges_dbg);
 }
 
 void dump_graph(void)
@@ -470,7 +541,7 @@ void bfs2(void)
 * }
 * ***/
 
-void bfs_edge(struct graph_edge *e, struct graph_node *node, struct graph_node *anode, int dir)
+void bfs_edge(struct graph_edge *e, struct graph_node *node, struct graph_node *anode, enum edge_dir dir)
 {
   ASSERT(dir < 3);
   struct graph_edge *candidate = NULL;
@@ -532,6 +603,72 @@ dbg_num_hits++;
   }
 }
 
+void ya_bfs_edge(struct graph_edge *e, struct graph_node *node, struct graph_node *anode, enum edge_dir dir)
+{
+printf("BFS edge called for edge %d (going %d) in direction %d\n", e->num, e->dir, dir);
+  struct graph_edge *candidate = NULL;
+
+  for (uns i=0; i<GARY_SIZE(node->edges); i++)
+  {
+    struct graph_edge *other = node->edges[i];
+if (e->num == 987) printf("Got label %d\n", e->num);
+    if ((other->longline != (uns) -1) && (other->longline != e->longline)) continue;
+if (e->num == 987) printf("Continuing with edge %d\n", e->num);
+
+printf("Testing %d ?= %d\n", other->visited, e->longline);
+    if (other->visited != e->longline) {
+    printf("Pushing new edge %d / %ju\n", other->num, other->id);
+    struct graph_edge **e_ptr = GARY_PUSH(bfs_queue);
+    *e_ptr = other;
+    other->visited = e->longline;
+    }
+
+    if (((other->n1->id == node->id) && (other->n2->id == anode->id)) ||
+        ((other->n2->id == node->id) && (other->n1->id == anode->id)))
+        continue;
+
+    if (((other->n1->id == node->id) || (other->n2->id == node->id)) &&
+        (e->label) && (other->label) &&
+        (e->label->type == SYMBOLIZER_TEXT) && (other->label->type == SYMBOLIZER_TEXT) &&
+        (((struct sym_text *) e->label)->text == ((struct sym_text *) other->label)->text))
+    {
+      if (! candidate || (other->length > candidate->length))
+      candidate = other;
+    }
+  }
+
+  if (candidate)
+  {
+printf("New line in longline %u\n", e->longline);
+    struct graph_edge *other = candidate;
+      other->longline = e->longline;
+      other->dir = dir;
+      if (((dir == DIR_BWD) && (other->n1->id == node->id)) ||
+          ((dir == DIR_FWD) && (other->n2->id == node->id)))
+      {
+        struct graph_node *swp = other->n2;
+        other->n2 = other->n1;
+        other->n1 = swp;
+      }
+
+      switch (dir)
+      {
+        case DIR_BWD:
+          e->prev = other;
+          other->next = e;
+          longlines[other->longline].first = other;
+          break;
+        case DIR_FWD:
+          e->next = other;
+          other->prev = e;
+          break;
+        default:
+          printf("Oops\n");
+          ASSERT(0);
+      }
+  }
+}
+
 void bfs(void)
 {
   for (uns i=0; i<GARY_SIZE(bfs_queue); i++)
@@ -560,6 +697,45 @@ void bfs(void)
   }
 }
 
+void ya_bfs(uns longline)
+{
+printf("BFS called for longline %u\n", longline);
+printf("%d longlines are believed to exist, %d exist\n", num_longlines, GARY_SIZE(longlines));
+  for (uns i=0; i<GARY_SIZE(bfs_queue); i++)
+  {
+    struct graph_edge *cur = bfs_queue[i];
+    printf("Exploring new edge %d; %d remaining\n", cur->num, GARY_SIZE(bfs_queue));
+    //ASSERT(! cur->visited);
+
+    cur->visited = longline;
+
+    if (cur->longline == (uns) -1)
+      continue;
+
+    if (cur->dir == DIR_UNSET)
+    {
+      cur->dir = DIR_CENTER;
+      ya_bfs_edge(cur, cur->n1, cur->n2, DIR_BWD);
+      ya_bfs_edge(cur, cur->n2, cur->n1, DIR_FWD);
+    }
+    else
+    {
+      switch (cur->dir)
+      {
+        case DIR_BWD:
+          ya_bfs_edge(cur, cur->n1, cur->n2, cur->dir);
+          break;
+        case DIR_FWD:
+          ya_bfs_edge(cur, cur->n2, cur->n1, cur->dir);
+          break;
+        default:
+          // FIXME
+          ;
+      }
+    }
+  }
+}
+
 void bfs_wrapper(void)
 {
   GARY_INIT(bfs_queue, 0);
@@ -587,6 +763,38 @@ void bfs_wrapper(void)
   GARY_FREE(bfs_queue);
 }
 
+void ya_bfs_wrapper(void)
+{
+  GARY_INIT(bfs_queue, 0);
+  GARY_INIT(longlines, 0);
+
+  HASH_FOR_ALL(hash, node)
+  {
+    for (uns i=0; i<GARY_SIZE(node->edges); i++)
+    {
+      if ((node->edges[i]->label) && (node->edges[i]->longline == (uns) -1))
+      {
+        GARY_PUSH(longlines);
+        longlines[num_longlines].first = node->edges[i];
+        printf("Running new BFS\n");
+        printf("Creating longline %u\n", num_longlines);
+        GARY_RESIZE(bfs_queue, 0);
+        struct graph_edge **e = GARY_PUSH(bfs_queue);
+        *e = node->edges[i];
+        node->edges[i]->longline = num_longlines;
+        ya_bfs(node->edges[i]->longline);
+        //dump_longlines();
+        printf("Joined %d edges\n", dbg_num_hits); dbg_num_hits = 0;
+        printf("Planned %u edges\n", GARY_SIZE(bfs_queue));
+        num_longlines++;
+      }
+    }
+  }
+  HASH_END_FOR;
+
+  GARY_FREE(bfs_queue);
+}
+
 /***
 * void oldbfs(void)
 * {
@@ -644,6 +852,27 @@ void bfs_wrapper(void)
 * ***/
 
 void dump_longlines(void)
+{
+printf("*** Longlines dump\n");
+  for (uns i=0; i<GARY_SIZE(longlines); i++)
+  {
+printf("Longline %u:", i);
+    struct graph_edge *e = longlines[i].first;
+if ((e->label) && (e->label->type == SYMBOLIZER_TEXT))
+  printf(" labelled %s", osm_val_decode(((struct sym_text *) e->label)->text));
+printf("\n");
+
+    while (e)
+    {
+      printf("\t#%ju (%d): [%.2f; %.2f] -- [%.2f; %.2f] (dir %d)\n",
+             e->id, e->num, e->n1->o->x, e->n1->o->y, e->n2->o->x, e->n2->o->y, e->dir);
+
+      e = e->next;
+    }
+  }
+}
+
+void dump_longlines_old(void)
 {
   for (uns i=0; i<GARY_SIZE(longlines); i++)
   {
@@ -657,13 +886,13 @@ void dump_longlines(void)
       printf("\t#%ju (%d)", e->id, e->num);
       switch (e->dir)
       {
-      case 1:
+      case DIR_BWD:
 	printf("[%.2f; %.2f] -- #%ju [%.2f; %.2f] (dir %d)\n", e->anode->o->x, e->anode->o->y, e->bnode->o->o.id, e->bnode->o->x, e->bnode->o->y, e->dir);
 	break;
-      case 2:
+      case DIR_FWD:
 	printf("[%.2f; %.2f] -- #%ju [%.2f; %.2f] (dir %d)\n", e->bnode->o->x, e->bnode->o->y, e->anode->o->o.id, e->anode->o->x, e->anode->o->y, e->dir);
 	break;
-      case 0:
+      case DIR_CENTER:
 	printf("[%.2f; %.2f] -- #%ju [%.2f; %.2f] (dir %d)\n", e->n1->o->x, e->n1->o->y, e->n2->o->o.id, e->n2->o->x, e->n2->o->y, e->dir);
 	break;
       default:
@@ -675,6 +904,89 @@ void dump_longlines(void)
   }
 }
 
+void make_segments_new(void)
+{
+  for (uns i=0; i<GARY_SIZE(longlines); i++)
+  {
+    // Skip lines which are not labelled
+    if (! (longlines[i].first && longlines[i].first->label))
+      continue;
+
+    struct request_line *request = GARY_PUSH(requests_line);
+    request->request.ind = -1;
+    request->request.type = REQUEST_LINE;
+
+    GARY_INIT(request->sections, 0);
+
+    int cur_length = 0;
+    struct request_section *rls = GARY_PUSH(request->sections);
+    rls->request.ind = num_requests++;
+    rls->request.type = REQUEST_SECTION;
+    rls->num_segments = 0;
+    GARY_INIT(rls->segments, 0);
+
+    struct graph_edge *e = longlines[i].first;
+    struct request_segment *rs = NULL;
+
+    struct sym_text *st = NULL;
+    if (e->label->type == SYMBOLIZER_TEXT)
+    {
+      st = (struct sym_text *) e->label;
+    }
+    else
+    {
+      continue;
+      // FIXME;
+    }
+
+    while (e)
+    {
+      if ((cur_length + e->length > conf_max_section_length) &&
+          !(cur_length + e->length < conf_max_section_overlay))
+      {
+        struct osm_node *n = e->n1->o;
+
+        rs = GARY_PUSH(rls->segments);
+        rls->num_segments++;
+        rs->x1 = n->x;
+        rs->y1 = n->y;
+        // FIXME: Truly compute x2, y2
+        rs->x2 = n->x;
+        rs->y2 = n->y;
+
+        rls = GARY_PUSH(request->sections);
+        rls->request.ind = num_requests++;
+        rls->request.type = REQUEST_SECTION;
+        rls->num_segments = 0;
+        GARY_INIT(rls->segments, 0);
+      }
+
+      if (e->length < st->tw)
+      {
+        e = e->next;
+        continue;
+      }
+
+      rs = GARY_PUSH(rls->segments);
+      rls->num_segments++;
+      rs->request.type = REQUEST_SEGMENT;
+      rs->request.ind = num_requests++;
+      rs->label = e->label;
+
+      rs->x1 = e->n1->o->x;
+      rs->y1 = e->n1->o->y;
+      rs->x2 = e->n2->o->x;
+      rs->y2 = e->n2->o->y;
+
+      rs->zindex = e->zindex;
+
+      cur_length += e->length;
+
+      e = e->next;
+    }
+  }
+}
+
 void make_segments(void)
 {
 printf("Analysing %u longlines\n", GARY_SIZE(longlines));
@@ -706,6 +1018,7 @@ if (longlines[i].first->label->type != SYMBOLIZER_TEXT)
     while (e)
     {
       if (! e->label) break;
+
       struct request_segment *r = GARY_PUSH(request->segments);
       request->num_segments++;
 
@@ -766,6 +1079,65 @@ void dump_linelabel_requests(void)
   }
 }
 
+void dump_bitmaps(struct individual *individual)
+{
+  bool *bitmap = malloc(page_width_int * page_height_int * sizeof(bool));
+  printf("Bitmap size is %d\n", page_width_int * page_height_int);
+  for (int i=0; i<page_height_int; i++)
+    for (int j=0; j<page_width_int; j++)
+      bitmap[i*page_width_int + j] = 0;
+
+  for (uns i=0; i<GARY_SIZE(individual->placements); i++)
+  {
+    struct placement *p = &(individual->placements[i]);
+    struct point_variant *v = NULL;
+
+    switch (p->request->type)
+    {
+      case REQUEST_SEGMENT: ;
+        struct request_segment *rs = (struct request_segment *) p->request;
+        v = rs->variant;
+        break;
+      case REQUEST_POINT: ;
+        struct request_point *rp = (struct request_point *) p->request;
+        v = &(rp->variants[p->variant_used]);
+        break;
+      case REQUEST_AREA: ;
+        struct request_area *ra = (struct request_area *) p->request;
+        printf("Using %d-th of %d variants\n", p->variant_used, GARY_SIZE(ra->variants));
+        v = &(ra->variants[p->variant_used]);
+        break;
+      default:
+        ASSERT(p->request->type != REQUEST_INVALID);
+        continue;
+    }
+
+    printf("Rendering %d-th label %d x %d (w x h)\n", i, v->width, v->height);
+    for (int row = max2(p->y, 0); row < min2(p->y + v->height, page_height_int); row++)
+    {
+      for (int col = max2(p->x, 0); col < min2(p->x + v->width, page_width_int); col++)
+      {
+        printf("Writing to %d\n", row*page_width_int + col);
+        bitmap[row * page_width_int + col] = 1;
+      }
+    }
+  }
+
+  errno = 0;
+  FILE *fd_dump = fopen("dump.pbm", "w");
+  fprintf(fd_dump, "P1\n");
+  fprintf(fd_dump, "%d %d\n", page_width_int, page_height_int);
+  for (int i=0; i<page_height_int; i++)
+  {
+    for (int j=0; j<page_width_int; j++)
+    {
+      fprintf(fd_dump, "%d", bitmap[(int) (i*page_width_int + j)] ? 1 : 0);
+    }
+    fprintf(fd_dump, "\n");
+  }
+  fclose(fd_dump);
+}
+
 void dump_individual(struct individual *individual)
 {
 printf("(There are %d requests)\n", num_requests);
@@ -776,19 +1148,20 @@ printf("(There are %d requests)\n", num_requests);
     switch (p->request->type)
     {
       case REQUEST_POINT:
-        printf("Point at [%.2f; %.2f]\n", p->x, p->y);
+        printf("Point at [%.2f; %.2f] on %u\n", p->x, p->y, ((struct request_point *) p->request)->zindex);
         break;
       case REQUEST_LINE: ;
         struct request_line *rl = (struct request_line *) p->request;
         print_label(rl->segments[0].label);
         break;
       case REQUEST_SEGMENT: ;
+        printf("Segment placed at [%.2f; %.2f] on %u\n", p->x, p->y, ((struct request_segment *) p->request)->zindex);
         break;
       case REQUEST_AREA: ;
         struct request_area *ra = (struct request_area *) p->request;
         printf("Area label ");
         print_label(ra->label);
-        printf(" at [%.2f; %.2f]\n", p->x, p->y);
+        printf(" at [%.2f; %.2f] on %u\n", p->x, p->y, ((struct request_area *) p->request)->zindex);
         break;
       default:
         ASSERT(p->request->type != 0);
@@ -802,10 +1175,10 @@ void labeller_label(void)
   make_graph();
   label_graph();
 dump_graph();
-  bfs_wrapper();
+  ya_bfs_wrapper();
 dump_longlines();
-  make_segments();
-dump_linelabel_requests();
+  make_segments_new();
+//dump_linelabel_requests();
 
 printf("Having %u point requests, %u line requests and %u area requests\n", GARY_SIZE(requests_point), GARY_SIZE(requests_line), GARY_SIZE(requests_area));
 
@@ -828,10 +1201,71 @@ printf("Having %u point requests, %u line requests and %u area requests\n", GARY
 */
 
   dump_individual(population1[0]);
+dump_bitmaps(population1[0]);
 
   for (uns i=0; i<GARY_SIZE(population1[0]->placements); i++)
   {
 printf("Coping with %d\n", population1[0]->placements[i].request->type);
+
+    struct symbol *s = NULL;
+    z_index_t zindex = 0;
+    switch (population1[0]->placements[i].request->type)
+    {
+      case REQUEST_POINT: ;
+        struct request_point *rp = (struct request_point *) population1[0]->placements[i].request;
+        s = rp->sym;
+        zindex = rp->zindex;
+        printf("%u\n", zindex);
+        break;
+      case REQUEST_SEGMENT: ;
+        struct request_segment *rs = (struct request_segment *) population1[0]->placements[i].request;
+        s = rs->label;
+        printf("Assigned label to s\n");
+        zindex = rs->zindex;
+        printf("%u\n", zindex);
+        break;
+      case REQUEST_AREA: ;
+        struct request_area *ra = (struct request_area *) population1[0]->placements[i].request;
+        s = ra->label;
+        zindex = ra->zindex;
+        printf("%u\n", zindex);
+        break;
+      default:
+        ASSERT(population1[0]->placements[i].request != REQUEST_INVALID);
+        printf("Yep, in default, continuing\n");
+        continue;
+    }
+
+printf("Will plan symbol on %u\n", zindex);
+
+    switch (s->type)
+    {
+      case SYMBOLIZER_POINT: ;
+        struct sym_point *sp = (struct sym_point *) s;
+        sp->x = population1[0]->placements[i].x;
+        sp->y = population1[0]->placements[i].y;
+        sym_plan((struct symbol *) sp, zindex);
+        break;
+      case SYMBOLIZER_ICON: ;
+	struct sym_icon *si = (struct sym_icon *) s;
+	si->sir.x = population1[0]->placements[i].x;
+	si->sir.y = population1[0]->placements[i].y;
+        sym_plan((struct symbol *) si, zindex);
+	break;
+      case SYMBOLIZER_TEXT: ;
+        struct sym_text *st = (struct sym_text *) s;
+        st->x = population1[0]->placements[i].x;
+        st->y = population1[0]->placements[i].y;
+        st->next_duplicate = NULL;
+        sym_plan((struct symbol *) st, zindex);
+        break;
+      default:
+        ASSERT(s->type != SYMBOLIZER_INVALID);
+    }
+
+
+
+/***
     switch (population1[0]->placements[i].request->type)
     {
       case REQUEST_POINT: ;
@@ -859,6 +1293,18 @@ printf("Coping with %d\n", population1[0]->placements[i].request->type);
         break;
       case REQUEST_AREA: ;
         struct request_area *ra = (struct request_area *) population1[0]->placements[i].request;
+        switch (ra->label->type)
+        {
+          case SYMBOLIZER_ICON
+          case SYMBOLIZER_TEXT: ;
+            struct sym_text *st = (struct sym_text *) ra->label;
+            st->x = population1[0]->placements[i].x;
+            st->y = population1[0]->placements[i].y;
+            break;
+          default:
+            // FIXME
+            ;
+        }
         if (ra->label->type == SYMBOLIZER_INVALID) printf("Haúúú 2\n");
         sym_plan((struct symbol *) ra->label, ra->zindex);
         break;
@@ -890,6 +1336,8 @@ printf("Coping with %d\n", population1[0]->placements[i].request->type);
     default:
       ASSERT(population1[0]->placements[i].request->type != REQUEST_INVALID);
     }
+***/
+
   }
 
   return;
@@ -917,6 +1365,7 @@ void make_population(void)
 {
   for (int i=0; i<conf_pop_size; i++)
   {
+    printf("Making individual %d\n", i);
     struct individual *individual = ep_alloc(ep_individuals); init_individual(individual);
     population1[i] = individual;
 
@@ -1100,18 +1549,50 @@ void gen_coords(struct placement *p)
   {
     case REQUEST_POINT:
       gen_coords_point(p);
-    case REQUEST_LINE:
-    case REQUEST_SEGMENT:
+      break;
     case REQUEST_AREA:
+      gen_coords_area(p);
+      break;
+    case REQUEST_SEGMENT:
+      gen_coords_segment(p);
+      break;
+    case REQUEST_LINE:
       printf("Not yet implemented\n");
+      break;
     default:
       ASSERT(p->request->type != REQUEST_INVALID);
   }
 }
 
-void gen_coords_point(struct placement *p UNUSED)
+double gen_movement(void)
 {
-  // FIXME
+  double m = (random() % 1000000) / 10000;
+  m = pow(m, 1.0/3) * flip(1, -1);
+  printf("Movement %.2f\n", m);
+  return m;
+}
+
+void gen_coords_point(struct placement *p)
+{
+  p->x = p->x + gen_movement();
+}
+
+void gen_coords_segment(struct placement *p)
+{
+  struct request_segment *rs = (struct request_segment *) p->request;
+  int a = flip(1, 2);
+  p->x = (a == 1 ? rs->x1 : rs->x2);
+  p->y = (a == 1 ? rs->y1 : rs->y2);
+}
+
+void gen_coords_area(struct placement *p)
+{
+  struct request_area *ra = (struct request_area *) p->request;
+
+  p->x = p->x + gen_movement();
+  p->y = p->y + gen_movement();
+
+  printf("Moved label to [%.2f; %.2f] from [%.2f; %.2f]\n", p->x, p->y, ra->cx, ra->cy);
 }
 
 struct map_part **get_parts(struct placement *symbol, struct individual *individual)
@@ -1207,6 +1688,7 @@ void init_placement(struct placement *p, struct request *r)
   // FIXME
   p->request = r;
   p->processed = 0;
+  p->x = p->y = 0; // To prevent valgrind from complaining
   switch (r->type)
   {
     case REQUEST_POINT: ;
@@ -1216,6 +1698,10 @@ void init_placement(struct placement *p, struct request *r)
       break;
     case REQUEST_LINE: ;
       break;
+    case REQUEST_SECTION: ;
+      struct request_section *rls = (struct request_section *) r;
+      p->variant_used = randint(0, rls->num_segments);
+      break;
     case REQUEST_SEGMENT: ;
       struct request_segment *rs = (struct request_segment *) r;
       p->x = rs->x2;
@@ -1225,10 +1711,15 @@ void init_placement(struct placement *p, struct request *r)
       struct request_area *ra = (struct request_area *) r;
       p->x = ra->cx;
       p->y = ra->cy;
+      p->variant_used = 0;
+      break;
     default:
       ASSERT(p->request->type != REQUEST_INVALID);
+      printf("Valid request: %d\n", p->request->type);
+      ASSERT(0);
   }
 
+  gen_coords(p);
   printf("Inited placement to [%.2f; %.2f]\n", p->x, p->y);
 }
 
diff --git a/labeller.h b/labeller.h
index cf30b0e..d6dfa27 100644
--- a/labeller.h
+++ b/labeller.h
@@ -1,12 +1,22 @@
 #ifndef _LEO_LABELLER_H
 #define _LEO_LABELLER_H
 
+enum edge_dir
+{
+  DIR_INVALID,
+  DIR_UNSET,
+  DIR_CENTER,
+  DIR_FWD,
+  DIR_BWD,
+};
+
 enum request_type
 {
   REQUEST_INVALID,
   REQUEST_POINT,
   REQUEST_AREA,
   REQUEST_LINE,
+  REQUEST_SECTION,
   REQUEST_SEGMENT,
 };
 
@@ -19,8 +29,8 @@ enum term_cond
 
 struct point_variant
 {
-  double width;
-  double height;
+  int width;
+  int height;
   bool *bitmap;
 };
 
@@ -51,17 +61,23 @@ struct request_point
 struct request_segment
 {
   struct request request;
+  struct request_line *rl;
   double x1;
   double y1;
   double x2;
   double y2;
-  double k;
-  struct sym_line *sym;
   struct symbol *label;
   struct point_variant *variant;
   z_index_t zindex;
 };
 
+struct request_section
+{
+  struct request request;
+  int num_segments;
+  struct request_segment *segments;
+};
+
 struct request_line
 {
   struct request request;
@@ -70,6 +86,7 @@ struct request_line
   int num_segments;
   struct line_variant *variants;
   struct request_segment *segments;
+  struct request_section *sections;
 };
 
 struct request_area
@@ -108,7 +125,7 @@ struct graph_edge
   osm_id_t id;
   double length;
   color_t color;
-  bool visited;
+  int visited;
   struct graph_edge *prev;
   struct graph_edge *next;
   struct graph_node *n1;
@@ -117,7 +134,7 @@ struct graph_edge
   struct symbol *label;
   struct sym_line *line;
   z_index_t zindex;
-  int dir;
+  enum edge_dir dir;
   struct graph_node *anode;
   struct graph_node *bnode; // DEBUG PRINT
   int num; // DEBUG
@@ -178,8 +195,6 @@ void perform_mutation(struct individual *individual);
 
 void init_placement(struct placement *p, struct request *r);
 void init_individual(struct individual *i);
-void gen_coords_point(struct placement *p);
-void gen_coords(struct placement *p);
 struct map_part **get_parts(struct placement *symbol, struct individual *individual);
 
 int randint(int min, int max);