Labeller: Backup before bisect

diff --git a/labeller.c b/labeller.c
index a0ba5c2307f0b7e48c71b8b1879e358afd19e56d..e8e423b0c0b6de0c81148609f478c41ace62e6b3 100644 (file)
--- a/labeller.c
+++ b/labeller.c
@@ -73,7 +73,7 @@ int conf_mutate_chvar_bound = 0.1;
 
 int conf_elite_perc = 5;
 
-double conf_max_section_length = 10;
+double conf_max_section_length = 100;
 double conf_max_section_overlay = 10;
 
 int old_best = 0; // FIXME: Shall be int max
@@ -190,12 +190,12 @@ void make_bitmap_label(struct point_variant *v, struct sym_text *text)
   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);
+//  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);
+//      printf("Writing at %d\n", i*v->width + j);
     }
 }
 
@@ -246,7 +246,7 @@ printf("Adding point\n");
       return;
   }
 
-  printf("Inited point to [%.2f; %.2f] on %u\n", r->x, r->y, r->zindex);
+//  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)
@@ -591,6 +591,8 @@ void make_segments(void)
     if (! (longlines[i].first && longlines[i].first->label))
       continue;
 
+    printf("New longline\n");
+
     struct request_line *request = GARY_PUSH(requests_line);
     request->request.ind = num_requests++;
     request->request.type = REQUEST_LINE;
@@ -614,15 +616,24 @@ void make_segments(void)
     }
     else
     {
+      printf("Warning: Skipping line\n");
       continue;
       // FIXME;
     }
 
+int dbg_e = 1;
     while (e)
     {
+      printf("Edge %d\n", dbg_e);
+      dbg_e++;
+if (e < (void *) 100)
+{
+  exit(42);
+}
       if ((cur_length + e->length > conf_max_section_length) &&
           !(cur_length + e->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;
 
         rs = GARY_PUSH(rls->segments);
@@ -662,9 +673,10 @@ void make_segments(void)
         GARY_INIT(rls->segments, 0);
       }
 
-      if (e->length < st->tw)
+      if (st && (e->length < st->tw))
       {
         e = e->next;
+        printf("Warning: Skipping segment\n");
         continue;
       }
 
@@ -705,102 +717,40 @@ void make_segments(void)
 
       e = e->next;
     }
+
+    if (request->sections[0].num_segments == 0)
+    {
+      // FIXME
+      printf("WARNING: 0 segment section\n");
+      GARY_POP(requests_line);
+      num_requests -= 2;
+    }
   }
 }
 
