Add new overlap removal mode "ortho"; use as default for fdp.

diff --git a/lib/fdpgen/xlayout.c b/lib/fdpgen/xlayout.c
index 92ba80d640f8f7b2ab6bfcc17307a155685d925e..fe45c50a7e0c55e049afc5bf14074d4c9724c0e7 100644 (file)
--- a/lib/fdpgen/xlayout.c
+++ b/lib/fdpgen/xlayout.c
@@ -42,7 +42,7 @@ Increase less between tries
 /* #define ORIG      */
 #define BOX    /* Use bbox to determine overlap, else use circles */
 
-#define DFLT_overlap   "scale"    /* default overlap value */
+#define DFLT_overlap   "9:ortho"    /* default overlap value */
 
 #define WD2(n) ((ND_width(n))*X_fact)
 #define HT2(n) ((ND_height(n))*X_fact)
@@ -98,7 +98,6 @@ static void xinit_params(graph_t* g, int n, xparams * xpms)
 #define X_loopcnt    xParams.loopcnt
 #define X_C          xParams.C
 
-#define DFLT_tries 9
 
 static double cool(int t)
 {
@@ -509,7 +508,8 @@ static int x_layout(graph_t * g, xparams * pxpms, int tries)
  * x_layout to remove overlaps.
  * Thus,
  *  NULL or ""  => dflt overlap
- *  "mode"      => dflt tries, then removeOverlap with mode
+ *  "mode"      => "0:mode", i.e. removeOverlap with mode only
+ *  "true"      => "0:true", i.e., no overlap removal
  *  "n:"        => n tries only
  *  "n:mode"    => n tries, then removeOverlap with mode
  *  "0:"        => no overlap removal
@@ -537,7 +537,7 @@ void fdp_xLayout(graph_t * g, xparams * xpms)
       if (tries < 0) tries = 0;
     }
     else {
-      tries = DFLT_tries;
+      tries = 0;
       rest = ovlp;
     }
     if (Verbose) {

diff --git a/lib/neatogen/adjust.c b/lib/neatogen/adjust.c
index ee3c787ddd5c236816d198353a9682b3181b1afa..39a1f04779841249d04834fa9744700cce99e080 100644 (file)
--- a/lib/neatogen/adjust.c
+++ b/lib/neatogen/adjust.c
@@ -679,10 +679,6 @@ void normalize(graph_t * g)
     }
 }
 
