/// <summary> /// Puts the line segment into a normalized form. /// </summary> /// <remarks> /// This is useful for using line segments in maps and indexes when /// topological equality rather than exact equality is desired. /// <para> /// A segment in normalized form has the first point smaller than /// the second (according to the standard ordering on /// <see cref="Coordinate"/>). /// </para> /// </remarks> public override void Normalize() { if (p1.CompareTo(p0) < 0) { Reverse(); } }
public void TestCompareTo() { Coordinate lowest = new Coordinate(10.0, 100.0, 50.0); Coordinate highest = new Coordinate(20.0, 100.0, 50.0); Coordinate equalToHighest = new Coordinate(20.0, 100.0, 50.0); Coordinate higherStill = new Coordinate(20.0, 200.0, 50.0); Assert.AreEqual(-1, lowest.CompareTo(highest)); Assert.AreEqual(1, highest.CompareTo(lowest)); Assert.AreEqual(-1, highest.CompareTo(higherStill)); Assert.AreEqual(0, highest.CompareTo(equalToHighest)); }
/// <summary> /// Adds an edge between the coordinates orig and dest /// to this graph. /// </summary> /// <param name="orig">the edge origin location</param> /// <param name="dest">the edge destination location</param> /// <returns>the created edge</returns> public virtual HalfEdge AddEdge(Coordinate orig, Coordinate dest) { int cmp = dest.CompareTo(orig); // ignore zero-length edges if (cmp == 0) { return(null); } // Attempt to find the edge already in the graph. // Return it if found. // Otherwise, use a found edge with same origin (if any) to construct new edge. HalfEdge eAdj; bool eAdjFound = vertexMap.TryGetValue(orig, out eAdj); HalfEdge eSame = null; if (eAdjFound) { eSame = eAdj.Find(dest); } if (eSame != null) { return(eSame); } HalfEdge e = Insert(orig, dest, eAdj); return(e); }
/// <summary> /// Compares this object with the specified object for order. /// Uses the standard lexicographic ordering for the points in the LineSegment. /// </summary> /// <param name="o"> /// The <c>LineSegment</c> with which this <c>LineSegment</c> /// is being compared. /// </param> /// <returns> /// A negative integer, zero, or a positive integer as this <c>LineSegment</c> /// is less than, equal to, or greater than the specified <c>LineSegment</c>. /// </returns> public int CompareTo(object o) { var other = (LineSegment)o; var comp0 = _p0.CompareTo(other._p0); return(comp0 != 0 ? comp0 : _p1.CompareTo(other._p1)); }
/// <summary> /// Updates the tracked ringStartEdge /// if the given edge has a lower origin /// (using the standard <see cref="Coordinate"/> ordering). /// </summary> /// <remarks> /// Identifying the lowest starting node meets two goals: /// * It ensures that isolated input rings are created using the original node and orientation. /// * For isolated rings formed from multiple input linestrings, /// it provides a canonical node and orientation for the output /// (rather than essentially random, and thus hard to test). /// </remarks> /// <param name="e"></param> private void UpdateRingStartEdge(DissolveHalfEdge e) { if (!e.IsStart) { e = (DissolveHalfEdge)e.Sym; if (!e.IsStart) { return; } } // here e is known to be a start edge if (_ringStartEdge == null) { _ringStartEdge = e; return; } Coordinate eOrig = e.Orig; Coordinate rseOrig = _ringStartEdge.Orig; int compareTo = eOrig.CompareTo(rseOrig); if (compareTo < 0) { _ringStartEdge = e; } }
public void CompareTo_Returns_Correct_Comparison_For_All_Data(int x1, int y1, int x2, int y2, int result) { var coord1 = new Coordinate(x1, y1); var coord2 = new Coordinate(x2, y2); Assert.Equal(result, coord1.CompareTo(coord2)); }
public void CompareTo_Same_Assert() { Coordinate left = new Coordinate(10, 10); var result = left.CompareTo(left); Assert.AreEqual(0, result); }
public void CompareTo_Null_Assert() { Coordinate left = new Coordinate(30, 30); var result = left.CompareTo(null); Assert.AreEqual(1, result); }
public void CompareTo_LessThan_Assert() { Coordinate left = new Coordinate(10, 10); Coordinate right = new Coordinate(20, 20); var result = left.CompareTo(right); Assert.AreEqual(-1, result); }
public void CompareTo_GreaterThan_Assert() { Coordinate left = new Coordinate(30, 30); Coordinate right = new Coordinate(20, 20); var result = left.CompareTo(right); Assert.AreEqual(1, result); }
/// <summary> /// Compares this object with the specified object for order. /// Uses the standard lexicographic ordering for the points in the LineSegment. /// </summary> /// <param name="o">The LineSegment with which this LineSegment /// is being compared /// </param> /// <returns>A negative integer, zero, or a positive integer as this LineSegment /// is less than, equal to, or greater than the specified LineSegment /// </returns> public override int CompareTo(object o) { LineSegment other = (LineSegment)o; int comp0 = p0.CompareTo(other.p0); if (comp0 != 0) { return(comp0); } return(p1.CompareTo(other.p1)); }
/// <summary> /// Determines whether two <see cref="Coordinate" /> arrays of equal length /// are equal in opposite directions. /// </summary> /// <param name="pts1"></param> /// <param name="pts2"></param> /// <returns></returns> private static bool IsEqualReversed(Coordinate[] pts1, Coordinate[] pts2) { for (int i = 0; i < pts1.Length; i++) { Coordinate p1 = pts1[i]; Coordinate p2 = pts2[pts1.Length - i - 1]; if (p1.CompareTo(p2) != 0) { return(false); } } return(true); }
/// <summary> /// Returns the minimum coordinate, using the usual lexicographic comparison. /// </summary> /// <param name="coordinates">Array to search.</param> /// <returns>The minimum coordinate in the array, found using <c>CompareTo</c>.</returns> public static Coordinate MinCoordinate(Coordinate[] coordinates) { Coordinate minCoord = null; for (int i = 0; i < coordinates.Length; i++) { if (minCoord == null || minCoord.CompareTo(coordinates[i]) > 0) { minCoord = coordinates[i]; } } return(minCoord); }
public Segment(Coordinate p1, Coordinate p2) { if (p1.CompareTo(p2) > 0) { this.FromPt = p2; this.ToPt = p1; } else { this.FromPt = p1; this.ToPt = p2; } }
public int CompareTo(MatchedAddress other) { int c = -Score.CompareTo(other.Score); if (c == 0) { c = Address.CompareTo(other.Address); if (c == 0) { c = Location.CompareTo(other.Location); } } return(c); }
public void test_CompareTo() { //create a coordinate (the z value is not used so there is no need to create it) Coordinate coord = new Coordinate(testX, testY); //create an equal coordinate Coordinate coord2 = new Coordinate(1.0, 2.0); //create a coordinate where X is greater & Y is equal Coordinate coord3 = new Coordinate(2.0, 2.0); //create a coordinate where Y is greater & x is equal Coordinate coord4 = new Coordinate(1.0, 3.0); //create a coordinate where both X & Y are greater Coordinate coord5 = new Coordinate(2.0, 3.0); //create a coordinate where X is less & Y is equal Coordinate coord6 = new Coordinate(0.0, 2.0); //create a coordinate where Y is less & X is equal Coordinate coord7 = new Coordinate(1.0, 1.0); //create a coordinate where both are less Coordinate coord8 = new Coordinate(0.0, 0.0); //create a point to send to throw the exception _gf = new GeometryFactory(_pm, _srid); Point point = _gf.CreatePoint(coord); Assertion.AssertEquals("CompareTo1: ", 0, coord.CompareTo(coord2)); Assertion.AssertEquals("CompareTo2: ", -1, coord.CompareTo(coord3)); Assertion.AssertEquals("CompareTo3: ", -1, coord.CompareTo(coord4)); Assertion.AssertEquals("CompareTo4: ", -1, coord.CompareTo(coord5)); Assertion.AssertEquals("CompareTo5: ", 1, coord.CompareTo(coord6)); Assertion.AssertEquals("CompareTo6: ", 1, coord.CompareTo(coord7)); Assertion.AssertEquals("CompareTo7: ", 1, coord.CompareTo(coord8)); try { coord.CompareTo(point); Assertion.Fail("ArgumentException should have been thrown"); } catch (ArgumentException) { } }
public void CompareTo_InvalidType_Assert() { Coordinate left = new Coordinate(30, 30); var result = left.CompareTo(DateTime.Now); }
/// <summary> /// /// </summary> /// <param name="other"></param> /// <returns></returns> protected internal override int CompareToSameClass(object other) { Point point = (Point)other; return(Coordinate.CompareTo(point.Coordinate)); }
/// <summary> /// Tests whether the query rectangle intersects a given line segment. /// </summary> /// <param name="p0">The first endpoint of the segment</param> /// <param name="p1">The second endpoint of the segment</param> /// <returns><c>true</c> if the rectangle intersects the segment</returns> public bool Intersects(Coordinate p0, Coordinate p1) { // TODO: confirm that checking envelopes first is faster /** * If the segment envelope is disjoint from the * rectangle envelope, there is no intersection */ var segEnv = new Envelope(p0, p1); if (!_rectEnv.Intersects(segEnv)) { return(false); } /** * If either segment endpoint lies in the rectangle, * there is an intersection. */ if (_rectEnv.Intersects(p0)) { return(true); } if (_rectEnv.Intersects(p1)) { return(true); } /** * Normalize segment. * This makes p0 less than p1, * so that the segment runs to the right, * or vertically upwards. */ if (p0.CompareTo(p1) > 0) { var tmp = p0; p0 = p1; p1 = tmp; } /** * Compute angle of segment. * Since the segment is normalized to run left to right, * it is sufficient to simply test the Y ordinate. * "Upwards" means relative to the left end of the segment. */ bool isSegUpwards = p1.Y > p0.Y; /** * Since we now know that neither segment endpoint * lies in the rectangle, there are two possible * situations: * 1) the segment is disjoint to the rectangle * 2) the segment crosses the rectangle completely. * * In the case of a crossing, the segment must intersect * a diagonal of the rectangle. * * To distinguish these two cases, it is sufficient * to test intersection with * a single diagonal of the rectangle, * namely the one with slope "opposite" to the slope * of the segment. * (Note that if the segment is axis-parallel, * it must intersect both diagonals, so this is * still sufficient.) */ if (isSegUpwards) { _li.ComputeIntersection(p0, p1, _diagDown0, _diagDown1); } else { _li.ComputeIntersection(p0, p1, _diagUp0, _diagUp1); } if (_li.HasIntersection) { return(true); } return(false); }
public virtual bool within_y_axis(Coordinate y) { return(top_y_coordinate.CompareTo(y) >= 0); }
public virtual bool within_x_axis(Coordinate x) { return(top_x_coordinate.CompareTo(x) >= 0); }
/// <summary> /// Test if an the coordinates for an edge form a valid edge (with non-zero length) /// </summary> /// <param name="orig">The start coordinate</param> /// <param name="dest">The end coordinate</param> /// <returns><c>true</c> of the edge formed is valid</returns> public static bool IsValidEdge(Coordinate orig, Coordinate dest) { int cmp = dest.CompareTo(orig); return(cmp != 0); }
public int CompareTo(Robot other) => Coordinate.CompareTo(other.Coordinate);
/// <summary> /// Tests whether the query rectangle intersects a given line segment. /// </summary> /// <param name="p0">The first endpoint of the segment</param> /// <param name="p1">The second endpoint of the segment</param> /// <returns><c>true</c> if the rectangle intersects the segment</returns> public bool Intersects(Coordinate p0, Coordinate p1) { // TODO: confirm that checking envelopes first is faster /** * If the segment envelope is disjoint from the * rectangle envelope, there is no intersection */ var segEnv = new Envelope(p0, p1); if (!_rectEnv.Intersects(segEnv)) return false; /** * If either segment endpoint lies in the rectangle, * there is an intersection. */ if (_rectEnv.Intersects(p0)) return true; if (_rectEnv.Intersects(p1)) return true; /** * Normalize segment. * This makes p0 less than p1, * so that the segment runs to the right, * or vertically upwards. */ if (p0.CompareTo(p1) > 0) { var tmp = p0; p0 = p1; p1 = tmp; } /** * Compute angle of segment. * Since the segment is normalized to run left to right, * it is sufficient to simply test the Y ordinate. * "Upwards" means relative to the left end of the segment. */ var isSegUpwards = p1.Y > p0.Y; /** * Since we now know that neither segment endpoint * lies in the rectangle, there are two possible * situations: * 1) the segment is disjoint to the rectangle * 2) the segment crosses the rectangle completely. * * In the case of a crossing, the segment must intersect * a diagonal of the rectangle. * * To distinguish these two cases, it is sufficient * to test intersection with * a single diagonal of the rectangle, * namely the one with slope "opposite" to the slope * of the segment. * (Note that if the segment is axis-parallel, * it must intersect both diagonals, so this is * still sufficient.) */ if (isSegUpwards) { _li.ComputeIntersection(p0, p1, _diagDown0, _diagDown1); } else { _li.ComputeIntersection(p0, p1, _diagUp0, _diagUp1); } if (_li.HasIntersection) return true; return false; }