X-Git-Url: http://mj.ucw.cz/gitweb/?a=blobdiff_plain;f=labeller.c;h=0942f073d826788166d232f13ae4842e19176e5e;hb=21017820e79722500c429cabda7f7c3a74259cd1;hp=ee740ba8451558ba49a019493d5c6a15340c83ee;hpb=6a7eb18eb0f3cb8a6a26edf9cf63e949afbd744e;p=leo.git

diff --git a/labeller.c b/labeller.c
index ee740ba..0942f07 100644
--- a/labeller.c
+++ b/labeller.c
@@ -41,6 +41,9 @@ struct eltpool *ep_individuals;
 struct individual **population1;
 struct individual **population2;
 
+int dbg_segments = 0;
+int dbg_plan = 0;
+
 int page_width_int;
 int page_height_int;
 
@@ -99,12 +102,14 @@ void breed(void);
 void mutate(void);
 void elite(void);
 void rank_population(void);
+void plan_individual(struct individual *individual);
 
 void make_bitmap(struct point_variant *v, struct symbol *sym);
 void make_bitmap_icon(struct point_variant *v, struct sym_icon *si);
 void make_bitmap_point(struct point_variant *v, struct sym_point *sp);
 void make_bitmap_label(struct point_variant *v, struct sym_text *text);
 
+void cut_edge(struct graph_edge *e, double dist);
 struct request_line *make_new_line(void);
 struct request_section *make_new_section(struct request_line *rl);
 struct request_segment *make_new_segment(struct request_section *rls, struct symbol *sym);
@@ -133,7 +138,8 @@ void labeller_cleanup(void);
 struct individual **perform_crossover(struct individual *parent1, struct individual *parent2);
 void perform_mutation(struct individual *individual);
 
-void init_placement(struct placement *p, struct request *r);
+void hide_segment_labels(struct individual *individual);
+void init_placement(struct placement *p, struct individual *individual, struct request *r);
 void init_individual(struct individual *i);
 struct map_part **get_parts(struct placement *symbol, struct individual *individual);
 
@@ -241,28 +247,13 @@ void make_bitmap_point(struct point_variant *v, struct sym_point *sp)
 
 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);
     }
 }
 
@@ -686,6 +677,39 @@ struct request_segment *make_new_segment(struct request_section *rls, struct sym
   return rs;
 }
 
+void cut_edge(struct graph_edge *e, double dist)
+{
+  if (dbg_segments)
+    printf("Cutting [%.2f; %.2f] -- [%.2f; %.2f] to dist %.2f\n", e->n1->o->x, e->n1->o->y, e->n2->o->x, e->n2->o->y, dist);
+
+  struct graph_edge *new = malloc(sizeof(struct graph_edge));
+  *new = *e;
+  e->next = new;
+
+  struct osm_node *n1 = e->n1->o;
+  struct osm_node *n2 = e->n2->o;
+
+  // FIXME
+  if ((n1->x == n2->x) && (n1->y == n2->y))
+  {
+    printf("[%.2f; %.2f] -- [%.2f; %.2f]\n", n1->x, n1->y, n2->x, n2->y);
+    printf("Won't cut point\n");
+    return;
+  }
+
+  struct osm_node *n11 = malloc(sizeof(struct osm_node));
+  struct graph_node *gn = malloc(sizeof(struct graph_node));
+  gn->o = n11;
+  double vsize = sqrt(pow(n1->x - n2->x, 2) + pow(n1->y - n2->y, 2));
+  n11->x = n1->x + (n2->x - n1->x) / vsize * dist;
+  n11->y = n1->y + (n2->y - n1->y) / vsize * dist;
+
+  e->n2 = new->n1 = gn;
+
+  e->length = hypot(abs(n1->x - n11->x), abs(n1->y - n11->y));
+  new->length = hypot(abs(n11->x - n2->x), abs(n11->y - n2->y));
+}
+
 void make_segments(void)
 {
   for (uns i=0; i<GARY_SIZE(longlines); i++)
@@ -699,7 +723,7 @@ void make_segments(void)
     struct request_segment *rs = NULL;
 
     struct graph_edge *e = longlines[i].first;
-    int cur_length = 0;
+    double cur_length = 0;
 
     struct sym_text *st = NULL;
     if (e->label->type == SYMBOLIZER_TEXT)
@@ -713,26 +737,34 @@ void make_segments(void)
       // FIXME;
     }
 
