} // End Property Slope2D
// https://stackoverflow.com/questions/17692922/check-is-a-point-x-y-is-between-two-points-drawn-on-a-straight-line
public bool IsPointOnLine(MyPoint3D <T> p)
{
T norm = this.Vector.MagnitudeSquared;
MyVector3D <T> vec1 = new MyVector3D <T>(this.m_start, p);
MyVector3D <T> vec2 = new MyVector3D <T>(this.m_end, p);
T dist = Arithmetics <T> .Add(vec1.MagnitudeSquared, vec2.MagnitudeSquared);
if (norm.Equals(dist))
{
return(true);
}
T delta = Arithmetics <T> .Subtract(vec1.MagnitudeSquared, vec2.MagnitudeSquared);
decimal decDelta = System.Convert.ToDecimal(delta);
decDelta = System.Math.Abs(decDelta);
// Greatest possible floating-point difference
decimal decFloatEpsilon = System.Convert.ToDecimal(float.Epsilon);
if (decDelta <= decFloatEpsilon)
{
return(true);
}
return(false);
} // End Function IsPointOnLine
public MyVector3D(MyPoint3D <T> a, MyPoint3D <T> b)
{
this.X = Arithmetics <T> .Subtract(a.X, b.X);
this.Y = Arithmetics <T> .Subtract(a.Y, b.Y);
this.Z = Arithmetics <T> .Subtract(a.Z, b.Z);
} // End Constructor
private void AddLineToMap(MyPoint3D p1, MyPoint3D p2)
{
VM.LineVM l = new VM.LineVM();
l.Locations = new LocationCollection();
l.Locations.Add(p1.ToGeo().ToLocation());
l.Locations.Add(p2.ToGeo().ToLocation());
GuidanceLines.Add(l);
}
public void TestIsInLineSegment()
{
MyPoint3D p1 = new MyPoint3D(1, 3, 0);
MyPoint3D p2 = new MyPoint3D(0, -1, 0);
Assert.IsTrue(Utility.IsInLineSegment(p1, p2, new MyPoint3D(0.25, 0, 0)));
Assert.IsTrue(Utility.IsInLineSegment(p2, p1, new MyPoint3D(0.25, 0, 0)));
Assert.IsFalse(Utility.IsInLineSegment(p2, p1, new MyPoint3D(0.25, 4, 0)));
}
} // End Function IsPointOnLine
public static MyVector3D <T> ToVector(MyPoint3D <T> start, MyPoint3D <T> end)
{
T x = Arithmetics <T> .Subtract(end.X, start.X);
T y = Arithmetics <T> .Subtract(end.Y, start.Y);
T z = Arithmetics <T> .Subtract(end.Z, start.Z);
return(new MyVector3D <T>(x, y, z));
} // End Function ToVector
} // End Operator +
public static MyPoint3D <T> operator +(MyPoint3D <T> point, MyVector3D <T> a)
{
MyPoint3D <T> p = point.Clone();
p.X = Arithmetics <T> .Add(p.X, a.X);
p.Y = Arithmetics <T> .Add(p.Y, a.Y);
p.Z = Arithmetics <T> .Add(p.Z, a.Z);
return(p);
} // End Operator +
private void AddSwathToMap(MyPoint3D p1, MyPoint3D p2, double width)
{
VM.PolygonVM polygon = new VM.PolygonVM();
polygon.Fill = new SolidColorBrush(Colors.Blue);
polygon.Fill.Opacity = 0.3;
polygon.Locations = new LocationCollection();
MyPoint3D n = (p2 - p1).Normalize();
MyPoint3D np = new MyPoint3D(n.Y, -n.X, 0);
polygon.Locations.Add((p1 + (np * (width / 2))).ToGeo().ToLocation());
polygon.Locations.Add((p2 + (np * (width / 2))).ToGeo().ToLocation());
polygon.Locations.Add((p2 - (np * (width / 2))).ToGeo().ToLocation());
polygon.Locations.Add((p1 - (np * (width / 2))).ToGeo().ToLocation());
Swathes.Add(polygon);
}
} // End Function ToString
/// <summary>
/// Returns a new Vector that is the linear blend of the 2 given Vectors
/// </summary>
/// <param name="a">First input vector</param>
/// <param name="b">Second input vector</param>
/// <param name="blend">The blend factor. a when blend=0, b when blend=1.</param>
/// <returns>a when blend=0, b when blend=1, and a linear combination otherwise</returns>
public static MyPoint3D <T> Lerp(MyPoint3D <T> a, MyPoint3D <T> b, T blend)
{
T bxax = Arithmetics <T> .Subtract(b.X, a.X);
T byay = Arithmetics <T> .Subtract(b.Y, a.Y);
T bzaz = Arithmetics <T> .Subtract(b.Z, a.Z);
T f1 = Arithmetics <T> .Multiply(blend, bxax);
T f2 = Arithmetics <T> .Multiply(blend, byay);
T f3 = Arithmetics <T> .Multiply(blend, bzaz);
T x = Arithmetics <T> .Add(f1, a.X);
T y = Arithmetics <T> .Add(f2, a.Y);
T z = Arithmetics <T> .Add(f3, a.Z);
return(new MyPoint3D <T>(x, y, z));
} // End Function Lerp
public void TestShiftPoint()
{
MyPoint3D p1 = new MyPoint3D(1, -1, 0);
MyPoint3D p2 = new MyPoint3D(0, 0, 0);
MyPoint3D p3 = new MyPoint3D(1, 1, 0);
var p = Utility.ShiftPoint(p1, p2, p3, 12);
Assert.AreEqual(0, p.Y);
Assert.AreEqual(true, Math.Abs(-12 * Math.Sqrt(2) - p.X) < 0.00000000001);
List <MyPoint3D> cartPolygon = new List <MyPoint3D>();
cartPolygon.Add(new MyPoint3D(0, 1, 0));
cartPolygon.Add(new MyPoint3D(1, 1, 0));
cartPolygon.Add(new MyPoint3D(1, 0, 0));
cartPolygon.Add(new MyPoint3D(0, 0, 0));
cartPolygon.Add(new MyPoint3D(0, 1, 0));
int i = 1;
p = Utility.ShiftPoint(cartPolygon[i - 1], cartPolygon[i], cartPolygon[i + 1], 0.1);
Assert.AreEqual(1.1, p.X);
Assert.AreEqual(1.1, p.Y);
i = 2;
p = Utility.ShiftPoint(cartPolygon[i - 1], cartPolygon[i], cartPolygon[i + 1], 0.1);
Assert.AreEqual(1.1, p.X);
Assert.AreEqual(-0.1, p.Y);
i = 3;
p = Utility.ShiftPoint(cartPolygon[i - 1], cartPolygon[i], cartPolygon[i + 1], 0.1);
Assert.AreEqual(-0.1, p.X);
Assert.AreEqual(-0.1, p.Y);
}
} // End Function MyLine3D
public MyLine3D(MyPoint3D <T> start, MyVector3D <T> vec)
{
this.Start = start;
this.End = start + vec;
} // End Function MyLine3D
public MyLine3D(MyPoint3D <T> start, MyPoint3D <T> end)
{
this.Start = start;
this.End = end;
} // End Function MyLine3D
} // End Constructor
public MyPoint3D(MyPoint3D <T> point)
{
this.X = point.X;
this.Y = point.Y;
this.Z = point.Z;
} // End Constructor
} // End Constructor
public MyVector3D(MyPoint3D <T> point)
: base(point.X, point.Y, point.Z)
{
} // End Constructor
private AnalysisResult AnalyzeFieldAndShowSwaths(FieldVM polygon, LineDefinition lineDef)
{
double processedArea = 0;
double width = ImplementWidth;
var geoPolygon = new List <GeoPoint>();
foreach (var p in polygon.Locations)
{
geoPolygon.Add(p.ToGeoPoint());
}
List <MyPoint3D> cartPolygon = new List <MyPoint3D>();
foreach (var p in polygon.Locations)
{
cartPolygon.Add(p.ToGeoPoint().ToCart());
}
double length = width / 2.0;
if (Utility.CalculateArea(geoPolygon, false) < 0)
{
length = -length;
}
List <MyPoint3D> boundary = new List <MyPoint3D>();
MyPoint3D prevP = cartPolygon[0];
boundary.Add(cartPolygon[0]);
for (int i = 1; i < cartPolygon.Count; i++)
{
if ((prevP - cartPolygon[i]).Norm < 3)
{
continue;
}
prevP = cartPolygon[i];
boundary.Add(cartPolygon[i]);
}
if ((boundary.First() - boundary.Last()).Norm < 3)
{
boundary.Remove(boundary.Last());
}
length = -length;
List <MyPoint3D> headLand = Utility.ShiftBoundary(length, boundary);
headLand.Add(headLand.First());
List <MyPoint3D> innerBoundary = Utility.ShiftBoundary(2 * length, boundary);
AddHeadLandToMap(headLand);
AddOuterSwathToMap(boundary, innerBoundary);
var intersections = Utility.GetHeadlandIntersections(headLand, lineDef, width);
processedArea += width * ComputeParallelLines(width, headLand, lineDef, intersections, true).LinesLength;
lineDef = LineDefinition.GetParallelLine(lineDef, -width);
intersections = Utility.GetHeadlandIntersections(headLand, lineDef, width);
processedArea += width * ComputeParallelLines(-width, headLand, lineDef, intersections, true).LinesLength;
for (int i = 1; i < headLand.Count; i++)
{
processedArea += width * (headLand[i - 1] - headLand[i]).Norm;
}
AnalysisResult res = new AnalysisResult();
res.AppliedArea = processedArea;
res.FieldArea = Utility.CalculateArea(geoPolygon);
return(res);
}
