public Fraction DistanceSquared(PointFr that)
{
var dX = _x - that.X;
var dY = _y - that.Y;
return(dX * dX + dY * dY);
}
public double Distance(PointFr that)
{
var dX = (_x - that.X).ToDouble();
var dY = (_y - that.Y).ToDouble();
return(Math.Sqrt(dX * dX + dY * dY));
}
public static PointFr Midpoint(PointFr a, PointFr b)
{
return(new PointFr(
(a.X + b.X) / 2,
(a.Y + b.Y) / 2
));
}
public Fraction DistanceXY(PointFr that)
{
var dX = (_x - that.X).Abs();
var dY = (_y - that.Y).Abs();
return(dX + dY);
}
public EventPoint(PointFr value, EventPointType type, LineSegmentFr[] crossingSegments, SweepLine sweepLine)
{
PointValue = value;
Type = type;
CrossingSegments = crossingSegments;
SweepLine = sweepLine;
}
public EventPoint(PointFr value, EventPointType type, LineSegmentFr?segment, SweepLine sweepLine)
{
PointValue = value;
Type = type;
Segment = segment;
SweepLine = sweepLine;
}
} // test bada współliniowość, a nie czy punkt jest zawarty w odcinku
public static Fraction PointFrOrientationTest(PointFr point, LineSegmentFr segment)
{
var p0 = point;
var p1 = segment.StartPoint;
var p2 = segment.EndPoint;
return((p1.X - p0.X) * (p2.Y - p0.Y) - (p1.Y - p0.Y) * (p2.X - p0.X));
}
public bool Contains(PointFr p)
{
if (IsVertical())
{
return(Constant.Equals(p.X));
}
return(Slope * p.X + Constant == p.Y);
}
private static Fraction CalculateSlope(PointFr p1, PointFr p2) // Slope = (p2.y - p1.y) / (p2.x - p1.x)
{
if (p1.X.Equals(p2.X))
{
return(Fraction.PositiveInfinity);
}
return((p2.Y - p1.Y) / (p2.X - p1.X));
}
private static Fraction CalculateConstant(PointFr p, Fraction slope) // Constant = (-Slope* p.x) + p.y
{
if (slope.IsInfinity()) // IsVertical()
{
return(p.X);
}
return(-slope * p.X + p.Y);
}
public LineFr(Fraction slope, PointFr p)
{
if (slope.IsNaN())
{
throw new ArgumentException("Slope (Nachylenie) nie może przyjmować wartości NaN");
}
Slope = slope.IsInfinity() ? Fraction.PositiveInfinity : slope;
Constant = CalculateConstant(p, slope);
}
public LineFr(PointFr p1, PointFr p2)
{
if (p1.Equals(p2))
{
throw new ArgumentException("Nie można utworzyć linii dla dwóch takich samych punktów");
}
Slope = CalculateSlope(p1, p2);
Constant = CalculateConstant(p1, Slope);
}
public LineFr PerpendicularLine(PointFr p)
{
if (IsHorizontal())
{
return(Vertical(p.X));
}
if (IsVertical())
{
return(Horizontal(p.Y));
}
var newSlope = Slope.Inverse();
return(new LineFr(newSlope, p));
}
public static bool IsInsideConvexPolygon(PointFr point, PolygonFr polygon)
{
var vertices = polygon.Vertices.ToList(); // wierzchołki posortowane przeciwnie do wskazówek zegara względem wnętrza wielokąta
var edges = polygon.Edges().ToList();
if (vertices.Count < 3)
{
throw new ArgumentException("Polygon can't have less than 3 vertices");
}
if (ConvexHullJarvis(vertices).Count != vertices.Count) // Powinno wystarczyć Count
{
throw new ArgumentException("Polygon must be convex");
}
if (vertices.Count == 3)
{
return(!edges.Any(point.IsRightOf));
}
var polyCenter = polygon.Center;
if (polyCenter == null)
{
throw new Exception("Can't calculate center of the Polygon");
}
var mid = (PointFr)polyCenter;
while (edges.Count > 1)
{
var testSegment = new LineSegmentFr(mid, edges[edges.Count / 2].StartPoint);
if (point.IsRightOf(testSegment))
{
edges = edges.Take(edges.Count / 2).ToList();
}
else if (point.IsLeftOf(testSegment))
{
edges = edges.Skip(edges.Count / 2).ToList();
}
else if (testSegment.Contains(point))
{
return(true);
}
else
{
throw new Exception("Invalid calculations performed, it should never happen");
}
}
return(!point.IsRightOf(edges.Single())); // czyli IsLeftOf + Contains, jeżeli jest we wierzchołku to będzie spełniony ostatni warunek z while'a
}
public void Insert(PointFr p, EventPoint ep) // Wstawia zdarzenie ep w punkcie p do bieżącej kolejki zdarzeń zdarzenia Right są dodawane na początku, pozostałe na końcu
{
var existing = new C5.LinkedList <EventPoint>();
if (_events.Exists(kvp => kvp.Key.Equals(p)))
{
existing = _events[p];
_events.Remove(p);
}
if (ep.Type == EventPointType.Right) // Zdarzenia 'Right' powinny byc na początku listy
{
existing.Insert(0, ep);
}
else
{
existing.Add(ep);
}
_events.Add(p, existing);
}
public bool Contains2(PointFr point)
{
if (Edges(true).Any(edge => edge.Contains(point)))
{
return(true);
}
int i, j = _vertices.Count - 1;
var contains = false;
for (i = 0; i < _vertices.Count; i++)
{
if ((_vertices[i].Y < point.Y && _vertices[j].Y >= point.Y || _vertices[j].Y < point.Y && _vertices[i].Y >= point.Y) && (_vertices[i].X <= point.X || _vertices[j].X <= point.X))
{
contains ^= (_vertices[i].X + (point.Y - _vertices[i].Y) / (_vertices[j].Y - _vertices[i].Y) * (_vertices[j].X - _vertices[i].X) < point.X);
}
j = i;
}
return(contains);
}
public static bool IsInsidePolygon(PointFr point, PolygonFr polygon)
{
if (polygon.Edges(true).Any(edge => edge.Contains(point)))
{
return(true);
}
var vertices = polygon.Vertices.ToList();
int i, j = vertices.Count - 1;
var contains = false;
for (i = 0; i < vertices.Count; i++)
{
if ((vertices[i].Y < point.Y && vertices[j].Y >= point.Y || vertices[j].Y < point.Y && vertices[i].Y >= point.Y) && (vertices[i].X <= point.X || vertices[j].X <= point.X))
{
contains ^= (vertices[i].X + (point.Y - vertices[i].Y) / (vertices[j].Y - vertices[i].Y) * (vertices[j].X - vertices[i].X) < point.X);
}
j = i;
}
return(contains);
}
public LineSegmentFr(PointFr start, PointFr end, bool LeftMostPointFirst = false)
{
if (start.Equals(end))
{
throw new ArgumentException("Nie można utworzyć odcinka, o dwóch takich samych punktach");
}
StartPoint = start;
EndPoint = end;
MaxX = start.X > end.X ? start.X : end.X;
MaxY = start.Y > end.Y ? start.Y : end.Y;
MinX = start.X < end.X ? start.X : end.X;
MinY = start.Y < end.Y ? start.Y : end.Y;
Line = new LineFr(start, end);
if (LeftMostPointFirst)
{
NormalizeEndPoints();
}
}
public bool Contains(PointFr p)
{
return(StartPoint.Equals(p) || EndPoint.Equals(p) ||
(Line.Contains(p) && (p.X >= MinX) && p.X <= MaxX && p.Y >= MinY && p.Y <= MaxY));
}
public bool IsBelow(PointFr that)
{
return(_x < that.Y);
}
public bool IsAbove(PointFr that)
{
return(_x > that.Y);
}
public static Fraction Slope(PointFr from, PointFr to)
{
return((to.Y - from.Y) / (to.X - from.X));
}
public bool Contains(PointFr point)
{
return(GeometryCalculations.IsInsidePolygon(point, this));
}
public bool HasEnding(PointFr p)
{
return(StartPoint.Equals(p) || EndPoint.Equals(p));
}
public TriangleFr(PointFr vertex1, PointFr vertex2, PointFr vertex3)
{
Vertex1 = vertex1;
Vertex2 = vertex2;
Vertex3 = vertex3;
}
public bool ContainsInCircumcircle(PointFr p, TriangleFr superTriangle = null)
{
var vertices = Vertices().OrderBy(pnt => pnt.X).ThenBy(pnt => pnt.Y).ToList();
var p1 = vertices[0];
var p2 = vertices[1];
var p3 = vertices[2];
if ((p1.Y - p2.Y).Abs() == 0 && (p2.Y - p3.Y).Abs() == 0) // < double.Epsilon
{
return(false);
}
if (superTriangle != null)
{
var sharedVertices = SharedVertices(superTriangle).ToList();
var otherVertices = vertices.Except(sharedVertices).ToList();
if (sharedVertices.Count == 1)
{
return(!new LineSegmentFr(p, sharedVertices.Single()).Intersects(new LineFr(otherVertices[0], otherVertices[1])));
}
if (sharedVertices.Count == 2)
{
return(!new LineSegmentFr(p, sharedVertices.First()).Intersects(new LineFr(new LineFr(sharedVertices[0], sharedVertices[1]).Slope, otherVertices[0])));
}
}
Fraction m1, m2;
Fraction mx1, mx2;
Fraction my1, my2;
Fraction xc, yc;
if ((p2.Y - p1.Y).Abs() == 0) // < double.Epsilon
{
m2 = -(p3.X - p2.X) / (p3.Y - p2.Y);
mx2 = (p2.X + p3.X) * 0.5;
my2 = (p2.Y + p3.Y) * 0.5; // Oblicz środek okręgu opisanego (xc, yc)
xc = (p2.X + p1.X) * 0.5;
yc = m2 * (xc - mx2) + my2;
}
else if ((p3.Y - p2.Y).Abs() == 0) // < double.Epsilon
{
m1 = -(p2.X - p1.X) / (p2.Y - p1.Y);
mx1 = (p1.X + p2.X) * 0.5;
my1 = (p1.Y + p2.Y) * 0.5;
xc = (p3.X + p2.X) * 0.5; // Oblicz środek okręgu opisanego (xc,yc)
yc = m1 * (xc - mx1) + my1;
}
else
{
m1 = -(p2.X - p1.X) / (p2.Y - p1.Y);
m2 = -(p3.X - p2.X) / (p3.Y - p2.Y);
mx1 = (p1.X + p2.X) * 0.5;
mx2 = (p2.X + p3.X) * 0.5;
my1 = (p1.Y + p2.Y) * 0.5;
my2 = (p2.Y + p3.Y) * 0.5;
xc = (m1 * mx1 - m2 * mx2 + my2 - my1) / (m1 - m2); // Oblicz środek okręgu opisanego (xc,yc)
yc = m1 * (xc - mx1) + my1;
}
var dx = p2.X - xc;
var dy = p2.Y - yc;
var rsqr = dx * dx + dy * dy; //double r = Math.Sqrt(rsqr); // Promień okręgu opisanego
dx = p.X - xc;
dy = p.Y - yc;
var drsqr = dx * dx + dy * dy;
return(drsqr <= rsqr);
}
public static double Angle(PointFr p1, PointFr p2, PointFr refp)
{
return(Math.Atan2((p1.Y - refp.Y).ToDouble(), (p1.X - refp.X).ToDouble()) - Math.Atan2((p2.Y - refp.Y).ToDouble(), (p2.X - refp.X).ToDouble()) * 180 / Math.PI);
}
public bool IsLeftOf(PointFr that)
{
return(_x < that.X);
}
public static Fraction AngleFr(PointFr p1, PointFr p2, PointFr refp)
{
return(Fraction.Atan2(p1.Y - refp.Y, p1.X - refp.X) - Fraction.Atan2(p2.Y - refp.Y, p2.X - refp.X) * 180 / Math.PI);
}
public bool IsRightOf(PointFr that)
{
return(_x > that.X);
}
