/// <summary> /// Find the intersection of data with fix /// </summary> /// <param name="data"></param> /// <param name="fix"></param> /// <returns></returns> private static double getIntersection(LineP data, LineP fix) { Vector intersection = Vector.Interception(data.start, data.end, fix.start, fix.end); if (intersection != null) { return(Vector.Abs(intersection - data.start) / Vector.Abs(data.end - data.start)); } return(-1); }
public double Weight() { if (weight == double.MinValue) { double[] lenght = new double[4]; double diffSum = 0; double min = Double.MaxValue; double max = Double.MinValue; double minDistance = Channels[0].getDistanceStraight() / 20; double result = 0; for (int i = 0; i < 4; i++) { lenght[i] = Channels[i].getDistance(); min = Math.Min(min, lenght[i]); max = Math.Max(max, lenght[i]); diffSum += Math.Abs(lenght[i] - (Channels[i].getDistanceStraight() / desiredLengthFactor)); for (int j = 0; j < Channels[i].LinearCombinations.Count - 1; j++) { if (i == 0) { if (Vector.Abs(Channels[i].LinearCombinations[j] - Channels[i + 1].LinearCombinations[j]) < minDistance) { result += 1000; } } else if (i == Channels.Count - 1) { if (Vector.Abs(Channels[i].LinearCombinations[j] - Channels[i - 1].LinearCombinations[j]) < minDistance) { result += 1000; } } else { if (Vector.Abs(Channels[i].LinearCombinations[j] - Channels[i + 1].LinearCombinations[j]) < minDistance) { result += 1000; } if (Vector.Abs(Channels[i].LinearCombinations[j] - Channels[i - 1].LinearCombinations[j]) < minDistance) { result += 1000; } } } } result += max - min; result += diffSum; weight = result; } return(weight); }
public double getDistance() { double result = 0; Vector last = Start; foreach (Vector v in LinearCombinations) { result += Vector.Abs(last - v); last = v; } return(result); }
internal void Randomize(double factor) { for (int i = 2; i < 8; i++) { Vector v = LinearCombinations.ElementAt(i); if (!ImmutablePoints.Contains(v)) { int sign = (i % 2 == 1) ? 1 : -1; Vector orth = Vector.Orthogonal(End - Start); orth = (orth / Vector.Abs(orth)) * (Utils.getNextDouble() * factor * sign); v.X += orth.X; v.Y += orth.Y; } } }
/// <summary> ///Graham-Scan (Only 2D !! z = 0) ///bestimme Punkt q mit minimaler y-Koordinate; ///sortiere die Punkte des Arrays nach ihrem Winkel, und bei gleichem Winkel nach ihrem Abstand zum Nullpunkt (der Punkt q wird zu p0); ///Z will be set to 0 for all Vectors!! /// </summary> /// <param name="input"></param> /// <returns></returns> public static List <Vector> Sort(List <Vector> input) { List <Vector> result = new List <Vector>(); List <Vector> list = new List <Vector>(input); Vector minY = input[0]; int count = 0; int pos = 0; foreach (Vector v in list) { v.Z = 0; if (v.Y < minY.Y) { minY = v; pos = count; } count++; } result.Add(minY); list.Remove(minY); Vector reference = minY - new Vector(1, 1, 0); while (list.Count > 0) { Vector minVec = list[0]; double minAngle = Vector.AngleClockwise(reference, minY, minVec); double minDist = Vector.Abs(minVec - minY); foreach (Vector v in list) { double minAngleTmp = Vector.AngleClockwise(reference, minY, v); double minDistTmp = Vector.Abs(v - minY); if (minAngleTmp < minAngle || (minAngleTmp == minAngle && minDistTmp < minDist)) { minVec = v; minAngle = minAngleTmp; minDist = minDistTmp; } } list.Remove(minVec); result.Add(minVec); } return(result); }
/// <summary> /// Find the intersection of data with fix. Insersection point ip is output parameter /// </summary> /// <param name="data"></param> /// <param name="fix"></param> /// <param name="ip"></param> /// <returns></returns> private static bool getIntersection(LineP data, LineP fix, out IntersectionPoint ip) { ip = new IntersectionPoint(); bool res = false; Vector intersectionV = Vector.Interception(data.start, data.end, fix.start, fix.end); if (intersectionV != null) { double intersection = Vector.Abs(intersectionV - data.start) / Vector.Abs(data.end - data.start); long timestmp = data.TimestamStart + (long)Math.Truncate((data.TimestamEnd - data.TimestamStart) * intersection); double x = data.start.X + (data.end.X - data.start.X) * intersection; double y = data.start.Y + (data.end.Y - data.start.Y) * intersection; double z = data.start.Z + (data.end.Z - data.start.Z) * intersection; ip.longitude = x; ip.latitude = y; ip.altitude = z; ip.Timestamp = timestmp; res = true; return(res); } return(res); }
public void addPolygons() { Vector ChannelRadius = Channels[3].Start - Channels[0].Start; Point Ende = new Point(); Ende.longitude = c.XtoLongitude(Channels[3].Start.X); Ende.latitude = c.YtoLatitude(Channels[3].Start.Y); Point Start = new Point(); Start.longitude = c.XtoLongitude(Channels[0].Start.X); Start.latitude = c.YtoLatitude(Channels[0].Start.Y); double origDist = Converter.Distance(Ende, Start); ChannelRadius = (ChannelRadius / origDist) * (channel * (-1.0 / 2.0)); Vector ortho = Vector.Orthogonal(ChannelRadius) / 10.0; double factorLengthSides = 10.0; double distChannelRadius = -Vector.Abs(ChannelRadius); double orthoLengthFactor = 1.0; for (int i = 1; i < 8; i += 1) { Vector localChannelRadius; localChannelRadius = Vector.Orthogonal(Channels[0].LinearCombinations[i + 1] - Channels[0].LinearCombinations[i]); localChannelRadius = (localChannelRadius / Vector.Abs(localChannelRadius)) * distChannelRadius; ortho = Vector.Orthogonal(localChannelRadius) / orthoLengthFactor; Vector a1 = Channels[0].LinearCombinations[i] + localChannelRadius + ortho; Vector a2 = Channels[0].LinearCombinations[i + 1] + localChannelRadius - ortho; Vector a3 = a1 + ChannelRadius * factorLengthSides + ortho; Vector a4 = a2 + ChannelRadius * factorLengthSides - ortho; Polygons.Add(new ParcourPolygon(a1, a2, a4, a3)); Vector b1 = Channels[0].LinearCombinations[i] - localChannelRadius + ortho; Vector b2 = Channels[0].LinearCombinations[i + 1] - localChannelRadius - ortho; localChannelRadius = Vector.Orthogonal(Channels[1].LinearCombinations[i + 1] - Channels[1].LinearCombinations[i]); localChannelRadius = (localChannelRadius / Vector.Abs(localChannelRadius)) * distChannelRadius; ortho = Vector.Orthogonal(localChannelRadius) / orthoLengthFactor; Vector b3 = Channels[1].LinearCombinations[i] + localChannelRadius + ortho; Vector b4 = Channels[1].LinearCombinations[i + 1] + localChannelRadius - ortho; Polygons.Add(new ParcourPolygon(b1, b2, b4, b3)); Vector c1 = Channels[1].LinearCombinations[i] - localChannelRadius + ortho; Vector c2 = Channels[1].LinearCombinations[i + 1] - localChannelRadius - ortho; localChannelRadius = Vector.Orthogonal(Channels[2].LinearCombinations[i + 1] - Channels[2].LinearCombinations[i]); localChannelRadius = (localChannelRadius / Vector.Abs(localChannelRadius)) * distChannelRadius; ortho = Vector.Orthogonal(localChannelRadius) / orthoLengthFactor; Vector c3 = Channels[2].LinearCombinations[i] + localChannelRadius + ortho; Vector c4 = Channels[2].LinearCombinations[i + 1] + localChannelRadius - ortho; Polygons.Add(new ParcourPolygon(c1, c2, c4, c3)); Vector d1 = Channels[2].LinearCombinations[i] - localChannelRadius + ortho; Vector d2 = Channels[2].LinearCombinations[i + 1] - localChannelRadius - ortho; localChannelRadius = Vector.Orthogonal(Channels[3].LinearCombinations[i + 1] - Channels[3].LinearCombinations[i]); localChannelRadius = (localChannelRadius / Vector.Abs(localChannelRadius)) * distChannelRadius; ortho = Vector.Orthogonal(localChannelRadius) / orthoLengthFactor; Vector d3 = Channels[3].LinearCombinations[i] + localChannelRadius + ortho; Vector d4 = Channels[3].LinearCombinations[i + 1] + localChannelRadius - ortho; Polygons.Add(new ParcourPolygon(d1, d2, d4, d3)); Vector e1 = Channels[3].LinearCombinations[i] - localChannelRadius + ortho; Vector e2 = Channels[3].LinearCombinations[i + 1] - localChannelRadius - ortho; Vector e3 = e1 - ChannelRadius * factorLengthSides + ortho; Vector e4 = e2 - ChannelRadius * factorLengthSides - ortho; Polygons.Add(new ParcourPolygon(e1, e2, e4, e3)); } }
public double getDistanceStraight() { return(Vector.Abs(Start - End)); }
private bool samePos(Point a, Point b) { return(Vector.Abs(new Vector(a.longitude, a.latitude, a.altitude) - new Vector(b.longitude, b.latitude, b.altitude)) < 0.00001); }
public void addPolygons() { Point Start = new Point(); Start.longitude = c.XtoLongitude(Channel.Start.X); Start.latitude = c.YtoLatitude(Channel.Start.Y); //TODO double latitude = Start.latitude; double longitude = Start.longitude; double channelMeterKm = channelWidth; double latitudePlus1 = latitude + 1; double longitudePlus1 = longitude + 1; double distLat1 = Converter.Distance(longitude, latitude, longitude, latitudePlus1); double distLong1 = Converter.Distance(longitude, latitude, longitudePlus1, latitude); double corridorDiffInLat = channelMeterKm / distLat1; double corridorDiffInLong = channelMeterKm / distLong1; double channelLatitude = corridorDiffInLat / 2; double channelLongitude = corridorDiffInLong / 2; double longitudePlusChannel = longitude + channelLongitude; double latitudePlusChannel = latitude + channelLatitude; double channelx = c.LongitudeToX(longitudePlusChannel) - Channel.Start.X; double channely = c.LatitudeToY(latitudePlusChannel) - Channel.Start.Y; Vector channel = new Vector(channelx, channely, 0); Vector startEnd = new Vector(Channel.End.X, Channel.End.Y, 0) - new Vector(Channel.Start.X, Channel.Start.Y, 0); Vector startEndOrtho = Vector.Orthogonal(startEnd) * (-1); Vector startEndOrthoNormalized = (startEndOrtho / Vector.Abs(startEndOrtho)) * Vector.Abs(channel); Vector startEndNormalized = (startEnd / Vector.Abs(startEnd)) * Vector.Abs(channel); for (int i = 1; i < 8; i++) { Vector localChannel = Channel.LinearCombinations[i + 1] - Channel.LinearCombinations[i]; Vector localChannelOrtho = Vector.Orthogonal(localChannel); Vector localChannelOrthoNormalized = (localChannelOrtho / Vector.Abs(localChannelOrtho)) * -Vector.Abs(channel); Vector a1_intersection = Vector.InterceptionLine(Channel.LinearCombinations[i], startEndOrtho, Channel.LinearCombinations[i] + localChannelOrthoNormalized - localChannel * 10, Channel.LinearCombinations[i + 1] + localChannelOrthoNormalized + localChannel * 10); { Vector localChannel2 = Channel.LinearCombinations[i] - Channel.LinearCombinations[i - 1]; Vector localChannelOrtho2 = Vector.Orthogonal(localChannel2); Vector localChannelOrthoNormalized2 = (localChannelOrtho2 / Vector.Abs(localChannelOrtho2)) * -Vector.Abs(channel); Vector a1_intersection2 = Vector.InterceptionLine(Channel.LinearCombinations[i], startEndOrtho, Channel.LinearCombinations[i] + localChannelOrthoNormalized2 - localChannel2 * 10, Channel.LinearCombinations[i] + localChannelOrthoNormalized2 + localChannel2 * 10); a1_intersection = new Vector(a1_intersection.X, Math.Min(a1_intersection.Y, a1_intersection2.Y), 0); } Vector a2_intersection = Vector.InterceptionLine(Channel.LinearCombinations[i + 1], startEndOrtho, Channel.LinearCombinations[i] + localChannelOrthoNormalized - localChannel * 10, Channel.LinearCombinations[i + 1] + localChannelOrthoNormalized + localChannel * 10); { Vector localChannel2 = Channel.LinearCombinations[i + 2] - Channel.LinearCombinations[i + 1]; Vector localChannelOrtho2 = Vector.Orthogonal(localChannel2); Vector localChannelOrthoNormalized2 = (localChannelOrtho2 / Vector.Abs(localChannelOrtho2)) * -Vector.Abs(channel); Vector a2_intersection2 = Vector.InterceptionLine(Channel.LinearCombinations[i + 1], startEndOrtho, Channel.LinearCombinations[i + 1] + localChannelOrthoNormalized2 - localChannel2 * 10, Channel.LinearCombinations[i + 1] + localChannelOrthoNormalized2 + localChannel2 * 10); a2_intersection = new Vector(a2_intersection.X, Math.Min(a2_intersection.Y, a2_intersection2.Y), 0); } Vector a1 = a1_intersection; Vector a2 = a2_intersection; Vector a3 = a1 + startEndOrtho / 3; Vector a4 = a2 + startEndOrtho / 3; Polygons.Add(new ParcourPolygon(a1, a2, a4, a3)); Vector b1_intersection = Vector.InterceptionLine(Channel.LinearCombinations[i], startEndOrtho, Channel.LinearCombinations[i] - localChannelOrthoNormalized - localChannel * 10, Channel.LinearCombinations[i + 1] - localChannelOrthoNormalized + localChannel * 10); { Vector localChannel2 = Channel.LinearCombinations[i] - Channel.LinearCombinations[i - 1]; Vector localChannelOrtho2 = Vector.Orthogonal(localChannel2); Vector localChannelOrthoNormalized2 = (localChannelOrtho2 / Vector.Abs(localChannelOrtho2)) * -Vector.Abs(channel); Vector b1_intersection2 = Vector.InterceptionLine(Channel.LinearCombinations[i], startEndOrtho, Channel.LinearCombinations[i] - localChannelOrthoNormalized2 - localChannel2 * 10, Channel.LinearCombinations[i] - localChannelOrthoNormalized2 + localChannel2 * 10); b1_intersection = new Vector(b1_intersection.X, Math.Max(b1_intersection.Y, b1_intersection2.Y), 0); } Vector b2_intersection = Vector.InterceptionLine(Channel.LinearCombinations[i + 1], startEndOrtho, Channel.LinearCombinations[i] - localChannelOrthoNormalized - localChannel * 10, Channel.LinearCombinations[i + 1] - localChannelOrthoNormalized + localChannel * 10); { Vector localChannel2 = Channel.LinearCombinations[i + 2] - Channel.LinearCombinations[i + 1]; Vector localChannelOrtho2 = Vector.Orthogonal(localChannel2); Vector localChannelOrthoNormalized2 = (localChannelOrtho2 / Vector.Abs(localChannelOrtho2)) * -Vector.Abs(channel); Vector b2_intersection2 = Vector.InterceptionLine(Channel.LinearCombinations[i + 1], startEndOrtho, Channel.LinearCombinations[i + 1] - localChannelOrthoNormalized2 - localChannel2 * 10, Channel.LinearCombinations[i + 1] - localChannelOrthoNormalized2 + localChannel2 * 10); b2_intersection = new Vector(b2_intersection.X, Math.Max(b2_intersection.Y, b2_intersection2.Y), 0); } Vector b1 = b1_intersection; Vector b2 = b2_intersection; Vector b3 = b1 - startEndOrtho / 3; Vector b4 = b2 - startEndOrtho / 3; Polygons.Add(new ParcourPolygon(b1, b2, b4, b3)); } }
public void GenerateParcour(ParcourSet parcour, Converter c, double lenght, double channel, int count) { this.parcour = parcour; this.c = c; this.count = count; Line Start = parcour.Line.Single(p => p.Type == (int)LineType.START) as Line; if (Start == null) { return; } #region StartVektoren Vector StartAV = new Vector(c.LongitudeToX(Start.A.longitude), c.LatitudeToY(Start.A.latitude), 0); Vector StartBV = new Vector(c.LongitudeToX(Start.B.longitude), c.LatitudeToY(Start.B.latitude), 0); Vector StartOV = new Vector(c.LongitudeToX(Start.O.longitude), c.LatitudeToY(Start.O.latitude), 0); Vector StartAB = Vector.Direction(StartAV, StartBV); Vector StartMV = Vector.Middle(StartAV, StartBV); Vector StartLotOrientation = Vector.MinDistance(StartAV, StartBV, StartOV); double GateRadiusKm = Converter.NMtoM(0.3); Vector StartABNormalized = StartAB / Vector.Abs(StartAB); double StartABLength = Converter.Distance(c.XtoLongitude(StartAV.X), c.YtoLatitude(StartAV.Y), c.XtoLongitude((StartAV + StartABNormalized).X), c.YtoLatitude((StartAV + StartABNormalized).Y)); Vector StartAB1KM = StartABNormalized / StartABLength; StartLotOrientation = StartLotOrientation * (Vector.Abs(StartAB1KM * GateRadiusKm) / Vector.Abs(StartLotOrientation)); StartOV = StartMV + (StartLotOrientation * 2); Vector Start_A_M = StartAV + (StartAB1KM * GateRadiusKm); Vector Start_A_A = StartAV; Vector Start_A_B = Start_A_M + (StartAB1KM * GateRadiusKm); Vector Start_A_O = Start_A_M + StartLotOrientation; Line Start_A; if (parcour.Line.Any(p => p.Type == (int)LineType.START_A)) { Start_A = parcour.Line.Single(p => p.Type == (int)LineType.START_A); } else { Start_A = new Line(); Start_A.Type = (int)LineType.START_A; parcour.Line.Add(Start_A); } Start_A.A = Factory.newGPSPoint(c.XtoLongitude(Start_A_A.X), c.YtoLatitude(Start_A_A.Y), 0); Start_A.B = Factory.newGPSPoint(c.XtoLongitude(Start_A_B.X), c.YtoLatitude(Start_A_B.Y), 0); Start_A.O = Factory.newGPSPoint(c.XtoLongitude(Start_A_O.X), c.YtoLatitude(Start_A_O.Y), 0); Vector Start_D_M = StartBV - (StartAB1KM * GateRadiusKm); Vector Start_D_B = StartBV; Vector Start_D_A = Start_D_M - (StartAB1KM * GateRadiusKm); Vector Start_D_O = Start_D_M + StartLotOrientation; Line Start_D; if (parcour.Line.Any(p => p.Type == (int)LineType.START_D)) { Start_D = parcour.Line.Single(p => p.Type == (int)LineType.START_D); } else { Start_D = new Line(); Start_D.Type = (int)LineType.START_D; parcour.Line.Add(Start_D); } Start_D.A = Factory.newGPSPoint(c.XtoLongitude(Start_D_A.X), c.YtoLatitude(Start_D_A.Y), 0); Start_D.B = Factory.newGPSPoint(c.XtoLongitude(Start_D_B.X), c.YtoLatitude(Start_D_B.Y), 0); Start_D.O = Factory.newGPSPoint(c.XtoLongitude(Start_D_O.X), c.YtoLatitude(Start_D_O.Y), 0); Vector Start_B_M = Start_A_M + (Vector.Direction(Start_A_M, Start_D_M) / 3.0); Vector Start_B_A = Start_B_M - (StartAB1KM * GateRadiusKm); Vector Start_B_B = Start_B_M + (StartAB1KM * GateRadiusKm); Vector Start_B_O = Start_B_M + StartLotOrientation; Line Start_B; if (parcour.Line.Any(p => p.Type == (int)LineType.START_B)) { Start_B = parcour.Line.Single(p => p.Type == (int)LineType.START_B); } else { Start_B = new Line(); Start_B.Type = (int)LineType.START_B; parcour.Line.Add(Start_B); } Start_B.A = Factory.newGPSPoint(c.XtoLongitude(Start_B_A.X), c.YtoLatitude(Start_B_A.Y), 0); Start_B.B = Factory.newGPSPoint(c.XtoLongitude(Start_B_B.X), c.YtoLatitude(Start_B_B.Y), 0); Start_B.O = Factory.newGPSPoint(c.XtoLongitude(Start_B_O.X), c.YtoLatitude(Start_B_O.Y), 0); Vector Start_C_M = Start_A_M + ((Vector.Direction(Start_A_M, Start_D_M) * 2) / 3.0); Vector Start_C_B = Start_C_M - (StartAB1KM * GateRadiusKm); Vector Start_C_A = Start_C_M + (StartAB1KM * GateRadiusKm); Vector Start_C_O = Start_C_M + StartLotOrientation; Line Start_C; if (parcour.Line.Any(p => p.Type == (int)LineType.START_C)) { Start_C = parcour.Line.Single(p => p.Type == (int)LineType.START_C); } else { Start_C = new Line(); Start_C.Type = (int)LineType.START_C; parcour.Line.Add(Start_C); } Start_C.A = Factory.newGPSPoint(c.XtoLongitude(Start_C_A.X), c.YtoLatitude(Start_C_A.Y), 0); Start_C.B = Factory.newGPSPoint(c.XtoLongitude(Start_C_B.X), c.YtoLatitude(Start_C_B.Y), 0); Start_C.O = Factory.newGPSPoint(c.XtoLongitude(Start_C_O.X), c.YtoLatitude(Start_C_O.Y), 0); #endregion #region EndeVektoren double lengthKm = Converter.NMtoM(lenght); Vector lotPoint = StartMV + StartLotOrientation; double lotLenght = Converter.Distance(c.XtoLongitude(StartMV.X), c.YtoLatitude(StartMV.Y), c.XtoLongitude(lotPoint.X), c.YtoLatitude(lotPoint.Y)); Vector StartEnd = (StartLotOrientation / lotLenght) * lengthKm * EndLineDist; //Shorten to make linearcombinations of vectors ... factor to be definded Vector EndeAV = StartAV + StartEnd; Vector EndeBV = StartBV + StartEnd; Vector EndeMV = Vector.Middle(EndeAV, EndeBV); Vector EndeOV = EndeMV + StartLotOrientation; Vector EndeAB = Vector.Direction(EndeAV, EndeBV); Vector Ende_A_A = Start_A_A + StartEnd; Vector Ende_A_B = Start_A_B + StartEnd; Vector Ende_A_M = Start_A_M + StartEnd; Vector Ende_A_O = Start_A_O + StartEnd; Line END_A; if (parcour.Line.Any(p => p.Type == (int)LineType.END_A)) { END_A = parcour.Line.Single(p => p.Type == (int)LineType.END_A); } else { END_A = new Line(); END_A.Type = (int)LineType.END_A; parcour.Line.Add(END_A); } END_A.A = Factory.newGPSPoint(c.XtoLongitude(Ende_A_A.X), c.YtoLatitude(Ende_A_A.Y), 0); END_A.B = Factory.newGPSPoint(c.XtoLongitude(Ende_A_B.X), c.YtoLatitude(Ende_A_B.Y), 0); END_A.O = Factory.newGPSPoint(c.XtoLongitude(Ende_A_O.X), c.YtoLatitude(Ende_A_O.Y), 0); Vector Ende_B_A = Start_B_A + StartEnd; Vector Ende_B_B = Start_B_B + StartEnd; Vector Ende_B_M = Start_B_M + StartEnd; Vector Ende_B_O = Start_B_O + StartEnd; Line END_B; if (parcour.Line.Any(p => p.Type == (int)LineType.END_B)) { END_B = parcour.Line.Single(p => p.Type == (int)LineType.END_B); } else { END_B = new Line(); END_B.Type = (int)LineType.END_B; parcour.Line.Add(END_B); } END_B.A = Factory.newGPSPoint(c.XtoLongitude(Ende_B_A.X), c.YtoLatitude(Ende_B_A.Y), 0); END_B.B = Factory.newGPSPoint(c.XtoLongitude(Ende_B_B.X), c.YtoLatitude(Ende_B_B.Y), 0); END_B.O = Factory.newGPSPoint(c.XtoLongitude(Ende_B_O.X), c.YtoLatitude(Ende_B_O.Y), 0); Vector Ende_C_A = Start_C_A + StartEnd; Vector Ende_C_B = Start_C_B + StartEnd; Vector Ende_C_M = Start_C_M + StartEnd; Vector Ende_C_O = Start_C_O + StartEnd; Line END_C; if (parcour.Line.Any(p => p.Type == (int)LineType.END_C)) { END_C = parcour.Line.Single(p => p.Type == (int)LineType.END_C); } else { END_C = new Line(); END_C.Type = (int)LineType.END_C; parcour.Line.Add(END_C); } END_C.A = Factory.newGPSPoint(c.XtoLongitude(Ende_C_A.X), c.YtoLatitude(Ende_C_A.Y), 0); END_C.B = Factory.newGPSPoint(c.XtoLongitude(Ende_C_B.X), c.YtoLatitude(Ende_C_B.Y), 0); END_C.O = Factory.newGPSPoint(c.XtoLongitude(Ende_C_O.X), c.YtoLatitude(Ende_C_O.Y), 0); Vector Ende_D_A = Start_D_A + StartEnd; Vector Ende_D_B = Start_D_B + StartEnd; Vector Ende_D_M = Start_D_M + StartEnd; Vector Ende_D_O = Start_D_O + StartEnd; Line END_D; if (parcour.Line.Any(p => p.Type == (int)LineType.END_D)) { END_D = parcour.Line.Single(p => p.Type == (int)LineType.END_D); } else { END_D = new Line(); END_D.Type = (int)LineType.END_D; parcour.Line.Add(END_D); } END_D.A = Factory.newGPSPoint(c.XtoLongitude(Ende_D_A.X), c.YtoLatitude(Ende_D_A.Y), 0); END_D.B = Factory.newGPSPoint(c.XtoLongitude(Ende_D_B.X), c.YtoLatitude(Ende_D_B.Y), 0); END_D.O = Factory.newGPSPoint(c.XtoLongitude(Ende_D_O.X), c.YtoLatitude(Ende_D_O.Y), 0); #endregion #region LineOfNoReturn double lengthLONRKm = Converter.NMtoM(LineOfNoReturnDist); Vector StartToLONR = (StartLotOrientation / lotLenght) * ((lengthKm * EndLineDist) - lengthLONRKm); Vector LONR_A = StartAV + StartToLONR; Vector LONR_B = StartBV + StartToLONR; Vector LONR_O = StartOV + StartToLONR; Line LONR; if (parcour.Line.Any(p => p.Type == (int)LineType.NOBACKTRACKLINE)) { LONR = parcour.Line.Single(p => p.Type == (int)LineType.NOBACKTRACKLINE); } else { LONR = new Line(); LONR.Type = (int)LineType.NOBACKTRACKLINE; parcour.Line.Add(LONR); } LONR.A = Factory.newGPSPoint(c.XtoLongitude(LONR_A.X), c.YtoLatitude(LONR_A.Y), 0); LONR.B = Factory.newGPSPoint(c.XtoLongitude(LONR_B.X), c.YtoLatitude(LONR_B.Y), 0); LONR.O = Factory.newGPSPoint(c.XtoLongitude(LONR_O.X), c.YtoLatitude(LONR_O.Y), 0); #endregion CalculateParcour(parcour, c, channel); }