public Square square_at(Coordinate coordinate) { return contains_token_at(coordinate) ? (Square) new PlayingSquare(_squares[coordinate.X, coordinate.Y]) : new EmptyPlayingSquare(); }
public Coordinate Reproject(Coordinate coordinate, ISpatialReference @from, ISpatialReference to) { double[] xy, z; ToDotSpatial(coordinate, out xy, out z); DotSpatial.Projections.Reproject.ReprojectPoints(xy, z, GetProjectionInfo(@from), GetProjectionInfo(to), 0, 1); return ToGeoAPI(xy, z); }
/// <summary> /// Normalizes the vector <param name="v"></param> /// </summary> /// <param name="v">The normalized <paramref name="v"/></param> public static void Normalize(Coordinate v) { double absVal = Math.Sqrt(v.X * v.X + v.Y * v.Y + v.Z * v.Z); v.X /= absVal; v.Y /= absVal; v.Z /= absVal; }
/// <summary> /// /// </summary> /// <param name="p"></param> /// <param name="ring"></param> /// <returns></returns> public static bool IsPointInRing(Coordinate p, Coordinate[] ring) { int i; // point index; i1 = i-1 mod n int crossings = 0; // number of edge/ray crossings int nPts = ring.Length; /* For each line edge l = (i-1, i), see if it crosses ray from test point in positive x direction. */ for (i = 1; i < nPts; i++) { int i1 = i - 1; // point index; i1 = i-1 mod n Coordinate p1 = ring[i]; Coordinate p2 = ring[i1]; double x1 = p1.X - p.X; double y1 = p1.Y - p.Y; double x2 = p2.X - p.X; double y2 = p2.Y - p.Y; if (((y1 > 0) && (y2 <= 0)) || ((y2 > 0) && (y1 <= 0))) { /* e straddles x axis, so compute intersection. */ double xInt = (x1 * y2 - x2 * y1) / (y2 - y1); // x intersection of e with ray /* crosses ray if strictly positive intersection. */ if (0.0 < xInt) crossings++; } } /* p is inside if an odd number of crossings. */ return (crossings % 2) == 1; }
public void Multipg() { Random rnd = new Random(); Polygon[] pg = new Polygon[50]; GeoAPI.Geometries.IPolygon[] pgcheck = new GeoAPI.Geometries.IPolygon[50]; GisSharpBlog.NetTopologySuite.Geometries.GeometryFactory gf = new GisSharpBlog.NetTopologySuite.Geometries.GeometryFactory(); for (int i = 0; i < 50; i++) { Coordinate center = new Coordinate((rnd.NextDouble() * 360) - 180, (rnd.NextDouble() * 180) - 90); Coordinate[] coord = new Coordinate[36]; GeoAPI.Geometries.ICoordinate[] coordscheck = new GeoAPI.Geometries.ICoordinate[36]; for (int ii = 0; ii < 36; ii++) { coord[ii] = new Coordinate(center.X + Math.Cos((ii * 10) * Math.PI / 10), center.Y + (ii * 10) * Math.PI / 10); double x = coord[ii].X; double y = coord[ii].Y; GisSharpBlog.NetTopologySuite.Geometries.Coordinate c = new GisSharpBlog.NetTopologySuite.Geometries.Coordinate(x, y); coordscheck[ii] = c; } coord[35] = new Coordinate(coord[0].X, coord[0].Y); coordscheck[35] = new GisSharpBlog.NetTopologySuite.Geometries.Coordinate(coordscheck[0].X, coordscheck[0].Y); GeoAPI.Geometries.ILinearRing ring = gf.CreateLinearRing(coordscheck); pgcheck[i] = gf.CreatePolygon(ring, null); pg[i] = new Polygon(coord); } MultiPolygon mpg = new MultiPolygon(pg); GeoAPI.Geometries.IMultiPolygon mpgcheck = gf.CreateMultiPolygon(pgcheck); for (int ii = 0; ii < mpg.Coordinates.Count; ii++) { Assert.AreEqual(mpg.Coordinates[ii].X, mpgcheck.Coordinates[ii].X); Assert.AreEqual(mpg.Coordinates[ii].Y, mpgcheck.Coordinates[ii].Y); } }
private static string PointInformation() { StringBuilder text = new StringBuilder(); Window window = Window.GetWindowAtCursor(); Coordinate pt = new Coordinate(CoordinateType.Absolute, new WindowEntity.Point() { X = Cursor.Position.X, Y = Cursor.Position.Y }); Color color = Desktop.Primary.GetPixelColor(pt); if(window != null) { WindowEntity.Point rel = pt.ToRelative(window); StretchedPoint st = pt.ToStretched(window); text.Append("<b>Window</b>: "); text.AppendFormat("[{0}, {1}] ", window.Width, window.Height); text.AppendFormat("\"{0}\"", window.Title); text.AppendLine(); text.Append("<br><b>Color</b>: "); text.AppendLine(color.ToString()); text.Append("<br><b>Coordinate</b>: Absolute: "); text.AppendFormat("X = {0}, Y = {1}", pt.X, pt.Y); text.Append("; Relative: "); text.AppendFormat("X = {0}, Y = {1}", rel.X, rel.Y); text.Append("; Stretched: "); text.AppendFormat(CultureInfo.InvariantCulture, "X = {0}, Y = {1}", st.X, st.Y); } else { text.Append("<b>Color</b>: "); text.AppendLine(color.ToString()); text.Append("<br><b>Coordinate</b>: Absolute: "); text.AppendFormat("{0}, {1}", pt.X, pt.Y); } return text.ToString(); }
/// <summary> /// Creates a new instance of a vector where the X, Y and Z terms are the same as the /// specified coordinate. /// </summary> /// <param name="coord">The ICoordinate to use</param> public Vector(Coordinate coord) { X = coord.X; Y = coord.Y; Z = coord.Z; RemoveNan(); }
private void TestWriteZMValuesShapeFile(bool testM) { var points = new Coordinate[3]; points[0] = new Coordinate(0, 0); points[1] = new Coordinate(1, 0); points[2] = new Coordinate(1, 1); var csFactory = DotSpatialAffineCoordinateSequenceFactory.Instance; var sequence = csFactory.Create(3, Ordinates.XYZM); for (var i = 0; i < 3; i++) { sequence.SetOrdinate(i, Ordinate.X, points[i].X); sequence.SetOrdinate(i, Ordinate.Y, points[i].Y); sequence.SetOrdinate(i, Ordinate.Z, 1 + i); if (testM) sequence.SetOrdinate(i, Ordinate.M, 11 + i); } var lineString = Factory.CreateLineString(sequence); var attributes = new AttributesTable(); attributes.AddAttribute("FOO", "Trond"); var feature = new Feature(Factory.CreateMultiLineString(new[] { lineString }), attributes); var features = new Feature[1]; features[0] = feature; var shpWriter = new ShapefileDataWriter("ZMtest", Factory) { Header = ShapefileDataWriter.GetHeader(features[0], features.Length) }; shpWriter.Write(features); // Now let's read the file and verify that we got Z and M back var factory = new GeometryFactory(DotSpatialAffineCoordinateSequenceFactory.Instance); using (var reader = new ShapefileDataReader("ZMtest", factory)) { reader.Read(); var geom = reader.Geometry; for (var i = 0; i < 3; i++) { var c = geom.Coordinates[i]; Assert.AreEqual(i + 1, c.Z); } if (testM) { sequence = ((ILineString)geom).CoordinateSequence; for (var i = 0; i < 3; i++) { Assert.AreEqual(sequence.GetOrdinate(i, Ordinate.M), 11 + i); } } // Run a simple attribute test too var v = reader.GetString(0); Assert.AreEqual(v, "Trond"); } }
/// <summary> /// Finds number of players for each team at a coordinate at rolls to find a winner /// /// </summary> public void RollForEngagement(Coordinate coordinate, Match match) { List<Player> homePlayersAtCoordinate = new List<Player>(); List<Player> awayPlayerAtCoordinate = new List<Player>(); foreach (Player somePlayer in match.GetPlayersAtCoordinate(coordinate, match)) { if (somePlayer.Team.TeamName == match.HomeTeam.TeamName) { homePlayersAtCoordinate.Add(somePlayer); } else { awayPlayerAtCoordinate.Add(somePlayer); } } Console.WriteLine(match.HomeTeam.TeamName + " has " + homePlayersAtCoordinate.Count + " players at coordinate 2,2"); Console.WriteLine(match.AwayTeam.TeamName + " has " + awayPlayerAtCoordinate.Count + " players at coordinate 2,2"); //roll for greek players at coordinate Random rnd = new Random(); int rollHome = rnd.Next(1, 7); int rollAway = rnd.Next(1, 7); Console.WriteLine(match.HomeTeam.TeamName + " rolls " + rollHome); Console.WriteLine(match.AwayTeam.TeamName + " rolls " + rollAway); //+2 til roll pr. player at coordinate. int modifiedGreekRoll = rollHome + homePlayersAtCoordinate.Count * 2; int modifiedOlsenRoll = rollAway + awayPlayerAtCoordinate.Count * 2; Console.WriteLine("greek modified roll is" + modifiedGreekRoll); Console.WriteLine("Olsen modified roll is" + modifiedOlsenRoll); ResultOfEngagement engagementResult = FindWinner(match, modifiedGreekRoll, modifiedOlsenRoll); var downedPlayer = new Player(); //add effect (down player, equals half a player next round and can't move. if (engagementResult != ResultOfEngagement.Tie) { downedPlayer = EffectOfEngangement(engagementResult, homePlayersAtCoordinate, awayPlayerAtCoordinate); } else { Console.WriteLine("Its was a tie, no player downed"); } if (downedPlayer != null) { if (match.MatchBall.PlayerWithBall == downedPlayer) { //give player to another player at that coordinate } Console.WriteLine(downedPlayer.Name + " " + downedPlayer.State); } Console.WriteLine(engagementResult.ToString()); }
public Build(BlockTemplate BlockType, Coordinate Location) : base(Location) { this.BlockType = BlockType; MarkerTile = TileNames.TaskIconBlank; GnomeIcon = TileNames.TaskIconBuild; }
public Pixel(Coordinate position, int r, int g, int b) : this(position) { this.R = r; this.G = g; this.B = b; }
/// <summary> /// /// </summary> /// <param name="pts1"></param> /// <param name="orientation1"></param> /// <param name="pts2"></param> /// <param name="orientation2"></param> /// <returns></returns> private static int CompareOriented(Coordinate[] pts1, bool orientation1, Coordinate[] pts2, bool orientation2) { int dir1 = orientation1 ? 1 : -1; int dir2 = orientation2 ? 1 : -1; int limit1 = orientation1 ? pts1.Length : -1; int limit2 = orientation2 ? pts2.Length : -1; int i1 = orientation1 ? 0 : pts1.Length - 1; int i2 = orientation2 ? 0 : pts2.Length - 1; while (true) { int compPt = pts1[i1].CompareTo(pts2[i2]); if (compPt != 0) return compPt; i1 += dir1; i2 += dir2; bool done1 = i1 == limit1; bool done2 = i2 == limit2; if(done1 && !done2) return -1; if(!done1 && done2) return 1; if(done1 && done2) return 0; } }
/// <summary> /// Adds a point to the current line. /// </summary> /// <param name="pt">The <see cref="Coordinate" /> to add.</param> /// <param name="allowRepeatedPoints">If <c>true</c>, allows the insertions of repeated points.</param> public void Add(Coordinate pt, bool allowRepeatedPoints) { if (_coordList == null) _coordList = new CoordinateList(); _coordList.Add(pt, allowRepeatedPoints); _lastPt = pt; }
public bool is_square_at(Coordinate coordinate) { if (coordinate.Y > 2 || coordinate.X > 2) return false; else return true; }
/// <summary> /// Initializes the NMEA Geographic position, Latitude and Longitude and parses an NMEA sentence /// </summary> /// <param name="NMEAsentence"></param> public GPGLL(string NMEAsentence) { try { //Split into an array of strings. string[] split = NMEAsentence.Split(new Char[] { ',' }); try { _position = new Coordinate(GPSHandler.GPSToDecimalDegrees(split[3], split[4]), GPSHandler.GPSToDecimalDegrees(split[1], split[2])); } catch { _position = null; } try { _timeOfSolution = new TimeSpan(int.Parse(split[5].Substring(0, 2)), int.Parse(split[5].Substring(2, 2)), int.Parse(split[5].Substring(4))); } catch { _timeOfSolution = null; // TimeSpan.Zero; } _dataValid = (split[6] == "A"); } catch { } }
public TundraTile(Coordinate position) { _painter = new TundraTilePainter(); _name = MainStrings.TundraTileName; _properties = new TileProperties(0, 30, position, -20); _effects = new TilePropertiesForEffects(); }
/// <summary> /// Creates an AffineTransformation defined by a single control vector. A /// control vector consists of a source point and a destination point, which is /// the image of the source point under the desired transformation. This /// produces a translation. /// </summary> /// <param name="src0">The start point of the control vector</param> /// <param name="dest0">The end point of the control vector</param> /// <returns>The computed transformation</returns> public static AffineTransformation CreateFromControlVectors(Coordinate src0, Coordinate dest0) { double dx = dest0.X - src0.X; double dy = dest0.Y - src0.Y; return AffineTransformation.TranslationInstance(dx, dy); }
/// <summary> /// Computes the "edge distance" of an intersection point p along a segment. /// The edge distance is a metric of the point along the edge. /// The metric used is a robust and easy to compute metric function. /// It is not equivalent to the usual Euclidean metric. /// It relies on the fact that either the x or the y ordinates of the /// points in the edge are unique, depending on whether the edge is longer in /// the horizontal or vertical direction. /// NOTE: This function may produce incorrect distances /// for inputs where p is not precisely on p1-p2 /// (E.g. p = (139,9) p1 = (139,10), p2 = (280,1) produces distanct 0.0, which is incorrect. /// My hypothesis is that the function is safe to use for points which are the /// result of rounding points which lie on the line, but not safe to use for truncated points. /// </summary> public static double ComputeEdgeDistance(Coordinate p, Coordinate p0, Coordinate p1) { var dx = Math.Abs(p1.X - p0.X); var dy = Math.Abs(p1.Y - p0.Y); var dist = -1.0; // sentinel value if (p.Equals(p0)) dist = 0.0; else if (p.Equals(p1)) { dist = dx > dy ? dx : dy; } else { double pdx = Math.Abs(p.X - p0.X); double pdy = Math.Abs(p.Y - p0.Y); dist = dx > dy ? pdx : pdy; // <FIX>: hack to ensure that non-endpoints always have a non-zero distance if (dist == 0.0 && ! p.Equals2D(p0)) dist = Math.Max(pdx, pdy); } Assert.IsTrue(!(dist == 0.0 && ! p.Equals(p0)), "Bad distance calculation"); return dist; }
/// <summary> /// Creates a specified number of random point features inside a single polygon feature. /// </summary> /// <param name="ConstrainingFeature">Random points will be generated inside this polygon feature.</param> /// <param name="NumberOfPoints">The number of points to be randomly generated.</param> /// <returns>A point feature set with the randomly created features.</returns> public static FeatureSet RandomPoints(Feature ConstrainingFeature, int NumberOfPoints) { //This function generates random points within the boundaries of one polygon feature FeatureSet fsOut = new FeatureSet(); fsOut.FeatureType = FeatureType.Point; Coordinate c = new Coordinate(); Random r = new Random(); int i = 0; while (i < NumberOfPoints) { c = new Coordinate(); //make a random point somewhere in the rectangular extents of the feature double rndx = r.Next(0, 100000) / 100000.0; double rndy = r.Next(0, 100000) / 100000.0; c.X = rndx * (ConstrainingFeature.Envelope.Right() - ConstrainingFeature.Envelope.Left()) + ConstrainingFeature.Envelope.Left(); c.Y = rndy * (ConstrainingFeature.Envelope.Top() - ConstrainingFeature.Envelope.Bottom()) + ConstrainingFeature.Envelope.Bottom(); //check if the point falls within the polygon featureset if (ConstrainingFeature.Intersects(c)) { fsOut.AddFeature(new Feature(c)); i++; } } return fsOut; }
public static Coordinate PointNotInList(Coordinate[] testPts, Coordinate[] pts) { foreach (Coordinate testPt in testPts) if (!IsInList(testPt, pts)) return testPt; return null; }
public void addSinglePieceToClusterCorrectLiberties() { //arrange GoBoard testgame = new GoBoard(5); Coordinate loc = new Coordinate(3, 3); testgame.addPiece(loc, Space.Black); PieceCluster simpleCluster = new PieceCluster(loc, Space.Black, testgame); Coordinate loc2 = new Coordinate(4, 2); testgame.addPiece(loc2, Space.White); Coordinate loc3 = new Coordinate(4, 3); testgame.addPiece(loc3, Space.Black); simpleCluster.piecesAdd(loc3); simpleCluster.removeLiberty(loc3); simpleCluster.addLibertiesOf(loc3); int expected = 5; //act int actual = simpleCluster.Liberties.Count; //assert Assert.AreEqual(expected, actual); }
public RemoveBlockMutation(Coordinate Location, Gnome Gnome) { this.MutationTimeFrame = MutationTimeFrame.BeforeUpdatingConnectivity; this.Location = Location; this.Gnome = Gnome; }
public void Multils() { Random rnd = new Random(); LineString[] ls = new LineString[40]; GeoAPI.Geometries.ILineString[] lscheck = new GeoAPI.Geometries.ILineString[40]; GisSharpBlog.NetTopologySuite.Geometries.GeometryFactory gf = new GisSharpBlog.NetTopologySuite.Geometries.GeometryFactory(); for (int ii = 0; ii < 40; ii++) { Coordinate[] coord = new Coordinate[36]; GeoAPI.Geometries.ICoordinate[] coordcheck = new GeoAPI.Geometries.ICoordinate[36]; for (int i = 0; i < 36; i++) { coord[i] = new Coordinate((rnd.NextDouble() * 360) - 180, (rnd.NextDouble() * 180) - 90); double x = coord[i].X; double y = coord[i].Y; GisSharpBlog.NetTopologySuite.Geometries.Coordinate c = new GisSharpBlog.NetTopologySuite.Geometries.Coordinate(x, y); coordcheck[i] = c; } ls[ii] = new LineString(coord); lscheck[ii] = gf.CreateLineString(coordcheck); } MultiLineString mls = new MultiLineString(ls); GeoAPI.Geometries.IMultiLineString mlscheck = gf.CreateMultiLineString(lscheck); for (int ii = 0; ii < mls.Coordinates.Count; ii++) { Assert.AreEqual(mls.Coordinates[ii].X, mlscheck.Coordinates[ii].X); Assert.AreEqual(mls.Coordinates[ii].Y, mlscheck.Coordinates[ii].Y); } Assert.AreEqual(mls.NumGeometries, mlscheck.NumGeometries); }
/// <summary> /// Determines whether two lines or line segments intersects /// </summary> /// <param name="a1">The first point of the first line</param> /// <param name="b1">The second point of the first line</param> /// <param name="line1Mode">LineMode value that specifies whether A1B1 should be treated as infinite line or as line segment</param> /// <param name="a2">The first point of the second line</param> /// <param name="b2">The second point of the second line</param> /// <param name="line2Mode">LineMode value that specifies whether A2B2 should be treated as infinite line or as line segment</param> /// <returns>true if A1B1 intersects A2B2, otherwise returns false</returns> public bool Intersects(Coordinate a1, Coordinate b1, LineMode line1Mode, Coordinate a2, Coordinate b2, LineMode line2Mode) { double paramA1 = b1.Y - a1.Y; double paramB1 = a1.X - b1.X; double paramC1 = paramA1 * a1.X + paramB1 * a1.Y; double paramA2 = b2.Y - a2.Y; double paramB2 = a2.X - b2.X; double paramC2 = paramA2 * a2.X + paramB2 * a2.Y; double det = paramA1 * paramB2 - paramA2 * paramB1; if (det == 0) { return false; } else { double x = (paramB2 * paramC1 - paramB1 * paramC2) / det; double y = (paramA1 * paramC2 - paramA2 * paramC1) / det; if (line1Mode == LineMode.LineSegment) { if (x < Math.Min(a1.X, b1.X) || x > Math.Max(a1.X, b1.X) || y < Math.Min(a1.Y, b1.Y) || y > Math.Max(a1.Y, b1.Y)) { return false; } } if (line2Mode == LineMode.LineSegment) { if (x < Math.Min(a2.X, b2.X) || x > Math.Max(a2.X, b2.X) || y < Math.Min(a2.Y, b2.Y) || y > Math.Max(a2.Y, b2.Y)) { return false; } } return true; } }
/// <summary> /// Creates a new instance of TextSymbolizer /// </summary> public LabelSymbolizer() { Angle = 0; UseAngle = false; LabelAngleField = null; UseLabelAngleField = false; BorderVisible = false; BorderColor = Color.Black; BackColor = Color.AntiqueWhite; BackColorEnabled = false; DropShadowColor = Color.FromArgb(20, 0, 0, 0); DropShadowEnabled = false; DropShadowGeographicOffset = new Coordinate(0, 0); DropShadowPixelOffset = new PointF(2F, 2F); FontSize = 10F; FontFamily = "Arial Unicode MS"; FontStyle = FontStyle.Regular; FontColor = Color.Black; HaloColor = Color.White; HaloEnabled = false; ScaleMode = ScaleMode.Symbolic; LabelPlacementMethod = LabelPlacementMethod.Centroid; PartsLabelingMethod = PartLabelingMethod.LabelLargestPart; PreventCollisions = true; PriorityField = "FID"; Orientation = ContentAlignment.MiddleCenter; }
public JungleTile(Coordinate position) { _painter = new JungleTilePainter(); _name = MainStrings.JungleTileName; _properties = new TileProperties(85, 20, position, 27); _effects = new TilePropertiesForEffects(); }
/// <summary> /// Computes the cross product of <paramref name="v1"/> and <paramref name="v2"/> /// </summary> /// <param name="v1">A vector</param> /// <param name="v2">A vector</param> /// <returns>The cross product of <paramref name="v1"/> and <paramref name="v2"/></returns> public static Coordinate CrossProduct(Coordinate v1, Coordinate v2) { double x = Det(v1.Y, v1.Z, v2.Y, v2.Z); double y = -Det(v1.X, v1.Z, v2.X, v2.Z); double z = Det(v1.X, v1.Y, v2.X, v2.Y); return new Coordinate(x, y, z); }
/// <summary> /// Initializes the NMEA Recommended minimum specific GPS/Transit data and parses an NMEA sentence /// </summary> /// <param name="NMEAsentence"></param> public GPRMC(string NMEAsentence) { try { //Split into an array of strings. string[] split = NMEAsentence.Split(new Char[] { ',' }); //Extract date/time try { string[] DateTimeFormats = { "ddMMyyHHmmss", "ddMMyy", "ddMMyyHHmmss.FFFFFF" }; if (split[9].Length >= 6) { //Require at least the date to be present string time = split[9] + split[1]; // +" 0"; _timeOfFix = DateTime.ParseExact(time, DateTimeFormats, GPSHandler.numberFormat_EnUS, System.Globalization.DateTimeStyles.AssumeUniversal); } else _timeOfFix = new DateTime(); } catch { _timeOfFix = new DateTime(); } if (split[2] == "A") _status = StatusEnum.OK; else _status = StatusEnum.Warning; _position = new Coordinate( GPSHandler.GPSToDecimalDegrees(split[5], split[6]), GPSHandler.GPSToDecimalDegrees(split[3], split[4])); GPSHandler.dblTryParse(split[7], out _speed); GPSHandler.dblTryParse(split[8], out _course); GPSHandler.dblTryParse(split[10], out _magneticVariation); } catch { } }
/// <summary> /// This method handles single points as well as LineStrings. /// LineStrings are assumed <b>not</b> to be closed (the function will not /// fail for closed lines, but will generate superfluous line caps). /// </summary> /// <param name="inputPts">The vertices of the line to offset</param> /// <param name="distance">The offset distance</param> /// <returns>A Coordinate array representing the curve <br/> /// or <c>null</c> if the curve is empty /// </returns> public Coordinate[] GetLineCurve(Coordinate[] inputPts, double distance) { _distance = distance; // a zero or negative width buffer of a line/point is empty if (distance < 0.0 && !_bufParams.IsSingleSided) return null; if (distance == 0.0) return null; var posDistance = Math.Abs(distance); var segGen = GetSegmentGenerator(posDistance); if (inputPts.Length <= 1) { ComputePointCurve(inputPts[0], segGen); } else { if (_bufParams.IsSingleSided) { var isRightSide = distance < 0.0; ComputeSingleSidedBufferCurve(inputPts, isRightSide, segGen); } else ComputeLineBufferCurve(inputPts, segGen); } var lineCoord = segGen.GetCoordinates(); return lineCoord; }
/// <summary> /// Tests whether a triangle is acute. A triangle is acute iff all interior /// angles are acute. This is a strict test - right triangles will return /// <tt>false</tt> A triangle which is not acute is either right or obtuse. /// <para/> /// Note: this implementation is not robust for angles very close to 90 degrees. /// </summary> /// <param name="a">A vertex of the triangle</param> /// <param name="b">A vertex of the triangle</param> /// <param name="c">A vertex of the triangle</param> /// <returns>True if the triangle is acute.</returns> public static Boolean IsAcute(Coordinate a, Coordinate b, Coordinate c) { if (!AngleUtility.IsAcute(a, b, c)) return false; if (!AngleUtility.IsAcute(b, c, a)) return false; if (!AngleUtility.IsAcute(c, a, b)) return false; return true; }