private bool AnglesAreClose(double angle1, double angle2, double tolerance)
{
if (Math.Abs(angle1 - angle2) < tolerance)
{
return(true);
}
if (360 - RRTHelpers.SanatizeAngle(angle1 - angle2) < tolerance)
{
return(true);
}
return(false);
}
private bool StepCurve(RRTNode node1, RRTNode node2, double delta, System.Drawing.Point middle, double radius, double angle, double theta)
{
double outerlength = Math.Abs(delta * RRTHelpers.ToRadians * radius);
double steps = outerlength / StepWidthCurve;
double angleStep = delta / steps;
RRTNode start = node1.Clone();
RRTNode end = node2.Clone();
double beforeLength = 0;
RRTNode temp = node1;
while (temp.Position != end.Position)
{
if (temp == null || temp.Predecessor == null)
{
break;
}
beforeLength += RRTHelpers.CalculateDistance(temp, temp.Predecessor);
temp = temp.Predecessor;
}
RRTNode lastNode = null;
bool success = true;
for (int i = 0; i < (int)steps; i++)
{
int NewX = (int)(middle.X - Math.Cos(RRTHelpers.SanatizeAngle(theta * RRTHelpers.ToDegree + i * angleStep) * RRTHelpers.ToRadians) * radius);
int NewY = (int)(middle.Y - Math.Sin(RRTHelpers.SanatizeAngle(theta * RRTHelpers.ToDegree + i * angleStep) * RRTHelpers.ToRadians) * radius);
double NewOrientation = RRTHelpers.SanatizeAngle(node1.Orientation + i * angleStep);
if (InternalMap.IsOccupied(NewX, NewY))
{
success = false;
break;
}
RRTNode newNode = null;
if (lastNode == null)
{
newNode = new RRTNode(new System.Drawing.Point(NewX, NewY), NewOrientation, start);
newNode.Inverted = start.Inverted;
start.Successors.Add(newNode);
}
else
{
newNode = new RRTNode(new System.Drawing.Point(NewX, NewY), NewOrientation, lastNode);
lastNode.Successors.Add(newNode);
newNode.Inverted = lastNode.Inverted;
//RRTHelpers.DrawImportantNode (newNode, InternalMap, 5, Color.DarkOrange);
}
lastNode = newNode;
}
if (lastNode == null)
{
success = false;
}
//We successfully connected them
if (success)
{
double afterLength = 0;
temp = lastNode;
while (temp.Position != end.Position)
{
if (temp == null || temp.Predecessor == null)
{
break;
}
afterLength += RRTHelpers.CalculateDistance(temp, temp.Predecessor);
temp = temp.Predecessor;
}
if (afterLength > beforeLength)
{
return(false);
}
end.Predecessor = lastNode;
lastNode.AddSucessor(end);
if (node1.Predecessor != null)
{
node1.Predecessor.Successors.Clear();
node1.Predecessor.AddSucessor(start);
start.Predecessor = node1.Predecessor;
}
else
{
Console.WriteLine("Node1.Predecessor was null");
}
if (node2.Successors.Count > 0)
{
end.AddSucessor(node2.Successors[0]);
node2.Successors[0].Predecessor = end;
node2.Predecessor = null;
node2.Successors.Clear();
}
else
{
Console.WriteLine("Node2.Successor[0] was null");
}
node1.Successors.Clear();
node2.Successors.Clear();
node2.Predecessor = null;
node1.Predecessor = null;
Path.CalculateLength();
return(true);
}
return(false);
}
/// <summary>
/// Optimize our path so we hit the endpoint
/// </summary>
public void OptimizeForEndPoint()
{
//Go along from then nearest point to the endpoint
RRTNode previous = Path.Start;
Console.WriteLine("Path length before optimization for endpoint: " + Path.Length + " Count: " + Path.CountNodes + " Cost: " + Path.Cost());
Console.WriteLine();
while (previous != null)
{
if (previous == null)
{
break;
}
//Calculate angle delta (angle between orientations) (in degrees)
double delta = previous.Orientation - EndPoint.Orientation;
double angle = RRTHelpers.CalculateAngle(previous, EndPoint);
//Check if the orientation of the selected point is nearly the same as the orientation of the endpoint
//if (Math.Abs(previous.Orientation - EndPoint.Orientation) < AllowedOrientationDeviation * 5 || 180 -Math.Abs(previous.Orientation - EndPoint.Orientation) < AllowedOrientationDeviation * 5 )
if (AnglesAreClose(delta, 0, AllowedOrientationDeviation) && (AnglesAreClose(EndPoint.Orientation, angle * RRTHelpers.ToDegree, MaximumDriftAngle)))
{
//Okey connect them
RRTNode selectedNode = previous;
RRTNode lastNode = null;
//Create a clone we can work on
RRTNode start = selectedNode.Clone();
double Distance = RRTHelpers.CalculateDistance(selectedNode, EndPoint);
if (Math.Abs(RRTHelpers.SanatizeAngle(angle * RRTHelpers.ToDegree)) > this.MaximumDriftAngle)
{
previous = previous.Predecessor;
continue;
}
bool success = true;
//Connect them
for (double i = 0; i <= Distance; i += StepWidthEnd)
{
//Create new point
int NewX = (int)(selectedNode.Position.X + i * Math.Cos(angle));
int NewY = (int)(selectedNode.Position.Y + i * Math.Sin(angle));
//Check if this point is occupied
if (InternalMap.IsOccupied(NewX, NewY))
{
success = false;
break;
}
RRTNode newNode = null;
if (lastNode == null)
{
newNode = new RRTNode(new System.Drawing.Point(NewX, NewY), start.Orientation, start);
start.Successors.Add(newNode);
}
else
{
newNode = new RRTNode(new System.Drawing.Point(NewX, NewY), start.Orientation, lastNode);
lastNode.Successors.Add(newNode);
}
lastNode = newNode;
}
if (lastNode == null)
{
success = false;
}
if (success)
{
Path.Start = lastNode;
//Replace the selectNode with our start node.
start.Predecessor = selectedNode.Predecessor;
selectedNode.Predecessor.Successors.Clear();
selectedNode.Predecessor.AddSucessor(start);
selectedNode.Predecessor = null;
selectedNode.Successors.Clear();
previous = start;
}
}
previous = previous.Predecessor;
}
Path.CalculateLength();
Console.WriteLine("Path length after optimization for endpoint: " + Path.Length + " Count: " + Path.CountNodes + " Cost: " + Path.Cost());
}
/// <summary>
/// Optimize two points taken from the path by trying to connect them via a curve.
/// </summary>
public bool OptimizeCurves(RRTNode start, RRTNode end)
{
//Calculate distance
double distance = RRTHelpers.CalculateDistance(start, end);
//Distance is too small that it makes sense to optimize it
if (distance < 10)
{
return(false);
}
//Calculate angle delta (angle between orientations) (in degrees)
double delta = end.Orientation - start.Orientation;
//Calculate angle between points (in radians)
double angle = RRTHelpers.CalculateAngle(start, end);
//We can't go from inverted to not inverted (not from forward to backwards or the other way round)
//NOTE Mit Kurvenfahrt ist das kein Problem, kann aber vermehrt zu Wendeschleifen führen
if (start.Inverted != end.Inverted)
{
return(false);
}
//Now decide if going straight is way to go
//NOTE delta ist entweder sehr klein oder sehr groß (fast 360°, siehe Hilfsfunktion "anglesAreClose" in pseudocode)
//NOTE Im zweiten Check prüfe, ob Orientierung und Fahrtwinkel näher zusammenliegen als MaximumDriftAngle
if (AnglesAreClose(delta, 0, AllowedOrientationDeviation) && (AnglesAreClose(start.Orientation, angle * RRTHelpers.ToDegree, MaximumDriftAngle)))
//if (Math.Abs (delta) < AllowedOrientationDeviation*5 && Math.Abs(angle*RRTHelpers.ToDegree) < MaximumDriftAngle)
{
//The deviation in the orientation is small enough we can accept going straight (or drift)
//And the angle between the points is smaller than the maximum drift we can do
//Step straight or in a drift. This function may manipulate the path
bool ret = StepStraight(start, end, distance, angle);
return(ret);
}
else
{
//We try a curve
double theta = RRTHelpers.SanatizeAngle(angle * RRTHelpers.ToDegree + Math.Sign(delta) * (180 - Math.Abs(delta)) / 2) * RRTHelpers.ToRadians;
double radius = Math.Abs(distance / (2 * Math.Sin(delta * RRTHelpers.ToRadians / 2)));
//Check if the radius is > minimum radius
if (radius < MinimumRadius)
{
return(false);
}
//Calculate middle point (theta is in radians)
double midX = start.Position.X + Math.Cos(theta) * radius;
double midY = start.Position.Y + Math.Sin(theta) * radius;
//RRTHelpers.DrawImportantNode (new RRTNode (new System.Drawing.Point ((int)midX, (int)midY), theta, null), InternalMap, 5, System.Drawing.Color.DarkMagenta);
//Theta in radians, delta in degrees -> gamma in degrees
double gamma = start.Orientation - RRTHelpers.SanatizeAngle(theta * RRTHelpers.ToDegree - Math.Sign(delta) * 90);
double driftAngle = gamma; //In degree
if (Math.Abs(driftAngle) / MaximumDriftAngle + MinimumRadius / radius >= 1)
{
return(false);
}
bool ret = StepCurve(start, end, delta, new System.Drawing.Point((int)midX, (int)midY), radius, angle, theta);
return(ret);
}
}
/// <summary>
/// Steps to random node in a curve.
/// </summary>
/// <param name="Start">Start.</param>
/// <param name="End">End.</param>
/// <param name="Distance">Distance.</param>
/// <param name="Angle">Angle.</param>
/// <param name="BaseAngle">Base angle.</param>
/// <param name="Middle">Middle.</param>
/// <param name="Left">If set to <c>true</c> left.</param>
private void StepToNodeCurve(RRTNode Start, RRTNode End, double Distance, double Angle, double BaseAngle, Point Middle, bool Left)
{
RRTNode lastFoundNode = null;
//RRTHelpers.DrawImportantNode(new RRTNode(Middle, BaseAngle,null), InternalMap, 5, Color.Coral);
Func <double, bool> CalculateNewPoint = (double x) =>
{
//We interpret the random angle as the angle in a polar coordinate system
int NewX = Middle.X + (int)((double)Distance * Math.Cos((x) * RRTHelpers.ToRadians));
int NewY = Middle.Y + (int)((double)Distance * Math.Sin((x) * RRTHelpers.ToRadians));
double Orientation = Start.Orientation - (BaseAngle - x);
Orientation = RRTHelpers.SanatizeAngle(Orientation);
if (!PointValid(new Point((int)NewX, (int)NewY)))
{
if (lastFoundNode == null)
{
RRTNode BetweenNode = new RRTNode(new Point((int)NewX, (int)NewY), Orientation, Start);
Start.AddSucessor(BetweenNode);
lastFoundNode = BetweenNode;
BetweenNode.Inverted = End.Inverted;
this.AllNodes.Add(BetweenNode);
}
else
{
RRTNode BetweenNode = new RRTNode(new Point((int)NewX, (int)NewY), Orientation, lastFoundNode);
lastFoundNode.AddSucessor(BetweenNode);
lastFoundNode = BetweenNode;
BetweenNode.Inverted = End.Inverted;
this.AllNodes.Add(BetweenNode);
}
return(true);
}
else
{
return(false);
}
};
double AdaptedStepWidth = (CircleStepWidth * 360.0) / (2 * Math.PI * Distance);
if (Left)
{
for (double x = (BaseAngle) + AdaptedStepWidth; x < Angle; x += AdaptedStepWidth)
{
if (!CalculateNewPoint(x)) //Break if a not valid point was stepped into
{
break;
}
}
}
else
{
for (double x = (BaseAngle) - AdaptedStepWidth; x > Angle; x -= AdaptedStepWidth)
{
if (!CalculateNewPoint(x)) //Break if a not valid point was stepped into
{
break;
}
}
}
}