+    printf("New longline\n");
     while (e)
     {
-      if ((cur_length + e->length > conf_max_section_length) &&
-          !(cur_length + e->length < conf_max_section_overlay))
+      if (cur_length + e->length > conf_max_section_length + conf_max_section_overlay)
       {
-        printf("Making new section, new length would be %f, allowed is %.2f / %.2f\n", cur_length + e->length, conf_max_section_length, conf_max_section_overlay);
-        struct osm_node *n = e->n1->o;
+        if (dbg_segments)
+          printf("Edge too long, length is %.2f; %.2f - %.2f = %.2f\n", e->length, conf_max_section_length, cur_length, conf_max_section_length - cur_length);
+        cut_edge(e, conf_max_section_length - cur_length);
+      }
 
+      if (cur_length + e->length > conf_max_section_length)
+      {
+        if (dbg_segments)
+          printf("Making new section, new length would be %f, allowed is %.2f / %.2f\n", cur_length + e->length, conf_max_section_length, conf_max_section_overlay);
+
+        struct osm_node *n1 = e->n1->o;
+        struct osm_node *n2 = e->n2->o;
         rs = make_new_segment(rls, e->label);
-        rs->x1 = n->x;
-        rs->y1 = n->y;
-        // FIXME: Truly compute x2, y2
-        rs->x2 = n->x;
-        rs->y2 = n->y;
+        rs->x1 = n1->x;
+        rs->y1 = n1->y;
+        rs->x2 = n2->x;
+        rs->y2 = n2->y;
         rs->zindex = e->zindex;
 
         rs->label = malloc(sizeof(struct sym_text));
         *((struct sym_text *) rs->label) = *((struct sym_text *) e->label);
-
         rls = make_new_section(request);
+        cur_length = 0;
       }
 
       if (st && (e->length < st->tw))
@@ -751,6 +783,7 @@ void make_segments(void)
       rs->x2 = e->n2->o->x;
       rs->y2 = e->n2->o->y;
 
+      // FIXME: Set text rotation
       rs->angle = atan2(rs->x2 - rs->x1, rs->y2 - rs->y1);
       rs->zindex = e->zindex;
 
@@ -896,107 +929,104 @@ printf("(There are %d requests)\n", num_requests);
   printf("\nTotal penalty: %d\n", individual->penalty);
 }
 
-void labeller_label(void)
+void plan_individual(struct individual *individual)
 {
-  make_graph();
-  label_graph();
-//dump_graph();
-  bfs_wrapper();
-//dump_longlines();
-  make_segments();
-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));
-
-  GARY_INIT(population1, conf_pop_size);
-  GARY_INIT(population2, conf_pop_size);
-  make_population();
-
-  printf("Dealing with %d requests\n", num_requests);
-
-/*
-  while (! shall_terminate())
-  {
-    iteration++;
-
-    struct individual **swp = population1;
-    population1 = population2;
-    population2 = swp;
-    pop2_ind = 0;
-  }
-*/
-
-  dump_individual(population1[0]);
-//dump_bitmaps(population1[0]);
-
-  for (uns i=0; i<GARY_SIZE(population1[0]->placements); i++)
+  for (uns i=0; i<GARY_SIZE(individual->placements); i++)
   {
-//printf("(%d) Coping with %d\n", i, population1[0]->placements[i].request->type);
-
     struct symbol *s = NULL;
     z_index_t zindex = 0;
-    switch (population1[0]->placements[i].request->type)
+    if (individual->placements[i].variant_used < 0) continue;
+    switch (individual->placements[i].request->type)
     {
       case REQUEST_POINT: ;
-        struct request_point *rp = (struct request_point *) population1[0]->placements[i].request;
+        struct request_point *rp = (struct request_point *) individual->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;
+        struct request_segment *rs = (struct request_segment *) individual->placements[i].request;
         s = rs->label;
-//        printf("Assigned label to s\n");
-//        print_label(s);
         zindex = rs->zindex;
-//        printf("%u\n", zindex);
         break;
       case REQUEST_LINE: ;
-//        printf("*** Line detected ***\n");
         break;
       case REQUEST_AREA: ;
-        struct request_area *ra = (struct request_area *) population1[0]->placements[i].request;
+        struct request_area *ra = (struct request_area *) individual->placements[i].request;
         s = ra->label;
         zindex = ra->zindex;
-//        printf("%u\n", zindex);
         break;
       default:
-//        printf("Testing request type (flushing final placements)\n");
-        ASSERT(population1[0]->placements[i].request != REQUEST_INVALID);
-//        printf("Yep, in default, continuing\n");
+        ASSERT(individual->placements[i].request != REQUEST_INVALID);
         continue;
     }
 
-printf("Will plan symbol at [%.2f; %.2f] on %u\n", population1[0]->placements[i].x, population1[0]->placements[i].y, zindex);
+if (dbg_plan)
+  printf("Will plan symbol at [%.2f; %.2f] on %u\n", individual->placements[i].x, individual->placements[i].y, zindex);
 
     if (s) 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;
+        sp->x = individual->placements[i].x;
+        sp->y = individual->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;
+	si->sir.x = individual->placements[i].x;
+	si->sir.y = individual->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->x = individual->placements[i].x;
+        st->y = individual->placements[i].y;
         st->next_duplicate = NULL;
-        printf("Planning text %s at [%.2f; %.2f] on %u\n", osm_val_decode(st->text), st->x, st->y, zindex);
+        if (dbg_plan) printf("Planning text %s at [%.2f; %.2f] on %u, with rotation %.2f\n", osm_val_decode(st->text), st->x, st->y, zindex, st->rotate);
         sym_plan((struct symbol *) st, zindex);
         break;
       default:
-//        printf("Testing symbolizer type\n");
         ASSERT(s->type != SYMBOLIZER_INVALID);
     }
   }
 
