//
// Creates a flying shape using a CROSSING intersection
// offCross
// |
// ______|______ <--crossingInter
// |
// _____|_____ <--standsInter
//
// Returns <offCross>
//
public Point CreatesFlyingShapeWithCrossing(Intersection thatInter)
{
// A valid transversal is required for this shape
if (!this.CreatesAValidTransversalWith(thatInter))
{
return(null);
}
// We hould not have have endpoint standing as that is handled elsewhere
if (this.StandsOnEndpoint() || thatInter.StandsOnEndpoint())
{
return(null);
}
//
// Determine which is the crossing intersection and which stands on the endpoints
//
Intersection crossingInter = null;
Intersection standsInter = null;
if (this.Crossing() && thatInter.StandsOn())
{
crossingInter = this;
standsInter = thatInter;
}
else if (thatInter.Crossing() && this.StandsOn())
{
crossingInter = thatInter;
standsInter = this;
}
else
{
return(null);
}
Segment transversal = this.AcquireTransversal(thatInter);
// Stands on intersection must have BOTH points not on the transversal line
// |
// ______|______
// |
// |_____
// |
// |
if (!transversal.PointLiesOn(standsInter.CreatesTShape()))
{
return(null);
}
// Success, we have the desired shape
// Acquire return point: offCross
Segment transversalCrossing = crossingInter.GetCollinearSegment(transversal);
return(Segment.Between(crossingInter.intersect, transversalCrossing.Point1, standsInter.intersect) ?
transversalCrossing.Point1 : transversalCrossing.Point2);
}
public Point OtherPoint(Segment seg)
{
if (seg.HasPoint(A) && seg.HasPoint(B))
{
return(C);
}
if (seg.HasPoint(A) && seg.HasPoint(C))
{
return(B);
}
if (seg.HasPoint(B) && seg.HasPoint(C))
{
return(A);
}
if (seg.PointLiesOn(A) && seg.PointLiesOn(B))
{
return(C);
}
if (seg.PointLiesOn(A) && seg.PointLiesOn(C))
{
return(B);
}
if (seg.PointLiesOn(B) && seg.PointLiesOn(C))
{
return(A);
}
return(null);
}
//
// Creates a shape like an extended t
// offCross offCross
// | |
// _____|____ ______|______
// | |
// |_____ offStands offStands _____|
//
// Returns <offStands, offCross>
public KeyValuePair <Point, Point> CreatesCrossedTShape(Intersection thatInter)
{
KeyValuePair <Point, Point> nullPair = new KeyValuePair <Point, Point>(null, null);
// A valid transversal is required for this shape
if (!this.CreatesAValidTransversalWith(thatInter))
{
return(nullPair);
}
//
// Determine which is the crossing intersection and which stands on the endpoints
//
Intersection crossingInter = null;
Intersection standsInter = null;
if (this.Crossing() && thatInter.StandsOnEndpoint())
{
crossingInter = this;
standsInter = thatInter;
}
else if (thatInter.Crossing() && this.StandsOnEndpoint())
{
crossingInter = thatInter;
standsInter = this;
}
else
{
return(nullPair);
}
//
// Acquire the returning points
//
Segment transversal = this.AcquireTransversal(thatInter);
Segment parallelStands = standsInter.OtherSegment(transversal);
Point offStands = transversal.PointLiesOn(parallelStands.Point1) ? parallelStands.Point2 : parallelStands.Point1;
Segment transversalCross = crossingInter.GetCollinearSegment(transversal);
Point offCross = Segment.Between(crossingInter.intersect, transversalCross.Point1, standsInter.intersect) ? transversalCross.Point1 : transversalCross.Point2;
return(new KeyValuePair <Point, Point>(offStands, offCross));
}
private void Verify()
{
if (points.Count < 2)
{
throw new ArgumentException("A Collinear relationship requires at least 2 points: " + this.ToString());
}
// Create a segment of the endpoints to compare all points for collinearity
Segment line = new Segment(points[0], points[points.Count - 1]);
foreach (Point pt in points)
{
if (!line.PointLiesOn(pt))
{
throw new ArgumentException("Point " + pt + " is not collinear with line " + line.ToString());
}
if (!line.PointLiesOnAndBetweenEndpoints(pt))
{
throw new ArgumentException("Point " + pt + " is not between the endpoints of segment " + line.ToString());
}
}
}
//
// PointA
// |
// | X (pt)
// |_____________________ otherSegment
// |
// |
// PointB
//
public Point SameSidePoint(Segment otherSegment, Point pt)
{
// Is the given point on other? If so, we cannot make a determination.
if (otherSegment.PointLiesOn(pt))
{
return(null);
}
// Make a vector out of this vector as well as the vector connecting one of the points to the given pt
Vector thisVector = new Vector(Point1, Point2);
Vector thatVector = new Vector(Point1, pt);
Vector projectionOfOtherOntoThis = thisVector.Projection(thatVector);
// We are interested most in the endpoint of the projection (which is not the
Point projectedEndpoint = projectionOfOtherOntoThis.NonOriginEndpoint();
// Find the intersection between the two lines
Point intersection = FindIntersection(otherSegment);
if (this.PointLiesOn(projectedEndpoint))
{
System.Diagnostics.Debug.WriteLine("Unexpected: Projection does not lie on this line. " + this + " " + projectedEndpoint);
}
// The endpoint of the projection is on this vector. Therefore, we can judge which side of the given segment the given pt lies on.
if (Segment.Between(projectedEndpoint, Point1, intersection))
{
return(Point1);
}
if (Segment.Between(projectedEndpoint, Point2, intersection))
{
return(Point2);
}
return(null);
}
//
// Determine tangency of the given segment.
// Indicate tangency by returning the segment which creates the 90^0 angle.
//
public Segment IsTangent(Segment segment)
{
// If the center and the segment points are collinear, this will not be a tangent.
if (segment.PointLiesOn(this.center)) return null;
// Acquire the line perpendicular to the segment that passes through the center of the circle.
Segment perpendicular = segment.GetPerpendicular(this.center);
// If the segment was found to pass through the center, it is not a tangent
if (perpendicular.Equals(segment)) return null;
// Is this perpendicular segment a radius? Check length
//if (!Utilities.CompareValues(perpendicular.Length, this.radius)) return null;
// Is the perpendicular a radius? Check that the intersection of the segment and the perpendicular is on the circle
Point intersection = segment.FindIntersection(perpendicular);
if (!this.PointLiesOn(intersection)) return null;
// The intersection between the perpendicular and the segment must be within the endpoints of the segment.
return segment.PointLiesOnAndBetweenEndpoints(intersection) ? perpendicular : null;
}
//
// PointA
// |
// | X (pt)
// |_____________________ otherSegment
// |
// |
// PointB
//
public Point SameSidePoint(Segment otherSegment, Point pt)
{
// Is the given point on other? If so, we cannot make a determination.
if (otherSegment.PointLiesOn(pt)) return null;
// Make a vector out of this vector as well as the vector connecting one of the points to the given pt
Vector thisVector = new Vector(Point1, Point2);
Vector thatVector = new Vector(Point1, pt);
Vector projectionOfOtherOntoThis = thisVector.Projection(thatVector);
// We are interested most in the endpoint of the projection (which is not the
Point projectedEndpoint = projectionOfOtherOntoThis.NonOriginEndpoint();
// Find the intersection between the two lines
Point intersection = FindIntersection(otherSegment);
if (this.PointLiesOn(projectedEndpoint))
{
System.Diagnostics.Debug.WriteLine("Unexpected: Projection does not lie on this line. " + this + " " + projectedEndpoint);
}
// The endpoint of the projection is on this vector. Therefore, we can judge which side of the given segment the given pt lies on.
if (Segment.Between(projectedEndpoint, Point1, intersection)) return Point1;
if (Segment.Between(projectedEndpoint, Point2, intersection)) return Point2;
return null;
}
public Point OtherPoint(Segment seg)
{
if (seg.HasPoint(A) && seg.HasPoint(B)) return C;
if (seg.HasPoint(A) && seg.HasPoint(C)) return B;
if (seg.HasPoint(B) && seg.HasPoint(C)) return A;
if (seg.PointLiesOn(A) && seg.PointLiesOn(B)) return C;
if (seg.PointLiesOn(A) && seg.PointLiesOn(C)) return B;
if (seg.PointLiesOn(B) && seg.PointLiesOn(C)) return A;
return null;
}
//
// Creates a Chair
//
// | | |
// |_____|____ leftInter |_________ tipOfT
// | | |
// | | |
// off tipOfT
//
// bottomInter
//
// <leftInter, bottomInter>
// Returns the legs of the chair in specific ordering: <off, bottomTip>
public KeyValuePair <Point, Point> CreatesChairShape(Intersection thatInter)
{
KeyValuePair <Point, Point> nullPair = new KeyValuePair <Point, Point>(null, null);
// A valid transversal is required for this shape
if (!this.CreatesAValidTransversalWith(thatInter))
{
return(nullPair);
}
// Both intersections must be standing on (and not endpoints)
if (!this.StandsOn() || !thatInter.StandsOn())
{
return(nullPair);
}
if (this.StandsOnEndpoint() || thatInter.StandsOnEndpoint())
{
return(nullPair);
}
Point thisTipOfT = this.CreatesTShape();
Point thatTipOfT = thatInter.CreatesTShape();
Segment transversal = this.AcquireTransversal(thatInter);
Intersection leftInter = null;
Intersection bottomInter = null;
// Avoid:
// |
// |______
// | |
// | |
// this is leftInter
Point bottomTip = null;
if (transversal.PointLiesOn(thisTipOfT))
{
if (transversal.PointLiesOnAndBetweenEndpoints(thisTipOfT))
{
return(nullPair);
}
leftInter = this;
bottomInter = thatInter;
bottomTip = thisTipOfT;
}
// thatInter is leftInter
else if (transversal.PointLiesOn(thatTipOfT))
{
if (transversal.PointLiesOnAndBetweenEndpoints(thatTipOfT))
{
return(nullPair);
}
leftInter = thatInter;
bottomInter = this;
bottomTip = thisTipOfT;
}
// Otherwise, this indicates a PI-shaped scenario
else
{
return(nullPair);
}
//
// Returns the bottom of the legs of the chair
//
Segment parallelLeft = leftInter.OtherSegment(transversal);
Segment crossingTester = new Segment(parallelLeft.Point1, bottomTip);
Point intersection = transversal.FindIntersection(crossingTester);
Point off = transversal.PointLiesOnAndBetweenEndpoints(intersection) ? parallelLeft.Point2 : parallelLeft.Point1;
return(new KeyValuePair <Point, Point>(off, bottomTip));
}
//
// Creates an F-Shape
// top
// _____ offEnd <--- Stands on Endpt
// |
// |_____ offStands <--- Stands on
// |
// |
// bottom
// Order of non-collinear points is order of intersections: <this, that>
public KeyValuePair <Point, Point> CreatesFShape(Intersection thatInter)
{
KeyValuePair <Point, Point> nullPair = new KeyValuePair <Point, Point>(null, null);
// A valid transversal is required for this shape
if (!this.CreatesAValidTransversalWith(thatInter))
{
return(nullPair);
}
// Avoid both standing on an endpoint
if (this.StandsOnEndpoint() && thatInter.StandsOnEndpoint())
{
return(nullPair);
}
Intersection endpt = null;
Intersection standsOn = null;
if (this.StandsOnEndpoint() && thatInter.StandsOn())
{
endpt = this;
standsOn = thatInter;
}
else if (thatInter.StandsOnEndpoint() && this.StandsOn())
{
endpt = thatInter;
standsOn = this;
}
else
{
return(nullPair);
}
Segment transversal = this.AcquireTransversal(thatInter);
Segment transversalStands = standsOn.GetCollinearSegment(transversal);
//
// Determine Top and bottom to avoid PI shape
//
Point top = null;
Point bottom = null;
if (Segment.Between(standsOn.intersect, transversalStands.Point1, endpt.intersect))
{
bottom = transversalStands.Point1;
top = transversalStands.Point2;
}
else
{
bottom = transversalStands.Point2;
top = transversalStands.Point1;
}
// Avoid: ____ Although this shouldn't happen since both intersections do not stand on endpoints
// ____|
if (transversal.HasPoint(top) && transversal.HasPoint(bottom))
{
return(nullPair);
}
// Also avoid Simple PI-Shape
//
if (!transversal.HasPoint(top) && !transversal.HasPoint(bottom))
{
return(nullPair);
}
// Find the two points that make the points of the F
Segment parallelEndPt = endpt.OtherSegment(transversal);
Segment parallelStands = standsOn.OtherSegment(transversal);
Point offEnd = transversal.PointLiesOn(parallelEndPt.Point1) ? parallelEndPt.Point2 : parallelEndPt.Point1;
Point offStands = transversal.PointLiesOn(parallelStands.Point1) ? parallelStands.Point2 : parallelStands.Point1;
// Check this is not a crazy F
// _____
// |
// ____|
// |
// |
Point intersection = transversal.FindIntersection(new Segment(offEnd, offStands));
if (transversal.PointLiesOnAndBetweenEndpoints(intersection))
{
return(nullPair);
}
// Return in the order of 'off' points: <this, that>
return(this.Equals(endpt) ? new KeyValuePair <Point, Point>(offEnd, offStands) : new KeyValuePair <Point, Point>(offStands, offEnd));
}
private void Verify()
{
if (points.Count < 2) throw new ArgumentException("A Collinear relationship requires at least 2 points: " + this.ToString());
// Create a segment of the endpoints to compare all points for collinearity
Segment line = new Segment(points[0], points[points.Count - 1]);
foreach (Point pt in points)
{
if (!line.PointLiesOn(pt))
{
throw new ArgumentException("Point " + pt + " is not collinear with line " + line.ToString());
}
if (!line.PointLiesOnAndBetweenEndpoints(pt))
{
throw new ArgumentException("Point " + pt + " is not between the endpoints of segment " + line.ToString());
}
}
}