internal static void DragEdge(Point delta, GeomEdge e, EdgeRestoreData edgeRestoreData,
Set <GeometryObject> objectsMarkedToDrag)
{
Site site = null;
if (objectsMarkedToDrag.Contains(e.Source))
{
if (!objectsMarkedToDrag.Contains(e.Target))
{
site = e.UnderlyingPolyline.HeadSite;
}
}
else
{
site = e.UnderlyingPolyline.LastSite;
}
if (site == null)
{
TranslateEdge(e, delta, edgeRestoreData);
}
else
{
DragEdgeWithSite(delta, e, site);
}
}
public static GeometryGraph CopyGraph(GeometryGraph graph)
{
if (graph == null) return null;
var copy = new GeometryGraph();
Dictionary<Node,Node> nodeCopy=new Dictionary<Node, Node>(graph.Nodes.Count);
foreach (Node node in graph.Nodes) {
var c = new Node();
copy.Nodes.Add(c);
nodeCopy[node] = c;
c.BoundaryCurve = node.BoundaryCurve.Clone();
}
foreach (Edge edge in graph.Edges) {
var source = edge.Source;
var target = edge.Target;
var copySource = nodeCopy[source];
var copyTarget = nodeCopy[target];
Edge edgeCopy=new Edge(copySource,copyTarget);
copy.Edges.Add(edgeCopy);
StraightLineEdges.RouteEdge(edgeCopy,0);
}
return copy;
}
public static GeometryGraph CopyGraph(GeometryGraph graph)
{
if (graph == null)
{
return(null);
}
var copy = new GeometryGraph();
Dictionary <Node, Node> nodeCopy = new Dictionary <Node, Node>(graph.Nodes.Count);
foreach (Node node in graph.Nodes)
{
var c = new Node();
copy.Nodes.Add(c);
nodeCopy[node] = c;
c.BoundaryCurve = node.BoundaryCurve.Clone();
}
foreach (Edge edge in graph.Edges)
{
var source = edge.Source;
var target = edge.Target;
var copySource = nodeCopy[source];
var copyTarget = nodeCopy[target];
Edge edgeCopy = new Edge(copySource, copyTarget);
copy.Edges.Add(edgeCopy);
StraightLineEdges.RouteEdge(edgeCopy, 0);
}
return(copy);
}
static Dictionary <GeomEdge, double> GetMiddleAnglesOfMultiedge(List <GeomEdge> multiedge, GeomNode node)
{
var ret = new Dictionary <GeomEdge, double>();
GeomEdge firstEdge = multiedge[0];
Point a = node.Center;
Point b = Middle(firstEdge.Curve);
ret[firstEdge] = 0;
for (int i = 1; i < multiedge.Count; i++)
{
GeomEdge edge = multiedge[i];
Point c = Middle(edge.Curve);
double angle = Point.Angle(b, a, c);
if (angle > Math.PI)
{
angle = angle - Math.PI * 2;
}
ret[edge] = angle;
}
return(ret);
}
///// <summary>
///// Creates a curve by using the underlying polyline
///// </summary>
///// <param name="underlyingPoly"></param>
///// <returns></returns>
// [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Polyline")]
// static public Curve CreateCurveFromEdgeUnderlyingPolyline(UnderlyingPolyline underlyingPoly) {
// Curve curve = new Curve();
// Site a = underlyingPoly.HeadSite;//the corner start
// Site b; //the corner origin
// Site c;//the corner other end
// while (SmoothedPolyline.FindCorner(a, out b, out c)) {
// CubicBezierSegment seg = SmoothedPolyline.CreateBezierSeg(b.bezierSegmentShrinkCoefficient, a, b, c);
// if (curve.Segments.Count == 0) {
// if (!ApproximateComparer.Close(a.Point, seg.Start))
// Curve.AddLineSeg(curve, a.Point, seg.Start);
// } else if (!ApproximateComparer.Close(curve.End, seg.Start))
// Routing.ContinueWithLineSeg(curve, seg.Start);
// curve.AddSegment(seg);
// a = b;
// }
// System.Diagnostics.Debug.Assert(a.Next.Next == null);
// if (curve.Segments.Count == 0) {
// if (!ApproximateComparer.Close(a.Point, a.Next.Point)) {
// Curve.AddLineSeg(curve, a.Point, a.Next.Point);
// } else {
// double w=5;
// curve.Segments.Add(new CubicBezierSegment(a.Point, a.Point+new Point(w,w),a.Point+new Point(-w,w), b.Point));
// }
// } else if (!ApproximateComparer.Close(curve.End, a.Next.Point))
// Routing.ContinueWithLineSeg(curve, a.Next.Point);
// return curve;
// }
static void TranslateEdge(GeomEdge e, Point delta, EdgeRestoreData edgeRestoreData)
{
if (edgeRestoreData.Curve != null)
{
e.Curve = edgeRestoreData.Curve.Clone();
e.Curve.Translate(delta);
}
if (e.UnderlyingPolyline != null)
{
for (Site s = e.UnderlyingPolyline.HeadSite, s0 = edgeRestoreData.UnderlyingPolyline.HeadSite;
s != null;
s = s.Next, s0 = s0.Next)
{
s.Point = s0.Point + delta;
}
}
if (e.EdgeGeometry.SourceArrowhead != null)
{
e.EdgeGeometry.SourceArrowhead.TipPosition = edgeRestoreData.ArrowheadAtSourcePosition + delta;
}
if (e.EdgeGeometry.TargetArrowhead != null)
{
e.EdgeGeometry.TargetArrowhead.TipPosition = edgeRestoreData.ArrowheadAtTargetPosition + delta;
}
if (e.Label != null)
{
e.Label.Center = edgeRestoreData.LabelCenter + delta;
}
}
static void CalculateMiddleOffsetsForMultiedge(List <GeomEdge> multiedge, GeomNode node,
Dictionary <GeomEdge, double> offsetsInsideOfMultiedge,
double nodeSeparation)
{
Dictionary <GeomEdge, double> middleAngles = GetMiddleAnglesOfMultiedge(multiedge, node);
var angles = new double[middleAngles.Count];
var edges = new GeomEdge[middleAngles.Count];
int i = 0;
foreach (var v in middleAngles)
{
angles[i] = v.Value;
edges[i] = v.Key;
i++;
}
Array.Sort(angles, edges);
double separation = nodeSeparation * 6;
int k = edges.Length / 2;
bool even = k * 2 == edges.Length;
double off;
if (even)
{
off = -separation / 2;
for (int j = k - 1; j >= 0; j--)
{
GeomEdge edge = edges[j];
offsetsInsideOfMultiedge[edge] = off;
off -= separation + (edge.Label != null ? edge.Label.Width : 0);
}
off = separation / 2;
for (int j = k; j < edges.Length; j++)
{
GeomEdge edge = edges[j];
offsetsInsideOfMultiedge[edge] = off;
off += separation + (edge.Label != null ? edge.Label.Width : 0);
}
}
else
{
off = 0;
for (int j = k; j >= 0; j--)
{
GeomEdge edge = edges[j];
offsetsInsideOfMultiedge[edge] = off;
off -= separation + (edge.Label != null ? edge.Label.Width : 0);
}
off = separation;
for (int j = k + 1; j < edges.Length; j++)
{
GeomEdge edge = edges[j];
offsetsInsideOfMultiedge[edge] = off;
off += separation + (edge.Label != null ? edge.Label.Width : 0);
}
}
}
private void DrawEdge(Edge e, Pen pen, Graphics graphics) {
graphics.DrawPath(pen, CreateGraphicsPath(e.Curve));
if (e.EdgeGeometry != null && e.EdgeGeometry.SourceArrowhead != null)
DrawArrow(e, pen, graphics, e.Curve.Start, e.EdgeGeometry.SourceArrowhead.TipPosition);
if (e.EdgeGeometry != null && e.EdgeGeometry.TargetArrowhead != null)
DrawArrow(e, pen, graphics, e.Curve.End, e.EdgeGeometry.TargetArrowhead.TipPosition);
}
internal void CreateEdge()
{
if (Model == null)
{
return;
}
if (this.Source.Label == null || this.Target.Label == null)
{
return;
}
Dictionary <string, Entity> entitiesLookup = Model.DisplayedSubmodel.Entities.ToDictionary(x => x.Label, y => y);
if ((entitiesLookup.ContainsKey(Source.Label) || entitiesLookup.ContainsKey(Target.Label)) == false)
{
return;
}
if (drawingEdge != null)
{
DeleteDrawingEdge(false);
}
if (Model.Graph != null)
{
drawingEdge = Model.Graph.AddEdge(Source.Label, Target.Label);
drawingEdge.Attr = CreateEdgeAttr();
drawingEdge.Label = CreateLabel(drawingEdge, Model.ShowRelationshipLabels ? Type : "");
LayoutEdge coreEdge = GeometryGraphCreator.CreateGeometryEdgeFromDrawingEdge(drawingEdge);
CreateEdgeCurve(drawingEdge, coreEdge);
Model.GeometryGraph.Edges.Add(coreEdge);
drawingEdge.GeometryEdge = coreEdge;
drawingEdge.UserData = this;
}
else
{
if (IsAddedOnViewGraph)
{
IsAddedOnViewGraph = false;
return;
}
DrawingNode source = Model.GraphEditor.Graph.FindNode(Source.Label);
DrawingNode target = Model.GraphEditor.Graph.FindNode(Target.Label);
if (target != null)
{
drawingEdge = Model.GraphEditor.Viewer.AddEdge(source, target, false);
drawingEdge.Attr = CreateEdgeAttr();
drawingEdge.UserData = this;
}
RenameEdge();
}
}
void ModifyEdgeByScale(Point delta, GeomEdge edge)
{
//StraightLineEdges.CreateSimpleEdgeCurveWithUnderlyingPolyline(edge);
var sn = edge.Source.UserData as Drawing.Node;
var tn = edge.Target.UserData as Drawing.Node;
//var gg = graph.UserData as Graph;
//var vsn = Viewer.GetIViewerObject(sn);
//var vtn = Viewer.GetIViewerObject(tn);
Drawing.Node oN = null, tN = null;
if (Viewer.GetIViewerObject(sn).MarkedForDragging)
{
tN = sn;
oN = tn;
}
else
{
tN = tn;
oN = sn;
}
Point o = oN.Pos, t = tN.Pos, t_ = t - delta;
double scale = (t - o).Length / (t_ - o).Length;
//double angle = Point.Angle(t, o, t_)*180/Math.PI;
double angle = Point.Angle(t, o, t_);
System.Windows.Media.Matrix mm = System.Windows.Media.Matrix.Identity;
//mm.ScaleAt(scale, scale, o.X, o.Y);
mm.RotateAt(angle, o.X, o.Y);
//PlaneTransformation mt = new PlaneTransformation(mm.M11,mm.M12,mm.OffsetX,mm.M21,mm.M22,mm.OffsetY);
var scaleMatrix = new PlaneTransformation(scale, 0, 0, 0, scale, 0);
var translateToOrigin = new PlaneTransformation(1, 0, -o.X, 0, 1, -o.Y);
var translateToNode = new PlaneTransformation(1, 0, o.X, 0, 1, o.Y);
var rotateMatrix = PlaneTransformation.Rotation(-angle);
var matrix = translateToNode * scaleMatrix * rotateMatrix * translateToOrigin;
if (edge.UnderlyingPolyline != null)
{
var ul = edge.UnderlyingPolyline;
if (tN == sn)
{
ul.HeadSite.Point = t;
}
else
{
ul.LastSite.Point = t;
}
for (Site s = ul.HeadSite.Next; s != ul.LastSite; s = s.Next)
{
s.Point = matrix * s.Point;
}
edge.Curve = ul.CreateCurve();
Arrowheads.TrimSplineAndCalculateArrowheads(edge, edge.Curve, true, false);
}
//edge.Curve = edge.Curve.Transform(matrix);
//var angle= Point.Angle(graph.)
}
/// <summary>
/// preparing for an edge corner dragging
/// </summary>
/// <param name="geometryEdge"></param>
/// <param name="site"></param>
/// <returns></returns>
public UndoRedoAction PrepareForEdgeCornerDragging(GeomEdge geometryEdge, Site site)
{
EditedEdge = geometryEdge;
UndoRedoAction edgeDragUndoRedoAction = CreateEdgeEditUndoRedoAction();
// var edgeRestoreDate = (EdgeRestoreData) edgeDragUndoRedoAction.GetRestoreData(geometryEdge);
// edgeRestoreDate.Site = site;
return(InsertToListAndSetTheBoxBefore(edgeDragUndoRedoAction));
}
static Edge NewEdge(GeometryGraph g, int i, int j)
{
var e = new Edge(g.Nodes[i], g.Nodes[j])
{
LineWidth = 0.01
};
return(e);
}
/// <summary>
/// deletes the polyline corner
/// </summary>
/// <param name="edge"></param>
/// <param name="site"></param>
/// <param name="userData">an object to be stored in the unde action</param>
public void DeleteSite(GeomEdge edge, Site site, IViewerObject userData)
{
EditedEdge = edge;
PrepareForPolylineCornerRemoval(userData, site);
site.Previous.Next = site.Next; //removing the site from the list
site.Next.Previous = site.Previous;
//just to recalc everything in a correct way
DragEdgeWithSite(new Point(0, 0), edge,
site.Previous);
}
public void AddEdge(IViewerEdge edge, bool registerForUndo)
{
//if (registerForUndo) drawingLayoutEditor.RegisterEdgeAdditionForUndo(edge);
var drawingEdge = edge.Edge;
Edge geomEdge = drawingEdge.GeometryEdge;
drawingGraph.AddPrecalculatedEdge(drawingEdge);
drawingGraph.GeometryGraph.Edges.Add(geomEdge);
}
static void AddEdgesBetweenColumns(string[] col0, string[] col1, GeometryGraph graph)
{
foreach (var id in col0)
{
Edge edge = new Edge(graph.FindNodeByUserData(id), graph.FindNodeByUserData(col1[r.Next(col1.Length)]));
edge.EdgeGeometry.TargetArrowhead = null;
graph.Edges.Add(edge);
edge = new Edge(graph.FindNodeByUserData(id), graph.FindNodeByUserData(col1[r.Next(col1.Length)]));
graph.Edges.Add(edge);
}
}
static void CreateCurveOnChangedPolyline(GeomEdge e)
{
Curve curve = e.UnderlyingPolyline.CreateCurve();
if (
!Arrowheads.TrimSplineAndCalculateArrowheads(e.EdgeGeometry, e.Source.BoundaryCurve,
e.Target.BoundaryCurve, curve, false, false))
{
Arrowheads.CreateBigEnoughSpline(e);
}
}
/// <summary>
/// insert a polyline corner
/// </summary>
/// <param name="edge"></param>
/// <param name="point">the point to insert the corner</param>
/// <param name="siteBeforeInsertion"></param>
/// <param name="affectedEntity">an object to be stored in the undo action</param>
public void InsertSite(GeomEdge edge, Point point, Site siteBeforeInsertion, IViewerObject affectedEntity)
{
EditedEdge = edge;
//creating the new site
Site first = siteBeforeInsertion;
Site second = first.Next;
var s = new Site(first, point, second);
PrepareForPolylineCornerInsertion(affectedEntity, s);
//just to recalc everything in a correct way
DragEdgeWithSite(new Point(0, 0), edge, s);
}
private void DrawEdge(Edge e, Pen pen, Graphics graphics)
{
graphics.DrawPath(pen, CreateGraphicsPath(e.Curve));
if (e.EdgeGeometry != null && e.EdgeGeometry.SourceArrowhead != null)
{
DrawArrow(e, pen, graphics, e.Curve.Start, e.EdgeGeometry.SourceArrowhead.TipPosition);
}
if (e.EdgeGeometry != null && e.EdgeGeometry.TargetArrowhead != null)
{
DrawArrow(e, pen, graphics, e.Curve.End, e.EdgeGeometry.TargetArrowhead.TipPosition);
}
}
/// <summary>
/// gets the enumerator pointing to the polyline corner before the point
/// </summary>
/// <param name="edge"></param>
/// <param name="point"></param>
/// <returns></returns>
public static Site GetPreviousSite(GeomEdge edge, Point point)
{
Site prevSite = edge.UnderlyingPolyline.HeadSite;
Site nextSite = prevSite.Next;
do
{
if (BetweenSites(prevSite, nextSite, point))
{
return(prevSite);
}
prevSite = nextSite;
nextSite = nextSite.Next;
} while (nextSite != null);
return(null);
}
void CreateEdgeCurve(DrawingEdge de, LayoutEdge le)
{
var a = de.SourceNode.GeometryNode.Center;
var b = de.TargetNode.GeometryNode.Center;
Site start, end, mids;
if (Source.Label == Target.Label)
{
start = new Site(a);
end = new Site(b);
var mid1 = de.SourceNode.GeometryNode.Center;
mid1.X += (de.SourceNode.GeometryNode.BoundingBox.Width / 3 * 2);
var mid2 = mid1;
mid1.Y -= de.SourceNode.GeometryNode.BoundingBox.Height / 2;
mid2.Y += de.SourceNode.GeometryNode.BoundingBox.Height / 2;
Site mid1s = new Site(mid1);
Site mid2s = new Site(mid2);
start.Next = mid1s;
mid1s.Previous = start;
mid1s.Next = mid2s;
mid2s.Previous = mid1s;
mid2s.Next = end;
end.Previous = mid2s;
}
else
{
start = new Site(a);
end = new Site(b);
mids = new Site(a * 0.5 + b * 0.5);
start.Next = mids;
mids.Previous = start;
mids.Next = end;
end.Previous = mids;
}
SmoothedPolyline polyline = new SmoothedPolyline(start);
le.UnderlyingPolyline = polyline;
le.Curve = polyline.CreateCurve();
if (Arrowheads.TrimSplineAndCalculateArrowheads(le, le.Curve, true, true) == false)
{
Arrowheads.CreateBigEnoughSpline(le);
}
}
/// <summary>
/// Verifies that the edge's label is near the edge.
/// </summary>
private static void VerifyLabelIsNearEdges(Edge edge)
{
Label label = edge.Label;
if (label != null)
{
Rectangle labelBox = label.BoundingBox;
Point[] edgePoints = edge.GetPoints();
Point[] labelPoints = new[] { labelBox.Center, labelBox.LeftTop, labelBox.LeftBottom, labelBox.RightBottom, labelBox.RightTop };
if (!edgePoints.Any(p => labelBox.Contains(p)))
{
// If the edge doesn't intersect the label, check that the label is at least nearby.
// 10 was chosen as the distance tolerance since it is fairly small and passes on pretty much every diagram I tested.
double closestDistance = GetClosestDistance(edgePoints, labelPoints);
Assert.IsTrue(closestDistance < 10, "The label was placed greater than 10 units from the edge.");
}
}
}
private void DrawArrow(Edge e, Pen pen, Graphics graphics, P start, P end)
{
PointF[] points;
float arrowAngle = 30;
P dir = end - start;
P h = dir;
dir /= dir.Length;
P s = new P(-dir.Y, dir.X);
s *= h.Length * ((float)Math.Tan(arrowAngle * 0.5f * (Math.PI / 180.0)));
points = new PointF[] { MsaglPointToDrawingPoint(start + s), MsaglPointToDrawingPoint(end), MsaglPointToDrawingPoint(start - s) };
graphics.FillPolygon(pen.Brush, points);
}
static void TestFD()
{
GeometryGraph graph = CreateGeometryGraphForFD();
//LayoutAlgorithmSettings.ShowGraph(graph);
var settings = new FastIncrementalLayoutSettings {
AvoidOverlaps = true,
ApplyForces = false,
RungeKuttaIntegration = true
};
var ir = new InitialLayout(graph, settings);
ir.Run();
RouteEdges(graph, settings);
//LayoutAlgorithmSettings.ShowGraph(graph);
// AddNodeFd(graph);
var n = new Node(CurveFactory.CreateDiamond(200, 200, new Point(350, 230)));
var e = new Edge(n, graph.Nodes[42]);
graph.Edges.Add(e);
e = new Edge(n, graph.Nodes[6]);
graph.Edges.Add(e);
e = new Edge(n, graph.Nodes[12]);
graph.Edges.Add(e);
graph.Nodes.Add(n);
graph.RootCluster.AddChild(n);
settings.algorithm = new FastIncrementalLayout(graph, settings, settings.MaxConstraintLevel, f => settings);
settings.Unconverge();
settings.CreateLock(n, new Rectangle(200, 400, 500, 100));
do
{
settings.IncrementalRun(graph);
} while (!settings.Converged);
RouteEdges(graph, settings);
#if TEST_MSAGL
LayoutAlgorithmSettings.ShowGraph(graph);
#endif
Environment.Exit(0);
}
private static void AddEdge(Microsoft.Msagl.Drawing.Node a, Microsoft.Msagl.Drawing.Node b, Graph graph)
{
var de = new Microsoft.Msagl.Drawing.Edge(a, b, ConnectionToGraph.Connected);
de.Attr.LineWidth = Math.Max(1, (int)(a.Width / 10));
de.Attr.Color = new Microsoft.Msagl.Drawing.Color(200, 100, 100, 100);
var ge = new Edge(a.GeometryNode, b.GeometryNode);
Point start = a.GeometryNode.Center;
Point end = b.GeometryNode.Center;
Point d = (end - start) / 4;
Point b1 = start + d;
Point b2 = b1 + d;
Point b3 = b2 + d;
ge.EdgeGeometry.Curve = new CubicBezierSegment(start, b1, b2, b3);
ge.EdgeGeometry.TargetArrowhead = new Arrowhead()
{
TipPosition = end
};
de.GeometryEdge = ge;
ge.UserData = de;
}
internal EdgeRestoreData(Edge edge) {
if (edge.UnderlyingPolyline == null) {
var asCurve = (edge.Curve as Curve) ?? new Curve(new List<ICurve> {edge.Curve});
edge.UnderlyingPolyline =
SmoothedPolyline.FromPoints(
new[] {edge.Source.Center}.Concat(Polyline.PolylineFromCurve(asCurve)).
Concat(new[] {edge.Target.Center}));
}
UnderlyingPolyline = edge.UnderlyingPolyline.Clone();
Curve = edge.Curve.Clone();
if (edge.EdgeGeometry.SourceArrowhead != null)
ArrowheadAtSourcePosition = edge.EdgeGeometry.SourceArrowhead.TipPosition;
if (edge.EdgeGeometry.TargetArrowhead != null)
ArrowheadAtTargetPosition = edge.EdgeGeometry.TargetArrowhead.TipPosition;
if (edge.Label != null && edge.UnderlyingPolyline != null) {
labelCenter = edge.Label.Center;
Curve untrimmedCurve = edge.UnderlyingPolyline.CreateCurve();
LabelAttachmentParameter = untrimmedCurve.ClosestParameter(labelCenter);
LabelOffsetFromTheAttachmentPoint = labelCenter - untrimmedCurve[LabelAttachmentParameter];
}
}
IEnumerable <RectangleNode <object> > EdgeRectNodes(GeomEdge edge)
{
const int parts = 64; //divide each edge into 64 segments
var curve = edge.Curve;
double delta = (curve.ParEnd - curve.ParStart) / parts;
Point p0 = curve.Start;
for (int i = 1; i <= parts; i++)
{
yield return(new RectangleNode <object>(edge, new Rectangle(p0, p0 = curve[curve.ParStart + i * delta])));
}
if (edge.ArrowheadAtSource)
{
yield return(new RectangleNode <object>(edge, new Rectangle(edge.EdgeGeometry.SourceArrowhead.TipPosition, curve.Start)));
}
if (edge.ArrowheadAtTarget)
{
yield return(new RectangleNode <object>(edge, new Rectangle(edge.EdgeGeometry.TargetArrowhead.TipPosition, curve.End)));
}
}
private string DotGeomString(Microsoft.Msagl.Core.Layout.Edge geometryEdge)
{
var edgeGeom = geometryEdge.EdgeGeometry;
if (edgeGeom == null)
{
return("");
}
CubicBezierSegment b = edgeGeom.Curve as CubicBezierSegment;
if (b == null)
{
return("");
}
string ret = "";
if (edgeGeom.SourceArrowhead != null)
{
ret += string.Format("s,{0},{1} ", edgeGeom.SourceArrowhead.TipPosition.X, edgeGeom.SourceArrowhead.TipPosition.Y);
}
if (edgeGeom.TargetArrowhead != null)
{
ret += string.Format("e,{0},{1} ", edgeGeom.TargetArrowhead.TipPosition.X, edgeGeom.TargetArrowhead.TipPosition.Y);
}
for (int i = 0; i < 4; i++)
{
ret += string.Format("{0},{1} ", b.B(i).X, b.B(i).Y);
}
return("pos=" + Utils.Quote(ret));
}
/// <summary>
///
/// </summary>
/// <param name="drawingEdge"></param>
/// <returns></returns>
public static Microsoft.Msagl.Core.Layout.Edge CreateGeometryEdgeFromDrawingEdge(Edge drawingEdge)
{
var sourceNode = drawingEdge.SourceNode.GeometryNode;
var targetNode = drawingEdge.TargetNode.GeometryNode;
var msaglEdge = new Microsoft.Msagl.Core.Layout.Edge(sourceNode, targetNode);
drawingEdge.GeometryEdge = msaglEdge;
msaglEdge.SourcePort = drawingEdge.SourcePort;
msaglEdge.TargetPort = drawingEdge.TargetPort;
if (drawingEdge.Label != null)
{
// && graph.LayoutAlgorithmSettings is SugiyamaLayoutSettings &&
// graph.LayoutAlgorithmSettings.routingMode == false){
msaglEdge.Label = drawingEdge.Label.GeometryLabel;
msaglEdge.Label.GeometryParent = msaglEdge;
}
msaglEdge.Weight = drawingEdge.Attr.Weight;
msaglEdge.Length = drawingEdge.Attr.Length;
msaglEdge.Separation = drawingEdge.Attr.Separation;
if (drawingEdge.Attr.ArrowAtSource)
{
msaglEdge.EdgeGeometry.SourceArrowhead = new Arrowhead {
Length = drawingEdge.Attr.ArrowheadLength
};
}
if (drawingEdge.Attr.ArrowAtTarget)
{
msaglEdge.EdgeGeometry.TargetArrowhead = new Arrowhead {
Length = drawingEdge.Attr.ArrowheadLength
};
}
msaglEdge.UserData = drawingEdge;
msaglEdge.LineWidth = drawingEdge.Attr.LineWidth;
return(msaglEdge);
}
static void FixPortAtTarget(Shape shape, Port port, Edge e) {
if (e.TargetPort == null)
e.TargetPort = port;
else
shape.Ports.Insert(e.TargetPort);
}
/// <summary>
/// deletes the polyline corner
/// </summary>
/// <param name="edge"></param>
/// <param name="site"></param>
/// <param name="userData">an object to be stored in the unde action</param>
public void DeleteSite(GeomEdge edge, Site site, IViewerObject userData) {
EditedEdge = edge;
PrepareForPolylineCornerRemoval(userData, site);
site.Previous.Next = site.Next; //removing the site from the list
site.Next.Previous = site.Previous;
//just to recalc everything in a correct way
DragEdgeWithSite(new Point(0, 0), edge,
site.Previous);
}
static void foo(Edge p0) {
p0.Weight *= 2;
p0.LineWidth *= 2;
p0.Weight *= 2;
p0.LineWidth *= 2;
p0.Weight *= 2;
p0.LineWidth *= 2;
p0.Weight *= 2;
if (p0.EdgeGeometry != null)
p0.EdgeGeometry.LineWidth /= 2;
p0.LineWidth *= 2;
}
/// <summary>
/// constructor
/// </summary>
/// <param name="editedEdgePar"></param>
public EdgeDragUndoRedoAction(GeomEdge editedEdgePar) : base((GeometryGraph)editedEdgePar.GeometryParent)
{
editedEdge = editedEdgePar;
}
/// <summary>
/// </summary>
/// <param name="delta">delta of the drag</param>
/// <param name="e">the modified edge</param>
/// <param name="site"></param>
internal static void DragEdgeWithSite(Point delta, GeomEdge e, Site site)
{
e.RaiseLayoutChangeEvent(delta);
site.Point += delta;
CreateCurveOnChangedPolyline(e);
}
static IEnumerable<Edge> CreateEdgesForGroupRouting(IEnumerable<Cluster> clusters) {
var c = GetClusterById(clusters, "c");
var f = GetClusterById(clusters, "f");
var a = c.Clusters.Single(s => s.UserData.Equals("a"));
var b = c.Clusters.Single(s => s.UserData.Equals("b"));
var d = f.Clusters.Single(s => s.UserData.Equals("d"));
var e = f.Clusters.Single(s => s.UserData.Equals("e"));
var h = GetClusterById(clusters, "h");
var g = GetClusterById(clusters, "g");
var l = GetClusterById(clusters, "l");
var k = GetClusterById(clusters, "k");
var ports = new Dictionary<Cluster, Set<Port>>();
AddPortToShape(k, ports, new CurvePort(k.BoundaryCurve, 0.4*(k.BoundaryCurve.ParEnd + k.BoundaryCurve.ParStart)));
AddPortToShape(l, ports);
AddPortToShape(a, ports);
AddPortToShape(b, ports);
AddPortToShape(d, ports);
AddPortToShape(e, ports);
AddPortToShape(h, ports);
AddPortToShape(g, ports);
var hSecondPort = new CurvePort(h.BoundaryCurve, 0.1);
ports[h].Insert(hSecondPort);
var hFreePort = new FloatingPort(null, new Point(-129, -55));
var kFreePort = new FloatingPort(null, new Point(137, -51));
ports[h].Insert(hFreePort);
ports[k].Insert(kFreePort);
var fFreePort = new FloatingPort(null, new Point(3, 3));
var kFreePort0 = new FloatingPort(null, new Point(106, 8));
AddPortToShape(f,ports, fFreePort);
AddPortToShape(k, ports, kFreePort0);
AddPortToShape(c,ports,new CurvePort(c.BoundaryCurve, 0));
AddPortToShape(f, ports,new FloatingPort(f.BoundaryCurve, f.BoundingBox.Center));
var freePort0 = new FloatingPort(null, new Point(72, -1.3));
var halfFreeEdge = new EdgeGeometry(freePort0, ports[a].First());
var freePort1 = new FloatingPort(null, new Point(-122, 110));
var freeEdge = new EdgeGeometry(freePort0, freePort1);
var ab = new EdgeGeometry(ports[a].First(), ports[b].First());
var abE = new Edge(a, b) {EdgeGeometry = ab};
var ae = new EdgeGeometry(ports[a].First(), ports[e].First());
var aeE = new Edge(a, e) {EdgeGeometry = ae};
var de = new EdgeGeometry(ports[d].First(), ports[e].First());
var deE = new Edge(d, e) {EdgeGeometry = de};
var ad = new EdgeGeometry(ports[a].First(), ports[d].First());
var adE = new Edge(a, d) {EdgeGeometry = ad};
var he = new EdgeGeometry(ports[h].First(), ports[e].First());
var heE = new Edge(h, e) {EdgeGeometry = he};
var gd = new EdgeGeometry(ports[g].First(), ports[d].First());
var gdE = new Edge(g, d) {EdgeGeometry = gd};
var lg = new EdgeGeometry(ports[l].First(), ports[g].First());
var lgE = new Edge(l, g) {EdgeGeometry = lg};
var le = new EdgeGeometry(ports[l].First(), ports[e].First());
var leE = new Edge(l, e) {EdgeGeometry = le};
var ca = new EdgeGeometry(ports[c].First(), ports[a].First());
var caE = new Edge(c, a) {EdgeGeometry = ca};
var cd = new EdgeGeometry(ports[c].First(), ports[d].First());
var cdE = new Edge(c, d) {EdgeGeometry = cd};
var hl = new EdgeGeometry(hSecondPort, ports[l].First());
var hlE = new Edge(h, l) {EdgeGeometry = hl};
var lh = new EdgeGeometry(ports[l].First(), hSecondPort);
var lhE = new Edge(l, h) {EdgeGeometry = lh};
var ha = new EdgeGeometry(hSecondPort, ports[a].First());
var haE = new Edge(h, a) {EdgeGeometry = ha};
var hk = new EdgeGeometry(hSecondPort, ports[k].First());
var hkE = new Edge(h, k) {EdgeGeometry = hk};
var hk0 = new EdgeGeometry(hFreePort, kFreePort);
var hk0E = new Edge(h, k) {EdgeGeometry = hk0};
var fk = new EdgeGeometry(fFreePort, kFreePort0);
var fkE = new Edge(f, k) {EdgeGeometry = fk};
var hThirdPort = new CurvePort(h.BoundaryCurve, 0.5);
var halfFreeInside = new EdgeGeometry(ports[b].First(), freePort1);
//var halfFreeInside = new Edge(b, d) { EdgeGeometry = ad };
ports[h].Insert(hThirdPort);
var lSecondPort = new CurvePort(l.BoundaryCurve, 0);
ports[l].Insert(lSecondPort);
var hThirdLSecond = new EdgeGeometry(hThirdPort, lSecondPort);
var hThirdLSecondE = new Edge(h, l) {EdgeGeometry = hThirdLSecond};
// return new[] {
// /*halfFreeInside, freeEdge,*/ halfFreeEdge, lh
// };
return new[] {
lhE, abE, aeE, deE, adE, heE, gdE, lgE, leE, cdE, hlE,
hThirdLSecondE, caE, haE, hkE, hk0E, fkE
};
}
/// <summary>
/// Removes an in-edge from the node's edge list (this won't remove the edge from the graph).
/// </summary>
/// <param name="edge">The edge to be removed</param>
public void RemoveInEdge(Edge edge)
{
inEdges.Remove(edge);
}
internal static ICurve CreateBaseSegmentForDraggingEdgeWithSource(Point delta, GeomEdge edge,
EdgeRestoreData edgeRestoreData,
Dictionary <GeomEdge, double> offsets)
{
double offset;
ICurve seg;
Point a = edgeRestoreData.UnderlyingPolyline.HeadSite.Point + delta;
Point b = edgeRestoreData.UnderlyingPolyline.LastSite.Point;
if (offsets.TryGetValue(edge, out offset) && offset != 0)
{
Point ab = b - a;
Point abOrtog = ab.Normalize().Rotate(Math.PI / 2) * offset;
seg = CreateBaseSegOnSourceTargetAndOrth(ref a, ref b, ref abOrtog);
// SugiyamaLayoutSettings.Show(seg, edge.Curve, edge.Source.BoundaryCurve);
}
else
{
seg = new LineSegment(a, b);
}
return(seg);
}
/// <summary>
/// Removes an out-edge from the node's edge list (this won't remove the edge from the graph).
/// </summary>
/// <param name="edge">The edge to be removed</param>
public void RemoveOutEdge(Edge edge)
{
outEdges.Remove(edge);
}
private static void InsertEdgePortsToShapes(Dictionary<Node, Shape> nodesToShapes, Edge edge) {
nodesToShapes[edge.Target].Ports.Insert(edge.TargetPort);
nodesToShapes[edge.Source].Ports.Insert(edge.SourcePort);
}
public DEdge AddEdgeBetweenNodes(DNode source, DNode target)
{
if (!IsContainedSub(source))
throw new InvalidOperationException("The edge source node must be in the graph or in one of its nested graphs.");
if (!IsContainedSub(target))
throw new InvalidOperationException("The edge target node must be in the graph or in one of its nested graphs.");
if (source.ParentGraph == this && target.ParentGraph == this)
{
DEdge dEdge = new DEdge(source, target, new DrawingEdge(source.Node, target.Node, ConnectionToGraph.Disconnected), ConnectionToGraph.Disconnected);
GeometryEdge gEdge = new GeometryEdge(source.GeometryNode, target.GeometryNode) { GeometryParent = Graph.GeometryGraph };
dEdge.GeometryEdge = gEdge;
dEdge.ArrowheadAtTarget = ArrowStyle.Normal;
AddEdge(dEdge, false);
return dEdge;
}
else
return AddCrossEdge(source, target);
}
/// <summary>
/// Removes a self-edge from the node's edge list (this won't remove the edge from the graph).
/// </summary>
/// <param name="edge">The edge to be removed</param>
public void RemoveSelfEdge(Edge edge)
{
selfEdges.Remove(edge);
}
public FiEdge(Edge mEdge) {
this.mEdge = mEdge;
source = (FiNode) mEdge.Source.AlgorithmData;
target = (FiNode) mEdge.Target.AlgorithmData;
}
public void RouteSelectedEdges(int separation)
{
double nodeSeparation = Graph.LayoutAlgorithmSettings.NodeSeparation;
double nodePadding = nodeSeparation / 3;
double loosePadding = SplineRouter.ComputeLooseSplinePadding(nodeSeparation, nodePadding);
BundlingSettings bundlingSettings = new BundlingSettings() { EdgeSeparation = separation, CreateUnderlyingPolyline = true };
EdgeRoutingSettings settings = new EdgeRoutingSettings() { BundlingSettings = bundlingSettings, EdgeRoutingMode = EdgeRoutingMode };
if (settings.EdgeRoutingMode == EdgeRoutingMode.SugiyamaSplines)
settings.EdgeRoutingMode = EdgeRoutingMode.Spline;
if (Nodes().Any(n => n.MarkedForDragging))
{
Dictionary<DNode, GeometryNode> nodesThisToAux = new Dictionary<DNode, GeometryNode>();
Dictionary<DEdge, GeometryEdge> edgesThisToAux = new Dictionary<DEdge, GeometryEdge>();
GeometryGraph ggAux = new GeometryGraph();
foreach (DNode node in Nodes())
{
var n = new GeometryNode()
{
BoundaryCurve = node.GeometryNode.BoundaryCurve,
GeometryParent = ggAux,
Padding = node.GeometryNode.Padding,
};
ggAux.Nodes.Add(n);
nodesThisToAux[node] = n;
}
foreach (DNode node in Nodes().Where(n => n.MarkedForDragging))
{
foreach (DEdge edge in node.Edges)
{
if (!edgesThisToAux.ContainsKey(edge))
{
var e = new GeometryEdge(nodesThisToAux[edge.Source], nodesThisToAux[edge.Target]);
if (edge.Source == edge.Target)
nodesThisToAux[edge.Source].AddSelfEdge(e);
else
{
nodesThisToAux[edge.Source].AddOutEdge(e);
nodesThisToAux[edge.Target].AddInEdge(e);
}
ggAux.Edges.Add(e);
edgesThisToAux[edge] = e;
}
}
/*ggAux.Nodes.Add(node.GeometryNode);
if (node.MarkedForDragging)
{
foreach (DEdge edge in node.Edges)
{
if (!ggAux.Nodes.Contains(edge.Source.GeometryNode))
ggAux.Nodes.Add(edge.Source.GeometryNode);
if (!ggAux.Nodes.Contains(edge.Target.GeometryNode))
ggAux.Nodes.Add(edge.Target.GeometryNode);
if (!ggAux.Edges.Contains(edge.GeometryEdge))
ggAux.Edges.Add(edge.GeometryEdge);
}
}*/
}
DoEdgeRouting(ggAux, settings, nodeSeparation);
//BundledEdgeRouter.RouteEdgesInMetroMapStyle(ggAux, Math.PI / 6.0, nodePadding, loosePadding, settings);
/*var router = new SplineRouter(ggAux, settings);
router.Run(CancelToken);
VerifyPolylines();*/
foreach (var kv in edgesThisToAux)
kv.Key.GeometryEdge.EdgeGeometry = kv.Value.EdgeGeometry;
}
else
{
DoEdgeRouting(Graph.GeometryGraph, settings, nodeSeparation);
//BundledEdgeRouter.RouteEdgesInMetroMapStyle(Graph.GeometryGraph, Math.PI / 6.0, nodePadding, loosePadding, settings);
/*var router = new SplineRouter(Graph.GeometryGraph, settings);
router.Run(CancelToken);
VerifyPolylines();*/
}
//Invalidate();
}
public void AddSelfEdge(Edge e){
selfEdges.Insert(e);
}
static void DragEdgeAsStraightLine(Point delta, GeomEdge edge)
{
StraightLineEdges.CreateSimpleEdgeCurveWithUnderlyingPolyline(edge);
}
public void AddOutEdge(Edge e){
outEdges.Insert(e);
}
static Edge NewEdge(GeometryGraph g, int i, int j) {
var e= new Edge(g.Nodes[i],g.Nodes[j]) {LineWidth = 0.01};
return e;
}
/// <summary>
/// Constructor. At the moment of the constructor call the site should not be inserted yet
/// </summary>
/// <param name="edgeToEdit"></param>
public SiteInsertUndoAction(GeomEdge edgeToEdit)
: base((GeometryGraph)edgeToEdit.GeometryParent) {
this.editedEdge = edgeToEdit;
this.AddRestoreData(editedEdge, RestoreHelper.GetRestoreData(editedEdge));
}
static void TestFD() {
GeometryGraph graph = CreateGeometryGraphForFD();
//LayoutAlgorithmSettings.ShowGraph(graph);
var settings = new FastIncrementalLayoutSettings {
AvoidOverlaps = true,
ApplyForces = false,
RungeKuttaIntegration = true
};
var ir = new InitialLayout(graph, settings);
ir.Run();
RouteEdges(graph, settings);
//LayoutAlgorithmSettings.ShowGraph(graph);
// AddNodeFd(graph);
var n = new Node(CurveFactory.CreateDiamond(200, 200, new Point(350, 230)));
var e = new Edge(n, graph.Nodes[42]);
graph.Edges.Add(e);
e = new Edge(n, graph.Nodes[6]);
graph.Edges.Add(e);
e = new Edge(n, graph.Nodes[12]);
graph.Edges.Add(e);
graph.Nodes.Add(n);
graph.RootCluster.AddChild(n);
settings.algorithm=new FastIncrementalLayout(graph, settings, settings.MaxConstraintLevel, f=>settings);
settings.Unconverge();
settings.CreateLock(n, new Rectangle(200, 400, 500, 100));
do {
settings.IncrementalRun(graph);
} while (!settings.Converged);
RouteEdges(graph, settings);
#if DEBUG
LayoutAlgorithmSettings.ShowGraph(graph);
#endif
Environment.Exit(0);
}
/// <summary>
/// Constructor. At the moment of the constructor call the site should not be inserted yet
/// </summary>
/// <param name="edgePar"></param>
public SiteRemoveUndoAction(GeomEdge edgePar)
: base((GeometryGraph)edgePar.GeometryParent)
{
this.editedEdge = edgePar;
this.AddRestoreData(editedEdge, RestoreHelper.GetRestoreData(editedEdge));
}
public static void TreeWithConstraints() {
var graph = new GeometryGraph();
var closed = new Node(CreateEllipse(), "clos");
var line = new Node(CreateEllipse(), "line");
var bezier = new Node(CreateEllipse(), "bezi");
var arc = new Node(CreateEllipse(), "arc");
var rectangle = new Node(CreateEllipse(), "rect");
var ellipse = new Node(CreateEllipse(), "elli");
var polygon = new Node(CreateEllipse(), "poly");
var shapes = new Node(CreateEllipse(), "shap");
var open = new Node(CreateEllipse(), "open");
graph.Nodes.Add(closed);
graph.Nodes.Add(line);
graph.Nodes.Add(bezier);
graph.Nodes.Add(arc);
graph.Nodes.Add(rectangle);
graph.Nodes.Add(ellipse);
graph.Nodes.Add(polygon);
graph.Nodes.Add(shapes);
graph.Nodes.Add(open);
var so = new Edge(shapes, open);
var sc = new Edge(shapes, closed);
var ol = new Edge(open, line);
var ob = new Edge(open, bezier);
var oa = new Edge(open, arc);
var cr = new Edge(closed, rectangle);
var ce = new Edge(closed, ellipse);
var cp = new Edge(closed, polygon);
graph.Edges.Add(so);
graph.Edges.Add(sc);
graph.Edges.Add(ol);
graph.Edges.Add(ob);
graph.Edges.Add(oa);
graph.Edges.Add(cr);
graph.Edges.Add(ce);
graph.Edges.Add(cp);
var settings = new SugiyamaLayoutSettings();
settings.AddUpDownVerticalConstraint(closed, ellipse);
settings.AddUpDownVerticalConstraint(open, bezier);
settings.AddUpDownConstraint(closed, open);
settings.AddSameLayerNeighbors(polygon, open);
settings.AddLeftRightConstraint(closed, open);
settings.AddUpDownConstraint(closed, open);
//settings.AddSameLayerNeighbors(polygon, open);
settings.AddLeftRightConstraint(closed, open);
//To verify 444585, just turn on this following commented line
settings.AddLeftRightConstraint(ellipse, rectangle);
settings.AddLeftRightConstraint(ellipse, bezier);
var layeredLayout = new LayeredLayout(graph, settings);
layeredLayout.Run();
#if DEBUG
LayoutAlgorithmSettings.ShowGraph(graph);
#endif
Debug.Assert(Math.Abs(closed.Center.X - ellipse.Center.X) < 0.01);
Debug.Assert(Math.Abs(open.Center.X - bezier.Center.X) < 0.01);
foreach (Node n0 in graph.Nodes) {
foreach (Node n1 in graph.Nodes) {
if (n0 == n1) {
continue;
}
Debug.Assert(!n0.BoundingBox.Intersects(n1.BoundingBox));
}
}
ValidateUpDownVerticalConstraint(closed, ellipse);
ValidateUpDownVerticalConstraint(open, bezier);
ValidateUpDownConstraint(closed, open);
ValidateNeighborConstraint(graph, polygon, open);
ValidateLeftRightConstraint(closed, open);
//To verify 444585, also turn on this following commented line
ValidateLeftRightConstraint(ellipse, rectangle);
ValidateLeftRightConstraint(ellipse, bezier);
}
public void AddInEdge(Edge e){
inEdges.Insert(e);
}
static void TestConstraints() {
var gg = new GeometryGraph();
var node1 = new Node {GeometryParent = gg};
node1.BoundaryCurve =CurveFactory.CreateEllipse(20.0,10.0,new Point(0.0, 0.0));
gg.Nodes.Add(node1);
var node2 = new Node {GeometryParent = gg};
node2.BoundaryCurve =
CurveFactory.CreateEllipse(20.0,10.0,new Point(0.0, 0.0));
gg.Nodes.Add(node2);
var edge = new Edge(node1,node2) {GeometryParent = gg};
gg.Edges.Add(edge);
edge.Label = new Label {GeometryParent = edge,
//need to set the label dimensions, otherwise the assertion is thrown
Width = 10, Height = 10
};
//node1.AddOutEdge(edge); //the edges have been already added to the nodes in gg.Edges.Add(edge)
//node2.AddInEdge(edge);
var settings = new SugiyamaLayoutSettings();
settings.AddSameLayerNeighbors(node1, node2);
var layoutAlgorithm = new
LayeredLayout(gg, settings);
layoutAlgorithm.Run();
#if TEST_MSAGL
LayoutAlgorithmSettings.ShowGraph(gg);
#endif
Environment.Exit(0);
}
/// <summary>
/// constructor
/// </summary>
/// <param name="editedEdgePar"></param>
public EdgeDragUndoRedoAction(GeomEdge editedEdgePar):base((GeometryGraph)editedEdgePar.GeometryParent) {
editedEdge = editedEdgePar;
}
static void FixPortAtSource(Shape shape, Port port, Edge e) {
if (e.SourcePort == null)
e.SourcePort = port;
else
shape.Ports.Insert(e.SourcePort);
}
static void TestGraphWithConstraints() {
var graph = new GeometryGraph();
var closed = new Node(CreateEllipse(), "closed");
var line = new Node(CreateEllipse(), "line");
var bezier = new Node(CreateEllipse(), "bezier");
var arc = new Node(CreateEllipse(), "arc");
var rectangle = new Node(CreateEllipse(), "rectangle");
var ellipse = new Node(CreateEllipse(), "ellipse");
var polygon = new Node(CreateEllipse(), "polygon");
var shapes = new Node(CreateEllipse(), "shapes");
var open = new Node(CreateEllipse(), "open");
graph.Nodes.Add(closed);
graph.Nodes.Add(line);
graph.Nodes.Add(bezier);
graph.Nodes.Add(arc);
graph.Nodes.Add(rectangle);
graph.Nodes.Add(ellipse);
graph.Nodes.Add(polygon);
graph.Nodes.Add(shapes);
graph.Nodes.Add(open);
var so = new Edge(shapes, open);
var sc = new Edge(shapes, closed);
var ol = new Edge(open, line);
var ob = new Edge(open, bezier);
var oa = new Edge(open, arc);
var cr = new Edge(closed, rectangle);
var ce = new Edge(closed, ellipse);
var cp = new Edge(closed, polygon);
graph.Edges.Add(so);
graph.Edges.Add(sc);
graph.Edges.Add(ol);
graph.Edges.Add(ob);
graph.Edges.Add(oa);
graph.Edges.Add(cr);
graph.Edges.Add(ce);
graph.Edges.Add(cp);
var settings = new SugiyamaLayoutSettings();
settings.AddUpDownVerticalConstraint(closed, ellipse);
settings.AddUpDownVerticalConstraint(open, bezier);
settings.AddUpDownConstraint(closed, open);
settings.AddSameLayerNeighbors(polygon, open);
settings.AddLeftRightConstraint(closed, open);
settings.AddLeftRightConstraint(open, closed);
////To verify 444585, just turn on this following commented line
settings.AddLeftRightConstraint(ellipse, rectangle);
settings.AddLeftRightConstraint(ellipse, bezier);
var layeredLayout = new LayeredLayout(graph, settings);
layeredLayout.Run();
#if DEBUG
DisplayGeometryGraph.ShowGraph(graph);
#endif
}
static void TestPaddingForEdge(GeometryGraph geomGraph, Edge edge) {
const int steps = 100;
var edgeCurve = edge.Curve;
var step = (edgeCurve.ParEnd - edgeCurve.ParStart)/steps;
for(var par=edgeCurve.ParStart; par<edgeCurve.ParEnd; par= par+step) {
var curvePoint = edgeCurve[par];
foreach (var node in geomGraph.Nodes.Where(node => node == edge.Source && node == edge.Target)) {
var nb = node.BoundaryCurve;
var p = nb.ClosestParameter(curvePoint);
var nodePoint = nb[p];
#if DEBUG
if ((nodePoint - curvePoint).Length < 0.99)
LayoutAlgorithmSettings.Show(new LineSegment(nodePoint, curvePoint), nb, edgeCurve);
#endif
}
}
}
static void CalculateAttachedSegmentEnd(GeomLabel label, GeomEdge edge)
{
label.AttachmentSegmentEnd = edge.Curve[edge.Curve.ClosestParameter(label.Center)];
}
private void RouteEdge(GeometryEdge geometryEdge)
{
var router = new RouterBetweenTwoNodes(Graph.GeometryGraph, Graph.Attr.NodeSeparation * tightOffsetForRouting,
Graph.Attr.NodeSeparation * looseOffsetForRouting,
Graph.Attr.NodeSeparation * offsetForRelaxingInRouting);
try
{
router.RouteEdge(geometryEdge, true);
}
catch (Exception)
{
}
}
private static void TransformUnderlyingPolyline(GeometryGraph geometryGraph, GeometryEdge e, PlaneTransformation transformation)
{
if (e.UnderlyingPolyline != null)
{
for (Microsoft.Msagl.Core.Geometry.Site s = e.UnderlyingPolyline.HeadSite; s != null; s = s.Next)
{
s.Point = transformation * s.Point;
}
}
}
static void TestGraphWithConstraints()
{
var graph = new GeometryGraph();
var closed = new Node(CreateEllipse(), "closed");
var line = new Node(CreateEllipse(), "line");
var bezier = new Node(CreateEllipse(), "bezier");
var arc = new Node(CreateEllipse(), "arc");
var rectangle = new Node(CreateEllipse(), "rectangle");
var ellipse = new Node(CreateEllipse(), "ellipse");
var polygon = new Node(CreateEllipse(), "polygon");
var shapes = new Node(CreateEllipse(), "shapes");
var open = new Node(CreateEllipse(), "open");
graph.Nodes.Add(closed);
graph.Nodes.Add(line);
graph.Nodes.Add(bezier);
graph.Nodes.Add(arc);
graph.Nodes.Add(rectangle);
graph.Nodes.Add(ellipse);
graph.Nodes.Add(polygon);
graph.Nodes.Add(shapes);
graph.Nodes.Add(open);
var so = new Edge(shapes, open);
var sc = new Edge(shapes, closed);
var ol = new Edge(open, line);
var ob = new Edge(open, bezier);
var oa = new Edge(open, arc);
var cr = new Edge(closed, rectangle);
var ce = new Edge(closed, ellipse);
var cp = new Edge(closed, polygon);
graph.Edges.Add(so);
graph.Edges.Add(sc);
graph.Edges.Add(ol);
graph.Edges.Add(ob);
graph.Edges.Add(oa);
graph.Edges.Add(cr);
graph.Edges.Add(ce);
graph.Edges.Add(cp);
var settings = new SugiyamaLayoutSettings();
settings.AddUpDownVerticalConstraint(closed, ellipse);
settings.AddUpDownVerticalConstraint(open, bezier);
settings.AddUpDownConstraint(closed, open);
settings.AddSameLayerNeighbors(polygon, open);
settings.AddLeftRightConstraint(closed, open);
settings.AddLeftRightConstraint(open, closed);
////To verify 444585, just turn on this following commented line
settings.AddLeftRightConstraint(ellipse, rectangle);
settings.AddLeftRightConstraint(ellipse, bezier);
var layeredLayout = new LayeredLayout(graph, settings);
layeredLayout.Run();
#if TEST_MSAGL
DisplayGeometryGraph.ShowGraph(graph);
#endif
}
private DEdge AddCrossEdge(DNode source, DNode target)
{
DEdge dEdge = new DEdge(source, target, new DrawingEdge(source.Node, target.Node, ConnectionToGraph.Disconnected), ConnectionToGraph.Disconnected);
GeometryEdge gEdge = new GeometryEdge(source.GeometryNode, target.GeometryNode) { GeometryParent = Graph.GeometryGraph };
dEdge.GeometryEdge = gEdge;
dEdge.ArrowheadAtTarget = ArrowStyle.Normal;
m_CrossEdges.Add(dEdge);
return dEdge;
/*DEdge ret;
var s = VisualTreeHelper.GetRoot(this);
var ss = VisualTreeHelper.GetRoot(source);
var ts = VisualTreeHelper.GetRoot(target);
if (s != ss || s != ts || ss != ts)
ret = new DEdge(source, target, null, ConnectionToGraph.Disconnected);
else
ret = NestedGraphHelper.DrawCrossEdge(this, source, target);
m_CrossEdges.Add(ret);
return ret;*/
}
