Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
gen.lib.dotgen.dotsplines__c Maven / Gradle / Ivy
/* ========================================================================
* PlantUML : a free UML diagram generator
* ========================================================================
*
* Project Info: http://plantuml.com
*
* If you like this project or if you find it useful, you can support us at:
*
* http://plantuml.com/patreon (only 1$ per month!)
* http://plantuml.com/paypal
*
* This file is part of Smetana.
* Smetana is a partial translation of Graphviz/Dot sources from C to Java.
*
* (C) Copyright 2009-2022, Arnaud Roques
*
* This translation is distributed under the same Licence as the original C program:
*
*************************************************************************
* Copyright (c) 2011 AT&T Intellectual Property
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors: See CVS logs. Details at http://www.graphviz.org/
*************************************************************************
*
* THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
* LICENSE ("AGREEMENT"). [Eclipse Public License - v 1.0]
*
* ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES
* RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
*
* You may obtain a copy of the License at
*
* http://www.eclipse.org/legal/epl-v10.html
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package gen.lib.dotgen;
import static gen.lib.cgraph.edge__c.agfstout;
import static gen.lib.cgraph.edge__c.aghead;
import static gen.lib.cgraph.edge__c.agnxtout;
import static gen.lib.cgraph.edge__c.agtail;
import static gen.lib.cgraph.node__c.agfstnode;
import static gen.lib.cgraph.node__c.agnxtnode;
import static gen.lib.cgraph.obj__c.agraphof;
import static gen.lib.common.routespl__c.makeStraightEdge;
import static gen.lib.common.routespl__c.routepolylines;
import static gen.lib.common.routespl__c.routesplines;
import static gen.lib.common.routespl__c.routesplinesinit;
import static gen.lib.common.routespl__c.routesplinesterm;
import static gen.lib.common.routespl__c.simpleSplineRoute;
import static gen.lib.common.splines__c.add_box;
import static gen.lib.common.splines__c.beginpath;
import static gen.lib.common.splines__c.clip_and_install;
import static gen.lib.common.splines__c.endpath;
import static gen.lib.common.splines__c.getsplinepoints;
import static gen.lib.common.splines__c.makeSelfEdge;
import static gen.lib.common.utils__c.updateBB;
import static gen.lib.dotgen.cluster__c.mark_lowclusters;
import static h.ST_pointf.add_pointf;
import static h.ST_pointf.pointfof;
import static smetana.core.JUtils.EQ;
import static smetana.core.JUtils.LOG2;
import static smetana.core.JUtils.NEQ;
import static smetana.core.JUtils.qsort1;
import static smetana.core.Macro.ABS;
import static smetana.core.Macro.AGSEQ;
import static smetana.core.Macro.BETWEEN;
import static smetana.core.Macro.BOTTOM;
import static smetana.core.Macro.EDGETYPEMASK;
import static smetana.core.Macro.EDGE_LABEL;
import static smetana.core.Macro.ED_adjacent;
import static smetana.core.Macro.ED_edge_type;
import static smetana.core.Macro.ED_head_port;
import static smetana.core.Macro.ED_label;
import static smetana.core.Macro.ED_spl;
import static smetana.core.Macro.ED_tail_port;
import static smetana.core.Macro.ED_to_orig;
import static smetana.core.Macro.ED_to_virt;
import static smetana.core.Macro.ED_tree_index;
import static smetana.core.Macro.ET_CURVED;
import static smetana.core.Macro.ET_LINE;
import static smetana.core.Macro.ET_NONE;
import static smetana.core.Macro.ET_SPLINE;
import static smetana.core.Macro.FLATEDGE;
import static smetana.core.Macro.FLATORDER;
import static smetana.core.Macro.GD_bb;
import static smetana.core.Macro.GD_flags;
import static smetana.core.Macro.GD_flip;
import static smetana.core.Macro.GD_has_labels;
import static smetana.core.Macro.GD_maxrank;
import static smetana.core.Macro.GD_minrank;
import static smetana.core.Macro.GD_nlist;
import static smetana.core.Macro.GD_nodesep;
import static smetana.core.Macro.GD_rank;
import static smetana.core.Macro.GD_ranksep;
import static smetana.core.Macro.GVSPLINES;
import static smetana.core.Macro.IGNORED;
import static smetana.core.Macro.MAKEFWDEDGE;
import static smetana.core.Macro.MAX;
import static smetana.core.Macro.MIN;
import static smetana.core.Macro.M_PI;
import static smetana.core.Macro.N;
import static smetana.core.Macro.ND_alg;
import static smetana.core.Macro.ND_clust;
import static smetana.core.Macro.ND_coord;
import static smetana.core.Macro.ND_flat_out;
import static smetana.core.Macro.ND_ht;
import static smetana.core.Macro.ND_in;
import static smetana.core.Macro.ND_label;
import static smetana.core.Macro.ND_lw;
import static smetana.core.Macro.ND_mval;
import static smetana.core.Macro.ND_next;
import static smetana.core.Macro.ND_node_type;
import static smetana.core.Macro.ND_order;
import static smetana.core.Macro.ND_other;
import static smetana.core.Macro.ND_out;
import static smetana.core.Macro.ND_rank;
import static smetana.core.Macro.ND_rw;
import static smetana.core.Macro.NORMAL;
import static smetana.core.Macro.NOTI;
import static smetana.core.Macro.REGULAREDGE;
import static smetana.core.Macro.ROUND;
import static smetana.core.Macro.UNSUPPORTED;
import static smetana.core.Macro.VIRTUAL;
import static smetana.core.debug.SmetanaDebug.ENTERING;
import static smetana.core.debug.SmetanaDebug.LEAVING;
import gen.annotation.Difficult;
import gen.annotation.Original;
import gen.annotation.Reviewed;
import gen.annotation.Unused;
import h.ST_Agedge_s;
import h.ST_Agedgeinfo_t;
import h.ST_Agedgepair_s;
import h.ST_Agnode_s;
import h.ST_Agraph_s;
import h.ST_Ppoly_t;
import h.ST_bezier;
import h.ST_boxf;
import h.ST_path;
import h.ST_pathend_t;
import h.ST_pointf;
import h.ST_port;
import h.ST_rank_t;
import h.ST_spline_info_t;
import h.ST_splines;
import smetana.core.CArray;
import smetana.core.CArrayOfStar;
import smetana.core.CFunction;
import smetana.core.CFunctionAbstract;
import smetana.core.Memory;
import smetana.core.Z;
import smetana.core.__ptr__;
public class dotsplines__c {
//3 1vvsta5i8of59frav6uymguav
// static inline boxf boxfof(double llx, double lly, double urx, double ury)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="boxfof", key="1vvsta5i8of59frav6uymguav", definition="static inline boxf boxfof(double llx, double lly, double urx, double ury)")
public static ST_boxf boxfof(double llx, double lly, double urx, double ury) {
// WARNING!! STRUCT
return boxfof_w_(llx, lly, urx, ury).copy();
}
private static ST_boxf boxfof_w_(double llx, double lly, double urx, double ury) {
ENTERING("1vvsta5i8of59frav6uymguav","boxfof");
try {
final ST_boxf b = new ST_boxf();
b.LL.x = llx;
b.LL.y = lly;
b.UR.x = urx;
b.UR.y = ury;
return b;
} finally {
LEAVING("1vvsta5i8of59frav6uymguav","boxfof");
}
}
//3 dobhmc46zwtvv8rg3ywntl91j
// static edge_t* getmainedge(edge_t * e)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="getmainedge", key="dobhmc46zwtvv8rg3ywntl91j", definition="static edge_t* getmainedge(edge_t * e)")
public static ST_Agedge_s getmainedge(ST_Agedge_s e) {
ENTERING("dobhmc46zwtvv8rg3ywntl91j","getmainedge");
try {
ST_Agedge_s le = e;
while (ED_to_virt(le)!=null)
le = ED_to_virt(le);
while (ED_to_orig(le)!=null)
le = ED_to_orig(le);
return le;
} finally {
LEAVING("dobhmc46zwtvv8rg3ywntl91j","getmainedge");
}
}
public static CFunction spline_merge = new CFunctionAbstract("spline_merge") {
public Object exe(Object... args) {
return spline_merge((ST_Agnode_s)args[0]);
}};
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="spline_merge", key="ddeny5ht7w8b16ztj5zt840ld", definition="static boolean spline_merge(node_t * n)")
public static boolean spline_merge(ST_Agnode_s n) {
ENTERING("ddeny5ht7w8b16ztj5zt840ld","spline_merge");
try {
return ((ND_node_type(n) == 1)
&& ((ND_in(n).size > 1) || (ND_out(n).size > 1)));
} finally {
LEAVING("ddeny5ht7w8b16ztj5zt840ld","spline_merge");
}
}
public static CFunction swap_ends_p = new CFunctionAbstract("swap_ends_p") {
public Object exe(Object... args) {
return swap_ends_p((ST_Agedge_s)args[0]);
}};
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="swap_ends_p", key="36ofw2qfqlh5ci8gc8cfkqgg3", definition="static boolean swap_ends_p(edge_t * e)")
public static boolean swap_ends_p(ST_Agedge_s e) {
ENTERING("36ofw2qfqlh5ci8gc8cfkqgg3","swap_ends_p");
try {
while (ED_to_orig(e)!=null)
e = ED_to_orig(e);
if (ND_rank(aghead(e)) > ND_rank(agtail(e)))
return false;
if (ND_rank(aghead(e)) < ND_rank(agtail(e)))
return true;
if (ND_order(aghead(e)) >= ND_order(agtail(e)))
return false;
return true;
} finally {
LEAVING("36ofw2qfqlh5ci8gc8cfkqgg3","swap_ends_p");
}
}
//3 3krohso3quojiv4fveh1en7o6
// int portcmp(port p0, port p1)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="portcmp", key="3krohso3quojiv4fveh1en7o6", definition="int portcmp(port p0, port p1)")
public static int portcmp(final ST_port p0, final ST_port p1) {
// WARNING!! STRUCT
return portcmp_w_(p0.copy(), p1.copy());
}
private static int portcmp_w_(final ST_port p0, final ST_port p1) {
ENTERING("3krohso3quojiv4fveh1en7o6","portcmp");
try {
int rv;
if (p1.defined == false)
return (p0.defined ? 1 : 0);
if (p0.defined == false)
return -1;
rv = (int) (p0.p.x - p1.p.x);
if (rv == 0)
rv = (int) (p0.p.y - p1.p.y);
return rv;
} finally {
LEAVING("3krohso3quojiv4fveh1en7o6","portcmp");
}
}
//3 10wbtt4gwnxgqutinpj4ymjpk
// static void swap_bezier(bezier * old, bezier * new)
@Unused
@Difficult
@Reviewed(when = "16/11/2020")
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="swap_bezier", key="10wbtt4gwnxgqutinpj4ymjpk", definition="static void swap_bezier(bezier * old, bezier * new)")
public static void swap_bezier(CArray old, CArray new_) {
ENTERING("10wbtt4gwnxgqutinpj4ymjpk","swap_bezier");
try {
CArray list;
CArray lp;
CArray olp;
int i, sz;
sz = old.get__(0).size;
list = CArray.ALLOC__(sz, ST_pointf.class);
lp = list;
olp = old.get__(0).list.plus_(sz - 1);
for (i = 0; i < sz; i++) { /* reverse list of points */
lp.get__(0).___(olp.get__(0));
lp=lp.plus_(1);
olp=olp.plus_(-1);
}
new_.get__(0).list = list;
new_.get__(0).size = sz;
new_.get__(0).sflag = old.get__(0).eflag;
new_.get__(0).eflag = old.get__(0).sflag;
new_.get__(0).sp.___(old.get__(0).ep);
new_.get__(0).ep.___(old.get__(0).sp);
} finally {
LEAVING("10wbtt4gwnxgqutinpj4ymjpk","swap_bezier");
}
}
//3 3256l3e2huarsy29dd97vqj85
// static void swap_spline(splines * s)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="swap_spline", key="3256l3e2huarsy29dd97vqj85", definition="static void swap_spline(splines * s)")
public static void swap_spline(ST_splines s) {
ENTERING("3256l3e2huarsy29dd97vqj85","swap_spline");
try {
CArray list;
CArray lp;
CArray olp;
int i, sz;
sz = s.size;
list = CArray.ALLOC__(sz, ST_bezier.class);
//list = new CStar(sz, ST_bezier.class);
lp = list;
olp = s.list.plus_(sz - 1);
for (i = 0; i < sz; i++) { /* reverse and swap list of beziers */
swap_bezier(olp, lp);
olp = olp.plus_(-1);
lp = lp.plus_(1);
}
/* free old structures */
for (i = 0; i < sz; i++)
Memory.free(s.list.get__(i).list);
Memory.free(s.list);
s.list = list;
} finally {
LEAVING("3256l3e2huarsy29dd97vqj85","swap_spline");
}
}
//3 dgkssqjj566ifra0xy7m46qsb
// static void edge_normalize(graph_t * g)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="edge_normalize", key="dgkssqjj566ifra0xy7m46qsb", definition="static void edge_normalize(graph_t * g)")
public static void edge_normalize(ST_Agraph_s g) {
ENTERING("dgkssqjj566ifra0xy7m46qsb","edge_normalize");
try {
ST_Agedge_s e;
ST_Agnode_s n;
for (n = agfstnode(g); n!=null; n = agnxtnode(g, n)) {
for (e = agfstout(g, n); e!=null; e = agnxtout(g, e)) {
if ((Boolean)Z.z().sinfo.swapEnds.exe(e) && ED_spl(e)!=null)
swap_spline(ED_spl(e));
}
}
} finally {
LEAVING("dgkssqjj566ifra0xy7m46qsb","edge_normalize");
}
}
//3 bwzdgdea9suuagzueyw8ztx42
// static void resetRW (graph_t * g)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="resetRW", key="bwzdgdea9suuagzueyw8ztx42", definition="static void resetRW (graph_t * g)")
public static Object resetRW(Object... arg_) {
UNSUPPORTED("e2z2o5ybnr5tgpkt8ty7hwan1"); // static void
UNSUPPORTED("c4vqsmfolc1meewxoebfkyppx"); // resetRW (graph_t * g)
UNSUPPORTED("erg9i1970wdri39osu8hx2a6e"); // {
UNSUPPORTED("7ma9kdgag30w5ofv1niitxbro"); // node_t* n;
UNSUPPORTED("7wq24g054kmx3aw25vk5ksj4"); // for (n = agfstnode(g); n; n = agnxtnode(g,n)) {
UNSUPPORTED("b83f20tdode2lz5a49mhmn9ei"); // if (ND_other(n).list) {
UNSUPPORTED("ez6pf4w4vi7z6fqq43v5i3gpv"); // double tmp = ND_rw(n);
UNSUPPORTED("24qsh566odunv14qzj2zan7bz"); // ND_rw(n) = ND_mval(n);
UNSUPPORTED("cgxuqwflawrd9e6dmnsh3sbwa"); // ND_mval(n) = tmp;
UNSUPPORTED("flupwh3kosf3fkhkxllllt1"); // }
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("c24nfmv9i7o5eoqaymbibp7m7"); // }
throw new UnsupportedOperationException();
}
private final static int NSUB = 9;
private final static int CHUNK = 128;
private final static int MINW = 16;
private final static int HALFMINW = 8;
private final static int FWDEDGE = 16;
private final static int BWDEDGE = 32;
private final static int MAINGRAPH = 64;
private final static int AUXGRAPH = 128;
/* _dot_splines:
* Main spline routing code.
* The normalize parameter allows this function to be called by the
* recursive call in make_flat_edge without normalization occurring,
* so that the edge will only be normalized once in the top level call
* of dot_splines.
*/
//3 6agx6m2qof9lg57co232lwakj
// static void _dot_splines(graph_t * g, int normalize)
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="_dot_splines", key="6agx6m2qof9lg57co232lwakj", definition="static void _dot_splines(graph_t * g, int normalize)")
static void _dot_splines(ST_Agraph_s g, int normalize)
{
ENTERING("6agx6m2qof9lg57co232lwakj","_dot_splines");
try {
int i, j, k, n_nodes, n_edges, ind, cnt;
ST_Agnode_s n;
final ST_Agedgeinfo_t fwdedgeai = new ST_Agedgeinfo_t(), fwdedgebi = new ST_Agedgeinfo_t();
final ST_Agedgepair_s fwdedgea = new ST_Agedgepair_s(), fwdedgeb = new ST_Agedgepair_s();
ST_Agedge_s e, e0, e1, ea, eb, le0, le1;
CArrayOfStar edges;
ST_path P;
final ST_spline_info_t sd = new ST_spline_info_t();
int et = (GD_flags(g) & (7 << 1));
fwdedgea.out.base.data = fwdedgeai;
fwdedgeb.out.base.data = fwdedgebi;
if (et == ET_NONE) return;
if (et == ET_CURVED) {
resetRW (g);
if ((GD_has_labels(g) & EDGE_LABEL)!=0) {
UNSUPPORTED("4k888z8ymdp2b653twxc1ugbu"); // agerr (AGWARN, "edge labels with splines=curved not supported in dot - use xlabels\n");
}
for (n = agfstnode (g); n!=null; n = agnxtnode(g, n)) {
for (e = agfstout(g, n); e!=null; e = agnxtout(g,e)) {
makeStraightEdge(g, e, et, Z.z().sinfo);
}
}
UNSUPPORTED("46btiag50nczzur103eqhjcup"); // goto finish;
}
mark_lowclusters(g);
if (routesplinesinit()!=0) return;
P = new ST_path();
/* FlatHeight = 2 * GD_nodesep(g); */
sd.Splinesep = GD_nodesep(g) / 4;
sd.Multisep = GD_nodesep(g);
edges = CArrayOfStar.ALLOC(CHUNK, ST_Agedge_s.class);
/* compute boundaries and list of splines */
sd.RightBound = 0;
sd.LeftBound = 0;
n_edges = n_nodes = 0;
for (i = GD_minrank(g); i <= GD_maxrank(g); i++) {
n_nodes += GD_rank(g).get__(i).n;
if ((n = GD_rank(g).get__(i).v.get_(0))!=null)
sd.LeftBound = (int)MIN(sd.LeftBound, (ND_coord(n).x - ND_lw(n)));
if (GD_rank(g).get__(i).n!=0 && (n = GD_rank(g).get__(i).v.get_(GD_rank(g).get__(i).n - 1))!=null)
sd.RightBound = (int)MAX(sd.RightBound, (ND_coord(n).x + ND_rw(n)));
sd.LeftBound -= MINW;
sd.RightBound += MINW;
for (j = 0; j < GD_rank(g).get__(i).n; j++) {
n = GD_rank(g).get__(i).v.get_(j);
/* if n is the label of a flat edge, copy its position to
* the label.
*/
if (ND_alg(n)!=null) {
ST_Agedge_s fe = (ST_Agedge_s) ND_alg(n);
assert (ED_label(fe)!=null);
ED_label(fe).pos.___(ND_coord(n));
ED_label(fe).set= NOTI(false);
}
if ((ND_node_type(n) != NORMAL) &&
((Boolean)Z.z().sinfo.splineMerge.exe(n) == false))
continue;
for (k = 0; (e = ND_out(n).list.get_(k))!=null; k++) {
if ((ED_edge_type(e) == FLATORDER)
|| (ED_edge_type(e) == IGNORED))
continue;
setflags(e, REGULAREDGE, FWDEDGE, MAINGRAPH);
edges.set_(n_edges++, e);
if (n_edges % CHUNK == 0)
edges = CArrayOfStar.REALLOC(n_edges + CHUNK, edges, ST_Agedge_s.class);
}
if (ND_flat_out(n).list!=null)
for (k = 0; (e = ND_flat_out(n).list.get_(k))!=null; k++) {
setflags(e, FLATEDGE, 0, AUXGRAPH);
edges.set_(n_edges++, e);
if (n_edges % CHUNK == 0)
edges = CArrayOfStar.REALLOC(n_edges + CHUNK, edges, ST_Agedge_s.class);
}
if (ND_other(n).list!=null) {
/* In position, each node has its rw stored in mval and,
* if a node is part of a loop, rw may be increased to
* reflect the loops and associated labels. We restore
* the original value here.
*/
if (ND_node_type(n) == NORMAL) {
double tmp = ND_rw(n);
ND_rw(n, ND_mval(n));
ND_mval(n, tmp);
}
for (k = 0; (e = ND_other(n).list.get_(k))!=null; k++) {
setflags(e, 0, 0, AUXGRAPH);
edges.set_(n_edges++, e);
if (n_edges % CHUNK == 0)
edges = CArrayOfStar.REALLOC(n_edges + CHUNK, edges, ST_Agedge_s.class);
}
}
}
}
/* Sort so that equivalent edges are contiguous.
* Equivalence should basically mean that 2 edges have the
* same set {(tailnode,tailport),(headnode,headport)}, or
* alternatively, the edges would be routed identically if
* routed separately.
*/
LOG2("_dot_splines::n_edges="+n_edges);
qsort1(edges, n_edges,
dotsplines__c.edgecmp);
/* FIXME: just how many boxes can there be? */
P.boxes = ST_boxf.malloc(n_nodes + 20 * 2 * NSUB);
sd.Rank_box = ST_boxf.malloc(i);
if (et == ET_LINE) {
/* place regular edge labels */
for (n = GD_nlist(g); n!=null; n = ND_next(n)) {
if ((ND_node_type(n) == VIRTUAL) && (ND_label(n)!=null)) {
place_vnlabel(n);
}
}
}
for (i = 0; i < n_edges;) {
boolean havePorts;
ind = i;
le0 = getmainedge((e0 = edges.get_(i++)));
if (ED_tail_port(e0).defined || ED_head_port(e0).defined) {
havePorts = true;
ea = e0;
} else {
havePorts = false;
ea = le0;
}
if ((ED_tree_index(ea) & BWDEDGE)!=0) {
MAKEFWDEDGE(fwdedgea.out, ea);
ea = fwdedgea.out;
}
for (cnt = 1; i < n_edges; cnt++, i++) {
if (NEQ(le0, (le1 = getmainedge((e1 = edges.get_(i))))))
break;
if (ED_adjacent(e0)!=0) continue; /* all flat adjacent edges at once */
if (ED_tail_port(e1).defined || ED_head_port(e1).defined) {
if (N(havePorts)) break;
else
eb = e1;
} else {
if (havePorts) break;
else
eb = le1;
}
if ((ED_tree_index(eb) & BWDEDGE)!=0) {
MAKEFWDEDGE(fwdedgeb.out, eb);
eb = fwdedgeb.out;
}
if (portcmp(ED_tail_port(ea), ED_tail_port(eb))!=0)
break;
if (portcmp(ED_head_port(ea), ED_head_port(eb))!=0)
break;
if ((ED_tree_index(e0) & EDGETYPEMASK) == FLATEDGE
&& NEQ(ED_label(e0), ED_label(e1)))
break;
if ((ED_tree_index(edges.get_(i)) & MAINGRAPH)!=0) /* Aha! -C is on */
break;
}
if (EQ(agtail(e0), aghead(e0))) {
int b, sizey, r;
n = agtail(e0);
r = ND_rank(n);
if (r == GD_maxrank(g)) {
if (r > 0)
sizey = (int) (ND_coord(GD_rank(g).get__(r-1).v.get_(0)).y - ND_coord(n).y);
else
sizey = (int) ND_ht(n);
}
else if (r == GD_minrank(g)) {
sizey = (int)(ND_coord(n).y - ND_coord(GD_rank(g).get__(r+1).v.get_(0)).y);
}
else {
int upy = (int) (ND_coord(GD_rank(g).get__(r-1).v.get_(0)).y - ND_coord(n).y);
int dwny = (int) (ND_coord(n).y - ND_coord(GD_rank(g).get__(r+1).v.get_(0)).y);
sizey = MIN(upy, dwny);
}
makeSelfEdge(P, edges, ind, cnt, sd.Multisep, sizey/2, Z.z().sinfo);
for (b = 0; b < cnt; b++) {
e = edges.get_(ind+b);
if (ED_label(e)!=null)
updateBB(g, ED_label(e));
}
}
else if (ND_rank(agtail(e0)) == ND_rank(aghead(e0))) {
make_flat_edge(g, sd, P, edges, ind, cnt, et);
}
else
make_regular_edge(g, sd, P, edges, ind, cnt, et);
}
/* place regular edge labels */
for (n = GD_nlist(g); n!=null; n = ND_next(n)) {
if ((ND_node_type(n) == VIRTUAL) && (ND_label(n))!=null) {
place_vnlabel(n);
updateBB(g, ND_label(n));
}
}
/* normalize splines so they always go from tail to head */
/* place_portlabel relies on this being done first */
if (normalize!=0)
edge_normalize(g);
finish :
/* vladimir: place port labels */
/* FIX: head and tail labels are not part of cluster bbox */
if ((Z.z().E_headlabel!=null || Z.z().E_taillabel!=null) && (Z.z().E_labelangle!=null || Z.z().E_labeldistance!=null)) {
UNSUPPORTED("attp4bsjqe99xnhi7lr7pszar"); // for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
UNSUPPORTED("54jm4bbgzyl0txauszo1mappu"); // if (E_headlabel) {
UNSUPPORTED("dw8yu56thd0wpolmtby8r5doo"); // for (e = agfstin(g, n); e; e = agnxtin(g, e))
UNSUPPORTED("4h39n1vkqyqszgmg2o7d2pw7z"); // if (ED_head_label(AGMKOUT(e))) {
UNSUPPORTED("ex7h0x60y0l4oi3dsqg7sfk1t"); // place_portlabel(AGMKOUT(e), NOT(0));
UNSUPPORTED("9u960ou1xs0cdsdn0qe8a13ye"); // updateBB(g, ED_head_label(AGMKOUT(e)));
UNSUPPORTED("dkxvw03k2gg9anv4dbze06axd"); // }
UNSUPPORTED("6t98dcecgbvbvtpycwiq2ynnj"); // }
UNSUPPORTED("cqi8doquf015wo1bw8on36qct"); // if (E_taillabel) {
UNSUPPORTED("6gnq0yj07udpwxbuc86k8yysb"); // for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
UNSUPPORTED("ejz8yrj8mh0l0gdl5zeaht1ex"); // if (ED_tail_label(e)) {
UNSUPPORTED("9pdg7peez077ldl84zfh73o1w"); // if (place_portlabel(e, 0))
UNSUPPORTED("6jup6d9gfnx4b1wptmtw09n6w"); // updateBB(g, ED_tail_label(e));
UNSUPPORTED("dkxvw03k2gg9anv4dbze06axd"); // }
UNSUPPORTED("6eq5kf0bj692bokt0bixy1ixh"); // }
UNSUPPORTED("6t98dcecgbvbvtpycwiq2ynnj"); // }
UNSUPPORTED("flupwh3kosf3fkhkxllllt1"); // }
}
/* end vladimir */
if (et != ET_CURVED) {
Memory.free(edges);
Memory.free(P.boxes);
Memory.free(P);
Memory.free(sd.Rank_box);
routesplinesterm();
}
Z.z().State = GVSPLINES;
Z.z().EdgeLabelsDone = 1;
} finally {
LEAVING("6agx6m2qof9lg57co232lwakj","_dot_splines");
}
}
//3 5n306wbdfjbfnimdo9lg6jjaa
// void dot_splines(graph_t * g)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="dot_splines", key="5n306wbdfjbfnimdo9lg6jjaa", definition="void dot_splines(graph_t * g)")
public static void dot_splines(ST_Agraph_s g) {
ENTERING("5n306wbdfjbfnimdo9lg6jjaa","dot_splines");
try {
_dot_splines (g, 1);
} finally {
LEAVING("5n306wbdfjbfnimdo9lg6jjaa","dot_splines");
}
}
//3 8jja9ukzsq8tlb9yy7uzavg91
// static void place_vnlabel(node_t * n)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="place_vnlabel", key="8jja9ukzsq8tlb9yy7uzavg91", definition="static void place_vnlabel(node_t * n)")
public static void place_vnlabel(ST_Agnode_s n) {
ENTERING("8jja9ukzsq8tlb9yy7uzavg91","place_vnlabel");
try {
final ST_pointf dimen = new ST_pointf();
double width;
ST_Agedge_s e;
if (ND_in(n).size == 0)
return; /* skip flat edge labels here */
for (e = (ST_Agedge_s) ND_out(n).list.get_(0); ED_edge_type(e) != 0;
e = ED_to_orig(e));
dimen.___(ED_label(e).dimen);
width = GD_flip(agraphof(n)) ? dimen.y : dimen.x;
ED_label(e).pos.x = ND_coord(n).x + width / 2.0;
ED_label(e).pos.y = ND_coord(n).y;
ED_label(e).set= NOTI(false);
} finally {
LEAVING("8jja9ukzsq8tlb9yy7uzavg91","place_vnlabel");
}
}
//3 598jn37hjkm7j0kcg2nmdvlwq
// static void setflags(edge_t *e, int hint1, int hint2, int f3)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="setflags", key="598jn37hjkm7j0kcg2nmdvlwq", definition="static void setflags(edge_t *e, int hint1, int hint2, int f3)")
public static void setflags(ST_Agedge_s e, int hint1, int hint2, int f3) {
ENTERING("598jn37hjkm7j0kcg2nmdvlwq","setflags");
try {
int f1, f2;
if (hint1 != 0)
f1 = hint1;
else {
if (EQ(agtail(e), aghead(e)))
if (ED_tail_port(e).defined || ED_head_port(e).defined)
f1 = 4;
else
f1 = 8;
else if (ND_rank(agtail(e)) == ND_rank(aghead(e)))
f1 = 2;
else
f1 = 1;
}
if (hint2 != 0)
f2 = hint2;
else {
if (f1 == 1)
f2 = (ND_rank(agtail(e)) < ND_rank(aghead(e))) ? 16 : 32;
else if (f1 == 2)
f2 = (ND_order(agtail(e)) < ND_order(aghead(e))) ? 16 : 32;
else /* f1 == SELF*EDGE */
f2 = 16;
}
ED_tree_index(e, (f1 | f2 | f3));
} finally {
LEAVING("598jn37hjkm7j0kcg2nmdvlwq","setflags");
}
}
public static CFunction edgecmp = new CFunctionAbstract("edgecmp") {
public Object exe(Object... args) {
return edgecmp((CArrayOfStar)args[0], (CArrayOfStar)args[1]);
}};
/* edgecmp:
* lexicographically order edges by
* - edge type
* - |rank difference of nodes|
* - |x difference of nodes|
* - id of witness edge for equivalence class
* - port comparison
* - graph type
* - labels if flat edges
* - edge id
*/
//3 1nf1s6wkn35ptjn884ii56fh
// static int edgecmp(edge_t** ptr0, edge_t** ptr1)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="edgecmp", key="1nf1s6wkn35ptjn884ii56fh", definition="static int edgecmp(edge_t** ptr0, edge_t** ptr1)")
public static int edgecmp(CArrayOfStar ptr0, CArrayOfStar ptr1) {
ENTERING("1nf1s6wkn35ptjn884ii56fh","edgecmp");
try {
final ST_Agedgeinfo_t fwdedgeai = new ST_Agedgeinfo_t(), fwdedgebi = new ST_Agedgeinfo_t();
final ST_Agedgepair_s fwdedgea = new ST_Agedgepair_s(), fwdedgeb = new ST_Agedgepair_s();
ST_Agedge_s e0, e1, ea, eb, le0, le1;
int et0, et1, v0, v1, rv;
double t0, t1;
fwdedgea.out.base.data = fwdedgeai;
fwdedgeb.out.base.data = fwdedgebi;
e0 = ptr0.get_(0);
e1 = ptr1.get_(0);
et0 = ED_tree_index(e0) & 15;
et1 = ED_tree_index(e1) & 15;
if (et0 != et1)
return (et1 - et0);
le0 = getmainedge(e0);
le1 = getmainedge(e1);
t0 = ND_rank(agtail(le0)) - ND_rank(aghead(le0));
t1 = ND_rank(agtail(le1)) - ND_rank(aghead(le1));
v0 = ABS((int)t0); /* ugly, but explicit as to how we avoid equality tests on fp numbers */
v1 = ABS((int)t1);
if (v0 != v1)
return (v0 - v1);
t0 = ND_coord(agtail(le0)).x - ND_coord(aghead(le0)).x;
t1 = ND_coord(agtail(le1)).x - ND_coord(aghead(le1)).x;
v0 = ABS((int)t0);
v1 = ABS((int)t1);
if (v0 != v1)
return (v0 - v1);
/* This provides a cheap test for edges having the same set of endpoints. */
if (AGSEQ(le0) != AGSEQ(le1))
return (AGSEQ(le0) - AGSEQ(le1));
ea = (ED_tail_port(e0).defined || ED_head_port(e0).defined) ? e0 : le0;
if ((ED_tree_index(ea) & 32)!=0) {
MAKEFWDEDGE(fwdedgea.out, ea);
ea = (ST_Agedge_s) fwdedgea.out;
}
eb = (ED_tail_port(e1).defined || ED_head_port(e1).defined) ? e1 : le1;
if ((ED_tree_index(eb) & 32)!=0) {
MAKEFWDEDGE(fwdedgeb.out, eb);
eb = (ST_Agedge_s) fwdedgeb.out;
}
if ((rv = portcmp(ED_tail_port(ea), ED_tail_port(eb)))!=0)
return rv;
if ((rv = portcmp(ED_head_port(ea), ED_head_port(eb)))!=0)
return rv;
et0 = ED_tree_index(e0) & 192;
et1 = ED_tree_index(e1) & 192;
if (et0 != et1)
return (et0 - et1);
if (et0 == 2 && NEQ(ED_label(e0), ED_label(e1)))
UNSUPPORTED("return (int) (ED_label(e0) - ED_label(e1))");
return (AGSEQ(e0) - AGSEQ(e1));
} finally {
LEAVING("1nf1s6wkn35ptjn884ii56fh","edgecmp");
}
}
public static CFunction edgelblcmpfn = new CFunctionAbstract("edgelblcmpfn") {
public Object exe(Object... args) {
return edgelblcmpfn((CArrayOfStar)args[0], (CArrayOfStar)args[1]);
}};
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="edgelblcmpfn", key="bmsa24i3avg14po4sp17yh89k", definition="static int edgelblcmpfn(edge_t** ptr0, edge_t** ptr1)")
public static int edgelblcmpfn(CArrayOfStar ptr0, CArrayOfStar ptr1) {
ENTERING("bmsa24i3avg14po4sp17yh89k","edgelblcmpfn");
try {
ST_Agedge_s e0, e1;
final ST_pointf sz0 = new ST_pointf(), sz1 = new ST_pointf();
e0 = ptr0.get_(0);
e1 = ptr1.get_(0);
if (ED_label(e0)!=null) {
if (ED_label(e1)!=null) {
sz0.___(ED_label(e0).dimen);
sz1.___(ED_label(e1).dimen);
if (sz0.x > sz1.x) return -1;
else if (sz0.x < sz1.x) return 1;
else if (sz0.y > sz1.y) return -1;
else if (sz0.y < sz1.y) return 1;
else return 0;
}
else
return -1;
}
else if (ED_label(e1)!=null) {
return 1;
}
else
return 0;
} finally {
LEAVING("bmsa24i3avg14po4sp17yh89k","edgelblcmpfn");
}
}
/* makeSimpleFlatLabels:
* This handles the second simplest case for flat edges between
* two adjacent nodes. We still invoke a dot on a rotated problem
* to handle edges with ports. This usually works, but fails for
* records because of their weird nature.
*/
//3 3xmylrnypvoqrj2yrxnomsj5k
// static void makeSimpleFlatLabels (node_t* tn, node_t* hn, edge_t** edges, int ind, int cnt, int et, int n_lbls)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="makeSimpleFlatLabels", key="3xmylrnypvoqrj2yrxnomsj5k", definition="static void makeSimpleFlatLabels (node_t* tn, node_t* hn, edge_t** edges, int ind, int cnt, int et, int n_lbls)")
public static void makeSimpleFlatLabels(ST_Agnode_s tn, ST_Agnode_s hn, CArrayOfStar edges, int ind, int cnt, int et, int n_lbls) {
ENTERING("3xmylrnypvoqrj2yrxnomsj5k","makeSimpleFlatLabels");
try {
CArray ps;
final ST_Ppoly_t poly = new ST_Ppoly_t();
int pn[] = new int[1];
ST_Agedge_s e = edges.get_(ind);
final CArray points = CArray.ALLOC__(10, ST_pointf.class);
final ST_pointf tp = new ST_pointf(), hp = new ST_pointf();
int i, pointn;
double leftend, rightend, ctrx=0, ctry=0, miny, maxy;
double uminx=0, umaxx=0;
double lminx=0, lmaxx=0;
CArrayOfStar earray = CArrayOfStar.ALLOC(cnt, ST_Agedge_s.class);
for (i = 0; i < cnt; i++) {
earray.set_(i, edges.get_(ind + i));
}
qsort1(earray,
cnt,
dotsplines__c.edgelblcmpfn);
tp.___(add_pointf(ND_coord(tn), ED_tail_port(e).p));
hp.___(add_pointf(ND_coord(hn), ED_head_port(e).p));
leftend = tp.x+ND_rw(tn);
rightend = hp.x-ND_lw(hn);
ctrx = (leftend + rightend)/2.0;
/* do first edge */
e = earray.get_(0);
pointn = 0;
points.get__(pointn++).___(tp);
points.get__(pointn++).___(tp);
points.get__(pointn++).___(hp);
points.get__(pointn++).___(hp);
clip_and_install(e, aghead(e), points, pointn, Z.z().sinfo);
ED_label(e).pos.x = ctrx;
ED_label(e).pos.y = (tp.y + (ED_label(e).dimen.y+6)/2.0);
ED_label(e).set = 1;
miny = tp.y + 6/2.0;
maxy = miny + ED_label(e).dimen.y;
uminx = ctrx - (ED_label(e).dimen.x)/2.0;
umaxx = ctrx + (ED_label(e).dimen.x)/2.0;
for (i = 1; i < n_lbls; i++) {
e = earray.get_(i);
if (i%2!=0) { /* down */
if (i == 1) {
lminx = ctrx - (ED_label(e).dimen.x)/2.0;
lmaxx = ctrx + (ED_label(e).dimen.x)/2.0;
}
miny -= 6 + ED_label(e).dimen.y;
points.get__(0).___(tp);
points.get__(1).x = tp.x;
points.get__(1).y = miny - 6;
points.get__(2).x = hp.x;
points.get__(2).y = points.get__(1).y;
points.get__(3).___(hp);
points.get__(4).x = lmaxx;
points.get__(4).y = hp.y;
points.get__(5).x = lmaxx;
points.get__(5).y = miny;
points.get__(6).x = lminx;
points.get__(6).y = miny;
points.get__(7).x = lminx;
points.get__(7).y = tp.y;
ctry = miny + (ED_label(e).dimen.y)/2.0;
}
else { /* up */
points.get__(0).___(tp);
points.get__(1).x = uminx;
points.get__(1).y = tp.y;
points.get__(2).x = uminx;
points.get__(2).y = maxy;
points.get__(3).x = umaxx;
points.get__(3).y = maxy;
points.get__(4).x = umaxx;
points.get__(4).y = hp.y;
points.get__(5).x = hp.x;
points.get__(5).y = hp.y;
points.get__(6).x = hp.x;
points.get__(6).y = maxy + 6;
points.get__(7).x = tp.x;
points.get__(7).y = maxy + 6;
ctry = maxy + (ED_label(e).dimen.y)/2.0 + 6;
maxy += ED_label(e).dimen.y + 6;
}
poly.pn = 8;
poly.ps = points;
ps = simpleSplineRoute (tp, hp, poly, pn, et == (3 << 1));
if (pn[0] == 0) return;
ED_label(e).pos.x = ctrx;
ED_label(e).pos.y = ctry;
ED_label(e).set= NOTI(false);
clip_and_install(e, aghead(e), ps, pn[0], Z.z().sinfo);
}
/* edges with no labels */
for (; i < cnt; i++) {
e = earray.get_(i);
if (i%2!=0) { /* down */
if (i == 1) {
lminx = (2*leftend + rightend)/3.0;
lmaxx = (leftend + 2*rightend)/3.0;
}
miny -= 6;
points.get__(0).___(tp);
points.get__(1).x = tp.x;
points.get__(1).y = miny - 6;
points.get__(2).x = hp.x;
points.get__(2).y = points.get__(1).y;
points.get__(3).___(hp);
points.get__(4).x = lmaxx;
points.get__(4).y = hp.y;
points.get__(5).x = lmaxx;
points.get__(5).y = miny;
points.get__(6).x = lminx;
points.get__(6).y = miny;
points.get__(7).x = lminx;
points.get__(7).y = tp.y;
}
else { /* up */
UNSUPPORTED("7owdudualx55z2cnm9x3iio0w"); // points[0] = tp;
UNSUPPORTED("43w0zont6q3y1axlcy96rzm5x"); // points[1].x = uminx;
UNSUPPORTED("285u4l65puy5nr3pgq6acl4i2"); // points[1].y = tp.y;
UNSUPPORTED("uctdrwzmec4w6vmirs9on197"); // points[2].x = uminx;
UNSUPPORTED("d9b8e2upja8koam9memys7nj1"); // points[2].y = maxy;
UNSUPPORTED("e8a8ucdpq7sgmbi3qyldleb1s"); // points[3].x = umaxx;
UNSUPPORTED("d7xd9vzbdbezltrxsp9a3byuc"); // points[3].y = maxy;
UNSUPPORTED("59abeyxxk9ow1g6m45t4ahih7"); // points[4].x = umaxx;
UNSUPPORTED("2lzgl5468xguophz9d5wyer2x"); // points[4].y = hp.y;
UNSUPPORTED("41u0uroraw4xanvpgg6l74kyh"); // points[5].x = hp.x;
UNSUPPORTED("cwkk5bnko3e1udrx4cb720zss"); // points[5].y = hp.y;
UNSUPPORTED("eev7hf3617k74bnq18uiedyb0"); // points[6].x = hp.x;
UNSUPPORTED("aqxt1dvgfq5zcptjwgx1b3mmq"); // points[6].y = maxy + 6;
UNSUPPORTED("5s3o04yf5lzca6ruuygfxngj2"); // points[7].x = tp.x;
UNSUPPORTED("56zheeat0b8mo4uvlcbvgbu80"); // points[7].y = maxy + 6;
UNSUPPORTED("7un2qk34mmmhqi296vl50bacs"); // maxy += + 6;
}
poly.pn = 8;
poly.ps = points;
ps = simpleSplineRoute (tp, hp, poly, pn, et == (3 << 1));
if (pn[0] == 0) return;
clip_and_install(e, aghead(e), ps, pn[0], Z.z().sinfo);
}
Memory.free (earray);
} finally {
LEAVING("3xmylrnypvoqrj2yrxnomsj5k","makeSimpleFlatLabels");
}
}
/* makeSimpleFlat:
*/
//3 8kqyzk43ovc2sq6jegua6ytp
// static void makeSimpleFlat (node_t* tn, node_t* hn, edge_t** edges, int ind, int cnt, int et)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="makeSimpleFlat", key="8kqyzk43ovc2sq6jegua6ytp", definition="static void makeSimpleFlat (node_t* tn, node_t* hn, edge_t** edges, int ind, int cnt, int et)")
public static void makeSimpleFlat(ST_Agnode_s tn, ST_Agnode_s hn, CArrayOfStar edges, int ind, int cnt, int et) {
ENTERING("8kqyzk43ovc2sq6jegua6ytp","makeSimpleFlat");
try {
ST_Agedge_s e = edges.get_(ind);
final CArray points = CArray.ALLOC__(10, ST_pointf.class);
final ST_pointf tp = new ST_pointf(), hp = new ST_pointf();
int i, pointn;
double stepy, dy;
tp.___(add_pointf(ND_coord(tn), ED_tail_port(e).p));
hp.___(add_pointf(ND_coord(hn), ED_head_port(e).p));
stepy = (cnt > 1) ? ND_ht(tn) / (double)(cnt - 1) : 0.;
dy = tp.y - ((cnt > 1) ? ND_ht(tn) / 2. : 0.);
for (i = 0; i < cnt; i++) {
e = edges.get_(ind + i);
pointn = 0;
if ((et == ET_SPLINE) || (et == ET_LINE)) {
points.get__(pointn++).___(tp);
points.get__(pointn++).___(pointfof((2 * tp.x + hp.x) / 3, dy));
points.get__(pointn++).___(pointfof((2 * hp.x + tp.x) / 3, dy));
points.get__(pointn++).___(hp);
}
else { /* ET_PLINE */
UNSUPPORTED("cai7diqq01v8vb92u4mx1xh38"); // points[pointn++] = tp;
UNSUPPORTED("cai7diqq01v8vb92u4mx1xh38"); // points[pointn++] = tp;
UNSUPPORTED("bnd7kao912fmo940u1gz3cmws"); // points[pointn++] = pointfof((2 * tp.x + hp.x) / 3, dy);
UNSUPPORTED("bnd7kao912fmo940u1gz3cmws"); // points[pointn++] = pointfof((2 * tp.x + hp.x) / 3, dy);
UNSUPPORTED("bnd7kao912fmo940u1gz3cmws"); // points[pointn++] = pointfof((2 * tp.x + hp.x) / 3, dy);
UNSUPPORTED("akir2i0ddpv2ombgdzzs9qqqa"); // points[pointn++] = pointfof((2 * hp.x + tp.x) / 3, dy);
UNSUPPORTED("akir2i0ddpv2ombgdzzs9qqqa"); // points[pointn++] = pointfof((2 * hp.x + tp.x) / 3, dy);
UNSUPPORTED("akir2i0ddpv2ombgdzzs9qqqa"); // points[pointn++] = pointfof((2 * hp.x + tp.x) / 3, dy);
UNSUPPORTED("59cwjy3j5e0igp278migykzi"); // points[pointn++] = hp;
UNSUPPORTED("59cwjy3j5e0igp278migykzi"); // points[pointn++] = hp;
}
dy += stepy;
clip_and_install(e, aghead(e), points, pointn, Z.z().sinfo);
}
} finally {
LEAVING("8kqyzk43ovc2sq6jegua6ytp","makeSimpleFlat");
}
}
//3 bhnjospwghq4plid12757c928
// static void make_flat_adj_edges(graph_t* g, path* P, edge_t** edges, int ind, int cnt, edge_t* e0, int et)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="make_flat_adj_edges", key="bhnjospwghq4plid12757c928", definition="static void make_flat_adj_edges(graph_t* g, path* P, edge_t** edges, int ind, int cnt, edge_t* e0, int et)")
public static void make_flat_adj_edges(ST_Agraph_s g, ST_path P, CArrayOfStar edges, int ind, int cnt, ST_Agedge_s e0, int et) {
ENTERING("bhnjospwghq4plid12757c928","make_flat_adj_edges");
try {
ST_Agnode_s n;
ST_Agnode_s tn, hn;
ST_Agedge_s e;
int labels = 0, ports = 0;
ST_Agraph_s auxg;
ST_Agraph_s subg;
ST_Agnode_s auxt, auxh;
ST_Agedge_s auxe;
int i, j, midx, midy, leftx, rightx;
final ST_pointf del = new ST_pointf();
ST_Agedge_s hvye = null;
__ptr__ attrs;
tn = agtail(e0); hn = aghead(e0);
for (i = 0; i < cnt; i++) {
e = edges.get_(ind + i);
if (ED_label(e)!=null) labels++;
if (ED_tail_port(e).defined || ED_head_port(e).defined) ports = 1;
}
if (ports == 0) {
/* flat edges without ports and labels can go straight left to right */
if (labels == 0) {
makeSimpleFlat (tn, hn, edges, ind, cnt, et);
}
/* flat edges without ports but with labels take more work */
else {
makeSimpleFlatLabels (tn, hn, edges, ind, cnt, et, labels);
}
return;
}
UNSUPPORTED("3ua0mgcwxnpymnpiv77owaur2"); // attrs = (attr_state_t*)zmalloc(sizeof(attr_state_t));
UNSUPPORTED("5qcpchn65culafc5t2ibioksb"); // auxg = cloneGraph (g, attrs);
UNSUPPORTED("cwolismpef6l1w4xj5etx8w09"); // subg = agsubg (auxg, "xxx",1);
UNSUPPORTED("eocu0fte9egz381w3t8y5m64t"); // agbindrec(subg, "Agraphinfo_t", sizeof(Agraphinfo_t), NOT(0));
UNSUPPORTED("er19m8huvnjjn1v6rreiisdf6"); // agset (subg, "rank", "source");
UNSUPPORTED("du7zwfglureqnv5g2wiammuuu"); // rightx = ND_coord(hn).x;
UNSUPPORTED("5qa24lmumrg29fbtl0fo4d4z1"); // leftx = ND_coord(tn).x;
UNSUPPORTED("b2x6j7m1cmmkcmdl5jo9wn0ap"); // if (GD_flip(g)) {
UNSUPPORTED("2elvc001uux0vbe7sv4098e0c"); // node_t* n;
UNSUPPORTED("6m8k99c09zmhwgcdsgo33dugz"); // n = tn;
UNSUPPORTED("cenlfgoeymhe1am5z6632xniq"); // tn = hn;
UNSUPPORTED("cp2gf6c1xawd2yjbqerw98we3"); // hn = n;
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("1e98fnf9lsk7hwgjt70gh5r55"); // auxt = cloneNode(subg, tn, GD_flip(g));
UNSUPPORTED("a4xa8i1nw83hhnknv84280z00"); // auxh = cloneNode(auxg, hn, GD_flip(g));
UNSUPPORTED("1psokm6w9e7qw7fm2g1cayuk7"); // for (i = 0; i < cnt; i++) {
UNSUPPORTED("8hwholxjp08y4q0zbb561684q"); // e = edges[ind + i];
UNSUPPORTED("b3w40fpgfj0j66yi6j582thq2"); // for (; ED_edge_type(e) != 0; e = ED_to_orig(e));
UNSUPPORTED("bcu59ji1apn0rvv7aisl6e4pw"); // if (agtail(e) == tn)
UNSUPPORTED("4o3mq2ztiyxlbkpgcyygj4lny"); // auxe = cloneEdge (auxg, auxt, auxh, e);
UNSUPPORTED("9352ql3e58qs4fzapgjfrms2s"); // else
UNSUPPORTED("3a7m578mxun4c8zv0jurzh7ox"); // auxe = cloneEdge (auxg, auxh, auxt, e);
UNSUPPORTED("e6khamu7fhu5m7il9r2v06mui"); // ED_alg(e) = auxe;
UNSUPPORTED("64u9xrw8iwy3mtuupoktw7xoz"); // if (!hvye && !ED_tail_port(e).defined && !ED_head_port(e).defined) {
UNSUPPORTED("6t23nfzzldtl419g582pr0wjn"); // hvye = auxe;
UNSUPPORTED("3fi2uxwkmau5664gnhzyosan5"); // ED_alg(hvye) = e;
UNSUPPORTED("flupwh3kosf3fkhkxllllt1"); // }
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("co4n3cv6ybhgvm341r3re61vu"); // if (!hvye) {
UNSUPPORTED("a0sxhnruv0ip65j05wt7dciak"); // hvye = agedge (auxg, auxt, auxh,NULL,1);
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("26l323zwxztuc6sfnh36x7i9f"); // agxset (hvye, E_weight, "10000");
UNSUPPORTED("4pj2d4pwf7wi9fcu4v0byk83z"); // GD_gvc(auxg) = GD_gvc(g);
UNSUPPORTED("b6dpjp9wgjzgoy0tq7b9kms74"); // GD_dotroot(auxg) = auxg;
UNSUPPORTED("e08t9bx8ldb1d5e0582wg82sx"); // setEdgeType (auxg, et);
UNSUPPORTED("8y4433lgybq35f4t7viqsvz5v"); // dot_init_node_edge(auxg);
UNSUPPORTED("13c2nt4jwumpvtwudz38a4sb3"); // dot_rank(auxg, 0);
UNSUPPORTED("6onnznyz9fof6r8we5z1e4r63"); // dot_mincross(auxg, 0);
UNSUPPORTED("4ry85qx5xmahkm0mdv9s65azo"); // dot_position(auxg, 0);
UNSUPPORTED("9921qakdgil2jvrvinke44xsz"); // /* reposition */
UNSUPPORTED("ang8wy78872hvqkzvgfjwqwfl"); // midx = (ND_coord(tn).x - ND_rw(tn) + ND_coord(hn).x + ND_lw(hn))/2;
UNSUPPORTED("2r2ywte92l423tbcdfvbhz3zh"); // midy = (ND_coord(auxt).x + ND_coord(auxh).x)/2;
UNSUPPORTED("b8juh1dggb6sz4d9df42i150k"); // for (n = GD_nlist(auxg); n; n = ND_next(n)) {
UNSUPPORTED("4prtyy13ox1fif8vil3g86g87"); // if (n == auxt) {
UNSUPPORTED("7gvpia4yo3bfvh5dl7uwr3dbe"); // ND_coord(n).y = rightx;
UNSUPPORTED("2zsspnn0nfrdf9fx8sh3ld8j4"); // ND_coord(n).x = midy;
UNSUPPORTED("flupwh3kosf3fkhkxllllt1"); // }
UNSUPPORTED("ba2aaoh9ujy4ww9luial39sya"); // else if (n == auxh) {
UNSUPPORTED("aoy1ze6hhjuym44mkasdt19qp"); // ND_coord(n).y = leftx;
UNSUPPORTED("2zsspnn0nfrdf9fx8sh3ld8j4"); // ND_coord(n).x = midy;
UNSUPPORTED("flupwh3kosf3fkhkxllllt1"); // }
UNSUPPORTED("80o8q2qh1hr671ladbyqzglnt"); // else ND_coord(n).y = midx;
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("48hn94qz2y2kb6lqc3462vlco"); // dot_sameports(auxg);
UNSUPPORTED("bglhuc9grqkk9ozb97oeh0m3b"); // _dot_splines(auxg, 0);
UNSUPPORTED("euvfot8f7xxnibd223qgsylew"); // dotneato_postprocess(auxg);
UNSUPPORTED("4mg60pszj0s1anwg8zp0tq0ra"); // /* copy splines */
UNSUPPORTED("b2x6j7m1cmmkcmdl5jo9wn0ap"); // if (GD_flip(g)) {
UNSUPPORTED("baukf0b2l91bkgnfdc04rvuxe"); // del.x = ND_coord(tn).x - ND_coord(auxt).y;
UNSUPPORTED("96sq686mw9bvj7dli7wb241au"); // del.y = ND_coord(tn).y + ND_coord(auxt).x;
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("1nyzbeonram6636b1w955bypn"); // else {
UNSUPPORTED("bxg8i1hqms0izrryxh2at6p7b"); // del.x = ND_coord(tn).x - ND_coord(auxt).x;
UNSUPPORTED("3xqgvdcxmu8e4eqtnhaa256tk"); // del.y = ND_coord(tn).y - ND_coord(auxt).y;
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("1psokm6w9e7qw7fm2g1cayuk7"); // for (i = 0; i < cnt; i++) {
UNSUPPORTED("47ogn0fae1yuy3kefpawcgcmx"); // bezier* auxbz;
UNSUPPORTED("4mujfxtr0wy7m1rbm57rwigo4"); // bezier* bz;
UNSUPPORTED("8hwholxjp08y4q0zbb561684q"); // e = edges[ind + i];
UNSUPPORTED("b3w40fpgfj0j66yi6j582thq2"); // for (; ED_edge_type(e) != 0; e = ED_to_orig(e));
UNSUPPORTED("3ii7nnxg3x8jpdk6lcijbizvf"); // auxe = (edge_t*)ED_alg(e);
UNSUPPORTED("5rc7uvn4xqfetekcci1uwri5v"); // if ((auxe == hvye) & !ED_alg(auxe)) continue; /* pseudo-edge */
UNSUPPORTED("52vy3jbu67nebznqkhxxqthih"); // auxbz = ED_spl(auxe)->list;
UNSUPPORTED("azr1tv8blnu3i6b7wstpqv2tc"); // bz = new_spline(e, auxbz->size);
UNSUPPORTED("df84ie4egl6l1i82tz1zp7hg"); // bz->sflag = auxbz->sflag;
UNSUPPORTED("49bzonc32mbuchcsmw7csexdw"); // bz->sp = transformf(auxbz->sp, del, GD_flip(g));
UNSUPPORTED("9g1glpjjy5wmh7dyr6u0nb2cn"); // bz->eflag = auxbz->eflag;
UNSUPPORTED("44tftrsdjjuh1qjmxjpysmee3"); // bz->ep = transformf(auxbz->ep, del, GD_flip(g));
UNSUPPORTED("w0xl6ghxoii2ze2xmbbunv4d"); // for (j = 0; j < auxbz->size; ) {
UNSUPPORTED("22zm6ljvhpz7j2kiqee31nx61"); // pointf cp[4];
UNSUPPORTED("4c88sva3ojadip5w3ehu782tp"); // cp[0] = bz->list[j] = transformf(auxbz->list[j], del, GD_flip(g));
UNSUPPORTED("5jqtd9htl25cd3if3pjtl8dpo"); // j++;
UNSUPPORTED("duk541biqshfomah8rlxeyigr"); // if ( j >= auxbz->size )
UNSUPPORTED("9ekmvj13iaml5ndszqyxa8eq"); // break;
UNSUPPORTED("2qrbm7mhicvoxzk91h9x3gq64"); // cp[1] = bz->list[j] = transformf(auxbz->list[j], del, GD_flip(g));
UNSUPPORTED("5jqtd9htl25cd3if3pjtl8dpo"); // j++;
UNSUPPORTED("f4x9unnnofgnvy91ejtm90kw"); // cp[2] = bz->list[j] = transformf(auxbz->list[j], del, GD_flip(g));
UNSUPPORTED("5jqtd9htl25cd3if3pjtl8dpo"); // j++;
UNSUPPORTED("6pldfj31dg88qzsa012v8auxn"); // cp[3] = transformf(auxbz->list[j], del, GD_flip(g));
UNSUPPORTED("2xvehdctlpogpd7xhdf1pku00"); // update_bb_bz(&GD_bb(g), cp);
UNSUPPORTED("4mhlpjofolwivhm0tl8cxznly"); // }
UNSUPPORTED("8bokoh0vcnmvjcahn7de1z0kd"); // if (ED_label(e)) {
UNSUPPORTED("8ido4wfhvlqvczqfq5xz33kak"); // ED_label(e)->pos = transformf(ED_label(auxe)->pos, del, GD_flip(g));
UNSUPPORTED("3tkba5lhpnujfu8lcz8lewsyn"); // ED_label(e)->set = NOT(0);
UNSUPPORTED("c62p0r1jj71ceakgzrv2gorvu"); // updateBB(g, ED_label(e));
UNSUPPORTED("flupwh3kosf3fkhkxllllt1"); // }
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("22prbnbyxmapn1fcer1sktez7"); // cleanupCloneGraph (auxg, attrs);
UNSUPPORTED("c24nfmv9i7o5eoqaymbibp7m7"); // }
throw new UnsupportedOperationException();
} finally {
LEAVING("bhnjospwghq4plid12757c928","make_flat_adj_edges");
}
}
//3 fybar4mljnmkh3kure5k1eod
// static void makeFlatEnd (graph_t* g, spline_info_t* sp, path* P, node_t* n, edge_t* e, pathend_t* endp, boolean isBegin)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="makeFlatEnd", key="fybar4mljnmkh3kure5k1eod", definition="static void makeFlatEnd (graph_t* g, spline_info_t* sp, path* P, node_t* n, edge_t* e, pathend_t* endp, boolean isBegin)")
public static void makeFlatEnd(ST_Agraph_s g, ST_spline_info_t sp, ST_path P, ST_Agnode_s n, ST_Agedge_s e, ST_pathend_t endp, boolean isBegin) {
ENTERING("fybar4mljnmkh3kure5k1eod","makeFlatEnd");
try {
final ST_boxf b = new ST_boxf();
b.___(maximal_bbox(g, sp, n, null, e));
endp.nb.___(b);
endp.sidemask = (1<<2);
if (isBegin) beginpath(P, e, 2, endp, false);
else endpath(P, e, 2, endp, false);
b.UR.y = endp.boxes[endp.boxn[0] - 1].UR.y;
b.LL.y = endp.boxes[endp.boxn[0] - 1].LL.y;
b.___(makeregularend((ST_boxf) b, (1<<2), ND_coord(n).y + GD_rank(g).get__(ND_rank(n)).ht2));
if (b.LL.x < b.UR.x && b.LL.y < b.UR.y)
UNSUPPORTED("cmjm4y40vf7wklmgz0ae4k36v"); // endp->boxes[endp->boxn++] = b;
} finally {
LEAVING("fybar4mljnmkh3kure5k1eod","makeFlatEnd");
}
}
//3 w8ptjibydq995d2lexg85mku
// static void make_flat_labeled_edge(graph_t* g, spline_info_t* sp, path* P, edge_t* e, int et)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="make_flat_labeled_edge", key="w8ptjibydq995d2lexg85mku", definition="static void make_flat_labeled_edge(graph_t* g, spline_info_t* sp, path* P, edge_t* e, int et)")
public static void make_flat_labeled_edge(ST_Agraph_s g, ST_spline_info_t sp, ST_path P, ST_Agedge_s e, int et) {
ENTERING("w8ptjibydq995d2lexg85mku","make_flat_labeled_edge");
try {
ST_Agnode_s tn, hn, ln;
CArray ps = null;
final ST_pathend_t tend = new ST_pathend_t(), hend = new ST_pathend_t();
final ST_boxf lb = new ST_boxf();
int boxn, i, ydelta;
int pn[] = new int[1];
ST_Agedge_s f;
final CArray points = CArray.ALLOC__(7, ST_pointf.class);
tn = agtail(e);
hn = aghead(e);
for (f = ED_to_virt(e); ED_to_virt(f)!=null; f = ED_to_virt(f));
ln = agtail(f);
ED_label(e).pos.___(ND_coord(ln));
ED_label(e).set= NOTI(false);
if (et == (1 << 1)) {
UNSUPPORTED("ataaqkehwb736ts2x6olzqokx"); // pointf startp, endp, lp;
UNSUPPORTED("48h6vk2e5niep4dmpua377248"); // startp = add_pointf(ND_coord(tn), ED_tail_port(e).p);
UNSUPPORTED("8fokfn1629eyiqnzi7mey9o2q"); // endp = add_pointf(ND_coord(hn), ED_head_port(e).p);
UNSUPPORTED("8zpih1olxdgp3sxk2br3lezzx"); // lp = ED_label(e)->pos;
UNSUPPORTED("1sblcap44288tmc3cr80iqpj5"); // lp.y -= (ED_label(e)->dimen.y)/2.0;
UNSUPPORTED("8ew9p3k3j0b33dnq0ntgbb6x8"); // points[1] = points[0] = startp;
UNSUPPORTED("16h577fdghqtaeot735guew4e"); // points[2] = points[3] = points[4] = lp;
UNSUPPORTED("9zjfovamhwwehbviws68s5woy"); // points[5] = points[6] = endp;
UNSUPPORTED("68ojpcos92c96bc0i5ag1yb6v"); // ps = points;
UNSUPPORTED("1uunj4jbr2uhiqxwor6rzmr3j"); // pn = 7;
}
else {
lb.LL.x = ND_coord(ln).x - ND_lw(ln);
lb.UR.x = ND_coord(ln).x + ND_rw(ln);
lb.UR.y = ND_coord(ln).y + ND_ht(ln)/2;
ydelta = (int)(ND_coord(ln).y - GD_rank(g).get__(ND_rank(tn)).ht1 -
ND_coord(tn).y + GD_rank(g).get__(ND_rank(tn)).ht2);
ydelta = (int)(ydelta / 6.);
lb.LL.y = lb.UR.y - MAX(5.,ydelta);
boxn = 0;
makeFlatEnd (g, sp, P, tn, e, tend, true);
makeFlatEnd (g, sp, P, hn, e, hend, false);
Z.z().boxes[boxn].LL.x = tend.boxes[tend.boxn[0] - 1].LL.x;
Z.z().boxes[boxn].LL.y = tend.boxes[tend.boxn[0] - 1].UR.y;
Z.z().boxes[boxn].UR.x = lb.LL.x;
Z.z().boxes[boxn].UR.y = lb.LL.y;
boxn++;
Z.z().boxes[boxn].LL.x = tend.boxes[tend.boxn[0] - 1].LL.x;
Z.z().boxes[boxn].LL.y = lb.LL.y;
Z.z().boxes[boxn].UR.x = hend.boxes[hend.boxn[0] - 1].UR.x;
Z.z().boxes[boxn].UR.y = lb.UR.y;
boxn++;
Z.z().boxes[boxn].LL.x = lb.UR.x;
Z.z().boxes[boxn].UR.y = lb.LL.y;
Z.z().boxes[boxn].LL.y = hend.boxes[hend.boxn[0] - 1].UR.y;
Z.z().boxes[boxn].UR.x = hend.boxes[hend.boxn[0] - 1].UR.x;
boxn++;
for (i = 0; i < tend.boxn[0]; i++) add_box(P, tend.boxes[i]);
for (i = 0; i < boxn; i++) add_box(P, Z.z().boxes[i]);
for (i = hend.boxn[0] - 1; i >= 0; i--) add_box(P, hend.boxes[i]);
if (et == (5 << 1)) ps = routesplines(P, pn);
else ps = routepolylines(P, pn);
if (pn[0] == 0) return;
}
clip_and_install(e, aghead(e), ps, pn[0], Z.z().sinfo);
} finally {
LEAVING("w8ptjibydq995d2lexg85mku","make_flat_labeled_edge");
}
}
//3 d97ga7gm34rs6r0jo494nhhuo
// static void make_flat_bottom_edges(graph_t* g, spline_info_t* sp, path * P, edge_t ** edges, int ind, int cnt, edge_t* e, int splines)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="make_flat_bottom_edges", key="d97ga7gm34rs6r0jo494nhhuo", definition="static void make_flat_bottom_edges(graph_t* g, spline_info_t* sp, path * P, edge_t ** edges, int ind, int cnt, edge_t* e, int splines)")
public static Object make_flat_bottom_edges(Object... arg_) {
UNSUPPORTED("e2z2o5ybnr5tgpkt8ty7hwan1"); // static void
UNSUPPORTED("bkp39vt080is6iiqobsw59sk9"); // make_flat_bottom_edges(graph_t* g, spline_info_t* sp, path * P, edge_t ** edges, int
UNSUPPORTED("2gat0ltxh7j57lspwmm9s9x7j"); // ind, int cnt, edge_t* e, int splines)
UNSUPPORTED("erg9i1970wdri39osu8hx2a6e"); // {
UNSUPPORTED("5np4z3gp6cfmicyuz91nownp8"); // node_t *tn, *hn;
UNSUPPORTED("3zgmm04g7gq65c57gco0id1eb"); // int j, i, r;
UNSUPPORTED("5wdd96amz7w1sym59mg5nfj51"); // double stepx, stepy, vspace;
UNSUPPORTED("63ozqzusft8gpehyaqrdjyr1"); // rank_t* nextr;
UNSUPPORTED("7hps2kejtrotcphg5gymma43b"); // int pn;
UNSUPPORTED("2rkzhui0essisp5zlw44vx4j9"); // pointf *ps;
UNSUPPORTED("32b8td88encjfj6yd1sp8bef"); // pathend_t tend, hend;
UNSUPPORTED("d0x4emyekwlcpua99voy3764p"); // tn = agtail(e);
UNSUPPORTED("axoua6xpo7xc40u2oj0a8dmr9"); // hn = aghead(e);
UNSUPPORTED("63jjxtcojh1aq4na9u4w2a6xe"); // r = ND_rank(tn);
UNSUPPORTED("atjnavwfg3xe4ygorslb4vvtv"); // if (r < GD_maxrank(g)) {
UNSUPPORTED("6b35lbhficoaf5216p3sdq1cj"); // nextr = GD_rank(g) + (r+1);
UNSUPPORTED("bj0cch0dmhpux7wm3fg4zg368"); // vspace = ND_coord(tn).y - GD_rank(g)[r].pht1 -
UNSUPPORTED("dqcrkagghulp8u9iuoyckepf7"); // (ND_coord(nextr->v[0]).y + nextr->pht2);
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("1nyzbeonram6636b1w955bypn"); // else {
UNSUPPORTED("1sai54q4zfayczfcrklgw4x17"); // vspace = GD_ranksep(g);
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("dyxkx5ftlgbeem7089pcu1qo4"); // stepx = ((double)(sp->Multisep)) / (cnt+1);
UNSUPPORTED("63qqo8mqbn6alfa5k3gfalz53"); // stepy = vspace / (cnt+1);
UNSUPPORTED("euw24sa4cgazdf9z7a3sretis"); // makeBottomFlatEnd (g, sp, P, tn, e, &tend, NOT(0));
UNSUPPORTED("c8ip2hla7pb8tz4fhsj5m34wk"); // makeBottomFlatEnd (g, sp, P, hn, e, &hend, 0);
UNSUPPORTED("1psokm6w9e7qw7fm2g1cayuk7"); // for (i = 0; i < cnt; i++) {
UNSUPPORTED("3smlz0a87gj8w58rwau2ewq23"); // int boxn;
UNSUPPORTED("bg5tj2hjixth58v04043jb3do"); // boxf b;
UNSUPPORTED("8hwholxjp08y4q0zbb561684q"); // e = edges[ind + i];
UNSUPPORTED("cpcqkqkhkaviy153h92apd82e"); // boxn = 0;
UNSUPPORTED("4wkbaj2424ug9j97efwu1r5mc"); // b = tend.boxes[tend.boxn - 1];
UNSUPPORTED("3eyfj1o1bqxlfqw7tq76qiiiz"); // boxes[boxn].LL.x = b.LL.x;
UNSUPPORTED("dwlejn7xasxh4yyoq2xodqnyj"); // boxes[boxn].UR.y = b.LL.y;
UNSUPPORTED("10o1e4r5ux8d7cr6zg379ss59"); // boxes[boxn].UR.x = b.UR.x + (i + 1) * stepx;
UNSUPPORTED("79f4mryzkqqs3t4sxnet9jc7b"); // boxes[boxn].LL.y = b.LL.y - (i + 1) * stepy;
UNSUPPORTED("cbrsymd5wpvadg3ziz4dypa50"); // boxn++;
UNSUPPORTED("7n7f256w4ewtzexwfxjo28b2"); // boxes[boxn].LL.x = tend.boxes[tend.boxn - 1].LL.x;
UNSUPPORTED("6in0ql0upnjg00mgj5k8av2m4"); // boxes[boxn].UR.y = boxes[boxn-1].LL.y;
UNSUPPORTED("46ftsiqovpzo9r0mnlc4nf83"); // boxes[boxn].UR.x = hend.boxes[hend.boxn - 1].UR.x;
UNSUPPORTED("4bjnn4mhczzd1un9rbib5glch"); // boxes[boxn].LL.y = boxes[boxn].UR.y - stepy;
UNSUPPORTED("cbrsymd5wpvadg3ziz4dypa50"); // boxn++;
UNSUPPORTED("6oycftap8apw4glb1s5jzineu"); // b = hend.boxes[hend.boxn - 1];
UNSUPPORTED("77c1sajrw9kfc7avomly90gm8"); // boxes[boxn].UR.x = b.UR.x;
UNSUPPORTED("e94nxsepfdq17q69drbro41je"); // boxes[boxn].UR.y = b.LL.y;
UNSUPPORTED("6cipt7th0uv2xfwyh4rvwignj"); // boxes[boxn].LL.x = b.LL.x - (i + 1) * stepx;
UNSUPPORTED("50uajtfbvgkrruywpjq9m4zoj"); // boxes[boxn].LL.y = boxes[boxn-1].UR.y;
UNSUPPORTED("cbrsymd5wpvadg3ziz4dypa50"); // boxn++;
UNSUPPORTED("eu29s7oeoca2yo9trhfhb9juy"); // for (j = 0; j < tend.boxn; j++) add_box(P, tend.boxes[j]);
UNSUPPORTED("b8xs00axp4lkksof6hmim3n3x"); // for (j = 0; j < boxn; j++) add_box(P, boxes[j]);
UNSUPPORTED("ahci7z910ypoj0e54wchvk54v"); // for (j = hend.boxn - 1; j >= 0; j--) add_box(P, hend.boxes[j]);
UNSUPPORTED("7r9nsxbfy7w3csc04nxo97xpq"); // if (splines) ps = routesplines(P, &pn);
UNSUPPORTED("dfku80ag90r137s9az9493oow"); // else ps = routepolylines(P, &pn);
UNSUPPORTED("919jubmuis4tp1c1f87rvfhog"); // if (pn == 0)
UNSUPPORTED("6cprbghvenu9ldc0ez1ifc63q"); // return;
UNSUPPORTED("62oxk9cc5wf0f8gqbothfte1f"); // clip_and_install(e, aghead(e), ps, pn, &sinfo);
UNSUPPORTED("l1nh40fo9oar4mz31h14bc9i"); // P->nbox = 0;
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("c24nfmv9i7o5eoqaymbibp7m7"); // }
throw new UnsupportedOperationException();
}
/* make_flat_edge:
* Construct flat edges edges[ind...ind+cnt-1]
* There are 4 main cases:
* - all edges between a and b where a and b are adjacent
* - one labeled edge
* - all non-labeled edges with identical ports between non-adjacent a and b
* = connecting bottom to bottom/left/right - route along bottom
* = the rest - route along top
*/
//3 6yr3jfkljl5w0z6dv354ryx63
// static void make_flat_edge(graph_t* g, spline_info_t* sp, path * P, edge_t ** edges, int ind, int cnt, int et)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="make_flat_edge", key="6yr3jfkljl5w0z6dv354ryx63", definition="static void make_flat_edge(graph_t* g, spline_info_t* sp, path * P, edge_t ** edges, int ind, int cnt, int et)")
public static void make_flat_edge(ST_Agraph_s g, ST_spline_info_t sp, ST_path P, CArrayOfStar edges, int ind, int cnt, int et) {
ENTERING("6yr3jfkljl5w0z6dv354ryx63","make_flat_edge");
try {
ST_Agnode_s tn, hn;
final ST_Agedgeinfo_t fwdedgei = new ST_Agedgeinfo_t();
final ST_Agedgepair_s fwdedge = new ST_Agedgepair_s();
ST_Agedge_s e;
int j, i, r, isAdjacent;
double stepx, stepy, vspace;
int tside, hside;
int pn[] = new int[] {0};
CArray ps;
final ST_pathend_t tend = new ST_pathend_t(), hend = new ST_pathend_t();
fwdedge.out.base.data = fwdedgei;
/* Get sample edge; normalize to go from left to right */
e = edges.get_(ind);
isAdjacent = ED_adjacent(e);
if ((ED_tree_index(e) & 32)!=0) {
MAKEFWDEDGE(fwdedge.out, e);
e = (ST_Agedge_s) fwdedge.out;
}
for (i = 1; i < cnt; i++) {
if (ED_adjacent(edges.get_(ind+i))!=0) {
isAdjacent = 1;
break;
}
}
/* The lead edge edges[ind] might not have been marked earlier as adjacent,
* so check them all.
*/
if (isAdjacent!=0) {
make_flat_adj_edges (g, P, edges, ind, cnt, e, et);
return;
}
if (ED_label(e)!=null) { /* edges with labels aren't multi-edges */
make_flat_labeled_edge (g, sp, P, e, et);
return;
}
if (et == (1 << 1)) {
makeSimpleFlat (agtail(e), aghead(e), edges, ind, cnt, et);
return;
}
tside = ED_tail_port(e).side;
hside = ED_head_port(e).side;
if (((tside == (1<<0)) && (hside != (1<<2))) ||
((hside == (1<<0)) && (tside != (1<<2)))) {
make_flat_bottom_edges (g, sp, P, edges, ind, cnt, e, et == (5 << 1));
return;
}
tn = agtail(e);
hn = aghead(e);
r = ND_rank(tn);
if (r > 0) {
CArray prevr;
if ((GD_has_labels(g) & (1 << 0))!=0)
prevr = GD_rank(g).plus_(r-2);
else
prevr = GD_rank(g).plus_(r-1);
vspace = ND_coord(prevr.get__(0).v.get_(0)).y - prevr.get__(0).ht1 - ND_coord(tn).y - GD_rank(g).get__(r).ht2;
}
else {
vspace = GD_ranksep(g);
}
stepx = ((double)sp.Multisep) / (cnt+1);
stepy = vspace / (cnt+1);
makeFlatEnd (g, sp, P, tn, e, tend, true);
makeFlatEnd (g, sp, P, hn, e, hend, false);
for (i = 0; i < cnt; i++) {
int boxn;
final ST_boxf b = new ST_boxf();
e = edges.get_(ind + i);
boxn = 0;
b.___(tend.boxes[tend.boxn[0] - 1]);
Z.z().boxes[boxn].LL.x = b.LL.x;
Z.z().boxes[boxn].LL.y = b.UR.y;
Z.z().boxes[boxn].UR.x = b.UR.x + (i + 1) * stepx;
Z.z().boxes[boxn].UR.y = b.UR.y + (i + 1) * stepy;
boxn++;
Z.z().boxes[boxn].LL.x = (tend.boxes[tend.boxn[0] - 1]).LL.x;
Z.z().boxes[boxn].LL.y = (Z.z().boxes[boxn-1]).UR.y;
Z.z().boxes[boxn].UR.x = (hend.boxes[hend.boxn[0] - 1]).UR.x;
Z.z().boxes[boxn].UR.y = Z.z().boxes[boxn].LL.y + stepy;
boxn++;
b.___(hend.boxes[hend.boxn[0] - 1]);
Z.z().boxes[boxn].UR.x = b.UR.x;
Z.z().boxes[boxn].LL.y = b.UR.y;
Z.z().boxes[boxn].LL.x = b.LL.x - (i + 1) * stepx;
Z.z().boxes[boxn].UR.y = (Z.z().boxes[boxn-1]).LL.y;
boxn++;
for (j = 0; j < tend.boxn[0]; j++) add_box(P, tend.boxes[j]);
for (j = 0; j < boxn; j++) add_box(P, Z.z().boxes[j]);
for (j = hend.boxn[0] - 1; j >= 0; j--) add_box(P, hend.boxes[j]);
if (et == (5 << 1)) ps = routesplines(P, pn);
else ps = routepolylines(P, pn);
if (pn[0] == 0)
return;
clip_and_install(e, aghead(e), ps, pn[0], Z.z().sinfo);
P.nbox = 0;
}
} finally {
LEAVING("6yr3jfkljl5w0z6dv354ryx63","make_flat_edge");
}
}
//3 2n9bpvx34fnukqu1f9u4v7v6n
// static int makeLineEdge(graph_t* g, edge_t* fe, pointf* points, node_t** hp)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="makeLineEdge", key="2n9bpvx34fnukqu1f9u4v7v6n", definition="static int makeLineEdge(graph_t* g, edge_t* fe, pointf* points, node_t** hp)")
public static int makeLineEdge(ST_Agraph_s g, ST_Agedge_s fe, __ptr__ points, __ptr__ hp) {
ENTERING("2n9bpvx34fnukqu1f9u4v7v6n","makeLineEdge");
try {
UNSUPPORTED("d9cz56vtrl0ri6hz88cumukuf"); // static int
UNSUPPORTED("1act0rov08v6lg5ydqldks7d1"); // makeLineEdge(graph_t* g, edge_t* fe, pointf* points, node_t** hp)
UNSUPPORTED("erg9i1970wdri39osu8hx2a6e"); // {
UNSUPPORTED("awgar8whid8l1c7lyj8w53w3i"); // int delr, pn;
UNSUPPORTED("ewlm0dtv1gpudqhfx5nsr9d77"); // node_t* hn;
UNSUPPORTED("cncpk333257fxnc9w8kfl8m70"); // node_t* tn;
UNSUPPORTED("etezq0kgy6mttiwr53pna62d7"); // edge_t* e = fe;
UNSUPPORTED("3ll9r1mvzzbhqrs4dwsduif44"); // pointf startp, endp, lp;
UNSUPPORTED("bgjjpl6jaaa122twwwd0vif6x"); // pointf dimen;
UNSUPPORTED("gdtli7sq5cifvdpg3ecrudew"); // double width, height;
UNSUPPORTED("1pa1p9mnpooqack43qfpnoio2"); // while (ED_edge_type(e) != 0)
UNSUPPORTED("bdmai1d040qmubf08ds339v9x"); // e = ED_to_orig(e);
UNSUPPORTED("axoua6xpo7xc40u2oj0a8dmr9"); // hn = aghead(e);
UNSUPPORTED("d0x4emyekwlcpua99voy3764p"); // tn = agtail(e);
UNSUPPORTED("b4x4vd9cei4o3tjifzw7pdec6"); // delr = ABS(ND_rank(hn)-ND_rank(tn));
UNSUPPORTED("447fk34earndyf1qvvzttsxtk"); // if ((delr == 1) || ((delr == 2) && (GD_has_labels(g) & (1 << 0))))
UNSUPPORTED("c9ckhc8veujmwcw0ar3u3zld4"); // return 0;
UNSUPPORTED("cbnarpi971ox21zdds7a60axh"); // if (agtail(fe) == agtail(e)) {
UNSUPPORTED("o7usaxh5vv7rla55dxzkfmk7"); // *hp = hn;
UNSUPPORTED("48h6vk2e5niep4dmpua377248"); // startp = add_pointf(ND_coord(tn), ED_tail_port(e).p);
UNSUPPORTED("8fokfn1629eyiqnzi7mey9o2q"); // endp = add_pointf(ND_coord(hn), ED_head_port(e).p);
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("1nyzbeonram6636b1w955bypn"); // else {
UNSUPPORTED("3uxftvwe3olgfi579s8izpl76"); // *hp = tn;
UNSUPPORTED("akhrhgryddg74jqispnh1j1nn"); // startp = add_pointf(ND_coord(hn), ED_head_port(e).p);
UNSUPPORTED("dqdai9l5thna19ynowkfwstuh"); // endp = add_pointf(ND_coord(tn), ED_tail_port(e).p);
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("brrmfllffwlnqxljgrwy8x5pq"); // if (ED_label(e)) {
UNSUPPORTED("et7phi46cskfaxzpfo97e1s5s"); // dimen = ED_label(e)->dimen;
UNSUPPORTED("z26zaj60vrdy38k1c2vk7law"); // if (GD_flip(agraphof(hn))) {
UNSUPPORTED("6mcl7j0bp09d061f0dywd1ru8"); // width = dimen.y;
UNSUPPORTED("eax7dzvpgqzsiffa2dn2idrxe"); // height = dimen.x;
UNSUPPORTED("flupwh3kosf3fkhkxllllt1"); // }
UNSUPPORTED("8k75h069sv2k9b6tgz77dscwd"); // else {
UNSUPPORTED("de3o94hui5i4dbq9moun6h57f"); // width = dimen.x;
UNSUPPORTED("41ge1nnwfokwi43f6tlkgmvb0"); // height = dimen.y;
UNSUPPORTED("flupwh3kosf3fkhkxllllt1"); // }
UNSUPPORTED("d9umd1qjkl4kkybpd7se993ij"); // lp = ED_label(e)->pos, lp;
UNSUPPORTED("arxilpbzpy5a2s8skwl644jj2"); // if (leftOf (endp,startp,lp)) {
UNSUPPORTED("7bfb4rovu9obr4fje0hi95e67"); // lp.x += width/2.0;
UNSUPPORTED("7y2ejp6vr760aqh5qp4v5zdc8"); // lp.y -= height/2.0;
UNSUPPORTED("9l9roc1u8a03ljwm2mmeaiqq2"); // }
UNSUPPORTED("8k75h069sv2k9b6tgz77dscwd"); // else {
UNSUPPORTED("a4spf3n199lr00qkdb3vb8i6c"); // lp.x -= width/2.0;
UNSUPPORTED("f15m64yxj1oq475bvrt63d5gf"); // lp.y += height/2.0;
UNSUPPORTED("flupwh3kosf3fkhkxllllt1"); // }
UNSUPPORTED("8ew9p3k3j0b33dnq0ntgbb6x8"); // points[1] = points[0] = startp;
UNSUPPORTED("16h577fdghqtaeot735guew4e"); // points[2] = points[3] = points[4] = lp;
UNSUPPORTED("9zjfovamhwwehbviws68s5woy"); // points[5] = points[6] = endp;
UNSUPPORTED("1uunj4jbr2uhiqxwor6rzmr3j"); // pn = 7;
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("1nyzbeonram6636b1w955bypn"); // else {
UNSUPPORTED("8ew9p3k3j0b33dnq0ntgbb6x8"); // points[1] = points[0] = startp;
UNSUPPORTED("aztkfl5qctibiu6en7xf6xf3e"); // points[3] = points[2] = endp;
UNSUPPORTED("5rmgdadjn23z8djo32eh9bhzd"); // pn = 4;
UNSUPPORTED("dvgyxsnyeqqnyzq696k3vskib"); // }
UNSUPPORTED("abnopd2ggrpdb538wf7zsmrhq"); // return pn;
UNSUPPORTED("c24nfmv9i7o5eoqaymbibp7m7"); // }
throw new UnsupportedOperationException();
} finally {
LEAVING("2n9bpvx34fnukqu1f9u4v7v6n","makeLineEdge");
}
}
private static final int NUMPTS = 2000;
//3 30wfq1dby4t07hft9io52nq6z
// static void make_regular_edge(graph_t* g, spline_info_t* sp, path * P, edge_t ** edges, int ind, int cnt, int et)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="make_regular_edge", key="30wfq1dby4t07hft9io52nq6z", definition="static void make_regular_edge(graph_t* g, spline_info_t* sp, path * P, edge_t ** edges, int ind, int cnt, int et)")
public static void make_regular_edge(ST_Agraph_s g, ST_spline_info_t sp, ST_path P, CArrayOfStar edges, int ind, int cnt, int et) {
ENTERING("30wfq1dby4t07hft9io52nq6z","make_regular_edge");
try {
ST_Agnode_s tn, hn = null;
final ST_Agedgeinfo_t fwdedgeai = new ST_Agedgeinfo_t(), fwdedgebi = new ST_Agedgeinfo_t(), fwdedgei = new ST_Agedgeinfo_t();
final ST_Agedgepair_s fwdedgea = new ST_Agedgepair_s(), fwdedgeb = new ST_Agedgepair_s(), fwdedge = new ST_Agedgepair_s();
ST_Agedge_s e, fe, le, segfirst;
CArray ps = null;
final ST_pathend_t tend = new ST_pathend_t(), hend = new ST_pathend_t();
final ST_boxf b = new ST_boxf();
int boxn, sl, si, i, j, dx, hackflag, longedge;
boolean smode;
int pn[] = new int[] {0};
int pointn[] = new int[] {0};
fwdedgea.out.base.data = fwdedgeai;
fwdedgeb.out.base.data = fwdedgebi;
fwdedge.out.base.data = fwdedgei;
if (N(Z.z().pointfs)) {
Z.z().pointfs = CArray.ALLOC__(NUMPTS, ST_pointf.class);
Z.z().pointfs2 = CArray.ALLOC__(NUMPTS, ST_pointf.class);
Z.z().numpts = NUMPTS;
Z.z().numpts2 = NUMPTS;
}
sl = 0;
e = edges.get_(ind);
hackflag = 0;
if (ABS(ND_rank(agtail(e)) - ND_rank(aghead(e))) > 1) {
UNSUPPORTED("8f17srpa5iisomehrb4b01h51"); // fwdedgeai = *(Agedgeinfo_t*)e->base.data;
UNSUPPORTED("97znyysf99vzzwpgnqcpp5yek"); // fwdedgea.out = *e;
UNSUPPORTED("b6jipryp9p354gtq9lwa35lzj"); // fwdedgea.out.base.data = (Agrec_t*)&fwdedgeai;
UNSUPPORTED("568s5ftes1chv9n1s98g9cncf"); // if (ED_tree_index(e) & 32) {
UNSUPPORTED("9hw2l0eu91vauhvj3cxf3andc"); // MAKEFWDEDGE(&fwdedgeb.out, e);
UNSUPPORTED("1rql0qzotc0yyozcfkj9p8xkm"); // agtail(&fwdedgea.out) = aghead(e);
UNSUPPORTED("dw3p473qmkgjvxewsr8pimi2h"); // ED_tail_port(&fwdedgea.out) = ED_head_port(e);
UNSUPPORTED("7yhr8hn3r6wohafwxrt85b2j2"); // } else {
UNSUPPORTED("2gys0bodxz4fbasfnrvx6ivg2"); // fwdedgebi = *(Agedgeinfo_t*)e->base.data;
UNSUPPORTED("1qqbo2mfls7xhbdno0no8xq54"); // fwdedgeb.out = *e;
UNSUPPORTED("980ksnsma7kvvr9755ge8bhzh"); // fwdedgeb.out.base.data = (Agrec_t*)&fwdedgebi;
UNSUPPORTED("6le0rehxs2odmv3zg1qg5wvd4"); // agtail(&fwdedgea.out) = agtail(e);
UNSUPPORTED("flupwh3kosf3fkhkxllllt1"); // }
UNSUPPORTED("3p0d08nntark676jlv1jl0j27"); // le = getmainedge(e);
UNSUPPORTED("6tmwmfqoz3y8k44xamrpv82tl"); // while (ED_to_virt(le))
UNSUPPORTED("1c19c7ftue4zoibf7d2tm6uxy"); // le = ED_to_virt(le);
UNSUPPORTED("d29k9lzj5g3d8dfxigwogdnoe"); // aghead(&fwdedgea.out) = aghead(le);
UNSUPPORTED("36l0czce101bg0wbmu68xjd7z"); // ED_head_port(&fwdedgea.out).defined = 0;
UNSUPPORTED("497rb9p6jdgdoyem0y42ecy6c"); // ED_edge_type(&fwdedgea.out) = 1;
UNSUPPORTED("4tjj1vbw4mog2qlouazrdirvw"); // ED_head_port(&fwdedgea.out).p.x = ED_head_port(&fwdedgea.out).p.y = 0;
UNSUPPORTED("8kdma1vi9aibo7isrge0lunrh"); // ED_to_orig(&fwdedgea.out) = e;
UNSUPPORTED("eih8eaai768x1un5mixrtgstp"); // e = &fwdedgea.out;
UNSUPPORTED("bxkpl0bp0qhtxaj6rspd19d1k"); // hackflag = NOT(0);
} else {
if ((ED_tree_index(e) & BWDEDGE)!=0) {
MAKEFWDEDGE(fwdedgea.out, e);
e = fwdedgea.out;
}
}
fe = e;
/* compute the spline points for the edge */
if ((et == ET_LINE) && (pointn[0] = makeLineEdge (g, fe, Z.z().pointfs, hn.unsupported()))!=0) {
}
else {
boolean splines = (et == ET_SPLINE);
boxn = 0;
pointn[0] = 0;
segfirst = e;
tn = agtail(e);
hn = aghead(e);
b.___(maximal_bbox(g, sp, tn, null, e));
tend.nb.___(b);
beginpath(P, e, REGULAREDGE, tend, spline_merge(tn));
b.UR.y = tend.boxes[tend.boxn[0] - 1].UR.y;
b.LL.y = tend.boxes[tend.boxn[0] - 1].LL.y;
b.___(makeregularend(b, BOTTOM,
ND_coord(tn).y - GD_rank(g).get__(ND_rank(tn)).ht1));
if (b.LL.x < b.UR.x && b.LL.y < b.UR.y)
tend.boxes[tend.boxn[0]++].___(b);
longedge = 0;
smode = false; si = -1;
while (ND_node_type(hn) == VIRTUAL && N(((Boolean)Z.z().sinfo.splineMerge.exe(hn)).booleanValue())) {
longedge = 1;
Z.z().boxes[boxn++].___(rank_box(sp, g, ND_rank(tn)));
if (N(smode)
&& ((sl = straight_len(hn)) >=
((GD_has_labels(g) & EDGE_LABEL)!=0 ? 4 + 1 : 2 + 1))) {
smode = true;
si = 1; sl -= 2;
}
if (N(smode) || si > 0) {
si--;
Z.z().boxes[boxn++].___(maximal_bbox(g, sp, hn, e, ND_out(hn).list.get_(0)));
e = ND_out(hn).list.get_(0);
tn = agtail(e);
hn = aghead(e);
continue;
}
hend.nb.___(maximal_bbox(g, sp, hn, e, ND_out(hn).list.get_(0)));
endpath(P, e, 1, hend, spline_merge(aghead(e)));
b.___(makeregularend(hend.boxes[hend.boxn[0] - 1], (1<<2),
ND_coord(hn).y + GD_rank(g).get__(ND_rank(hn)).ht2));
if (b.LL.x < b.UR.x && b.LL.y < b.UR.y)
UNSUPPORTED("1crhubfzekx1qi2ti9ajqsfoc"); // hend.boxes[hend.boxn++] = b;
P.end.theta = M_PI / 2;
P.end.constrained= true;
completeregularpath(P, segfirst, e, tend, hend, Z.z().boxes, boxn, 1);
if (splines) ps = routesplines(P, pn);
else {
UNSUPPORTED("biyp75vm751j3qmqacagfej4b"); // ps = routepolylines (P, &pn);
UNSUPPORTED("4fmdmgg43suu7ppgrcaofwqzh"); // if ((et == (1 << 1)) && (pn > 4)) {
UNSUPPORTED("2ftwbx9nsy10ldzds3ej4hxi7"); // ps[1] = ps[0];
UNSUPPORTED("2fedie0btpk43e74p462n0y4n"); // ps[3] = ps[2] = ps[pn-1];
UNSUPPORTED("3fwatldph3opctz8aieqd214d"); // pn = 4;
UNSUPPORTED("6eq5kf0bj692bokt0bixy1ixh"); // }
}
if (pn[0] == 0)
return;
if (pointn[0] + pn[0] > Z.z().numpts) {
/* This should be enough to include 3 extra points added by
* straight_path below.
*/
UNSUPPORTED("k37sqlxbjikqg4xdonnvefo3"); // numpts = 2*(pointn+pn);
UNSUPPORTED("8kbxhk7qirj3tr7hn1ukwar3h"); // pointfs = RALLOC(numpts, pointfs, pointf);
}
for (i = 0; i < pn[0]; i++) {
Z.z().pointfs.get__(pointn[0]++).___(ps.get__(i));
}
e = straight_path((ST_Agedge_s)ND_out(hn).list.get_(0), sl, Z.z().pointfs, pointn);
recover_slack(segfirst, P);
segfirst = e;
tn = agtail(e);
hn = aghead(e);
boxn = 0;
tend.nb.___(maximal_bbox(g, sp, tn, (ST_Agedge_s) ND_in(tn).list.get_(0), e));
beginpath(P, e, 1, tend, spline_merge(tn));
b.___(makeregularend(tend.boxes[tend.boxn[0] - 1], (1<<0),
ND_coord(tn).y - GD_rank(g).get__(ND_rank(tn)).ht1));
if (b.LL.x < b.UR.x && b.LL.y < b.UR.y)
UNSUPPORTED("cjx6tldge3otk1pk6ks1pkn2w"); // tend.boxes[tend.boxn++] = b;
P.start.theta = -M_PI / 2;
P.start.constrained= true;
smode = false;
}
Z.z().boxes[boxn++].___(rank_box(sp, g, ND_rank(tn)));
b.___(maximal_bbox(g, sp, hn, e, null));
hend.nb.___(b);
endpath(P, (ST_Agedge_s) (hackflag!=0 ? fwdedgeb.out : e), 1, hend, spline_merge(aghead(e)));
b.UR.y = hend.boxes[hend.boxn[0] - 1].UR.y;
b.LL.y = hend.boxes[hend.boxn[0] - 1].LL.y;
b.___(makeregularend(b, (1<<2),
ND_coord(hn).y + GD_rank(g).get__(ND_rank(hn)).ht2));
if (b.LL.x < b.UR.x && b.LL.y < b.UR.y)
{
hend.boxes[hend.boxn[0]].___(b);
hend.boxn[0] = hend.boxn[0]+1;
}
completeregularpath(P, segfirst, e, tend, hend, Z.z().boxes, boxn,
longedge);
if (splines) ps = routesplines(P, pn);
else ps = routepolylines (P, pn);
if ((et == ET_LINE) && (pn[0] > 4)) {
/* Here we have used the polyline case to handle
* an edge between two nodes on adjacent ranks. If the
* results really is a polyline, straighten it.
*/
UNSUPPORTED("1u7e6lrkiipml54kkm7ylw56t"); // ps[1] = ps[0];
UNSUPPORTED("76bh6z0xok01d0gdybxcx4ful"); // ps[3] = ps[2] = ps[pn-1];
UNSUPPORTED("95b6xp8h5ai070bekyjhmiehh"); // pn = 4;
}
if (pn[0] == 0)
return;
if (pointn[0] + pn[0] > Z.z().numpts) {
UNSUPPORTED("c6ux5effs02grz7xh3k8ernda"); // numpts = 2*(pointn+pn);
UNSUPPORTED("bedaqcn9h03q6ia6zbezuee1m"); // pointfs = RALLOC(numpts, pointfs, pointf);
}
for (i = 0; i < pn[0]; i++) {
Z.z().pointfs.get__(pointn[0]).___(ps.get__(i));
pointn[0]++;
}
recover_slack(segfirst, P);
hn = hackflag!=0 ? aghead(fwdedgeb.out) : aghead(e);
}
/* make copies of the spline points, one per multi-edge */
if (cnt == 1) {
clip_and_install(fe, hn, Z.z().pointfs, pointn[0], Z.z().sinfo);
return;
}
dx = sp.Multisep * (cnt - 1) / 2;
for (i = 1; i < pointn[0] - 1; i++)
Z.z().pointfs.get__(i).x = Z.z().pointfs.get__(i).x - dx;
if (Z.z().numpts > Z.z().numpts2) {
UNSUPPORTED("9ubr4m7bdv5f5ldk2ta6yw3up"); // numpts2 = numpts;
UNSUPPORTED("8qwp7ddy5ztgam63fzfjmu890"); // pointfs2 = RALLOC(numpts2, pointfs2, pointf);
}
for (i = 0; i < pointn[0]; i++)
Z.z().pointfs2.get__(i).___(Z.z().pointfs.get__(i));
clip_and_install(fe, hn, Z.z().pointfs2, pointn[0], Z.z().sinfo);
for (j = 1; j < cnt; j++) {
e = edges.get_(ind + j);
if ((ED_tree_index(e) & 32)!=0) {
MAKEFWDEDGE(fwdedge.out, e);
e = fwdedge.out;
}
for (i = 1; i < pointn[0] - 1; i++)
Z.z().pointfs.get__(i).x = Z.z().pointfs.get__(i).x + sp.Multisep;
for (i = 0; i < pointn[0]; i++)
Z.z().pointfs2.get__(i).___(Z.z().pointfs.get__(i));
clip_and_install(e, aghead(e), Z.z().pointfs2, pointn[0], Z.z().sinfo);
}
} finally {
LEAVING("30wfq1dby4t07hft9io52nq6z","make_regular_edge");
}
}
//3 va61hggynvb6z6j34w7otmab
// static void completeregularpath(path * P, edge_t * first, edge_t * last, pathend_t * tendp, pathend_t * hendp, boxf * boxes, int boxn, int flag)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="completeregularpath", key="va61hggynvb6z6j34w7otmab", definition="static void completeregularpath(path * P, edge_t * first, edge_t * last, pathend_t * tendp, pathend_t * hendp, boxf * boxes, int boxn, int flag)")
public static void completeregularpath(ST_path P, ST_Agedge_s first, ST_Agedge_s last, ST_pathend_t tendp, ST_pathend_t hendp, ST_boxf[] boxes, int boxn, int flag) {
ENTERING("va61hggynvb6z6j34w7otmab","completeregularpath");
try {
ST_Agedge_s uleft, uright, lleft, lright;
int i, fb, lb;
ST_splines spl;
CArray pp;
int pn;
fb = lb = -1;
uleft = uright = null;
uleft = top_bound(first, -1);
uright = top_bound(first, 1);
if (uleft!=null) {
if (N(spl = getsplinepoints(uleft))) return;
pp = spl.list.get__(0).list;
pn = spl.list.get__(0).size;
}
if (uright!=null) {
if (N(spl = getsplinepoints(uright))) return;
pp = spl.list.get__(0).list;
pn = spl.list.get__(0).size;
}
lleft = lright = null;
lleft = bot_bound(last, -1);
lright = bot_bound(last, 1);
if (lleft!=null) {
if (N(spl = getsplinepoints(lleft))) return;
pp = spl.list.get__(spl.size - 1).list;
pn = spl.list.get__(spl.size - 1).size;
}
if (lright!=null) {
if (N(spl = getsplinepoints(lright))) return;
pp = spl.list.get__(spl.size - 1).list;
pn = spl.list.get__(spl.size - 1).size;
}
for (i = 0; i < tendp.boxn[0]; i++)
add_box(P, (tendp).boxes[i]);
fb = P.nbox + 1;
lb = fb + boxn - 3;
for (i = 0; i < boxn; i++)
add_box(P, boxes[i]);
for (i = hendp.boxn[0] - 1; i >= 0; i--)
add_box(P, (hendp).boxes[i]);
adjustregularpath(P, fb, lb);
} finally {
LEAVING("va61hggynvb6z6j34w7otmab","completeregularpath");
}
}
//3 3wwhczhpkcnflwr1l9wcga7tq
// static boxf makeregularend(boxf b, int side, double y)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="makeregularend", key="3wwhczhpkcnflwr1l9wcga7tq", definition="static boxf makeregularend(boxf b, int side, double y)")
public static ST_boxf makeregularend(final ST_boxf b, int side, double y) {
// WARNING!! STRUCT
return makeregularend_w_(b.copy(), side, y).copy();
}
private static ST_boxf makeregularend_w_(final ST_boxf b, int side, double y) {
ENTERING("3wwhczhpkcnflwr1l9wcga7tq","makeregularend");
try {
final ST_boxf newb = new ST_boxf();
switch (side) {
case (1<<0):
newb.___(boxfof(b.LL.x, y, b.UR.x, b.LL.y));
break;
case (1<<2):
newb.___(boxfof(b.LL.x, b.UR.y, b.UR.x, y));
break;
}
return newb;
} finally {
LEAVING("3wwhczhpkcnflwr1l9wcga7tq","makeregularend");
}
}
//3 88xrlzjovkxcnay9b2y5zyiid
// static void adjustregularpath(path * P, int fb, int lb)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="adjustregularpath", key="88xrlzjovkxcnay9b2y5zyiid", definition="static void adjustregularpath(path * P, int fb, int lb)")
public static void adjustregularpath(ST_path P, int fb, int lb) {
ENTERING("88xrlzjovkxcnay9b2y5zyiid","adjustregularpath");
try {
ST_boxf bp1, bp2;
int i, x;
for (i = fb-1; i < lb+1; i++) {
bp1 = (ST_boxf) P.boxes[i];
if ((i - fb) % 2 == 0) {
if (bp1.LL.x >= bp1.UR.x) {
x = (int)((bp1.LL.x + bp1.UR.x) / 2);
bp1.LL.x = x - 8;
bp1.UR.x = x + 8;
}
} else {
if (bp1.LL.x + 16 > bp1.UR.x) {
x = (int)((bp1.LL.x + bp1.UR.x) / 2);
bp1.LL.x = x - 8;
bp1.UR.x = x + 8;
}
}
}
for (i = 0; i < P.nbox - 1; i++) {
bp1 = (ST_boxf) P.boxes[i];
bp2 = (ST_boxf) P.boxes[i+1];
if (i >= fb && i <= lb && (i - fb) % 2 == 0) {
if (bp1.LL.x + 16 > bp2.UR.x)
bp2.UR.x = bp1.LL.x + 16;
if (bp1.UR.x - 16 < bp2.LL.x)
bp2.LL.x = bp1.UR.x - 16;
} else if (i + 1 >= fb && i < lb && (i + 1 - fb) % 2 == 0) {
if (bp1.LL.x + 16 > bp2.UR.x)
bp1.LL.x = bp2.UR.x - 16;
if (bp1.UR.x - 16 < bp2.LL.x)
bp1.UR.x = bp2.LL.x + 16;
}
}
} finally {
LEAVING("88xrlzjovkxcnay9b2y5zyiid","adjustregularpath");
}
}
//3 bajn5vx0isu427n6dh131b985
// static boxf rank_box(spline_info_t* sp, graph_t * g, int r)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="rank_box", key="bajn5vx0isu427n6dh131b985", definition="static boxf rank_box(spline_info_t* sp, graph_t * g, int r)")
public static ST_boxf rank_box(ST_spline_info_t sp, ST_Agraph_s g, int r) {
// WARNING!! STRUCT
return rank_box_w_(sp, g, r).copy();
}
private static ST_boxf rank_box_w_(ST_spline_info_t sp, ST_Agraph_s g, int r) {
ENTERING("bajn5vx0isu427n6dh131b985","rank_box");
try {
final ST_boxf b = new ST_boxf();
ST_Agnode_s /* *right0, *right1, */ left0, left1;
b.___(sp.Rank_box[r]);
if (b.LL.x == b.UR.x) {
left0 = (ST_Agnode_s) GD_rank(g).get__(r).v.get_(0);
/* right0 = GD_rank(g)[r].v[GD_rank(g)[r].n - 1]; */
left1 = (ST_Agnode_s) GD_rank(g).get__(r + 1).v.get_(0);
/* right1 = GD_rank(g)[r + 1].v[GD_rank(g)[r + 1].n - 1]; */
b.LL.x = sp.LeftBound;
b.LL.y = ND_coord(left1).y + GD_rank(g).get__(r + 1).ht2;
b.UR.x = sp.RightBound;
b.UR.y = ND_coord(left0).y - GD_rank(g).get__(r).ht1;
sp.Rank_box[r].___(b);
}
return b;
} finally {
LEAVING("bajn5vx0isu427n6dh131b985","rank_box");
}
}
//3 6qwcnugx2ytjrvi5rgxzyzg5i
// static int straight_len(node_t * n)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="straight_len", key="6qwcnugx2ytjrvi5rgxzyzg5i", definition="static int straight_len(node_t * n)")
public static int straight_len(ST_Agnode_s n) {
ENTERING("6qwcnugx2ytjrvi5rgxzyzg5i","straight_len");
try {
int cnt = 0;
ST_Agnode_s v;
v = n;
while (true) {
v = (ST_Agnode_s) aghead(ND_out(v).list.get_(0));
if (ND_node_type(v) != 1)
break;
if ((ND_out(v).size != 1) || (ND_in(v).size != 1))
break;
if (ND_coord(v).x != ND_coord(n).x)
break;
cnt++;
}
return cnt;
} finally {
LEAVING("6qwcnugx2ytjrvi5rgxzyzg5i","straight_len");
}
}
//3 15pgjjuil2c1rjldu29j07gbz
// static edge_t *straight_path(edge_t * e, int cnt, pointf * plist, int *np)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="", key="15pgjjuil2c1rjldu29j07gbz", definition="static edge_t *straight_path(edge_t * e, int cnt, pointf * plist, int *np)")
public static ST_Agedge_s straight_path(ST_Agedge_s e, int cnt, CArray plist, int np[]) {
ENTERING("15pgjjuil2c1rjldu29j07gbz","straight_path");
try {
int n = np[0];
ST_Agedge_s f = e;
while ((cnt--)!=0)
f = (ST_Agedge_s) ND_out(aghead(f)).list.get_(0);
plist.get__(np[0]++).___(plist.get__(n - 1));
plist.get__(np[0]++).___(plist.get__(n - 1));
plist.get__(np[0]).___(ND_coord(agtail(f))); /* will be overwritten by next spline */
return f;
} finally {
LEAVING("15pgjjuil2c1rjldu29j07gbz","straight_path");
}
}
//3 4ilkzqtegd5uffawb4qcjthu1
// static void recover_slack(edge_t * e, path * p)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="recover_slack", key="4ilkzqtegd5uffawb4qcjthu1", definition="static void recover_slack(edge_t * e, path * p)")
public static void recover_slack(ST_Agedge_s e, ST_path p) {
ENTERING("4ilkzqtegd5uffawb4qcjthu1","recover_slack");
try {
int b;
ST_Agnode_s vn;
b = 0; /* skip first rank box */
for (vn = aghead(e);
ND_node_type(vn) == 1 && N(((Boolean)Z.z().sinfo.splineMerge.exe(vn)).booleanValue());
vn = aghead(ND_out(vn).list.get_(0))) {
while ((b < p.nbox) && (p.boxes[b].LL.y > ND_coord(vn).y))
b++;
if (b >= p.nbox)
break;
if (p.boxes[b].UR.y < ND_coord(vn).y)
continue;
if (ND_label(vn)!=null)
resize_vn(vn, (int)p.boxes[b].LL.x, (int)p.boxes[b].UR.x,
(int)(p.boxes[b].UR.x + ND_rw(vn)));
else
resize_vn(vn, (int)p.boxes[b].LL.x, (int)((p.boxes[b].LL.x +
p.boxes[b].UR.x) / 2),
(int)p.boxes[b].UR.x);
}
} finally {
LEAVING("4ilkzqtegd5uffawb4qcjthu1","recover_slack");
}
}
//3 3vmg1q1r0eb14etvjdk4cukpd
// static void resize_vn(vn, lx, cx, rx) node_t *vn
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="resize_vn", key="3vmg1q1r0eb14etvjdk4cukpd", definition="static void resize_vn(vn, lx, cx, rx) node_t *vn")
public static void resize_vn(ST_Agnode_s vn, int lx, int cx, int rx) {
ENTERING("3vmg1q1r0eb14etvjdk4cukpd","resize_vn");
try {
ND_coord(vn).x = cx;
ND_lw(vn, cx - lx);
ND_rw(vn, rx - cx);
} finally {
LEAVING("3vmg1q1r0eb14etvjdk4cukpd","resize_vn");
}
}
//3 9t0v5wicmjuc3ij9hko6iawle
// static edge_t *top_bound(edge_t * e, int side)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="", key="9t0v5wicmjuc3ij9hko6iawle", definition="static edge_t *top_bound(edge_t * e, int side)")
public static ST_Agedge_s top_bound(ST_Agedge_s e, int side) {
ENTERING("9t0v5wicmjuc3ij9hko6iawle","top_bound");
try {
ST_Agedge_s f, ans = null;
int i;
for (i = 0; (f = (ST_Agedge_s) ND_out(agtail(e)).list.get_(i))!=null; i++) {
if (side * (ND_order(aghead(f)) - ND_order(aghead(e))) <= 0)
continue;
if ((ED_spl(f) == null)
&& ((ED_to_orig(f) == null) || (ED_spl(ED_to_orig(f)) == null)))
continue;
if ((ans == null)
|| (side * (ND_order(aghead(ans)) - ND_order(aghead(f))) > 0))
ans = f;
}
return ans;
} finally {
LEAVING("9t0v5wicmjuc3ij9hko6iawle","top_bound");
}
}
//3 9fsg0uiyhtrayd4mimmc0i25e
// static edge_t *bot_bound(edge_t * e, int side)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="", key="9fsg0uiyhtrayd4mimmc0i25e", definition="static edge_t *bot_bound(edge_t * e, int side)")
public static ST_Agedge_s bot_bound(ST_Agedge_s e, int side) {
ENTERING("9fsg0uiyhtrayd4mimmc0i25e","bot_bound");
try {
ST_Agedge_s f, ans = null;
int i;
for (i = 0; (f = (ST_Agedge_s) ND_in(aghead(e)).list.get_(i))!=null; i++) {
if (side * (ND_order(agtail(f)) - ND_order(agtail(e))) <= 0)
continue;
if ((ED_spl(f) == null)
&& ((ED_to_orig(f) == null) || (ED_spl(ED_to_orig(f)) == null)))
continue;
if ((ans == null)
|| (side * (ND_order(agtail(ans)) - ND_order(agtail(f))) > 0))
ans = f;
}
return ans;
} finally {
LEAVING("9fsg0uiyhtrayd4mimmc0i25e","bot_bound");
}
}
//3 65uvkv1mextaah5m997ibe3qs
// static int cl_vninside(graph_t * cl, node_t * n)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="cl_vninside", key="65uvkv1mextaah5m997ibe3qs", definition="static int cl_vninside(graph_t * cl, node_t * n)")
public static boolean cl_vninside(ST_Agraph_s cl, ST_Agnode_s n) {
ENTERING("65uvkv1mextaah5m997ibe3qs","cl_vninside");
try {
return (BETWEEN(GD_bb(cl).LL.x, (double)(ND_coord(n).x), GD_bb(cl).UR.x) &&
BETWEEN(GD_bb(cl).LL.y, (double)(ND_coord(n).y), GD_bb(cl).UR.y));
} finally {
LEAVING("65uvkv1mextaah5m997ibe3qs","cl_vninside");
}
}
//3 dzvvmxkya868w5x78lkvchigk
// static Agraph_t *cl_bound(graph_t* g, node_t *n, node_t *adj)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="", key="dzvvmxkya868w5x78lkvchigk", definition="static Agraph_t *cl_bound(graph_t* g, node_t *n, node_t *adj)")
public static ST_Agraph_s cl_bound(ST_Agraph_s g, ST_Agnode_s n, ST_Agnode_s adj) {
ENTERING("dzvvmxkya868w5x78lkvchigk","cl_bound");
try {
ST_Agraph_s rv, cl, tcl, hcl;
ST_Agedge_s orig;
rv = null;
if (ND_node_type(n) == 0)
tcl = hcl = ND_clust(n);
else {
orig = ED_to_orig(ND_out(n).list.get_(0));
tcl = ND_clust(agtail(orig));
hcl = ND_clust(aghead(orig));
}
if (ND_node_type(adj) == 0) {
cl = ( EQ(ND_clust(adj), g) ? null:ND_clust(adj));
if (cl!=null && NEQ(cl, tcl) && NEQ(cl, hcl))
rv = cl;
} else {
orig = ED_to_orig(ND_out(adj).list.get_(0));
cl = ( EQ(ND_clust(agtail(orig)), g) ? null:ND_clust(agtail(orig)));
if (cl!=null && NEQ(cl, tcl) && NEQ(cl, hcl) && cl_vninside(cl, adj))
rv = cl;
else {
cl = ( EQ(ND_clust(aghead(orig)), g) ? null:ND_clust(aghead(orig)));
if (cl!=null && NEQ(cl, tcl) && NEQ(cl, hcl) && cl_vninside(cl, adj))
rv = cl;
}
}
return rv;
} finally {
LEAVING("dzvvmxkya868w5x78lkvchigk","cl_bound");
}
}
private final static int FUDGE = 4;
//3 6qwgl36ugfnduc5x59ohuewv1
// static boxf maximal_bbox(graph_t* g, spline_info_t* sp, node_t* vn, edge_t* ie, edge_t* oe)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="maximal_bbox", key="6qwgl36ugfnduc5x59ohuewv1", definition="static boxf maximal_bbox(graph_t* g, spline_info_t* sp, node_t* vn, edge_t* ie, edge_t* oe)")
public static ST_boxf maximal_bbox(ST_Agraph_s g, ST_spline_info_t sp, ST_Agnode_s vn, ST_Agedge_s ie, ST_Agedge_s oe) {
// WARNING!! STRUCT
return maximal_bbox_w_(g, sp, vn, ie, oe).copy();
}
private static ST_boxf maximal_bbox_w_(ST_Agraph_s g, ST_spline_info_t sp, ST_Agnode_s vn, ST_Agedge_s ie, ST_Agedge_s oe) {
ENTERING("6qwgl36ugfnduc5x59ohuewv1","maximal_bbox");
try {
double b, nb;
ST_Agraph_s left_cl, right_cl;
ST_Agnode_s left, right;
final ST_boxf rv = new ST_boxf();
left_cl = right_cl = null;
/* give this node all the available space up to its neighbors */
b = (double)(ND_coord(vn).x - ND_lw(vn) - FUDGE);
if ((left = neighbor(g, vn, ie, oe, -1))!=null) {
if ((left_cl = cl_bound(g, vn, left))!=null)
nb = GD_bb(left_cl).UR.x + (double)(sp.Splinesep);
else {
nb = (double)(ND_coord(left).x + ND_mval(left));
if (ND_node_type(left) == NORMAL)
nb += GD_nodesep(g) / 2.;
else
nb += (double)(sp.Splinesep);
}
if (nb < b)
b = nb;
rv.LL.x = ROUND(b);
} else
rv.LL.x = MIN(ROUND(b), sp.LeftBound);
/* we have to leave room for our own label! */
if ((ND_node_type(vn) == VIRTUAL) && (ND_label(vn)!=null))
b = (double)(ND_coord(vn).x + 10);
else
b = (double)(ND_coord(vn).x + ND_rw(vn) + FUDGE);
if ((right = neighbor(g, vn, ie, oe, 1))!=null) {
if ((right_cl = cl_bound(g, vn, right))!=null)
nb = GD_bb(right_cl).LL.x - (double)(sp.Splinesep);
else {
nb = ND_coord(right).x - ND_lw(right);
if (ND_node_type(right) == NORMAL)
nb -= GD_nodesep(g) / 2.;
else
nb -= (double)(sp.Splinesep);
}
if (nb > b)
b = nb;
rv.UR.x = ROUND(b);
} else
rv.UR.x = MAX(ROUND(b), sp.RightBound);
if ((ND_node_type(vn) == VIRTUAL) && (ND_label(vn)!=null)) {
rv.UR.x = rv.UR.x - ND_rw(vn);
if (rv.UR.x < rv.LL.x) rv.UR.x = ND_coord(vn).x;
}
rv.LL.y = ND_coord(vn).y - GD_rank(g).get__(ND_rank(vn)).ht1;
rv.UR.y = ND_coord(vn).y + GD_rank(g).get__(ND_rank(vn)).ht2;
return rv;
} finally {
LEAVING("6qwgl36ugfnduc5x59ohuewv1","maximal_bbox");
}
}
//3 18pm6r3xcy90f0xi5hpm9jdhk
// static node_t * neighbor(graph_t* g, node_t *vn, edge_t *ie, edge_t *oe, int dir)
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="neighbor", key="18pm6r3xcy90f0xi5hpm9jdhk", definition="static node_t * neighbor(graph_t* g, node_t *vn, edge_t *ie, edge_t *oe, int dir)")
public static ST_Agnode_s neighbor(ST_Agraph_s g, ST_Agnode_s vn, ST_Agedge_s ie, ST_Agedge_s oe, int dir) {
ENTERING("18pm6r3xcy90f0xi5hpm9jdhk","neighbor");
try {
int i;
ST_Agnode_s n, rv = null;
CArray rank = GD_rank(g).plus_(ND_rank(vn));
for (i = ND_order(vn) + dir; ((i >= 0) && (i < rank.get__(0).n)); i += dir) {
n = rank.get__(0).v.get_(i);
if ((ND_node_type(n) == 1) && (ND_label(n)!=null)) {
rv = n;
break;
}
if (ND_node_type(n) == 0) {
rv = n;
break;
}
if (pathscross(n, vn, ie, oe) == false) {
rv = n;
break;
}
}
return rv;
} finally {
LEAVING("18pm6r3xcy90f0xi5hpm9jdhk","neighbor");
}
}
//3 f4q0oqe165s9pl5k0th5noeyv
// static boolean pathscross(n0, n1, ie1, oe1) node_t *n0, *n1
@Unused
@Original(version="2.38.0", path="lib/dotgen/dotsplines.c", name="pathscross", key="f4q0oqe165s9pl5k0th5noeyv", definition="static boolean pathscross(n0, n1, ie1, oe1) node_t *n0, *n1")
public static boolean pathscross(ST_Agnode_s n0, ST_Agnode_s n1, ST_Agedge_s ie1, ST_Agedge_s oe1) {
ENTERING("f4q0oqe165s9pl5k0th5noeyv","pathscross");
try {
ST_Agedge_s e0, e1;
ST_Agnode_s na, nb;
boolean order;
int cnt;
order = (ND_order(n0) > ND_order(n1));
if ((ND_out(n0).size != 1) && (ND_out(n0).size != 1))
return false;
e1 = oe1;
if (ND_out(n0).size == 1 && e1!=null) {
e0 = (ST_Agedge_s) ND_out(n0).list.get_(0);
for (cnt = 0; cnt < 2; cnt++) {
if (EQ(na = aghead(e0), nb = aghead(e1)))
break;
if (order != (ND_order(na) > ND_order(nb)))
return true;
if ((ND_out(na).size != 1) || (ND_node_type(na) == 0))
break;
e0 = (ST_Agedge_s) ND_out(na).list.get_(0);
if ((ND_out(nb).size != 1) || (ND_node_type(nb) == 0))
break;
e1 = (ST_Agedge_s) ND_out(nb).list.get_(0);
}
}
e1 = ie1;
if (ND_in(n0).size == 1 && e1!=null) {
e0 = (ST_Agedge_s) ND_in(n0).list.get_(0);
for (cnt = 0; cnt < 2; cnt++) {
if (EQ(na = agtail(e0), nb = agtail(e1)))
break;
if (order != (ND_order(na) > ND_order(nb)))
return true;
if ((ND_in(na).size != 1) || (ND_node_type(na) == 0))
break;
e0 = (ST_Agedge_s) ND_in(na).list.get_(0);
if ((ND_in(nb).size != 1) || (ND_node_type(nb) == 0))
break;
e1 = (ST_Agedge_s) ND_in(nb).list.get_(0);
}
}
return false;
} finally {
LEAVING("f4q0oqe165s9pl5k0th5noeyv","pathscross");
}
}
}
