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);
}
/// <summary>
/// Steps to node.
/// Takes a start and an end node and the argument wether to go straight or in a circle.
/// Steps into this direction
/// </summary>
/// <param name="Start">Start.</param>
/// <param name="End">End.</param>
private void StepToNodeStraight(RRTNode Start, RRTNode End)
{
double distance = RRTHelpers.CalculateDistance(Start, End);
double angle = RRTHelpers.CalculateAngle(Start, End);
double cosArgument = Math.Cos(angle);
double sinArgument = Math.Sin(angle);
RRTNode lastFoundNode = null;
//Lambda function that calculates a new point from a given x value
//Checks if the node is valid
//Adds it into the list of nodes.
//Returns false if point not valid
Func <double, bool> CalculateNewPoint = (double x) =>
{
int NewX = Start.Position.X + (int)((double)x * cosArgument);
int NewY = Start.Position.Y + (int)((double)x * sinArgument);
if (!PointValid(new Point(NewX, NewY)))
{
if (lastFoundNode == null)
{
RRTNode BetweenNode = new RRTNode(new Point(NewX, NewY), Start.Orientation, Start);
Start.AddSucessor(BetweenNode);
lastFoundNode = BetweenNode;
BetweenNode.Inverted = End.Inverted;
this.AllNodes.Add(BetweenNode);
}
else
{
RRTNode BetweenNode = new RRTNode(new Point(NewX, NewY), lastFoundNode.Orientation, lastFoundNode);
lastFoundNode.AddSucessor(BetweenNode);
lastFoundNode = BetweenNode;
BetweenNode.Inverted = End.Inverted;
this.AllNodes.Add(BetweenNode);
}
return(true);
}
else
{
return(false);
}
};
for (double x = 0; x < distance; x += StepWidth)
{
if (!CalculateNewPoint(x))
{
break;
}
}
}
/// <summary>
/// Draws the given RRTPath.
/// </summary>
/// <param name="Path">Path.</param>
/// <param name="_Map">Map.</param>
/// <param name="PathPen">Path pen.</param>
public static void DrawPath(RRTPath Path, Map _Map, Pen PathPen)
{
RRTNode previous = Path.Start;
Graphics g = Graphics.FromImage(_Map.ImageMap);
while (previous != null)
{
RRTHelpers.DrawImportantNode(previous, _Map, 2, Path.Color);
if (previous.Predecessor != null)
{
g.DrawLine(PathPen, _Map.ToMapCoordinates(previous.Position), _Map.ToMapCoordinates(previous.Predecessor.Position));
}
previous = previous.Predecessor;
}
}
/// <summary>
/// Do a step into the right direction
/// </summary>
private void DoStep()
{
bool Curve = RRTHelpers.BooleanRandom(this.PreferStraight);
//Select a random base node from the list of all nodes
RRTNode RandomNode = RRTHelpers.SelectRandomNode(AllNodes);
//large value -> don' take nearest so often
bool SelectNearest = RRTHelpers.BooleanRandom(130);
if (SelectNearest)
{
//Take from 10 nodes the node that is the nearest to the endpoint
double bestDistance = RRTHelpers.CalculateDistance(RandomNode, EndRRTNode);
for (int i = 0; i < 10; i++)
{
RRTNode NewNode = RRTHelpers.SelectRandomNode(AllNodes);
double distance = RRTHelpers.CalculateDistance(NewNode, EndRRTNode);
if (distance < bestDistance)
{
bestDistance = distance;
RandomNode = NewNode;
}
}
}
if (!Curve)
{
//First go straight
//Get a new straight or drift random node
RRTNode NewStraightNode = RRTHelpers.GetRandomStraightPoint(RandomNode, this.MaximumDrift, this.StraightInvertProbability);
//Now step to the new node
StepToNodeStraight(RandomNode, NewStraightNode);
}
else
{
//Second go curve
double Distance = 0;
double Angle = 0;
double BaseAngle = 0;
bool Left = false;
Point Middle = new Point();
RRTNode NewCurveNode = RRTHelpers.GetRandomCurvePoint(RandomNode, this.MinumumRadius, ref Distance, ref Angle, ref BaseAngle, ref Middle, ref Left);
//RRTHelpers.DrawImportantNode(NewCurveNode, InternalMap, 4, Color.CornflowerBlue);
StepToNodeCurve(RandomNode, NewCurveNode, Distance, Angle, BaseAngle, Middle, Left);
}
}
/// <summary>
/// Calculates the length and the amount of nodes in the path.
/// </summary>
public void CalculateLength()
{
Length = 0;
CountNodes = 0;
RRTNode previous = Start;
while (previous != null)
{
if (previous.Predecessor != null)
{
Length += RRTHelpers.CalculateDistance(previous, previous.Predecessor);
}
previous = previous.Predecessor;
CountNodes++;
}
//Put them into the list.
NodesList = ToList();
}
public static int Main(string[] args)
{
//Stopwatch for getting the total execution time
Stopwatch totalTimeWatch = new Stopwatch();
totalTimeWatch.Start();
if (args.Length > 3)
{
//Parse arguments
//1. Path 2. Start 3. Stop 4. Output path 5. path to xml document with path (optional)
string MapPath = args [0];
string start = args [1]; //x,y,phi
start = start.Trim();
string stop = args [2]; // x, y, phi
stop = stop.Trim();
string outputPath = args[3];
string[] startArray = start.Split(new char[] { ',' });
string[] stopArray = stop.Split(new char[] { ',' });
Point StartPoint = new Point(Convert.ToInt32(startArray [0]), Convert.ToInt32(startArray [1]));
double StartOrientation = Convert.ToDouble(startArray [2]);
Point StopPoint = new Point(Convert.ToInt32(stopArray [0]), Convert.ToInt32(stopArray [1]));
double StopOrientation = Convert.ToDouble(stopArray [2]);
Console.WriteLine("Start is: " + StartPoint.ToString() + " , " + StartOrientation);
Console.WriteLine("Stop is: " + StopPoint.ToString() + " , " + StopOrientation);
//Check if a path for the xml document was given.
string pathXml = "";
if (args.Length > 4)
{
pathXml = args [4];
Console.WriteLine("Saving path to: " + pathXml);
}
//In case the map exists
if (File.Exists(MapPath))
{
//Stopwatch for timing
Stopwatch watch = new Stopwatch();
watch.Start();
//Load bitmap
Bitmap BitMap = ImageHelpers.CreateNonIndexedImage(new Bitmap(MapPath));
//Create new map from bitmap
Map MyMap = new Map(BitMap);
watch.Stop();
Console.WriteLine("Loading Map took: " + watch.ElapsedMilliseconds + " ms");
watch.Reset();
//Create new instance of algorithm
RRT Algorithm = new RRT(MyMap);
//Callback (lambda function) when the rrt algorithm has finished
Algorithm.Finished += (object sender, EventArgs e) => {
//Stop timing stopwatch
watch.Stop();
Console.WriteLine("Algorithm took: " + watch.ElapsedMilliseconds + " ms");
//Event that gets called when the RRT is finished
Console.WriteLine("Finished");
watch.Reset();
watch.Start();
//Look for paths from the endpoint to the start
List <RRTPath> paths = Algorithm.FindPathToTarget();
watch.Stop();
Console.WriteLine("Finding path took: " + watch.ElapsedMilliseconds + " ms");
//In case we found a path
if (paths.Count > 0)
{
//ATTENTION: Path.Start is the point next to given EndPoint
// Path.End is the StartPoint
//Clean the path (Remove all branches in the tree we dont want to follow)
RRTPath shortestPath = RRTPath.CleanPath(paths[0]);
shortestPath.Color = Color.Red;
//Draw the path
RRTHelpers.DrawPath(shortestPath, MyMap, Pens.Cyan);
//Ok optimize with the currently best path
Console.WriteLine("Starting Optimization");
//Create new instance of optimizer
PathOptimizer optimizer = new PathOptimizer(shortestPath, MyMap, Algorithm.EndRRTNode);
watch.Reset();
watch.Start();
//Optimize the path
optimizer.Optimize();
watch.Stop();
Console.WriteLine("Optimizing took: " + watch.ElapsedMilliseconds + " ms");
optimizer.Path.Color = Color.Blue;
//Draw the path
RRTHelpers.DrawPath(optimizer.Path, MyMap, Pens.DarkGoldenrod);
//Save it into a file if a xml path was given
if (pathXml != "")
{
optimizer.Path.SaveToFile(pathXml);
}
}
else
{
Console.WriteLine("No paths found");
}
watch.Reset();
watch.Start();
//Draw the legend in the upper left corner
MyMap.DrawLegend();
//Draw the tree on the map
//RRTHelpers.DrawTree(Algorithm.StartRRTNode, MyMap);
//Draw the start point
RRTHelpers.DrawImportantNode(Algorithm.StartRRTNode, MyMap, 5, Color.Red);
//Draw the endpoint
RRTHelpers.DrawImportantNode(Algorithm.EndRRTNode, MyMap, 5, Color.Aqua);
watch.Stop();
Console.WriteLine("Drawing took: " + watch.ElapsedMilliseconds + " ms");
if (paths.Count > 0)
{
watch.Reset();
watch.Start();
//Save the result
MyMap.SaveBitmapToFile(outputPath);
watch.Stop();
Console.WriteLine("Saving result to image took: " + watch.ElapsedMilliseconds + " ms");
}
};
//Start the RRT
watch.Start();
Algorithm.Start(StartPoint, StartOrientation, StopPoint, StopOrientation);
}
}
totalTimeWatch.Stop();
Console.WriteLine("Totaltime was: " + totalTimeWatch.ElapsedMilliseconds + " ms");
return(0);
}
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 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>
/// 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>
/// Find a path from the endpoint to the startpoint.
/// This is done by looking at all points and selecting the points that are in the given target area.
/// Their orientation may only vary by the given AcceptableOrientationDeviation.
/// </summary>
/// <returns>The path to target.</returns>
public List <RRTPath> FindPathToTarget()
{
//Move area around the endpoint
Rectangle TranslatedTargetArea = new Rectangle(EndPoint.X - TargetArea.Width / 2, EndPoint.Y + TargetArea.Height / 2, TargetArea.Width, TargetArea.Height);
Graphics g = Graphics.FromImage(InternalMap.ImageMap);
g.DrawRectangle(Pens.Fuchsia, new Rectangle(InternalMap.ToMapCoordinates(TranslatedTargetArea.Location), TranslatedTargetArea.Size));
List <RRTNode> NodesInTargetArea = new List <RRTNode>();
List <RRTPath> Paths = new List <RRTPath>();
//Step through all nodes
foreach (var item in AllNodes)
{
//Check if the rectangle contains the point and check the orientation
if (Math.Abs(item.Orientation - EndRRTNode.Orientation) < AcceptableOrientationDeviation)
{
if ((Math.Abs(EndPoint.X - item.Position.X) < TargetArea.Width / 2) && (Math.Abs(EndPoint.Y - item.Position.Y) < TargetArea.Height / 2))
{
//Add to the list of found nodes.
NodesInTargetArea.Add(item);
Console.WriteLine("Found node in target area: " + item);
}
}
}
//In case no point was found return
if (NodesInTargetArea.Count == 0)
{
return(Paths);
}
//Some helpers for creating a nice color for the paths ;)
int B = 0;
int R = 255;
int Step = 255 / NodesInTargetArea.Count;
//Step through all found nodes
foreach (var item in NodesInTargetArea)
{
//Calculate length
double length = 0;
//Follow the Predecessor until their is none (this is the startpoint then)
RRTNode previous = item.Predecessor;
RRTNode end = null;
while (previous != null)
{
if (previous.Predecessor != null)
{
//TODO replace with RRTHelpers.CalculateDistance
length += RRTHelpers.CalculateDistance(previous, previous.Predecessor);
//length += Math.Sqrt (Math.Pow (previous.Position.X - previous.Predecessor.Position.X, 2) + Math.Pow (previous.Position.Y - previous.Predecessor.Position.Y, 2));
}
else
{
end = previous;
}
previous = previous.Predecessor;
}
//Create new path from start and end item
RRTPath path = new RRTPath(item, end);
Paths.Add(path);
path.Color = Color.FromArgb(R, 50, B);
path.DistanceToEnd = RRTHelpers.CalculateDistance(path.Start, EndRRTNode);
path.OrientationDeviation = path.Start.Orientation - EndRRTNode.Orientation;
B += Step;
R -= Step;
}
//Sort the list by the cost function of the given paths
Paths.Sort((RRTPath x, RRTPath y) => {
if (x.Cost() > y.Cost())
{
return(1);
}
else
{
return(-1);
}
});
//List<RRTPath> SortedList = Paths.AsParallel().OrderBy(o => o.Cost()).ToList();
foreach (var item in Paths)
{
Console.WriteLine("Length for path " + item.Color.ToString() + " : " + item.Length + " Distance to End: " + item.DistanceToEnd + " OrientationDif: " + item.OrientationDeviation);
}
return(Paths);
}
/// <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;
}
}
}
}
private void GenerateStartLine()
{
//TODO calculate distance
double Distance = 1000;
for (int offset = (int)-MaximumDrift; offset < (int)MaximumDrift; offset++)
{
RRTNode lastFound = null;
for (int i = 0; i < Distance; i = i + StepWidth)
{
int NewX = StartRRTNode.Position.X + (int)((double)i * Math.Cos((StartRRTNode.Orientation + offset) * RRTHelpers.ToRadians));
int NewY = StartRRTNode.Position.Y + (int)((double)i * Math.Sin((StartRRTNode.Orientation + offset) * RRTHelpers.ToRadians));
if (!PointValid(new Point((int)NewX, (int)NewY)))
{
if (lastFound == null)
{
RRTNode NewNode = new RRTNode(new Point(NewX, NewY), StartRRTNode.Orientation + offset, StartRRTNode);
StartRRTNode.AddSucessor(NewNode);
this.AllNodes.Add(NewNode);
lastFound = NewNode;
}
else
{
RRTNode NewNode = new RRTNode(new Point(NewX, NewY), StartRRTNode.Orientation + offset, lastFound);
lastFound.AddSucessor(NewNode);
this.AllNodes.Add(NewNode);
lastFound = NewNode;
}
}
else
{
break;
}
}
lastFound = null;
for (int i = 0; i < Distance; i = i + StepWidth)
{
int NewX = StartRRTNode.Position.X + (int)((double)i * Math.Cos(RRTHelpers.InvertOrientation(StartRRTNode.Orientation + offset) * RRTHelpers.ToRadians));
int NewY = StartRRTNode.Position.Y + (int)((double)i * Math.Sin(RRTHelpers.InvertOrientation(StartRRTNode.Orientation + offset) * RRTHelpers.ToRadians));
if (!PointValid(new Point((int)NewX, (int)NewY)))
{
if (lastFound == null)
{
RRTNode NewNode = new RRTNode(new Point(NewX, NewY), StartRRTNode.Orientation + offset, StartRRTNode);
NewNode.Inverted = true;
StartRRTNode.AddSucessor(NewNode);
this.AllNodes.Add(NewNode);
lastFound = NewNode;
}
else
{
RRTNode NewNode = new RRTNode(new Point(NewX, NewY), StartRRTNode.Orientation + offset, lastFound);
lastFound.AddSucessor(NewNode);
this.AllNodes.Add(NewNode);
lastFound = NewNode;
NewNode.Inverted = true;
}
}
else
{
break;
}
}
}
}