?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Introduce POLYGONHOLE_MODE for creating holes in polygons
[geda-pcb/gde.git] / src / toporouter.c
blobfa57635b19443f044ffbda174608d7d2602d4066
1 /*
2 * COPYRIGHT
3 *
4 * Topological Autorouter for
5 * PCB, interactive printed circuit board design
6 * Copyright (C) 2009 Anthony Blake
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 *
22 * Contact addresses for email:
23 * Anthony Blake, tonyb33@gmail.com
24 *
25 *
26 *
27 * This is *EXPERIMENTAL* code.
28 *
29 * As the code is experimental, the algorithms and code
30 * are likely to change. Which means it isn't documented
31 * or optimized. If you would like to learn about Topological
32 * Autorouters, the following papers are good starting points:
33 *
34 * This file implements a topological autorouter, and uses techniques from the
35 * following publications:
36 *
37 * Dayan, T. and Dai, W.W.M., "Layer Assignment for a Rubber Band Router" Tech
38 * Report UCSC-CRL-92-50, Univ. of California, Santa Cruz, 1992.
39 *
40 * Dai, W.W.M and Dayan, T. and Staepelaere, D., "Topological Routing in SURF:
41 * Generating a Rubber-Band Sketch" Proc. 28th ACM/IEEE Design Automation
42 * Conference, 1991, pp. 39-44.
43 *
44 * David Staepelaere, Jeffrey Jue, Tal Dayan, Wayne Wei-Ming Dai, "SURF:
45 * Rubber-Band Routing System for Multichip Modules," IEEE Design and Test of
46 * Computers ,vol. 10, no. 4, pp. 18-26, October/December, 1993.
47 *
48 * Dayan, T., "Rubber-band based topological router" PhD Thesis, Univ. of
49 * California, Santa Cruz, 1997.
50 *
51 * David Staepelaere, "Geometric transformations for a rubber-band sketch"
52 * Master's thesis, Univ. of California, Santa Cruz, September 1992.
53 *
54 */
55
56
57 #include "toporouter.h"
58
59 static void
60 toporouter_edge_init (toporouter_edge_t *edge)
61 {
62 edge->routing = NULL;
63 edge->flags = 0;
64 }
65
66 toporouter_edge_class_t *
67 toporouter_edge_class(void)
68 {
69 static toporouter_edge_class_t *class = NULL;
70
71 if (class == NULL) {
72 GtsObjectClassInfo constraint_info = {
73 "toporouter_edge_t",
74 sizeof (toporouter_edge_t),
75 sizeof (toporouter_edge_class_t),
76 (GtsObjectClassInitFunc) NULL,
77 (GtsObjectInitFunc) toporouter_edge_init,
78 (GtsArgSetFunc) NULL,
79 (GtsArgGetFunc) NULL
80 };
81 class = gts_object_class_new (GTS_OBJECT_CLASS (gts_edge_class ()), &constraint_info);
82 }
83
84 return class;
85 }
86
87 static void
88 toporouter_bbox_init (toporouter_bbox_t *box)
89 {
90 box->data = NULL;
91 box->type = OTHER;
92 box->constraints = NULL;
93 box->cluster = NULL;
94 }
95
96 toporouter_bbox_class_t *
97 toporouter_bbox_class(void)
98 {
99 static toporouter_bbox_class_t *class = NULL;
100
101 if (class == NULL) {
102 GtsObjectClassInfo constraint_info = {
103 "toporouter_bbox_t",
104 sizeof (toporouter_bbox_t),
105 sizeof (toporouter_bbox_class_t),
106 (GtsObjectClassInitFunc) NULL,
107 (GtsObjectInitFunc) toporouter_bbox_init,
108 (GtsArgSetFunc) NULL,
109 (GtsArgGetFunc) NULL
110 };
111 class = gts_object_class_new (GTS_OBJECT_CLASS (gts_bbox_class ()), &constraint_info);
112 }
113
114 return class;
115 }
116
117 static void
118 toporouter_vertex_class_init (toporouter_vertex_class_t *klass)
119 {
120
121 }
122
123 static void
124 toporouter_vertex_init (toporouter_vertex_t *vertex)
125 {
126 vertex->bbox = NULL;
127 vertex->parent = NULL;
128 vertex->child = NULL;
129 vertex->flags = 0;
130 vertex->routingedge = NULL;
131 vertex->arc = NULL;
132 vertex->oproute = NULL;
133 vertex->route = NULL;
134
135 vertex->gcost = 0.;
136 vertex->hcost = 0.;
137 vertex->gn = 0;
138 }
139
140 toporouter_vertex_class_t *
141 toporouter_vertex_class(void)
142 {
143 static toporouter_vertex_class_t *klass = NULL;
144
145 if (klass == NULL) {
146 GtsObjectClassInfo constraint_info = {
147 "toporouter_vertex_t",
148 sizeof (toporouter_vertex_t),
149 sizeof (toporouter_vertex_class_t),
150 (GtsObjectClassInitFunc) toporouter_vertex_class_init,
151 (GtsObjectInitFunc) toporouter_vertex_init,
152 (GtsArgSetFunc) NULL,
153 (GtsArgGetFunc) NULL
154 };
155 klass = gts_object_class_new (GTS_OBJECT_CLASS (gts_vertex_class ()), &constraint_info);
156 }
157
158 return klass;
159 }
160
161 static void
162 toporouter_constraint_class_init (toporouter_constraint_class_t *klass)
163 {
164
165 }
166
167 static void
168 toporouter_constraint_init (toporouter_constraint_t *constraint)
169 {
170 constraint->box = NULL;
171 constraint->routing = NULL;
172 }
173
174 toporouter_constraint_class_t *
175 toporouter_constraint_class(void)
176 {
177 static toporouter_constraint_class_t *klass = NULL;
178
179 if (klass == NULL) {
180 GtsObjectClassInfo constraint_info = {
181 "toporouter_constraint_t",
182 sizeof (toporouter_constraint_t),
183 sizeof (toporouter_constraint_class_t),
184 (GtsObjectClassInitFunc) toporouter_constraint_class_init,
185 (GtsObjectInitFunc) toporouter_constraint_init,
186 (GtsArgSetFunc) NULL,
187 (GtsArgGetFunc) NULL
188 };
189 klass = gts_object_class_new (GTS_OBJECT_CLASS (gts_constraint_class ()), &constraint_info);
190 }
191
192 return klass;
193 }
194
195 static void
196 toporouter_arc_init (toporouter_arc_t *arc)
197 {
198 arc->x0 = -1.;
199 arc->y0 = -1.;
200 arc->x1 = -1.;
201 arc->y1 = -1.;
202 arc->centre = NULL;
203 arc->v = NULL;
204 arc->v1 = NULL;
205 arc->v2 = NULL;
206 arc->r = -1.;
207 arc->dir = 31337;
208 arc->clearance = NULL;
209 arc->oproute = NULL;
210 }
211
212 toporouter_arc_class_t *
213 toporouter_arc_class(void)
214 {
215 static toporouter_arc_class_t *klass = NULL;
216
217 if (klass == NULL) {
218 GtsObjectClassInfo constraint_info = {
219 "toporouter_arc_t",
220 sizeof (toporouter_arc_t),
221 sizeof (toporouter_arc_class_t),
222 (GtsObjectClassInitFunc) NULL,
223 (GtsObjectInitFunc) toporouter_arc_init,
224 (GtsArgSetFunc) NULL,
225 (GtsArgGetFunc) NULL
226 };
227 klass = gts_object_class_new (GTS_OBJECT_CLASS (gts_constraint_class ()), &constraint_info);
228 }
229
230 return klass;
231 }
232
233 #define MARGIN 10.0f
234
235 drawing_context_t *
236 toporouter_output_init(int w, int h, char *filename)
237 {
238 drawing_context_t *dc;
239
240 dc = malloc(sizeof(drawing_context_t));
241
242 dc->iw = w;
243 dc->ih = h;
244 dc->filename = filename;
245
246 /* Calculate scaling to maintain aspect ratio */
247 if(PCB->MaxWidth > PCB->MaxHeight) {
248 /* Scale board width to match image width minus 2xMARGIN */
249 dc->s = ((double)dc->iw - (2 * MARGIN)) / (double)PCB->MaxWidth;
250 dc->ih = (double)PCB->MaxHeight * dc->s + (2 * MARGIN);
251 }else{
252 /* Scale board height to match image height minus 2xMARGIN */
253 dc->s = ((double)dc->ih - (2 * MARGIN)) / (double)PCB->MaxHeight;
254 dc->iw = (double)PCB->MaxWidth * dc->s + (2 * MARGIN);
255 }
256
257 #if TOPO_OUTPUT_ENABLED
258 dc->surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, dc->iw, dc->ih);
259 dc->cr = cairo_create (dc->surface);
260
261 cairo_rectangle (dc->cr, 0, 0, dc->iw, dc->ih);
262 cairo_set_source_rgb (dc->cr, 0, 0, 0);
263 cairo_fill (dc->cr);
264
265 #endif
266
267 return dc;
268 }
269
270 void
271 toporouter_output_close(drawing_context_t *dc)
272 {
273 #if TOPO_OUTPUT_ENABLED
274 cairo_surface_write_to_png (dc->surface, dc->filename);
275 cairo_destroy (dc->cr);
276 cairo_surface_destroy (dc->surface);
277 #endif
278 }
279
280 gdouble
281 lookup_keepaway(char *name)
282 {
283 if(name)
284 STYLE_LOOP(PCB);
285 {
286 // if(!strcmp(style->Name, name)) return style->Keepaway + 1.;
287 if(!strcmp(style->Name, name)) return style->Keepaway;
288 }
289 END_LOOP;
290 // return Settings.Keepaway + 1.;
291 return Settings.Keepaway ;
292 }
293
294 gdouble
295 lookup_thickness(char *name)
296 {
297 if(name)
298 STYLE_LOOP(PCB);
299 {
300 if(!strcmp(style->Name, name)) return style->Thick;
301 }
302 END_LOOP;
303 return Settings.LineThickness;
304 }
305
306 inline gdouble
307 cluster_keepaway(toporouter_cluster_t *cluster)
308 {
309 if(cluster) return lookup_keepaway(cluster->netlist->style);
310 return lookup_keepaway(NULL);
311 }
312
313 inline gdouble
314 cluster_thickness(toporouter_cluster_t *cluster)
315 {
316 if(cluster) return lookup_thickness(cluster->netlist->style);
317 return lookup_thickness(NULL);
318 }
319
320 gint
321 toporouter_draw_vertex(gpointer item, gpointer data)
322 {
323 #if TOPO_OUTPUT_ENABLED
324 drawing_context_t *dc = (drawing_context_t *) data;
325 toporouter_vertex_t *tv;
326 PinType *pin;
327 PadType *pad;
328 gdouble blue;
329
330 if(TOPOROUTER_IS_VERTEX((GtsObject*)item)) {
331 tv = TOPOROUTER_VERTEX((GtsObject*)item);
332
333 if(tv->flags & VERTEX_FLAG_RED) {
334 cairo_set_source_rgba(dc->cr, 1., 0., 0., 0.8f);
335 cairo_arc(dc->cr,
336 tv->v.p.x * dc->s + MARGIN,
337 tv->v.p.y * dc->s + MARGIN,
338 500. * dc->s, 0, 2 * M_PI);
339 cairo_fill(dc->cr);
340
341 }else if(tv->flags & VERTEX_FLAG_GREEN) {
342 cairo_set_source_rgba(dc->cr, 0., 1., 0., 0.8f);
343 cairo_arc(dc->cr,
344 tv->v.p.x * dc->s + MARGIN,
345 tv->v.p.y * dc->s + MARGIN,
346 500. * dc->s, 0, 2 * M_PI);
347 cairo_fill(dc->cr);
348
349 }else if(tv->flags & VERTEX_FLAG_BLUE) {
350 cairo_set_source_rgba(dc->cr, 0., 0., 1., 0.8f);
351 cairo_arc(dc->cr,
352 tv->v.p.x * dc->s + MARGIN,
353 tv->v.p.y * dc->s + MARGIN,
354 500. * dc->s, 0, 2 * M_PI);
355 cairo_fill(dc->cr);
356
357
358 }
359 //printf("tv->type = %d\n", tv->type);
360 if(!dc->mode) {
361 if(tv->bbox) {
362 pin = (PinType*) tv->bbox->data;
363 pad = (PadType*) tv->bbox->data;
364
365 blue = 0.0f;
366 switch(tv->bbox->type) {
367 case PIN:
368 cairo_set_source_rgba(dc->cr, 1.0f, 0., 0.0f, 0.2f);
369 cairo_arc(dc->cr,
370 tv->v.p.x * dc->s + MARGIN,
371 tv->v.p.y * dc->s + MARGIN,
372 (((gdouble)pin->Thickness / 2.0f) + (gdouble)lookup_keepaway(pin->Name) ) * dc->s, 0, 2 * M_PI);
373 cairo_fill(dc->cr);
374
375 cairo_set_source_rgba(dc->cr, 1.0f, 0., 0., 0.4f);
376 cairo_arc(dc->cr,
377 tv->v.p.x * dc->s + MARGIN,
378 tv->v.p.y * dc->s + MARGIN,
379 (gdouble)(pin->Thickness) / 2.0f * dc->s,
380 0, 2 * M_PI);
381 cairo_fill(dc->cr);
382
383 break;
384 case VIA:
385 cairo_set_source_rgba(dc->cr, 0.0f, 0., 1., 0.2f);
386 cairo_arc(dc->cr,
387 tv->v.p.x * dc->s + MARGIN,
388 tv->v.p.y * dc->s + MARGIN,
389 (((gdouble)pin->Thickness / 2.0f) + (gdouble)lookup_keepaway(pin->Name) ) * dc->s, 0, 2 * M_PI);
390 cairo_fill(dc->cr);
391
392 cairo_set_source_rgba(dc->cr, 0.0f, 0., 1., 0.4f);
393 cairo_arc(dc->cr,
394 tv->v.p.x * dc->s + MARGIN,
395 tv->v.p.y * dc->s + MARGIN,
396 (gdouble)(pin->Thickness) / 2.0f * dc->s,
397 0, 2 * M_PI);
398 cairo_fill(dc->cr);
399
400 break;
401 case PAD:
402 cairo_set_source_rgba(dc->cr, 0.0f, 1., 0., 0.5f);
403 cairo_arc(dc->cr,
404 tv->v.p.x * dc->s + MARGIN,
405 tv->v.p.y * dc->s + MARGIN,
406 400. * dc->s, 0, 2 * M_PI);
407 cairo_fill(dc->cr);
408
409 break;
410 default:
411 break;
412 }
413 }
414 }else{
415 if(tv->flags & VERTEX_FLAG_BLUE) {
416 cairo_set_source_rgba(dc->cr, 0., 0., 1., 0.8f);
417 cairo_arc(dc->cr,
418 tv->v.p.x * dc->s + MARGIN,
419 tv->v.p.y * dc->s + MARGIN,
420 500. * dc->s, 0, 2 * M_PI);
421 cairo_fill(dc->cr);
422 }else if(tv->flags & VERTEX_FLAG_RED) {
423 cairo_set_source_rgba(dc->cr, 1., 0., 0., 0.8f);
424 cairo_arc(dc->cr,
425 tv->v.p.x * dc->s + MARGIN,
426 tv->v.p.y * dc->s + MARGIN,
427 500. * dc->s, 0, 2 * M_PI);
428 cairo_fill(dc->cr);
429
430 }else if(tv->flags & VERTEX_FLAG_GREEN) {
431 cairo_set_source_rgba(dc->cr, 0., 1., 0., 0.8f);
432 cairo_arc(dc->cr,
433 tv->v.p.x * dc->s + MARGIN,
434 tv->v.p.y * dc->s + MARGIN,
435 500. * dc->s, 0, 2 * M_PI);
436 cairo_fill(dc->cr);
437 }
438
439 }
440 }else{
441 fprintf(stderr, "Unknown data passed to toporouter_draw_vertex, aborting foreach\n");
442 return -1;
443 }
444 return 0;
445 #else
446 return -1;
447 #endif
448 }
449
450 gint
451 toporouter_draw_edge(gpointer item, gpointer data)
452 {
453 #if TOPO_OUTPUT_ENABLED
454 drawing_context_t *dc = (drawing_context_t *) data;
455 toporouter_edge_t *te;
456 toporouter_constraint_t *tc;
457
458 if(TOPOROUTER_IS_EDGE((GtsObject*)item)) {
459 te = TOPOROUTER_EDGE((GtsObject*)item);
460 cairo_set_source_rgba(dc->cr, 1.0f, 1.0f, 1.0f, 0.5f);
461 cairo_move_to(dc->cr,
462 te->e.segment.v1->p.x * dc->s + MARGIN,
463 te->e.segment.v1->p.y * dc->s + MARGIN);
464 cairo_line_to(dc->cr,
465 te->e.segment.v2->p.x * dc->s + MARGIN,
466 te->e.segment.v2->p.y * dc->s + MARGIN);
467 cairo_stroke(dc->cr);
468 }else if(TOPOROUTER_IS_CONSTRAINT((GtsObject*)item)) {
469 tc = TOPOROUTER_CONSTRAINT((GtsObject*)item);
470 if(tc->box) {
471 switch(tc->box->type) {
472 case BOARD:
473 cairo_set_source_rgba(dc->cr, 1.0f, 0.0f, 1.0f, 0.9f);
474 cairo_move_to(dc->cr,
475 tc->c.edge.segment.v1->p.x * dc->s + MARGIN,
476 tc->c.edge.segment.v1->p.y * dc->s + MARGIN);
477 cairo_line_to(dc->cr,
478 tc->c.edge.segment.v2->p.x * dc->s + MARGIN,
479 tc->c.edge.segment.v2->p.y * dc->s + MARGIN);
480 cairo_stroke(dc->cr);
481 break;
482 case PIN:
483 case PAD:
484 cairo_set_source_rgba(dc->cr, 1.0f, 0.0f, 0.0f, 0.9f);
485 cairo_move_to(dc->cr,
486 tc->c.edge.segment.v1->p.x * dc->s + MARGIN,
487 tc->c.edge.segment.v1->p.y * dc->s + MARGIN);
488 cairo_line_to(dc->cr,
489 tc->c.edge.segment.v2->p.x * dc->s + MARGIN,
490 tc->c.edge.segment.v2->p.y * dc->s + MARGIN);
491 cairo_stroke(dc->cr);
492 break;
493 case LINE:
494 cairo_set_source_rgba(dc->cr, 0.0f, 1.0f, 0.0f, 0.9f);
495 cairo_move_to(dc->cr,
496 tc->c.edge.segment.v1->p.x * dc->s + MARGIN,
497 tc->c.edge.segment.v1->p.y * dc->s + MARGIN);
498 cairo_line_to(dc->cr,
499 tc->c.edge.segment.v2->p.x * dc->s + MARGIN,
500 tc->c.edge.segment.v2->p.y * dc->s + MARGIN);
501 cairo_stroke(dc->cr);
502 break;
503
504 default:
505 cairo_set_source_rgba(dc->cr, 1.0f, 1.0f, 0.0f, 0.9f);
506 cairo_move_to(dc->cr,
507 tc->c.edge.segment.v1->p.x * dc->s + MARGIN,
508 tc->c.edge.segment.v1->p.y * dc->s + MARGIN);
509 cairo_line_to(dc->cr,
510 tc->c.edge.segment.v2->p.x * dc->s + MARGIN,
511 tc->c.edge.segment.v2->p.y * dc->s + MARGIN);
512 cairo_stroke(dc->cr);
513 break;
514 }
515 }else{
516 printf("CONSTRAINT without box\n");
517
518 }
519 }else{
520 fprintf(stderr, "Unknown data passed to toporouter_draw_edge, aborting foreach\n");
521 return -1;
522 }
523
524 return 0;
525 #else
526 return -1;
527 #endif
528 }
529
530 //#define vertex_bbox(v) (v->bbox)
531 ///*
532 toporouter_bbox_t *
533 vertex_bbox(toporouter_vertex_t *v)
534 {
535 return v ? v->bbox : NULL;
536 }
537 //*/
538 char *
539 vertex_netlist(toporouter_vertex_t *v)
540 {
541 toporouter_bbox_t *box = vertex_bbox(v);
542
543 if(box && box->cluster) return box->cluster->netlist->netlist;
544
545 return NULL;
546 }
547
548 char *
549 constraint_netlist(toporouter_constraint_t *c)
550 {
551 toporouter_bbox_t *box = c->box;
552
553 if(box && box->cluster) return box->cluster->netlist->netlist;
554
555 return NULL;
556 }
557
558 inline guint
559 epsilon_equals(gdouble a, gdouble b)
560 {
561 if(a > b - EPSILON && a < b + EPSILON) return 1;
562 return 0;
563 }
564
565 void
566 print_bbox(toporouter_bbox_t *box)
567 {
568 printf("[BBOX ");
569 switch(box->type) {
570 case PAD:
571 printf("PAD "); break;
572 case PIN:
573 printf("PIN "); break;
574 case VIA:
575 printf("VIA "); break;
576 case LINE:
577 printf("LINE "); break;
578 case BOARD:
579 printf("BOARD "); break;
580 case POLYGON:
581 printf("POLYGON "); break;
582 default:
583 printf("UNKNOWN "); break;
584 }
585
586 if(box->point)
587 printf("P: %f,%f,%f ", vx(box->point), vy(box->point), vz(box->point));
588 else
589 printf("P: NONE ");
590
591 printf("LAYER: %d ", box->layer);
592 printf("CLUSTER: %d]\n", box->cluster ? box->cluster->c : -1);
593
594 }
595
596 void
597 print_vertex(toporouter_vertex_t *v)
598 {
599 if(v)
600 printf("[V %f,%f,%f ", vx(v), vy(v), vz(v));
601 else
602 printf("[V (null) ");
603
604 printf("%s ", vertex_netlist(v));
605 if(v->route && v->route->netlist)
606 printf("%s ", v->route->netlist->netlist);
607
608 if(v->routingedge) {
609 guint n = g_list_length(edge_routing(v->routingedge));
610 guint pos = g_list_index(edge_routing(v->routingedge), v);
611
612 if(TOPOROUTER_IS_CONSTRAINT(v->routingedge))
613 printf("[CONST ");
614 else
615 printf("[EDGE ");
616
617 printf("%d/%d] ", pos, n);
618
619 }
620
621
622 if(v->flags & VERTEX_FLAG_TEMP) printf("TEMP ");
623 if(v->flags & VERTEX_FLAG_ROUTE) printf("ROUTE ");
624 if(v->flags & VERTEX_FLAG_SPECCUT) printf("SPECCUT ");
625 if(v->flags & VERTEX_FLAG_FAKE) printf("FAKE ");
626
627 printf("]\n");
628
629 }
630
631 gdouble
632 vertex_net_thickness(toporouter_vertex_t *v)
633 {
634 toporouter_bbox_t *box = vertex_bbox(v);
635
636 if(!box) {
637
638 while(v && (v->flags & VERTEX_FLAG_TEMP || v->flags & VERTEX_FLAG_ROUTE)) {
639 v = v->parent;
640 }
641
642 box = vertex_bbox(v);
643
644 }else{
645 if(box->type == PIN || box->type == VIA) {
646 PinType *pin = (PinType *)box->data;
647 if(TEST_FLAG(SQUAREFLAG, pin) || TEST_FLAG(OCTAGONFLAG, pin)) {
648 return 0.;
649 }
650 // return ((PinType *)box->data)->Thickness + 1.;
651 return ((PinType *)box->data)->Thickness;
652 }else if(box->type == PAD) {
653 PadType *pad = (PadType *)box->data;
654 if(pad->Point1.X == pad->Point2.X && pad->Point1.Y == pad->Point2.Y && !TEST_FLAG(SQUAREFLAG, pad)) {
655 return pad->Thickness;
656 }
657 return 0.;
658 }else if(box->type == BOARD) {
659 return 0.;
660 }else if(box->type == LINE) {
661 LineType *line = (LineType *) box->data;
662 return line->Thickness;
663 }else if(box->type == POLYGON) {
664 return 0.;
665 }
666
667 printf("Unrecognized type in thickness lookup..\n");
668 }
669
670 // if(!box || !box->cluster) return Settings.LineThickness + 1.;
671 if(!box || !box->cluster) return Settings.LineThickness;
672
673 return cluster_thickness(box->cluster);
674 }
675
676 gdouble
677 vertex_net_keepaway(toporouter_vertex_t *v)
678 {
679 toporouter_bbox_t *box = vertex_bbox(v);
680 if(!box) {
681
682 while(v && (v->flags & VERTEX_FLAG_TEMP || v->flags & VERTEX_FLAG_ROUTE)) {
683 v = v->parent;
684 }
685 box = vertex_bbox(v);
686 }
687 else{
688 // if(box->type == PIN || box->type == VIA)
689 // return ((PinType *)box->data)->Clearance;
690 // else if(box->type == PAD)
691 // return ((PadType *)box->data)->Clearance;
692
693 }
694
695 // if(!box || !box->cluster) return Settings.Keepaway + 1.;
696 if(!box || !box->cluster) return Settings.Keepaway;
697 return cluster_keepaway(box->cluster);
698 }
699 /*
700 void
701 print_trace (void)
702 {
703 void *array[10];
704 size_t size;
705 char **strings;
706 size_t i;
707
708 size = backtrace (array, 10);
709 strings = backtrace_symbols (array, size);
710
711 printf ("Obtained %zd stack frames.\n", size);
712
713 for (i = 0; i < size; i++)
714 printf ("%s\n", strings[i]);
715
716 free (strings);
717 }
718 */
719 /* fills in x and y with coordinates of point from a towards b of distance d */
720 void
721 point_from_point_to_point(toporouter_vertex_t *a, toporouter_vertex_t *b, gdouble d, gdouble *x, gdouble *y)
722 {
723 gdouble dx = vx(b) - vx(a);
724 gdouble dy = vy(b) - vy(a);
725 gdouble theta = atan(fabs(dy/dx));
726
727 //#ifdef DEBUG_EXPORT
728 if(!finite(theta)) {
729 // printf("!finte(theta): a = %f,%f b = %f,%f d = %f\n", vx(a), vy(a), vx(b), vy(b), d);
730 // print_trace();
731 //TODO: this shouldn't happen, fix the hack
732 *x = vx(a);
733 *y = vy(a);
734 return;
735 }
736 //#endif
737
738 g_assert(finite(theta));
739
740 *x = vx(a); *y = vy(a);
741
742 if( dx >= 0. ) {
743
744 if( dy >= 0. ) {
745 *x += d * cos(theta);
746 *y += d * sin(theta);
747 }else{
748 *x += d * cos(theta);
749 *y -= d * sin(theta);
750 }
751
752 }else{
753
754 if( dy >= 0. ) {
755 *x -= d * cos(theta);
756 *y += d * sin(theta);
757 }else{
758 *x -= d * cos(theta);
759 *y -= d * sin(theta);
760 }
761
762 }
763 }
764
765
766 inline gint
767 coord_wind(gdouble ax, gdouble ay, gdouble bx, gdouble by, gdouble cx, gdouble cy)
768 {
769 gdouble rval, dx1, dx2, dy1, dy2;
770 dx1 = bx - ax; dy1 = by - ay;
771 dx2 = cx - bx; dy2 = cy - by;
772 rval = (dx1*dy2)-(dy1*dx2);
773 return (rval > EPSILON) ? 1 : ((rval < -EPSILON) ? -1 : 0);
774 }
775
776 /* wind_v:
777 * returns 1,0,-1 for counterclockwise, collinear or clockwise, respectively.
778 */
779 int
780 point_wind(GtsPoint *a, GtsPoint *b, GtsPoint *c)
781 {
782 gdouble rval, dx1, dx2, dy1, dy2;
783 dx1 = b->x - a->x; dy1 = b->y - a->y;
784 dx2 = c->x - b->x; dy2 = c->y - b->y;
785 rval = (dx1*dy2)-(dy1*dx2);
786 return (rval > EPSILON) ? 1 : ((rval < -EPSILON) ? -1 : 0);
787 }
788
789 inline int
790 vertex_wind(GtsVertex *a, GtsVertex *b, GtsVertex *c)
791 {
792 return point_wind(GTS_POINT(a), GTS_POINT(b), GTS_POINT(c));
793 }
794
795 inline int
796 tvertex_wind(toporouter_vertex_t *a, toporouter_vertex_t *b, toporouter_vertex_t *c)
797 {
798 return point_wind(GTS_POINT(a), GTS_POINT(b), GTS_POINT(c));
799 }
800
801 int
802 sloppy_point_wind(GtsPoint *a, GtsPoint *b, GtsPoint *c)
803 {
804 gdouble rval, dx1, dx2, dy1, dy2;
805 dx1 = b->x - a->x; dy1 = b->y - a->y;
806 dx2 = c->x - b->x; dy2 = c->y - b->y;
807 rval = (dx1*dy2)-(dy1*dx2);
808 return (rval > 10.) ? 1 : ((rval < -10.) ? -1 : 0);
809 }
810
811 inline int
812 sloppy_vertex_wind(GtsVertex *a, GtsVertex *b, GtsVertex *c)
813 {
814 return point_wind(GTS_POINT(a), GTS_POINT(b), GTS_POINT(c));
815 }
816
817 /* moves vertex v d units in the direction of vertex p */
818 void
819 coord_move_towards_coord_values(gdouble ax, gdouble ay, gdouble px, gdouble py, gdouble d, gdouble *x, gdouble *y)
820 {
821 gdouble dx = px - ax;
822 gdouble dy = py - ay;
823 gdouble theta = atan(fabs(dy/dx));
824
825
826 if(!finite(theta)) {
827 printf("!finite(theta) a = %f,%f p = %f,%f d = %f\n",
828 ax, ay, px, py, d);
829
830 }
831
832 g_assert(finite(theta));
833
834 if( dx >= 0. ) {
835
836 if( dy >= 0. ) {
837 *x = ax + (d * cos(theta));
838 *y = ay + (d * sin(theta));
839 }else{
840 *x = ax + (d * cos(theta));
841 *y = ay - (d * sin(theta));
842 }
843
844 }else{
845
846 if( dy >= 0. ) {
847 *x = ax - (d * cos(theta));
848 *y = ay + (d * sin(theta));
849 }else{
850 *x = ax - (d * cos(theta));
851 *y = ay - (d * sin(theta));
852 }
853
854 }
855
856 }
857
858 /* moves vertex v d units in the direction of vertex p */
859 void
860 vertex_move_towards_point_values(GtsVertex *v, gdouble px, gdouble py, gdouble d, gdouble *x, gdouble *y)
861 {
862 gdouble dx = px - GTS_POINT(v)->x;
863 gdouble dy = py - GTS_POINT(v)->y;
864 gdouble theta = atan(fabs(dy/dx));
865
866 g_assert(finite(theta));
867
868 if( dx >= 0. ) {
869
870 if( dy >= 0. ) {
871 *x = GTS_POINT(v)->x + (d * cos(theta));
872 *y = GTS_POINT(v)->y + (d * sin(theta));
873 }else{
874 *x = GTS_POINT(v)->x + (d * cos(theta));
875 *y = GTS_POINT(v)->y - (d * sin(theta));
876 }
877
878 }else{
879
880 if( dy >= 0. ) {
881 *x = GTS_POINT(v)->x - (d * cos(theta));
882 *y = GTS_POINT(v)->y + (d * sin(theta));
883 }else{
884 *x = GTS_POINT(v)->x - (d * cos(theta));
885 *y = GTS_POINT(v)->y - (d * sin(theta));
886 }
887
888 }
889
890 }
891
892 /* moves vertex v d units in the direction of vertex p */
893 void
894 vertex_move_towards_vertex_values(GtsVertex *v, GtsVertex *p, gdouble d, gdouble *x, gdouble *y)
895 {
896 gdouble dx = GTS_POINT(p)->x - GTS_POINT(v)->x;
897 gdouble dy = GTS_POINT(p)->y - GTS_POINT(v)->y;
898 gdouble theta = atan(fabs(dy/dx));
899
900 g_assert(finite(theta));
901
902 if( dx >= 0. ) {
903
904 if( dy >= 0. ) {
905 *x = GTS_POINT(v)->x + (d * cos(theta));
906 *y = GTS_POINT(v)->y + (d * sin(theta));
907 }else{
908 *x = GTS_POINT(v)->x + (d * cos(theta));
909 *y = GTS_POINT(v)->y - (d * sin(theta));
910 }
911
912 }else{
913
914 if( dy >= 0. ) {
915 *x = GTS_POINT(v)->x - (d * cos(theta));
916 *y = GTS_POINT(v)->y + (d * sin(theta));
917 }else{
918 *x = GTS_POINT(v)->x - (d * cos(theta));
919 *y = GTS_POINT(v)->y - (d * sin(theta));
920 }
921
922 }
923
924 }
925
926 #define tv_on_layer(v,l) (l == TOPOROUTER_BBOX(TOPOROUTER_VERTEX(v)->boxes->data)->layer)
927
928 inline gdouble
929 min_spacing(toporouter_vertex_t *v1, toporouter_vertex_t *v2)
930 {
931
932 gdouble v1halfthick, v2halfthick, v1keepaway, v2keepaway, ms;
933 // toporouter_edge_t *e = v1->routingedge;
934
935 v1halfthick = vertex_net_thickness(TOPOROUTER_VERTEX(v1)) / 2.;
936 v2halfthick = vertex_net_thickness(TOPOROUTER_VERTEX(v2)) / 2.;
937
938 v1keepaway = vertex_net_keepaway(TOPOROUTER_VERTEX(v1));
939 v2keepaway = vertex_net_keepaway(TOPOROUTER_VERTEX(v2));
940
941 ms = v1halfthick + v2halfthick + MAX(v1keepaway, v2keepaway);
942
943 #ifdef SPACING_DEBUG
944 printf("v1halfthick = %f v2halfthick = %f v1keepaway = %f v2keepaway = %f ms = %f\n",
945 v1halfthick, v2halfthick, v1keepaway, v2keepaway, ms);
946 #endif
947
948 return ms;
949 }
950
951 // v1 is a vertex in the CDT, and v2 is a net... other way around?
952 inline gdouble
953 min_vertex_net_spacing(toporouter_vertex_t *v1, toporouter_vertex_t *v2)
954 {
955
956 gdouble v1halfthick, v2halfthick, v1keepaway, v2keepaway, ms;
957
958 v1halfthick = vertex_net_thickness(TOPOROUTER_VERTEX(v1)) / 2.;
959 v2halfthick = cluster_thickness(vertex_bbox(v2)->cluster) / 2.;
960
961 v1keepaway = vertex_net_keepaway(TOPOROUTER_VERTEX(v1));
962 v2keepaway = cluster_keepaway(vertex_bbox(v2)->cluster);
963
964 ms = v1halfthick + v2halfthick + MAX(v1keepaway, v2keepaway);
965
966 return ms;
967 }
968
969 inline gdouble
970 min_oproute_vertex_spacing(toporouter_oproute_t *oproute, toporouter_vertex_t *v2)
971 {
972
973 gdouble v1halfthick, v2halfthick, v1keepaway, v2keepaway, ms;
974
975 v1halfthick = lookup_thickness(oproute->style) / 2.;
976 v2halfthick = vertex_net_thickness(v2) / 2.;
977
978 v1keepaway = lookup_keepaway(oproute->style);
979 v2keepaway = vertex_net_keepaway(v2);
980
981 ms = v1halfthick + v2halfthick + MAX(v1keepaway, v2keepaway);
982
983 return ms;
984 }
985
986 gdouble
987 min_oproute_net_spacing(toporouter_oproute_t *oproute, toporouter_vertex_t *v2)
988 {
989
990 gdouble v1halfthick, v2halfthick, v1keepaway, v2keepaway, ms;
991
992 v1halfthick = lookup_thickness(oproute->style) / 2.;
993 v2halfthick = cluster_thickness(v2->route->src) / 2.;
994
995 v1keepaway = lookup_keepaway(oproute->style);
996 v2keepaway = cluster_keepaway(v2->route->src);
997
998 ms = v1halfthick + v2halfthick + MAX(v1keepaway, v2keepaway);
999
1000 return ms;
1001 }
1002
1003 gdouble
1004 min_net_net_spacing(toporouter_vertex_t *v1, toporouter_vertex_t *v2)
1005 {
1006
1007 gdouble v1halfthick, v2halfthick, v1keepaway, v2keepaway, ms;
1008
1009 v1halfthick = cluster_thickness(v1->route->src) / 2.;
1010 v2halfthick = cluster_thickness(v2->route->src) / 2.;
1011
1012 v1keepaway = cluster_keepaway(v1->route->src);
1013 v2keepaway = cluster_keepaway(v2->route->src);
1014
1015 ms = v1halfthick + v2halfthick + MAX(v1keepaway, v2keepaway);
1016
1017 return ms;
1018 }
1019
1020 void
1021 toporouter_draw_cluster(toporouter_t *r, drawing_context_t *dc, toporouter_cluster_t *cluster, gdouble red, gdouble green, gdouble blue, guint layer)
1022 {
1023 #if TOPO_OUTPUT_ENABLED
1024 //GList *i = cluster->i;
1025
1026 //while(i) {
1027 // toporouter_bbox_t *box = TOPOROUTER_BBOX(i->data);
1028
1029 // if(box->point && vz(box->point) == layer) {
1030 // cairo_set_source_rgba(dc->cr, red, green, blue, 0.8f);
1031 // cairo_arc(dc->cr, vx(box->point) * dc->s + MARGIN, vy(box->point) * dc->s + MARGIN, 500. * dc->s, 0, 2 * M_PI);
1032 // cairo_fill(dc->cr);
1033 // }
1034
1035 // i = i->next;
1036 //}
1037 #endif
1038 }
1039
1040 void
1041 toporouter_draw_surface(toporouter_t *r, GtsSurface *s, char *filename, int w, int h, int mode, GList *datas, int layer, GList *candidatepoints)
1042 {
1043 #if TOPO_OUTPUT_ENABLED
1044 drawing_context_t *dc;
1045 GList *i;
1046 toporouter_vertex_t *tv, *tv2 = NULL;
1047
1048 dc = toporouter_output_init(w, h, filename);
1049 dc->mode = mode;
1050 dc->data = NULL;
1051
1052 gts_surface_foreach_edge(s, toporouter_draw_edge, dc);
1053 gts_surface_foreach_vertex(s, toporouter_draw_vertex, dc);
1054
1055 i = r->routednets;
1056 while(i) {
1057 GList *j = TOPOROUTER_ROUTE(i->data)->path;
1058 tv2 = NULL;
1059 while(j) {
1060 tv = TOPOROUTER_VERTEX(j->data);
1061 if(GTS_POINT(tv)->z == layer) {
1062 if(tv && tv2) {
1063 cairo_set_source_rgba(dc->cr, 0.0f, 1.0f, 0.0f, 0.8f);
1064 cairo_move_to(dc->cr,
1065 GTS_POINT(tv)->x * dc->s + MARGIN,
1066 GTS_POINT(tv)->y * dc->s + MARGIN);
1067 cairo_line_to(dc->cr,
1068 GTS_POINT(tv2)->x * dc->s + MARGIN,
1069 GTS_POINT(tv2)->y * dc->s + MARGIN);
1070 cairo_stroke(dc->cr);
1071 }
1072
1073 if(tv->flags & VERTEX_FLAG_RED) {
1074 cairo_set_source_rgba(dc->cr, 1., 0., 0., 0.8f);
1075 cairo_arc(dc->cr,
1076 tv->v.p.x * dc->s + MARGIN,
1077 tv->v.p.y * dc->s + MARGIN,
1078 500. * dc->s, 0, 2 * M_PI);
1079 cairo_fill(dc->cr);
1080
1081 }else if(tv->flags & VERTEX_FLAG_GREEN) {
1082 cairo_set_source_rgba(dc->cr, 0., 1., 0., 0.8f);
1083 cairo_arc(dc->cr,
1084 tv->v.p.x * dc->s + MARGIN,
1085 tv->v.p.y * dc->s + MARGIN,
1086 500. * dc->s, 0, 2 * M_PI);
1087 cairo_fill(dc->cr);
1088
1089 }else if(tv->flags & VERTEX_FLAG_BLUE) {
1090 cairo_set_source_rgba(dc->cr, 0., 0., 1., 0.8f);
1091 cairo_arc(dc->cr,
1092 tv->v.p.x * dc->s + MARGIN,
1093 tv->v.p.y * dc->s + MARGIN,
1094 500. * dc->s, 0, 2 * M_PI);
1095 cairo_fill(dc->cr);
1096
1097 }
1098 else {
1099
1100 cairo_set_source_rgba(dc->cr, 1., 1., 1., 0.8f);
1101 cairo_arc(dc->cr,
1102 tv->v.p.x * dc->s + MARGIN,
1103 tv->v.p.y * dc->s + MARGIN,
1104 500. * dc->s, 0, 2 * M_PI);
1105 cairo_fill(dc->cr);
1106
1107
1108 }
1109
1110 if(tv->routingedge && !TOPOROUTER_IS_CONSTRAINT(tv->routingedge)) {
1111 gdouble tempx, tempy, nms, pms;
1112 GList *i = g_list_find(edge_routing(tv->routingedge), tv);
1113 toporouter_vertex_t *nextv, *prevv;
1114
1115 nextv = edge_routing_next(tv->routingedge,i);
1116 prevv = edge_routing_prev(tv->routingedge,i);
1117
1118 nms = min_spacing(tv,nextv);
1119 pms = min_spacing(tv,prevv);
1120
1121 g_assert(finite(nms)); g_assert(finite(pms));
1122
1123 point_from_point_to_point(tv, nextv, nms, &tempx, &tempy);
1124
1125 cairo_set_source_rgba(dc->cr, 0.0f, 1.0f, 1.0f, 0.8f);
1126 cairo_move_to(dc->cr, vx(tv) * dc->s + MARGIN, vy(tv) * dc->s + MARGIN);
1127 cairo_line_to(dc->cr, tempx * dc->s + MARGIN, tempy * dc->s + MARGIN);
1128 cairo_stroke(dc->cr);
1129
1130 point_from_point_to_point(tv, prevv, pms, &tempx, &tempy);
1131
1132 cairo_move_to(dc->cr, vx(tv) * dc->s + MARGIN, vy(tv) * dc->s + MARGIN);
1133 cairo_line_to(dc->cr, tempx * dc->s + MARGIN, tempy * dc->s + MARGIN);
1134 cairo_stroke(dc->cr);
1135
1136
1137
1138
1139 }
1140
1141
1142 }
1143 tv2 = tv;
1144 j = j->next;
1145 }
1146 i = i->next;
1147 }
1148
1149 while(datas) {
1150 toporouter_route_t *routedata = (toporouter_route_t *) datas->data;
1151
1152 GList *i;//, *k;
1153
1154 toporouter_draw_cluster(r, dc, routedata->src, 1., 0., 0., layer);
1155 toporouter_draw_cluster(r, dc, routedata->dest, 0., 0., 1., layer);
1156
1157 tv2 = NULL;
1158 i = routedata->path;
1159 while(i) {
1160 tv = TOPOROUTER_VERTEX(i->data);
1161 if(GTS_POINT(tv)->z == layer) {
1162 if(tv && tv2) {
1163 cairo_set_source_rgba(dc->cr, 0.0f, 1.0f, 0.0f, 0.8f);
1164 cairo_move_to(dc->cr,
1165 GTS_POINT(tv)->x * dc->s + MARGIN,
1166 GTS_POINT(tv)->y * dc->s + MARGIN);
1167 cairo_line_to(dc->cr,
1168 GTS_POINT(tv2)->x * dc->s + MARGIN,
1169 GTS_POINT(tv2)->y * dc->s + MARGIN);
1170 cairo_stroke(dc->cr);
1171 }
1172 }
1173 tv2 = tv;
1174 i = i->next;
1175 }
1176
1177
1178 if(routedata->alltemppoints) {
1179 GList *i, *j;
1180 i = j = g_hash_table_get_keys (routedata->alltemppoints);
1181 while(i) {
1182 toporouter_vertex_t *tv = TOPOROUTER_VERTEX(i->data);
1183
1184 if(GTS_POINT(tv)->z != layer) {
1185 i = i->next;
1186 continue;
1187 }
1188 if(tv->flags & VERTEX_FLAG_BLUE) {
1189 cairo_set_source_rgba(dc->cr, 0., 0., 1., 0.8f);
1190 cairo_arc(dc->cr,
1191 tv->v.p.x * dc->s + MARGIN,
1192 tv->v.p.y * dc->s + MARGIN,
1193 500. * dc->s, 0, 2 * M_PI);
1194 cairo_fill(dc->cr);
1195 }else if(tv->flags & VERTEX_FLAG_RED) {
1196 cairo_set_source_rgba(dc->cr, 1., 0., 0., 0.8f);
1197 cairo_arc(dc->cr,
1198 tv->v.p.x * dc->s + MARGIN,
1199 tv->v.p.y * dc->s + MARGIN,
1200 500. * dc->s, 0, 2 * M_PI);
1201 cairo_fill(dc->cr);
1202
1203 }else if(tv->flags & VERTEX_FLAG_GREEN) {
1204 cairo_set_source_rgba(dc->cr, 0., 1., 0., 0.8f);
1205 cairo_arc(dc->cr,
1206 tv->v.p.x * dc->s + MARGIN,
1207 tv->v.p.y * dc->s + MARGIN,
1208 500. * dc->s, 0, 2 * M_PI);
1209 cairo_fill(dc->cr);
1210 }else{
1211 cairo_set_source_rgba(dc->cr, 1., 1., 1., 0.8f);
1212 cairo_arc(dc->cr,
1213 tv->v.p.x * dc->s + MARGIN,
1214 tv->v.p.y * dc->s + MARGIN,
1215 500. * dc->s, 0, 2 * M_PI);
1216 cairo_fill(dc->cr);
1217 }
1218 i = i->next;
1219 }
1220 g_list_free(j);
1221 }
1222 datas = datas->next;
1223 }
1224 toporouter_output_close(dc);
1225 #endif
1226 }
1227
1228
1229 void
1230 toporouter_layer_free(toporouter_layer_t *l)
1231 {
1232 g_list_free(l->vertices);
1233 g_list_free(l->constraints);
1234
1235 }
1236
1237 guint
1238 groupcount(void)
1239 {
1240 int group;
1241 guint count = 0;
1242
1243 for (group = 0; group < max_layer; group++) {
1244 if(PCB->LayerGroups.Number[group] > 0) count++;
1245 }
1246
1247 return count;
1248 }
1249
1250 void
1251 toporouter_free(toporouter_t *r)
1252 {
1253 struct timeval endtime;
1254 int secs, usecs;
1255
1256 int i;
1257 for(i=0;i<groupcount();i++) {
1258 toporouter_layer_free(&r->layers[i]);
1259 }
1260
1261
1262 gettimeofday(&endtime, NULL);
1263
1264 secs = (int)(endtime.tv_sec - r->starttime.tv_sec);
1265 usecs = (int)((endtime.tv_usec - r->starttime.tv_usec) / 1000);
1266
1267 if(usecs < 0) {
1268 secs -= 1;
1269 usecs += 1000;
1270 }
1271
1272 Message(_("Elapsed time: %d.%02d seconds\n"), secs, usecs);
1273 free(r->layers);
1274 free(r);
1275
1276 }
1277
1278 /* wind:
1279 * returns 1,0,-1 for counterclockwise, collinear or clockwise, respectively.
1280 */
1281 int
1282 wind(toporouter_spoint_t *p1, toporouter_spoint_t *p2, toporouter_spoint_t *p3)
1283 {
1284 double rval, dx1, dx2, dy1, dy2;
1285 dx1 = p2->x - p1->x; dy1 = p2->y - p1->y;
1286 dx2 = p3->x - p2->x; dy2 = p3->y - p2->y;
1287 rval = (dx1*dy2)-(dy1*dx2);
1288 return (rval > 0.0001) ? 1 : ((rval < -0.0001) ? -1 : 0);
1289 }
1290
1291 /* wind_double:
1292 * returns 1,0,-1 for counterclockwise, collinear or clockwise, respectively.
1293 */
1294 int
1295 wind_double(gdouble p1_x, gdouble p1_y, gdouble p2_x, gdouble p2_y, gdouble p3_x, gdouble p3_y)
1296 {
1297 double rval, dx1, dx2, dy1, dy2;
1298 dx1 = p2_x - p1_x; dy1 = p2_y - p1_y;
1299 dx2 = p3_x - p2_x; dy2 = p3_y - p2_y;
1300 rval = (dx1*dy2)-(dy1*dx2);
1301 return (rval > 0.0001) ? 1 : ((rval < -0.0001) ? -1 : 0);
1302 }
1303
1304 inline void
1305 print_toporouter_constraint(toporouter_constraint_t *tc)
1306 {
1307 printf("%f,%f -> %f,%f ",
1308 tc->c.edge.segment.v1->p.x,
1309 tc->c.edge.segment.v1->p.y,
1310 tc->c.edge.segment.v2->p.x,
1311 tc->c.edge.segment.v2->p.y);
1312 }
1313
1314 inline void
1315 print_toporouter_vertex(toporouter_vertex_t *tv)
1316 {
1317 printf("%f,%f ", tv->v.p.x, tv->v.p.y);
1318 }
1319
1320
1321 /**
1322 * vertices_on_line:
1323 * Given vertex a, gradient m, and radius r:
1324 *
1325 * Return vertices on line of a & m at r from a
1326 */
1327 void
1328 vertices_on_line(toporouter_spoint_t *a, gdouble m, gdouble r, toporouter_spoint_t *b0, toporouter_spoint_t *b1)
1329 {
1330
1331 gdouble c, temp;
1332
1333 if(m == INFINITY || m == -INFINITY) {
1334 b0->y = a->y + r;
1335 b1->y = a->y - r;
1336
1337 b0->x = a->x;
1338 b1->x = a->x;
1339
1340 return;
1341 }
1342
1343 c = a->y - (m * a->x);
1344
1345 temp = sqrt( pow(r, 2) / ( 1 + pow(m, 2) ) );
1346
1347 b0->x = a->x + temp;
1348 b1->x = a->x - temp;
1349
1350 b0->y = b0->x * m + c;
1351 b1->y = b1->x * m + c;
1352
1353 }
1354
1355 /**
1356 * vertices_on_line:
1357 * Given vertex a, gradient m, and radius r:
1358 *
1359 * Return vertices on line of a & m at r from a
1360 */
1361 void
1362 coords_on_line(gdouble ax, gdouble ay, gdouble m, gdouble r, gdouble *b0x, gdouble *b0y, gdouble *b1x, gdouble *b1y)
1363 {
1364
1365 gdouble c, temp;
1366
1367 if(m == INFINITY || m == -INFINITY) {
1368 *b0y = ay + r;
1369 *b1y = ay - r;
1370
1371 *b0x = ax;
1372 *b1x = ax;
1373
1374 return;
1375 }
1376
1377 c = ay - (m * ax);
1378
1379 temp = sqrt( pow(r, 2) / ( 1 + pow(m, 2) ) );
1380
1381 *b0x = ax + temp;
1382 *b1x = ax - temp;
1383
1384 *b0y = *b0x * m + c;
1385 *b1y = *b1x * m + c;
1386
1387 }
1388
1389 /**
1390 * vertices_on_line:
1391 * Given vertex a, gradient m, and radius r:
1392 *
1393 * Return vertices on line of a & m at r from a
1394 */
1395 void
1396 points_on_line(GtsPoint *a, gdouble m, gdouble r, GtsPoint *b0, GtsPoint *b1)
1397 {
1398
1399 gdouble c, temp;
1400
1401 if(m == INFINITY || m == -INFINITY) {
1402 b0->y = a->y + r;
1403 b1->y = a->y - r;
1404
1405 b0->x = a->x;
1406 b1->x = a->x;
1407
1408 return;
1409 }
1410
1411 c = a->y - (m * a->x);
1412
1413 temp = sqrt( pow(r, 2) / ( 1 + pow(m, 2) ) );
1414
1415 b0->x = a->x + temp;
1416 b1->x = a->x - temp;
1417
1418 b0->y = b0->x * m + c;
1419 b1->y = b1->x * m + c;
1420
1421 }
1422
1423 /*
1424 * Returns gradient of segment given by a & b
1425 */
1426 gdouble
1427 vertex_gradient(toporouter_spoint_t *a, toporouter_spoint_t *b)
1428 {
1429 if(a->x == b->x) return INFINITY;
1430
1431 return ((b->y - a->y) / (b->x - a->x));
1432 }
1433
1434 /*
1435 * Returns gradient of segment given by (x0,y0) & (x1,y1)
1436 */
1437 inline gdouble
1438 cartesian_gradient(gdouble x0, gdouble y0, gdouble x1, gdouble y1)
1439 {
1440 if(epsilon_equals(x0,x1)) return INFINITY;
1441
1442 return ((y1 - y0) / (x1 - x0));
1443 }
1444
1445 /*
1446 * Returns gradient of segment given by (x0,y0) & (x1,y1)
1447 */
1448 inline gdouble
1449 point_gradient(GtsPoint *a, GtsPoint *b)
1450 {
1451 return cartesian_gradient(a->x, a->y, b->x, b->y);
1452 }
1453
1454 gdouble
1455 segment_gradient(GtsSegment *s)
1456 {
1457 return cartesian_gradient(
1458 GTS_POINT(s->v1)->x,
1459 GTS_POINT(s->v1)->y,
1460 GTS_POINT(s->v2)->x,
1461 GTS_POINT(s->v2)->y);
1462 }
1463
1464 /*
1465 * Returns gradient perpendicular to m
1466 */
1467 gdouble
1468 perpendicular_gradient(gdouble m)
1469 {
1470 if(isinf(m)) return 0.0f;
1471 if(m < EPSILON && m > -EPSILON) return INFINITY;
1472 return -1.0f/m;
1473 }
1474
1475 /*
1476 * Returns the distance between two vertices in the x-y plane
1477 */
1478 gdouble
1479 vertices_plane_distance(toporouter_spoint_t *a, toporouter_spoint_t *b) {
1480 return sqrt( pow(a->x - b->x, 2) + pow(a->y - b->y, 2) );
1481 }
1482
1483 /*
1484 * Finds the point p distance r away from a on the line segment of a & b
1485 */
1486 inline void
1487 vertex_outside_segment(toporouter_spoint_t *a, toporouter_spoint_t *b, gdouble r, toporouter_spoint_t *p)
1488 {
1489 gdouble m;
1490 toporouter_spoint_t temp[2];
1491
1492 m = vertex_gradient(a,b);
1493
1494 vertices_on_line(a, vertex_gradient(a,b), r, &temp[0], &temp[1]);
1495
1496 if(vertices_plane_distance(&temp[0], b) > vertices_plane_distance(&temp[1], b)) {
1497 p->x = temp[0].x;
1498 p->y = temp[0].y;
1499 }else{
1500 p->x = temp[1].x;
1501 p->y = temp[1].y;
1502 }
1503
1504 }
1505
1506 /* proper intersection:
1507 * AB and CD must share a point interior to both segments.
1508 * returns TRUE if AB properly intersects CD.
1509 */
1510 gint
1511 coord_intersect_prop(gdouble ax, gdouble ay, gdouble bx, gdouble by, gdouble cx, gdouble cy, gdouble dx, gdouble dy)
1512 {
1513 gint wind_abc = coord_wind(ax, ay, bx, by, cx, cy);
1514 gint wind_abd = coord_wind(ax, ay, bx, by, dx, dy);
1515 gint wind_cda = coord_wind(cx, cy, dx, dy, ax, ay);
1516 gint wind_cdb = coord_wind(cx, cy, dx, dy, bx, by);
1517
1518 if( !wind_abc || !wind_abd || !wind_cda || !wind_cdb ) return 0;
1519
1520 return ( wind_abc ^ wind_abd ) && ( wind_cda ^ wind_cdb );
1521 }
1522
1523 /* proper intersection:
1524 * AB and CD must share a point interior to both segments.
1525 * returns TRUE if AB properly intersects CD.
1526 */
1527 int
1528 point_intersect_prop(GtsPoint *a, GtsPoint *b, GtsPoint *c, GtsPoint *d)
1529 {
1530
1531 if( point_wind(a, b, c) == 0 ||
1532 point_wind(a, b, d) == 0 ||
1533 point_wind(c, d, a) == 0 ||
1534 point_wind(c, d, b) == 0 ) return 0;
1535
1536 return ( point_wind(a, b, c) ^ point_wind(a, b, d) ) &&
1537 ( point_wind(c, d, a) ^ point_wind(c, d, b) );
1538 }
1539
1540 inline int
1541 vertex_intersect_prop(GtsVertex *a, GtsVertex *b, GtsVertex *c, GtsVertex *d)
1542 {
1543 return point_intersect_prop(GTS_POINT(a), GTS_POINT(b), GTS_POINT(c), GTS_POINT(d));
1544 }
1545
1546 inline int
1547 tvertex_intersect_prop(toporouter_vertex_t *a, toporouter_vertex_t *b, toporouter_vertex_t *c, toporouter_vertex_t *d)
1548 {
1549 return point_intersect_prop(GTS_POINT(a), GTS_POINT(b), GTS_POINT(c), GTS_POINT(d));
1550 }
1551 /*
1552 inline int
1553 tvertex_intersect(toporouter_vertex_t *a, toporouter_vertex_t *b, toporouter_vertex_t *c, toporouter_vertex_t *d)
1554 {
1555 if( !point_wind(GTS_POINT(a), GTS_POINT(d), GTS_POINT(b)) || !point_wind(GTS_POINT(a), GTS_POINT(c), GTS_POINT(b)) ) return 1;
1556
1557 return
1558 ( point_wind(GTS_POINT(a), GTS_POINT(b), GTS_POINT(c)) ^ point_wind(GTS_POINT(a), GTS_POINT(b), GTS_POINT(d)) ) &&
1559 ( point_wind(GTS_POINT(c), GTS_POINT(d), GTS_POINT(a)) ^ point_wind(GTS_POINT(c), GTS_POINT(d), GTS_POINT(b)) );
1560 }
1561 */
1562
1563 /* intersection vertex:
1564 * AB and CD must share a point interior to both segments.
1565 * returns vertex at intersection of AB and CD.
1566 */
1567 GtsVertex *
1568 vertex_intersect(GtsVertex *a, GtsVertex *b, GtsVertex *c, GtsVertex *d)
1569 {
1570 GtsVertexClass *vertex_class = GTS_VERTEX_CLASS (toporouter_vertex_class ());
1571 GtsVertex *rval;
1572 gdouble ua_top, ua_bot, ua, rx, ry;
1573
1574 /* TODO: this could be done more efficiently without duplicating computation */
1575 if(!vertex_intersect_prop(a, b, c, d)) return NULL;
1576
1577 ua_top = ((d->p.x - c->p.x) * (a->p.y - c->p.y)) -
1578 ((d->p.y - c->p.y) * (a->p.x - c->p.x));
1579 ua_bot = ((d->p.y - c->p.y) * (b->p.x - a->p.x)) -
1580 ((d->p.x - c->p.x) * (b->p.y - a->p.y));
1581 ua = ua_top / ua_bot;
1582 rx = a->p.x + (ua * (b->p.x - a->p.x));
1583 ry = a->p.y + (ua * (b->p.y - a->p.y));
1584
1585 rval = gts_vertex_new (vertex_class, rx, ry, 0.0f);
1586
1587 return rval;
1588 }
1589
1590 /* intersection vertex:
1591 * AB and CD must share a point interior to both segments.
1592 * returns vertex at intersection of AB and CD.
1593 */
1594 void
1595 coord_intersect(gdouble ax, gdouble ay, gdouble bx, gdouble by, gdouble cx, gdouble cy, gdouble dx, gdouble dy, gdouble *rx, gdouble *ry)
1596 {
1597 gdouble ua_top, ua_bot, ua;
1598
1599 ua_top = ((dx - cx) * (ay - cy)) - ((dy - cy) * (ax - cx));
1600 ua_bot = ((dy - cy) * (bx - ax)) - ((dx - cx) * (by - ay));
1601 ua = ua_top / ua_bot;
1602 *rx = ax + (ua * (bx - ax));
1603 *ry = ay + (ua * (by - ay));
1604
1605 }
1606
1607
1608 /*
1609 * returns true if c is between a and b
1610 */
1611 int
1612 point_between(GtsPoint *a, GtsPoint *b, GtsPoint *c)
1613 {
1614 if( point_wind(a, b, c) != 0 ) return 0;
1615
1616 if( a->x != b->x ) {
1617 return ((a->x <= c->x) &&
1618 (c->x <= b->x)) ||
1619 ((a->x >= c->x) &&
1620 (c->x >= b->x));
1621 }
1622 return ((a->y <= c->y) &&
1623 (c->y <= b->y)) ||
1624 ((a->y >= c->y) &&
1625 (c->y >= b->y));
1626 }
1627
1628 inline int
1629 vertex_between(GtsVertex *a, GtsVertex *b, GtsVertex *c)
1630 {
1631 return point_between(GTS_POINT(a), GTS_POINT(b), GTS_POINT(c));
1632 }
1633
1634 void
1635 delaunay_create_from_vertices(GList *vertices, GtsSurface **surface, GtsTriangle **t)
1636 {
1637 GList *i = vertices;
1638 GtsVertex *v1, *v2, *v3;
1639 GSList *vertices_slist = NULL;
1640
1641 while (i) {
1642 vertices_slist = g_slist_prepend(vertices_slist, i->data);
1643 i = i->next;
1644 }
1645
1646 // TODO: just work this out from the board outline
1647 *t = gts_triangle_enclosing (gts_triangle_class (), vertices_slist, 100000.0f);
1648 gts_triangle_vertices (*t, &v1, &v2, &v3);
1649
1650 *surface = gts_surface_new (gts_surface_class (), gts_face_class (),
1651 GTS_EDGE_CLASS(toporouter_edge_class ()), GTS_VERTEX_CLASS(toporouter_vertex_class ()) );
1652
1653 gts_surface_add_face (*surface, gts_face_new (gts_face_class (), (*t)->e1, (*t)->e2, (*t)->e3));
1654
1655 i = vertices;
1656 while (i) {
1657 toporouter_vertex_t *v = TOPOROUTER_VERTEX(gts_delaunay_add_vertex (*surface, i->data, NULL));
1658
1659 if(v) {
1660 printf("ERROR: vertex could not be added to CDT ");
1661 print_vertex(v);
1662 }
1663
1664 i = i->next;
1665 }
1666
1667 gts_allow_floating_vertices = TRUE;
1668 gts_object_destroy (GTS_OBJECT (v1));
1669 gts_object_destroy (GTS_OBJECT (v2));
1670 gts_object_destroy (GTS_OBJECT (v3));
1671 gts_allow_floating_vertices = FALSE;
1672
1673 g_slist_free(vertices_slist);
1674 // return surface;
1675 }
1676
1677 GSList *
1678 list_to_slist(GList *i)
1679 {
1680 GSList *rval = NULL;
1681 while(i) {
1682 rval = g_slist_prepend(rval, i->data);
1683 i = i->next;
1684 }
1685 return rval;
1686 }
1687
1688 toporouter_bbox_t *
1689 toporouter_bbox_create_from_points(int layer, GList *vertices, toporouter_term_t type, gpointer data)
1690 {
1691 toporouter_bbox_t *bbox;
1692 GSList *vertices_slist = list_to_slist(vertices);
1693
1694 // delaunay_create_from_vertices(vertices, &s, &t);
1695 bbox = TOPOROUTER_BBOX( gts_bbox_points(GTS_BBOX_CLASS(toporouter_bbox_class()), vertices_slist) );
1696 bbox->type = type;
1697 bbox->data = data;
1698
1699 bbox->surface = NULL;
1700 bbox->enclosing = NULL;
1701
1702 bbox->layer = layer;
1703
1704 bbox->point = NULL;
1705 bbox->realpoint = NULL;
1706
1707 g_slist_free(vertices_slist);
1708 return bbox;
1709 }
1710
1711 toporouter_bbox_t *
1712 toporouter_bbox_create(int layer, GList *vertices, toporouter_term_t type, gpointer data)
1713 {
1714 toporouter_bbox_t *bbox;
1715 GtsSurface *s;
1716 GtsTriangle *t;
1717
1718 delaunay_create_from_vertices(vertices, &s, &t);
1719 bbox = TOPOROUTER_BBOX( gts_bbox_surface(GTS_BBOX_CLASS(toporouter_bbox_class()), s) );
1720 bbox->type = type;
1721 bbox->data = data;
1722
1723 bbox->surface = s;
1724 bbox->enclosing = t;
1725
1726 bbox->layer = layer;
1727
1728 return bbox;
1729 }
1730
1731 GtsVertex *
1732 insert_vertex(toporouter_t *r, toporouter_layer_t *l, gdouble x, gdouble y, toporouter_bbox_t *box)
1733 {
1734 GtsVertexClass *vertex_class = GTS_VERTEX_CLASS (toporouter_vertex_class ());
1735 GtsVertex *v;
1736 GList *i;
1737
1738 i = l->vertices;
1739 while (i) {
1740 v = i->data;
1741 if(v->p.x == x && v->p.y == y) {
1742 TOPOROUTER_VERTEX(v)->bbox = box;
1743 return v;
1744 }
1745 i = i->next;
1746 }
1747
1748 v = gts_vertex_new (vertex_class , x, y, l - r->layers);
1749 TOPOROUTER_VERTEX(v)->bbox = box;
1750 l->vertices = g_list_prepend(l->vertices, v);
1751
1752 return v;
1753 }
1754
1755 GList *
1756 insert_constraint_edge(toporouter_t *r, toporouter_layer_t *l, gdouble x1, gdouble y1, guint flags1,
1757 gdouble x2, gdouble y2, guint flags2, toporouter_bbox_t *box)
1758 {
1759 GtsVertexClass *vertex_class = GTS_VERTEX_CLASS (toporouter_vertex_class ());
1760 GtsEdgeClass *edge_class = GTS_EDGE_CLASS (toporouter_constraint_class ());
1761 GtsVertex *p[2];
1762 GtsVertex *v;
1763 GList *i;
1764 GtsEdge *e;
1765
1766 p[0] = p[1] = NULL;
1767
1768 /* insert or find points */
1769
1770 i = l->vertices;
1771 while (i) {
1772 v = i->data;
1773 if(v->p.x == x1 && v->p.y == y1)
1774 p[0] = v;
1775 if(v->p.x == x2 && v->p.y == y2)
1776 p[1] = v;
1777 i = i->next;
1778 }
1779
1780 if(p[0] == NULL) {
1781 p[0] = gts_vertex_new (vertex_class, x1, y1, l - r->layers);
1782 TOPOROUTER_VERTEX(p[0])->bbox = box;
1783 l->vertices = g_list_prepend(l->vertices, p[0]);
1784 }
1785 if(p[1] == NULL) {
1786 p[1] = gts_vertex_new (vertex_class, x2, y2, l - r->layers);
1787 TOPOROUTER_VERTEX(p[1])->bbox = box;
1788 l->vertices = g_list_prepend(l->vertices, p[1]);
1789 }
1790
1791 TOPOROUTER_VERTEX(p[0])->flags = flags1;
1792 TOPOROUTER_VERTEX(p[1])->flags = flags2;
1793
1794 e = gts_edge_new (edge_class, p[0], p[1]);
1795 TOPOROUTER_CONSTRAINT(e)->box = box;
1796 l->constraints = g_list_prepend (l->constraints, e);
1797 // return insert_constraint_edge_rec(r, l, p, box);
1798 return g_list_prepend(NULL, e);
1799
1800 }
1801
1802 void
1803 insert_constraints_from_list(toporouter_t *r, toporouter_layer_t *l, GList *vlist, toporouter_bbox_t *box)
1804 {
1805 GList *i = vlist;
1806 toporouter_vertex_t *pv = NULL, *v;
1807
1808 while(i) {
1809 v = TOPOROUTER_VERTEX(i->data);
1810
1811 if(pv) {
1812 box->constraints =
1813 g_list_concat(box->constraints, insert_constraint_edge(r, l, vx(v), vy(v), v->flags, vx(pv), vy(pv), pv->flags, box));
1814 }
1815
1816 pv = v;
1817 i = i->next;
1818 }
1819
1820 v = TOPOROUTER_VERTEX(vlist->data);
1821 box->constraints =
1822 g_list_concat(box->constraints, insert_constraint_edge(r, l, vx(v), vy(v), v->flags, vx(pv), vy(pv), pv->flags, box));
1823
1824 }
1825
1826 void
1827 insert_centre_point(toporouter_t *r, toporouter_layer_t *l, gdouble x, gdouble y)
1828 {
1829 GList *i;
1830 GtsVertexClass *vertex_class = GTS_VERTEX_CLASS (toporouter_vertex_class ());
1831
1832 i = l->vertices;
1833 while (i) {
1834 GtsPoint *p = GTS_POINT(i->data);
1835 if(p->x == x && p->y == y)
1836 return;
1837 i = i->next;
1838 }
1839
1840 l->vertices = g_list_prepend(l->vertices, gts_vertex_new(vertex_class, x, y, 0.0f));
1841 }
1842
1843 GtsPoint *
1844 midpoint(GtsPoint *a, GtsPoint *b)
1845 {
1846 return gts_point_new(gts_point_class(), (a->x + b->x) / 2., (a->y + b->y) / 2., 0.);
1847 }
1848
1849 inline gdouble
1850 pad_rad(PadType *pad)
1851 {
1852 return (lookup_thickness(pad->Name) / 2.) + lookup_keepaway(pad->Name);
1853 }
1854
1855 inline gdouble
1856 pin_rad(PinType *pin)
1857 {
1858 return (lookup_thickness(pin->Name) / 2.) + lookup_keepaway(pin->Name);
1859 }
1860
1861 GList *
1862 rect_with_attachments(gdouble rad,
1863 gdouble x0, gdouble y0,
1864 gdouble x1, gdouble y1,
1865 gdouble x2, gdouble y2,
1866 gdouble x3, gdouble y3,
1867 gdouble z)
1868 {
1869 GtsVertexClass *vertex_class = GTS_VERTEX_CLASS (toporouter_vertex_class ());
1870 GList *r = NULL, *rr = NULL, *i;
1871 toporouter_vertex_t *curpoint, *temppoint;
1872
1873
1874 curpoint = TOPOROUTER_VERTEX(gts_vertex_new (vertex_class, x0, y0, z));
1875
1876 r = g_list_prepend(NULL, curpoint);
1877 r = g_list_prepend(r, gts_vertex_new (vertex_class, x1, y1, z));
1878 r = g_list_prepend(r, gts_vertex_new (vertex_class, x2, y2, z));
1879 r = g_list_prepend(r, gts_vertex_new (vertex_class, x3, y3, z));
1880
1881 i = r;
1882 while(i) {
1883 temppoint = TOPOROUTER_VERTEX(i->data);
1884 rr = g_list_prepend(rr, curpoint);
1885
1886 curpoint = temppoint;
1887 i = i->next;
1888 }
1889
1890 g_list_free(r);
1891
1892 return rr;
1893 }
1894
1895 #define VERTEX_CENTRE(x) TOPOROUTER_VERTEX( vertex_bbox(x)->point )
1896
1897 /*
1898 * Read pad data from layer into toporouter_layer_t struct
1899 *
1900 * Inserts points and constraints into GLists
1901 */
1902 int
1903 read_pads(toporouter_t *r, toporouter_layer_t *l, guint layer)
1904 {
1905 toporouter_spoint_t p[2], rv[5];
1906 gdouble x[2], y[2], t, m;
1907 GList *objectconstraints;
1908
1909 GList *vlist = NULL;
1910 toporouter_bbox_t *bbox = NULL;
1911
1912 guint front = GetLayerGroupNumberByNumber (max_layer + COMPONENT_LAYER);
1913 guint back = GetLayerGroupNumberByNumber (max_layer + SOLDER_LAYER);
1914
1915 // printf("read_pads: front = %d back = %d layer = %d\n",
1916 // front, back, layer);
1917
1918 /* If its not the top or bottom layer, there are no pads to read */
1919 if(l - r->layers != front && l - r->layers != back) return 0;
1920
1921 ELEMENT_LOOP(PCB->Data);
1922 {
1923 PAD_LOOP(element);
1924 {
1925 if( (l - r->layers == back && TEST_FLAG(ONSOLDERFLAG, pad)) ||
1926 (l - r->layers == front && !TEST_FLAG(ONSOLDERFLAG, pad)) ) {
1927
1928
1929 objectconstraints = NULL;
1930 t = (gdouble)pad->Thickness / 2.0f;
1931 x[0] = pad->Point1.X;
1932 x[1] = pad->Point2.X;
1933 y[0] = pad->Point1.Y;
1934 y[1] = pad->Point2.Y;
1935
1936
1937 if(TEST_FLAG(SQUAREFLAG, pad)) {
1938 /* Square or oblong pad. Four points and four constraint edges are
1939 * used */
1940
1941 if(x[0] == x[1] && y[0] == y[1]) {
1942 /* Pad is square */
1943
1944 // vlist = g_list_prepend(NULL, gts_vertex_new (vertex_class, x[0]-t, y[0]-t, 0.));
1945 // vlist = g_list_prepend(vlist, gts_vertex_new (vertex_class, x[0]-t, y[0]+t, 0.));
1946 // vlist = g_list_prepend(vlist, gts_vertex_new (vertex_class, x[0]+t, y[0]+t, 0.));
1947 // vlist = g_list_prepend(vlist, gts_vertex_new (vertex_class, x[0]+t, y[0]-t, 0.));
1948 vlist = rect_with_attachments(pad_rad(pad),
1949 x[0]-t, y[0]-t,
1950 x[0]-t, y[0]+t,
1951 x[0]+t, y[0]+t,
1952 x[0]+t, y[0]-t,
1953 l - r->layers);
1954 bbox = toporouter_bbox_create(l - r->layers, vlist, PAD, pad);
1955 r->bboxes = g_slist_prepend(r->bboxes, bbox);
1956 insert_constraints_from_list(r, l, vlist, bbox);
1957 g_list_free(vlist);
1958
1959 //bbox->point = GTS_POINT( gts_vertex_new(vertex_class, x[0], y[0], 0.) );
1960 bbox->point = GTS_POINT( insert_vertex(r, l, x[0], y[0], bbox) );
1961 g_assert(TOPOROUTER_VERTEX(bbox->point)->bbox == bbox);
1962 }else {
1963 /* Pad is diagonal oblong or othogonal oblong */
1964
1965 m = cartesian_gradient(x[0], y[0], x[1], y[1]);
1966
1967 p[0].x = x[0]; p[0].y = y[0];
1968 p[1].x = x[1]; p[1].y = y[1];
1969
1970 vertex_outside_segment(&p[0], &p[1], t, &rv[0]);
1971 vertices_on_line(&rv[0], perpendicular_gradient(m), t, &rv[1], &rv[2]);
1972
1973 vertex_outside_segment(&p[1], &p[0], t, &rv[0]);
1974 vertices_on_line(&rv[0], perpendicular_gradient(m), t, &rv[3], &rv[4]);
1975
1976 if(wind(&rv[1], &rv[2], &rv[3]) != wind(&rv[2], &rv[3], &rv[4])) {
1977 rv[0].x = rv[3].x; rv[0].y = rv[3].y;
1978 rv[3].x = rv[4].x; rv[3].y = rv[4].y;
1979 rv[4].x = rv[0].x; rv[4].y = rv[0].y;
1980 }
1981
1982 // vlist = g_list_prepend(NULL, gts_vertex_new (vertex_class, rv[1].x, rv[1].y, 0.));
1983 // vlist = g_list_prepend(vlist, gts_vertex_new (vertex_class, rv[2].x, rv[2].y, 0.));
1984 // vlist = g_list_prepend(vlist, gts_vertex_new (vertex_class, rv[3].x, rv[3].y, 0.));
1985 // vlist = g_list_prepend(vlist, gts_vertex_new (vertex_class, rv[4].x, rv[4].y, 0.));
1986 vlist = rect_with_attachments(pad_rad(pad),
1987 rv[1].x, rv[1].y,
1988 rv[2].x, rv[2].y,
1989 rv[3].x, rv[3].y,
1990 rv[4].x, rv[4].y,
1991 l - r->layers);
1992 bbox = toporouter_bbox_create(l - r->layers, vlist, PAD, pad);
1993 r->bboxes = g_slist_prepend(r->bboxes, bbox);
1994 insert_constraints_from_list(r, l, vlist, bbox);
1995 g_list_free(vlist);
1996
1997 //bbox->point = GTS_POINT( gts_vertex_new(vertex_class, (x[0] + x[1]) / 2., (y[0] + y[1]) / 2., 0.) );
1998 bbox->point = GTS_POINT( insert_vertex(r, l, (x[0] + x[1]) / 2., (y[0] + y[1]) / 2., bbox) );
1999 g_assert(TOPOROUTER_VERTEX(bbox->point)->bbox == bbox);
2000
2001 }
2002
2003 }else {
2004 /* Either round pad or pad with curved edges */
2005
2006 if(x[0] == x[1] && y[0] == y[1]) {
2007 /* One point */
2008
2009 /* bounding box same as square pad */
2010 vlist = rect_with_attachments(pad_rad(pad),
2011 x[0]-t, y[0]-t,
2012 x[0]-t, y[0]+t,
2013 x[0]+t, y[0]+t,
2014 x[0]+t, y[0]-t,
2015 l - r->layers);
2016 bbox = toporouter_bbox_create(l - r->layers, vlist, PAD, pad);
2017 r->bboxes = g_slist_prepend(r->bboxes, bbox);
2018 g_list_free(vlist);
2019
2020 //bbox->point = GTS_POINT( insert_vertex(r, l, x[0], y[0], bbox) );
2021 bbox->point = GTS_POINT( insert_vertex(r, l, x[0], y[0], bbox) );
2022
2023 }else{
2024 /* Two points and one constraint edge */
2025
2026 /* the rest is just for bounding box */
2027 m = cartesian_gradient(x[0], y[0], x[1], y[1]);
2028
2029 p[0].x = x[0]; p[0].y = y[0];
2030 p[1].x = x[1]; p[1].y = y[1];
2031
2032 vertex_outside_segment(&p[0], &p[1], t, &rv[0]);
2033 vertices_on_line(&rv[0], perpendicular_gradient(m), t, &rv[1], &rv[2]);
2034
2035 vertex_outside_segment(&p[1], &p[0], t, &rv[0]);
2036 vertices_on_line(&rv[0], perpendicular_gradient(m), t, &rv[3], &rv[4]);
2037
2038 if(wind(&rv[1], &rv[2], &rv[3]) != wind(&rv[2], &rv[3], &rv[4])) {
2039 rv[0].x = rv[3].x; rv[0].y = rv[3].y;
2040 rv[3].x = rv[4].x; rv[3].y = rv[4].y;
2041 rv[4].x = rv[0].x; rv[4].y = rv[0].y;
2042 }
2043
2044 vlist = rect_with_attachments(pad_rad(pad),
2045 rv[1].x, rv[1].y,
2046 rv[2].x, rv[2].y,
2047 rv[3].x, rv[3].y,
2048 rv[4].x, rv[4].y,
2049 l - r->layers);
2050 bbox = toporouter_bbox_create(l - r->layers, vlist, PAD, pad);
2051 r->bboxes = g_slist_prepend(r->bboxes, bbox);
2052 insert_constraints_from_list(r, l, vlist, bbox);
2053 g_list_free(vlist);
2054
2055 //bbox->point = GTS_POINT( gts_vertex_new(vertex_class, (x[0] + x[1]) / 2., (y[0] + y[1]) / 2., 0.) );
2056 bbox->point = GTS_POINT( insert_vertex(r, l, (x[0] + x[1]) / 2., (y[0] + y[1]) / 2., bbox) );
2057
2058 //bbox->constraints = g_list_concat(bbox->constraints, insert_constraint_edge(r, l, x[0], y[0], x[1], y[1], bbox));
2059
2060 }
2061
2062
2063 }
2064
2065 }
2066 }
2067 END_LOOP;
2068 }
2069 END_LOOP;
2070
2071 return 0;
2072 }
2073
2074 /*
2075 * Read points data (all layers) into GList
2076 *
2077 * Inserts pin and via points
2078 */
2079 int
2080 read_points(toporouter_t *r, toporouter_layer_t *l, int layer)
2081 {
2082 gdouble x, y, t;
2083
2084 GList *vlist = NULL;
2085 toporouter_bbox_t *bbox = NULL;
2086
2087 ELEMENT_LOOP(PCB->Data);
2088 {
2089 PIN_LOOP(element);
2090 {
2091
2092 t = (gdouble)pin->Thickness / 2.0f;
2093 x = pin->X;
2094 y = pin->Y;
2095
2096 if(TEST_FLAG (SQUAREFLAG, pin)) {
2097
2098 vlist = rect_with_attachments(pin_rad(pin),
2099 x-t, y-t,
2100 x-t, y+t,
2101 x+t, y+t,
2102 x+t, y-t,
2103 l - r->layers);
2104 bbox = toporouter_bbox_create(l - r->layers, vlist, PIN, pin);
2105 r->bboxes = g_slist_prepend(r->bboxes, bbox);
2106 insert_constraints_from_list(r, l, vlist, bbox);
2107 g_list_free(vlist);
2108 bbox->point = GTS_POINT( insert_vertex(r, l, x, y, bbox) );
2109
2110 }else if(TEST_FLAG(OCTAGONFLAG, pin)){
2111 /* TODO: Handle octagon pins */
2112 fprintf(stderr, "No support for octagon pins yet\n");
2113 }else{
2114 vlist = rect_with_attachments(pin_rad(pin),
2115 x-t, y-t,
2116 x-t, y+t,
2117 x+t, y+t,
2118 x+t, y-t,
2119 l - r->layers);
2120 bbox = toporouter_bbox_create(l - r->layers, vlist, PIN, pin);
2121 r->bboxes = g_slist_prepend(r->bboxes, bbox);
2122 g_list_free(vlist);
2123 bbox->point = GTS_POINT( insert_vertex(r, l, x, y, bbox) );
2124 }
2125 }
2126 END_LOOP;
2127 }
2128 END_LOOP;
2129
2130 VIA_LOOP(PCB->Data);
2131 {
2132
2133 t = (gdouble)via->Thickness / 2.0f;
2134 x = via->X;
2135 y = via->Y;
2136
2137 if(TEST_FLAG (SQUAREFLAG, via)) {
2138
2139 vlist = rect_with_attachments(pin_rad((PinType*)via),
2140 x-t, y-t,
2141 x-t, y+t,
2142 x+t, y+t,
2143 x+t, y-t,
2144 l - r->layers);
2145 bbox = toporouter_bbox_create(l - r->layers, vlist, VIA, via);
2146 r->bboxes = g_slist_prepend(r->bboxes, bbox);
2147 insert_constraints_from_list(r, l, vlist, bbox);
2148 g_list_free(vlist);
2149 bbox->point = GTS_POINT( insert_vertex(r, l, x, y, bbox) );
2150
2151 }else if(TEST_FLAG(OCTAGONFLAG, via)){
2152 /* TODO: Handle octagon vias */
2153 fprintf(stderr, "No support for octagon vias yet\n");
2154 }else{
2155
2156 vlist = rect_with_attachments(pin_rad((PinType*)via),
2157 x-t, y-t,
2158 x-t, y+t,
2159 x+t, y+t,
2160 x+t, y-t,
2161 l - r->layers);
2162 bbox = toporouter_bbox_create(l - r->layers, vlist, VIA, via);
2163 r->bboxes = g_slist_prepend(r->bboxes, bbox);
2164 g_list_free(vlist);
2165
2166 bbox->point = GTS_POINT( insert_vertex(r, l, x, y, bbox) );
2167
2168 }
2169 }
2170 END_LOOP;
2171 return 0;
2172 }
2173
2174 /*
2175 * Read line data from layer into toporouter_layer_t struct
2176 *
2177 * Inserts points and constraints into GLists
2178 */
2179 int
2180 read_lines(toporouter_t *r, toporouter_layer_t *l, LayerType *layer, int ln)
2181 {
2182 gdouble xs[2], ys[2];
2183
2184 GList *vlist = NULL;
2185 toporouter_bbox_t *bbox = NULL;
2186
2187 GtsVertexClass *vertex_class = GTS_VERTEX_CLASS (toporouter_vertex_class ());
2188
2189 LINE_LOOP(layer);
2190 {
2191 xs[0] = line->Point1.X;
2192 xs[1] = line->Point2.X;
2193 ys[0] = line->Point1.Y;
2194 ys[1] = line->Point2.Y;
2195 if(!(xs[0] == xs[1] && ys[0] == ys[1])) {
2196 vlist = g_list_prepend(NULL, gts_vertex_new (vertex_class, xs[0], ys[0], l - r->layers));
2197 vlist = g_list_prepend(vlist, gts_vertex_new (vertex_class, xs[1], ys[1], l - r->layers));
2198 // TODO: replace this with surface version
2199 bbox = toporouter_bbox_create_from_points(GetLayerGroupNumberByNumber(ln), vlist, LINE, line);
2200 r->bboxes = g_slist_prepend(r->bboxes, bbox);
2201 //new;;
2202 //insert_constraints_from_list(r, l, vlist, bbox);
2203 g_list_free(vlist);
2204 // bbox->point = GTS_POINT( insert_vertex(r, l, (xs[0]+xs[1])/2., (ys[0]+ys[1])/2., bbox) );
2205
2206 bbox->constraints = g_list_concat(bbox->constraints, insert_constraint_edge(r, l, xs[0], ys[0], 0, xs[1], ys[1], 0, bbox));
2207 }
2208 }
2209 END_LOOP;
2210
2211 return 0;
2212 }
2213
2214 void
2215 create_board_edge(gdouble x0, gdouble y0, gdouble x1, gdouble y1, gdouble max, gint layer, GList **vlist)
2216 {
2217 GtsVertexClass *vertex_class = GTS_VERTEX_CLASS (toporouter_vertex_class ());
2218 gdouble d = sqrt(pow(x0-x1,2) + pow(y0-y1,2));
2219 guint n = d / max, count = 1;
2220 gdouble inc = n ? d / n : d;
2221 gdouble x = x0, y = y0;
2222
2223 *vlist = g_list_prepend(*vlist, gts_vertex_new (vertex_class, x0, y0, layer));
2224
2225 while(count < n) {
2226 coord_move_towards_coord_values(x0, y0, x1, y1, inc, &x, &y);
2227 *vlist = g_list_prepend(*vlist, gts_vertex_new (vertex_class, x, y, layer));
2228
2229 x0 = x; y0 = y;
2230 count++;
2231 }
2232
2233 }
2234
2235
2236 int
2237 read_board_constraints(toporouter_t *r, toporouter_layer_t *l, int layer)
2238 {
2239 // GtsVertexClass *vertex_class = GTS_VERTEX_CLASS (toporouter_vertex_class ());
2240 GList *vlist = NULL;
2241 toporouter_bbox_t *bbox = NULL;
2242
2243 /* Add points for corners of board, and constrain those edges */
2244 // vlist = g_list_prepend(NULL, gts_vertex_new (vertex_class, 0., 0., layer));
2245 // vlist = g_list_prepend(vlist, gts_vertex_new (vertex_class, PCB->MaxWidth, 0., layer));
2246 // vlist = g_list_prepend(vlist, gts_vertex_new (vertex_class, PCB->MaxWidth, PCB->MaxHeight, layer));
2247 // vlist = g_list_prepend(vlist, gts_vertex_new (vertex_class, 0., PCB->MaxHeight, layer));
2248
2249 create_board_edge(0., 0., PCB->MaxWidth, 0., 10000., layer, &vlist);
2250 create_board_edge(PCB->MaxWidth, 0., PCB->MaxWidth, PCB->MaxHeight, 10000., layer, &vlist);
2251 create_board_edge(PCB->MaxWidth, PCB->MaxHeight, 0., PCB->MaxHeight, 10000., layer, &vlist);
2252 create_board_edge(0., PCB->MaxHeight, 0., 0., 10000., layer, &vlist);
2253
2254 bbox = toporouter_bbox_create(layer, vlist, BOARD, NULL);
2255 r->bboxes = g_slist_prepend(r->bboxes, bbox);
2256 insert_constraints_from_list(r, l, vlist, bbox);
2257 g_list_free(vlist);
2258
2259 return 0;
2260 }
2261
2262 gdouble
2263 triangle_cost(GtsTriangle *t, gpointer *data){
2264
2265 gdouble *min_quality = data[0];
2266 gdouble *max_area = data[1];
2267 gdouble quality = gts_triangle_quality(t);
2268 gdouble area = gts_triangle_area(t);
2269
2270 if (quality < *min_quality || area > *max_area)
2271 return quality;
2272 return 0.0;
2273 }
2274
2275
2276 void
2277 print_constraint(toporouter_constraint_t *e)
2278 {
2279 printf("CONSTRAINT:\n");
2280 print_vertex(tedge_v1(e));
2281 print_vertex(tedge_v2(e));
2282 }
2283
2284 void
2285 print_edge(toporouter_edge_t *e)
2286 {
2287 GList *i = edge_routing(e);
2288
2289 printf("EDGE:\n");
2290
2291 print_vertex(tedge_v1(e));
2292
2293 while(i) {
2294 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
2295 print_vertex(v);
2296 i = i->next;
2297 }
2298
2299 print_vertex(tedge_v2(e));
2300 }
2301 static void pick_first_face (GtsFace * f, GtsFace ** first)
2302 {
2303 if (*first == NULL)
2304 *first = f;
2305 }
2306
2307 void
2308 unconstrain(toporouter_layer_t *l, toporouter_constraint_t *c)
2309 {
2310 toporouter_edge_t *e;
2311
2312 gts_allow_floating_vertices = TRUE;
2313 e = TOPOROUTER_EDGE(gts_edge_new (GTS_EDGE_CLASS (toporouter_edge_class ()), GTS_SEGMENT(c)->v1, GTS_SEGMENT(c)->v2));
2314 gts_edge_replace(GTS_EDGE(c), GTS_EDGE(e));
2315 l->constraints = g_list_remove(l->constraints, c);
2316 c->box->constraints = g_list_remove(c->box->constraints, c);
2317 c->box = NULL;
2318 gts_object_destroy (GTS_OBJECT (c));
2319 gts_allow_floating_vertices = FALSE;
2320 }
2321
2322 void
2323 build_cdt(toporouter_t *r, toporouter_layer_t *l)
2324 {
2325 /* TODO: generalize into surface *cdt_create(vertices, constraints) */
2326 GList *i;
2327 //GtsEdge *temp;
2328 //GtsVertex *v;
2329 GtsTriangle *t;
2330 GtsVertex *v1, *v2, *v3;
2331 GSList *vertices_slist;
2332
2333 vertices_slist = list_to_slist(l->vertices);
2334
2335 if(l->surface) {
2336 GtsFace * first = NULL;
2337 gts_surface_foreach_face (l->surface, (GtsFunc) pick_first_face, &first);
2338 gts_surface_traverse_destroy(gts_surface_traverse_new (l->surface, first));
2339 }
2340
2341 t = gts_triangle_enclosing (gts_triangle_class (), vertices_slist, 1000.0f);
2342 gts_triangle_vertices (t, &v1, &v2, &v3);
2343
2344 g_slist_free(vertices_slist);
2345
2346 l->surface = gts_surface_new (gts_surface_class (), gts_face_class (),
2347 GTS_EDGE_CLASS(toporouter_edge_class ()), GTS_VERTEX_CLASS(toporouter_vertex_class ()) );
2348
2349 gts_surface_add_face (l->surface, gts_face_new (gts_face_class (), t->e1, t->e2, t->e3));
2350
2351
2352 // fprintf(stderr, "ADDED VERTICES\n");
2353 /*
2354 GtsFace *debugface;
2355
2356 if((debugface = gts_delaunay_check(l->surface))) {
2357 fprintf(stderr, "WARNING: Delaunay check failed\n");
2358 fprintf(stderr, "\tViolating triangle:\n");
2359 fprintf(stderr, "\t%f,%f %f,%f\n",
2360 debugface->triangle.e1->segment.v1->p.x,
2361 debugface->triangle.e1->segment.v1->p.y,
2362 debugface->triangle.e1->segment.v2->p.x,
2363 debugface->triangle.e1->segment.v2->p.y
2364 );
2365 fprintf(stderr, "\t%f,%f %f,%f\n",
2366 debugface->triangle.e2->segment.v1->p.x,
2367 debugface->triangle.e2->segment.v1->p.y,
2368 debugface->triangle.e2->segment.v2->p.x,
2369 debugface->triangle.e2->segment.v2->p.y
2370 );
2371 fprintf(stderr, "\t%f,%f %f,%f\n",
2372 debugface->triangle.e3->segment.v1->p.x,
2373 debugface->triangle.e3->segment.v1->p.y,
2374 debugface->triangle.e3->segment.v2->p.x,
2375 debugface->triangle.e3->segment.v2->p.y
2376 );
2377 // toporouter_draw_surface(r, l->surface, "debug.png", 4096, 4096);
2378 {
2379 int i;
2380 for(i=0;i<groupcount();i++) {
2381 char buffer[256];
2382 sprintf(buffer, "debug-%d.png", i);
2383 toporouter_draw_surface(r, r->layers[i].surface, buffer, 2048, 2048, 2, NULL, i, NULL);
2384 }
2385 }
2386
2387 }
2388 */
2389 check_cons_continuation:
2390 i = l->constraints;
2391 while (i) {
2392 toporouter_constraint_t *c1 = TOPOROUTER_CONSTRAINT(i->data);
2393 GList *j = i->next;
2394 // printf("adding cons: "); print_constraint(c1);
2395
2396 while(j) {
2397 toporouter_constraint_t *c2 = TOPOROUTER_CONSTRAINT(j->data);
2398 guint rem = 0;
2399 GList *temp;
2400
2401 // printf("\tconflict: "); print_constraint(c2);
2402 toporouter_bbox_t *c1box = c1->box, *c2box = c2->box;
2403 toporouter_vertex_t *c1v1 = tedge_v1(c1);
2404 toporouter_vertex_t *c1v2 = tedge_v2(c1);
2405 toporouter_vertex_t *c2v1 = tedge_v1(c2);
2406 toporouter_vertex_t *c2v2 = tedge_v2(c2);
2407
2408 if(gts_segments_are_intersecting(GTS_SEGMENT(c1), GTS_SEGMENT(c2)) == GTS_IN) {
2409 toporouter_vertex_t *v;
2410 unconstrain(l, c1); unconstrain(l, c2);
2411 rem = 1;
2412 // proper intersection
2413 v = TOPOROUTER_VERTEX(vertex_intersect(
2414 GTS_VERTEX(c1v1),
2415 GTS_VERTEX(c1v2),
2416 GTS_VERTEX(c2v1),
2417 GTS_VERTEX(c2v2)));
2418
2419 // remove both constraints
2420 // replace with 4x constraints
2421 // insert new intersection vertex
2422 GTS_POINT(v)->z = vz(c1v1);
2423
2424 l->vertices = g_list_prepend(l->vertices, v);
2425 // gts_delaunay_add_vertex (l->surface, GTS_VERTEX(v), NULL);
2426
2427 v->bbox = c1box;
2428
2429 temp = insert_constraint_edge(r, l, vx(c1v1), vy(c1v1), 0, vx(v), vy(v), 0, c1box);
2430 c1box->constraints = g_list_concat(c1box->constraints, temp);
2431
2432 temp = insert_constraint_edge(r, l, vx(c1v2), vy(c1v2), 0, vx(v), vy(v), 0, c1box);
2433 c1box->constraints = g_list_concat(c1box->constraints, temp);
2434
2435 temp = insert_constraint_edge(r, l, vx(c2v1), vy(c2v1), 0, vx(v), vy(v), 0, c2box);
2436 c2box->constraints = g_list_concat(c2box->constraints, temp);
2437
2438 temp = insert_constraint_edge(r, l, vx(c2v2), vy(c2v2), 0, vx(v), vy(v), 0, c2box);
2439 c2box->constraints = g_list_concat(c2box->constraints, temp);
2440
2441 }else if(gts_segments_are_intersecting(GTS_SEGMENT(c1), GTS_SEGMENT(c2)) == GTS_ON ||
2442 gts_segments_are_intersecting(GTS_SEGMENT(c2), GTS_SEGMENT(c1)) == GTS_ON) {
2443
2444 if(vertex_between(edge_v1(c2), edge_v2(c2), edge_v1(c1)) && vertex_between(edge_v1(c2), edge_v2(c2), edge_v2(c1))) {
2445 unconstrain(l, c1); unconstrain(l, c2);
2446 rem = 1;
2447 // remove c1
2448 temp = insert_constraint_edge(r, l, vx(c2v1), vy(c2v1), 0, vx(c2v2), vy(c2v2), 0, c2box);
2449 c2box->constraints = g_list_concat(c2box->constraints, temp);
2450
2451 }else if(vertex_between(edge_v1(c1), edge_v2(c1), edge_v1(c2)) && vertex_between(edge_v1(c1), edge_v2(c1), edge_v2(c2))) {
2452 unconstrain(l, c1); unconstrain(l, c2);
2453 rem = 1;
2454 // remove c2
2455 temp = insert_constraint_edge(r, l, vx(c1v1), vy(c1v1), 0, vx(c1v2), vy(c1v2), 0, c1box);
2456 c1box->constraints = g_list_concat(c1box->constraints, temp);
2457
2458 //}else if(!vertex_wind(edge_v1(c1), edge_v2(c1), edge_v1(c2)) && !vertex_wind(edge_v1(c1), edge_v2(c1), edge_v2(c2))) {
2459 /* }else if(vertex_between(edge_v1(c1), edge_v2(c1), edge_v1(c2)) || vertex_between(edge_v1(c1), edge_v2(c1), edge_v2(c2))) {
2460 unconstrain(l, c1); unconstrain(l, c2);
2461 rem = 1;
2462 printf("all colinear\n");
2463 // exit(1);
2464 temp = insert_constraint_edge(r, l, vx(c1v1), vy(c1v1), 0, vx(c1v2), vy(c1v2), 0, c1box);
2465 c1box->constraints = g_list_concat(c1box->constraints, temp);
2466
2467 if(vertex_between(GTS_VERTEX(c1v1), GTS_VERTEX(c1v2), GTS_VERTEX(c2v2))) {
2468 // v2 of c2 is inner
2469 if(vertex_between(GTS_VERTEX(c2v1), GTS_VERTEX(c2v2), GTS_VERTEX(c1v2))) {
2470 // v2 of c1 is inner
2471 // c2 = c1.v2 -> c2.v1
2472 temp = insert_constraint_edge(r, l, vx(c1v2), vy(c1v2), 0, vx(c2v1), vy(c2v1), 0, c2box);
2473 c2box->constraints = g_list_concat(c2box->constraints, temp);
2474 }else{
2475 // v1 of c1 is inner
2476 // c2 = c1.v1 -> c2.v1
2477 temp = insert_constraint_edge(r, l, vx(c1v1), vy(c1v1), 0, vx(c2v1), vy(c2v1), 0, c2box);
2478 c2box->constraints = g_list_concat(c2box->constraints, temp);
2479 }
2480 }else{
2481 // v1 of c2 is inner
2482 if(vertex_between(GTS_VERTEX(c2v1), GTS_VERTEX(c2v2), GTS_VERTEX(c1v2))) {
2483 // v2 of c1 is inner
2484 // c2 = c1.v2 -> c2.v2
2485 temp = insert_constraint_edge(r, l, vx(c1v2), vy(c1v2), 0, vx(c2v2), vy(c2v2), 0, c2box);
2486 c2box->constraints = g_list_concat(c2box->constraints, temp);
2487 }else{
2488 // v1 of c1 is inner
2489 // c2 = c1.v1 -> c2.v2
2490 temp = insert_constraint_edge(r, l, vx(c1v1), vy(c1v1), 0, vx(c2v2), vy(c2v2), 0, c2box);
2491 c2box->constraints = g_list_concat(c2box->constraints, temp);
2492 }
2493 }*/
2494 }else if(vertex_between(edge_v1(c2), edge_v2(c2), edge_v1(c1)) && c1v1 != c2v1 && c1v1 != c2v2) {
2495 unconstrain(l, c1); unconstrain(l, c2);
2496 rem = 1;
2497 //v1 of c1 is on c2
2498 printf("v1 of c1 on c2\n");
2499
2500 // replace with 2x constraints
2501 temp = insert_constraint_edge(r, l, vx(c2v1), vy(c2v1), 0, vx(c1v1), vy(c1v1), 0, c2box);
2502 c2box->constraints = g_list_concat(c2box->constraints, temp);
2503 temp = insert_constraint_edge(r, l, vx(c2v2), vy(c2v2), 0, vx(c1v1), vy(c1v1), 0, c2box);
2504 c2box->constraints = g_list_concat(c2box->constraints, temp);
2505
2506 temp = insert_constraint_edge(r, l, vx(c1v1), vy(c1v1), 0, vx(c1v2), vy(c1v2), 0, c1box);
2507 c1box->constraints = g_list_concat(c1box->constraints, temp);
2508
2509 // restore c1
2510 //temp = insert_constraint_edge(r, l, vx(tedge_v2(c1)), vy(tedge_v2(c1)), 0, vx(tedge_v1(c1)), vy(tedge_v1(c1)), 0, c1->box);
2511 //c2->box->constraints = g_list_concat(c2->box->constraints, temp);
2512
2513 }else if(vertex_between(edge_v1(c2), edge_v2(c2), edge_v2(c1)) && c1v2 != c2v1 && c1v2 != c2v2) {
2514 unconstrain(l, c1); unconstrain(l, c2);
2515 rem = 1;
2516 //v2 of c1 is on c2
2517 printf("v2 of c1 on c2\n");
2518
2519 // replace with 2x constraints
2520 temp = insert_constraint_edge(r, l, vx(c2v1), vy(c2v1), 0, vx(c1v2), vy(c1v2), 0, c2box);
2521 c2box->constraints = g_list_concat(c2box->constraints, temp);
2522 temp = insert_constraint_edge(r, l, vx(c2v2), vy(c2v2), 0, vx(c1v2), vy(c1v2), 0, c2box);
2523 c2box->constraints = g_list_concat(c2box->constraints, temp);
2524
2525 temp = insert_constraint_edge(r, l, vx(c1v1), vy(c1v1), 0, vx(c1v2), vy(c1v2), 0, c1box);
2526 c1box->constraints = g_list_concat(c1box->constraints, temp);
2527
2528 }else if(vertex_between(edge_v1(c1), edge_v2(c1), edge_v1(c2)) && c2v1 != c1v1 && c2v1 != c1v2) {
2529 unconstrain(l, c1); unconstrain(l, c2);
2530 rem = 1;
2531 //v1 of c2 is on c1
2532 printf("v1 of c2 on c1\n");
2533
2534 // replace with 2x constraints
2535 temp = insert_constraint_edge(r, l, vx(c1v1), vy(c1v1), 0, vx(c2v1), vy(c2v1), 0, c1box);
2536 c1box->constraints = g_list_concat(c1box->constraints, temp);
2537 temp = insert_constraint_edge(r, l, vx(c1v2), vy(c1v2), 0, vx(c2v1), vy(c2v1), 0, c1box);
2538 c1box->constraints = g_list_concat(c1box->constraints, temp);
2539
2540 temp = insert_constraint_edge(r, l, vx(c2v1), vy(c2v1), 0, vx(c2v2), vy(c2v2), 0, c2box);
2541 c2box->constraints = g_list_concat(c2box->constraints, temp);
2542 }else if(vertex_between(edge_v1(c1), edge_v2(c1), edge_v2(c2)) && c2v2 != c1v1 && c2v2 != c1v2) {
2543 unconstrain(l, c1); unconstrain(l, c2);
2544 rem = 1;
2545 //v2 of c2 is on c1
2546 printf("v2 of c2 on c1\n");
2547
2548 // replace with 2x constraints
2549 temp = insert_constraint_edge(r, l, vx(c1v1), vy(c1v1), 0, vx(c2v2), vy(c2v2), 0, c1box);
2550 c1box->constraints = g_list_concat(c1box->constraints, temp);
2551 temp = insert_constraint_edge(r, l, vx(c1v2), vy(c1v2), 0, vx(c2v2), vy(c2v2), 0, c1box);
2552 c1box->constraints = g_list_concat(c1box->constraints, temp);
2553
2554 temp = insert_constraint_edge(r, l, vx(c2v1), vy(c2v1), 0, vx(c2v2), vy(c2v2), 0, c2box);
2555 c2box->constraints = g_list_concat(c2box->constraints, temp);
2556 }
2557 }
2558 if(rem) goto check_cons_continuation;
2559
2560 j = j->next;
2561 }
2562
2563 i = i->next;
2564 }
2565
2566 i = l->vertices;
2567 while (i) {
2568 //v = i->data;
2569 //if(r->flags & TOPOROUTER_FLAG_DEBUG_CDTS)
2570 // fprintf(stderr, "\tadding vertex %f,%f\n", v->p.x, v->p.y);
2571 toporouter_vertex_t *v = TOPOROUTER_VERTEX(gts_delaunay_add_vertex (l->surface, i->data, NULL));
2572 if(v) {
2573 printf("conflict: "); print_vertex(v);
2574 }
2575
2576 i = i->next;
2577 }
2578 i = l->constraints;
2579 while (i) {
2580
2581 toporouter_constraint_t *c1 = TOPOROUTER_CONSTRAINT(i->data);
2582
2583 // printf("adding cons: "); print_constraint(c1);
2584
2585 GSList *conflicts = gts_delaunay_add_constraint (l->surface, i->data);
2586 GSList *j = conflicts;
2587 while(j) {
2588 if(TOPOROUTER_IS_CONSTRAINT(j->data)) {
2589 toporouter_constraint_t *c2 = TOPOROUTER_CONSTRAINT(j->data);
2590
2591 printf("\tconflict: "); print_constraint(c2);
2592
2593 }
2594 j = j->next;
2595 }
2596 g_slist_free(conflicts);
2597
2598 i = i->next;
2599 }
2600
2601 // if(rerun)
2602 // goto build_cdt_continuation;
2603 // fprintf(stderr, "ADDED CONSTRAINTS\n");
2604 gts_allow_floating_vertices = TRUE;
2605 gts_object_destroy (GTS_OBJECT (v1));
2606 gts_object_destroy (GTS_OBJECT (v2));
2607 gts_object_destroy (GTS_OBJECT (v3));
2608 gts_allow_floating_vertices = FALSE;
2609
2610 /*
2611 {
2612 gpointer data[2];
2613 gdouble quality = 0.50, area = G_MAXDOUBLE;
2614 guint num = gts_delaunay_conform(l->surface, -1, (GtsEncroachFunc) gts_vertex_encroaches_edge, NULL);
2615
2616 if (num == 0){
2617 data[0] = &quality;
2618 data[1] = &area;
2619 num = gts_delaunay_refine(l->surface, -1, (GtsEncroachFunc) gts_vertex_encroaches_edge, NULL, (GtsKeyFunc) triangle_cost, data);
2620 }
2621 }
2622 */
2623 #ifdef DEBUG_IMPORT
2624 gts_surface_print_stats(l->surface, stderr);
2625 #endif
2626
2627 {
2628 char buffer[64];
2629 FILE *fout2;
2630 sprintf(buffer, "surface%d.gts", l - r->layers);
2631 fout2 = fopen(buffer, "w");
2632 gts_surface_write(l->surface, fout2);
2633 }
2634
2635 }
2636
2637 gint
2638 visited_cmp(gconstpointer a, gconstpointer b)
2639 {
2640 if(a<b) return -1;
2641 if(a>b) return 1;
2642 return 0;
2643 }
2644
2645 gdouble
2646 coord_xangle(gdouble ax, gdouble ay, gdouble bx, gdouble by)
2647 {
2648 gdouble dx, dy, theta;
2649
2650 dx = fabs(ax - bx);
2651 dy = fabs(ay - by);
2652
2653 if(dx < EPSILON) {
2654 theta = M_PI / 2.;
2655 } else theta = atan(dy/dx);
2656
2657 if(by <= ay) {
2658 if(bx < ax) theta = M_PI - theta;
2659 }else{
2660 if(bx < ax) theta += M_PI;
2661 else theta = (2 * M_PI) - theta;
2662 }
2663
2664 return theta;
2665 }
2666
2667 gdouble
2668 point_xangle(GtsPoint *a, GtsPoint *b)
2669 {
2670 gdouble dx, dy, theta;
2671
2672 dx = fabs(a->x - b->x);
2673 dy = fabs(a->y - b->y);
2674
2675 if(dx < EPSILON) {
2676 theta = M_PI / 2.;
2677 } else theta = atan(dy/dx);
2678
2679 if(b->y >= a->y) {
2680 if(b->x < a->x) theta = M_PI - theta;
2681 }else{
2682 if(b->x < a->x) theta += M_PI;
2683 else theta = (2 * M_PI) - theta;
2684 }
2685
2686 return theta;
2687 }
2688
2689
2690 GList *
2691 cluster_vertices(toporouter_t *r, toporouter_cluster_t *c)
2692 {
2693 GList *rval = NULL;
2694
2695 if(!c) return NULL;
2696
2697 FOREACH_CLUSTER(c->netlist->clusters) {
2698 if((r->flags & TOPOROUTER_FLAG_AFTERRUBIX && cluster->c == c->c) || (!(r->flags & TOPOROUTER_FLAG_AFTERRUBIX) && cluster == c)) {
2699 FOREACH_BBOX(cluster->boxes) {
2700 if(box->type == LINE) {
2701 g_assert(box->constraints->data);
2702 rval = g_list_prepend(rval, tedge_v1(box->constraints->data));
2703 rval = g_list_prepend(rval, tedge_v2(box->constraints->data));
2704 }else if(box->point) {
2705 rval = g_list_prepend(rval, TOPOROUTER_VERTEX(box->point));
2706 //g_assert(vertex_bbox(TOPOROUTER_VERTEX(box->point)) == box);
2707 }else {
2708 printf("WARNING: cluster_vertices: unhandled bbox type\n");
2709 }
2710
2711 } FOREACH_END;
2712
2713
2714 }
2715
2716 } FOREACH_END;
2717
2718 return rval;
2719 }
2720
2721 void
2722 print_cluster(toporouter_cluster_t *c)
2723 {
2724
2725 if(!c) {
2726 printf("[CLUSTER (NULL)]\n");
2727 return;
2728 }
2729
2730 printf("CLUSTER %d: NETLIST = %s STYLE = %s\n", c->c, c->netlist->netlist, c->netlist->style);
2731
2732 FOREACH_BBOX(c->boxes) {
2733 print_bbox(box);
2734 } FOREACH_END;
2735 }
2736
2737
2738 toporouter_cluster_t *
2739 cluster_create(toporouter_t *r, toporouter_netlist_t *netlist)
2740 {
2741 toporouter_cluster_t *c = malloc(sizeof(toporouter_cluster_t));
2742
2743 c->c = c->pc = netlist->clusters->len;
2744 g_ptr_array_add(netlist->clusters, c);
2745 c->netlist = netlist;
2746 c->boxes = g_ptr_array_new();
2747
2748 return c;
2749 }
2750
2751 toporouter_bbox_t *
2752 toporouter_bbox_locate(toporouter_t *r, toporouter_term_t type, void *data, gdouble x, gdouble y, guint layergroup)
2753 {
2754 GtsPoint *p = gts_point_new(gts_point_class(), x, y, layergroup);
2755 GSList *boxes = gts_bb_tree_stabbed(r->bboxtree, p), *i = boxes;
2756
2757 gts_object_destroy(GTS_OBJECT(p));
2758
2759 while(i) {
2760 toporouter_bbox_t *box = TOPOROUTER_BBOX(i->data);
2761
2762 if(box->type == type && box->data == data) {
2763 g_slist_free(boxes);
2764 return box;
2765 }
2766
2767 i = i->next;
2768 }
2769
2770 g_slist_free(boxes);
2771 return NULL;
2772 }
2773
2774 void
2775 cluster_join_bbox(toporouter_cluster_t *cluster, toporouter_bbox_t *box)
2776 {
2777 if(box) {
2778 g_ptr_array_add(cluster->boxes, box);
2779 box->cluster = cluster;
2780 }
2781 }
2782
2783 toporouter_netlist_t *
2784 netlist_create(toporouter_t *r, char *netlist, char *style)
2785 {
2786 toporouter_netlist_t *nl = malloc(sizeof(toporouter_netlist_t));
2787 nl->netlist = netlist;
2788 nl->style = style;
2789 nl->clusters = g_ptr_array_new();
2790 nl->routes = g_ptr_array_new();
2791 nl->routed = NULL;
2792 nl->pair = NULL;
2793 g_ptr_array_add(r->netlists, nl);
2794 return nl;
2795 }
2796
2797 void
2798 import_clusters(toporouter_t *r)
2799 {
2800 NetListListType nets;
2801 ResetFoundPinsViasAndPads (false);
2802 ResetFoundLinesAndPolygons (false);
2803 nets = CollectSubnets(false);
2804 NETLIST_LOOP(&nets);
2805 {
2806 if(netlist->NetN > 0) {
2807 toporouter_netlist_t *nl = netlist_create(r, netlist->Net->Connection->menu->Name, netlist->Net->Connection->menu->Style);
2808
2809 NET_LOOP(netlist);
2810 {
2811
2812 toporouter_cluster_t *cluster = cluster_create(r, nl);
2813 #ifdef DEBUG_MERGING
2814 printf("NET:\n");
2815 #endif
2816 CONNECTION_LOOP (net);
2817 {
2818
2819 if(connection->type == LINE_TYPE) {
2820 LineType *line = (LineType *) connection->ptr2;
2821 toporouter_bbox_t *box = toporouter_bbox_locate(r, LINE, line, connection->X, connection->Y, connection->group);
2822 cluster_join_bbox(cluster, box);
2823
2824 #ifdef DEBUG_MERGING
2825 printf("\tLINE %d,%d\n", connection->X, connection->Y);
2826 #endif
2827 }else if(connection->type == PAD_TYPE) {
2828 PadType *pad = (PadType *) connection->ptr2;
2829 toporouter_bbox_t *box = toporouter_bbox_locate(r, PAD, pad, connection->X, connection->Y, connection->group);
2830 cluster_join_bbox(cluster, box);
2831
2832 #ifdef DEBUG_MERGING
2833 printf("\tPAD %d,%d\n", connection->X, connection->Y);
2834 #endif
2835 }else if(connection->type == PIN_TYPE) {
2836
2837 for(guint m=0;m<groupcount();m++) {
2838 PinType *pin = (PinType *) connection->ptr2;
2839 toporouter_bbox_t *box = toporouter_bbox_locate(r, PIN, pin, connection->X, connection->Y, m);
2840 cluster_join_bbox(cluster, box);
2841 }
2842
2843 #ifdef DEBUG_MERGING
2844 printf("\tPIN %d,%d\n", connection->X, connection->Y);
2845 #endif
2846 }else if(connection->type == VIA_TYPE) {
2847
2848 for(guint m=0;m<groupcount();m++) {
2849 PinType *pin = (PinType *) connection->ptr2;
2850 toporouter_bbox_t *box = toporouter_bbox_locate(r, VIA, pin, connection->X, connection->Y, m);
2851 cluster_join_bbox(cluster, box);
2852 }
2853
2854 #ifdef DEBUG_MERGING
2855 printf("\tVIA %d,%d\n", connection->X, connection->Y);
2856 #endif
2857 }else if(connection->type == POLYGON_TYPE) {
2858 PolygonType *polygon = (PolygonType *) connection->ptr2;
2859 toporouter_bbox_t *box = toporouter_bbox_locate(r, POLYGON, polygon, connection->X, connection->Y, connection->group);
2860 cluster_join_bbox(cluster, box);
2861
2862 #ifdef DEBUG_MERGING
2863 printf("\tPOLYGON %d,%d\n", connection->X, connection->Y);
2864 #endif
2865
2866 }
2867 }
2868 END_LOOP;
2869 #ifdef DEBUG_MERGING
2870 printf("\n");
2871 #endif
2872 }
2873 END_LOOP;
2874
2875 }
2876 }
2877 END_LOOP;
2878 FreeNetListListMemory(&nets);
2879 }
2880
2881 void
2882 import_geometry(toporouter_t *r)
2883 {
2884 toporouter_layer_t *cur_layer;
2885
2886 int group;
2887
2888 #ifdef DEBUG_IMPORT
2889 for (group = 0; group < max_layer; group++) {
2890 printf("Group %d: Number %d:\n", group, PCB->LayerGroups.Number[group]);
2891
2892 for (int entry = 0; entry < PCB->LayerGroups.Number[group]; entry++) {
2893 printf("\tEntry %d\n", PCB->LayerGroups.Entries[group][entry]);
2894 }
2895 }
2896 #endif
2897 /* Allocate space for per layer struct */
2898 cur_layer = r->layers = malloc(groupcount() * sizeof(toporouter_layer_t));
2899
2900 /* Foreach layer, read in pad vertices and constraints, and build CDT */
2901 for (group = 0; group < max_layer; group++) {
2902 #ifdef DEBUG_IMPORT
2903 printf("*** LAYER GROUP %d ***\n", group);
2904 #endif
2905 if(PCB->LayerGroups.Number[group] > 0){
2906 cur_layer->vertices = NULL;
2907 cur_layer->constraints = NULL;
2908
2909 #ifdef DEBUG_IMPORT
2910 printf("reading board constraints from layer %d into group %d\n", PCB->LayerGroups.Entries[group][0], group);
2911 #endif
2912 read_board_constraints(r, cur_layer, PCB->LayerGroups.Entries[group][0]);
2913 #ifdef DEBUG_IMPORT
2914 printf("reading points from layer %d into group %d \n",PCB->LayerGroups.Entries[group][0], group);
2915 #endif
2916 read_points(r, cur_layer, PCB->LayerGroups.Entries[group][0]);
2917
2918 //#ifdef DEBUG_IMPORT
2919 // printf("reading pads from layer %d into group %d\n", number, group);
2920 //#endif
2921 read_pads(r, cur_layer, group);
2922
2923 GROUP_LOOP(PCB->Data, group)
2924 {
2925
2926 #ifdef DEBUG_IMPORT
2927 printf("reading lines from layer %d into group %d\n", number, group);
2928 #endif
2929 read_lines(r, cur_layer, layer, number);
2930
2931 }
2932 END_LOOP;
2933
2934
2935
2936 #ifdef DEBUG_IMPORT
2937 printf("building CDT\n");
2938 #endif
2939 build_cdt(r, cur_layer);
2940 printf("finished\n");
2941 /* {
2942 int i;
2943 for(i=0;i<groupcount();i++) {
2944 char buffer[256];
2945 sprintf(buffer, "build%d.png", i);
2946 toporouter_draw_surface(r, r->layers[i].surface, buffer, 2048, 2048, 2, NULL, i, NULL);
2947 }
2948 }*/
2949 #ifdef DEBUG_IMPORT
2950 printf("finished building CDT\n");
2951 #endif
2952 cur_layer++;
2953 }
2954 }
2955
2956 r->bboxtree = gts_bb_tree_new(r->bboxes);
2957
2958 import_clusters(r);
2959
2960 #ifdef DEBUG_IMPORT
2961 printf("finished import!\n");
2962 #endif
2963 }
2964
2965
2966 gint
2967 compare_points(gconstpointer a, gconstpointer b)
2968 {
2969 GtsPoint *i = GTS_POINT(a);
2970 GtsPoint *j = GTS_POINT(b);
2971
2972 if(i->x == j->x) {
2973 if(i->y == j->y) return 0;
2974 if(i->y < j->y) return -1;
2975 return 1;
2976 }
2977 if(i->x < j->x) return -1;
2978 return 1;
2979 }
2980
2981 gint
2982 compare_segments(gconstpointer a, gconstpointer b)
2983 {
2984 if(a == b) return 0;
2985 if(a < b) return -1;
2986 return 1;
2987 }
2988 #define DEBUG_CLUSTER_FIND 1
2989 toporouter_cluster_t *
2990 cluster_find(toporouter_t *r, gdouble x, gdouble y, gdouble z)
2991 {
2992 GtsPoint *p = gts_point_new(gts_point_class(), x, y, z);
2993 GSList *hits = gts_bb_tree_stabbed(r->bboxtree, p);
2994 toporouter_cluster_t *rval = NULL;
2995
2996 #ifdef DEBUG_CLUSTER_FIND
2997 printf("FINDING %f,%f,%f\n\n", x, y, z);
2998 #endif
2999
3000 while(hits) {
3001 toporouter_bbox_t *box = TOPOROUTER_BBOX(hits->data);
3002
3003 #ifdef DEBUG_CLUSTER_FIND
3004 printf("HIT BOX: "); print_bbox(box);
3005 #endif
3006
3007 if(box->layer == (int)z) {
3008 if(box->type != BOARD) {
3009 if(box->type == LINE) {
3010 LineType *line = (LineType *)box->data;
3011 gint linewind = coord_wind(line->Point1.X, line->Point1.Y, x, y, line->Point2.X, line->Point2.Y);
3012
3013 if(line->Point1.X > x - EPSILON && line->Point1.X < x + EPSILON &&
3014 line->Point1.Y > y - EPSILON && line->Point1.Y < y + EPSILON) {
3015 rval = box->cluster;
3016 // break;
3017 }
3018 if(line->Point2.X > x - EPSILON && line->Point2.X < x + EPSILON &&
3019 line->Point2.Y > y - EPSILON && line->Point2.Y < y + EPSILON) {
3020 rval = box->cluster;
3021 // break;
3022 }
3023 if(!linewind) {
3024 rval = box->cluster;
3025 // break;
3026 }
3027
3028 }else if(box->surface) {
3029
3030 if(gts_point_locate(p, box->surface, NULL)) {
3031 rval = box->cluster;
3032 break;
3033 }
3034
3035 }
3036 }
3037 }
3038 hits = hits->next;
3039 }
3040
3041 gts_object_destroy(GTS_OBJECT(p));
3042
3043
3044 #ifdef DEBUG_CLUSTER_FIND
3045 printf("cluster_find: %f,%f,%f: ", x, y, z);
3046 print_cluster(rval);
3047 #endif
3048
3049 return rval;
3050 }
3051
3052 gdouble
3053 simple_h_cost(toporouter_t *r, toporouter_vertex_t *curpoint, toporouter_vertex_t *destpoint)
3054 {
3055 gdouble layerpenalty = (vz(curpoint) == vz(destpoint)) ? 0. : r->viacost;
3056
3057 return gts_point_distance(GTS_POINT(curpoint), GTS_POINT(destpoint)) + layerpenalty;
3058 }
3059
3060 #define FCOST(x) (x->gcost + x->hcost)
3061 gdouble
3062 route_heap_cmp(gpointer item, gpointer data)
3063 {
3064 return FCOST(TOPOROUTER_VERTEX(item));
3065 }
3066
3067 #define closelist_insert(p) closelist = g_list_prepend(closelist, p)
3068
3069 typedef struct {
3070 toporouter_vertex_t *key;
3071 toporouter_vertex_t *result;
3072 }toporouter_heap_search_data_t;
3073
3074 void
3075 toporouter_heap_search(gpointer data, gpointer user_data)
3076 {
3077 toporouter_vertex_t *v = TOPOROUTER_VERTEX(data);
3078 toporouter_heap_search_data_t *heap_search_data = (toporouter_heap_search_data_t *)user_data;
3079 if(v == heap_search_data->key) heap_search_data->result = v;
3080 }
3081 /*
3082 void
3083 toporouter_heap_color(gpointer data, gpointer user_data)
3084 {
3085 toporouter_vertex_t *v = TOPOROUTER_VERTEX(data);
3086 v->flags |= (guint) user_data;
3087 }
3088 */
3089 inline gdouble
3090 angle_span(gdouble a1, gdouble a2)
3091 {
3092 if(a1 > a2)
3093 return ((2*M_PI)-a1 + a2);
3094 return a2-a1;
3095 }
3096
3097 gdouble
3098 region_span(toporouter_vertex_region_t *region)
3099 {
3100 gdouble a1,a2;
3101
3102 g_assert(region->v1 != NULL);
3103 g_assert(region->v2 != NULL);
3104 g_assert(region->origin != NULL);
3105
3106 a1 = point_xangle(GTS_POINT(region->origin), GTS_POINT(region->v1));
3107 a2 = point_xangle(GTS_POINT(region->origin), GTS_POINT(region->v2));
3108
3109 return angle_span(a1, a2);
3110 }
3111
3112 gdouble
3113 edge_capacity(toporouter_edge_t *e)
3114 {
3115 return gts_point_distance(GTS_POINT(edge_v1(e)), GTS_POINT(edge_v2(e)));
3116 }
3117
3118 gdouble
3119 edge_flow(toporouter_edge_t *e, toporouter_vertex_t *v1, toporouter_vertex_t *v2, toporouter_vertex_t *dest)
3120 {
3121 GList *i = edge_routing(e);
3122 toporouter_vertex_t *pv = tedge_v1(e), *v = NULL;
3123 gdouble flow = 0.;
3124 guint waiting = 1;
3125
3126 if((pv == v1 || pv == v2) && waiting) {
3127 flow += min_vertex_net_spacing(pv, dest);
3128 pv = dest;
3129 waiting = 0;
3130 }
3131
3132 g_assert(v1 != v2);
3133
3134 while(i) {
3135 v = TOPOROUTER_VERTEX(i->data);
3136
3137
3138 if(pv == dest)
3139 flow += min_vertex_net_spacing(v, pv);
3140 else
3141 flow += min_spacing(v, pv);
3142
3143 if((v == v1 || v == v2) && waiting) {
3144 flow += min_vertex_net_spacing(v, dest);
3145 pv = dest;
3146 waiting = 0;
3147 }else{
3148 pv = v;
3149 }
3150 i = i->next;
3151 }
3152
3153 if(pv == dest)
3154 flow += min_vertex_net_spacing(tedge_v2(e), pv);
3155 else
3156 flow += min_spacing(tedge_v2(e), pv);
3157
3158 return flow;
3159 }
3160
3161 void
3162 print_path(GList *path)
3163 {
3164 GList *i = path;
3165
3166 printf("PATH:\n");
3167 while(i) {
3168 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
3169 // printf("[V %f,%f,%f]\n", vx(v), vy(v), vz(v));
3170 print_vertex(v);
3171
3172 if(v->child && !g_list_find(path, v->child))
3173 printf("\t CHILD NOT IN LIST\n");
3174 if(v->parent && !g_list_find(path, v->parent))
3175 printf("\t parent NOT IN LIST\n");
3176 i = i->next;
3177 }
3178
3179
3180 }
3181
3182 GList *
3183 split_path(GList *path)
3184 {
3185 toporouter_vertex_t *pv = NULL;
3186 GList *curpath = NULL, *i, *paths = NULL;
3187 #ifdef DEBUG_ROUTE
3188 printf("PATH:\n");
3189 #endif
3190 i = path;
3191 while(i) {
3192 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
3193
3194 #ifdef DEBUG_ROUTE
3195 printf("v = %f,%f ", vx(v), vy(v));
3196 if(v->parent) printf("parent = %f,%f ", vx(v->parent), vy(v->parent));
3197 if(v->child) printf("child = %f,%f ", vx(v->child), vy(v->child));
3198 printf("\n");
3199 #endif
3200 // printf("***\n");
3201 // if(v) printf("v = %f,%f\n", GTS_POINT(v)->x, GTS_POINT(v)->y);
3202 // if(pv) printf("pv = %f,%f\n", GTS_POINT(pv)->x, GTS_POINT(pv)->y);
3203
3204
3205 if(pv)
3206 if(GTS_POINT(v)->x == GTS_POINT(pv)->x && GTS_POINT(v)->y == GTS_POINT(pv)->y) {
3207 if(g_list_length(curpath) > 1) paths = g_list_prepend(paths, curpath);
3208 curpath = NULL;
3209
3210 pv->child = NULL;
3211 v->parent = NULL;
3212 }
3213
3214 curpath = g_list_append(curpath, v);
3215
3216 pv = v;
3217 i = i->next;
3218 }
3219
3220 if(g_list_length(curpath) > 1)
3221 paths = g_list_prepend(paths, curpath);
3222
3223 return paths;
3224 }
3225
3226
3227
3228 #define edge_gradient(e) (cartesian_gradient(GTS_POINT(GTS_SEGMENT(e)->v1)->x, GTS_POINT(GTS_SEGMENT(e)->v1)->y, \
3229 GTS_POINT(GTS_SEGMENT(e)->v2)->x, GTS_POINT(GTS_SEGMENT(e)->v2)->y))
3230
3231
3232 /* sorting into ascending distance from v1 */
3233 gint
3234 routing_edge_insert(gconstpointer a, gconstpointer b, gpointer user_data)
3235 {
3236 GtsPoint *v1 = GTS_POINT(edge_v1(user_data));
3237
3238 if(gts_point_distance2(v1, GTS_POINT(a)) < gts_point_distance2(v1, GTS_POINT(b)) - EPSILON)
3239 return -1;
3240 if(gts_point_distance2(v1, GTS_POINT(a)) > gts_point_distance2(v1, GTS_POINT(b)) + EPSILON)
3241 return 1;
3242 /*
3243 printf("a = %x b = %x\n", (int) a, (int) b);
3244
3245 printf("WARNING: routing_edge_insert() with same points..\n \
3246 v1 @ %f,%f\n\
3247 a @ %f,%f\n\
3248 b @ %f,%f\n",
3249 v1->x, v1->y,
3250 vx(a), vy(a),
3251 vx(a), vy(b));
3252 printf("A: "); print_vertex(TOPOROUTER_VERTEX(a));
3253 printf("B: "); print_vertex(TOPOROUTER_VERTEX(b));
3254
3255 TOPOROUTER_VERTEX(a)->flags |= VERTEX_FLAG_RED;
3256 TOPOROUTER_VERTEX(b)->flags |= VERTEX_FLAG_RED;
3257 */
3258 return 0;
3259 }
3260
3261
3262 toporouter_vertex_t *
3263 new_temp_toporoutervertex(gdouble x, gdouble y, toporouter_edge_t *e)
3264 {
3265 GtsVertexClass *vertex_class = GTS_VERTEX_CLASS (toporouter_vertex_class ());
3266 GList *i = edge_routing(e);
3267 toporouter_vertex_t *r;
3268 ///*
3269 while(i) {
3270 r = TOPOROUTER_VERTEX(i->data);
3271 if(epsilon_equals(vx(r),x) && epsilon_equals(vy(r),y)) {
3272 if(r->flags & VERTEX_FLAG_TEMP) return r;
3273 }
3274 i = i->next;
3275 }
3276 //*/
3277 r = TOPOROUTER_VERTEX( gts_vertex_new (vertex_class, x, y, vz(edge_v1(e))) );
3278 r->flags |= VERTEX_FLAG_TEMP;
3279 r->routingedge = e;
3280
3281 if(TOPOROUTER_IS_CONSTRAINT(e))
3282 TOPOROUTER_CONSTRAINT(e)->routing = g_list_insert_sorted_with_data(edge_routing(e), r, routing_edge_insert, e);
3283 else
3284 e->routing = g_list_insert_sorted_with_data(edge_routing(e), r, routing_edge_insert, e);
3285
3286 return r;
3287 }
3288
3289
3290 /* create vertex on edge e at radius r from v, closest to ref */
3291 toporouter_vertex_t *
3292 new_temp_toporoutervertex_in_segment(toporouter_edge_t *e, toporouter_vertex_t *v, gdouble r, toporouter_vertex_t *ref)
3293 {
3294 gdouble m = edge_gradient(e);
3295 toporouter_spoint_t p, np1, np2;
3296 // toporouter_vertex_t *b = TOPOROUTER_VERTEX((GTS_VERTEX(v) == edge_v1(e)) ? edge_v2(e) : edge_v1(e));
3297 toporouter_vertex_t *rval = NULL;
3298 p.x = vx(v); p.y = vy(v);
3299
3300 vertices_on_line(&p, m, r, &np1, &np2);
3301
3302 if( (pow(np1.x - vx(ref), 2) + pow(np1.y - vy(ref), 2)) < (pow(np2.x - vx(ref), 2) + pow(np2.y - vy(ref), 2)) )
3303 rval = new_temp_toporoutervertex(np1.x, np1.y, e);
3304 else
3305 rval = new_temp_toporoutervertex(np2.x, np2.y, e);
3306
3307 return rval;
3308 }
3309
3310 gint
3311 vertex_keepout_test(toporouter_t *r, toporouter_vertex_t *v)
3312 {
3313 GList *i = r->keepoutlayers;
3314 while(i) {
3315 gdouble keepout = *((double *) i->data);
3316 if(vz(v) == keepout) return 1;
3317 i = i->next;
3318 }
3319 return 0;
3320 }
3321
3322 void
3323 closest_cluster_pair(toporouter_t *r, GList *src_vertices, GList *dest_vertices, toporouter_vertex_t **a, toporouter_vertex_t **b)
3324 {
3325 GList *i = src_vertices, *j = dest_vertices;
3326
3327 gdouble min = 0.;
3328 *a = NULL; *b = NULL;
3329
3330 i = src_vertices;
3331 while(i) {
3332 toporouter_vertex_t *v1 = TOPOROUTER_VERTEX(i->data);
3333
3334 if(vertex_keepout_test(r, v1)) { i = i->next; continue; }
3335
3336 j = dest_vertices;
3337 while(j) {
3338 toporouter_vertex_t *v2 = TOPOROUTER_VERTEX(j->data);
3339 if(vertex_keepout_test(r, v2) || vz(v2) != vz(v1)) { j = j->next; continue; }
3340
3341 if(!*a) {
3342 *a = v1; *b = v2; min = simple_h_cost(r, *a, *b);
3343 }else{
3344 gdouble tempd = simple_h_cost(r, v1, v2);
3345 if(r->flags & TOPOROUTER_FLAG_GOFAR && tempd > min) {
3346 *a = v1; *b = v2; min = tempd;
3347 }else
3348 if(tempd < min) {
3349 *a = v1; *b = v2; min = tempd;
3350 }
3351 }
3352
3353 j = j->next;
3354 }
3355
3356 i = i->next;
3357 }
3358
3359 // g_list_free(src_vertices);
3360 // g_list_free(dest_vertices);
3361 }
3362
3363
3364 toporouter_vertex_t *
3365 closest_dest_vertex(toporouter_t *r, toporouter_vertex_t *v, toporouter_route_t *routedata)
3366 {
3367 GList //*vertices = cluster_vertices(r, routedata->dest),
3368 *i = routedata->destvertices;
3369 toporouter_vertex_t *closest = NULL;
3370 gdouble closest_distance = 0.;
3371
3372 // if(routedata->flags & TOPOROUTER_FLAG_FLEX) i = r->destboxes;
3373
3374 while(i) {
3375 toporouter_vertex_t *cv = TOPOROUTER_VERTEX(i->data);
3376
3377 if(vz(cv) != vz(v)) { i = i->next; continue; }
3378
3379 if(!closest) {
3380 closest = cv; closest_distance = simple_h_cost(r, v, closest);
3381 }else{
3382 gdouble tempd = simple_h_cost(r, v, cv);
3383 if(r->flags & TOPOROUTER_FLAG_GOFAR && tempd > closest_distance) {
3384 closest = cv; closest_distance = tempd;
3385 }else
3386 if(tempd < closest_distance) {
3387 closest = cv; closest_distance = tempd;
3388 }
3389 }
3390 i = i->next;
3391 }
3392
3393 // g_list_free(vertices);
3394
3395 #ifdef DEBUG_ROUTE
3396 printf("CLOSEST = %f,%f,%f\n", vx(closest), vy(closest), vz(closest));
3397 #endif
3398 return closest;
3399 }
3400
3401 #define toporouter_edge_gradient(e) (cartesian_gradient(vx(edge_v1(e)), vy(edge_v1(e)), vx(edge_v2(e)), vy(edge_v2(e))))
3402
3403
3404 /* returns the capacity of the triangle cut through v */
3405 gdouble
3406 triangle_interior_capacity(GtsTriangle *t, toporouter_vertex_t *v)
3407 {
3408 toporouter_edge_t *e = TOPOROUTER_EDGE(gts_triangle_edge_opposite(t, GTS_VERTEX(v)));
3409 gdouble x, y, m1, m2, c2, c1, len;
3410
3411 g_assert(e);
3412
3413 m1 = toporouter_edge_gradient(e);
3414 m2 = perpendicular_gradient(m1);
3415 c2 = (isinf(m2)) ? vx(v) : vy(v) - (m2 * vx(v));
3416 c1 = (isinf(m1)) ? vx(edge_v1(e)) : vy(edge_v1(e)) - (m1 * vx(edge_v1(e)));
3417
3418 if(isinf(m2))
3419 x = vx(v);
3420 else if(isinf(m1))
3421 x = vx(edge_v1(e));
3422 else
3423 x = (c2 - c1) / (m1 - m2);
3424
3425 y = (isinf(m2)) ? vy(edge_v1(e)) : (m2 * x) + c2;
3426
3427 len = gts_point_distance2(GTS_POINT(edge_v1(e)), GTS_POINT(edge_v2(e)));
3428
3429 #ifdef DEBUG_ROUTE
3430 printf("%f,%f len = %f v = %f,%f\n", x, y, len, vx(v), vy(v));
3431 #endif
3432
3433 if(epsilon_equals(x,vx(edge_v1(e))) && epsilon_equals(y,vy(edge_v1(e)))) return INFINITY;
3434 if(epsilon_equals(x,vx(edge_v2(e))) && epsilon_equals(y,vy(edge_v2(e)))) return INFINITY;
3435
3436 if(x >= MIN(vx(edge_v1(e)),vx(edge_v2(e))) &&
3437 x <= MAX(vx(edge_v1(e)),vx(edge_v2(e))) &&
3438 y >= MIN(vy(edge_v1(e)),vy(edge_v2(e))) &&
3439 y <= MAX(vy(edge_v1(e)),vy(edge_v2(e))))
3440
3441 // if( (pow(vx(edge_v1(e)) - x, 2) + pow(vy(edge_v1(e)) - y, 2)) < len && (pow(vx(edge_v2(e)) - x, 2) + pow(vy(edge_v2(e)) - y, 2)) < len )
3442 return sqrt(pow(vx(v) - x, 2) + pow(vy(v) - y, 2));
3443
3444 return INFINITY;
3445 }
3446
3447 inline toporouter_vertex_t *
3448 segment_common_vertex(GtsSegment *s1, GtsSegment *s2)
3449 {
3450 if(!s1 || !s2) return NULL;
3451 if(s1->v1 == s2->v1) return TOPOROUTER_VERTEX(s1->v1);
3452 if(s1->v2 == s2->v1) return TOPOROUTER_VERTEX(s1->v2);
3453 if(s1->v1 == s2->v2) return TOPOROUTER_VERTEX(s1->v1);
3454 if(s1->v2 == s2->v2) return TOPOROUTER_VERTEX(s1->v2);
3455 return NULL;
3456 }
3457
3458 inline toporouter_vertex_t *
3459 route_vertices_common_vertex(toporouter_vertex_t *v1, toporouter_vertex_t *v2)
3460 {
3461 return segment_common_vertex(GTS_SEGMENT(v1->routingedge), GTS_SEGMENT(v2->routingedge));
3462 }
3463
3464
3465 inline guint
3466 edges_third_edge(GtsSegment *s1, GtsSegment *s2, toporouter_vertex_t **v1, toporouter_vertex_t **v2)
3467 {
3468 if(!s1 || !s2) return 0;
3469 if(s1->v1 == s2->v1) {
3470 *v1 = TOPOROUTER_VERTEX(s1->v2);
3471 *v2 = TOPOROUTER_VERTEX(s2->v2);
3472 return 1;
3473 }
3474 if(s1->v2 == s2->v1) {
3475 *v1 = TOPOROUTER_VERTEX(s1->v1);
3476 *v2 = TOPOROUTER_VERTEX(s2->v2);
3477 return 1;
3478 }
3479 if(s1->v1 == s2->v2) {
3480 *v1 = TOPOROUTER_VERTEX(s1->v2);
3481 *v2 = TOPOROUTER_VERTEX(s2->v1);
3482 return 1;
3483 }
3484 if(s1->v2 == s2->v2) {
3485 *v1 = TOPOROUTER_VERTEX(s1->v1);
3486 *v2 = TOPOROUTER_VERTEX(s2->v1);
3487 return 1;
3488 }
3489 return 0;
3490 }
3491
3492 /* returns the flow from e1 to e2, and the flow from the vertex oppisate e1 to
3493 * e1 and the vertex oppisate e2 to e2 */
3494 gdouble
3495 flow_from_edge_to_edge(GtsTriangle *t, toporouter_edge_t *e1, toporouter_edge_t *e2,
3496 toporouter_vertex_t *common_v, toporouter_vertex_t *curpoint)
3497 {
3498 gdouble r = 0.;
3499 toporouter_vertex_t *pv = common_v, *v;
3500 toporouter_edge_t *op_edge;
3501
3502 GList *i = edge_routing(e1);
3503 while(i) {
3504 v = TOPOROUTER_VERTEX(i->data);
3505
3506 if(v == curpoint) {
3507 r += min_spacing(v, pv);
3508 pv = v;
3509 i = i->next; continue;
3510 }
3511 // if(!(v->flags & VERTEX_FLAG_TEMP)) {
3512 if((v->flags & VERTEX_FLAG_ROUTE)) {
3513 if(v->parent)
3514 if(v->parent->routingedge == e2) {
3515 r += min_spacing(v, pv);
3516 pv = v;
3517 i = i->next; continue;
3518 }
3519
3520 if(v->child)
3521 if(v->child->routingedge == e2) {
3522 r += min_spacing(v, pv);
3523 pv = v;
3524 i = i->next; continue;
3525 }
3526 }
3527 i = i->next;
3528 }
3529
3530 op_edge = TOPOROUTER_EDGE(gts_triangle_edge_opposite(t, GTS_VERTEX(common_v)));
3531
3532 g_assert(op_edge);
3533 g_assert(e1);
3534 g_assert(e2);
3535
3536 v = segment_common_vertex(GTS_SEGMENT(e2), GTS_SEGMENT(op_edge));
3537 g_assert(v);
3538
3539 //v = TOPOROUTER_VERTEX(gts_triangle_vertex_opposite(t, GTS_EDGE(e1)));
3540 if(v->flags & VERTEX_FLAG_ROUTE && v->parent && v->parent->routingedge) {
3541 if(v->parent->routingedge == e1)
3542 r += min_spacing(v, pv);
3543 }
3544
3545 v = segment_common_vertex(GTS_SEGMENT(e1), GTS_SEGMENT(op_edge));
3546 g_assert(v);
3547
3548 //v = TOPOROUTER_VERTEX(gts_triangle_vertex_opposite(t, GTS_EDGE(e2)));
3549 if(v->flags & VERTEX_FLAG_ROUTE && v->parent && v->parent->routingedge) {
3550 if(v->parent->routingedge == e1)
3551 r += min_spacing(v, pv);
3552 }
3553
3554 if(TOPOROUTER_IS_CONSTRAINT(op_edge)) {
3555 toporouter_bbox_t *box = vertex_bbox(TOPOROUTER_VERTEX(edge_v1(op_edge)));
3556 r += vertex_net_thickness(v) / 2.;
3557 if(box) {
3558 r += MAX(vertex_net_keepaway(v), cluster_keepaway(box->cluster));
3559 r += cluster_thickness(box->cluster) / 2.;
3560 }else{
3561 r += vertex_net_keepaway(v);
3562
3563 }
3564 }
3565
3566 return r;
3567 }
3568
3569
3570
3571 guint
3572 check_triangle_interior_capacity(GtsTriangle *t, toporouter_vertex_t *v, toporouter_vertex_t *curpoint,
3573 toporouter_edge_t *op_edge, toporouter_edge_t *adj_edge1, toporouter_edge_t *adj_edge2)
3574 {
3575 gdouble ic = triangle_interior_capacity(t, v);
3576 gdouble flow = flow_from_edge_to_edge(t, adj_edge1, adj_edge2, v, curpoint);
3577
3578 if(TOPOROUTER_IS_CONSTRAINT(adj_edge1) || TOPOROUTER_IS_CONSTRAINT(adj_edge2)) return 1;
3579
3580
3581 if(flow > ic) {
3582 #ifdef DEBUG_ROUTE
3583 printf("fail interior capacity flow = %f ic = %f\n", flow, ic);
3584 #endif
3585 return 0;
3586 }
3587
3588 return 1;
3589 }
3590
3591 toporouter_vertex_t *
3592 edge_routing_next_not_temp(toporouter_edge_t *e, GList *list)
3593 {
3594 if(!TOPOROUTER_IS_CONSTRAINT(e)) {
3595 while(list) {
3596 toporouter_vertex_t *v = TOPOROUTER_VERTEX(list->data);
3597 if(!(v->flags & VERTEX_FLAG_TEMP))
3598 return v;
3599
3600 list = list->next;
3601 }
3602 }
3603 return tedge_v2(e);
3604 }
3605
3606 toporouter_vertex_t *
3607 edge_routing_prev_not_temp(toporouter_edge_t *e, GList *list)
3608 {
3609 if(!TOPOROUTER_IS_CONSTRAINT(e)) {
3610 while(list) {
3611 toporouter_vertex_t *v = TOPOROUTER_VERTEX(list->data);
3612 if(!(v->flags & VERTEX_FLAG_TEMP))
3613 return v;
3614
3615 list = list->prev;
3616 }
3617 }
3618 return tedge_v1(e);
3619 }
3620
3621 void
3622 edge_adjacent_vertices(toporouter_edge_t *e, toporouter_vertex_t *v, toporouter_vertex_t **v1, toporouter_vertex_t **v2)
3623 {
3624 GList *r = g_list_find(edge_routing(e), v);
3625
3626 if(v == tedge_v1(e)) {
3627 *v1 = NULL;
3628 *v2 = edge_routing_next_not_temp(e, edge_routing(e));
3629 }else if(v == tedge_v2(e)) {
3630 *v1 = edge_routing_prev_not_temp(e, g_list_last(edge_routing(e)));
3631 *v2 = NULL;
3632 }else{
3633 // r = g_list_find(r, v);
3634 *v1 = edge_routing_prev_not_temp(e, r);
3635 *v2 = edge_routing_next_not_temp(e, r);
3636
3637 }
3638
3639 }
3640
3641
3642 GList *
3643 candidate_vertices(toporouter_vertex_t *v1, toporouter_vertex_t *v2, toporouter_vertex_t *dest, toporouter_edge_t *e)
3644 {
3645 gdouble totald, v1ms, v2ms, flow, capacity, ms;
3646 GList *vs = NULL;
3647
3648 g_assert(v1);
3649 g_assert(v2);
3650 g_assert(dest);
3651
3652 g_assert(!(v1->flags & VERTEX_FLAG_TEMP));
3653 g_assert(!(v2->flags & VERTEX_FLAG_TEMP));
3654 #ifdef DEBUG_ROUTE
3655 printf("starting candidate vertices\n");
3656 printf("v1 = %f,%f v2 = %f,%f dest = %f,%f\n", vx(v1), vy(v1), vx(v2), vy(v2), vx(dest), vy(dest));
3657 #endif
3658 totald = gts_point_distance(GTS_POINT(v1), GTS_POINT(v2));
3659 v1ms = min_spacing(v1, dest);
3660 v2ms = min_spacing(v2, dest);
3661 ms = min_spacing(dest, dest);
3662 flow = TOPOROUTER_IS_CONSTRAINT(e) ? 0. : edge_flow(e, v1, v2, dest);
3663 capacity = edge_capacity(e);
3664
3665 #ifdef DEBUG_ROUTE
3666 g_assert(totald > 0);
3667
3668 printf("v1ms = %f v2ms = %f totald = %f ms = %f capacity = %f flow = %f\n", v1ms, v2ms, totald, ms, capacity, flow);
3669 #endif
3670
3671 if(flow >= capacity) return NULL;
3672
3673
3674 if(v1ms + v2ms + ms >= totald) {
3675 vs = g_list_prepend(vs, new_temp_toporoutervertex((vx(v1)+vx(v2)) / 2., (vy(v1)+vy(v2)) / 2., e));
3676 }else{
3677 gdouble x0, y0, x1, y1, d;
3678
3679 vertex_move_towards_vertex_values(GTS_VERTEX(v1), GTS_VERTEX(v2), v1ms, &x0, &y0);
3680
3681 vs = g_list_prepend(vs, new_temp_toporoutervertex(x0, y0, e));
3682
3683 vertex_move_towards_vertex_values(GTS_VERTEX(v2), GTS_VERTEX(v1), v2ms, &x1, &y1);
3684
3685 vs = g_list_prepend(vs, new_temp_toporoutervertex(x1, y1, e));
3686
3687 d = sqrt(pow(x0-x1,2) + pow(y0-y1,2));
3688
3689 if(ms < d) {
3690 // guint nint = d / ms;
3691 // gdouble dif = d / (nint + 1);
3692 gdouble dif = d / 2;
3693
3694 // for(guint j=0;j<nint;j++) {
3695 gdouble x, y;
3696
3697 // coord_move_towards_coord_values(x0, y0, x1, y1, dif * j, &x, &y);
3698 coord_move_towards_coord_values(x0, y0, x1, y1, dif, &x, &y);
3699
3700 vs = g_list_prepend(vs, new_temp_toporoutervertex(x, y, e));
3701
3702 // }
3703
3704 }
3705
3706 }
3707 #ifdef DEBUG_ROUTE
3708 printf("candidate vertices returning %d\n", g_list_length(vs));
3709 #endif
3710 return vs;
3711 }
3712
3713 GList *
3714 edge_routing_first_not_temp(toporouter_edge_t *e)
3715 {
3716 GList *i = edge_routing(e);
3717 toporouter_vertex_t *v;
3718
3719 while(i) {
3720 v = TOPOROUTER_VERTEX(i->data);
3721 if(!(v->flags & VERTEX_FLAG_TEMP)) return i;
3722
3723 i = i->next;
3724 }
3725
3726 return NULL;
3727 }
3728
3729 GList *
3730 edge_routing_last_not_temp(toporouter_edge_t *e)
3731 {
3732 GList *i = edge_routing(e), *last = NULL;
3733 toporouter_vertex_t *v;
3734
3735 while(i) {
3736 v = TOPOROUTER_VERTEX(i->data);
3737 if(!(v->flags & VERTEX_FLAG_TEMP)) last = i;
3738
3739 i = i->next;
3740 }
3741
3742 return last;
3743 }
3744
3745 void
3746 delete_vertex(toporouter_vertex_t *v)
3747 {
3748
3749 if(v->flags & VERTEX_FLAG_TEMP) {
3750 if(v->routingedge) {
3751 if(TOPOROUTER_IS_CONSTRAINT(v->routingedge))
3752 TOPOROUTER_CONSTRAINT(v->routingedge)->routing = g_list_remove(TOPOROUTER_CONSTRAINT(v->routingedge)->routing, v);
3753 else
3754 v->routingedge->routing = g_list_remove(v->routingedge->routing, v);
3755 }
3756
3757 gts_object_destroy ( GTS_OBJECT(v) );
3758 }
3759 }
3760
3761 #define edge_is_blocked(e) (TOPOROUTER_IS_EDGE(e) ? (e->flags & EDGE_FLAG_DIRECTCONNECTION) : 0)
3762
3763 GList *
3764 triangle_candidate_points_from_vertex(GtsTriangle *t, toporouter_vertex_t *v, toporouter_vertex_t *dest, toporouter_route_t *routedata)
3765 {
3766 toporouter_edge_t *op_e = TOPOROUTER_EDGE(gts_triangle_edge_opposite(t, GTS_VERTEX(v)));
3767 toporouter_vertex_t *vv1, *vv2, *constraintv = NULL;
3768 toporouter_edge_t *e1, *e2;
3769 GList *i;
3770 GList *rval = NULL;
3771
3772 #ifdef DEBUG_ROUTE
3773 printf("\tTRIANGLE CAND POINT FROM VERTEX\n");
3774
3775 g_assert(op_e);
3776 #endif
3777
3778 e1 = TOPOROUTER_EDGE(gts_vertices_are_connected(GTS_VERTEX(v), edge_v1(op_e)));
3779 e2 = TOPOROUTER_EDGE(gts_vertices_are_connected(GTS_VERTEX(v), edge_v2(op_e)));
3780
3781
3782 if(TOPOROUTER_IS_CONSTRAINT(op_e)) {
3783 if(TOPOROUTER_CONSTRAINT(op_e)->box->type == BOARD) {
3784 #ifdef DEBUG_ROUTE
3785 printf("BOARD constraint\n");
3786 #endif
3787 return NULL;
3788 }
3789 if(constraint_netlist(TOPOROUTER_CONSTRAINT(op_e)) != vertex_netlist(dest)) { // || TOPOROUTER_CONSTRAINT(op_e)->routing) {
3790 #ifdef DEBUG_ROUTE
3791 printf("op_e routing:\n");
3792 print_edge(op_e);
3793 #endif
3794 return NULL;
3795 }
3796 #ifdef DEBUG_ROUTE
3797 printf("RETURNING CONSTRAINT POING\n");
3798 #endif
3799 constraintv = new_temp_toporoutervertex_in_segment(op_e, TOPOROUTER_VERTEX(edge_v1(op_e)),
3800 gts_point_distance(GTS_POINT(edge_v1(op_e)), GTS_POINT(edge_v2(op_e))) / 2., TOPOROUTER_VERTEX(edge_v2(op_e)));
3801 // return g_list_prepend(NULL, vv1);
3802
3803
3804 }
3805
3806 if(edge_is_blocked(op_e)) {
3807 goto triangle_candidate_points_from_vertex_exit;
3808 }
3809 // v1 = tedge_v1(op_e);
3810 // v2 = tedge_v2(op_e);
3811
3812 if(v == tedge_v1(e1)) {
3813 i = edge_routing_first_not_temp(e1);
3814 }else{
3815 i = edge_routing_last_not_temp(e1);
3816 }
3817
3818 if(i) {
3819 toporouter_vertex_t *temp = TOPOROUTER_VERTEX(i->data);
3820
3821 if(temp->parent == tedge_v2(op_e) || temp->child == tedge_v2(op_e)) {
3822 #ifdef DEBUG_ROUTE
3823 printf("temp -> op_e->v2\n");
3824 #endif
3825 goto triangle_candidate_points_from_vertex_exit;
3826 }
3827 if(temp->parent->routingedge == op_e) {
3828 vv1 = temp->parent;
3829 #ifdef DEBUG_ROUTE
3830 printf("vv1->parent\n");
3831 #endif
3832
3833 }else if(temp->child->routingedge == op_e) {
3834 vv1 = temp->child;
3835 #ifdef DEBUG_ROUTE
3836 printf("vv1->child\n");
3837 #endif
3838
3839 }else{
3840 // must be to e2
3841 #ifdef DEBUG_ROUTE
3842 printf("temp -> e2?\n");
3843 printf("op_e = %f,%f\t\t%f,%f\n", vx(edge_v1(op_e)), vy(edge_v1(op_e)), vx(edge_v2(op_e)), vy(edge_v2(op_e)) );
3844 if(temp->parent->routingedge)
3845 printf("temp->parent->routingedge = %f,%f \t\t %f,%f\n",
3846 vx(edge_v1(temp->parent->routingedge)), vy(edge_v1(temp->parent->routingedge)),
3847 vx(edge_v2(temp->parent->routingedge)), vy(edge_v2(temp->parent->routingedge))
3848 );
3849 else
3850 printf("temp->parent->routingedge = NULL\n");
3851
3852 if(temp->child->routingedge)
3853 printf("temp->child->routingedge = %f,%f \t\t %f,%f\n",
3854 vx(edge_v1(temp->child->routingedge)), vy(edge_v1(temp->child->routingedge)),
3855 vx(edge_v2(temp->child->routingedge)), vy(edge_v2(temp->child->routingedge))
3856 );
3857 else
3858 printf("temp->child->routingedge = NULL\n");
3859 #endif
3860 goto triangle_candidate_points_from_vertex_exit;
3861 }
3862
3863 }else{
3864 vv1 = tedge_v1(op_e);
3865 #ifdef DEBUG_ROUTE
3866 printf("nothing on e1\n");
3867 #endif
3868 }
3869
3870 if(v == tedge_v1(e2)) {
3871 i = edge_routing_first_not_temp(e2);
3872 }else{
3873 i = edge_routing_last_not_temp(e2);
3874 }
3875
3876 if(i) {
3877 toporouter_vertex_t *temp = TOPOROUTER_VERTEX(i->data);
3878
3879 if(temp->parent == tedge_v1(op_e) || temp->child == tedge_v1(op_e)) {
3880 #ifdef DEBUG_ROUTE
3881 printf("temp -> op_e->v2\n");
3882 #endif
3883 goto triangle_candidate_points_from_vertex_exit;
3884 }
3885
3886 if(temp->parent->routingedge == op_e) {
3887 vv2 = temp->parent;
3888 #ifdef DEBUG_ROUTE
3889 printf("vv2->parent\n");
3890 #endif
3891 }else if(temp->child->routingedge == op_e) {
3892 vv2 = temp->child;
3893 #ifdef DEBUG_ROUTE
3894 printf("vv2->child\n");
3895 #endif
3896
3897 }else{
3898 // must be to e1
3899 #ifdef DEBUG_ROUTE
3900 printf("temp -> e1?\n");
3901 printf("op_e = %f,%f\t\t%f,%f\n", vx(edge_v1(op_e)), vy(edge_v1(op_e)), vx(edge_v2(op_e)), vy(edge_v2(op_e)) );
3902 if(temp->parent->routingedge)
3903 printf("temp->parent->routingedge = %f,%f \t\t %f,%f\n",
3904 vx(edge_v1(temp->parent->routingedge)), vy(edge_v1(temp->parent->routingedge)),
3905 vx(edge_v2(temp->parent->routingedge)), vy(edge_v2(temp->parent->routingedge))
3906 );
3907 else
3908 printf("temp->parent->routingedge = NULL\n");
3909
3910 if(temp->child->routingedge)
3911 printf("temp->child->routingedge = %f,%f \t\t %f,%f\n",
3912 vx(edge_v1(temp->child->routingedge)), vy(edge_v1(temp->child->routingedge)),
3913 vx(edge_v2(temp->child->routingedge)), vy(edge_v2(temp->child->routingedge))
3914 );
3915 else
3916 printf("temp->child->routingedge = NULL\n");
3917 #endif
3918 goto triangle_candidate_points_from_vertex_exit;
3919 }
3920
3921 }else{
3922 vv2 = tedge_v2(op_e);
3923 #ifdef DEBUG_ROUTE
3924 printf("nothing on e2\n");
3925 #endif
3926 }
3927
3928 #ifdef DEBUG_ROUTE
3929 printf("size of e1 routing = %d e2 routing = %d op_e routing = %d\n",
3930 g_list_length(edge_routing(e1)), g_list_length(edge_routing(e2)), g_list_length(edge_routing(op_e)));
3931 #endif
3932
3933 if(constraintv) {
3934 #ifdef DEBUG_ROUTE
3935 print_vertex(constraintv);
3936 printf("constraintv %f,%f returning\n", vx(constraintv), vy(constraintv));
3937 #endif
3938 return g_list_prepend(NULL, constraintv);
3939 }
3940
3941 i = edge_routing(op_e);
3942 while(i) {
3943 toporouter_vertex_t *temp = TOPOROUTER_VERTEX(i->data);
3944
3945 if(temp->parent == v || temp->child == v) {
3946 rval = g_list_concat(rval, candidate_vertices(vv1, temp, dest, op_e));
3947 vv1 = temp;
3948 }
3949
3950 i = i->next;
3951 }
3952
3953 rval = g_list_concat(rval, candidate_vertices(vv1, vv2, dest, op_e));
3954
3955 return rval;
3956
3957
3958
3959 triangle_candidate_points_from_vertex_exit:
3960 if(constraintv) //delete_vertex(constraintv);
3961 g_hash_table_insert(routedata->alltemppoints, constraintv, constraintv);
3962
3963 g_list_free(rval);
3964
3965 return NULL;
3966 }
3967
3968 void
3969 routedata_insert_temppoints(toporouter_route_t *data, GList *temppoints) {
3970 GList *j = temppoints;
3971 while(j) {
3972 g_hash_table_insert(data->alltemppoints, j->data, j->data);
3973 j = j->next;
3974 }
3975 }
3976
3977
3978 inline gint
3979 constraint_route_test(toporouter_constraint_t *c, toporouter_route_t *routedata)
3980 {
3981 if(c->box->cluster && c->box->cluster->netlist == routedata->src->netlist) {
3982 if(c->box->cluster->c == routedata->dest->c || c->box->cluster->c == routedata->src->c) return 1;
3983 }
3984 return 0;
3985 }
3986
3987 GList *
3988 all_candidates_on_edge(toporouter_edge_t *e, toporouter_route_t *routedata)
3989 {
3990 GList *rval = NULL;
3991 if(edge_is_blocked(e)) return NULL;
3992
3993 if(!TOPOROUTER_IS_CONSTRAINT(e)) {
3994 GList *i = edge_routing(e);
3995 toporouter_vertex_t *pv = tedge_v1(e);
3996
3997 while(i) {
3998 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
3999 if(!(v->flags & VERTEX_FLAG_TEMP)) {
4000 rval = g_list_concat(rval, candidate_vertices(pv, v, TOPOROUTER_VERTEX(routedata->destvertices->data), e));
4001 pv = v;
4002 }
4003 i = i->next;
4004 }
4005
4006 rval = g_list_concat(rval, candidate_vertices(pv, tedge_v2(e), TOPOROUTER_VERTEX(routedata->destvertices->data), e));
4007 }else if(TOPOROUTER_CONSTRAINT(e)->box->type == BOARD) {
4008 return NULL;
4009 }else if(constraint_route_test(TOPOROUTER_CONSTRAINT(e), routedata)) {
4010 toporouter_vertex_t *consv = new_temp_toporoutervertex_in_segment(e, tedge_v1(e), tvdistance(tedge_v1(e), tedge_v2(e)) / 2., tedge_v2(e));
4011 rval = g_list_prepend(rval, consv);
4012 // g_hash_table_insert(routedata->alltemppoints, consv, consv);
4013 }
4014
4015 return rval;
4016 }
4017
4018 GList *
4019 triangle_all_candidate_points_from_vertex(GtsTriangle *t, toporouter_vertex_t *v, toporouter_route_t *routedata)
4020 {
4021 toporouter_edge_t *op_e = TOPOROUTER_EDGE(gts_triangle_edge_opposite(t, GTS_VERTEX(v)));
4022 return all_candidates_on_edge(op_e, routedata);
4023 }
4024
4025 GList *
4026 triangle_all_candidate_points_from_edge(toporouter_t *r, GtsTriangle *t, toporouter_edge_t *e, toporouter_route_t *routedata,
4027 toporouter_vertex_t **dest, toporouter_vertex_t *curpoint)
4028 {
4029 toporouter_vertex_t *op_v;
4030 toporouter_edge_t *e1, *e2;
4031 GList *i, *rval = NULL, *rval2 = NULL;
4032 toporouter_vertex_t *boxpoint = NULL;
4033 guint e1intcap, e2intcap;
4034
4035 op_v = TOPOROUTER_VERTEX(gts_triangle_vertex_opposite(t, GTS_EDGE(e)));
4036
4037
4038 if(vertex_bbox(op_v)) boxpoint = TOPOROUTER_VERTEX(vertex_bbox(op_v)->point);
4039
4040 if(g_list_find(routedata->destvertices, op_v)) {
4041 rval = g_list_prepend(rval, op_v);
4042 *dest = op_v;
4043 return rval;
4044 }else if(g_list_find(routedata->destvertices, boxpoint)) {
4045 *dest = boxpoint;
4046 }else if(g_list_find(routedata->srcvertices, op_v)) {
4047 rval = g_list_prepend(rval, op_v);
4048 }
4049
4050 e1 = TOPOROUTER_EDGE(gts_vertices_are_connected(GTS_VERTEX(op_v), edge_v1(e)));
4051 e2 = TOPOROUTER_EDGE(gts_vertices_are_connected(GTS_VERTEX(op_v), edge_v2(e)));
4052
4053 rval = g_list_concat(rval, all_candidates_on_edge(e1, routedata));
4054 rval = g_list_concat(rval, all_candidates_on_edge(e2, routedata));
4055
4056 e1intcap = check_triangle_interior_capacity(t, tedge_v1(e), curpoint, e2, e, e1);
4057 e2intcap = check_triangle_interior_capacity(t, tedge_v2(e), curpoint, e1, e, e2);
4058
4059 i = rval;
4060 while(i) {
4061 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
4062
4063 if(!v->routingedge)
4064 rval2 = g_list_prepend(rval2, v);
4065 else if(v->routingedge == e1 && !(!TOPOROUTER_IS_CONSTRAINT(e1) && !e1intcap))
4066 rval2 = g_list_prepend(rval2, v);
4067 else if(v->routingedge == e2 && !(!TOPOROUTER_IS_CONSTRAINT(e2) && !e2intcap))
4068 rval2 = g_list_prepend(rval2, v);
4069
4070 i = i->next;
4071 }
4072 g_list_free(rval);
4073
4074 return rval2;
4075 }
4076
4077 GList *
4078 triangle_candidate_points_from_edge(toporouter_t *r, GtsTriangle *t, toporouter_edge_t *e, toporouter_vertex_t *v, toporouter_vertex_t **dest,
4079 toporouter_route_t *routedata)
4080 {
4081 toporouter_vertex_t *v1, *v2, *op_v, *vv = NULL, *e1constraintv = NULL, *e2constraintv = NULL;
4082 toporouter_edge_t *e1, *e2;
4083 GList *e1cands = NULL, *e2cands = NULL, *rval = NULL;
4084 guint noe1 = 0, noe2 = 0;
4085
4086 op_v = TOPOROUTER_VERTEX(gts_triangle_vertex_opposite(t, GTS_EDGE(e)));
4087
4088 e1 = TOPOROUTER_EDGE(gts_vertices_are_connected(GTS_VERTEX(op_v), edge_v1(e)));
4089 e2 = TOPOROUTER_EDGE(gts_vertices_are_connected(GTS_VERTEX(op_v), edge_v2(e)));
4090
4091 g_assert(*dest);
4092
4093 // v1 is prev dir, v2 is next dir
4094 edge_adjacent_vertices(e, v, &v1, &v2);
4095
4096 if(TOPOROUTER_IS_CONSTRAINT(e1)) {
4097 GList *i = edge_routing(e1);
4098
4099 if(TOPOROUTER_CONSTRAINT(e1)->box->type == BOARD) {
4100 noe1 = 1;
4101 }else if(!constraint_route_test(TOPOROUTER_CONSTRAINT(e1), routedata)) {
4102 noe1 = 1;
4103 #ifdef DEBUG_ROUTE
4104 printf("noe1 netlist\n");
4105 #endif
4106 }else
4107
4108 if(v1 == tedge_v1(e) ||
4109 (v1->parent->routingedge && v1->parent->routingedge == e1) ||
4110 (v1->child->routingedge && v1->child->routingedge == e1)) {
4111 e1constraintv = new_temp_toporoutervertex_in_segment(e1, tedge_v1(e1), gts_point_distance(GTS_POINT(edge_v1(e1)), GTS_POINT(edge_v2(e1))) / 2., tedge_v2(e1));
4112 }
4113
4114 while(i) {
4115 toporouter_vertex_t *temp = TOPOROUTER_VERTEX(i->data);
4116
4117 if((temp->child == tedge_v2(e) || temp->parent == tedge_v2(e)) && !(temp->flags & VERTEX_FLAG_TEMP)) noe2 = 1;
4118
4119 i = i->next;
4120 }
4121
4122 goto triangle_candidate_points_e2;
4123 }
4124
4125 if(edge_is_blocked(e1)) {
4126 noe1 = 1;
4127 goto triangle_candidate_points_e2;
4128 }
4129
4130 if(v1 == tedge_v1(e)) {
4131 // continue up e1
4132 toporouter_vertex_t *vv1, *vv2;
4133 edge_adjacent_vertices(e1, v1, &vv1, &vv2);
4134
4135 #ifdef DEBUG_ROUTE
4136 printf("v1 == e->v1\n");
4137 #endif
4138
4139 if(vv1) {
4140 // candidates from v1 until vv1
4141 vv = vv1;
4142 }else{
4143 // candidates from v1 until vv2
4144 vv = vv2;
4145 }
4146
4147 if(!e1constraintv) e1cands = candidate_vertices(v1, vv, *dest, e1);
4148
4149 if(vv != op_v) {
4150 if(vv->parent == tedge_v2(e) || vv->child == tedge_v2(e)) {
4151 #ifdef DEBUG_ROUTE
4152 printf("noe2 0\n");
4153 #endif
4154 noe2 = 1;
4155 }
4156 }
4157
4158 }else if(v1->parent != op_v && v1->child != op_v) {
4159 toporouter_vertex_t *vv1 = NULL, *vv2 = NULL;
4160
4161 #ifdef DEBUG_ROUTE
4162 printf("v1 != e->v1\n");
4163 #endif
4164
4165 if(v1->parent->routingedge == e1) {
4166 vv1 = v1->parent;
4167 #ifdef DEBUG_ROUTE
4168 printf("v1 parent = e1\n");
4169 #endif
4170 if(op_v == tedge_v1(e1)) {
4171 // candidates from v1->parent until prev vertex
4172 vv2 = edge_routing_prev_not_temp(e1, g_list_find(edge_routing(e1), v1->parent)->prev);
4173 }else{
4174 // candidates from v1->parent until next vertex
4175 vv2 = edge_routing_next_not_temp(e1, g_list_find(edge_routing(e1), v1->parent)->next);
4176 }
4177
4178 }else if(v1->child->routingedge == e1) {
4179 vv1 = v1->child;
4180 #ifdef DEBUG_ROUTE
4181 printf("v1 child = e1\n");
4182 #endif
4183 if(op_v == tedge_v1(e1)) {
4184 // candidates from v1->child until prev vertex
4185 vv2 = edge_routing_prev_not_temp(e1, g_list_find(edge_routing(e1), v1->child)->prev);
4186 }else{
4187 // candidates from v1->child until next vertex
4188 vv2 = edge_routing_next_not_temp(e1, g_list_find(edge_routing(e1), v1->child)->next);
4189 }
4190
4191 }else{
4192 #ifdef DEBUG_ROUTE
4193 printf("v1 ? \n");
4194 #endif
4195 goto triangle_candidate_points_e2;
4196 }
4197
4198 if(vv1 && vv2) {
4199 if(vv2->parent == tedge_v2(e) || vv2->child == tedge_v2(e)) {
4200 #ifdef DEBUG_ROUTE
4201 printf("noe2 1\n");
4202 #endif
4203 noe2 = 1;
4204 }
4205
4206 if(!e1constraintv) e1cands = candidate_vertices(vv1, vv2, *dest, e1);
4207
4208 vv = vv2;
4209 }
4210 }
4211
4212 if(vv && vv == op_v) {
4213 toporouter_vertex_t *boxpoint = NULL;
4214
4215 if(vertex_bbox(op_v)) boxpoint = TOPOROUTER_VERTEX(vertex_bbox(op_v)->point);
4216
4217 if(g_list_find(routedata->destvertices, op_v)) {
4218 rval = g_list_prepend(rval, op_v);
4219 *dest = op_v;
4220 }else if(g_list_find(routedata->destvertices, boxpoint)) {
4221 *dest = boxpoint;
4222 }else if(g_list_find(routedata->srcvertices, op_v)) {
4223 rval = g_list_prepend(rval, op_v);
4224 }
4225 }
4226
4227 triangle_candidate_points_e2:
4228
4229 if(noe2) {
4230 // printf("noe2\n");
4231 goto triangle_candidate_points_finish;
4232 }
4233
4234 if(TOPOROUTER_IS_CONSTRAINT(e2)) {
4235 GList *i = edge_routing(e2);
4236
4237 if(TOPOROUTER_CONSTRAINT(e2)->box->type == BOARD) {
4238 noe2 = 1;
4239 // goto triangle_candidate_points_finish;
4240 }else if(!constraint_route_test(TOPOROUTER_CONSTRAINT(e2), routedata)) {
4241 #ifdef DEBUG_ROUTE
4242 printf("noe2 netlist\n");
4243 #endif
4244 noe2 = 1;
4245 // goto triangle_candidate_points_finish;
4246 }else if(v2 == tedge_v2(e) ||
4247 (v2->parent->routingedge && v2->parent->routingedge == e2) ||
4248 (v2->child->routingedge && v2->child->routingedge == e2)) {
4249
4250 e2constraintv = new_temp_toporoutervertex_in_segment(e2, tedge_v1(e2), gts_point_distance(GTS_POINT(edge_v1(e2)), GTS_POINT(edge_v2(e2))) / 2., tedge_v2(e2));
4251
4252 }
4253
4254 while(i) {
4255 toporouter_vertex_t *temp = TOPOROUTER_VERTEX(i->data);
4256
4257 if((temp->child == tedge_v1(e) || temp->parent == tedge_v1(e)) && !(temp->flags & VERTEX_FLAG_TEMP))
4258 noe1 = 1;
4259
4260 i = i->next;
4261 }
4262
4263
4264
4265 goto triangle_candidate_points_finish;
4266 }
4267
4268 if(edge_is_blocked(e2)) {
4269 noe2 = 1;
4270 goto triangle_candidate_points_finish;
4271 }
4272
4273 if(v2 == tedge_v2(e)) {
4274 // continue up e2
4275 toporouter_vertex_t *vv1 = NULL, *vv2 = NULL;
4276 edge_adjacent_vertices(e2, v2, &vv1, &vv2);
4277
4278 #ifdef DEBUG_ROUTE
4279 printf("v2 == e->v2\n");
4280 #endif
4281
4282 if(vv1) {
4283 // candidates from v2 until vv1
4284 vv = vv1;
4285 }else{
4286 // candidates from v2 until vv2
4287 vv = vv2;
4288 }
4289
4290 if(!e2constraintv) e2cands = candidate_vertices(v2, vv, *dest, e2);
4291
4292 if(vv != op_v) {
4293 if(vv->parent == tedge_v1(e) || vv->child == tedge_v1(e)) {
4294 #ifdef DEBUG_ROUTE
4295 printf("noe1 0\n");
4296 #endif
4297 noe1 = 1;
4298 }
4299 }
4300
4301 }else if(v2->parent != op_v && v2->child != op_v) {
4302 toporouter_vertex_t *vv1 = NULL, *vv2 = NULL;
4303
4304 #ifdef DEBUG_ROUTE
4305 printf("v2 == e->v2\n");
4306 #endif
4307
4308 if(v2->parent->routingedge == e2) {
4309 vv1 = v2->parent;
4310 if(op_v == tedge_v1(e2)) {
4311 // candidates from v2->parent until prev vertex
4312 vv2 = edge_routing_prev_not_temp(e2, g_list_find(edge_routing(e2), vv1)->prev);
4313 }else{
4314 // candidates from v2->parent until next vertex
4315 vv2 = edge_routing_next_not_temp(e2, g_list_find(edge_routing(e2), vv1)->next);
4316 }
4317
4318 }else if(v2->child->routingedge == e2) {
4319 vv1 = v2->child;
4320 if(op_v == tedge_v1(e2)) {
4321 // candidates from v2->child until prev vertex
4322 vv2 = edge_routing_prev_not_temp(e2, g_list_find(edge_routing(e2), vv1)->prev);
4323 }else{
4324 // candidates from v2->child until next vertex
4325 vv2 = edge_routing_next_not_temp(e2, g_list_find(edge_routing(e2), vv1)->next);
4326 }
4327
4328 }else{
4329 goto triangle_candidate_points_finish;
4330 }
4331
4332 if(vv1 && vv2) {
4333 if(vv2->parent == tedge_v1(e) || vv2->child == tedge_v1(e)) {
4334 #ifdef DEBUG_ROUTE
4335 printf("noe1 1\n");
4336 #endif
4337 noe1 = 1;
4338 }
4339
4340 if(!e2constraintv) e2cands = candidate_vertices(vv1, vv2, *dest, e2);
4341 }
4342 }
4343
4344 triangle_candidate_points_finish:
4345
4346 v1 = segment_common_vertex(GTS_SEGMENT(e), GTS_SEGMENT(e1));
4347 v2 = segment_common_vertex(GTS_SEGMENT(e), GTS_SEGMENT(e2));
4348
4349 if(noe1 || !check_triangle_interior_capacity(t, v1, v, e2, e, e1)) {
4350 #ifdef DEBUG_ROUTE
4351 printf("freeing e1cands\n");
4352 #endif
4353 routedata_insert_temppoints(routedata, e1cands);
4354 g_list_free(e1cands);
4355 e1cands = NULL;
4356 }
4357
4358 if(noe2 || !check_triangle_interior_capacity(t, v2, v, e1, e, e2)) {
4359 #ifdef DEBUG_ROUTE
4360 printf("freeing e2cands\n");
4361 #endif
4362 routedata_insert_temppoints(routedata, e2cands);
4363 g_list_free(e2cands);
4364 e2cands = NULL;
4365 }
4366
4367 if(!noe1 && e1constraintv) {
4368 e1cands = g_list_prepend(e1cands, e1constraintv);
4369 }else if(e1constraintv) {
4370 g_hash_table_insert(routedata->alltemppoints, e1constraintv, e1constraintv);
4371 // delete_vertex(e1constraintv);
4372 }
4373
4374 if(!noe2 && e2constraintv) {
4375 e2cands = g_list_prepend(e2cands, e2constraintv);
4376 }else if(e2constraintv) {
4377 g_hash_table_insert(routedata->alltemppoints, e2constraintv, e2constraintv);
4378 // delete_vertex(e2constraintv);
4379 }
4380
4381 if(!noe1 && !noe2) return g_list_concat(rval, g_list_concat(e1cands, e2cands));
4382
4383 return g_list_concat(e1cands, e2cands);
4384 }
4385
4386 GList *
4387 compute_candidate_points(toporouter_t *tr, toporouter_layer_t *l, toporouter_vertex_t *curpoint, toporouter_route_t *data,
4388 toporouter_vertex_t **closestdest)
4389 {
4390 GList *r = NULL, *j;
4391 toporouter_edge_t *edge = curpoint->routingedge, *tempedge;
4392
4393 if(vertex_keepout_test(tr, curpoint)) goto compute_candidate_points_finish;
4394
4395 /* direct connection */
4396 // if(curpoint == TOPOROUTER_VERTEX(data->src->point))
4397 if((tempedge = TOPOROUTER_EDGE(gts_vertices_are_connected(GTS_VERTEX(curpoint), GTS_VERTEX(*closestdest))))) {
4398
4399 if(TOPOROUTER_IS_CONSTRAINT(tempedge)) {
4400 goto compute_candidate_points_finish;
4401 }else{
4402 if(!tempedge->routing) {
4403 r = g_list_prepend(NULL, *closestdest);
4404 tempedge->flags |= EDGE_FLAG_DIRECTCONNECTION;
4405 goto compute_candidate_points_finish;
4406 }else{
4407 #ifdef DEBUG_ROUTE
4408 printf("Direct connection, but has routing\n");
4409 #endif
4410 }
4411
4412 }
4413 /* if we get to here, there is routing blocking the direct connection,
4414 * continue as per normal */
4415 }
4416
4417 /* a real point origin */
4418 if(!(curpoint->flags & VERTEX_FLAG_TEMP)) {
4419 GSList *triangles, *i;
4420 i = triangles = gts_vertex_triangles(GTS_VERTEX(curpoint), NULL);
4421 #ifdef DEBUG_ROUTE
4422 printf("triangle count = %d\n", g_slist_length(triangles));
4423 #endif
4424 while(i) {
4425 GtsTriangle *t = GTS_TRIANGLE(i->data);
4426 GList *temppoints;
4427
4428 if(tr->flags & TOPOROUTER_FLAG_LEASTINVALID) temppoints = triangle_all_candidate_points_from_vertex(t, curpoint, data);
4429 else temppoints = triangle_candidate_points_from_vertex(t, curpoint, *closestdest, data);
4430
4431 #ifdef DEBUG_ROUTE
4432 printf("\treturned %d points\n", g_list_length(temppoints));
4433 #endif
4434 routedata_insert_temppoints(data, temppoints);
4435
4436 r = g_list_concat(r, temppoints);
4437 i = i->next;
4438 }
4439 g_slist_free(triangles);
4440 }else /* a temp point */ {
4441 int prevwind = vertex_wind(GTS_SEGMENT(edge)->v1, GTS_SEGMENT(edge)->v2, GTS_VERTEX(curpoint->parent));
4442 // printf("tempoint\n");
4443
4444 GSList *i = GTS_EDGE(edge)->triangles;
4445
4446 while(i) {
4447 GtsVertex *oppv = gts_triangle_vertex_opposite(GTS_TRIANGLE(i->data), GTS_EDGE(edge));
4448 if(prevwind != vertex_wind(GTS_SEGMENT(edge)->v1, GTS_SEGMENT(edge)->v2, oppv)) {
4449 GList *temppoints;
4450
4451 if(tr->flags & TOPOROUTER_FLAG_LEASTINVALID) temppoints = triangle_all_candidate_points_from_edge(tr, GTS_TRIANGLE(i->data), edge,
4452 data, closestdest, curpoint);
4453 else temppoints = triangle_candidate_points_from_edge(tr, GTS_TRIANGLE(i->data), edge, curpoint, closestdest, data);
4454
4455 j = temppoints;
4456 while(j) {
4457 toporouter_vertex_t *tempj = TOPOROUTER_VERTEX(j->data);
4458 if(tempj->flags & VERTEX_FLAG_TEMP)
4459 g_hash_table_insert(data->alltemppoints, j->data, j->data);
4460 #ifdef DEBUG_ROUTE
4461 else
4462 printf("got cand not a temp\n");
4463 #endif
4464 j = j->next;
4465 }
4466 r = g_list_concat(r, temppoints);
4467
4468 break;
4469 }
4470 i = i->next;
4471 }
4472 }
4473
4474 compute_candidate_points_finish:
4475
4476 if(vertex_bbox(curpoint) && vertex_bbox(curpoint)->cluster) {
4477 if(vertex_bbox(curpoint)->cluster->c == data->src->c) {
4478 r = g_list_concat(r, g_list_copy(data->srcvertices));
4479 }
4480 }
4481
4482 return r;
4483 }
4484
4485 gboolean
4486 temp_point_clean(gpointer key, gpointer value, gpointer user_data)
4487 {
4488 toporouter_vertex_t *tv = TOPOROUTER_VERTEX(value);
4489 if(tv->flags & VERTEX_FLAG_TEMP) {
4490 if(TOPOROUTER_IS_CONSTRAINT(tv->routingedge))
4491 TOPOROUTER_CONSTRAINT(tv->routingedge)->routing = g_list_remove(TOPOROUTER_CONSTRAINT(tv->routingedge)->routing, tv);
4492 else
4493 tv->routingedge->routing = g_list_remove(tv->routingedge->routing, tv);
4494 gts_object_destroy ( GTS_OBJECT(tv) );
4495 }
4496 return TRUE;
4497 }
4498
4499 void
4500 clean_routing_edges(toporouter_t *r, toporouter_route_t *data)
4501 {
4502 g_hash_table_foreach_remove(data->alltemppoints, temp_point_clean, NULL);
4503 g_hash_table_destroy(data->alltemppoints);
4504 data->alltemppoints = NULL;
4505 }
4506
4507 gdouble
4508 path_score(toporouter_t *r, GList *path)
4509 {
4510 gdouble score = 0.;
4511 toporouter_vertex_t *pv = NULL;
4512 toporouter_vertex_t *v0 = NULL;
4513
4514 if(!path) return INFINITY;
4515
4516 v0 = TOPOROUTER_VERTEX(path->data);
4517
4518 while(path) {
4519 toporouter_vertex_t *v = TOPOROUTER_VERTEX(path->data);
4520
4521 if(pv) {
4522 score += gts_point_distance(GTS_POINT(pv), GTS_POINT(v));
4523 if(pv != v0 && vz(pv) != vz(v))
4524 if(path->next)
4525 score += r->viacost;
4526
4527 }
4528
4529 pv = v;
4530 path = path->next;
4531 }
4532
4533 return score;
4534 }
4535
4536 void
4537 print_vertices(GList *vertices)
4538 {
4539 while(vertices) {
4540 toporouter_vertex_t *v = TOPOROUTER_VERTEX(vertices->data);
4541 print_vertex(v);
4542 print_bbox(vertex_bbox(v));
4543 if(vertex_bbox(v)) {
4544 printf("has bbox\n");
4545 if(vertex_bbox(v)->cluster)
4546 printf("has cluster\n");
4547 else
4548 printf("no cluster\n");
4549 }else printf("no bbox\n");
4550 vertices = vertices->next;
4551 }
4552 }
4553
4554 gint
4555 space_edge(gpointer item, gpointer data)
4556 {
4557 toporouter_edge_t *e = TOPOROUTER_EDGE(item);
4558 GList *i;
4559 gdouble *forces;
4560
4561 if(TOPOROUTER_IS_CONSTRAINT(e)) return 0;
4562
4563 if(!edge_routing(e) || !g_list_length(edge_routing(e))) return 0;
4564
4565 forces = malloc(sizeof(double) * g_list_length(edge_routing(e)));
4566
4567 for(guint j=0;j<100;j++) {
4568 guint k=0;
4569 guint equilibrium = 1;
4570
4571 i = edge_routing(e);
4572 while(i) {
4573 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
4574 gdouble ms, d;
4575
4576 if(i->prev) {
4577 // ms = min_net_net_spacing(TOPOROUTER_VERTEX(i->prev->data), v);
4578 ms = min_spacing(TOPOROUTER_VERTEX(i->prev->data), v);
4579 d = gts_point_distance(GTS_POINT(i->prev->data), GTS_POINT(v));
4580 }else{
4581 // ms = min_vertex_net_spacing(v, tedge_v1(e));
4582 ms = min_spacing(v, tedge_v1(e));
4583 d = gts_point_distance(GTS_POINT(edge_v1(e)), GTS_POINT(v));
4584 }
4585
4586 if(d < ms) forces[k] = ms - d;
4587 else forces[k] = 0.;
4588
4589 if(i->next) {
4590 // ms = min_net_net_spacing(TOPOROUTER_VERTEX(i->next->data), v);
4591 ms = min_spacing(TOPOROUTER_VERTEX(i->next->data), v);
4592 d = gts_point_distance(GTS_POINT(i->next->data), GTS_POINT(v));
4593 }else{
4594 // ms = min_vertex_net_spacing(v, tedge_v2(e));
4595 ms = min_spacing(v, tedge_v2(e));
4596 d = gts_point_distance(GTS_POINT(edge_v2(e)), GTS_POINT(v));
4597 }
4598
4599 if(d < ms) forces[k] += d - ms;
4600
4601 k++; i = i->next;
4602 }
4603
4604 k = 0;
4605 i = edge_routing(e);
4606 while(i) {
4607 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
4608 if(forces[k] > EPSILON || forces[k] < -EPSILON) equilibrium = 0;
4609 vertex_move_towards_vertex_values(GTS_VERTEX(v), edge_v2(e), forces[k] * 0.1, &(GTS_POINT(v)->x), &(GTS_POINT(v)->y));
4610 k++; i = i->next;
4611 }
4612
4613 if(equilibrium) {
4614 // printf("reached equilibriium at %d\n", j);
4615 break;
4616 }
4617
4618 }
4619
4620 free(forces);
4621 return 0;
4622 }
4623
4624 void
4625 swap_vertices(toporouter_vertex_t **v1, toporouter_vertex_t **v2)
4626 {
4627 toporouter_vertex_t *tempv = *v1;
4628 *v1 = *v2;
4629 *v2 = tempv;
4630 }
4631
4632 void
4633 split_edge_routing(toporouter_vertex_t *v, GList **l1, GList **l2)
4634 {
4635 GList *base, *i;
4636
4637 g_assert(v);
4638 g_assert(v->routingedge);
4639
4640 base = g_list_find(vrouting(v), v);
4641
4642 *l1 = g_list_prepend(*l1, tedge_v1(v->routingedge));
4643 *l2 = g_list_prepend(*l2, tedge_v2(v->routingedge));
4644
4645 g_assert(base);
4646
4647 i = base->next;
4648 while(i) {
4649 if(!(TOPOROUTER_VERTEX(i->data)->flags & VERTEX_FLAG_TEMP)) *l2 = g_list_prepend(*l2, i->data);
4650 i = i->next;
4651 }
4652
4653 i = base->prev;
4654 while(i) {
4655 if(!(TOPOROUTER_VERTEX(i->data)->flags & VERTEX_FLAG_TEMP)) *l1 = g_list_prepend(*l1, i->data);
4656 i = i->prev;
4657 }
4658 }
4659
4660 GList *
4661 vertices_routing_conflicts(toporouter_vertex_t *v, toporouter_vertex_t *pv)
4662 {
4663 toporouter_edge_t *e;
4664 GList *rval = NULL, *l1 = NULL, *l2 = NULL, *i;
4665
4666 if(vz(v) != vz(pv)) return NULL;
4667 g_assert(v != pv);
4668
4669 if(!v->routingedge && !pv->routingedge) {
4670 e = TOPOROUTER_EDGE(gts_vertices_are_connected(GTS_VERTEX(v), GTS_VERTEX(pv)));
4671 if(!e) return NULL;
4672 i = edge_routing(e);
4673 while(i) {
4674 rval = g_list_prepend(rval, TOPOROUTER_VERTEX(i->data)->route);
4675 i = i->next;
4676 }
4677 return rval;
4678 }
4679
4680 if(TOPOROUTER_IS_CONSTRAINT(v->routingedge) && TOPOROUTER_IS_CONSTRAINT(pv->routingedge))
4681 return NULL;
4682
4683 if(TOPOROUTER_IS_CONSTRAINT(pv->routingedge)) swap_vertices(&pv, &v);
4684
4685 if(!v->routingedge) swap_vertices(&pv, &v);
4686
4687 e = v->routingedge;
4688
4689 split_edge_routing(v, &l1, &l2);
4690 g_assert(l2);
4691 g_assert(l1);
4692
4693 if(!pv->routingedge) {
4694 toporouter_edge_t *e1, *e2;
4695 e1 = TOPOROUTER_EDGE(gts_vertices_are_connected(GTS_VERTEX(pv), edge_v1(e)));
4696 e2 = TOPOROUTER_EDGE(gts_vertices_are_connected(GTS_VERTEX(pv), edge_v2(e)));
4697
4698 l1 = g_list_concat(l1, g_list_copy(edge_routing(e1)));
4699 l2 = g_list_concat(l2, g_list_copy(edge_routing(e2)));
4700
4701 }else{
4702 GList *pvlist1 = NULL, *pvlist2 = NULL;
4703 toporouter_vertex_t *commonv = route_vertices_common_vertex(v, pv);
4704
4705 g_assert(commonv);
4706
4707 split_edge_routing(pv, &pvlist1, &pvlist2);
4708
4709 if(commonv == tedge_v1(e)) {
4710 toporouter_edge_t *ope;
4711
4712 if(commonv == tedge_v1(pv->routingedge)) {
4713 l1 = g_list_concat(l1, pvlist1);
4714 l2 = g_list_concat(l2, pvlist2);
4715 ope = TOPOROUTER_EDGE(gts_vertices_are_connected(edge_v2(e), edge_v2(pv->routingedge)));
4716 }else{
4717 l1 = g_list_concat(l1, pvlist2);
4718 l2 = g_list_concat(l2, pvlist1);
4719 ope = TOPOROUTER_EDGE(gts_vertices_are_connected(edge_v2(e), edge_v1(pv->routingedge)));
4720 }
4721 g_assert(ope);
4722 l2 = g_list_concat(l2, g_list_copy(edge_routing(ope)));
4723
4724 }else{
4725 toporouter_edge_t *ope;
4726 if(commonv == tedge_v1(pv->routingedge)) {
4727 l1 = g_list_concat(l1, pvlist2);
4728 l2 = g_list_concat(l2, pvlist1);
4729 ope = TOPOROUTER_EDGE(gts_vertices_are_connected(edge_v1(e), edge_v2(pv->routingedge)));
4730 }else{
4731 l1 = g_list_concat(l1, pvlist1);
4732 l2 = g_list_concat(l2, pvlist2);
4733 ope = TOPOROUTER_EDGE(gts_vertices_are_connected(edge_v1(e), edge_v1(pv->routingedge)));
4734 }
4735 g_assert(ope);
4736 l1 = g_list_concat(l1, g_list_copy(edge_routing(ope)));
4737 }
4738 }
4739
4740 i = l1;
4741 while(i) {
4742 toporouter_vertex_t *curv = TOPOROUTER_VERTEX(i->data);
4743
4744 if(curv->flags & VERTEX_FLAG_ROUTE && (g_list_find(l2, curv->parent) || g_list_find(l2, curv->child))) {
4745 if(!g_list_find(rval, curv->route)) rval = g_list_prepend(rval, curv->route);
4746 }
4747 i = i->next;
4748 }
4749 i = l2;
4750 while(i) {
4751 toporouter_vertex_t *curv = TOPOROUTER_VERTEX(i->data);
4752
4753 if(curv->flags & VERTEX_FLAG_ROUTE && (g_list_find(l1, curv->parent) || g_list_find(l1, curv->child))) {
4754 if(!g_list_find(rval, curv->route)) rval = g_list_prepend(rval, curv->route);
4755 }
4756 i = i->next;
4757 }
4758
4759 g_list_free(l1);
4760 g_list_free(l2);
4761
4762 return rval;
4763 }
4764
4765 gdouble
4766 vertices_routing_conflict_cost(toporouter_t *r, toporouter_vertex_t *v, toporouter_vertex_t *pv, guint *n)
4767 {
4768 GList *conflicts = vertices_routing_conflicts(v, pv), *i;
4769 gdouble penalty = 0.;
4770
4771 i = conflicts;
4772 while(i) {
4773 (*n) += 1;
4774 penalty += TOPOROUTER_ROUTE(i->data)->score;
4775 i = i->next;
4776 }
4777 g_list_free(conflicts);
4778 // if(penalty > 0.) printf("conflict penalty of %f with %f,%f %f,%f\n", penalty, vx(v), vy(v), vx(pv), vy(pv));
4779 return penalty;
4780 }
4781
4782 gdouble
4783 gcost(toporouter_t *r, toporouter_route_t *data, toporouter_vertex_t *srcv, toporouter_vertex_t *v, toporouter_vertex_t *pv, guint *n,
4784 toporouter_netlist_t *pair)
4785 {
4786 gdouble cost = 0., segcost;
4787
4788 *n = pv->gn;
4789
4790 if(g_list_find(data->srcvertices, v)) return 0.;
4791
4792 segcost = tvdistance(pv, v);
4793
4794 if(pair && !TOPOROUTER_IS_CONSTRAINT(v->routingedge) && v->routingedge) {
4795 GList *list = g_list_find(v->routingedge->routing, v);
4796 toporouter_vertex_t *pv = edge_routing_prev_not_temp(v->routingedge, list);
4797 toporouter_vertex_t *nv = edge_routing_next_not_temp(v->routingedge, list);
4798
4799 if(pv->route && pv->route->netlist == pair) {
4800 }else if(nv->route && nv->route->netlist == pair) {
4801 }else{
4802 segcost *= 10.;
4803 }
4804 }
4805
4806 cost = pv->gcost + segcost;
4807
4808 if(r->flags & TOPOROUTER_FLAG_LEASTINVALID) {
4809 gdouble conflictcost = 0.;
4810
4811 if(pv && v != pv && vz(v) == vz(pv)) conflictcost = vertices_routing_conflict_cost(r, v, pv, n);
4812
4813 if(!(r->flags & TOPOROUTER_FLAG_DETOUR && *n == 1)) {
4814 cost += conflictcost * (pow(*n,2));
4815 }
4816 }
4817
4818 return cost;
4819 }
4820
4821 #define vlayer(x) (&r->layers[(int)vz(x)])
4822
4823 guint
4824 candidate_is_available(toporouter_vertex_t *pv, toporouter_vertex_t *v)
4825 {
4826 // TODO: still needed?
4827 while(pv) {
4828 if(pv == v) return 0;
4829 pv = pv->parent;
4830 }
4831
4832 return 1;
4833 }
4834
4835 GList *
4836 route(toporouter_t *r, toporouter_route_t *data, guint debug)
4837 {
4838 GtsEHeap *openlist = gts_eheap_new(route_heap_cmp, NULL);
4839 GList *closelist = NULL;
4840 GList *i, *rval = NULL;
4841 toporouter_netlist_t *pair = NULL;
4842 gint count = 0;
4843
4844 toporouter_vertex_t *srcv = NULL, *destv = NULL, *curpoint = NULL;
4845 toporouter_layer_t *cur_layer, *dest_layer;
4846
4847 g_assert(data->src->c != data->dest->c);
4848
4849 if(data->destvertices) g_list_free(data->destvertices);
4850 if(data->srcvertices) g_list_free(data->srcvertices);
4851
4852 data->destvertices = cluster_vertices(r, data->dest);
4853 data->srcvertices = cluster_vertices(r, data->src);
4854
4855 closest_cluster_pair(r, data->srcvertices, data->destvertices, &curpoint, &destv);
4856
4857 if(!curpoint || !destv) goto routing_return;
4858
4859 srcv = curpoint;
4860 cur_layer = vlayer(curpoint); dest_layer = vlayer(destv);
4861
4862 data->path = NULL;
4863
4864 data->alltemppoints = g_hash_table_new(g_direct_hash, g_direct_equal);
4865
4866 curpoint->parent = NULL;
4867 curpoint->child = NULL;
4868 curpoint->gcost = 0.;
4869 curpoint->gn = 0;
4870 curpoint->hcost = simple_h_cost(r, curpoint, destv);
4871
4872 if(data->netlist && data->netlist->pair) {
4873 GList *i = r->routednets;
4874 while(i) {
4875 toporouter_route_t *curroute = TOPOROUTER_ROUTE(i->data);
4876 if(curroute->netlist == data->netlist->pair) {
4877 pair = data->netlist->pair;
4878 break;
4879 }
4880 i = i->next;
4881 }
4882 }
4883
4884 gts_eheap_insert(openlist, curpoint);
4885
4886 while(gts_eheap_size(openlist) > 0) {
4887 GList *candidatepoints;
4888 data->curpoint = curpoint;
4889 //draw_route_status(r, closelist, openlist, curpoint, data, count++);
4890
4891 curpoint = TOPOROUTER_VERTEX( gts_eheap_remove_top(openlist, NULL) );
4892 if(curpoint->parent && !(curpoint->flags & VERTEX_FLAG_TEMP)) {
4893 if(vz(curpoint) != vz(destv)) {
4894 toporouter_vertex_t *tempv;
4895 cur_layer = vlayer(curpoint);//&r->layers[(int)vz(curpoint)];
4896 tempv = closest_dest_vertex(r, curpoint, data);
4897 if(tempv) {
4898 destv = tempv;
4899 dest_layer = vlayer(destv);//&r->layers[(int)vz(destv)];
4900
4901 }
4902 }
4903 }
4904
4905 // destpoint = closest_dest_vertex(r, curpoint, data);
4906 // dest_layer = &r->layers[(int)vz(destpoint)];
4907
4908 if(g_list_find(data->destvertices, curpoint)) {
4909 toporouter_vertex_t *temppoint = curpoint;
4910 srcv = NULL;
4911 destv = curpoint;
4912
4913 data->path = NULL;
4914
4915 while(temppoint) {
4916 data->path = g_list_prepend(data->path, temppoint);
4917 if(g_list_find(data->srcvertices, temppoint)) {
4918 srcv = temppoint;
4919 if(r->flags & TOPOROUTER_FLAG_AFTERORDER) break;
4920 }
4921 temppoint = temppoint->parent;
4922 }
4923 rval = data->path;
4924 data->score = path_score(r, data->path);
4925 #ifdef DEBUG_ROUTE
4926 printf("ROUTE: path score = %f computation cost = %d\n", data->score, count);
4927 #endif
4928
4929 if(srcv->bbox->cluster != data->src) {
4930 data->src = srcv->bbox->cluster;
4931 }
4932
4933 if(destv->bbox->cluster != data->dest) {
4934 data->dest = destv->bbox->cluster;
4935 }
4936 goto route_finish;
4937 }
4938 closelist_insert(curpoint);
4939 #ifdef DEBUG_ROUTE
4940 printf("\n\n\n*** ROUTE COUNT = %d\n", count);
4941 #endif
4942 candidatepoints = compute_candidate_points(r, cur_layer, curpoint, data, &destv);
4943
4944 //#ifdef DEBUG_ROUTE
4945 /*********************
4946 if(debug && !strcmp(data->dest->netlist, " unnamed_net2"))
4947 {
4948 unsigned int mask = ~(VERTEX_FLAG_RED | VERTEX_FLAG_GREEN | VERTEX_FLAG_BLUE);
4949 char buffer[256];
4950 int j;
4951
4952 for(j=0;j<groupcount();j++) {
4953 i = r->layers[j].vertices;
4954 while(i) {
4955 TOPOROUTER_VERTEX(i->data)->flags &= mask;
4956 i = i->next;
4957 }
4958 }
4959
4960 i = candidatepoints;
4961 while(i) {
4962 TOPOROUTER_VERTEX(i->data)->flags |= VERTEX_FLAG_GREEN;
4963 // printf("flagged a candpoint @ %f,%f\n",
4964 // vx(i->data), vy(i->data));
4965 i = i->next;
4966 }
4967
4968 curpoint->flags |= VERTEX_FLAG_BLUE;
4969 if(curpoint->parent)
4970 curpoint->parent->flags |= VERTEX_FLAG_RED;
4971
4972
4973 for(j=0;j<groupcount();j++) {
4974 GList *datas = g_list_prepend(NULL, data);
4975 sprintf(buffer, "route-%d-%05d.png", j, count);
4976 toporouter_draw_surface(r, r->layers[j].surface, buffer, 1024, 1024, 2, datas, j, candidatepoints);
4977 g_list_free(datas);
4978 }
4979 }
4980 //#endif
4981 *********************/
4982 count++;
4983 // if(count > 100) exit(0);
4984 i = candidatepoints;
4985 while(i) {
4986 toporouter_vertex_t *temppoint = TOPOROUTER_VERTEX(i->data);
4987 if(!g_list_find(closelist, temppoint) && candidate_is_available(curpoint, temppoint)) { //&& temppoint != curpoint) {
4988 toporouter_heap_search_data_t heap_search_data = { temppoint, NULL };
4989
4990 guint temp_gn;
4991 gdouble temp_g_cost = gcost(r, data, srcv, temppoint, curpoint, &temp_gn, pair);
4992
4993
4994 gts_eheap_foreach(openlist,toporouter_heap_search, &heap_search_data);
4995
4996 if(heap_search_data.result) {
4997 if(temp_g_cost < temppoint->gcost) {
4998
4999 temppoint->gcost = temp_g_cost;
5000 temppoint->gn = temp_gn;
5001
5002 temppoint->parent = curpoint;
5003 curpoint->child = temppoint;
5004
5005 gts_eheap_update(openlist);
5006 }
5007 }else{
5008 temppoint->parent = curpoint;
5009 curpoint->child = temppoint;
5010
5011 temppoint->gcost = temp_g_cost;
5012 temppoint->gn = temp_gn;
5013
5014 temppoint->hcost = simple_h_cost(r, temppoint, destv);
5015 // if(cur_layer != dest_layer) temppoint->hcost += r->viacost;
5016 gts_eheap_insert(openlist, temppoint);
5017 }
5018
5019 }
5020 i = i->next;
5021 }
5022 g_list_free(candidatepoints);
5023
5024 }
5025 #ifdef DEBUG_ROUTE
5026 printf("ROUTE: could not find path!\n");
5027 #endif
5028
5029 data->score = INFINITY;
5030 clean_routing_edges(r, data);
5031
5032 data->path = NULL;
5033 //TOPOROUTER_VERTEX(data->src->point)->parent = NULL;
5034 //TOPOROUTER_VERTEX(data->src->point)->child = NULL;
5035 goto routing_return;
5036
5037 /*
5038 {
5039 int i;
5040 for(i=0;i<groupcount();i++) {
5041 char buffer[256];
5042 sprintf(buffer, "route-error-%d-%d.png", r->routecount, i);
5043 toporouter_draw_surface(r, r->layers[i].surface, buffer, 1280, 1280, 2, data, i, NULL);
5044 }
5045 r->routecount++;
5046 }
5047 // exit(0);
5048 */
5049 route_finish:
5050 // printf(" * finished a*\n");
5051 /*
5052 {
5053 int i;
5054 for(i=0;i<groupcount();i++) {
5055 char buffer[256];
5056 sprintf(buffer, "route-preclean-%d-%d.png", i, r->routecount);
5057 toporouter_draw_surface(r, r->layers[i].surface, buffer, 1024, 1024, 2, data, i, NULL);
5058 }
5059 r->routecount++;
5060 }
5061 */
5062 /* {
5063 i = data->path;
5064 while(i) {
5065 toporouter_vertex_t *tv = TOPOROUTER_VERTEX(i->data);
5066
5067 if(tv->routingedge) {
5068 GList *list = g_list_find(edge_routing(tv->routingedge), tv);
5069 toporouter_vertex_t *restartv = NULL, *boxpoint;
5070
5071 g_assert(list);
5072
5073 if(!list->next) {
5074 if(vertex_bbox(tedge_v2(tv->routingedge)))
5075 boxpoint = TOPOROUTER_VERTEX(vertex_bbox(tedge_v2(tv->routingedge))->point);
5076 else
5077 boxpoint = NULL;
5078
5079 if(tedge_v2(tv->routingedge) != srcv && g_list_find(data->srcvertices, tedge_v2(tv->routingedge)))
5080 restartv = tedge_v2(tv->routingedge);
5081 else if(boxpoint != srcv && g_list_find(data->srcvertices, boxpoint))
5082 restartv = boxpoint;
5083 }
5084
5085 if(!list->prev) {
5086 if(vertex_bbox(tedge_v1(tv->routingedge)))
5087 boxpoint = TOPOROUTER_VERTEX(vertex_bbox(tedge_v1(tv->routingedge))->point);
5088 else
5089 boxpoint = NULL;
5090
5091 if(tedge_v1(tv->routingedge) != srcv && g_list_find(data->srcvertices, tedge_v1(tv->routingedge)))
5092 restartv = tedge_v1(tv->routingedge);
5093 else if(boxpoint != srcv && g_list_find(data->srcvertices, boxpoint))
5094 restartv = boxpoint;
5095
5096 }
5097
5098 if(restartv) {
5099 clean_routing_edges(r, data);
5100 gts_eheap_destroy(openlist);
5101 g_list_free(closelist);
5102 openlist = gts_eheap_new(route_heap_cmp, NULL);
5103 closelist = NULL;
5104 g_list_free(data->path);
5105 printf("ROUTING RESTARTING with new src %f,%f,%f\n", vx(restartv), vy(restartv), vz(restartv));
5106 curpoint = restartv;
5107 goto route_begin;
5108 }
5109 }
5110
5111 i = i->next;
5112 }
5113 }*/
5114 ///*
5115 {
5116 toporouter_vertex_t *pv = NULL;
5117 GList *i = data->path;
5118 while(i) {
5119 toporouter_vertex_t *tv = TOPOROUTER_VERTEX(i->data);
5120
5121 if(pv && g_list_find(data->srcvertices, tv)) {
5122 GList *temp = g_list_copy(i);
5123 g_list_free(data->path);
5124 data->path = temp;
5125 i = data->path;
5126 }
5127 pv = tv;
5128 i = i->next;
5129 }
5130 }
5131 //*/
5132 {
5133 toporouter_vertex_t *pv = NULL;
5134 GList *i = data->path;
5135 while(i) {
5136 toporouter_vertex_t *tv = TOPOROUTER_VERTEX(i->data);
5137 if(tv->flags & VERTEX_FLAG_TEMP) {
5138 tv->flags ^= VERTEX_FLAG_TEMP;
5139 tv->flags |= VERTEX_FLAG_ROUTE;
5140 }
5141 if(pv) pv->child = tv;
5142
5143 if(tv->routingedge) tv->route = data;
5144
5145 // if(tv->routingedge && !TOPOROUTER_IS_CONSTRAINT(tv->routingedge)) space_edge(tv->routingedge, NULL);
5146
5147 pv = tv;
5148 i = i->next;
5149 }
5150 }
5151
5152 {
5153 toporouter_vertex_t *pv = NULL, *v = NULL;
5154
5155 GList *i = data->path;
5156 while(i) {
5157 v = TOPOROUTER_VERTEX(i->data);
5158
5159 if(pv) {
5160 v->parent = pv;
5161 pv->child = v;
5162 }else{
5163 v->parent = NULL;
5164 }
5165
5166 pv = v;
5167 i = i->next;
5168 }
5169
5170 if(v) v->child = NULL;
5171 }
5172
5173 clean_routing_edges(r, data);
5174 // /*
5175 {
5176 GList *i = data->path;
5177 while(i) {
5178 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
5179
5180 if(v->routingedge && !TOPOROUTER_IS_CONSTRAINT(v->routingedge))
5181 space_edge(v->routingedge, NULL);
5182 i = i->next;
5183 }
5184 }
5185 // */
5186 routing_return:
5187
5188 g_list_free(data->destvertices);
5189 g_list_free(data->srcvertices);
5190 data->destvertices = NULL;
5191 data->srcvertices = NULL;
5192 gts_eheap_destroy(openlist);
5193 g_list_free(closelist);
5194
5195 data->alltemppoints = NULL;
5196
5197 return rval;
5198 }
5199
5200 /* moves vertex v d units in the direction of vertex p */
5201 void
5202 vertex_move_towards_point(GtsVertex *v, gdouble px, gdouble py, gdouble d)
5203 {
5204 gdouble dx = px - GTS_POINT(v)->x;
5205 gdouble dy = py - GTS_POINT(v)->y;
5206 gdouble theta = atan(fabs(dy/dx));
5207
5208 g_assert(finite(theta));
5209
5210 if( dx >= 0. ) {
5211
5212 if( dy >= 0. ) {
5213 GTS_POINT(v)->x += d * cos(theta);
5214 GTS_POINT(v)->y += d * sin(theta);
5215 }else{
5216 GTS_POINT(v)->x += d * cos(theta);
5217 GTS_POINT(v)->y -= d * sin(theta);
5218 }
5219
5220 }else{
5221
5222 if( dy >= 0. ) {
5223 GTS_POINT(v)->x -= d * cos(theta);
5224 GTS_POINT(v)->y += d * sin(theta);
5225 }else{
5226 GTS_POINT(v)->x -= d * cos(theta);
5227 GTS_POINT(v)->y -= d * sin(theta);
5228 }
5229
5230 }
5231
5232 }
5233
5234 /* moves vertex v d units in the direction of vertex p */
5235 void
5236 vertex_move_towards_vertex(GtsVertex *v, GtsVertex *p, gdouble d)
5237 {
5238 gdouble dx = GTS_POINT(p)->x - GTS_POINT(v)->x;
5239 gdouble dy = GTS_POINT(p)->y - GTS_POINT(v)->y;
5240 gdouble theta = atan(fabs(dy/dx));
5241
5242 g_assert(finite(theta));
5243
5244 if( dx >= 0. ) {
5245
5246 if( dy >= 0. ) {
5247 GTS_POINT(v)->x += d * cos(theta);
5248 GTS_POINT(v)->y += d * sin(theta);
5249 }else{
5250 GTS_POINT(v)->x += d * cos(theta);
5251 GTS_POINT(v)->y -= d * sin(theta);
5252 }
5253
5254 }else{
5255
5256 if( dy >= 0. ) {
5257 GTS_POINT(v)->x -= d * cos(theta);
5258 GTS_POINT(v)->y += d * sin(theta);
5259 }else{
5260 GTS_POINT(v)->x -= d * cos(theta);
5261 GTS_POINT(v)->y -= d * sin(theta);
5262 }
5263
5264 }
5265
5266 }
5267
5268
5269 gdouble
5270 pathvertex_arcing_through_constraint(toporouter_vertex_t *pathv, toporouter_vertex_t *arcv)
5271 {
5272 toporouter_vertex_t *v = pathv->child;
5273
5274 if(!v || !v->routingedge) return 0.;
5275
5276 while(v->flags & VERTEX_FLAG_ROUTE && (tedge_v1(v->routingedge) == arcv || tedge_v2(v->routingedge) == arcv)) {
5277 if(TOPOROUTER_IS_CONSTRAINT(v->routingedge))
5278 return gts_point_distance(GTS_POINT(tedge_v1(v->routingedge)), GTS_POINT(tedge_v2(v->routingedge)));
5279 v = v->child;
5280 }
5281
5282 v = pathv->parent;
5283 while(v->flags & VERTEX_FLAG_ROUTE && (tedge_v1(v->routingedge) == arcv || tedge_v2(v->routingedge) == arcv)) {
5284 if(TOPOROUTER_IS_CONSTRAINT(v->routingedge))
5285 return gts_point_distance(GTS_POINT(tedge_v1(v->routingedge)), GTS_POINT(tedge_v2(v->routingedge)));
5286 v = v->parent;
5287 }
5288
5289 return 0.;
5290 }
5291
5292 gint
5293 vertices_connected(toporouter_vertex_t *a, toporouter_vertex_t *b)
5294 {
5295 return ((a->route->netlist == b->route->netlist && a->route->src->c == b->route->src->c) ? 1 : 0);
5296 }
5297
5298 gdouble
5299 edge_min_spacing(GList *list, toporouter_edge_t *e, toporouter_vertex_t *v, guint debug)
5300 {
5301 toporouter_vertex_t *origin;
5302 GList *i = list;
5303 gdouble space = 0.;
5304 toporouter_vertex_t *nextv, *prevv;
5305 //toporouter_vertex_t *edgev;
5306 //gdouble constraint_spacing;
5307
5308 if(!list) return INFINITY;
5309
5310 // printf("\t CMS %f,%f - %f,%f\n", vx(tedge_v1(e)), vy(tedge_v1(e)), vx(tedge_v2(e)), vy(tedge_v2(e)));
5311
5312 prevv = origin = TOPOROUTER_VERTEX(list->data);
5313
5314 // print_edge(e);
5315
5316 i = list;
5317 if(gts_point_distance2(GTS_POINT(origin), GTS_POINT(edge_v1(e))) < gts_point_distance2(GTS_POINT(v), GTS_POINT(edge_v1(e)))) {
5318
5319 /* towards v2 */
5320 while(i) {
5321 nextv = edge_routing_next(e, i);
5322 if(nextv->route && vertices_connected(nextv, prevv)) { i = i->next; continue; }
5323 if(!(nextv->flags & VERTEX_FLAG_TEMP)) {
5324 gdouble ms = min_spacing(prevv, nextv);
5325 if(nextv == tedge_v2(e)) {
5326 gdouble cms = pathvertex_arcing_through_constraint(TOPOROUTER_VERTEX(i->data), tedge_v2(e));
5327 // printf("\t CMS to %f,%f = %f \t ms = %f\n", vx(tedge_v2(e)), vy(tedge_v2(e)), cms, ms);
5328 // if(vx(tedge_v2(e)) > -EPSILON && vx(tedge_v2(e)) < EPSILON) {
5329 // printf("\t\tPROB: ");
5330 // print_vertex(tedge_v2(e));
5331 // }
5332 if(cms > EPSILON) space += MIN(ms, cms / 2.);
5333 else space += ms;
5334 } else
5335 space += ms;
5336
5337 prevv = nextv;
5338 }
5339 // printf("%f ", space);
5340 i = i->next;
5341 }
5342 }else{
5343
5344 /* towards v1 */
5345 while(i) {
5346 nextv = edge_routing_prev(e, i);
5347 if(nextv->route && vertices_connected(nextv, prevv)) { i = i->prev; continue; }
5348 if(!(nextv->flags & VERTEX_FLAG_TEMP)) {
5349 gdouble ms = min_spacing(prevv, nextv);
5350 if(nextv == tedge_v1(e)) {
5351 gdouble cms = pathvertex_arcing_through_constraint(TOPOROUTER_VERTEX(i->data), tedge_v1(e));
5352 // printf("\t CMS to %f,%f = %f \t ms = %f\n", vx(tedge_v1(e)), vy(tedge_v1(e)), cms, ms);
5353 // if(vx(tedge_v1(e)) > -EPSILON && vx(tedge_v1(e)) < EPSILON) {
5354 // printf("\t\tPROB: ");
5355 // print_vertex(tedge_v1(e));
5356 // }
5357 if(cms > EPSILON) space += MIN(ms, cms / 2.);
5358 else space += ms;
5359 } else
5360 space += ms;
5361
5362 prevv = nextv;
5363 }
5364 // printf("%f ", space);
5365 i = i->prev;
5366 }
5367 }
5368
5369 if(TOPOROUTER_IS_CONSTRAINT(e) && space > gts_point_distance(GTS_POINT(edge_v1(e)), GTS_POINT(edge_v2(e))) / 2.)
5370 space = gts_point_distance(GTS_POINT(edge_v1(e)), GTS_POINT(edge_v2(e))) / 2.;
5371
5372 // if(debug) printf("\tedge_min_spacing: %f\n", space);
5373 return space;
5374 }
5375
5376 /* line segment is 1 & 2, point is 3
5377 returns 0 if v3 is outside seg
5378 */
5379 guint
5380 vertex_line_normal_intersection(gdouble x1, gdouble y1, gdouble x2, gdouble y2, gdouble x3, gdouble y3, gdouble *x, gdouble *y)
5381 {
5382 gdouble m1 = cartesian_gradient(x1,y1,x2,y2);
5383 gdouble m2 = perpendicular_gradient(m1);
5384 gdouble c2 = (isinf(m2)) ? x3 : y3 - (m2 * x3);
5385 gdouble c1 = (isinf(m1)) ? x1 : y1 - (m1 * x1);
5386
5387 if(isinf(m2))
5388 *x = x3;
5389 else if(isinf(m1))
5390 *x = x1;
5391 else
5392 *x = (c2 - c1) / (m1 - m2);
5393
5394 *y = (isinf(m2)) ? y1 : (m2 * (*x)) + c2;
5395
5396 if(*x >= MIN(x1,x2) - EPSILON && *x <= MAX(x1,x2) + EPSILON && *y >= MIN(y1,y2) - EPSILON && *y <= MAX(y1,y2) + EPSILON)
5397 return 1;
5398 return 0;
5399 }
5400
5401 void
5402 print_toporouter_arc(toporouter_arc_t *arc)
5403 {
5404 // GList *i = arc->vs;
5405
5406 printf("ARC CENTRE: %f,%f ", vx(arc->centre), vy(arc->centre));// print_vertex(arc->centre);
5407 printf("RADIUS: %f", arc->r);
5408
5409 if(arc->dir>0) printf(" COUNTERCLOCKWISE ");
5410 else if(arc->dir<0) printf(" CLOCKWISE ");
5411 else printf(" COLINEAR(ERROR) ");
5412 /*
5413 printf("\n\tVS: ");
5414
5415 while(i) {
5416 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
5417 printf("%f,%f ", vx(v), vy(v));
5418
5419 i = i->next;
5420 }
5421 */
5422 }
5423
5424 void
5425 toporouter_arc_remove(toporouter_oproute_t *oproute, toporouter_arc_t *arc)
5426 {
5427 oproute->arcs = g_list_remove(oproute->arcs, arc);
5428
5429 if(arc->v) arc->v->arc = NULL;
5430 }
5431
5432 toporouter_arc_t *
5433 toporouter_arc_new(toporouter_oproute_t *oproute, toporouter_vertex_t *v1, toporouter_vertex_t *v2, toporouter_vertex_t *centre, gdouble r, gint dir)
5434 {
5435 toporouter_arc_t *arc = TOPOROUTER_ARC(gts_object_new(GTS_OBJECT_CLASS(toporouter_arc_class())));
5436 arc->centre = centre;
5437 arc->v = v1;
5438 arc->v1 = v1;
5439 arc->v2 = v2;
5440 arc->r = r;
5441 arc->dir = dir;
5442
5443 if(v1) v1->arc = arc;
5444 arc->oproute = oproute;
5445
5446 arc->clearance = NULL;
5447
5448 return arc;
5449 }
5450
5451 void
5452 path_set_oproute(GList *path, toporouter_oproute_t *oproute)
5453 {
5454 while(path) {
5455 toporouter_vertex_t *v = TOPOROUTER_VERTEX(path->data);
5456
5457 if(v->flags & VERTEX_FLAG_ROUTE)
5458 v->oproute = oproute;
5459
5460 path = path->next;
5461 }
5462 }
5463
5464 void
5465 print_oproute(toporouter_oproute_t *oproute)
5466 {
5467 GList *i = oproute->arcs;
5468
5469 printf("Optimized Route:\n");
5470 printf("\tNetlist:\t\t%s\n\tStyle:\t\t%s\n", oproute->netlist, oproute->style);
5471 // printf("%s\n", oproute->netlist);
5472 /*
5473 i = oproute->term1->zlink;
5474 while(i) {
5475 toporouter_vertex_t *thisv = TOPOROUTER_VERTEX(i->data);
5476 printf("\tNetlist:\t\t%s\n\tStyle:\t\t%s\n", vertex_bbox(thisv)->netlist, vertex_bbox(thisv)->style);
5477 i = i->next;
5478 }
5479 */
5480 printf("\t"); print_vertex(oproute->term1); printf("\n");
5481 i = oproute->arcs;
5482 while(i) {
5483 toporouter_arc_t *arc = (toporouter_arc_t *)i->data;
5484 printf("\t"); print_toporouter_arc(arc); printf("\n");
5485 i = i->next;
5486 }
5487 printf("\t"); print_vertex(oproute->term2); printf("\n");
5488 }
5489
5490 gdouble
5491 export_pcb_drawline(guint layer, guint x0, guint y0, guint x1, guint y1, guint thickness, guint keepaway)
5492 {
5493 gdouble d = 0.;
5494 LineTypePtr line;
5495 line = CreateDrawnLineOnLayer( LAYER_PTR(layer), x0, y0, x1, y1,
5496 thickness, keepaway,
5497 MakeFlags (AUTOFLAG | (TEST_FLAG (CLEARNEWFLAG, PCB) ? CLEARLINEFLAG : 0)));
5498
5499 if(line) {
5500 AddObjectToCreateUndoList (LINE_TYPE, LAYER_PTR(layer), line, line);
5501 d = coord_distance((double)x0, (double)y0, (double)x1, (double)y1) / 100.;
5502 }
5503 return d;
5504 }
5505
5506 gdouble
5507 arc_angle(toporouter_arc_t *arc)
5508 {
5509 gdouble x0, x1, y0, y1;
5510
5511 x0 = arc->x0 - vx(arc->centre);
5512 x1 = arc->x1 - vx(arc->centre);
5513 y0 = arc->y0 - vy(arc->centre);
5514 y1 = arc->y1 - vy(arc->centre);
5515
5516 return fabs(acos(((x0*x1)+(y0*y1))/(sqrt(pow(x0,2)+pow(y0,2))*sqrt(pow(x1,2)+pow(y1,2)))));
5517 }
5518
5519 gdouble
5520 export_pcb_drawarc(guint layer, toporouter_arc_t *a, guint thickness, guint keepaway)
5521 {
5522 gdouble sa, da, theta;
5523 gdouble x0, y0, x1, y1, d=0.;
5524 ArcTypePtr arc;
5525 gint wind;
5526
5527 wind = coord_wind(a->x0, a->y0, a->x1, a->y1, vx(a->centre), vy(a->centre));
5528
5529 sa = coord_xangle(a->x0, a->y0, vx(a->centre), vy(a->centre)) * 180. / M_PI;
5530
5531 x0 = a->x0 - vx(a->centre);
5532 x1 = a->x1 - vx(a->centre);
5533 y0 = a->y0 - vy(a->centre);
5534 y1 = a->y1 - vy(a->centre);
5535
5536 theta = arc_angle(a);
5537
5538 if(!a->dir || !wind) return 0.;
5539
5540 if(a->dir != wind) theta = 2. * M_PI - theta;
5541
5542 da = -a->dir * theta * 180. / M_PI;
5543
5544 if(da < 1. && da > -1.) return 0.;
5545 if(da > 359. || da < -359.) return 0.;
5546
5547 arc = CreateNewArcOnLayer(LAYER_PTR(layer), vx(a->centre), vy(a->centre), a->r, a->r,
5548 sa, da, thickness, keepaway,
5549 MakeFlags( AUTOFLAG | (TEST_FLAG (CLEARNEWFLAG, PCB) ? CLEARLINEFLAG : 0)));
5550
5551 if(arc) {
5552 AddObjectToCreateUndoList( ARC_TYPE, LAYER_PTR(layer), arc, arc);
5553 d = a->r * theta / 100.;
5554 }
5555
5556 return d;
5557 }
5558
5559 void
5560 calculate_term_to_arc(toporouter_vertex_t *v, toporouter_arc_t *arc, guint dir)
5561 {
5562 gdouble theta, a, b, bx, by, a0x, a0y, a1x, a1y;
5563 gint winddir;
5564
5565 theta = acos(arc->r / gts_point_distance(GTS_POINT(v), GTS_POINT(arc->centre)));
5566 a = arc->r * sin(theta);
5567 b = arc->r * cos(theta);
5568 #ifdef DEBUG_EXPORT
5569 printf("drawing arc with r %f theta %f d %f centre = %f,%f\n", arc->r, theta, gts_point_distance(GTS_POINT(v), GTS_POINT(arc->centre)), vx(arc->centre), vy(arc->centre));
5570 #endif
5571 point_from_point_to_point(arc->centre, v, b, &bx, &by);
5572
5573 coords_on_line(bx, by, perpendicular_gradient(point_gradient(GTS_POINT(v), GTS_POINT(arc->centre))), a, &a0x, &a0y, &a1x, &a1y);
5574
5575 winddir = coord_wind(vx(v), vy(v), a0x, a0y, vx(arc->centre), vy(arc->centre));
5576
5577 if(!winddir) {
5578 printf("!winddir @ v %f,%f arc->centre %f,%f\n", vx(v), vy(v), vx(arc->centre), vy(arc->centre));
5579 //TODO: fix hack: this shouldn't happen
5580 arc->x0 = vx(v);
5581 arc->y0 = vy(v);
5582 arc->x1 = vx(v);
5583 arc->y1 = vy(v);
5584 return;
5585 }
5586
5587 g_assert(winddir);
5588
5589 if(dir) winddir = -winddir;
5590
5591 if(winddir == arc->dir) {
5592 if(!dir) { arc->x0 = a0x; arc->y0 = a0y; }
5593 else{ arc->x1 = a0x; arc->y1 = a0y; }
5594 }else{
5595 if(!dir) { arc->x0 = a1x; arc->y0 = a1y; }
5596 else{ arc->x1 = a1x; arc->y1 = a1y; }
5597 }
5598
5599 }
5600
5601
5602
5603 // b1 is the projection in the direction of narc, while b2 is the perpendicular projection
5604 void
5605 arc_ortho_projections(toporouter_arc_t *arc, toporouter_arc_t *narc, gdouble *b1, gdouble *b2)
5606 {
5607 gdouble nax, nay, ax, ay, alen2, c;
5608 gdouble b1x, b1y, b2x, b2y;
5609
5610 #ifdef DEBUG_EXPORT
5611 printf("arc c = %f,%f narc c = %f,%f arc->0 = %f,%f\n",
5612 vx(arc->centre), vy(arc->centre),
5613 vx(narc->centre), vy(narc->centre),
5614 arc->x0, arc->y0);
5615 #endif
5616
5617 nax = vx(narc->centre) - vx(arc->centre);
5618 nay = vy(narc->centre) - vy(arc->centre);
5619 alen2 = pow(nax,2) + pow(nay,2);
5620
5621
5622 ax = arc->x0 - vx(arc->centre);
5623 ay = arc->y0 - vy(arc->centre);
5624
5625 #ifdef DEBUG_EXPORT
5626 printf("norm narc = %f,%f - %f\tA=%f,%f\n", nax, nay, sqrt(alen2), ax, ay);
5627 #endif
5628
5629 c = ((ax*nax)+(ay*nay)) / alen2;
5630
5631 b1x = c * nax;
5632 b1y = c * nay;
5633 b2x = ax - b1x;
5634 b2y = ay - b1y;
5635
5636 #ifdef DEBUG_EXPORT
5637 printf("proj = %f,%f perp proj = %f,%f\n", b1x, b1y, b2x, b2y);
5638 #endif
5639
5640 *b1 = sqrt(pow(b1x,2) + pow(b1y,2));
5641 *b2 = sqrt(pow(b2x,2) + pow(b2y,2));
5642
5643 }
5644
5645 guint
5646 calculate_arc_to_arc(toporouter_t *ar, toporouter_arc_t *parc, toporouter_arc_t *arc)
5647 {
5648 gdouble theta, a, b, bx, by, a0x, a0y, a1x, a1y, m, preva, prevb;
5649 gint winddir;
5650 toporouter_arc_t *bigr, *smallr;
5651
5652 if(parc->r > arc->r) {
5653 bigr = parc; smallr = arc;
5654 }else{
5655 bigr = arc; smallr = parc;
5656 }
5657 #ifdef DEBUG_EXPORT
5658 printf("bigr centre = %f,%f smallr centre = %f,%f\n", vx(bigr->centre), vy(bigr->centre),
5659 vx(smallr->centre), vy(smallr->centre));
5660 #endif
5661
5662 m = perpendicular_gradient(point_gradient(GTS_POINT(bigr->centre), GTS_POINT(smallr->centre)));
5663
5664 if(bigr->centre == smallr->centre) {
5665
5666 printf("bigr->centre == smallr->centre @ %f,%f\n", vx(smallr->centre), vy(smallr->centre));
5667 }
5668
5669 g_assert(bigr->centre != smallr->centre);
5670
5671 if(parc->dir == arc->dir) {
5672 //export_arc_straight:
5673
5674 theta = acos((bigr->r - smallr->r) / gts_point_distance(GTS_POINT(bigr->centre), GTS_POINT(smallr->centre)));
5675 a = bigr->r * sin(theta);
5676 b = bigr->r * cos(theta);
5677
5678 point_from_point_to_point(bigr->centre, smallr->centre, b, &bx, &by);
5679
5680 coords_on_line(bx, by, m, a, &a0x, &a0y, &a1x, &a1y);
5681
5682 winddir = coord_wind(vx(smallr->centre), vy(smallr->centre), a0x, a0y, vx(bigr->centre), vy(bigr->centre));
5683
5684 arc_ortho_projections(parc, arc, &prevb, &preva);
5685 //#ifdef DEBUG_EXPORT
5686 if(!winddir) {
5687
5688 printf("STRAIGHT:\n");
5689 printf("bigr centre = %f,%f smallr centre = %f,%f\n", vx(bigr->centre), vy(bigr->centre),
5690 vx(smallr->centre), vy(smallr->centre));
5691 printf("theta = %f a = %f b = %f bigrr = %f d = %f po = %f\n", theta, a, b, bigr->r,
5692 gts_point_distance(GTS_POINT(bigr->centre), GTS_POINT(smallr->centre)),
5693 bigr->r / gts_point_distance(GTS_POINT(bigr->centre), GTS_POINT(smallr->centre)));
5694 printf("bigr-r = %f smallr-r = %f ratio = %f\n",
5695 bigr->r, smallr->r, (bigr->r - smallr->r) / gts_point_distance(GTS_POINT(bigr->centre), GTS_POINT(smallr->centre)));
5696 printf("preva = %f prevb = %f\n\n", preva, prevb);
5697
5698 }
5699 //#endif
5700 g_assert(winddir);
5701
5702 if(bigr==parc) winddir = -winddir;
5703
5704 if(winddir == bigr->dir) {
5705 if(bigr==arc) {
5706 bigr->x0 = a0x;
5707 bigr->y0 = a0y;
5708 }else{
5709 bigr->x1 = a0x;
5710 bigr->y1 = a0y;
5711 }
5712 }else{
5713 if(bigr==arc) {
5714 bigr->x0 = a1x;
5715 bigr->y0 = a1y;
5716 }else{
5717 bigr->x1 = a1x;
5718 bigr->y1 = a1y;
5719 }
5720 }
5721
5722 a = smallr->r * sin(theta);
5723 b = smallr->r * cos(theta);
5724
5725 #ifdef DEBUG_EXPORT
5726 printf("a = %f b = %f\n", a, b);
5727 #endif
5728 point_from_point_to_point(smallr->centre, bigr->centre, -b, &bx, &by);
5729
5730 coords_on_line(bx, by, m, a, &a0x, &a0y, &a1x, &a1y);
5731
5732 if(winddir == bigr->dir) {
5733 if(bigr==arc) {
5734 smallr->x1 = a0x;
5735 smallr->y1 = a0y;
5736 }else{
5737 smallr->x0 = a0x;
5738 smallr->y0 = a0y;
5739 }
5740 }else{
5741 if(bigr==arc) {
5742 smallr->x1 = a1x;
5743 smallr->y1 = a1y;
5744 }else{
5745 smallr->x0 = a1x;
5746 smallr->y0 = a1y;
5747 }
5748 }
5749
5750 }else{
5751
5752 //export_arc_twist:
5753
5754 theta = acos((bigr->r + smallr->r) / gts_point_distance(GTS_POINT(bigr->centre), GTS_POINT(smallr->centre)));
5755 a = bigr->r * sin(theta);
5756 b = bigr->r * cos(theta);
5757
5758 point_from_point_to_point(bigr->centre, smallr->centre, b, &bx, &by);
5759
5760 coords_on_line(bx, by, m, a, &a0x, &a0y, &a1x, &a1y);
5761
5762 winddir = coord_wind(vx(smallr->centre), vy(smallr->centre), a0x, a0y, vx(bigr->centre), vy(bigr->centre));
5763 //#ifdef DEBUG_EXPORT
5764 if(!winddir) {
5765 printf("TWIST:\n");
5766 printf("theta = %f a = %f b = %f r = %f d = %f po = %f\n", theta, a, b, bigr->r + smallr->r,
5767 gts_point_distance(GTS_POINT(bigr->centre), GTS_POINT(smallr->centre)),
5768 (bigr->r+smallr->r) / gts_point_distance(GTS_POINT(bigr->centre), GTS_POINT(smallr->centre)));
5769
5770 printf("bigr centre = %f,%f smallr centre = %f,%f\n\n", vx(bigr->centre), vy(bigr->centre),
5771 vx(smallr->centre), vy(smallr->centre));
5772
5773 printf("big wind = %d small wind = %d\n", bigr->dir, smallr->dir);
5774 return 1;
5775 }
5776 //#endif
5777 /* if(!winddir) {
5778 smallr->centre->flags |= VERTEX_FLAG_RED;
5779 bigr->centre->flags |= VERTEX_FLAG_GREEN;
5780 //bigr->centre->flags |= VERTEX_FLAG_RED;
5781 {
5782 int i;
5783 for(i=0;i<groupcount();i++) {
5784 char buffer[256];
5785 sprintf(buffer, "wind%d.png", i);
5786 toporouter_draw_surface(ar, ar->layers[i].surface, buffer, 2096, 2096, 2, NULL, i, NULL);
5787 }
5788 }
5789 return;
5790 }
5791 */
5792 g_assert(winddir);
5793
5794 if(bigr==parc) winddir = -winddir;
5795
5796 if(winddir == bigr->dir) {
5797 if(bigr==arc) {
5798 bigr->x0 = a0x;
5799 bigr->y0 = a0y;
5800 }else{
5801 bigr->x1 = a0x;
5802 bigr->y1 = a0y;
5803 }
5804 }else{
5805 if(bigr==arc) {
5806 bigr->x0 = a1x;
5807 bigr->y0 = a1y;
5808 }else{
5809 bigr->x1 = a1x;
5810 bigr->y1 = a1y;
5811 }
5812 }
5813
5814 a = smallr->r * sin(theta);
5815 b = smallr->r * cos(theta);
5816
5817 point_from_point_to_point(smallr->centre, bigr->centre, b, &bx, &by);
5818
5819 coords_on_line(bx, by, m, a, &a0x, &a0y, &a1x, &a1y);
5820
5821 winddir = coord_wind(vx(smallr->centre), vy(smallr->centre), a0x, a0y, vx(bigr->centre), vy(bigr->centre));
5822
5823 g_assert(winddir);
5824
5825 if(bigr==parc) winddir = -winddir;
5826
5827 if(winddir == smallr->dir) {
5828 if(bigr==arc) {
5829 smallr->x1 = a0x;
5830 smallr->y1 = a0y;
5831 }else{
5832 smallr->x0 = a0x;
5833 smallr->y0 = a0y;
5834 }
5835 }else{
5836 if(bigr==arc) {
5837 smallr->x1 = a1x;
5838 smallr->y1 = a1y;
5839 }else{
5840 smallr->x0 = a1x;
5841 smallr->y0 = a1y;
5842 }
5843 }
5844
5845 }
5846
5847 return 0;
5848 }
5849
5850 void
5851 export_oproutes(toporouter_t *ar, toporouter_oproute_t *oproute)
5852 {
5853 guint layer = PCB->LayerGroups.Entries[oproute->layergroup][0];
5854 guint thickness = lookup_thickness(oproute->style);
5855 guint keepaway = lookup_keepaway(oproute->style);
5856 GList *arcs = oproute->arcs;
5857 toporouter_arc_t *arc, *parc = NULL;
5858
5859 if(!arcs) {
5860 ar->wiring_score += export_pcb_drawline(layer, vx(oproute->term1), vy(oproute->term1), vx(oproute->term2), vy(oproute->term2), thickness, keepaway);
5861 return;
5862 }
5863
5864
5865 // calculate_term_to_arc(oproute->term1, TOPOROUTER_ARC(arcs->data), 0, layer);
5866
5867 while(arcs) {
5868 arc = TOPOROUTER_ARC(arcs->data);
5869
5870 if(parc && arc) {
5871 ar->wiring_score += export_pcb_drawarc(layer, parc, thickness, keepaway);
5872 ar->wiring_score += export_pcb_drawline(layer, parc->x1, parc->y1, arc->x0, arc->y0, thickness, keepaway);
5873 }else if(!parc) {
5874 ar->wiring_score += export_pcb_drawline(layer, vx(oproute->term1), vy(oproute->term1), arc->x0, arc->y0, thickness, keepaway);
5875 }
5876
5877 parc = arc;
5878 arcs = arcs->next;
5879 }
5880 ar->wiring_score += export_pcb_drawarc(layer, arc, thickness, keepaway);
5881 ar->wiring_score += export_pcb_drawline(layer, arc->x1, arc->y1, vx(oproute->term2), vy(oproute->term2), thickness, keepaway);
5882
5883 }
5884
5885
5886
5887 void
5888 oproute_free(toporouter_oproute_t *oproute)
5889 {
5890 GList *i = oproute->arcs;
5891 while(i) {
5892 toporouter_arc_t *arc = (toporouter_arc_t *) i->data;
5893 if(arc->centre->flags & VERTEX_FLAG_TEMP)
5894 gts_object_destroy(GTS_OBJECT(arc->centre));
5895
5896 i = i->next;
5897 }
5898
5899 g_list_free(oproute->arcs);
5900 free(oproute);
5901 }
5902
5903 void
5904 oproute_calculate_tof(toporouter_oproute_t *oproute)
5905 {
5906 GList *arcs = oproute->arcs;
5907 toporouter_arc_t *parc = NULL, *arc;
5908
5909 oproute->tof = 0.;
5910
5911 if(!arcs) {
5912 oproute->tof = gts_point_distance(GTS_POINT(oproute->term1), GTS_POINT(oproute->term2));
5913 return;
5914 }
5915
5916 while(arcs) {
5917 arc = TOPOROUTER_ARC(arcs->data);
5918
5919 if(parc && arc) {
5920 oproute->tof += arc_angle(parc) * parc->r;
5921 oproute->tof += sqrt(pow(parc->x1-arc->x0,2)+pow(parc->y1-arc->y0,2));
5922 }else if(!parc) {
5923 oproute->tof += sqrt(pow(arc->x0-vx(oproute->term1),2)+pow(arc->y0-vy(oproute->term1),2));
5924 }
5925
5926 parc = arc;
5927 arcs = arcs->next;
5928 }
5929
5930 oproute->tof += arc_angle(parc) * parc->r;
5931 oproute->tof += sqrt(pow(arc->x1-vx(oproute->term2),2)+pow(arc->y1-vy(oproute->term2),2));
5932
5933 }
5934
5935 gdouble
5936 line_line_distance_at_normal(
5937 gdouble line1_x1, gdouble line1_y1,
5938 gdouble line1_x2, gdouble line1_y2,
5939 gdouble line2_x1, gdouble line2_y1,
5940 gdouble line2_x2, gdouble line2_y2,
5941 gdouble x, gdouble y)
5942 {
5943 gdouble m1 = perpendicular_gradient(cartesian_gradient(line1_x1, line1_y1, line1_x2, line1_y2));
5944 gdouble m2 = cartesian_gradient(line2_x1, line2_y1, line2_x2, line2_y2);
5945 gdouble c1 = (isinf(m1)) ? x : y - (m1 * x);
5946 gdouble c2 = (isinf(m2)) ? line2_x1 : line2_y1 - (m2 * line2_x1);
5947
5948 gdouble intx, inty;
5949
5950 if(isinf(m2)) intx = line2_x1;
5951 else if(isinf(m1)) intx = x;
5952 else intx = (c2 - c1) / (m1 - m2);
5953
5954 inty = (isinf(m2)) ? (m1 * intx) + c1 : (m2 * intx) + c2;
5955
5956 return sqrt(pow(x-intx,2)+pow(y-inty,2));
5957 }
5958
5959 void
5960 calculate_serpintine(gdouble delta, gdouble r, gdouble initiala, gdouble *a, guint *nhalfcycles)
5961 {
5962 gdouble lhalfcycle = 2.*(initiala-r)+(M_PI*r);
5963 guint n;
5964
5965 printf("lhalfcycle = %f r = %f\n", lhalfcycle, r);
5966
5967 n = (delta - M_PI*r) / (lhalfcycle - 2.*r) + 1;
5968 *a = (delta + 4.*n*r - n*M_PI*r + 4.*r - M_PI*r)/(2.*n);
5969 *nhalfcycles = n;
5970 }
5971
5972 gdouble
5973 oproute_min_spacing(toporouter_oproute_t *a, toporouter_oproute_t *b)
5974 {
5975 return lookup_thickness(a->style) / 2. + lookup_thickness(b->style) / 2. + MAX(lookup_keepaway(a->style), lookup_keepaway(b->style));
5976 }
5977
5978 gdouble
5979 vector_angle(gdouble ox, gdouble oy, gdouble ax, gdouble ay, gdouble bx, gdouble by)
5980 {
5981 gdouble alen = sqrt(pow(ax-ox,2)+pow(ay-oy,2));
5982 gdouble blen = sqrt(pow(bx-ox,2)+pow(by-oy,2));
5983 return acos( ((ax-ox)*(bx-ox)+(ay-oy)*(by-oy)) / (alen * blen) );
5984 }
5985
5986 toporouter_serpintine_t *
5987 toporouter_serpintine_new(gdouble x, gdouble y, gdouble x0, gdouble y0, gdouble x1, gdouble y1, gpointer start, gdouble halfa, gdouble
5988 radius, guint nhalfcycles)
5989 {
5990 toporouter_serpintine_t *serp = malloc(sizeof(toporouter_serpintine_t));
5991 serp->x = x;
5992 serp->y = y;
5993 serp->x0 = x0;
5994 serp->y0 = y0;
5995 serp->x1 = x1;
5996 serp->y1 = y1;
5997 serp->start = start;
5998 serp->halfa = halfa;
5999 serp->radius = radius;
6000 serp->nhalfcycles = nhalfcycles;
6001 serp->arcs = NULL;
6002 return serp;
6003 }
6004
6005 //#define DEBUG_RUBBERBAND 1
6006
6007 gdouble
6008 check_non_intersect_vertex(gdouble x0, gdouble y0, gdouble x1, gdouble y1, toporouter_vertex_t *pathv, toporouter_vertex_t *arcv,
6009 toporouter_vertex_t *opv, gint wind, gint *arcwind, gdouble *arcr, guint debug)
6010 {
6011 gdouble ms, line_int_x, line_int_y, x, y, d = 0., m;
6012 gdouble tx0, ty0, tx1, ty1;
6013 gint wind1, wind2;
6014
6015 g_assert(pathv->routingedge);
6016
6017 if(TOPOROUTER_IS_CONSTRAINT(pathv->routingedge)) {
6018 gdouble d = tvdistance(tedge_v1(pathv->routingedge), tedge_v2(pathv->routingedge)) / 2.;
6019 ms = min_spacing(pathv, arcv);
6020 if(ms > d) ms = d;
6021 }else{
6022 ms = edge_min_spacing(g_list_find(edge_routing(pathv->routingedge), pathv), pathv->routingedge, arcv, debug);
6023 }
6024
6025
6026 if(!vertex_line_normal_intersection(x0, y0, x1, y1, vx(arcv), vy(arcv), &line_int_x, &line_int_y)) {
6027
6028 if(coord_distance2(x0, y0, line_int_x, line_int_y) < coord_distance2(x1, y1, line_int_x, line_int_y))
6029 { line_int_x = x0; line_int_y = y0; }else{ line_int_x = x1; line_int_y = y1; }
6030
6031 m = perpendicular_gradient(cartesian_gradient(vx(arcv), vy(arcv), line_int_x, line_int_y));
6032 }else{
6033 m = cartesian_gradient(x0, y0, x1, y1);
6034 }
6035
6036 coords_on_line(vx(arcv), vy(arcv), m, 100., &tx0, &ty0, &tx1, &ty1);
6037
6038 wind1 = coord_wind(tx0, ty0, tx1, ty1, line_int_x, line_int_y);
6039 wind2 = coord_wind(tx0, ty0, tx1, ty1, vx(opv), vy(opv));
6040
6041 if(!wind2 || wind1 == wind2) return -1.;
6042
6043 if(!wind) {
6044 coords_on_line(line_int_x, line_int_y, perpendicular_gradient(m), ms, &tx0, &ty0, &tx1, &ty1);
6045 if(coord_distance2(tx0, ty0, vx(opv), vy(opv)) < coord_distance2(tx1, ty1, vx(opv), vy(opv)))
6046 { x = tx0; y = ty0; }else{ x = tx1; y = ty1; }
6047 }else{
6048 toporouter_vertex_t *parent = pathv->parent, *child = pathv->child;
6049 guint windtests = 0;
6050
6051 d = coord_distance(vx(arcv), vy(arcv), line_int_x, line_int_y);
6052 coord_move_towards_coord_values(line_int_x, line_int_y, vx(arcv), vy(arcv), ms + d, &x, &y);
6053 rewind_test:
6054 wind1 = coord_wind(line_int_x, line_int_y, x, y, vx(parent), vy(parent));
6055 wind2 = coord_wind(line_int_x, line_int_y, x, y, vx(child), vy(child));
6056 if(wind1 && wind2 && wind1 == wind2) {
6057 // return -1.;
6058 if(windtests++ == 2) return -1.;
6059
6060 if(parent->flags & VERTEX_FLAG_ROUTE) parent = parent->parent;
6061 if(child->flags & VERTEX_FLAG_ROUTE) child = child->child;
6062 goto rewind_test;
6063 }
6064 }
6065
6066
6067 *arcr = ms;
6068 *arcwind = tvertex_wind(pathv->parent, pathv, arcv);
6069
6070 #ifdef DEBUG_RUBBERBAND
6071 //if(debug)
6072 // printf("non-int check %f,%f ms %f d %f arcv %f,%f opv %f,%f\n", vx(arcv), vy(arcv), ms, d + ms,
6073 // vx(arcv), vy(arcv), vx(opv), vy(opv));
6074 #endif
6075
6076 return d + ms;
6077 }
6078
6079 gdouble
6080 check_intersect_vertex(gdouble x0, gdouble y0, gdouble x1, gdouble y1, toporouter_vertex_t *pathv, toporouter_vertex_t *arcv,
6081 toporouter_vertex_t *opv, gint wind, gint *arcwind, gdouble *arcr, guint debug)
6082 {
6083 gdouble ms, line_int_x, line_int_y, x, y, d = 0.;
6084
6085 if(TOPOROUTER_IS_CONSTRAINT(pathv->routingedge)) {
6086 gdouble d = tvdistance(tedge_v1(pathv->routingedge), tedge_v2(pathv->routingedge)) / 2.;
6087 ms = min_spacing(pathv, arcv);
6088 if(ms > d) ms = d;
6089 }else {
6090 ms = edge_min_spacing(g_list_find(edge_routing(pathv->routingedge), pathv), pathv->routingedge, arcv, debug);
6091 }
6092
6093 if(!vertex_line_normal_intersection(x0, y0, x1, y1, vx(arcv), vy(arcv), &line_int_x, &line_int_y))
6094 return -1.;
6095
6096 d = coord_distance(line_int_x, line_int_y, vx(arcv), vy(arcv));
6097
6098
6099 if(d > ms - EPSILON)
6100 return -1.;
6101
6102 coord_move_towards_coord_values(vx(arcv), vy(arcv), line_int_x, line_int_y, ms, &x, &y);
6103
6104 *arcr = ms;
6105 *arcwind = tvertex_wind(pathv->parent, pathv, arcv);
6106 // *arcwind = coord_wind(x0, y0, x, y, x1, y1);
6107 #ifdef DEBUG_RUBBERBAND
6108 //if(debug)
6109 // printf("int check %f,%f ms %f d %f arcv %f,%f opv %f,%f\n", vx(arcv), vy(arcv), ms, ms - d,
6110 // vx(arcv), vy(arcv), vx(opv), vy(opv));
6111 #endif
6112
6113 return ms - d;
6114 }
6115
6116 /* returns non-zero if arc has loops */
6117 guint
6118 check_arc_for_loops(gpointer t1, toporouter_arc_t *arc, gpointer t2)
6119 {
6120 gdouble x0, y0, x1, y1;
6121
6122 if(TOPOROUTER_IS_VERTEX(t1)) { x0 = vx(TOPOROUTER_VERTEX(t1)); y0 = vy(TOPOROUTER_VERTEX(t1)); }
6123 else { x0 = TOPOROUTER_ARC(t1)->x1; y0 = TOPOROUTER_ARC(t1)->y1; }
6124
6125 if(TOPOROUTER_IS_VERTEX(t2)) { x1 = vx(TOPOROUTER_VERTEX(t2)); y1 = vy(TOPOROUTER_VERTEX(t2)); }
6126 else { x1 = TOPOROUTER_ARC(t2)->x0; y1 = TOPOROUTER_ARC(t2)->y0; }
6127
6128 if(coord_intersect_prop(x0, y0, arc->x0, arc->y0, arc->x1, arc->y1, x1, y1) ) {
6129 // ||
6130 // (arc->x0 > arc->x1 - EPSILON && arc->x0 < arc->x1 + EPSILON &&
6131 // arc->y0 > arc->y1 - EPSILON && arc->y0 < arc->y1 + EPSILON)
6132 // ) {
6133 #ifdef DEBUG_RUBBERBAND
6134 printf("LOOPS %f %f -> %f %f & %f %f -> %f %f\n", x0, y0, arc->x0, arc->y0, arc->x1, arc->y1, x1, y1);
6135 #endif
6136 return 1;
6137 }
6138 return 0;
6139 }
6140
6141 toporouter_rubberband_arc_t *
6142 new_rubberband_arc(toporouter_vertex_t *pathv, toporouter_vertex_t *arcv, gdouble r, gdouble d, gint wind, GList *list)
6143 {
6144 toporouter_rubberband_arc_t *rba = malloc(sizeof(toporouter_rubberband_arc_t));
6145 rba->pathv = pathv;
6146 rba->arcv = arcv;
6147 rba->r = r;
6148 rba->d = d;
6149 rba->wind = wind;
6150 rba->list = list;
6151 return rba;
6152 }
6153
6154 gint
6155 compare_rubberband_arcs(toporouter_rubberband_arc_t *a, toporouter_rubberband_arc_t *b)
6156 { return b->d - a->d; }
6157
6158 void
6159 free_list_elements(gpointer data, gpointer user_data)
6160 { free(data); }
6161
6162
6163 /* returns the edge opposite v from the triangle facing (x,y), or NULL if v is colinear with an edge between v and a neighbor */
6164 /*
6165 GtsEdge *
6166 vertex_edge_facing_vertex(GtsVertex *v, gdouble x, gdouble y)
6167 {
6168 GSList *ts = gts_vertex_triangles(GTS_VERTEX(n), NULL);
6169 GSList *i = ts;
6170
6171 while(i) {
6172 GtsTriangle *t = GTS_TRIANGLE(i->data);
6173 GtsEdge *e = gts_triangle_edge_opposite(t, v);
6174
6175 if(coord_wind(vx(edge_v1(e)), vy(edge_v1(e)), vx(v), vy(v), x, y) == vertex_wind(edge_v1(e), v, edge_v2(e)) &&
6176 coord_wind(vx(edge_v2(e)), vy(edge_v2(e)), vx(v), vy(v), x, y) == vertex_wind(edge_v2(e), v, edge_v1(e))
6177 ) {
6178 g_slist_free(ts);
6179 return e;
6180 }
6181
6182 i = i->next;
6183 }
6184
6185 g_slist_free(ts);
6186 return NULL;
6187 }
6188 */
6189
6190 gdouble
6191 check_adj_pushing_vertex(toporouter_oproute_t *oproute, gdouble x0, gdouble y0, gdouble x1, gdouble y1, toporouter_vertex_t *v, gdouble *arcr, gint *arcwind, toporouter_vertex_t **arc)
6192 {
6193 GSList *ns = gts_vertex_neighbors(GTS_VERTEX(v), NULL, NULL);
6194 GSList *i = ns;
6195 gdouble maxd = 0.;
6196
6197 while(i) {
6198 toporouter_vertex_t *n = TOPOROUTER_VERTEX(i->data);
6199 gdouble segintx, seginty;
6200 if(vertex_line_normal_intersection(x0, y0, x1, y1, vx(n), vy(n), &segintx, &seginty)) {
6201 toporouter_edge_t *e = tedge(n, v);
6202 gdouble ms = 0., d = coord_distance(segintx, seginty, vx(n), vy(n));
6203 toporouter_vertex_t *a, *b;
6204 GList *closestnet = NULL;
6205
6206 g_assert(e);
6207
6208 if(v == tedge_v1(e)) {
6209 a = tedge_v1(e);
6210 b = tedge_v2(e);
6211 closestnet = edge_routing(e);
6212 }else{
6213 a = tedge_v2(e);
6214 b = tedge_v1(e);
6215 closestnet = g_list_last(edge_routing(e));
6216 }
6217
6218 if(closestnet) {
6219 ms = edge_min_spacing(closestnet, e, b, 0);
6220 ms += min_oproute_net_spacing(oproute, TOPOROUTER_VERTEX(closestnet->data));
6221 }else{
6222 ms = min_oproute_vertex_spacing(oproute, b);
6223 }
6224
6225 if(ms - d > maxd) {
6226 *arcr = ms;
6227 *arc = n;
6228 maxd = ms - d;
6229 if(vx(v) == x0 && vy(v) == y0) {
6230 *arcwind = coord_wind(x0, y0, vx(n), vy(n), x1, y1);
6231 }else if(vx(v) == x1 && vy(v) == y1) {
6232 *arcwind = coord_wind(x1, y1, vx(n), vy(n), x0, y0);
6233 }else{
6234 fprintf(stderr, "ERROR: check_adj_pushing_vertex encountered bad vertex v (coordinates don't match)\n");
6235 }
6236 }
6237 }
6238
6239 i = i->next;
6240 }
6241
6242 g_slist_free(ns);
6243 return maxd;
6244 }
6245
6246
6247 // path is t1 path
6248 GList *
6249 oproute_rubberband_segment(toporouter_t *r, toporouter_oproute_t *oproute, GList *path, gpointer t1, gpointer t2, guint debug)
6250 {
6251 gdouble x0, y0, x1, y1;
6252 toporouter_vertex_t *v1, *v2, *av1, *av2; /* v{1,2} are the vertex terminals of the segment, or arc terminal centres */
6253 toporouter_arc_t *arc1 = NULL, *arc2 = NULL, *newarc = NULL; /* arc{1,2} are the arc terminals of the segment, if they exist */
6254 GList *i = path;
6255 GList *list1, *list2;
6256
6257 GList *arcs = NULL;
6258 toporouter_rubberband_arc_t *max = NULL;
6259
6260 gdouble d, arcr;
6261 gint v1wind, v2wind, arcwind;
6262
6263 if(TOPOROUTER_IS_VERTEX(t1)) {
6264 v1 = TOPOROUTER_VERTEX(t1);
6265 x0 = vx(v1); y0 = vy(v1);
6266 }else{
6267 g_assert(TOPOROUTER_IS_ARC(t1));
6268 arc1 = TOPOROUTER_ARC(t1);
6269 v1 = TOPOROUTER_VERTEX(arc1->v1);
6270 x0 = arc1->x1;
6271 y0 = arc1->y1;
6272 }
6273
6274 if(TOPOROUTER_IS_VERTEX(t2)) {
6275 v2 = TOPOROUTER_VERTEX(t2);
6276 x1 = vx(v2); y1 = vy(v2);
6277 }else{
6278 g_assert(TOPOROUTER_IS_ARC(t2));
6279 arc2 = TOPOROUTER_ARC(t2);
6280 v2 = TOPOROUTER_VERTEX(arc2->v2);
6281 x1 = arc2->x0;
6282 y1 = arc2->y0;
6283 }
6284
6285 #define TEST_AND_INSERT(z) if(d > EPSILON) arcs = g_list_prepend(arcs, new_rubberband_arc(v, z, arcr, d, arcwind, i));
6286 #define ARC_CHECKS(z) (!(arc1 && arc1->centre == z) && !(arc2 && arc2->centre == z) && \
6287 !(TOPOROUTER_IS_VERTEX(t1) && z == v1) && !(TOPOROUTER_IS_VERTEX(t2) && z == v2))
6288
6289 if(v1 == v2 || !i->next || TOPOROUTER_VERTEX(i->data) == v2) return NULL;
6290
6291 //#ifdef DEBUG_RUBBERBAND
6292 if(debug) {
6293 printf("\nRB: line %f,%f %f,%f v1 = %f,%f v2 = %f,%f \n ", x0, y0, x1, y1, vx(v1), vy(v1), vx(v2), vy(v2));
6294 // if(v1->routingedge) print_edge(v1->routingedge);
6295 // if(v2->routingedge) print_edge(v2->routingedge);
6296
6297 }
6298 //#endif
6299
6300 /* check the vectices adjacent to the terminal vectices for push against the segment */
6301 //if(TOPOROUTER_IS_VERTEX(t1)) {
6302 // toporouter_vertex_t *arcc = NULL;
6303 // d = check_adj_pushing_vertex(oproute, x0, y0, x1, y1, v1, &arcr, &arcwind, &arcc);
6304 // g_assert(arcc != v1);
6305 // if(ARC_CHECKS(arcc) && d > EPSILON) arcs = g_list_prepend(arcs, new_rubberband_arc(v1, arcc, arcr, d, arcwind, path->next));
6306 //}
6307 //
6308 //if(TOPOROUTER_IS_VERTEX(t2)) {
6309 // toporouter_vertex_t *arcc = NULL;
6310 // d = check_adj_pushing_vertex(oproute, x0, y0, x1, y1, v2, &arcr, &arcwind, &arcc);
6311 // g_assert(arcc != v2);
6312 // if(ARC_CHECKS(arcc) && d > EPSILON) arcs = g_list_prepend(arcs, new_rubberband_arc(v2, arcc, arcr, d, arcwind, g_list_last(path)->prev));
6313 //}
6314
6315 i = i->next;
6316 while(i) {
6317 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
6318
6319 if(v == v2 || v == v1 || !v->routingedge) break;
6320
6321 #ifdef DEBUG_RUBBERBAND
6322 // if(debug)
6323 // printf("current v %f,%f - edge %f,%f %f,%f\n", vx(v), vy(v),
6324 // vx(tedge_v1(v->routingedge)), vy(tedge_v1(v->routingedge)),
6325 // vx(tedge_v2(v->routingedge)), vy(tedge_v2(v->routingedge))
6326 // );
6327 #endif
6328 g_assert(v->routingedge);
6329
6330 v1wind = coord_wind(x0, y0, x1, y1, vx(tedge_v1(v->routingedge)), vy(tedge_v1(v->routingedge)));
6331 v2wind = coord_wind(x0, y0, x1, y1, vx(tedge_v2(v->routingedge)), vy(tedge_v2(v->routingedge)));
6332 // if(debug) printf("\twinds: %d %d\n", v1wind, v2wind);
6333 if(!v1wind && !v2wind) { i = i->next; continue; }
6334
6335
6336 if(v1wind && v2wind && v1wind != v2wind) { /* edge is cutting through the current segment */
6337
6338 if(ARC_CHECKS(tedge_v1(v->routingedge)) ){ /* edge v1 is not the centre of an arc terminal */
6339 d = check_intersect_vertex(x0, y0, x1, y1, v, tedge_v1(v->routingedge), tedge_v2(v->routingedge), v1wind, &arcwind, &arcr, debug);
6340 TEST_AND_INSERT(tedge_v1(v->routingedge));
6341 }
6342
6343 if(ARC_CHECKS(tedge_v2(v->routingedge)) ){ /* edge v2 is not the centre of an arc terminal */
6344 d = check_intersect_vertex(x0, y0, x1, y1, v, tedge_v2(v->routingedge), tedge_v1(v->routingedge), v2wind, &arcwind, &arcr, debug);
6345 TEST_AND_INSERT(tedge_v2(v->routingedge));
6346 }
6347 }else{ /* edge is on one side of the segment */
6348
6349 if(ARC_CHECKS(tedge_v1(v->routingedge)) ){ /* edge v1 is not the centre of an arc terminal */
6350 d = check_non_intersect_vertex(x0, y0, x1, y1, v, tedge_v1(v->routingedge), tedge_v2(v->routingedge), v1wind, &arcwind, &arcr, debug);
6351 TEST_AND_INSERT(tedge_v1(v->routingedge));
6352 }
6353
6354 if(ARC_CHECKS(tedge_v2(v->routingedge)) ){ /* edge v2 is not the centre of an arc terminal */
6355 d = check_non_intersect_vertex(x0, y0, x1, y1, v, tedge_v2(v->routingedge), tedge_v1(v->routingedge), v2wind, &arcwind, &arcr, debug);
6356 TEST_AND_INSERT(tedge_v2(v->routingedge));
6357 }
6358 }
6359
6360 i = i->next;
6361 }
6362
6363 arcs = g_list_sort(arcs, (GCompareFunc) compare_rubberband_arcs);
6364 //rubberband_insert_maxarc:
6365 if(!arcs) return NULL;
6366 max = TOPOROUTER_RUBBERBAND_ARC(arcs->data);
6367
6368 av2 = max->pathv; i = max->list->next;
6369 while(i) {
6370 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
6371 if(v->routingedge && (tedge_v1(v->routingedge) == max->arcv || tedge_v2(v->routingedge) == max->arcv)) {
6372 av2 = v; i = i->next; continue;
6373 }
6374 break;
6375 }
6376
6377 av1 = max->pathv; i = max->list->prev;
6378 while(i) {
6379 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
6380 if(v->routingedge && (tedge_v1(v->routingedge) == max->arcv || tedge_v2(v->routingedge) == max->arcv)) {
6381 av1 = v; i = i->prev; continue;
6382 }
6383 break;
6384 }
6385 //#ifdef DEBUG_RUBBERBAND
6386 if(debug)
6387 printf("newarc @ %f,%f \t v1 = %f,%f v2 = %f,%f r = %f\n", vx(max->arcv), vy(max->arcv), vx(av1), vy(av1), vx(av2), vy(av2), max->r);
6388 //#endif
6389 newarc = toporouter_arc_new(oproute, av1, av2, max->arcv, max->r, max->wind);
6390
6391 if(TOPOROUTER_IS_VERTEX(t1))
6392 calculate_term_to_arc(TOPOROUTER_VERTEX(t1), newarc, 0);
6393 else if(calculate_arc_to_arc(r, TOPOROUTER_ARC(t1), newarc)) {
6394 printf("\tERROR: best: r = %f d = %f\n", max->r, max->d);
6395 printf("\tOPROUTE: %s\n", oproute->netlist);
6396 print_vertex(oproute->term1);
6397 print_vertex(oproute->term2);
6398 return NULL;
6399 }
6400
6401 if(TOPOROUTER_IS_VERTEX(t2))
6402 calculate_term_to_arc(TOPOROUTER_VERTEX(t2), newarc, 1);
6403 else if(calculate_arc_to_arc(r, newarc, TOPOROUTER_ARC(t2))) {
6404 printf("\tERROR: best: r = %f d = %f\n", max->r, max->d);
6405 printf("\tOPROUTE: %s\n", oproute->netlist);
6406 print_vertex(oproute->term1);
6407 print_vertex(oproute->term2);
6408 return NULL;
6409 }
6410
6411 //if(check_arc_for_loops(t1, newarc, t2)) {
6412 // if(arc1 && arc2) calculate_arc_to_arc(r, arc1, arc2);
6413 // else if(arc1) calculate_term_to_arc(TOPOROUTER_VERTEX(t2), arc1, 1);
6414 // else if(arc2) calculate_term_to_arc(TOPOROUTER_VERTEX(t1), arc2, 0);
6415
6416 //#ifdef DEBUG_RUBBERBAND
6417 // printf("REMOVING NEW ARC @ %f,%f\n", vx(newarc->centre), vy(newarc->centre));
6418 // //TODO: properly remove newarc
6419 //#endif
6420
6421 // arcs = g_list_remove(arcs, max);
6422 // free(max);
6423 // goto rubberband_insert_maxarc;
6424 //}
6425
6426
6427 list1 = oproute_rubberband_segment(r, oproute, path, t1, newarc, debug);
6428 list2 = oproute_rubberband_segment(r, oproute, i->next, newarc, t2, debug);
6429
6430 if(list1) {
6431 GList *list = g_list_last(list1);
6432 toporouter_arc_t *testarc = TOPOROUTER_ARC(list->data);
6433 toporouter_arc_t *parc = list->prev ? TOPOROUTER_ARC(list->prev->data) : arc1;
6434 gdouble px = parc ? parc->x1 : vx(TOPOROUTER_VERTEX(t1)), py = parc ? parc->y1 : vy(TOPOROUTER_VERTEX(t1));
6435
6436 if(coord_intersect_prop(px, py, testarc->x0, testarc->y0, testarc->x1, testarc->y1, newarc->x0, newarc->y0)) {
6437 list1 = g_list_remove(list1, testarc);
6438 if(parc) calculate_arc_to_arc(r, parc, newarc);
6439 else calculate_term_to_arc(TOPOROUTER_VERTEX(t1), newarc, 0);
6440 //#ifdef DEBUG_RUBBERBAND
6441 if(debug)
6442 printf("REMOVING ARC @ %f,%f\n", vx(testarc->centre), vy(testarc->centre));
6443 //#endif
6444 }
6445 }
6446 if(list2) {
6447 toporouter_arc_t *testarc = TOPOROUTER_ARC(list2->data);
6448 toporouter_arc_t *narc = list2->next ? TOPOROUTER_ARC(list2->next->data) : arc2;
6449 gdouble nx = narc ? narc->x0 : vx(TOPOROUTER_VERTEX(t2)), ny = narc ? narc->y0 : vy(TOPOROUTER_VERTEX(t2));
6450
6451 if(coord_intersect_prop(newarc->x1, newarc->y1, testarc->x0, testarc->y0, testarc->x1, testarc->y1, nx, ny)) {
6452 list2 = g_list_remove(list2, testarc);
6453 if(narc) calculate_arc_to_arc(r, newarc, narc);
6454 else calculate_term_to_arc(TOPOROUTER_VERTEX(t2), newarc, 1);
6455
6456 //#ifdef DEBUG_RUBBERBAND
6457 if(debug)
6458 printf("REMOVING ARC @ %f,%f\n", vx(testarc->centre), vy(testarc->centre));
6459 //#endif
6460 }
6461 }
6462
6463 g_list_foreach(arcs, free_list_elements, NULL);
6464 g_list_free(arcs);
6465
6466 return g_list_concat(list1, g_list_prepend(list2, newarc));
6467 }
6468
6469 void
6470 oproute_check_all_loops(toporouter_t *r, toporouter_oproute_t *oproute)
6471 {
6472 GList *i;
6473 gpointer t1;
6474
6475 loopcheck_restart:
6476 t1 = oproute->term1;
6477 i = oproute->arcs;
6478 while(i) {
6479 toporouter_arc_t *arc = TOPOROUTER_ARC(i->data);
6480 gpointer t2 = i->next ? i->next->data : oproute->term2;
6481
6482 if(check_arc_for_loops(t1, arc, t2)) {
6483
6484 if(TOPOROUTER_IS_ARC(t1) && TOPOROUTER_IS_ARC(t2))
6485 calculate_arc_to_arc(r, TOPOROUTER_ARC(t1), TOPOROUTER_ARC(t2));
6486 else if(TOPOROUTER_IS_ARC(t1))
6487 calculate_term_to_arc(TOPOROUTER_VERTEX(t2), TOPOROUTER_ARC(t1), 1);
6488 else if(TOPOROUTER_IS_ARC(t2))
6489 calculate_term_to_arc(TOPOROUTER_VERTEX(t1), TOPOROUTER_ARC(t2), 0);
6490
6491 oproute->arcs = g_list_remove(oproute->arcs, arc);
6492 goto loopcheck_restart;
6493 }
6494
6495 t1 = arc;
6496
6497 i = i->next;
6498 }
6499
6500 }
6501
6502 GtsTriangle *
6503 opposite_triangle(GtsTriangle *t, toporouter_edge_t *e)
6504 {
6505 GSList *i = GTS_EDGE(e)->triangles;
6506
6507 g_assert(e && t);
6508
6509 while(i) {
6510 if(GTS_TRIANGLE(i->data) != t) return GTS_TRIANGLE(i->data);
6511 i = i->next;
6512 }
6513
6514 return NULL;
6515 }
6516
6517
6518 void
6519 speccut_edge_routing_from_edge(GList *i, toporouter_edge_t *e)
6520 {
6521 g_assert(TOPOROUTER_IS_EDGE(e));
6522 while(i) {
6523 toporouter_vertex_t *curv = TOPOROUTER_VERTEX(i->data);
6524
6525 if(!(curv->flags & VERTEX_FLAG_TEMP)) {
6526 toporouter_vertex_t *newv = tvertex_intersect(curv, curv->parent, tedge_v1(e), tedge_v2(e));
6527
6528 // printf("\nCURV:\n");
6529 // print_vertex(curv);
6530 //
6531 // printf("CURV child:\n");
6532 // if(curv->child)
6533 // print_vertex(curv->child);
6534 // else
6535 // printf("NULL\n");
6536 //
6537 // printf("CURV parent:\n");
6538 // if(curv->parent)
6539 // print_vertex(curv->parent);
6540 // else
6541 // printf("NULL\n");
6542
6543 if(newv) {
6544 gint index;
6545 newv->flags |= VERTEX_FLAG_ROUTE;
6546 newv->flags |= VERTEX_FLAG_SPECCUT;
6547 e->routing = g_list_insert_sorted_with_data(e->routing, newv, routing_edge_insert, e);
6548 newv->route = curv->route;
6549 newv->oproute = curv->oproute;
6550 newv->routingedge = e;
6551 GTS_POINT(newv)->z = vz(curv);
6552
6553 newv->parent = curv->parent;
6554 newv->child = curv;
6555
6556 // curv->parent = newv;
6557
6558 index = g_list_index(newv->route->path, curv);
6559
6560 newv->route->path = g_list_insert(newv->route->path, newv, index);
6561
6562
6563 if(newv->oproute) newv->oproute->path = newv->route->path;
6564 }
6565
6566 if(!(curv->child->routingedge)) {
6567 newv = tvertex_intersect(curv, curv->child, tedge_v1(e), tedge_v2(e));
6568
6569 if(newv) {
6570 gint index;
6571 newv->flags |= VERTEX_FLAG_ROUTE;
6572 newv->flags |= VERTEX_FLAG_SPECCUT;
6573 e->routing = g_list_insert_sorted_with_data(e->routing, newv, routing_edge_insert, e);
6574 newv->route = curv->route;
6575 newv->oproute = curv->oproute;
6576 newv->routingedge = e;
6577 GTS_POINT(newv)->z = vz(curv);
6578
6579 newv->parent = curv;
6580 newv->child = curv->child;
6581
6582 // curv->child = newv;
6583
6584 index = g_list_index(newv->route->path, curv);
6585
6586 newv->route->path = g_list_insert(newv->route->path, newv, index+1);
6587
6588
6589 if(newv->oproute) newv->oproute->path = newv->route->path;
6590 }
6591
6592 }
6593
6594 }
6595 i = i->next;
6596 }
6597
6598 }
6599
6600 void
6601 speccut_edge_patch_links(toporouter_edge_t *e)
6602 {
6603 GList *i = e->routing;
6604 g_assert(TOPOROUTER_IS_EDGE(e));
6605 while(i) {
6606 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
6607 v->parent->child = v;
6608 v->child->parent = v;
6609 i = i->next;
6610 }
6611 }
6612
6613 gint
6614 check_speccut(toporouter_oproute_t *oproute, toporouter_vertex_t *v1, toporouter_vertex_t *v2, toporouter_edge_t *e, toporouter_edge_t *e1, toporouter_edge_t *e2)
6615 {
6616 GtsTriangle *t, *opt;
6617 toporouter_vertex_t *opv, *opv2;
6618 toporouter_edge_t *ope1, *ope2;
6619 gdouble cap, flow, line_int_x, line_int_y;
6620
6621 if(TOPOROUTER_IS_CONSTRAINT(e)) return 0;
6622
6623 if(!(t = gts_triangle_use_edges(GTS_EDGE(e), GTS_EDGE(e1), GTS_EDGE(e2)))) {
6624 printf("check_speccut: NULL t\n");
6625 return 0;
6626 }
6627
6628 if(!(opt = opposite_triangle(t, e))) {
6629 // printf("check_speccut: NULL opt\n");
6630 return 0;
6631 }
6632
6633 if(!(opv = segment_common_vertex(GTS_SEGMENT(e1), GTS_SEGMENT(e2)))) {
6634 printf("check_speccut: NULL opv\n");
6635 return 0;
6636 }
6637
6638 if(!(opv2 = TOPOROUTER_VERTEX(gts_triangle_vertex_opposite(opt, GTS_EDGE(e))))) {
6639 printf("check_speccut: NULL opv2\n");
6640 return 0;
6641 }
6642
6643 //TODO: shifting it out of the way would be better
6644 if(e->routing) {
6645 GList *i = e->routing;
6646 while(i) {
6647 toporouter_vertex_t *ev = TOPOROUTER_VERTEX(i->data);
6648 if(!tvertex_wind(opv, ev, opv2)) return 0;
6649 i = i->next;
6650 }
6651
6652 }
6653
6654 ope1 = tedge(opv2, tedge_v1(e));
6655 ope2 = tedge(opv2, tedge_v2(e));
6656
6657 //this fixes the weird pad exits in r8c board
6658 // if(TOPOROUTER_IS_CONSTRAINT(ope1)) return 0;
6659 if(TOPOROUTER_IS_CONSTRAINT(ope2)) return 0;
6660
6661 if(!tvertex_wind(opv2, tedge_v1(e), opv)) return 0;
6662 if(!tvertex_wind(opv2, tedge_v2(e), opv)) return 0;
6663
6664 if(!vertex_line_normal_intersection(
6665 vx(tedge_v1(e)), vy(tedge_v1(e)),
6666 vx(tedge_v2(e)), vy(tedge_v2(e)),
6667 vx(opv2), vy(opv2),
6668 &line_int_x, &line_int_y)) return 0;
6669
6670
6671 // return 0;
6672 //if(vertex_line_normal_intersection(tev1x(e), tev1y(e), tev2x(e), tev2y(e), vx(opv), vy(opv), &line_int_x, &line_int_y))
6673 // return 0;
6674
6675 g_assert(opt && opv2);
6676
6677 /* this is just temp, for the purposes of determining flow */
6678 if(tedge_v1(ope1) == opv2) {
6679 if(TOPOROUTER_IS_CONSTRAINT(ope1))
6680 TOPOROUTER_CONSTRAINT(ope1)->routing = g_list_append(TOPOROUTER_CONSTRAINT(ope1)->routing, v1);
6681 else
6682 ope1->routing = g_list_append(ope1->routing, v1);
6683 }else{
6684 if(TOPOROUTER_IS_CONSTRAINT(ope1))
6685 TOPOROUTER_CONSTRAINT(ope1)->routing = g_list_prepend(TOPOROUTER_CONSTRAINT(ope1)->routing, v1);
6686 else
6687 ope1->routing = g_list_prepend(ope1->routing, v1);
6688 }
6689
6690 cap = triangle_interior_capacity(opt, opv2);
6691 flow = flow_from_edge_to_edge(opt, tedge(opv2, tedge_v1(e)), tedge(opv2, tedge_v2(e)), opv2, v1);
6692
6693 /* temp v1 removed */
6694 if(TOPOROUTER_IS_CONSTRAINT(ope1))
6695 TOPOROUTER_CONSTRAINT(ope1)->routing = g_list_remove(TOPOROUTER_CONSTRAINT(ope1)->routing, v1);
6696 else
6697 ope1->routing = g_list_remove(ope1->routing, v1);
6698
6699 if(flow >= cap) {
6700 toporouter_edge_t *newe = TOPOROUTER_EDGE(gts_edge_new(GTS_EDGE_CLASS(toporouter_edge_class()), GTS_VERTEX(opv), GTS_VERTEX(opv2)));
6701
6702 speccut_edge_routing_from_edge(edge_routing(e1), newe);
6703 speccut_edge_routing_from_edge(edge_routing(e2), newe);
6704 speccut_edge_routing_from_edge(edge_routing(ope1), newe);
6705 speccut_edge_routing_from_edge(edge_routing(ope2), newe);
6706
6707 speccut_edge_patch_links(newe);
6708 /*
6709 printf("SPECCUT WITH v %f,%f for seg %f,%f %f,%f detected\n", vx(opv2), vy(opv2),
6710 vx(v1), vy(v1),
6711 vx(v2), vy(v2));
6712 printf("\tflow %f cap %f\n", flow, cap);
6713 print_edge(newe);
6714 */
6715 if(newe->routing) return 1;
6716 }
6717
6718
6719 return 0;
6720 }
6721
6722
6723 gint
6724 oproute_path_speccut(toporouter_oproute_t *oproute)
6725 {
6726 GList *i;
6727 toporouter_vertex_t *pv;
6728 path_speccut_restart:
6729 i = oproute->path;
6730 pv = NULL;
6731 while(i) {
6732 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
6733
6734
6735 if(pv && (v->routingedge || pv->routingedge) && !(pv->flags & VERTEX_FLAG_SPECCUT) && !(v->flags & VERTEX_FLAG_SPECCUT)) {
6736
6737 if(!v->routingedge) {
6738 if(check_speccut(oproute, pv, v, tedge(tedge_v1(pv->routingedge), v), pv->routingedge, tedge(tedge_v2(pv->routingedge), v)))
6739 goto path_speccut_restart;
6740 if(check_speccut(oproute, pv, v, tedge(tedge_v2(pv->routingedge), v), pv->routingedge, tedge(tedge_v1(pv->routingedge), v)))
6741 goto path_speccut_restart;
6742 }else if(!pv->routingedge) {
6743 if(check_speccut(oproute, v, pv, tedge(tedge_v1(v->routingedge), pv), v->routingedge, tedge(tedge_v2(v->routingedge), pv)))
6744 goto path_speccut_restart;
6745 if(check_speccut(oproute, v, pv, tedge(tedge_v2(v->routingedge), pv), v->routingedge, tedge(tedge_v1(v->routingedge), pv)))
6746 goto path_speccut_restart;
6747 }else{
6748 toporouter_vertex_t *v1 = NULL, *v2 = NULL;
6749 edges_third_edge(GTS_SEGMENT(v->routingedge), GTS_SEGMENT(pv->routingedge), &v1, &v2);
6750 if(check_speccut(oproute, v, pv, tedge(v1, v2), v->routingedge, pv->routingedge))
6751 goto path_speccut_restart;
6752 }
6753 }
6754
6755
6756 pv = v;
6757 i = i->next;
6758 }
6759
6760 return 0;
6761 }
6762
6763 toporouter_oproute_t *
6764 oproute_rubberband(toporouter_t *r, GList *path)
6765 {
6766 toporouter_oproute_t *oproute = malloc(sizeof(toporouter_oproute_t));
6767
6768 g_assert(path);
6769
6770 oproute->term1 = TOPOROUTER_VERTEX(path->data);
6771 oproute->term2 = TOPOROUTER_VERTEX(g_list_last(path)->data);
6772 oproute->arcs = NULL;
6773 oproute->style = vertex_bbox(oproute->term1)->cluster->netlist->style;
6774 oproute->netlist = vertex_bbox(oproute->term1)->cluster->netlist->netlist;
6775 oproute->layergroup = vz(oproute->term1);
6776 oproute->path = path;
6777 oproute->serp = NULL;
6778
6779 oproute->term1->parent = NULL;
6780 oproute->term2->child = NULL;
6781
6782 path_set_oproute(path, oproute);
6783
6784 // if(!strcmp(oproute->netlist, " unnamed_net1"))
6785 oproute_path_speccut(oproute);
6786
6787 #ifdef DEBUG_RUBBERBAND
6788 if(!strcmp(oproute->netlist, " VCC3V3") && vx(oproute->term1) == 95700. && vy(oproute->term1) == 70800. &&
6789 vx(oproute->term2) == 196700. && vy(oproute->term2) == 67300.)
6790 {
6791 // printf("OPROUTE %s - %f,%f %f,%f\n", oproute->netlist, vx(oproute->term1), vy(oproute->term1), vx(oproute->term2), vy(oproute->term2));
6792 // print_path(path);
6793 oproute->arcs = oproute_rubberband_segment(r, oproute, path, oproute->term1, oproute->term2, 1);
6794 }else
6795 #endif
6796 oproute->arcs = oproute_rubberband_segment(r, oproute, path, oproute->term1, oproute->term2, 0);
6797
6798 oproute_check_all_loops(r, oproute);
6799 return oproute;
6800
6801 }
6802
6803 void
6804 toporouter_export(toporouter_t *r)
6805 {
6806 GList *i = r->routednets;
6807 GList *oproutes = NULL;
6808
6809 while(i) {
6810 toporouter_route_t *routedata = TOPOROUTER_ROUTE(i->data);
6811 toporouter_oproute_t *oproute = oproute_rubberband(r, routedata->path);
6812 oproutes = g_list_prepend(oproutes, oproute);
6813 i = i->next;
6814 }
6815
6816 i = oproutes;
6817 while(i) {
6818 toporouter_oproute_t *oproute = (toporouter_oproute_t *) i->data;
6819 export_oproutes(r, oproute);
6820 oproute_free(oproute);
6821 i = i->next;
6822 }
6823
6824 Message(_("Reticulating splines... successful\n\n"));
6825 Message(_("Wiring cost: %f inches\n"), r->wiring_score / 1000.);
6826 printf("Wiring cost: %f inches\n", r->wiring_score / 1000.);
6827
6828 g_list_free(oproutes);
6829
6830 }
6831
6832 toporouter_route_t *
6833 routedata_create(void)
6834 {
6835 toporouter_route_t *routedata = malloc(sizeof(toporouter_route_t));
6836 routedata->netlist = NULL;
6837 routedata->alltemppoints = NULL;
6838 routedata->path = NULL;
6839 routedata->curpoint = NULL;
6840 routedata->pscore = routedata->score = 0.;
6841 routedata->flags = 0;
6842 routedata->src = routedata->dest = NULL;
6843 routedata->psrc = routedata->pdest = NULL;
6844 routedata->ppath = routedata->topopath = NULL;
6845
6846 routedata->ppathindices = NULL;
6847
6848 routedata->destvertices = routedata->srcvertices = NULL;
6849 return routedata;
6850 }
6851 /*
6852 void
6853 print_routedata(toporouter_route_t *routedata)
6854 {
6855 GList *srcvertices = cluster_vertices(routedata->src);
6856 GList *destvertices = cluster_vertices(routedata->dest);
6857
6858 printf("ROUTEDATA:\n");
6859 printf("SRCVERTICES:\n");
6860 print_vertices(srcvertices);
6861 printf("DESTVERTICES:\n");
6862 print_vertices(destvertices);
6863
6864 g_list_free(srcvertices);
6865 g_list_free(destvertices);
6866 }*/
6867
6868 toporouter_route_t *
6869 import_route(toporouter_t *r, RatType *line)
6870 {
6871 toporouter_route_t *routedata = routedata_create();
6872
6873 routedata->src = cluster_find(r, line->Point1.X, line->Point1.Y, line->group1);
6874 routedata->dest = cluster_find(r, line->Point2.X, line->Point2.Y, line->group2);
6875
6876 if(!routedata->src) printf("couldn't locate src\n");
6877 if(!routedata->dest) printf("couldn't locate dest\n");
6878
6879 if(!routedata->src || !routedata->dest) {
6880 printf("PROBLEM: couldn't locate rat src or dest for rat %d,%d,%d -> %d,%d,%d\n",
6881 line->Point1.X, line->Point1.Y, line->group1, line->Point2.X, line->Point2.Y, line->group2);
6882 free(routedata);
6883 return NULL;
6884 }
6885
6886 routedata->netlist = routedata->src->netlist;
6887
6888 g_assert(routedata->src->netlist == routedata->dest->netlist);
6889
6890 g_ptr_array_add(r->routes, routedata);
6891 g_ptr_array_add(routedata->netlist->routes, routedata);
6892
6893 r->failednets = g_list_prepend(r->failednets, routedata);
6894
6895 return routedata;
6896 }
6897
6898 void
6899 delete_route(toporouter_route_t *routedata, guint destroy)
6900 {
6901 GList *i = routedata->path;
6902 toporouter_vertex_t *pv = NULL;
6903
6904 while(i) {
6905 toporouter_vertex_t *tv = TOPOROUTER_VERTEX(i->data);
6906
6907 g_assert(tv);
6908
6909 if(tv && pv && !(tv->flags & VERTEX_FLAG_ROUTE) && !(pv->flags & VERTEX_FLAG_ROUTE)) {
6910 toporouter_edge_t *e = TOPOROUTER_EDGE(gts_vertices_are_connected(GTS_VERTEX(tv), GTS_VERTEX(pv)));
6911
6912 if(e && (e->flags & EDGE_FLAG_DIRECTCONNECTION)) {
6913 e->flags ^= EDGE_FLAG_DIRECTCONNECTION;
6914 }
6915 }
6916 pv = tv;
6917 i = i->next;
6918 }
6919
6920 i = routedata->path;
6921 while(i) {
6922 toporouter_vertex_t *tv = TOPOROUTER_VERTEX(i->data);
6923
6924 tv->parent = NULL;
6925 tv->child = NULL;
6926
6927 if(tv->routingedge) {
6928 if(TOPOROUTER_IS_CONSTRAINT(tv->routingedge))
6929 TOPOROUTER_CONSTRAINT(tv->routingedge)->routing = g_list_remove(TOPOROUTER_CONSTRAINT(tv->routingedge)->routing, tv);
6930 else
6931 tv->routingedge->routing = g_list_remove(tv->routingedge->routing, tv);
6932 if(destroy) gts_object_destroy ( GTS_OBJECT(tv) );
6933 }
6934
6935 i = i->next;
6936 }
6937
6938 if(routedata->path) g_list_free(routedata->path);
6939 routedata->path = NULL;
6940 routedata->curpoint = NULL;
6941 routedata->score = INFINITY;
6942 routedata->alltemppoints = NULL;
6943 }
6944
6945 /* remove route can be later reapplied */
6946 void
6947 remove_route(GList *path)
6948 {
6949 GList *i = path;
6950
6951 while(i) {
6952 toporouter_vertex_t *tv = TOPOROUTER_VERTEX(i->data);
6953
6954 tv->parent = NULL;
6955 tv->child = NULL;
6956
6957 // if(tv->flags & VERTEX_FLAG_ROUTE) g_assert(tv->route == routedata);
6958
6959 if(tv->routingedge) {
6960
6961 if(TOPOROUTER_IS_CONSTRAINT(tv->routingedge))
6962 TOPOROUTER_CONSTRAINT(tv->routingedge)->routing = g_list_remove(TOPOROUTER_CONSTRAINT(tv->routingedge)->routing, tv);
6963 else
6964 tv->routingedge->routing = g_list_remove(tv->routingedge->routing, tv);
6965 }
6966 i = i->next;
6967 }
6968
6969 }
6970
6971 gint
6972 apply_route(GList *path, toporouter_route_t *routedata)
6973 {
6974 GList *i = path;
6975 toporouter_vertex_t *pv = NULL;
6976 gint count = 0;
6977
6978 if(!path) return 0;
6979 // g_assert(path);
6980
6981 while(i) {
6982 toporouter_vertex_t *tv = TOPOROUTER_VERTEX(i->data);
6983
6984 if(tv->routingedge) {
6985 if(TOPOROUTER_IS_CONSTRAINT(tv->routingedge))
6986 TOPOROUTER_CONSTRAINT(tv->routingedge)->routing = g_list_insert_sorted_with_data(
6987 TOPOROUTER_CONSTRAINT(tv->routingedge)->routing,
6988 tv,
6989 routing_edge_insert,
6990 tv->routingedge);
6991 else
6992 tv->routingedge->routing = g_list_insert_sorted_with_data(
6993 tv->routingedge->routing,
6994 tv,
6995 routing_edge_insert,
6996 tv->routingedge);
6997
6998 count++;
6999 }
7000
7001 if(pv) {
7002 pv->child = tv;
7003 tv->parent = pv;
7004 }
7005
7006 if(tv->flags & VERTEX_FLAG_ROUTE) g_assert(tv->route == routedata);
7007
7008 pv = tv;
7009 i = i->next;
7010 }
7011
7012 TOPOROUTER_VERTEX(path->data)->parent = NULL;
7013 pv->child = NULL;
7014
7015 return count;
7016 }
7017
7018
7019 gint
7020 compare_routedata_ascending(gconstpointer a, gconstpointer b)
7021 {
7022 toporouter_route_t *ra = (toporouter_route_t *)a;
7023 toporouter_route_t *rb = (toporouter_route_t *)b;
7024 return ra->score - rb->score;
7025 }
7026
7027 void
7028 print_costmatrix(gdouble *m, guint n)
7029 {
7030 printf("COST MATRIX:\n");
7031 for(guint i = 0;i<n;i++) {
7032 for(guint j = 0;j<n;j++) {
7033 printf("%f ", m[(i*n)+j]);
7034 }
7035 printf("\n");
7036 }
7037 }
7038
7039
7040 inline void
7041 init_cost_matrix(gdouble *m, guint n)
7042 {
7043 for(guint i=0;i<n;i++) {
7044 for(guint j=0;j<n;j++) {
7045 m[(i*n)+j] = INFINITY;
7046 }
7047 }
7048 }
7049
7050
7051 toporouter_netscore_t *
7052 netscore_create(toporouter_t *r, toporouter_route_t *routedata, guint n, guint id)
7053 {
7054 toporouter_netscore_t *netscore = malloc(sizeof(toporouter_netscore_t));
7055 GList *path = route(r, routedata, 0);
7056
7057 netscore->id = id;
7058
7059 netscore->routedata = routedata;
7060 routedata->detourscore = netscore->score = routedata->score;
7061
7062 if(!finite(routedata->detourscore)) {
7063 printf("WARNING: !finite(detourscore)\n");
7064 print_cluster(routedata->src);
7065 print_cluster(routedata->dest);
7066 return NULL;
7067 }
7068
7069 netscore->pairwise_nodetour = malloc(n * sizeof(guint));
7070
7071 for(guint i=0;i<n;i++) {
7072 netscore->pairwise_nodetour[i] = 0;
7073 }
7074
7075 netscore->pairwise_detour_sum = 0.;
7076 netscore->pairwise_fails = 0;
7077
7078 netscore->r = r;
7079
7080 if(path) {
7081 routedata->topopath = g_list_copy(routedata->path);
7082 delete_route(routedata, 0);
7083 }
7084
7085 return netscore;
7086 }
7087
7088 inline void
7089 netscore_destroy(toporouter_netscore_t *netscore)
7090 {
7091 free(netscore->pairwise_nodetour);
7092 free(netscore);
7093 }
7094
7095 void
7096 print_netscores(GPtrArray* netscores)
7097 {
7098 printf("NETSCORES: \n\n");
7099 printf(" %15s %15s %15s\n----------------------------------------------------\n", "Score", "Detour Sum", "Pairwise Fails");
7100
7101 for(toporouter_netscore_t **i = (toporouter_netscore_t **) netscores->pdata; i < (toporouter_netscore_t **) netscores->pdata + netscores->len; i++) {
7102 #ifdef DEBUG_NETSCORES
7103 printf("%4d %15f %15f %15d %15x\n", (*i)->id, (*i)->score, (*i)->pairwise_detour_sum, (*i)->pairwise_fails, (guint)*i);
7104 #endif
7105 }
7106
7107 printf("\n");
7108 }
7109
7110 void
7111 netscore_pairwise_calculation(toporouter_netscore_t *netscore, GPtrArray *netscores)
7112 {
7113 toporouter_netscore_t **netscores_base = (toporouter_netscore_t **) (netscores->pdata);
7114 toporouter_route_t *temproutedata = routedata_create();
7115
7116 //route(netscore->r, netscore->routedata, 0);
7117 apply_route(netscore->routedata->topopath, netscore->routedata);
7118
7119 for(toporouter_netscore_t **i = netscores_base; i < netscores_base + netscores->len; i++) {
7120
7121 if(!netscore->pairwise_nodetour[i-netscores_base] && *i != netscore && (*i)->routedata->netlist != netscore->routedata->netlist) {
7122
7123 temproutedata->src = (*i)->routedata->src;
7124 temproutedata->dest = (*i)->routedata->dest;
7125
7126 route(netscore->r, temproutedata, 0);
7127
7128 if(temproutedata->score == (*i)->score) {
7129 netscore->pairwise_nodetour[i-netscores_base] = 1;
7130 (*i)->pairwise_nodetour[netscore->id] = 1;
7131 }else
7132 if(!finite(temproutedata->score)) {
7133 netscore->pairwise_fails += 1;
7134 }else{
7135 netscore->pairwise_detour_sum += temproutedata->score - (*i)->score;
7136 }
7137
7138 delete_route(temproutedata, 1);
7139 }
7140
7141 }
7142
7143 // delete_route(netscore->routedata, 1);
7144 remove_route(netscore->routedata->topopath);
7145
7146 free(temproutedata);
7147 }
7148
7149 gint
7150 netscore_pairwise_size_compare(toporouter_netscore_t **a, toporouter_netscore_t **b)
7151 {
7152 // infinite scores are last
7153 if(!finite((*a)->score) && !finite((*b)->score)) return 0;
7154 if(finite((*a)->score) && !finite((*b)->score)) return -1;
7155 if(finite((*b)->score) && !finite((*a)->score)) return 1;
7156
7157 // order by pairwise fails
7158 if((*a)->pairwise_fails < (*b)->pairwise_fails) return -1;
7159 if((*b)->pairwise_fails < (*a)->pairwise_fails) return 1;
7160
7161 // order by pairwise detour
7162 if((*a)->pairwise_detour_sum < (*b)->pairwise_detour_sum) return -1;
7163 if((*b)->pairwise_detour_sum < (*a)->pairwise_detour_sum) return 1;
7164
7165 // order by score
7166 if((*a)->score < (*b)->score) return -1;
7167 if((*b)->score < (*a)->score) return 1;
7168
7169 return 0;
7170 }
7171
7172 gint
7173 netscore_pairwise_compare(toporouter_netscore_t **a, toporouter_netscore_t **b)
7174 {
7175 // infinite scores are last
7176 if(!finite((*a)->score) && !finite((*b)->score)) return 0;
7177 if(finite((*a)->score) && !finite((*b)->score)) return -1;
7178 if(finite((*b)->score) && !finite((*a)->score)) return 1;
7179
7180 // order by pairwise fails
7181 if((*a)->pairwise_fails < (*b)->pairwise_fails) return -1;
7182 if((*b)->pairwise_fails < (*a)->pairwise_fails) return 1;
7183
7184 // order by pairwise detour
7185 if((*a)->pairwise_detour_sum < (*b)->pairwise_detour_sum) return -1;
7186 if((*b)->pairwise_detour_sum < (*a)->pairwise_detour_sum) return 1;
7187
7188 return 0;
7189 }
7190
7191 guint
7192 order_nets_preroute_greedy(toporouter_t *r, GList *nets, GList **rnets)
7193 {
7194 gint len = g_list_length(nets);
7195 GPtrArray* netscores = g_ptr_array_sized_new(len);
7196 guint failcount = 0;
7197
7198 while(nets) {
7199 toporouter_netscore_t *ns = netscore_create(r, TOPOROUTER_ROUTE(nets->data), len, failcount++);
7200 if(ns) g_ptr_array_add(netscores, ns);
7201 nets = nets->next;
7202 }
7203
7204 failcount = 0;
7205
7206 g_ptr_array_foreach(netscores, (GFunc) netscore_pairwise_calculation, netscores);
7207
7208 g_ptr_array_sort(netscores, (GCompareFunc) r->netsort);
7209
7210 #ifdef DEBUG_ORDERING
7211 print_netscores(netscores);
7212 #endif
7213
7214 *rnets = NULL;
7215 FOREACH_NETSCORE(netscores) {
7216 *rnets = g_list_prepend(*rnets, netscore->routedata);
7217 if(!finite(netscore->score)) failcount++;
7218 netscore_destroy(netscore);
7219 } FOREACH_END;
7220
7221 g_ptr_array_free(netscores, TRUE);
7222
7223 return failcount;
7224 }
7225
7226 toporouter_vertex_t *
7227 edge_closest_vertex(toporouter_edge_t *e, toporouter_vertex_t *v)
7228 {
7229 GList *i = v->routingedge ? edge_routing(v->routingedge) : NULL;
7230 gdouble closestd = 0.;
7231 toporouter_vertex_t *closestv = NULL;
7232
7233 while(i) {
7234 toporouter_vertex_t *ev = TOPOROUTER_VERTEX(i->data);
7235 gdouble tempd = gts_point_distance2(GTS_POINT(ev), GTS_POINT(v));
7236
7237 if(!closestv || (tempd < closestd)) {
7238 closestd = tempd;
7239 closestv = ev;
7240 }
7241
7242 i = i->next;
7243 }
7244
7245 return closestv;
7246 }
7247
7248 void
7249 snapshot(toporouter_t *r, char *name, GList *datas)
7250 {
7251 ///*
7252 {
7253 int i;
7254 for(i=0;i<groupcount();i++) {
7255 char buffer[256];
7256 sprintf(buffer, "route-%s-%d.png", name, i);
7257 toporouter_draw_surface(r, r->layers[i].surface, buffer, 2048, 2048, 2, datas, i, NULL);
7258 }
7259 }
7260 //*/
7261
7262 }
7263 /*
7264 gdouble
7265 route_conflict(toporouter_t *r, toporouter_route_t *route, guint *n)
7266 {
7267 GList *i = route->path;
7268 toporouter_vertex_t *pv = NULL;
7269 gdouble cost = 0.;
7270
7271 while(i) {
7272 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
7273 if(pv && vz(v) == vz(pv))
7274 cost += vertices_routing_conflict_cost(r, v, pv, n);
7275 pv = v;
7276 i = i->next;
7277 }
7278
7279 return cost;
7280 }
7281 */
7282 GList *
7283 route_conflicts(toporouter_route_t *route)
7284 {
7285 GList *conflicts = NULL, *i = route->path;
7286 toporouter_vertex_t *pv = NULL;
7287
7288 while(i) {
7289 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
7290
7291 if(pv && vz(pv) == vz(v)) {
7292 GList *temp = vertices_routing_conflicts(pv, v), *j;
7293
7294 j = temp;
7295 while(j) {
7296 toporouter_route_t *conroute = TOPOROUTER_ROUTE(j->data);
7297 if(!g_list_find(conflicts, conroute))
7298 conflicts = g_list_prepend(conflicts, conroute);
7299 j = j->next;
7300 }
7301
7302 if(temp) g_list_free(temp);
7303 }
7304
7305 pv = v;
7306 i = i->next;
7307 }
7308 return conflicts;
7309 }
7310
7311 gint
7312 spread_edge(gpointer item, gpointer data)
7313 {
7314 toporouter_edge_t *e = TOPOROUTER_EDGE(item);
7315 toporouter_vertex_t *v;
7316 gdouble spacing, s;
7317 GList *i;
7318
7319 if(TOPOROUTER_IS_CONSTRAINT(e)) return 0;
7320
7321 i = edge_routing(e);
7322
7323 if(!g_list_length(i)) return 0;
7324
7325 if(g_list_length(i) == 1) {
7326 v = TOPOROUTER_VERTEX(i->data);
7327 GTS_POINT(v)->x = (vx(edge_v1(e)) + vx(edge_v2(e))) / 2.;
7328 GTS_POINT(v)->y = (vy(edge_v1(e)) + vy(edge_v2(e))) / 2.;
7329 return 0;
7330 }
7331
7332 s = spacing = (gts_point_distance(GTS_POINT(edge_v1(e)), GTS_POINT(edge_v2(e))) ) / (g_list_length(i) + 1);
7333
7334 while(i) {
7335 v = TOPOROUTER_VERTEX(i->data);
7336 vertex_move_towards_vertex_values(edge_v1(e), edge_v2(e), s, &(GTS_POINT(v)->x), &(GTS_POINT(v)->y));
7337
7338 s += spacing;
7339 i = i->next;
7340 }
7341
7342 return 0;
7343 }
7344
7345 void
7346 route_checkpoint(toporouter_route_t *route, toporouter_route_t *temproute)
7347 {
7348 GList *i = g_list_last(route->path);
7349 gint n = g_list_length(route->path);
7350
7351 if(route->ppathindices) free(route->ppathindices);
7352 route->ppathindices = malloc(sizeof(gint)*n);
7353
7354 // n = 0;
7355 while(i) {
7356 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
7357 n--;
7358
7359 if(v->routingedge) {
7360 GList *j = g_list_find(edge_routing(v->routingedge), v)->prev;
7361 gint tempindex = g_list_index(edge_routing(v->routingedge), v);
7362
7363 while(j) {
7364 if(TOPOROUTER_VERTEX(j->data)->route == temproute) tempindex--;
7365 j = j->prev;
7366 }
7367
7368 route->ppathindices[n] = tempindex;
7369
7370 if(TOPOROUTER_IS_CONSTRAINT(v->routingedge))
7371 TOPOROUTER_CONSTRAINT(v->routingedge)->routing = g_list_remove(TOPOROUTER_CONSTRAINT(v->routingedge)->routing, v);
7372 else
7373 v->routingedge->routing = g_list_remove(v->routingedge->routing, v);
7374 }
7375
7376 i = i->prev;
7377 }
7378
7379 route->pscore = route->score;
7380 route->ppath = route->path;
7381 remove_route(route->path);
7382 route->path = NULL;
7383 route->psrc = route->src;
7384 route->pdest = route->dest;
7385 //route->src->pc = route->src->c;
7386 //route->dest->pc = route->dest->c;
7387 }
7388
7389 void
7390 route_restore(toporouter_route_t *route)
7391 {
7392 GList *i;
7393 toporouter_vertex_t *pv = NULL;
7394 gint n = 0;
7395
7396 g_assert(route->ppath);
7397 g_assert(route->ppathindices);
7398
7399 route->path = route->ppath;
7400 i = route->ppath;
7401 while(i) {
7402 toporouter_vertex_t *v = TOPOROUTER_VERTEX(i->data);
7403
7404 if(v->routingedge) {
7405 if(TOPOROUTER_IS_CONSTRAINT(v->routingedge))
7406 TOPOROUTER_CONSTRAINT(v->routingedge)->routing = g_list_insert(TOPOROUTER_CONSTRAINT(v->routingedge)->routing, v, route->ppathindices[n]);
7407 else
7408 v->routingedge->routing = g_list_insert(v->routingedge->routing, v, route->ppathindices[n]);
7409
7410 // space_edge(v->routingedge, NULL);
7411 }
7412
7413 if(pv) {
7414 pv->child = v;
7415 v->parent = pv;
7416 }
7417
7418 n++;
7419 pv = v;
7420 i = i->next;
7421 }
7422
7423 route->score = route->pscore;
7424 route->src = route->psrc;
7425 route->dest = route->pdest;
7426 //route->src->c = route->src->pc;
7427 //route->dest->c = route->dest->pc;
7428
7429 }
7430
7431 void
7432 cluster_merge(toporouter_route_t *routedata)
7433 {
7434 gint oldc = routedata->dest->c, newc = routedata->src->c;
7435
7436 FOREACH_CLUSTER(routedata->netlist->clusters) {
7437 if(cluster->c == oldc)
7438 cluster->c = newc;
7439 } FOREACH_END;
7440
7441 }
7442
7443 void
7444 netlist_recalculate(toporouter_netlist_t *netlist, GList *ignore)
7445 {
7446 GList *i = g_list_last(netlist->routed);
7447 gint n = netlist->clusters->len-1;
7448
7449 FOREACH_CLUSTER(netlist->clusters) {
7450 cluster->c = n--;
7451 } FOREACH_END;
7452
7453 while(i) {
7454 if(!ignore || !g_list_find(ignore, i->data)) cluster_merge(TOPOROUTER_ROUTE(i->data));
7455 i = i->prev;
7456 }
7457
7458 }
7459
7460 void
7461 netlists_recalculate(GList *netlists, GList *ignore)
7462 {
7463 GList *i = netlists;
7464 while(i) {
7465 netlist_recalculate(TOPOROUTER_NETLIST(i->data), ignore);
7466 i = i->next;
7467 }
7468 }
7469
7470 void
7471 netlists_rollback(GList *netlists)
7472 {
7473 // netlists_recalculate(netlists, NULL);
7474 while(netlists) {
7475 toporouter_netlist_t *netlist = TOPOROUTER_NETLIST(netlists->data);
7476
7477 FOREACH_CLUSTER(netlist->clusters) {
7478 cluster->c = cluster->pc;
7479 } FOREACH_END;
7480
7481 netlists = netlists->next;
7482 }
7483 }
7484
7485 void
7486 print_netlist(toporouter_netlist_t *netlist)
7487 {
7488
7489 printf("NETLIST %s: ", netlist->netlist);
7490
7491 FOREACH_CLUSTER(netlist->clusters) {
7492 printf("%d ", cluster->c);
7493
7494 } FOREACH_END;
7495 printf("\n");
7496 }
7497
7498 #define REMOVE_ROUTING(x) x->netlist->routed = g_list_remove(x->netlist->routed, x); \
7499 r->routednets = g_list_remove(r->routednets, x); \
7500 r->failednets = g_list_prepend(r->failednets, x)
7501
7502 #define INSERT_ROUTING(x) x->netlist->routed = g_list_prepend(x->netlist->routed, x); \
7503 r->routednets = g_list_prepend(r->routednets, x); \
7504 r->failednets = g_list_remove(r->failednets, x)
7505
7506 gint
7507 roar_route(toporouter_t *r, toporouter_route_t *routedata, gint threshold)
7508 {
7509 gint intfails = 0;
7510 GList *netlists = NULL, *routed = NULL;
7511
7512 g_assert(!routedata->path);
7513
7514 if(routedata->src->c == routedata->dest->c) {
7515 printf("ERROR: attempt to route already complete route\n");
7516 g_assert(routedata->src->c != routedata->dest->c);
7517 }
7518
7519 routedata->src->pc = routedata->src->c;
7520 routedata->dest->pc = routedata->dest->c;
7521 routedata->psrc = routedata->src;
7522 routedata->pdest = routedata->dest;
7523
7524 r->flags |= TOPOROUTER_FLAG_LEASTINVALID;
7525 if(route(r, routedata, 0)) {
7526 GList *conflicts, *j;
7527
7528 INSERT_ROUTING(routedata);
7529
7530 conflicts = route_conflicts(routedata);
7531 cluster_merge(routedata);
7532
7533 r->flags &= ~TOPOROUTER_FLAG_LEASTINVALID;
7534
7535 j = conflicts;
7536 while(j) {
7537 toporouter_route_t *conflict = TOPOROUTER_ROUTE(j->data);
7538 if(!g_list_find(netlists, conflict->netlist))
7539 netlists = g_list_prepend(netlists, conflict->netlist);
7540
7541 route_checkpoint(conflict, routedata);
7542
7543 REMOVE_ROUTING(conflict);
7544 j = j->next;
7545 }
7546
7547 netlists = g_list_prepend(netlists, routedata->netlist);
7548 netlists_recalculate(netlists, NULL);
7549
7550 j = conflicts;
7551 while(j) {
7552 toporouter_route_t *conflict = TOPOROUTER_ROUTE(j->data);
7553 g_assert(conflict->src->c != conflict->dest->c);
7554 if(route(r, conflict, 0)) {
7555 cluster_merge(conflict);
7556
7557 routed = g_list_prepend(routed, conflict);
7558
7559 INSERT_ROUTING(conflict);
7560
7561 netlist_recalculate(conflict->netlist, NULL);
7562
7563 }else{
7564 if(++intfails >= threshold) {
7565 GList *i = routed;
7566 while(i) {
7567 toporouter_route_t *intconflict = TOPOROUTER_ROUTE(i->data);
7568 REMOVE_ROUTING(intconflict);
7569 delete_route(intconflict, 1);
7570 i = i->next;
7571 }
7572 delete_route(routedata, 1);
7573 i = g_list_last(conflicts);
7574 while(i) {
7575 toporouter_route_t *intconflict = TOPOROUTER_ROUTE(i->data);
7576
7577 route_restore(intconflict);
7578 INSERT_ROUTING(intconflict);
7579
7580 i = i->prev;
7581 }
7582 REMOVE_ROUTING(routedata);
7583 intfails = 0;
7584 netlists_recalculate(netlists, NULL);
7585 goto roar_route_end;
7586 }
7587
7588 }
7589 j = j->next;
7590 }
7591
7592
7593 netlists_recalculate(netlists, NULL);
7594
7595 intfails--;
7596 roar_route_end:
7597 g_list_free(conflicts);
7598 g_list_free(netlists);
7599
7600 }else{
7601 r->flags &= ~TOPOROUTER_FLAG_LEASTINVALID;
7602 }
7603
7604 g_list_free(routed);
7605 return intfails;
7606 }
7607
7608 gint
7609 roar_router(toporouter_t *r, gint failcount, gint threshold)
7610 {
7611 gint pfailcount = failcount +1;
7612
7613 Message(_("ROAR router: "));
7614 for(guint j=0;j<6;j++) {
7615 GList *failed = g_list_copy(r->failednets), *k = failed;
7616
7617 k = failed;
7618 while(k) {
7619 failcount += roar_route(r, TOPOROUTER_ROUTE(k->data), threshold);
7620 k = k->next;
7621 }
7622 g_list_free(failed);
7623
7624 printf("\tROAR pass %d - %d routed - %d failed\n", j, g_list_length(r->routednets), g_list_length(r->failednets));
7625
7626 if(!failcount || failcount >= pfailcount) {
7627 Message(_("%d nets remaining\n"), failcount);
7628 break;
7629 }
7630 Message(_("%d -> "), failcount);
7631 pfailcount = failcount;
7632 }
7633
7634 return failcount;
7635 }
7636
7637 gint
7638 route_detour_compare(toporouter_route_t **a, toporouter_route_t **b)
7639 { return ((*b)->score - (*b)->detourscore) - ((*a)->score - (*a)->detourscore); }
7640
7641
7642
7643 void
7644 roar_detour_route(toporouter_t *r, toporouter_route_t *data)
7645 {
7646 gdouble pscore = data->score, nscore = 0.;
7647 GList *netlists = NULL;
7648
7649 route_checkpoint(data, NULL);
7650
7651 REMOVE_ROUTING(data);
7652
7653 netlists = g_list_prepend(NULL, data->netlist);
7654 netlists_recalculate(netlists, NULL);
7655
7656 r->flags |= TOPOROUTER_FLAG_LEASTINVALID;
7657 if(route(r, data, 0)) {
7658 GList *conflicts, *j;
7659
7660 nscore = data->score;
7661 conflicts = route_conflicts(data);
7662
7663 INSERT_ROUTING(data);
7664
7665 r->flags &= ~TOPOROUTER_FLAG_LEASTINVALID;
7666
7667 j = conflicts;
7668 while(j) {
7669 toporouter_route_t *conflict = TOPOROUTER_ROUTE(j->data);
7670
7671 if(!g_list_find(netlists, conflict->netlist))
7672 netlists = g_list_prepend(netlists, conflict->netlist);
7673 pscore += conflict->score;
7674
7675 route_checkpoint(conflict, NULL);
7676 REMOVE_ROUTING(conflict);
7677
7678 j = j->next;
7679 }
7680 netlists_recalculate(netlists, NULL);
7681
7682 j = conflicts;
7683 while(j) {
7684 toporouter_route_t *conflict = TOPOROUTER_ROUTE(j->data);
7685
7686 if(route(r, conflict, 0)) {
7687 cluster_merge(conflict);
7688 INSERT_ROUTING(conflict);
7689 nscore += conflict->score;
7690 }else{
7691 j = j->prev;
7692 goto roar_detour_route_rollback_int;
7693 }
7694 j = j->next;
7695 }
7696
7697 if(nscore > pscore) {
7698 j = g_list_last(conflicts);
7699 roar_detour_route_rollback_int:
7700 REMOVE_ROUTING(data);
7701
7702 while(j) {
7703 toporouter_route_t *conflict = TOPOROUTER_ROUTE(j->data);
7704 REMOVE_ROUTING(conflict);
7705 delete_route(conflict, 1);
7706 j = j->prev;
7707 }
7708
7709 j = g_list_last(conflicts);
7710 while(j) {
7711 toporouter_route_t *conflict = TOPOROUTER_ROUTE(j->data);
7712 route_restore(conflict);
7713 INSERT_ROUTING(conflict);
7714 j = j->prev;
7715 }
7716 delete_route(data, 1);
7717
7718 goto roar_detour_route_rollback_exit;
7719
7720 }
7721
7722 g_list_free(conflicts);
7723 }else{
7724 r->flags &= ~TOPOROUTER_FLAG_LEASTINVALID;
7725 roar_detour_route_rollback_exit:
7726 route_restore(data);
7727 INSERT_ROUTING(data);
7728 }
7729 netlists_recalculate(netlists, NULL);
7730
7731 g_list_free(netlists);
7732 }
7733
7734 void
7735 detour_router(toporouter_t *r)
7736 {
7737 GList *i = r->routednets;
7738 guint n = g_list_length(r->routednets);
7739 GPtrArray* scores = g_ptr_array_sized_new(n);
7740
7741 while(i) {
7742 toporouter_route_t *curroute = TOPOROUTER_ROUTE(i->data);
7743 curroute->score = path_score(r, curroute->path);
7744 g_ptr_array_add(scores, i->data);
7745 i = i->next;
7746 }
7747
7748 g_ptr_array_sort(scores, (GCompareFunc) route_detour_compare);
7749
7750 r->flags |= TOPOROUTER_FLAG_DETOUR;
7751
7752 for(toporouter_route_t **i = (toporouter_route_t **) scores->pdata; i < (toporouter_route_t **) scores->pdata + scores->len; i++) {
7753 toporouter_route_t *curroute = (*i);
7754
7755 if(finite(curroute->score) && finite(curroute->detourscore)) {
7756 // printf("%15s %15f \t %8f,%8f - %8f,%8f\n", (*i)->src->netlist + 2, (*i)->score - (*i)->detourscore,
7757 // vx(curroute->mergebox1->point), vy(curroute->mergebox1->point),
7758 // vx(curroute->mergebox2->point), vy(curroute->mergebox2->point));
7759
7760 if(curroute->score - curroute->detourscore > 1000.) {
7761 roar_detour_route(r, curroute);
7762 }else break;
7763
7764 }
7765 }
7766 printf("\n");
7767
7768 r->flags ^= TOPOROUTER_FLAG_DETOUR;
7769
7770 g_ptr_array_free(scores, TRUE);
7771
7772 }
7773
7774 gint
7775 rubix_router(toporouter_t *r, gint failcount)
7776 {
7777 GList *i, *ordering;
7778 order_nets_preroute_greedy(r, r->failednets, &ordering);
7779
7780 i = ordering;
7781 while(i) {
7782 toporouter_route_t *data = TOPOROUTER_ROUTE(i->data);
7783
7784 if(route(r, data, 0)) {
7785 INSERT_ROUTING(data);
7786 cluster_merge(data);
7787 failcount--;
7788 }
7789
7790 i = i->next;
7791 }
7792
7793 g_list_free(ordering);
7794
7795 return failcount;
7796 }
7797
7798 guint
7799 hybrid_router(toporouter_t *r)
7800 {
7801 gint failcount = g_list_length(r->failednets);
7802 r->flags |= TOPOROUTER_FLAG_AFTERORDER;
7803 r->flags |= TOPOROUTER_FLAG_AFTERRUBIX;
7804 failcount = rubix_router(r, failcount);
7805
7806 Message(_("RUBIX router: %d nets remaining\n"), failcount);
7807 printf("RUBIX router: %d nets remaining\n", failcount);
7808
7809 r->flags |= TOPOROUTER_FLAG_GOFAR;
7810
7811 for(guint i=0;i<6 && failcount;i++) {
7812 if(i % 2 == 1) {
7813 failcount = roar_router(r, failcount, 5);
7814 // printf("THRESH 5\n");
7815 }else{
7816 failcount = roar_router(r, failcount, 2);
7817 // printf("THRESH 2\n");
7818 }
7819
7820 detour_router(r);
7821 }
7822
7823 failcount = roar_router(r, failcount, 2);
7824 detour_router(r);
7825
7826 return failcount;
7827 }
7828
7829 void
7830 parse_arguments(toporouter_t *r, int argc, char **argv)
7831 {
7832 int i, tempint;
7833 for(i=0;i<argc;i++) {
7834 if(sscanf(argv[i], "viacost=%d", &tempint)) {
7835 r->viacost = (double)tempint;
7836 }else if(sscanf(argv[i], "l%d", &tempint)) {
7837 gdouble *layer = malloc(sizeof(gdouble));
7838 *layer = (double)tempint;
7839 r->keepoutlayers = g_list_prepend(r->keepoutlayers, layer);
7840 }
7841 }
7842
7843 for (guint group = 0; group < max_layer; group++)
7844 for (i = 0; i < PCB->LayerGroups.Number[group]; i++)
7845 if ((PCB->LayerGroups.Entries[group][i] < max_layer) && !(PCB->Data->Layer[PCB->LayerGroups.Entries[group][i]].On)) {
7846 gdouble *layer = malloc(sizeof(gdouble));
7847 *layer = (double)group;
7848 r->keepoutlayers = g_list_prepend(r->keepoutlayers, layer);
7849 }
7850
7851 }
7852
7853 toporouter_t *
7854 toporouter_new(void)
7855 {
7856 toporouter_t *r = calloc(1, sizeof(toporouter_t));
7857 time_t ltime;
7858
7859 gettimeofday(&r->starttime, NULL);
7860
7861 r->netsort = netscore_pairwise_compare;
7862
7863 r->destboxes = NULL;
7864 r->consumeddestboxes = NULL;
7865
7866 r->paths = NULL;
7867
7868 r->layers = NULL;
7869 r->flags = 0;
7870 r->viamax = 3;
7871 r->viacost = 10000.;
7872 r->stublength = 300.;
7873 r->serpintine_half_amplitude = 1500.;
7874
7875 r->wiring_score = 0.;
7876
7877 r->bboxes = NULL;
7878 r->bboxtree = NULL;
7879
7880 r->netlists = g_ptr_array_new();
7881 r->routes = g_ptr_array_new();
7882
7883 r->keepoutlayers = NULL;
7884
7885 r->routednets = NULL;
7886 r->failednets = NULL;
7887
7888 ltime=time(NULL);
7889
7890 gts_predicates_init();
7891
7892 Message(_("Topological Autorouter\n"));
7893 Message(_("Started %s"),asctime(localtime(&ltime)));
7894 Message(_("-------------------------------------\n"));
7895 Message(_("Copyright 2009 Anthony Blake (tonyb33@gmail.com)\n\n"));
7896 return r;
7897 }
7898
7899 void
7900 acquire_twonets(toporouter_t *r)
7901 {
7902 RAT_LOOP(PCB->Data);
7903 if( TEST_FLAG(SELECTEDFLAG, line) ) import_route(r, line);
7904 END_LOOP;
7905 // /*
7906 if(!r->routes->len) {
7907 RAT_LOOP(PCB->Data);
7908 import_route(r, line);
7909 END_LOOP;
7910 }
7911 // */
7912
7913 }
7914
7915 toporouter_netlist_t *
7916 find_netlist_by_name(toporouter_t *r, char *name)
7917 {
7918 FOREACH_NETLIST(r->netlists) {
7919 if(!strcmp(netlist->netlist, name)) return netlist;
7920 } FOREACH_END;
7921 return NULL;
7922 }
7923
7924 gint
7925 toporouter_set_pair(toporouter_t *r, toporouter_netlist_t *n1, toporouter_netlist_t *n2)
7926 {
7927 if(!n1 || !n2) return 0;
7928 n1->pair = n2;
7929 n2->pair = n1;
7930 return 1;
7931 }
7932
7933 static int
7934 toporouter (int argc, char **argv, int x, int y)
7935 {
7936 toporouter_t *r = toporouter_new();
7937 parse_arguments(r, argc, argv);
7938 import_geometry(r);
7939 acquire_twonets(r);
7940
7941 //if(!toporouter_set_pair(r, find_netlist_by_name(r, " DRAM_DQS_N"), find_netlist_by_name(r, " DRAM_DQS"))) {
7942 // printf("Couldn't associate pair\n");
7943 //}
7944
7945 hybrid_router(r);
7946 /*
7947 for(gint i=0;i<groupcount();i++) {
7948 gts_surface_foreach_edge(r->layers[i].surface, space_edge, NULL);
7949 }
7950 {
7951 int i;
7952 for(i=0;i<groupcount();i++) {
7953 char buffer[256];
7954 sprintf(buffer, "route%d.png", i);
7955 toporouter_draw_surface(r, r->layers[i].surface, buffer, 1024, 1024, 2, NULL, i, NULL);
7956 }
7957 }
7958 */
7959 toporouter_export(r);
7960 toporouter_free(r);
7961
7962 SaveUndoSerialNumber ();
7963 DeleteRats (false);
7964 RestoreUndoSerialNumber ();
7965 AddAllRats (false, NULL);
7966 RestoreUndoSerialNumber ();
7967 IncrementUndoSerialNumber ();
7968 ClearAndRedrawOutput ();
7969
7970 return 0;
7971 }
7972
7973 static int
7974 escape (int argc, char **argv, int x, int y)
7975 {
7976 guint dir, viax, viay;
7977 gdouble pitch, length, dx, dy;
7978
7979 if(argc != 1) return 0;
7980
7981 dir = atoi(argv[0]);
7982
7983
7984 ALLPAD_LOOP(PCB->Data);
7985 {
7986 if( TEST_FLAG(SELECTEDFLAG, pad) ) {
7987 PinTypePtr via;
7988 LineTypePtr line;
7989
7990 pitch = sqrt( pow(abs(element->Pad[0].Point1.X - element->Pad[1].Point1.X), 2) +
7991 pow(abs(element->Pad[0].Point1.Y - element->Pad[1].Point1.Y), 2) );
7992 length = sqrt(pow(pitch,2) + pow(pitch,2)) / 2.;
7993
7994 dx = length * sin(M_PI/4.);
7995 dy = length * cos(M_PI/4.);
7996
7997 switch(dir) {
7998 case 1:
7999 viax = pad->Point1.X - dx;
8000 viay = pad->Point1.Y + dy;
8001 break;
8002 case 3:
8003 viax = pad->Point1.X + dx;
8004 viay = pad->Point1.Y + dy;
8005 break;
8006 case 9:
8007 viax = pad->Point1.X + dx;
8008 viay = pad->Point1.Y - dy;
8009 break;
8010 case 7:
8011 viax = pad->Point1.X - dx;
8012 viay = pad->Point1.Y - dy;
8013 break;
8014 case 2:
8015 viax = pad->Point1.X;
8016 viay = pad->Point1.Y + (pitch/2);
8017 break;
8018 case 8:
8019 viax = pad->Point1.X;
8020 viay = pad->Point1.Y - (pitch/2);
8021 break;
8022 case 4:
8023 viax = pad->Point1.X - (pitch/2);
8024 viay = pad->Point1.Y;
8025 break;
8026 case 6:
8027 viax = pad->Point1.X + (pitch/2);
8028 viay = pad->Point1.Y;
8029 break;
8030 default:
8031 printf("ERROR: escape() with bad direction (%d)\n", dir);
8032 return 1;
8033 }
8034
8035 if ((via = CreateNewVia (PCB->Data, viax, viay,
8036 Settings.ViaThickness, 2 * Settings.Keepaway,
8037 0, Settings.ViaDrillingHole, NULL,
8038 NoFlags ())) != NULL)
8039 {
8040 AddObjectToCreateUndoList (VIA_TYPE, via, via, via);
8041 // if (gui->shift_is_pressed ())
8042 // ChangeObjectThermal (VIA_TYPE, via, via, via, PCB->ThermStyle);
8043 DrawVia (via, 0);
8044 if((line = CreateDrawnLineOnLayer (CURRENT, pad->Point1.X + 1., pad->Point1.Y + 1., viax + 1., viay + 1.,
8045 Settings.LineThickness, 2 * Settings.Keepaway,
8046 NoFlags())))
8047 {
8048
8049 AddObjectToCreateUndoList (LINE_TYPE, CURRENT, line, line);
8050 DrawLine (CURRENT, line, 0);
8051
8052 }
8053
8054 }
8055
8056 }
8057 }
8058 END_LOOP;
8059 END_LOOP;
8060
8061 IncrementUndoSerialNumber ();
8062 Draw ();
8063 return 0;
8064 }
8065
8066 static HID_Action toporouter_action_list[] = {
8067 {"Escape", "Select a set of pads", escape, "Pad escape", "Escape()"},
8068 {"Toporouter", "Select net(s)", toporouter, "Topological autorouter", "Toporouter()"}
8069 };
8070
8071 REGISTER_ACTIONS (toporouter_action_list)
8072
8073 void hid_toporouter_init()
8074 {
8075 register_toporouter_action_list();
8076 }
8077
Gareth Edwards' PCB tree