-/***
-* void make_segments_old(void)
-* {
-* printf("Analysing %u longlines\n", GARY_SIZE(longlines));
-*   for (uns i=0; i<GARY_SIZE(longlines); i++)
-*   {
-*     if (! longlines[i].first->label) continue;
-* //    printf("Survived! %s\n", osm_val_decode(longlines[i].first->text->text));
-* printf("New longline\n");
-* 
-* if (longlines[i].first->label->type != SYMBOLIZER_TEXT)
-* {
-*   printf("Heh?\n");
-*   exit(42);
-* }
-*     struct request_line *request = GARY_PUSH(requests_line);
-*     request->request.ind = -1;
-*     request->request.type = REQUEST_LINE;
-* 
-*     GARY_INIT(request->segments, 0);
-*     request->num_segments = 0;
-* 
-*     // ->num_variants FIXME
-*     // ->variants FIXME
-* 
-*     struct graph_edge *e = longlines[i].first;
-* 
-*     if (! e) printf("Oops\n");
-*     num_requests++;
-*     while (e)
-*     {
-*       if (! e->label) break;
-* 
-*       struct request_segment *r = GARY_PUSH(request->segments);
-*       request->num_segments++;
-* 
-*       r->request.ind = num_requests++;
-*       r->request.type = REQUEST_SEGMENT;
-* 
-*       struct osm_node *n = e->n1->o;
-*       r->x1 = n->x;
-*       r->y1 = n->y;
-*       n = e->n2->o;
-*       r->x2 = n->x;
-*       r->y2 = n->y;
-* 
-* printf("Segment [%.2f; %.2f] -- [%.2f; %.2f]\n", r->x1, r->y1, r->x2, r->y2);
-* 
-*       r->zindex = e->zindex;
-*       r->variant = malloc(sizeof(struct point_variant)); // FIXME
-*       switch (e->label->type)
-*       {
-*         case SYMBOLIZER_TEXT: ;
-*           struct sym_text *st = malloc(sizeof(struct sym_text));
-*           ((struct symbol *) st)->o = e->label->o;
-*           ((struct symbol *) st)->type = SYMBOLIZER_TEXT;
-*           st->x = r->x1;
-*           st->y = r->y1;
-*           st->text = ((struct sym_text *) e->label)->text;
-*           st->text_color = ((struct sym_text *) e->label)->text_color;
-*           st->font = ((struct sym_text *) e->label)->font;
-*           st->opacity = ((struct sym_text *) e->label)->opacity;
-*           st->halo_color = ((struct sym_text *) e->label)->halo_color;
-*           st->halo_radius = ((struct sym_text *) e->label)->halo_radius;
-*           st->halo_opacity = ((struct sym_text *) e->label)->halo_opacity;
-*           st->tw = ((struct sym_text *) e->label)->tw;
-*           st->th = ((struct sym_text *) e->label)->th;
-*           st->td = ((struct sym_text *) e->label)->td;
-*           r->label = (struct symbol *) st;
-*           // FIXME: This shall be done in more elegant way
-*           make_bitmap_label(r->variant, (struct sym_text *) e->label);
-*           break;
-*         default:
-*           // FIXME
-*           printf("Got here?\n");
-*           ;
-*       }
-* 
-*       e = e->next;
-*     }
-*   }
-* }
-***/
-
-/***
-* void dump_linelabel_requests(void)
-* {
-*   for (uns i=0; i<GARY_SIZE(requests_line); i++)
-*   {
-*     print_label(requests_line[i].segments[0].label);
-*   }
-* }
-***/
+void dump_linelabel_requests(void)
+{
+  for (uns i=0; i<GARY_SIZE(requests_line); i++)
+  {
+    if (requests_line[i].sections[0].num_segments == 0)
+    {
+      printf("HEY!\n");
+      continue;
+    }
+    printf("Request for linelabel, %d sections\n", GARY_SIZE(requests_line[i].sections));
+    print_label(requests_line[i].sections[0].segments[0].label);
+    for (uns j=0; j<GARY_SIZE(requests_line[i].sections); j++)
+    {
+      printf("%d section, %d segments\n", j, GARY_SIZE(requests_line[i].sections[j].segments));
+      for (uns k=0; k<GARY_SIZE(requests_line[i].sections[j].segments); k++)
+      {
+        struct request_segment *rs = &requests_line[i].sections[j].segments[k];
+        printf("[%.2f; %.2f] -- [%.2f; %.2f]\n", rs->x1, rs->y1, rs->x2, rs->y2);
+      }
+    }
+    printf("\n");
+  }
+}
 
 void dump_bitmaps(struct individual *individual)
 {
@@ -867,6 +817,7 @@ fprintf(stderr, "%d-th placement\n", i);
 
 void dump_individual(struct individual *individual)
 {
+printf("*** Dumping INDIVIDUAL ***\n");
 printf("(There are %d requests)\n", num_requests);
   for (uns i=0; i<GARY_SIZE(individual->placements); i++)
   {
@@ -886,7 +837,10 @@ printf("(There are %d requests)\n", num_requests);
         printf("*");
         break;
       case REQUEST_SEGMENT: ;
-        printf("Segment placed at [%.2f; %.2f] on %u\n", p->x, p->y, ((struct request_segment *) p->request)->zindex);
+        if (p->variant_used >= 0)
+          printf("Segment placed at [%.2f; %.2f] on %u\n", p->x, p->y, ((struct request_segment *) p->request)->zindex);
+        else
+          printf("Segment not placed\n");
         break;
       case REQUEST_AREA: ;
         struct request_area *ra = (struct request_area *) p->request;
@@ -906,11 +860,11 @@ void labeller_label(void)
 {
   make_graph();
   label_graph();
-dump_graph();
+//dump_graph();
   bfs_wrapper();
-dump_longlines();
+//dump_longlines();
   make_segments();
-//dump_linelabel_requests();
+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));
 
@@ -933,11 +887,11 @@ printf("Having %u point requests, %u line requests and %u area requests\n", GARY
 */
 
   dump_individual(population1[0]);
-dump_bitmaps(population1[0]);
+//dump_bitmaps(population1[0]);
 
   for (uns i=0; i<GARY_SIZE(population1[0]->placements); i++)
   {
-printf("(%d) Coping with %d\n", i, population1[0]->placements[i].request->type);
+//printf("(%d) Coping with %d\n", i, population1[0]->placements[i].request->type);
 
     struct symbol *s = NULL;
     z_index_t zindex = 0;
@@ -947,31 +901,35 @@ printf("(%d) Coping with %d\n", i, population1[0]->placements[i].request->type);
         struct request_point *rp = (struct request_point *) population1[0]->placements[i].request;
         s = rp->sym;
         zindex = rp->zindex;
-        printf("%u\n", 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");
+//        printf("Assigned label to s\n");
+//        print_label(s);
         zindex = rs->zindex;
-        printf("%u\n", 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;
         s = ra->label;
         zindex = ra->zindex;
-        printf("%u\n", zindex);
+//        printf("%u\n", zindex);
         break;
       default:
-        printf("Testing request type (flushing final placements)\n");
+//        printf("Testing request type (flushing final placements)\n");
         ASSERT(population1[0]->placements[i].request != REQUEST_INVALID);
-        printf("Yep, in default, continuing\n");
+//        printf("Yep, in default, continuing\n");
         continue;
     }
 
-printf("Will plan symbol on %u\n", zindex);
+printf("Will plan symbol at [%.2f; %.2f] on %u\n", population1[0]->placements[i].x, population1[0]->placements[i].y, zindex);
 
-    switch (s->type)
+    if (s) switch (s->type)
     {
       case SYMBOLIZER_POINT: ;
         struct sym_point *sp = (struct sym_point *) s;
@@ -990,109 +948,16 @@ printf("Will plan symbol on %u\n", zindex);
         st->x = population1[0]->placements[i].x;
         st->y = population1[0]->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);
         sym_plan((struct symbol *) st, zindex);
         break;
       default:
-        printf("Testing symbolizer type\n");
+//        printf("Testing symbolizer type\n");
         ASSERT(s->type != SYMBOLIZER_INVALID);
     }
-
-
-
-/***
-*     switch (population1[0]->placements[i].request->type)
-*     {
-*       case REQUEST_POINT: ;
-*         struct request_point *rp = (struct request_point *) population1[0]->placements[i].request;
-*         switch (rp->sym->type)
-*         {
-*           case SYMBOLIZER_POINT: ;
-*           printf("Moving point to final destination\n");
-*          struct sym_point *sp = (struct sym_point *) rp->sym;
-*          sp->x = population1[0]->placements[i].x;
-*          sp->y = population1[0]->placements[i].y;
-*             sym_plan((struct symbol *) sp, rp->zindex);
-*          break;
-*        case SYMBOLIZER_ICON: ;
-*           printf("Moving icon to final destination\n");
-*          struct sym_icon *si = (struct sym_icon *) rp->sym;
-*          si->sir.x = population1[0]->placements[i].x;
-*          si->sir.y = population1[0]->placements[i].y;
-*             sym_plan((struct symbol *) si, rp->zindex);
-*          break;
-*        default:
-*          printf("Haúúú 1\n");
-*          ;
-*         }
-*         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;
-* 
-*       case REQUEST_LINE: ;
-*         struct request_line *rl = (struct request_line *) population1[0]->placements[i].request;
-*         for (uns j=0; j<GARY_SIZE(rl->segments); j++)
-*         {
-*           switch (rl->segments[j].label->type)
-*           {
-*             case SYMBOLIZER_TEXT:
-*               ((struct sym_text *) rl->segments[j].label)->next_duplicate = NULL;
-*               ((struct sym_text *) rl->segments[j].label)->next_in_tile = NULL;
-*               printf("Planning text ");
-*               print_label(rl->segments[j].label);
-*             default:
-*               printf("Haúúú 3\n");
-*               // FIXME
-*               ;
-*           }
-*           sym_plan((struct symbol *) rl->segments[j].label, rl->segments[j].zindex); // FIXME: z-index
-*         }
-*         break;
-* 
-*       case REQUEST_SEGMENT: ;
-*         //struct request_segment *rs = (struct request_segment *) population1[0]->placements[i].request;
-*         printf("Segment!\n");
-* 
-*     default:
-*       ASSERT(population1[0]->placements[i].request->type != REQUEST_INVALID);
-*     }
-***/
-
   }
 
   return;
-
-  while (! shall_terminate())
-  {
-    iteration++;
-
-    breed();
-    mutate();
-    elite();
-    rank_population();
-    // sort population by fitness
-
-    struct individual **swp = population1;
-    population1 = population2;
-    printf("Swapped populations\n");
-    population2 = swp;
-    // GARY_RESIZE(population2, 0) -- is it needed?
-    pop2_ind = 0;
-  }
 }
 
 void make_population(void)
@@ -1129,6 +994,12 @@ void make_population(void)
       init_placement(&(individual->placements[p++]), (struct request *) &requests_area[j]);
     }
 
+if (p != num_requests)
+{
+  printf("Say bye\n");
+  exit(42);
+}
+
 printf("Testing p\n");
     ASSERT(p == num_requests);
   }
