}
+
+#ifdef WITH_CGRAPH
+/*****CGRAPH BLOCK*/
+static void makePortLabels(edge_t * e)
+{
+ if (ED_head_label(e) && !ED_head_label(e)->set) {
+ place_portlabel(e, TRUE);
+ updateBB(agraphof(agtail(e)), ED_head_label(e));
+ }
+ if (ED_tail_label(e) && !ED_tail_label(e)->set) {
+ place_portlabel(e, FALSE);
+ updateBB(agraphof(agtail(e)), ED_tail_label(e));
+ }
+}
+
+/* endPoints:
+ * Extract the actual end points of the spline, where
+ * they touch the node.
+ */
+static void endPoints(splines * spl, point * p, point * q)
+{
+ bezier bz;
+
+ bz = spl->list[0];
+ if (bz.sflag)
+ *p = bz.sp;
+ else
+ *p = bz.list[0];
+ bz = spl->list[spl->size - 1];
+ if (bz.eflag)
+ *q = bz.ep;
+ else
+ *q = bz.list[bz.size - 1];
+}
+
+/* polylineMidpoint;
+ * Find midpoint of polyline.
+ * pp and pq are set to the endpoints of the line segment containing it.
+ */
+static point
+polylineMidpoint (splines* spl, point* pp, point* pq)
+{
+ bezier bz;
+ int i, j, k;
+ double d, dist = 0;
+ point m;
+ pointf pf, qf, mf;
+
+ for (i = 0; i < spl->size; i++) {
+ bz = spl->list[i];
+ for (j = 0, k=3; k < bz.size; j+=3,k+=3) {
+ P2PF (bz.list[j],pf);
+ P2PF (bz.list[k],qf);
+ dist += DIST(pf,qf);
+ }
+ }
+ dist /= 2;
+ for (i = 0; i < spl->size; i++) {
+ bz = spl->list[i];
+ for (j = 0, k=3; k < bz.size; j+=3,k+=3) {
+ P2PF (bz.list[j],pf);
+ P2PF (bz.list[k],qf);
+ d = DIST(pf,qf);
+ if (d >= dist) {
+ *pp = bz.list[j];
+ *pq = bz.list[k];
+ mf.x = ((qf.x*dist) + (pf.x*(d-dist)))/d;
+ mf.y = ((qf.y*dist) + (pf.y*(d-dist)))/d;
+ PF2P(mf, m);
+ return m;
+ }
+ else
+ dist -= d;
+ }
+ }
+ assert (FALSE); /* should never get here */
+ return m;
+}
+
+#define LEFTOF(a,b,c) (((a.y - b.y)*(c.x - b.x) - (c.y - b.y)*(a.x - b.x)) > 0)
+#define MAXLABELWD (POINTS_PER_INCH/2.0)
+
+/* addEdgeLabels:
+ * rp and rq are the port points of the tail and head node.
+ * Adds label, headlabel and taillabel.
+ * The use of 2 and 4 in computing ld.x and ld.y are fudge factors, to
+ * introduce a bit of spacing.
+ * Updates bounding box.
+ * We try to use the actual endpoints of the spline, as they may differ
+ * significantly from rp and rq, but if the spline is degenerate (e.g.,
+ * the nodes overlap), we use rp and rq.
+ */
+void addEdgeLabels(edge_t * e, point rp, point rq)
+{
+ int et = EDGE_TYPE (agraphof(aghead(e))->root);
+ point p, q;
+ point d; /* midpoint of segment p-q */
+ point ld;
+ point sp;
+ point del;
+ pointf spf;
+ double f, ht, wd, dist2;
+ int leftOf;
+
+ if (ED_label(e) && !ED_label(e)->set) {
+ endPoints(ED_spl(e), &p, &q);
+ if ((p.x == q.x) && (p.y == q.y)) { /* degenerate spline */
+ p = rp;
+ q = rq;
+ sp = p;
+ }
+ else if (et == ET_SPLINE) {
+ d.x = (q.x + p.x) / 2;
+ d.y = (p.y + q.y) / 2;
+ sp = dotneato_closest(ED_spl(e), d);
+ }
+ else { /* ET_PLINE or ET_LINE */
+ sp = polylineMidpoint (ED_spl(e), &p, &q);
+ }
+ del.x = q.x - p.x;
+ del.y = q.y - p.y;
+ dist2 = del.x*del.x + del.y*del.y;
+ ht = (ED_label(e)->dimen.y + 2)/2.0;
+ spf.x = sp.x;
+ spf.y = sp.y;
+ if (dist2) {
+ wd = (MIN(ED_label(e)->dimen.x + 2, MAXLABELWD))/2.0;
+ leftOf = LEFTOF(p, q, sp);
+ if ((leftOf && (del.y >= 0)) || (!leftOf && (del.y < 0))) {
+ if (del.x*del.y >= 0)
+ ht *= -1;
+ }
+ else {
+ wd *= -1;
+ if (del.x*del.y < 0)
+ ht *= -1;
+ }
+ f = (del.y*wd - del.x*ht)/dist2;
+ ld.x = -f*del.y;
+ ld.y = f*del.x;
+ }
+ else { /* end points the same */
+ ld.x = 0;
+ ld.y = -ht;
+ }
+
+ ED_label(e)->p.x = spf.x + ld.x;
+ ED_label(e)->p.y = spf.y + ld.y;
+ ED_label(e)->set = TRUE;
+ updateBB(agraphof(agtail(e)), ED_label(e));
+ }
+ makePortLabels(e);
+}
+
+typedef struct {
+ node_t *n1;
+ point p1;
+ node_t *n2;
+ point p2;
+} edgeinfo;
+typedef struct {
+ Dtlink_t link;
+ edgeinfo id;
+ edge_t *e;
+} edgeitem;
+
+static void *newitem(Dt_t * d, edgeitem * obj, Dtdisc_t * disc)
+{
+ edgeitem *newp;
+
+ NOTUSED(disc);
+ newp = NEW(edgeitem);
+ newp->id = obj->id;
+ newp->e = obj->e;
+ ED_count(newp->e) = 1;
+
+ return newp;
+}
+
+static void freeitem(Dt_t * d, edgeitem * obj, Dtdisc_t * disc)
+{
+ free(obj);
+}
+
+static int
+cmpitems(Dt_t * d, edgeinfo * key1, edgeinfo * key2, Dtdisc_t * disc)
+{
+ int x;
+
+ if (key1->n1 > key2->n1)
+ return 1;
+ if (key1->n1 < key2->n1)
+ return -1;
+ if (key1->n2 > key2->n2)
+ return 1;
+ if (key1->n2 < key2->n2)
+ return -1;
+
+ if ((x = key1->p1.x - key2->p1.x))
+ return x;
+ if ((x = key1->p1.y - key2->p1.y))
+ return x;
+ if ((x = key1->p2.x - key2->p2.x))
+ return x;
+ return (key1->p2.y - key2->p2.y);
+}
+
+Dtdisc_t edgeItemDisc = {
+ offsetof(edgeitem, id),
+ sizeof(edgeinfo),
+ offsetof(edgeitem, link),
+ (Dtmake_f) newitem,
+ (Dtfree_f) freeitem,
+ (Dtcompar_f) cmpitems,
+ 0,
+ 0,
+ 0
+};
+
+/* equivEdge:
+ * See if we have already encountered an edge between the same
+ * node:port pairs. If so, return the earlier edge. If not,
+ * this edge is added to map and returned.
+ * We first have to canonicalize the key fields using a lexicographic
+ * ordering.
+ */
+static edge_t *equivEdge(Dt_t * map, edge_t * e)
+{
+ edgeinfo test;
+ edgeitem dummy;
+ edgeitem *ip;
+
+ if (agtail(e) < aghead(e)) {
+ test.n1 = agtail(e);
+ test.p1 = ED_tail_port(e).p;
+ test.n2 = aghead(e);
+ test.p2 = ED_head_port(e).p;
+ } else if (agtail(e) > aghead(e)) {
+ test.n2 = agtail(e);
+ test.p2 = ED_tail_port(e).p;
+ test.n1 = aghead(e);
+ test.p1 = ED_head_port(e).p;
+ } else {
+ point hp = ED_head_port(e).p;
+ point tp = ED_tail_port(e).p;
+ if (tp.x < hp.x) {
+ test.p1 = tp;
+ test.p2 = hp;
+ } else if (tp.x > hp.x) {
+ test.p1 = hp;
+ test.p2 = tp;
+ } else if (tp.y < hp.y) {
+ test.p1 = tp;
+ test.p2 = hp;
+ } else if (tp.y > hp.y) {
+ test.p1 = hp;
+ test.p2 = tp;
+ } else {
+ test.p1 = test.p2 = tp;
+ }
+ test.n2 = test.n1 = agtail(e);
+ }
+ dummy.id = test;
+ dummy.e = e;
+ ip = dtinsert(map, &dummy);
+ return ip->e;
+}
+
+
+/* makeSelfArcs:
+ * Generate loops. We use the library routine makeSelfEdge
+ * which also places the labels.
+ * We have to handle port labels here.
+ * as well as update the bbox from edge labels.
+ */
+void makeSelfArcs(path * P, edge_t * e, int stepx)
+{
+ int cnt = ED_count(e);
+
+ if (cnt == 1) {
+ edge_t *edges1[1];
+ edges1[0] = e;
+ makeSelfEdge(P, edges1, 0, 1, stepx, stepx, &sinfo);
+ if (ED_label(e))
+ updateBB(agraphof(agtail(e)), ED_label(e));
+ makePortLabels(e);
+ } else {
+ int i;
+ edge_t **edges = N_GNEW(cnt, edge_t *);
+ for (i = 0; i < cnt; i++) {
+ edges[i] = e;
+ e = ED_to_virt(e);
+ }
+ makeSelfEdge(P, edges, 0, cnt, stepx, stepx, &sinfo);
+ for (i = 0; i < cnt; i++) {
+ e = edges[i];
+ if (ED_label(e))
+ updateBB(agraphof(agtail(e)), ED_label(e));
+ makePortLabels(e);
+ }
+ free(edges);
+ }
+}
+
+/* makeStraightEdge:
+ *
+ * FIX: handle ports on boundary?
+ */
+void
+makeStraightEdge(graph_t * g, edge_t * e, int doPolyline)
+{
+ point dumb[4];
+ node_t *n = agtail(e);
+ node_t *head = aghead(e);
+ int e_cnt = ED_count(e);
+ pointf perp;
+ point del;
+ edge_t *e0;
+ int i, j, xstep, dx;
+ double l_perp;
+ point dumber[4];
+ point p, q;
+
+ p = dumb[1] = dumb[0] = add_points(ND_coord_i(n), ED_tail_port(e).p);
+ q = dumb[2] = dumb[3] =
+ add_points(ND_coord_i(head), ED_head_port(e).p);
+
+ if (e_cnt == 1) {
+ clip_and_install(e, aghead(e), dumb, 4, &sinfo);
+ addEdgeLabels(e, p, q);
+ return;
+ }
+
+ e0 = e;
+ perp.x = dumb[0].y - dumb[3].y;
+ perp.y = dumb[3].x - dumb[0].x;
+ if ((perp.x == 0) && (perp.y == 0)) {
+ /* degenerate case */
+ dumb[1] = dumb[0];
+ dumb[2] = dumb[3];
+ del.x = 0;
+ del.y = 0;
+ }
+ else {
+ l_perp = sqrt(perp.x * perp.x + perp.y * perp.y);
+ xstep = GD_nodesep(g);
+ dx = xstep * (e_cnt - 1) / 2;
+ dumb[1].x = dumb[0].x + (dx * perp.x) / l_perp;
+ dumb[1].y = dumb[0].y + (dx * perp.y) / l_perp;
+ dumb[2].x = dumb[3].x + (dx * perp.x) / l_perp;
+ dumb[2].y = dumb[3].y + (dx * perp.y) / l_perp;
+ del.x = -xstep * perp.x / l_perp;
+ del.y = -xstep * perp.y / l_perp;
+ }
+
+ for (i = 0; i < e_cnt; i++) {
+ if (aghead(e0) == head) {
+ p = dumb[0];
+ q = dumb[3];
+ for (j = 0; j < 4; j++) {
+ dumber[j] = dumb[j];
+ }
+ } else {
+ p = dumb[3];
+ q = dumb[0];
+ for (j = 0; j < 4; j++) {
+ dumber[3 - j] = dumb[j];
+ }
+ }
+ if (doPolyline) {
+ Ppoint_t pts[4];
+ Ppolyline_t spl, line;
+ point* ispline;
+
+ line.pn = 4;
+ line.ps = pts;
+ for (i=0; i < 4; i++)
+ P2PF (dumber[i], pts[i]);
+ make_polyline (line, &spl);
+ ispline = N_GNEW(spl.pn, point);
+ for (i=0; i < spl.pn; i++)
+ PF2P (spl.ps[i], ispline[i]);
+ clip_and_install(e0, aghead(e0), ispline, spl.pn, &sinfo);
+ free(ispline);
+ }
+ else
+ clip_and_install(e0, aghead(e0), dumber, 4, &sinfo);
+
+ addEdgeLabels(e0, p, q);
+ e0 = ED_to_virt(e0);
+ dumb[1].x += del.x;
+ dumb[1].y += del.y;
+ dumb[2].x += del.x;
+ dumb[2].y += del.y;
+ }
+}
+
+#define LEN(x,y) sqrt((x)*(x)+(y)*(y))
+
+/* makeObstacle:
+ * Given a node, return an obstacle reflecting the
+ * node's geometry. pmargin specifies how much space to allow
+ * around the polygon.
+ * Returns the constructed polygon on success, NULL on failure.
+ * Failure means the node shape is not supported.
+ *
+ * The polygon has its vertices in CW order.
+ *
+ */
+Ppoly_t *makeObstacle(node_t * n, expand_t* pmargin)
+{
+ Ppoly_t *obs;
+ polygon_t *poly;
+ double adj = 0.0;
+ int j, sides;
+ pointf polyp;
+ box b;
+ point pt;
+ field_t *fld;
+ epsf_t *desc;
+
+ switch (shapeOf(n)) {
+ case SH_POLY:
+ case SH_POINT:
+ obs = NEW(Ppoly_t);
+ poly = (polygon_t *) ND_shape_info(n);
+ if (poly->sides >= 3) {
+ sides = poly->sides;
+ } else { /* ellipse */
+ sides = 8;
+ adj = drand48() * .01;
+ }
+ obs->pn = sides;
+ obs->ps = N_NEW(sides, Ppoint_t);
+ /* assuming polys are in CCW order, and pathplan needs CW */
+ for (j = 0; j < sides; j++) {
+ double xmargin = 0.0, ymargin = 0.0;
+ if (poly->sides >= 3) {
+ if (pmargin->doAdd) {
+ if (poly->sides == 4) {
+ switch (j) {
+ case 0 :
+ xmargin = pmargin->x;
+ ymargin = pmargin->y;
+ break;
+ case 1 :
+ xmargin = -pmargin->x;
+ ymargin = pmargin->y;
+ break;
+ case 2 :
+ xmargin = -pmargin->x;
+ ymargin = -pmargin->y;
+ break;
+ case 3 :
+ xmargin = pmargin->x;
+ ymargin = -pmargin->y;
+ break;
+ }
+ polyp.x = poly->vertices[j].x + xmargin;
+ polyp.y = poly->vertices[j].y + ymargin;
+ }
+ else {
+ double h = LEN(poly->vertices[j].x,poly->vertices[j].y);
+ polyp.x = poly->vertices[j].x * (1.0 + pmargin->x/h);
+ polyp.y = poly->vertices[j].y * (1.0 + pmargin->y/h);
+ }
+ }
+ else {
+ polyp.x = poly->vertices[j].x * pmargin->x;
+ polyp.y = poly->vertices[j].y * pmargin->y;
+ }
+ } else {
+ double c, s;
+ c = cos(2.0 * M_PI * j / sides + adj);
+ s = sin(2.0 * M_PI * j / sides + adj);
+ if (pmargin->doAdd) {
+ polyp.x = c*(ND_lw_i(n)+ND_rw_i(n)+pmargin->x) / 2.0;
+ polyp.y = s*(ND_ht_i(n)+pmargin->y) / 2.0;
+ }
+ else {
+ polyp.x = pmargin->x * c * (ND_lw_i(n) + ND_rw_i(n)) / 2.0;
+ polyp.y = pmargin->y * s * ND_ht_i(n) / 2.0;
+ }
+ }
+ obs->ps[sides - j - 1].x = polyp.x + ND_coord_i(n).x;
+ obs->ps[sides - j - 1].y = polyp.y + ND_coord_i(n).y;
+ }
+ break;
+ case SH_RECORD:
+ fld = (field_t *) ND_shape_info(n);
+ b = fld->b;
+ obs = NEW(Ppoly_t);
+ obs->pn = 4;
+ obs->ps = N_NEW(4, Ppoint_t);
+ /* CW order */
+ pt = ND_coord_i(n);
+ if (pmargin->doAdd) {
+ obs->ps[0] = genPt(b.LL.x-pmargin->x, b.LL.y-pmargin->y, pt);
+ obs->ps[1] = genPt(b.LL.x-pmargin->x, b.UR.y+pmargin->y, pt);
+ obs->ps[2] = genPt(b.UR.x+pmargin->x, b.UR.y+pmargin->y, pt);
+ obs->ps[3] = genPt(b.UR.x+pmargin->x, b.LL.y-pmargin->y, pt);
+ }
+ else {
+ obs->ps[0] = recPt(b.LL.x, b.LL.y, pt, pmargin);
+ obs->ps[1] = recPt(b.LL.x, b.UR.y, pt, pmargin);
+ obs->ps[2] = recPt(b.UR.x, b.UR.y, pt, pmargin);
+ obs->ps[3] = recPt(b.UR.x, b.LL.y, pt, pmargin);
+ }
+ break;
+ case SH_EPSF:
+ desc = (epsf_t *) (ND_shape_info(n));
+ obs = NEW(Ppoly_t);
+ obs->pn = 4;
+ obs->ps = N_NEW(4, Ppoint_t);
+ /* CW order */
+ pt = ND_coord_i(n);
+ if (pmargin->doAdd) {
+ obs->ps[0] = genPt(-ND_lw_i(n)-pmargin->x, -ND_ht_i(n)-pmargin->y,pt);
+ obs->ps[1] = genPt(-ND_lw_i(n)-pmargin->x, ND_ht_i(n)+pmargin->y,pt);
+ obs->ps[2] = genPt(ND_rw_i(n)+pmargin->x, ND_ht_i(n)+pmargin->y,pt);
+ obs->ps[3] = genPt(ND_rw_i(n)+pmargin->x, -ND_ht_i(n)-pmargin->y,pt);
+ }
+ else {
+ obs->ps[0] = recPt(-ND_lw_i(n), -ND_ht_i(n), pt, pmargin);
+ obs->ps[1] = recPt(-ND_lw_i(n), ND_ht_i(n), pt, pmargin);
+ obs->ps[2] = recPt(ND_rw_i(n), ND_ht_i(n), pt, pmargin);
+ obs->ps[3] = recPt(ND_rw_i(n), -ND_ht_i(n), pt, pmargin);
+ }
+ break;
+ default:
+ obs = NULL;
+ break;
+ }
+ return obs;
+}
+
+/* getPath
+ * Construct the shortest path from one endpoint of e to the other.
+ * The obstacles and their number are given by obs and npoly.
+ * vconfig is a precomputed data structure to help in the computation.
+ * If chkPts is true, the function finds the polygons, if any, containing
+ * the endpoints and tells the shortest path computation to ignore them.
+ * Assumes this info is set in ND_lim, usually from _spline_edges.
+ * Returns the shortest path.
+ */
+Ppolyline_t
+getPath(edge_t * e, vconfig_t * vconfig, int chkPts, Ppoly_t ** obs,
+ int npoly)
+{
+ Ppolyline_t line;
+ int pp, qp;
+ Ppoint_t p, q;
+ point p1, q1;
+
+ p1 = add_points(ND_coord_i(agtail(e)), ED_tail_port(e).p);
+ q1 = add_points(ND_coord_i(aghead(e)), ED_head_port(e).p);
+ P2PF(p1, p);
+ P2PF(q1, q);
+
+ /* determine the polygons (if any) that contain the endpoints */
+ pp = qp = POLYID_NONE;
+ if (chkPts) {
+ pp = ND_lim(agtail(e));
+ qp = ND_lim(aghead(e));
+/*
+ for (i = 0; i < npoly; i++) {
+ if ((pp == POLYID_NONE) && in_poly(*obs[i], p))
+ pp = i;
+ if ((qp == POLYID_NONE) && in_poly(*obs[i], q))
+ qp = i;
+ }
+*/
+ }
+ Pobspath(vconfig, p, pp, q, qp, &line);
+ return line;
+}
+
+/* makePolyline:
+ */
+static void
+makePolyline(edge_t * e)
+{
+ int i;
+ Ppolyline_t spl, line = ED_path(e);
+ point* ispline;
+ point p1, q1;
+ Ppoint_t p0, q0;
+
+ p0 = line.ps[0];
+ q0 = line.ps[line.pn - 1];
+ make_polyline (line, &spl);
+ ispline = N_GNEW(spl.pn, point);
+ for (i=0; i < spl.pn; i++) {
+ PF2P (spl.ps[i], ispline[i]);
+ }
+
+ if (Verbose > 1)
+ fprintf(stderr, "polyline %s %s\n", agnameof(agtail(e)), agnameof(aghead(e)));
+ clip_and_install(e, aghead(e), ispline, spl.pn, &sinfo);
+ free(ispline);
+ PF2P(p0, p1);
+ PF2P(q0, q1);
+ addEdgeLabels(e, p1, q1);
+}
+
+/* makeSpline:
+ * Construct a spline connecting the endpoints of e, avoiding the npoly
+ * obstacles obs.
+ * The resultant spline is attached to the edge, the positions of any
+ * edge labels are computed, and the graph's bounding box is recomputed.
+ *
+ * If chkPts is true, the function checks if one or both of the endpoints
+ * is on or inside one of the obstacles and, if so, tells the shortest path
+ * computation to ignore them.
+ */
+void makeSpline(edge_t * e, Ppoly_t ** obs, int npoly, boolean chkPts)
+{
+ Ppolyline_t line, spline;
+ Pvector_t slopes[2];
+ int i, n_barriers;
+ int pp, qp;
+ Ppoint_t p, q;
+ point *ispline;
+ Pedge_t *barriers;
+ point p1, q1;
+
+ line = ED_path(e);
+ p = line.ps[0];
+ q = line.ps[line.pn - 1];
+ /* determine the polygons (if any) that contain the endpoints */
+ pp = qp = POLYID_NONE;
+ if (chkPts)
+ for (i = 0; i < npoly; i++) {
+ if ((pp == POLYID_NONE) && in_poly(*obs[i], p))
+ pp = i;
+ if ((qp == POLYID_NONE) && in_poly(*obs[i], q))
+ qp = i;
+ }
+
+ make_barriers(obs, npoly, pp, qp, &barriers, &n_barriers);
+ slopes[0].x = slopes[0].y = 0.0;
+ slopes[1].x = slopes[1].y = 0.0;
+ Proutespline(barriers, n_barriers, line, slopes, &spline);
+
+ /* north why did you ever use int coords */
+ ispline = N_GNEW(spline.pn, point);
+ for (i = 0; i < spline.pn; i++) {
+ ispline[i].x = ROUND(spline.ps[i].x);
+ ispline[i].y = ROUND(spline.ps[i].y);
+ }
+ if (Verbose > 1)
+ fprintf(stderr, "spline %s %s\n", agnameof(agtail(e)),agnameof(aghead(e)));
+ clip_and_install(e, aghead(e), ispline, spline.pn, &sinfo);
+ free(ispline);
+ free(barriers);
+ PF2P(p, p1);
+ PF2P(q, q1);
+ addEdgeLabels(e, p1, q1);
+}
+
+ /* True if either head or tail has a port on its boundary */
+#define BOUNDARY_PORT(e) ((ED_tail_port(e).side)||(ED_head_port(e).side))
+
+/* _spline_edges:
+ * Basic default routine for creating edges.
+ * If splines are requested, we construct the obstacles.
+ * If not, or nodes overlap, the function reverts to line segments.
+ * NOTE: intra-cluster edges are not constrained to
+ * remain in the cluster's bounding box and, conversely, a cluster's box
+ * is not altered to reflect intra-cluster edges.
+ * If Nop > 1 and the spline exists, it is just copied.
+ */
+static int _spline_edges(graph_t * g, expand_t* pmargin, int edgetype)
+{
+ node_t *n;
+ edge_t *e;
+ edge_t *e0;
+ Ppoly_t **obs = 0;
+ Ppoly_t *obp;
+ int cnt, i = 0, npoly;
+ vconfig_t *vconfig = 0;
+ path *P = NULL;
+ int useEdges = (Nop > 1);
+#ifdef ORTHO
+ extern void orthoEdges (Agraph_t* g, int useLbls, splineInfo* sinfo);
+#endif
+ router_t* rtr = 0;
+
+ /* build configuration */
+ if (edgetype != ET_LINE) {
+ obs = N_NEW(agnnodes(g), Ppoly_t *);
+ for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
+ obp = makeObstacle(n, pmargin);
+ if (obp) {
+ ND_lim(n) = i;
+ obs[i++] = obp;
+ }
+ else
+ ND_lim(n) = POLYID_NONE;
+ }
+ } else {
+ obs = 0;
+ }
+ npoly = i;
+ if (obs) {
+ if (Plegal_arrangement(obs, npoly)) {
+ if (edgetype != ET_ORTHO) vconfig = Pobsopen(obs, npoly);
+ }
+ else if (Verbose)
+ fprintf(stderr,
+ "nodes touch - falling back to straight line edges\n");
+ }
+
+ /* route edges */
+ if (Verbose)
+ fprintf(stderr, "Creating edges using %s\n",
+ (edgetype == ET_ORTHO) ? "orthogonal lines" :
+ (vconfig ? (edgetype == ET_SPLINE ? "splines" : "polylines") :
+ "line segments"));
+ if (vconfig) {
+ /* path-finding pass */
+ for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
+ for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
+ ED_path(e) = getPath(e, vconfig, TRUE, obs, npoly);
+ }
+ }
+ }
+#ifdef ORTHO
+ else if (edgetype == ET_ORTHO) {
+ orthoEdges (g, 0, &sinfo);
+ useEdges = 1;
+ }
+#endif
+
+ /* spline-drawing pass */
+ for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
+ for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
+/* fprintf (stderr, "%s -- %s %d\n", e->tail->name, e->head->name, ED_count(e)); */
+ node_t *head = aghead(e);
+ if (useEdges && ED_spl(e)) {
+ addEdgeLabels(e,
+ add_points(ND_coord_i(n), ED_tail_port(e).p),
+ add_points(ND_coord_i(head),
+ ED_head_port(e).p));
+ }
+ else if (ED_count(e) == 0) continue; /* only do representative */
+ else if (n == head) { /* self arc */
+ if (!P) {
+ P = NEW(path);
+ P->boxes = N_NEW(agnnodes(g) + 20 * 2 * 9, box);
+ }
+ makeSelfArcs(P, e, GD_nodesep(g));
+ } else if (vconfig) { /* ET_SPLINE or ET_POLYLINE */
+#ifdef HAVE_GTS
+ if ((ED_count(e) > 1) || BOUNDARY_PORT(e)) {
+ int fail = 0;
+ if ((ED_path(e).pn == 2) && !BOUNDARY_PORT(e))
+ /* if a straight line can connect the ends */
+ makeStraightEdge(g, e, edgetype == ET_PLINE);
+ else {
+ if (!rtr) rtr = mkRouter (obs, npoly);
+ fail = makeMultiSpline(e, rtr, edgetype == ET_PLINE);
+ }
+ if (!fail) continue;
+ }
+ /* We can probably remove this branch and just use
+ * makeMultiSpline. It can also catch the makeStraightEdge
+ * case. We could then eliminate all of the vconfig stuff.
+ */
+#endif
+ cnt = ED_count(e);
+ e0 = e;
+ for (i = 0; i < cnt; i++) {
+ if (edgetype == ET_SPLINE)
+ makeSpline(e0, obs, npoly, TRUE);
+ else
+ makePolyline(e0);
+ e0 = ED_to_virt(e0);
+ }
+ } else {
+ makeStraightEdge(g, e, 0);
+ }
+ }
+ }
+
+#ifdef HAVE_GTS
+ if (rtr)
+ freeRouter (rtr);
+#endif
+
+ if (vconfig)
+ Pobsclose (vconfig);
+ if (P) {
+ free(P->boxes);
+ free(P);
+ }
+ if (obs) {
+ for (i=0; i < npoly; i++)
+ free (obs[i]);
+ free (obs);
+ }
+ return 0;
+}
+
+/* splineEdges:
+ * Main wrapper code for generating edges.
+ * Sets desired separation.
+ * Coalesces equivalent edges (edges * with the same endpoints).
+ * It then calls the edge generating function, and marks the
+ * spline phase complete.
+ * Returns 0 on success.
+ *
+ * The edge function is given the graph, the separation to be added
+ * around obstacles, and the type of edge. It must guarantee
+ * that all bounding boxes are current; in particular, the bounding box of
+ * g must reflect the addition of the edges.
+ */
+int
+splineEdges(graph_t * g, int (*edgefn) (graph_t *, expand_t*, int),
+ int edgetype)
+{
+ node_t *n;
+ edge_t *e;
+ expand_t margin;
+ Dt_t *map;
+
+ margin = esepFactor (g);
+
+ /* find equivalent edges */
+ map = dtopen(&edgeItemDisc, Dtoset);
+ for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
+ for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
+ edge_t *leader = equivEdge(map, e);
+ if (leader != e) {
+ ED_count(leader)++;
+ ED_to_virt(e) = ED_to_virt(leader);
+ ED_to_virt(leader) = e;
+ }
+ }
+ }
+ dtclose(map);
+
+ if (edgefn(g, &margin, edgetype))
+ return 1;
+
+ State = GVSPLINES;
+ return 0;
+}
+
+/* spline_edges1:
+ * Construct edges using default algorithm and given splines value.
+ * Return 0 on success.
+ */
+int spline_edges1(graph_t * g, int edgetype)
+{
+ return splineEdges(g, _spline_edges, edgetype);
+}
+
+/* spline_edges0:
+ * Sets the graph's aspect ratio.
+ * Check splines attribute and construct edges using default algorithm.
+ * If the splines attribute is defined but equal to "", skip edge routing.
+ *
+ * Assumes u.bb for has been computed for g and all clusters
+ * (not just top-level clusters), and that GD_bb(g).LL is at the origin.
+ *
+ * This last criterion is, I believe, mainly to simplify the code
+ * in neato_set_aspect. It would be good to remove this constraint,
+ * as this would allow nodes pinned on input to have the same coordinates
+ * when output in dot or plain format.
+ *
+ */
+void spline_edges0(graph_t * g)
+{
+ int et = EDGE_TYPE (agroot(g));
+ neato_set_aspect(g);
+ if (et == ET_NONE) return;
+#ifndef ORTHO
+ if (et == ET_ORTHO) {
+ agerr (AGWARN, "Orthogonal edges not yet supported\n");
+ et = ET_PLINE;
+ GD_flags(agroot(g)) &= ~ET_ORTHO;
+ GD_flags(agroot(g)) |= ET_PLINE;
+ }
+#endif
+ spline_edges1(g, et);
+}
+
+/* spline_edges:
+ * Compute bounding box, translate graph to origin,
+ * then construct all edges. We assume the graph
+ * has no clusters, and only nodes have been
+ * positioned.
+ */
+void spline_edges(graph_t * g)
+{
+ node_t *n;
+ pointf offset;
+
+ compute_bb(g);
+ offset = cvt2ptf(GD_bb(g).LL);
+ for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
+ ND_pos(n)[0] -= offset.x;
+ ND_pos(n)[1] -= offset.y;
+ }
+ GD_bb(g).UR.x -= GD_bb(g).LL.x;
+ GD_bb(g).UR.y -= GD_bb(g).LL.y;
+ GD_bb(g).LL.x = 0;
+ GD_bb(g).LL.y = 0;
+ spline_edges0(g);
+}
+
+/* scaleEdge:
+ * Scale edge by given factor.
+ * Assume ED_spl != NULL.
+ */
+static void scaleEdge(edge_t * e, double xf, double yf)
+{
+ int i, j;
+ point *pt;
+ bezier *bez;
+ point delh, delt;
+
+ delh.x = POINTS(ND_pos(aghead(e))[0] * (xf - 1.0));
+ delh.y = POINTS(ND_pos(aghead(e))[1] * (yf - 1.0));
+ delt.x = POINTS(ND_pos(agtail(e))[0] * (xf - 1.0));
+ delt.y = POINTS(ND_pos(agtail(e))[1] * (yf - 1.0));
+
+ bez = ED_spl(e)->list;
+ for (i = 0; i < ED_spl(e)->size; i++) {
+ pt = bez->list;
+ for (j = 0; j < bez->size; j++) {
+ if ((i == 0) && (j == 0)) {
+ pt->x += delt.x;
+ pt->y += delt.y;
+ }
+ else if ((i == ED_spl(e)->size-1) && (j == bez->size-1)) {
+ pt->x += delh.x;
+ pt->y += delh.y;
+ }
+ else {
+ pt->x *= xf;
+ pt->y *= yf;
+ }
+ pt++;
+ }
+ if (bez->sflag) {
+ bez->sp.x += delt.x;
+ bez->sp.y += delt.y;
+ }
+ if (bez->eflag) {
+ bez->ep.x += delh.x;
+ bez->ep.y += delh.y;
+ }
+ bez++;
+ }
+
+ if (ED_label(e) && ED_label(e)->set) {
+ ED_label(e)->p.x *= xf;
+ ED_label(e)->p.y *= yf;
+ }
+ if (ED_head_label(e) && ED_head_label(e)->set) {
+ ED_head_label(e)->p.x += delh.x;
+ ED_head_label(e)->p.y += delh.y;
+ }
+ if (ED_tail_label(e) && ED_tail_label(e)->set) {
+ ED_tail_label(e)->p.x += delt.x;
+ ED_tail_label(e)->p.y += delt.y;
+ }
+}
+
+/* scaleBB:
+ * Scale bounding box of clusters of g by given factors.
+ */
+static void scaleBB(graph_t * g, double xf, double yf)
+{
+ int i;
+
+ GD_bb(g).UR.x *= xf;
+ GD_bb(g).UR.y *= yf;
+ GD_bb(g).LL.x *= xf;
+ GD_bb(g).LL.y *= yf;
+
+ if (GD_label(g) && GD_label(g)->set) {
+ GD_label(g)->p.x *= xf;
+ GD_label(g)->p.y *= yf;
+ }
+
+ for (i = 1; i <= GD_n_cluster(g); i++)
+ scaleBB(GD_clust(g)[i], xf, yf);
+}
+
+/* _neato_set_aspect;
+ * Assume all bounding boxes are correct and
+ * that GD_bb(g).LL is at origin.
+ */
+static void _neato_set_aspect(graph_t * g)
+{
+ /* int i; */
+ double xf, yf, actual, desired;
+ node_t *n;
+
+ /* compute_bb(g); */
+ if (GD_drawing(g)->ratio_kind) {
+ /* normalize */
+ assert(GD_bb(g).LL.x == 0);
+ assert(GD_bb(g).LL.y == 0);
+ if (GD_flip(g)) {
+ int t = GD_bb(g).UR.x;
+ GD_bb(g).UR.x = GD_bb(g).UR.y;
+ GD_bb(g).UR.y = t;
+ }
+ if (GD_drawing(g)->ratio_kind == R_FILL) {
+ /* fill is weird because both X and Y can stretch */
+ if (GD_drawing(g)->size.x <= 0)
+ return;
+ xf = (double) GD_drawing(g)->size.x / (double) GD_bb(g).UR.x;
+ yf = (double) GD_drawing(g)->size.y / (double) GD_bb(g).UR.y;
+ /* handle case where one or more dimensions is too big */
+ if ((xf < 1.0) || (yf < 1.0)) {
+ if (xf < yf) {
+ yf = yf / xf;
+ xf = 1.0;
+ } else {
+ xf = xf / yf;
+ yf = 1.0;
+ }
+ }
+ } else if (GD_drawing(g)->ratio_kind == R_EXPAND) {
+ if (GD_drawing(g)->size.x <= 0)
+ return;
+ xf = (double) GD_drawing(g)->size.x / (double) GD_bb(g).UR.x;
+ yf = (double) GD_drawing(g)->size.y / (double) GD_bb(g).UR.y;
+ if ((xf > 1.0) && (yf > 1.0)) {
+ double scale = MIN(xf, yf);
+ xf = yf = scale;
+ } else
+ return;
+ } else if (GD_drawing(g)->ratio_kind == R_VALUE) {
+ desired = GD_drawing(g)->ratio;
+ actual = ((double) GD_bb(g).UR.y) / ((double) GD_bb(g).UR.x);
+ if (actual < desired) {
+ yf = desired / actual;
+ xf = 1.0;
+ } else {
+ xf = actual / desired;
+ yf = 1.0;
+ }
+ } else
+ return;
+ if (GD_flip(g)) {
+ double t = xf;
+ xf = yf;
+ yf = t;
+ }
+
+ if (Nop > 1) {
+ edge_t *e;
+ for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
+ for (e = agfstout(g, n); e; e = agnxtout(g, e))
+ if (ED_spl(e))
+ scaleEdge(e, xf, yf);
+ }
+ }
+ /* Not relying on neato_nlist here allows us not to have to
+ * allocate it in the root graph and the connected components.
+ */
+ for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
+ ND_pos(n)[0] = ND_pos(n)[0] * xf;
+ ND_pos(n)[1] = ND_pos(n)[1] * yf;
+ }
+ scaleBB(g, xf, yf);
+ }
+}
+
+/* neato_set_aspect:
+ * Sets aspect ratio if necessary; real work done in _neato_set_aspect;
+ * This also copies the internal layout coordinates (ND_pos) to the
+ * external ones (ND_coord_i).
+ */
+void neato_set_aspect(graph_t * g)
+{
+ node_t *n;
+
+ _neato_set_aspect(g);
+ for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
+ ND_coord_i(n).x = POINTS(ND_pos(n)[0]);
+ ND_coord_i(n).y = POINTS(ND_pos(n)[1]);
+ }
+}
+#else
+/*****CGRAPH BLOCK*/
static void makePortLabels(edge_t * e)
{
if (ED_head_label(e) && !ED_head_label(e)->set) {
}
}
+#endif //end of graph libpicking
projects / graphviz / commitdiff