+}
+
+void labeller_label(void)
+{
+  make_graph();
+  label_graph();
+//dump_graph();
+  bfs_wrapper();
+//dump_longlines();
+  make_segments();
+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));
+
+  GARY_INIT(population1, conf_pop_size);
+  GARY_INIT(population2, conf_pop_size);
+  make_population();
+
+  printf("Dealing with %d requests\n", num_requests);
+
+/*
+  while (! shall_terminate())
+  {
+    iteration++;
+
+    struct individual **swp = population1;
+    population1 = population2;
+    population2 = swp;
+    pop2_ind = 0;
+  }
+*/
+
+  dump_individual(population1[0]);
+//dump_bitmaps(population1[0]);
+
+  plan_individual(population1[0]);
+
   labeller_cleanup();
 
   return;
@@ -1017,29 +1047,31 @@ void make_population(void)
     int p = 0;
     for (uns j=0; j<GARY_SIZE(requests_point); j++)
     {
-      init_placement(&(individual->placements[p++]), (struct request *) &requests_point[j]);
+      init_placement(&(individual->placements[p++]), individual, (struct request *) &requests_point[j]);
     }
 
     for (uns j=0; j<GARY_SIZE(requests_line); j++)
     {
-      init_placement(&(individual->placements[p++]), (struct request *) &requests_line[j]);
+      init_placement(&(individual->placements[p++]), individual, (struct request *) &requests_line[j]);
 
       for (uns k=0; k<GARY_SIZE(requests_line[j].sections); k++)
       {
-        init_placement(&(individual->placements[p++]), (struct request *) &requests_line[j].sections[k]);
+        init_placement(&(individual->placements[p++]), individual, (struct request *) &requests_line[j].sections[k]);
 
         for (uns l=0; l<GARY_SIZE(requests_line[j].sections[k].segments); l++)
         {
-          init_placement(&(individual->placements[p++]), (struct request *) &requests_line[j].sections[k].segments[l]);
+          init_placement(&(individual->placements[p++]), individual, (struct request *) &requests_line[j].sections[k].segments[l]);
         }
       }
     }
 
     for (uns j=0; j<GARY_SIZE(requests_area); j++)
     {
-      init_placement(&(individual->placements[p++]), (struct request *) &requests_area[j]);
+      init_placement(&(individual->placements[p++]), individual, (struct request *) &requests_area[j]);
     }
 
+    hide_segment_labels(individual);
+
 if (p != num_requests)
 {
   printf("Say bye\n");
@@ -1345,13 +1377,40 @@ void move_symbol_point(struct placement *p)
   p->y += (double) (move_min + randdouble()) * flip(1, -1);
 }
 
-void init_placement(struct placement *p, struct request *r)
+void hide_segment_labels(struct individual *individual)
+{
+  // BEWARE: This fully depends on current genetic encoding
+
+  int used = -1, num = -1;
+  for (uns i=0; i<GARY_SIZE(individual->placements); i++)
+  {
+    switch (individual->placements[i].request->type)
+    {
+      case REQUEST_SECTION:
+        used = individual->placements[i].variant_used;
+        num = 0;
+        break;
+      case REQUEST_SEGMENT:
+        if (num == used)
+          individual->placements[i].variant_used = 0;
+        else
+          individual->placements[i].variant_used = -1;
+        num++;
+        break;
+      default:
+        ;
+    }
+  }
+}
+
+void init_placement(struct placement *p, struct individual *individual, struct request *r)
 {
   // FIXME
   p->request = r;
   p->processed = 0;
   p->x = p->y = 0; // To prevent valgrind from complaining
   p->variant_used = 0;
+  p->individual = individual;
   switch (r->type)
   {
     case REQUEST_POINT: ;