@@ -1434,6 +1305,7 @@ void init_placement(struct placement *p, struct request *r)
   p->request = r;
   p->processed = 0;
   p->x = p->y = 0; // To prevent valgrind from complaining
+  p->variant_used = 0;
   switch (r->type)
   {
     case REQUEST_POINT: ;
@@ -1464,7 +1336,7 @@ void init_placement(struct placement *p, struct request *r)
   }
 
   gen_coords(p);
-  printf("Inited placement to [%.2f; %.2f]\n", p->x, p->y);
+//  printf("Inited placement to [%.2f; %.2f]\n", p->x, p->y);
 }
 
 void init_individual(struct individual *i)

diff --git a/sym-text.c b/sym-text.c
index f2f901e978270a7e364569750020842a0f483891..3188938a38fd151c92998fce6005a493b3cb7904 100644 (file)
--- a/sym-text.c
+++ b/sym-text.c
@@ -227,6 +227,7 @@ static void prepare_text_element(struct sym_text *t, struct svg *svg)
 static void sym_text_draw(struct symbol *sym, struct svg *svg)
 {
   struct sym_text *t = (struct sym_text *) sym;
+printf("Drawing %s at [%.2f; %.2f]\n", osm_val_decode(t->text), t->x, t->y);
 
   if (t->next_duplicate)
     {
@@ -460,11 +461,13 @@ static void sym_text_center(struct osm_object *o, struct style_info *si, osm_val
   if (o->type == OSM_TYPE_WAY && !osm_way_cyclic_p((struct osm_way *) o))
   {
     //sym_plan(&st->s, sym_zindex(o, si, 4.9));
+    printf("[Sym] Labelling way %ju with %s\n", o->id, osm_val_decode(st->text));
     labeller_add_linelabel(&st->s, o, sym_zindex(o, si, 4.9));
   }
   else
   {
     //sym_plan(&st->s, sym_zindex(o, si, 4.9));
+    printf("[Sym] Labelling area %ju with %s\n", o->id, osm_val_decode(st->text));
     labeller_add_arealabel(&st->s, o, sym_zindex(o, si, 4.9));
   }
 }

diff --git a/sym.c b/sym.c
index 00d89416b3e798d4ce3f16405e2d420847771aaa..334568161c24f007a86936f6cf816e03fc567331 100644 (file)
--- a/sym.c
+++ b/sym.c
@@ -71,6 +71,13 @@ void *sym_new(enum symbolizer_type type, struct osm_object *o, size_t size)
 
 void sym_plan(struct symbol *sym, z_index_t zindex)
 {
+  // DEBUG
+  if (sym->type == SYMBOLIZER_TEXT)
+  {
+    struct sym_text *st = (struct sym_text *) sym;
+    printf("In planner: Planning text %s at [%.2f; %.2f]\n", osm_val_decode(st->text), st->x, st->y);
+  }
+
   struct sym_planned *p = GARY_PUSH(sym_planned);
   p->sym = sym;
   p->zindex = zindex;
@@ -136,6 +143,16 @@ static void sym_draw(struct symbol *sym, z_index_t zindex, struct svg *svg)
 
 void sym_draw_all(struct svg *svg)
 {
+  for (uns i = 0; i < GARY_SIZE(sym_planned); i++)
+  {
+    // DEBUG
+    if (sym_planned[i].sym->type == SYMBOLIZER_TEXT)
+    {
+      struct sym_text *st = (struct sym_text *) sym_planned[i].sym;
+      printf("In planner: Will draw text %s at [%.2f; %.2f]\n", osm_val_decode(st->text), st->x, st->y);
+    }
+  }
+
   msg(L_INFO, "Sorting %u symbols by depth", (uns) GARY_SIZE(sym_planned));
   sym_sort(sym_planned, GARY_SIZE(sym_planned));
 
@@ -144,5 +161,14 @@ void sym_draw_all(struct svg *svg)
 
   msg(L_INFO, "Drawing symbols");
   for (uns i = 0; i < GARY_SIZE(sym_planned); i++)
+  {
+    // DEBUG
+    if (sym_planned[i].sym->type == SYMBOLIZER_TEXT)
+    {
+      struct sym_text *st = (struct sym_text *) sym_planned[i].sym;
+      printf("In planner: Will draw text %s at [%.2f; %.2f]\n", osm_val_decode(st->text), st->x, st->y);
+    }
+
     sym_draw(sym_planned[i].sym, sym_planned[i].zindex, svg);
+  }
 }