public static bool IsConnectionPossible(Point p1, Point p2, QuadTreeLib.QuadTree <WorkspaceManager.View.VisualComponents.CryptoLineView.FakeNode> quadTree)
{
if (p1.X != p2.X && p1.Y != p2.Y)
{
throw new ArgumentException("only 90° allowed");
}
System.Drawing.RectangleF queryRect;
if (p1.Y != p2.Y)
{
Point up = p2.Y < p1.Y ? p2 : p1;
Point down = p2.Y < p1.Y ? p1 : p2;
queryRect = new System.Drawing.RectangleF((float)up.X, (float)up.Y, (float)1, (float)(down.Y - up.Y));
}
else
{
Point left = p2.X < p1.X ? p2 : p1;
Point right = p2.X < p1.X ? p1 : p2;
queryRect = new System.Drawing.RectangleF((float)left.X, (float)left.Y, (float)(right.X - left.X), (float)1);
}
var b = !quadTree.QueryAny(queryRect);
return(b);
}
public static void PerformOrthogonalPointConnection(Node p1, Node p2, QuadTreeLib.QuadTree <WorkspaceManager.View.VisualComponents.CryptoLineView.FakeNode> quadTree)
{
if (IsConnectionPossible(p1.Point, p2.Point, quadTree))
{
p1.Vertices.Add(p2);
p2.Vertices.Add(p1);
}
}
private void makeOrthogonalPoints()
{
bool failed = false;
if (!IsEditingPoint)
{
if (!isSubstituteLine && !IsDragged && !HasComputed && !loaded)
{
List <Node> nodeList = new List <Node>();
FrameworkElement parent = Model.WorkspaceModel.MyEditor.Presentation;
// add start and end. Index will be 0 and 1
Node startNode = new Node()
{
Point = LineUtil.Cheat42(StartPoint, StartPointSource, 1)
},
endNode = new Node()
{
Point = LineUtil.Cheat42(EndPoint, EndPointSource, -1)
};
nodeList.Add(startNode);
nodeList.Add(endNode);
QuadTreeLib.QuadTree <FakeNode> quadTreePlugins = helper.PluginTree;
for (int routPoint = 0; routPoint < 4; ++routPoint)
{
foreach (var element in Visuals)
{
if (element is ComponentVisual)
{
IRouting p1 = element as IRouting;
nodeList.Add(new Node()
{
Point = p1.GetRoutingPoint(routPoint)
});
}
}
}
// connect points
int loopCount = nodeList.Count;
const int performanceTradeoffAt = 2;
LinkedList <Node> path = null;
for (int i = 0; i < loopCount; ++i)
{
StackFrameDijkstra.Dijkstra <Node> dijkstra = new StackFrameDijkstra.Dijkstra <Node>();
path = dijkstra.findPath(nodeList, startNode, endNode);
if (path != null)
{
break;
}
var p1 = nodeList[i];
// TODO: inner loop restriction! n²-n!
// is k=i instead of k=0 correct?
for (int k = i; k < loopCount; ++k)
{
var p2 = nodeList[k];
if (p1 == p2)
{
continue;
}
if (p1.Vertices.Contains(p2))
{
continue;
}
// no helping point required?
if (p1.Point.X == p2.Point.X ||
p1.Point.Y == p2.Point.Y)
{
LineUtil.PerformOrthogonalPointConnection(p1, p2, quadTreePlugins);
}
else
{
Point help = new Point(p1.Point.X, p2.Point.Y);
if (!LineUtil.PerformOrthogonalPointConnection(p1, help, p2, nodeList, quadTreePlugins))
{
help = new Point(p2.Point.X, p1.Point.Y);
if (!LineUtil.PerformOrthogonalPointConnection(p1, help, p2, nodeList, quadTreePlugins))
{
// optional todo: double edge helping routes
}
}
}
}
}
if (path == null)
{
StackFrameDijkstra.Dijkstra <Node> dijkstra = new StackFrameDijkstra.Dijkstra <Node>();
path = dijkstra.findPath(nodeList, startNode, endNode);
}
if (path != null)
{
var list = path.ToList();
PointList.Clear();
Point startPoint = StartPoint, curPoint, prevPoint = startPoint;
bool isStart = true;
for (int c = 0; c < list.Count; ++c)
{
var i = list[c];
curPoint = i.Point;
//this.PointList.Add(new FromTo(prevPoint, curPoint));
if ((startPoint.X != curPoint.X && startPoint.Y != curPoint.Y))
{
if (isStart)
{
this.PointList.Add(new FromTo(startPoint, prevPoint, FromToMeta.HasStartPoint));
isStart = false;
}
else
{
this.PointList.Add(new FromTo(startPoint, prevPoint));
}
startPoint = prevPoint;
}
if (c == list.Count - 1)
{
if ((startPoint.X != EndPoint.X && startPoint.Y != EndPoint.Y))
{
this.PointList.Add(new FromTo(startPoint, curPoint));
startPoint = curPoint;
}
}
prevPoint = curPoint;
}
this.PointList.Add(new FromTo(startPoint, EndPoint, FromToMeta.HasEndpoint));
HasComputed = true;
raiseComputationDone(true);
return;
}
failed = true;
}
//Failsafe
if (IsDragged || failed || isSubstituteLine)
{
if (StartPoint.X < EndPoint.X)
{
PointList.Clear();
PointList.Add(new FromTo(StartPoint, new Point((EndPoint.X + StartPoint.X) / 2, StartPoint.Y)));
PointList.Add(new FromTo(new Point((EndPoint.X + StartPoint.X) / 2, StartPoint.Y), new Point((EndPoint.X + StartPoint.X) / 2, EndPoint.Y)));
PointList.Add(new FromTo(new Point((EndPoint.X + StartPoint.X) / 2, EndPoint.Y), EndPoint));
}
else
{
if (StartPoint.X > EndPoint.X)
{
PointList.Clear();
PointList.Add(new FromTo(StartPoint, new Point((StartPoint.X + EndPoint.X) / 2, StartPoint.Y)));
PointList.Add(new FromTo(new Point((StartPoint.X + EndPoint.X) / 2, StartPoint.Y), new Point((StartPoint.X + EndPoint.X) / 2, EndPoint.Y)));
PointList.Add(new FromTo(new Point((StartPoint.X + EndPoint.X) / 2, EndPoint.Y), EndPoint));
}
}
}
raiseComputationDone(false);
}
raiseComputationDone(true);
}
public static bool PerformOrthogonalPointConnection(Node n1, Point p2, Node n3, List <Node> nodeList, QuadTreeLib.QuadTree <WorkspaceManager.View.VisualComponents.CryptoLineView.FakeNode> quadTreePlugins)
{
if (LineUtil.IsConnectionPossible(n1.Point, p2, quadTreePlugins) && LineUtil.IsConnectionPossible(n3.Point, p2, quadTreePlugins))
{
Node n2 = new Node()
{
Point = p2
};
n1.Vertices.Add(n2);
n2.Vertices.Add(n1);
n2.Vertices.Add(n3);
n3.Vertices.Add(n2);
nodeList.Add(n2);
return(true);
}
return(false);
}