-typedef enum {
-    AM_NONE, AM_VOR, AM_SCALE, AM_NSCALE, AM_SCALEXY, AM_PUSH, AM_PUSHPULL,
-    AM_ORTHOXY, AM_ORTHOYX, AM_COMPRESS
-} adjust_mode;
 typedef struct {
     adjust_mode mode;
     char *attrib;
@@ -696,6 +692,7 @@ static adjust_data adjustMode[] = {
     {AM_SCALEXY, "scalexy", "x and y scaling"},
     /* {AM_PUSH, "push", "push scan adjust"}, */
     /* {AM_PUSHPULL, "pushpull", "push-pull scan adjust"}, */
+    {AM_ORTHO, "ortho", "orthogonal constraints"},
     {AM_ORTHOXY, "orthoxy", "xy orthogonal constraints"},
     {AM_ORTHOYX, "orthoyx", "yx orthogonal constraints"},
     {AM_COMPRESS, "compress", "compress"},
@@ -730,8 +727,6 @@ removeOverlapAs(graph_t * G, char* flag)
 {
     /* int          userWindow = 0; */
     int ret;
-    extern void cAdjust(graph_t *, int);
-    extern void scAdjust(graph_t *, int);
     /* extern void  scanAdjust(graph_t*, int); */
 
     adjust_data *am;
@@ -763,11 +758,14 @@ removeOverlapAs(graph_t * G, char* flag)
        case AM_PUSHPULL:
            /* scanAdjust (G, 0); */
            break;
+       case AM_ORTHO:
+           cAdjust(G, AM_ORTHO);
+           break;
        case AM_ORTHOXY:
-           cAdjust(G, 1);
+           cAdjust(G, AM_ORTHOXY);
            break;
        case AM_ORTHOYX:
-           cAdjust(G, 0);
+           cAdjust(G, AM_ORTHOYX);
            break;
        case AM_COMPRESS:
            scAdjust(G, -1);

diff --git a/lib/neatogen/adjust.h b/lib/neatogen/adjust.h
index 5b41685f919b184dbe7904c8f4a84adeab2c98ec..5b5db360595315b82628b9208246dfe457d996de 100644 (file)
--- a/lib/neatogen/adjust.h
+++ b/lib/neatogen/adjust.h
@@ -23,11 +23,18 @@
 extern "C" {
 #endif
 
+typedef enum {
+    AM_NONE, AM_VOR, AM_SCALE, AM_NSCALE, AM_SCALEXY, AM_PUSH, AM_PUSHPULL,
+    AM_ORTHO, AM_ORTHOXY, AM_ORTHOYX, AM_COMPRESS
+} adjust_mode;
+
     extern double expFactor(graph_t * G);
     extern void adjustNodes(graph_t * G);
     extern void normalize(graph_t * g);
     extern void removeOverlap(graph_t * G);
     extern void removeOverlapAs(graph_t*, char*);
+    extern void cAdjust(graph_t *, int);
+    extern void scAdjust(graph_t *, int);
 
 #ifdef __cplusplus
 }

diff --git a/lib/neatogen/constraint.c b/lib/neatogen/constraint.c
index a3eda101dea431c9e39dca9bb5861bf9a5b88003..3d83ffadd779e6a94d5790e5a9fdb15e8723b0ed 100644 (file)
--- a/lib/neatogen/constraint.c
+++ b/lib/neatogen/constraint.c
@@ -22,7 +22,8 @@
 #include "neato.h"
 #include "adjust.h"
 
-#define SCALE 10
+/* For precision, scale up before algorithms, then scale down */
+#define SCALE 10   
 #define SCALE2 (SCALE/2)
 
 typedef struct nitem {
@@ -58,26 +59,50 @@ static Dtdisc_t constr = {
     NIL(Dtevent_f)
 };
 
-static int intersectY(nitem * p, nitem * q)
+static int distY(box * b1, box * b2)
 {
-    return ((p->bb.LL.y <= q->bb.UR.y) && (q->bb.LL.y <= p->bb.UR.y));
+    return ((b1->UR.y - b1->LL.y) + (b2->UR.y - b2->LL.y)) / 2;
 }
 
-static int intersectX(nitem * p, nitem * q)
+static int distX(box * b1, box * b2)
 {
-    return ((p->bb.LL.x <= q->bb.UR.x) && (q->bb.LL.x <= p->bb.UR.x));
+    return ((b1->UR.x - b1->LL.x) + (b2->UR.x - b2->LL.x)) / 2;
 }
 
-static int distY(box * b1, box * b2)
+/* intersectY0:
+ * Return true if boxes could overlap if shifted in x but don't,
+ * or if actually overlap and an x move is smallest to remove overlap.
+ * Otherwise (no y overlap or a y move is smaller), return false.
+ * Assume q pos to right of p pos.
+ */
+static int intersectY0(nitem * p, nitem * q)
 {
-    return ((b1->UR.y - b1->LL.y) + (b2->UR.y - b2->LL.y)) / 2;
+    int xdelta, ydelta;
+    int v = ((p->bb.LL.y <= q->bb.UR.y) && (q->bb.LL.y <= p->bb.UR.y));
+    if (v == 0)  /* no y overlap */
+       return 0;
+    if (p->bb.UR.x < q->bb.LL.x) /* but boxes don't really overlap */
+       return 1;
+    xdelta = distX(&p->bb,&q->bb) - (q->pos.x - p->pos.x);
+    if (q->pos.y >= p->pos.y) 
+       ydelta = distY(&p->bb,&q->bb) - (q->pos.y - p->pos.y); 
+    else
+       ydelta = distY(&p->bb,&q->bb) - (p->pos.y - q->pos.y); 
+    return (xdelta <= ydelta);
 }
 
-static int distX(box * b1, box * b2)
+static int intersectY(nitem * p, nitem * q)
 {
-    return ((b1->UR.x - b1->LL.x) + (b2->UR.x - b2->LL.x)) / 2;
+    return ((p->bb.LL.y <= q->bb.UR.y) && (q->bb.LL.y <= p->bb.UR.y));
+}
+
+static int intersectX(nitem * p, nitem * q)
+{
+    return ((p->bb.LL.x <= q->bb.UR.x) && (q->bb.LL.x <= p->bb.UR.x));
 }
 
+/* mapGraphs:
+ */
 static void mapGraphs(graph_t * g, graph_t * cg, distfn dist)
 {
     node_t *n;
@@ -119,6 +144,8 @@ static node_t *newNode(graph_t * g)
 }
 #endif
 
+/* mkConstraintG:
+ */
 static graph_t *mkConstraintG(graph_t * g, Dt_t * list,
                              intersectfn intersect, distfn dist)
 {
@@ -273,7 +300,12 @@ static void closeGraph(graph_t * cg)
     agclose(cg);
 }
 
-static void constrainX(graph_t * g, nitem * nlist, int nnodes)
+/* constrainX:
+ * Create the X constrains and solve. We use a linear objective function
+ * (absolute values rather than squares), so we can reuse network simplex.
+ * The constraints are encoded as a dag with edges having a minimum length.
+ */
+static void constrainX(graph_t * g, nitem * nlist, int nnodes, intersectfn ifn)
 {
     Dt_t *list = dtopen(&constr, Dtobag);
     nitem *p = nlist;
@@ -285,7 +317,7 @@ static void constrainX(graph_t * g, nitem * nlist, int nnodes)
        dtinsert(list, p);
        p++;
     }
-    cg = mkConstraintG(g, list, intersectY, distX);
+    cg = mkConstraintG(g, list, ifn, distX);
     rank(cg, 2, MAXINT);
 
     p = nlist;
@@ -304,7 +336,10 @@ static void constrainX(graph_t * g, nitem * nlist, int nnodes)
     dtclose(list);
 }
 
-static void constrainY(graph_t * g, nitem * nlist, int nnodes)
+/* constrainY:
+ * See constrainX.
+ */
+static void constrainY(graph_t * g, nitem * nlist, int nnodes, intersectfn ifn)
 {
     Dt_t *list = dtopen(&constr, Dtobag);
     nitem *p = nlist;
@@ -316,7 +351,7 @@ static void constrainY(graph_t * g, nitem * nlist, int nnodes)
        dtinsert(list, p);
        p++;
     }
-    cg = mkConstraintG(g, list, intersectX, distY);
+    cg = mkConstraintG(g, list, ifn, distY);
     rank(cg, 2, MAXINT);
 #ifdef DEBUG
     {
@@ -356,6 +391,8 @@ static void constrainY(graph_t * g, nitem * nlist, int nnodes)
   ((pb.LL.x <= qb.UR.x) && (qb.LL.x <= pb.UR.x) && \
           (pb.LL.y <= qb.UR.y) && (qb.LL.y <= pb.UR.y))
 
+/* overlaps:
+ */
 static int overlaps(nitem * p, int cnt)
 {
     int i, j;
@@ -374,6 +411,8 @@ static int overlaps(nitem * p, int cnt)
     return 0;
 }
 
+/* initItem:
+ */
 static void initItem(node_t * n, nitem * p, double margin)
 {
     int x = POINTS(SCALE * ND_pos(n)[0]);
@@ -401,8 +440,26 @@ static void initItem(node_t * n, nitem * p, double margin)
  *     constraint could move both x and y away, or the smallest, or some
  *     mixture.
  *  - follow by a scale down using actual shapes
+ * We use an optimization based on Marriott, Stuckey, Tam and He,
+ * "Removing Node Overlapping in Graph Layout Using Constrained Optimization",
+ * Constraints,8(2):143--172, 2003.
+ * We solve 2 constraint problem, one in X, one in Y. In each dimension,
+ * we require relative positions to remain the same. That is, if two nodes
+ * have the same x originally, they have the same x at the end, and if one
+ * node is to the left of another, it remains to the left. In addition, if
+ * two nodes could overlap by moving their X coordinates, we insert a constraint * to keep the two nodes sufficiently apart. Similarly, for Y.
+ * 
+ * mode = AM_ORTHOXY => first X, then Y
+ * mode = AM_ORTHOYX => first Y, then X
+ * mode = AM_ORTHO   => first X, then Y
+ * In the last case, relax the constraints as follows: during the X pass,
+ * if two nodes actually intersect and a smaller move in the Y direction
+ * will remove the overlap, we don't force the nodes apart in the X direction,
+ * but leave it for the Y pass to remove any remaining overlaps. Without this,
+ * the X pass will remove all overlaps, and the Y pass only compresses in the
+ * Y direction, causing a skewing of the aspect ratio.
  */
-void cAdjust(graph_t * g, int xy)
+void cAdjust(graph_t * g, int mode)
 {
     double margin;
     int i, nnodes = agnnodes(g);
@@ -420,12 +477,19 @@ void cAdjust(graph_t * g, int xy)
     if (overlaps(nlist, nnodes)) {
        point pt;
 
-       if (xy) {
-           constrainX(g, nlist, nnodes);
-           constrainY(g, nlist, nnodes);
-       } else {
-           constrainY(g, nlist, nnodes);
-           constrainX(g, nlist, nnodes);
+       switch ((adjust_mode)mode) {
+       case AM_ORTHOXY:
+           constrainX(g, nlist, nnodes, intersectY);
+           constrainY(g, nlist, nnodes, intersectX);
+           break;
+       case AM_ORTHOYX:
+           constrainY(g, nlist, nnodes, intersectX);
+           constrainX(g, nlist, nnodes, intersectY);
+           break;
+       default :
+           constrainX(g, nlist, nnodes, intersectY0);
+           constrainY(g, nlist, nnodes, intersectX);
+           break;
        }
        p = nlist;
        for (i = 0; i < nnodes; i++) {
@@ -598,6 +662,16 @@ static double computeScale(pointf * aarr, int m)
     return sc;
 }
 
+/* scAdjust:
+ * Scale the layout.
+ * equal > 0  => scale uniformly in x and y to remove overlaps
+ * equal = 0  => scale separately in x and y to remove overlaps
+ * equal < 0  => scale down uniformly in x and y to remove excess space
+ * The last assumes there are no overlaps at present.
+ * Based on Marriott, Stuckey, Tam and He,
+ * "Removing Node Overlapping in Graph Layout Using Constrained Optimization",
+ * Constraints,8(2):143--172, 2003.
+ */
 void scAdjust(graph_t * g, int equal)
 {
     int nnodes = agnnodes(g);