private void DrawPolygonClip(PaintEventArgs e) { var aPoint1 = new GeoCoordinate(20.0, 20.0, 0.0); var aPoint2 = new GeoCoordinate(30.0, 200.0, 0.0); var aPoint3 = new GeoCoordinate(100.0, 300.0, 0.0); var aPoint4 = new GeoCoordinate(400.0, 350.0, 0.0); var aPoint5 = new GeoCoordinate(350.0, 150.0, 0.0); var aPolyline = new GeoPolyline(); aPolyline.addVertex(aPoint1); aPolyline.addVertex(aPoint2); aPolyline.addVertex(aPoint3); aPolyline.addVertex(aPoint4); aPolyline.addVertex(aPoint5); aPolyline.close(); var aPolygon = new GeoPolygon(); aPolygon.setPolyline(aPolyline); DrawPolygon(e, aPolygon, Color.FromArgb(255, 0, 0, 255)); var aNormal = new GeoNormal(1, 1, 0); var aPlane = new GeoPlane(aNormal, 3.0 * trackBar1.Value + 100.0); var aClippedPolygon = aPolygon.clip(aPlane); DrawPolygon(e, aClippedPolygon, Color.FromArgb(255, 255, 0, 0)); }
public GeoProject shpRead() { //IFeatureSet fs = FeatureSet.Open(shppath); string str = fs.ProjectionString; ProjectionInfo info = fs.Projection; project = new GeoProject(); for (int i = 0; i < fs.Features.Count; i++) { Geometries geometries = new Geometries(); IList <Coordinate> vertics = fs.Features[i].Coordinates; GeoPolygon polygon = new GeoPolygon(); int circle = 1; foreach (Coordinate vertic in vertics) { GeoPoint point = new GeoPoint(); point.X = vertic.X; point.Y = vertic.Y; if (polygon.Points.Contains(point)) { polygon.Circle = circle; geometries.Polygons.Add(polygon); circle++; polygon = new GeoPolygon(); } polygon.Points.Add(point); } polygon.Circle = circle; geometries.Polygons.Add(polygon); project.Geometries.Add(geometries); } return(project); }
private GeoPolygonRegion GenerateFullMapPolygon() { double maxValue = double.MaxValue; double minValue = double.MinValue; double num3 = double.MaxValue; double num4 = double.MinValue; double num5 = 0.0; foreach (Transceiver transceiver in this.m_otherSubSysInterface.INet.TranceiverList) { num5 = 0.0; foreach (PropModelConfig config in transceiver.Cells[0].PropModels) { num5 = Math.Max(num5, (double) config.CalcRadius); } maxValue = Math.Min(maxValue, (transceiver.AntConfiguration[0].DX + transceiver.Parent.X) - num5); minValue = Math.Max(minValue, (transceiver.AntConfiguration[0].DX + transceiver.Parent.X) + num5); num4 = Math.Max(num4, (transceiver.AntConfiguration[0].DY + transceiver.Parent.Y) + num5); num3 = Math.Min(num3, (transceiver.AntConfiguration[0].DY + transceiver.Parent.Y) - num5); } GeoXYRect geoXYRect = new GeoXYRect(maxValue, minValue, num3, num4); GeoPolygon geoPolygon = new GeoPolygon(geoXYRect); GeoPolygonRegion region = new GeoPolygonRegion(); region.AddGeoPolygon(geoPolygon); region.Name = GeneralResource.GENERAL_FULL_MAP; return region; }
public void PolyfillTransmeridianComplex() { // This polygon is "complex" in that it has > 4 vertices - this // tests for a bug that was taking the max and min longitude as // the bounds for transmeridian polygons var verts = new[] { new GeoCoord(0.1m, -Constants.H3.M_PI + 0.00001m), new GeoCoord(0.1m, Constants.H3.M_PI - 0.00001m), new GeoCoord(0.05m, Constants.H3.M_PI - 0.2m), new GeoCoord(-0.1m, Constants.H3.M_PI - 0.00001m), new GeoCoord(-0.1m, -Constants.H3.M_PI + 0.00001m), new GeoCoord(-0.05m, -Constants.H3.M_PI + 0.2m), }; var geofence = new GeoFence { NumVerts = 6, Verts = verts }; var polygon = new GeoPolygon { GeoFence = geofence, NumHoles = 0 }; var hexagons = polygon.Polyfill(4); int actualNumHexagons = Utility.CountActualHexagons(hexagons); Assert.AreEqual(1204, actualNumHexagons); }
public void GeoPolygon_Serialize() { GeoPolygon poly; poly = new GeoPolygon( new GeoCoordinate[] { new GeoCoordinate(10, 20) }); poly = (GeoPolygon)GeoRegion.Parse(poly.ToString()); Assert.AreEqual(1, poly.Vertices.Count); Assert.IsTrue(new GeoCoordinate(10, 20) == poly.Vertices[0]); poly = new GeoPolygon( new GeoCoordinate[] { new GeoCoordinate(10, 20), new GeoCoordinate(0, 20), new GeoCoordinate(0, 0) }); poly = (GeoPolygon)GeoRegion.Parse(poly.ToString()); Assert.AreEqual(3, poly.Vertices.Count); Assert.IsTrue(new GeoCoordinate(10, 20) == poly.Vertices[0]); Assert.IsTrue(new GeoCoordinate(0, 20) == poly.Vertices[1]); Assert.IsTrue(new GeoCoordinate(0, 0) == poly.Vertices[2]); }
/// <summary> /// maxPolyfillSize returns the number of hexagons to allocate space for when /// performing a polyfill on the given GeoJSON-like data structure. /// /// The size is the maximum of either the number of points in the geofence or the /// number of hexagons in the bounding box of the geofence. /// </summary> /// <param name="geoPolygon">A GeoJSON-like data structure indicating the poly to fill</param> /// <param name="res">Hexagon resolution (0-15)</param> /// <returns>number of hexagons to allocate for</returns> /// <!-- /// algos.c /// int H3_EXPORT(maxPolyfillSize) /// --> public static int MaxPolyFillSize(this GeoPolygon geoPolygon, int res) { // Get the bounding box for the GeoJSON-like struct var bbox = geoPolygon.GeoFence.ToBBox(); int numHexagons = bbox.HexEstimate(res); // This algorithm assumes that the number of vertices is usually less than // the number of hexagons, but when it's wrong, this will keep it from // failing int totalVerts = geoPolygon.GeoFence.NumVerts; for (var i = 0; i < geoPolygon.NumHoles; i++) { totalVerts += geoPolygon.Holes[i].NumVerts; } if (numHexagons < totalVerts) { numHexagons = totalVerts; } // When the polygon is very small, near an icosahedron edge and is an odd // resolution, the line tracing needs an extra buffer than the estimator // function provides (but beefing that up to cover causes most situations to // over allocate memory) numHexagons += Constants.Algos.PolyfillBuffer; return(numHexagons); }
public void polyfillExact() { GeoCoord somewhere = new GeoCoord(1, 2); H3Index origin = H3Index.geoToH3(ref somewhere, 9); GeoBoundary boundary = new GeoBoundary(); H3Index.h3ToGeoBoundary(origin, ref boundary); List <GeoCoord> verts = new GeoCoord [boundary.numVerts + 1].ToList(); for (int i = 0; i < boundary.numVerts; i++) { verts[i] = boundary.verts[i]; } verts[boundary.numVerts] = boundary.verts[0]; Geofence someGeofence = new Geofence(); someGeofence.numVerts = boundary.numVerts + 1; someGeofence.verts = verts.ToArray(); GeoPolygon someHexagon = new GeoPolygon(); someHexagon.Geofence = someGeofence; someHexagon.numHoles = 0; int numHexagons = Algos.maxPolyfillSize(ref someHexagon, 9); var hexagons = new ulong[numHexagons].Select(cell => new H3Index(cell)).ToList(); Algos.polyfill(someHexagon, 9, hexagons); int actualNumHexagons = countActualHexagons(hexagons, numHexagons); Assert.True(actualNumHexagons == 1, "got expected polyfill size (1)"); }
public static List<GeoXYPoint> CoverageDistributePoint(GeoPolygon polygonPeak, double r) { List<GeoXYPoint> list = new List<GeoXYPoint>(); GeoXYPoint centerPoint = new GeoXYPoint((polygonPeak.Right + polygonPeak.Left) / 2.0, (polygonPeak.Top + polygonPeak.Bottom) / 2.0); GeoXYPoint southwest = GetSouthWestPoint(polygonPeak.Left, polygonPeak.Right, polygonPeak.Top, polygonPeak.Bottom, centerPoint, r); GeoXYPoint northeast = GetNorthEastClutterPoint(polygonPeak.Left, polygonPeak.Right, polygonPeak.Top, polygonPeak.Bottom, centerPoint, r); list = InitialDistribute(southwest, northeast, r); int index = 0; while (index < list.Count) { if (!polygonPeak.IsPointInPolygon(list[index])) { list.RemoveAt(index); index--; } index++; } for (int i = 0; list.Count == 0; i++) { if (i >= polygonPeak.Points.Count) { return list; } list = InitialDistribute(polygonPeak.Points[i], northeast, r); for (index = 0; index < list.Count; index++) { if (!polygonPeak.IsPointInPolygon(list[index])) { list.RemoveAt(index); index--; } } } return list; }
public void Polygons() { GeoLine line = new GeoLine( new[] { new GeoPosition(0, 0), new GeoPosition(0, 1), new GeoPosition(1, 1), new GeoPosition(0, 0), }); Assert.AreEqual( "geo.intersects(Foo, geography'POLYGON((0 0,0 1,1 1,0 0))')", SearchFilter.Create($"geo.intersects(Foo, {line})")); GeoPolygon polygon = new GeoPolygon(new[] { line }); Assert.AreEqual( "geo.intersects(Foo, geography'POLYGON((0 0,0 1,1 1,0 0))')", SearchFilter.Create($"geo.intersects(Foo, {polygon})")); Assert.Throws<ArgumentException>(() => SearchFilter.Create( $"{new GeoLine(new[] { new GeoPosition(0, 0) })}")); Assert.Throws<ArgumentException>(() => SearchFilter.Create( $"{new GeoLine(new[] { new GeoPosition(0, 0), new GeoPosition(0, 0), new GeoPosition(0, 0), new GeoPosition(1, 1) })}")); Assert.Throws<ArgumentException>(() => SearchFilter.Create( $"{new GeoPolygon(new[] { line, line })}")); }
public void PolyfillExact() { var somewhere = new GeoCoord(1, 2); var origin = somewhere.ToH3Index(9); var boundary = origin.ToGeoBoundary(); var verts = new List <GeoCoord>(); verts.AddRange(boundary.Verts.Take(boundary.NumVerts)); verts.Add(boundary.Verts[0]); var someGeofence = new GeoFence { NumVerts = boundary.NumVerts + 1, Verts = verts.ToArray() }; var someHexagon = new GeoPolygon { GeoFence = someGeofence, NumHoles = 0 }; var hexagons = someHexagon.Polyfill(9); var actualNumHexagons = Utility.CountActualHexagons(hexagons); Assert.AreEqual(1, actualNumHexagons); }
public void h3js_67() { decimal east = (-56.25m).DegreesToRadians(); decimal north = (-33.13755119234615m).DegreesToRadians(); decimal south = (-34.30714385628804m).DegreesToRadians(); decimal west = (-57.65625m).DegreesToRadians(); var testVerts = new[] { new GeoCoord(north, east), new GeoCoord(south, east), new GeoCoord(south, west), new GeoCoord(north, west), }; var testGeoFence = new GeoFence { NumVerts = 4, Verts = testVerts }; var testPolygon = new GeoPolygon { GeoFence = testGeoFence, NumHoles = 0 }; const int res = 7; var hexagons = testPolygon.Polyfill(res); int actualNumHexagons = Utility.CountActualHexagons(hexagons); Assert.AreEqual(4499, actualNumHexagons); }
public void bboxesFromGeoPolygon() { List <GeoCoord> verts = new List <GeoCoord> { new GeoCoord(0.8, 0.3), new GeoCoord(0.7, 0.6), new GeoCoord(1.1, 0.7), new GeoCoord(1.0, 0.2) }; Geofence geofence = new Geofence { numVerts = 4, verts = verts.ToArray() }; GeoPolygon polygon = new GeoPolygon { Geofence = geofence, numHoles = 0 }; BBox expected = new BBox { north = 1.1, south = 0.7, east = 0.7, west = 0.2 }; List <BBox> result = new List <BBox>(); result.Add(new BBox()); Polygon.bboxesFromGeoPolygon(polygon, ref result); Assert.True(BBox.bboxEquals(result[0], expected), "Got expected bbox"); }
public GeoProject shpRead() { //IFeatureSet fs = FeatureSet.Open(shppath); string str = fs.ProjectionString; ProjectionInfo info = fs.Projection; project = new GeoProject(); for (int i = 0; i < fs.Features.Count; i++) { Geometries geometries = new Geometries(); IList<Coordinate> vertics = fs.Features[i].Coordinates; GeoPolygon polygon = new GeoPolygon(); int circle = 1; foreach (Coordinate vertic in vertics) { GeoPoint point = new GeoPoint(); point.X = vertic.X; point.Y = vertic.Y; if (polygon.Points.Contains(point)) { polygon.Circle = circle; geometries.Polygons.Add(polygon); circle++; polygon = new GeoPolygon(); } polygon.Points.Add(point); } polygon.Circle = circle; geometries.Polygons.Add(polygon); project.Geometries.Add(geometries); } return project; }
private void DrawRegion(MapPen mapPen, MapBrush mapBrush, GeoPolygon region) { Pen pen = new Pen(Color.FromArgb((int)(mapPen.Color | 0xFF000000)), mapPen.Width); Brush brush = GetBrush(mapBrush); GeoBounds bounds = new GeoBounds(118.808451, 31.907395, 0.003907, 0.0035); ArrayList clippedPts = _sutherlandHodgman.ClipRegion(region.GetPoints()); GeoPoint[] screenPts = FromLatLngToMapPixel(clippedPts); if (screenPts.Length > 2) { { int[] xpoints = new int[screenPts.Length]; int[] ypoints = new int[screenPts.Length]; for (int i = 0; i < screenPts.Length; i++) { xpoints[i] = (int)screenPts[i].X; ypoints[i] = (int)screenPts[i].Y; } Point[] points = new Point[xpoints.Length]; for (int i = 0; i < points.Length; i++) { points[i] = new Point(xpoints[i], ypoints[i]); } SharedGraphics2D.Graphics.DrawPolygon(pen, points); SharedGraphics2D.Graphics.FillPolygon(brush, points); } } }
[Test] public void CreatePolygonWithHoles() { #region Snippet:CreatePolygonWithHoles var polygon = new GeoPolygon(new[] { // Outer ring new GeoLinearRing(new[] { new GeoPosition(-122.108727, 47.649383), new GeoPosition(-122.081538, 47.640846), new GeoPosition(-122.078634, 47.576066), new GeoPosition(-122.112686, 47.578559), // Last position same as first new GeoPosition(-122.108727, 47.649383), }), // Inner ring new GeoLinearRing(new[] { new GeoPosition(-122.102370, 47.607370), new GeoPosition(-122.083488, 47.608007), new GeoPosition(-122.085419, 47.597879), new GeoPosition(-122.107005, 47.596895), // Last position same as first new GeoPosition(-122.102370, 47.607370), }) }); #endregion }
// https://github.com/uber/h3-js/issues/76#issuecomment-561204505 public void entireWorld() { // TODO: Fails for a single worldwide polygon var worldVerts = new List <GeoCoord> { new GeoCoord(-Constants.H3.M_PI_2, -Constants.H3.M_PI), new GeoCoord(Constants.H3.M_PI_2, -Constants.H3.M_PI), new GeoCoord(Constants.H3.M_PI_2, 0), new GeoCoord(-Constants.H3.M_PI_2, 0), }; var worldGeofence = new GeoFence { NumVerts = 4, Verts = worldVerts.ToArray() }; var worldGeoPolygon = new GeoPolygon { GeoFence = worldGeofence, NumHoles = 0 }; var worldVerts2 = new List <GeoCoord> { new GeoCoord(-Constants.H3.M_PI_2, 0), new GeoCoord(Constants.H3.M_PI_2, 0), new GeoCoord(Constants.H3.M_PI_2, -Constants.H3.M_PI), new GeoCoord(-Constants.H3.M_PI_2, -Constants.H3.M_PI), }; var worldGeofence2 = new GeoFence { NumVerts = 4, Verts = worldVerts2.ToArray() }; var worldGeoPolygon2 = new GeoPolygon { GeoFence = worldGeofence2, NumHoles = 0 }; for (int res = 0; res < 3; res++) { var polyfillOut = worldGeoPolygon.Polyfill(res); var actualNumHexagons = Utility.CountActualHexagons(polyfillOut); var polyfillOut2 = worldGeoPolygon2.Polyfill(res); var actualNumHexagons2 = Utility.CountActualHexagons(polyfillOut2); Assert.AreEqual(res.NumHexagons(), actualNumHexagons + actualNumHexagons2); // Sets should be disjoint foreach (var fill1 in polyfillOut) { if (fill1 == 0) { continue; } bool found = polyfillOut2.Any(fill2 => fill1 == fill2); Assert.IsFalse(found); } polyfillOut.Clear(); polyfillOut2.Clear(); } }
//////////////////////////////////////////////////////////////////////////// //--------------------------------- REVISIONS ------------------------------ // Date Name Tracking # Description // --------- ------------------- ------------- ---------------------- // 18JUN2009 James Shen Initial Creation //////////////////////////////////////////////////////////////////////////// /** * default constructor. */ public MapRegion() { SetMapObjectType(REGION); PenStyle = new MapPen(); BrushStyle = new MapBrush(); CenterPt = new GeoLatLng(); Region = null; }
//////////////////////////////////////////////////////////////////////////// //--------------------------------- REVISIONS ------------------------------ // Date Name Tracking # Description // --------- ------------------- ------------- ---------------------- // 18JUN2009 James Shen Initial Creation //////////////////////////////////////////////////////////////////////////// /** * Copy constructor. * @param region map object copy from. */ public MapRegion(MapRegion region) : base(region) { SetMapObjectType(REGION); PenStyle = new MapPen(region.PenStyle); BrushStyle = new MapBrush(region.BrushStyle); Region = new GeoPolygon(region.Region); CenterPt = new GeoLatLng(region.CenterPt); }
public void GeoPolygon_Empty() { // Verify that a polygon created from an empty set of vertices is initalized to (0,0). var poly = new GeoPolygon(new GeoCoordinate[0]); Assert.IsTrue(poly.IsPoint); Assert.AreEqual(1, poly.Vertices.Count); Assert.AreEqual(GeoCoordinate.Origin, poly.Vertices[0]); }
public void GeoPolygon_Point() { // Verifies that point polygons are allowed. var pt = new GeoCoordinate(10, 20); var poly = new GeoPolygon(new GeoCoordinate[] { pt }); Assert.IsTrue(poly.IsPoint); Assert.AreEqual(1, poly.Vertices.Count); Assert.AreEqual(pt, poly.Vertices[0]); }
private void DrawPolygon(PaintEventArgs e, GeoPolygon aPolygon, Color aColor) { var aPolyline = aPolygon.polyline(); for (int i = 0; i < aPolyline.nbLines(); i++) { var aLine = aPolyline.line(i); DrawLine(e, aLine, aColor); } }
private static void fillIndex_assertions(H3Index h) { if (IsTransmeridianCell(h)) { // TODO: these do not work correctly return; } int currentRes = h.Resolution; // TODO: Not testing more than one depth because the assertions fail. for (int nextRes = currentRes; nextRes <= currentRes + 1; nextRes++) { var boundary = h.ToGeoBoundary(); var polygon = new GeoPolygon() { GeoFence = new GeoFence { NumVerts = boundary.NumVerts, Verts = boundary.Verts.ToArray() }, NumHoles = 0, Holes = new List <GeoFence>() }; var polyfillOut = polygon.Polyfill(nextRes); int polyfillCount = Utility.CountActualHexagons(polyfillOut); var children = h.ToChildren(nextRes); int h3ToChildrenCount = Utility.CountActualHexagons(children); polyfillOut = polyfillOut.Where(p => p != Constants.H3Index.H3_NULL).ToList(); polyfillOut.Sort(); children = children.Where(p => p != Constants.H3Index.H3_NULL).ToList(); children.Sort(); Assert.AreEqual(h3ToChildrenCount, polyfillCount, $"h: {h}\nnextRes: {nextRes}\ncurrentRes: {currentRes}"); bool match = true; for (int i = 0; i < children.Count; i++) { if (children[i] != polyfillOut[i]) { match = false; } } Assert.IsTrue(match); } }
public ZoomInRegionOperator(IApplicationContext appContext, GeoEventManager eventMgr, GeoMapMgr geoMapMgr) { this.m_Helper = ServiceHelper.Lookup<IGeoSelectionHelper>(appContext); this.m_Cursor = new Cursor(Huawei.UNet.Common.GlobalResource.GlobalResource.ZoomIn.GetHicon()); this.m_EventMgr = eventMgr; this.m_GeoMapMgr = geoMapMgr; this.InitDrawingStyle(); this.m_StartPlanePoint = new GeoXYPoint(); this.m_SelectionPolygon = new GeoPolygon(); this.m_SelectionRegion = new GeoPolygonRegion(); this.m_SelectionRegion.AddGeoPolygon(this.m_SelectionPolygon); }
private GeoPolygon CreatePolygon() { GeoPoint center = Map1.CurrentCenter; int segmentCount = 5; double radius = Math.Min(Map1.CurrentBound.Width, Map1.CurrentBound.Height) * .4; GeoPolygon polygon = new GeoPolygon(); polygon.OuterRing = CreateRing(center, radius, segmentCount); return(polygon); }
/// <summary> /// Create a set of bounding boxes from a GeoPolygon /// </summary> /// <param name="polygon">Input GeoPolygon</param> /// <returns> /// Output bboxes, one for the outer loop and one for each hole /// </returns> /// <!-- /// polygon.c /// void bboxesFromGeoPolygon /// --> public static List <BBox> ToBBoxes(this GeoPolygon polygon) { var results = new List <BBox> { polygon.GeoFence.ToBBox() }; for (var i = 0; i < polygon.NumHoles; i++) { results.Add(polygon.Holes[i].ToBBox()); } return(results); }
public void CreatePolygon() { #region Snippet:CreatePolygon var polygon = new GeoPolygon(new[] { new GeoPosition(-122.108727, 47.649383), new GeoPosition(-122.081538, 47.640846), new GeoPosition(-122.078634, 47.576066), new GeoPosition(-122.112686, 47.578559), new GeoPosition(-122.108727, 47.649383), }); #endregion }
private IMapZoneModel CreateMapZone(int id, string zoneName, GeoPolygon polygon) { var holes = new List <List <Vector2> >(); var bounds = GetWorldPoints2d(polygon.OuterBounds); foreach (var hole in polygon.Holes) { holes.Add(GetWorldPoints2d(hole)); } return(new MapZoneModel(zoneName, id, bounds, holes)); }
//////////////////////////////////////////////////////////////////////////// //--------------------------------- REVISIONS ------------------------------ // Date Name Tracking # Description // --------- ------------------- ------------- ---------------------- // 18JUN2009 James Shen Initial Creation //////////////////////////////////////////////////////////////////////////// /** * Copy constructor. * @param multiRegion map object copy from. */ public MapMultiRegion(MapMultiRegion multiRegion) : base(multiRegion) { SetMapObjectType(MULTIREGION); PenStyle = new MapPen(multiRegion.PenStyle); BrushStyle = new MapBrush(multiRegion.BrushStyle); Regions = new GeoPolygon[multiRegion.Regions.Length]; for (int i = 0; i < Regions.Length; i++) { Regions[i] = new GeoPolygon(multiRegion.Regions[i]); } CenterPt = new GeoLatLng(multiRegion.CenterPt); }
/// <summary> /// Encodes a polygon for use in OData filters. /// <seealso cref="EncodePolygon(GeoLine)"/> /// </summary> /// <param name="polygon">The <see cref="GeoPolygon"/> to encode.</param> /// <returns>The OData filter-encoded POLYGON string.</returns> /// <exception cref="ArgumentNullException"><paramref name="polygon"/> or <see cref="GeoPolygon.Rings"/> is null.</exception> public static string EncodePolygon(GeoPolygon polygon) { Argument.AssertNotNull(polygon, nameof(polygon)); Argument.AssertNotNull(polygon.Rings, $"{nameof(polygon)}.{nameof(polygon.Rings)}"); if (polygon.Rings.Count != 1) { throw new ArgumentException( $"A {nameof(GeoPolygon)} must have exactly one {nameof(GeoPolygon.Rings)} to form a searchable polygon.", $"{nameof(polygon)}.{nameof(polygon.Rings)}"); } return(EncodePolygon(polygon.Rings[0])); }
public void bboxesFromGeoPolygonHole() { List <GeoCoord> verts = new List <GeoCoord> { new GeoCoord(0.8, 0.3), new GeoCoord(0.7, 0.6), new GeoCoord(1.1, 0.7), new GeoCoord(1.0, 0.2) }; Geofence geofence = new Geofence { numVerts = 4, verts = verts.ToArray() }; // not a real hole, but doesn't matter for the test List <GeoCoord> holeVerts = new List <GeoCoord> { new GeoCoord(0.9, 0.3), new GeoCoord(0.9, 0.5), new GeoCoord(1.0, 0.7), new GeoCoord(0.9, 0.3) }; List <Geofence> holeGeofence = new List <Geofence> { new Geofence { numVerts = 4, verts = holeVerts.ToArray() } }; GeoPolygon polygon = new GeoPolygon { Geofence = geofence, numHoles = 1, holes = holeGeofence }; BBox expected = new BBox { north = 1.1, south = 0.7, east = 0.7, west = 0.2 }; BBox expectedHole = new BBox { north = 1.0, south = 0.9, east = 0.7, west = 0.3 }; List <BBox> result = new List <BBox> { new BBox(), new BBox() }; Polygon.bboxesFromGeoPolygon(polygon, ref result); Assert.True(BBox.bboxEquals(result[0], expected), "Got expected bbox"); Assert.True(BBox.bboxEquals(result[1], expectedHole), "Got expected hole bbox"); }
/// <summary> /// polyfill takes a given GeoJSON-like data structure and preallocated, /// zeroed memory, and fills it with the hexagons that are contained by /// the GeoJSON-like data structure. /// /// This implementation traces the GeoJSON geofence(s) in cartesian space with /// hexagons, tests them and their neighbors to be contained by the geofence(s), /// and then any newly found hexagons are used to test again until no new /// hexagons are found. /// </summary> /// <param name="polygon">The geofence and holes defining the relevant area</param> /// <param name="res">The Hexagon resolution (0-15)</param> /// <returns>List of H3Index that compose the polyfill</returns> /// <!-- /// algos.c /// void H3_EXPORT(polyfill) /// --> public static List <H3Index> Polyfill(this GeoPolygon polygon, int res) { // TODO: Eliminate this wrapper with the H3 4.0.0 release (int failure, var result) = polygon.PolyFillInternal(res); if (failure == 0) { return(result.Where(r => r != 0).ToList()); } // The polyfill algorithm can theoretically fail if the allocated memory is // not large enough for the polygon, but this should be impossible given the // conservative overestimation of the number of hexagons possible. int numHexagons = polygon.MaxPolyFillSize(res); return(new H3Index[numHexagons].ToList()); }
/// <summary> /// Encodes a polygon for use in OData filters. /// <seealso cref="EncodePolygon(GeoLinearRing)"/> /// </summary> /// <param name="polygon">The <see cref="GeoPolygon"/> to encode.</param> /// <returns>The OData filter-encoded POLYGON string.</returns> /// <exception cref="ArgumentNullException"><paramref name="polygon"/> or <see cref="GeoPolygon.Rings"/> is null.</exception> public static string EncodePolygon(GeoPolygon polygon) { Argument.AssertNotNull(polygon, nameof(polygon)); Argument.AssertNotNull(polygon.Rings, $"{nameof(polygon)}.{nameof(polygon.Rings)}"); if (polygon.Rings.Count != 1) { #pragma warning disable CA2208 // Instantiate argument exceptions correctly throw new ArgumentException( $"A {nameof(GeoPolygon)} must have exactly one {nameof(GeoPolygon.Rings)} to form a searchable polygon.", $"{nameof(polygon)}.{nameof(polygon.Rings)}"); #pragma warning restore CA2208 // Instantiate argument exceptions correctly } return(EncodePolygon(polygon.Rings[0])); }
private GeoMultiPolygon CreateMultiPolygon() { GeoPoint center1 = new GeoPoint(Map1.CurrentBound.MinX + Map1.CurrentBound.Width * .25, Map1.CurrentCenter.Y); GeoPoint center2 = new GeoPoint(Map1.CurrentBound.MinX + Map1.CurrentBound.Width * .75, Map1.CurrentCenter.Y); double radius = Map1.CurrentBound.Width * .25; int segmentCount = 5; GeoPolygon polygon1 = new GeoPolygon(CreateRing(center1, radius, segmentCount)); GeoPolygon polygon2 = new GeoPolygon(CreateRing(center2, radius, segmentCount)); GeoMultiPolygon multiPolygon = new GeoMultiPolygon(); multiPolygon.Polygons.Add(polygon1); multiPolygon.Polygons.Add(polygon2); return(multiPolygon); }
private static Polygon projectPolygon(GeoPolygon polygon, GnomonicProjection projection) { Polygon p = polygon.ToPlanarPolygon(false); foreach (Contour contour in p.Contours) { for (int i = 0; i < contour.Vertices.Count; i++) { double x, y; projection.Project(contour.Vertices[i].Y, contour.Vertices[i].X, out x, out y); contour.Vertices[i] = PlanimetryEnvironment.NewCoordinate(x, y); } } return(p); }
private void CalcInsideSituation(int index) { int indexRef = 0; int num2 = 0; GeoPolygon item = new GeoPolygon(); double slope = this.GetSlopeFromLinePair(index - 1, true, ref indexRef).PositiveLine.Slope; double d = this.GetSlopeFromLinePair(index, false, ref num2).PositiveLine.Slope; double num5 = Math.Tan((Math.Atan(slope) + Math.Atan(d)) / 2.0); if (this.IsSlopeNeedTransform(this.m_SourceLine.Points[indexRef + 1], this.m_SourceLine.Points[indexRef], this.m_SourceLine.Points[num2], this.m_SourceLine.Points[num2 + 1])) { num5 = -1.0 / num5; } if (!(this.IsSlopeNeedTransform(this.m_SourceLine.Points[indexRef + 1], this.m_SourceLine.Points[indexRef], this.m_SourceLine.Points[num2], this.m_SourceLine.Points[num2 + 1]) || (Math.Abs((double) (Math.Atan(slope) - Math.Atan(d))) >= 0.8))) { num5 = -1.0 / num5; } if (num5 == double.NegativeInfinity) { num5 = 1000.0; } GisLine line = this.GetPositionLine(this.m_SourceLine.Points[index], this.m_SourceLine.Points[index + 1], d, this.m_WidthOfStrip / 2.0); this.m_PositivePt = line.GetJointPt(this.GetSlopeFromLinePair(index, false, ref indexRef).PositiveLine); this.m_OppositePt = line.GetJointPt(this.GetSlopeFromLinePair(index, false, ref indexRef).OppositeLine); item.Points.Add(this.m_PositivePt); item.Points.Add(this.m_OppositePt); slope = this.GetSlopeFromLinePair(index, true, ref indexRef).PositiveLine.Slope; d = this.GetSlopeFromLinePair(index + 1, true, ref num2).PositiveLine.Slope; num5 = Math.Tan((Math.Atan(slope) + Math.Atan(d)) / 2.0); if (this.IsSlopeNeedTransform(this.m_SourceLine.Points[indexRef + 1], this.m_SourceLine.Points[indexRef], this.m_SourceLine.Points[num2], this.m_SourceLine.Points[num2 + 1])) { num5 = -1.0 / num5; } if (!(this.IsSlopeNeedTransform(this.m_SourceLine.Points[indexRef + 1], this.m_SourceLine.Points[indexRef], this.m_SourceLine.Points[num2], this.m_SourceLine.Points[num2 + 1]) || (Math.Abs((double) (Math.Atan(slope) - Math.Atan(d))) >= 0.8))) { num5 = -1.0 / num5; } if (num5 == double.NegativeInfinity) { num5 = 1000.0; } line = this.GetPositionLine(this.m_SourceLine.Points[index + 1], this.m_SourceLine.Points[index], slope, this.m_WidthOfStrip / 2.0); this.m_PositivePt = line.GetJointPt(this.GetSlopeFromLinePair(index, true, ref indexRef).PositiveLine); this.m_OppositePt = line.GetJointPt(this.GetSlopeFromLinePair(index, true, ref indexRef).OppositeLine); item.Points.Add(this.m_OppositePt); item.Points.Add(this.m_PositivePt); this.m_PolyList.Add(item); }
private GeoPolygonRegion CreatRegion() { GeoPolygonRegion region=new GeoPolygonRegion(); GeoPolygon polygon=new GeoPolygon(); List<GeoXYPoint> point_list=new List<GeoXYPoint>(); GeoXYPoint fpoint=new GeoXYPoint(1000,2500); point_list.Add(fpoint); GeoXYPoint spoint=new GeoXYPoint(3000,1000); point_list.Add(spoint); GeoXYPoint tpoint=new GeoXYPoint(3800,4000); point_list.Add(tpoint); GeoXYPoint lpoint=new GeoXYPoint(2200,4500); point_list.Add(lpoint); polygon.Points=point_list; region.AddGeoPolygon(polygon); return region; }
private GeoPolygonRegion CreatRegion() { GeoPolygonRegion region = new GeoPolygonRegion(); GeoPolygon polygon = new GeoPolygon(); List<GeoXYPoint> point_list = new List<GeoXYPoint>(); GeoXYPoint fpoint = new GeoXYPoint(0, 0); point_list.Add(fpoint); GeoXYPoint spoint = new GeoXYPoint(0, 50); point_list.Add(spoint); GeoXYPoint tpoint = new GeoXYPoint(50, 0); point_list.Add(tpoint); GeoXYPoint lpoint = new GeoXYPoint(50, 50); point_list.Add(lpoint); polygon.Points = point_list; region.AddGeoPolygon(polygon); return region; }
public bool Remove(GeoPolygon geoPolygon) { return this.m_Region.Remove(geoPolygon); }
public bool CalcPolyRegionResult() { GeoPolygon polygon; GeoPolygonRegion region; for (int i = 0; i < (this.m_SourceLine.Points.Count - 1); i++) { this.CalcPairParallel(this.m_SourceLine.Points[i], this.m_SourceLine.Points[i + 1]); } if (this.m_ValidPairParallel == 0) { GeoXYRect geoXYRect = new GeoXYRect(this.m_SourceLine.Points[0].X - (this.m_WidthOfStrip / 2.0), this.m_SourceLine.Points[0].X + (this.m_WidthOfStrip / 2.0), this.m_SourceLine.Points[0].Y - (this.m_WidthOfStrip / 2.0), this.m_SourceLine.Points[0].Y + (this.m_WidthOfStrip / 2.0)); polygon = new GeoPolygon(geoXYRect); region = new GeoPolygonRegion(true, PolygonCreationType.Union); region.AddGeoPolygon(polygon); this.m_BaseData.AddPolygonRegion(region); this.m_BaseData.RaiseDataChangedEvent(this, null); return true; } if (this.m_ValidPairParallel == 1) { this.m_GisLinePairList.Clear(); polygon = new GeoPolygon(); GisLine line = this.CreateGisLine(this.m_SourceLine.Points[0], this.m_SourceLine.Points[1]); GisLine line2 = this.GetPositionLine(this.m_SourceLine.Points[0], this.m_SourceLine.Points[1], line.Slope, this.m_WidthOfStrip / 2.0); this.CalcPairParallel(this.m_SourceLine.Points[0], this.m_SourceLine.Points[1]); this.m_PositivePt = line2.GetJointPt(this.m_GisLinePairList[0].PositiveLine); this.m_OppositePt = line2.GetJointPt(this.m_GisLinePairList[0].OppositeLine); polygon.Points.Add(this.m_PositivePt); polygon.Points.Add(this.m_OppositePt); line2 = this.GetPositionLine(this.m_SourceLine.Points[1], this.m_SourceLine.Points[0], line.Slope, this.m_WidthOfStrip / 2.0); this.m_PositivePt = line2.GetJointPt(this.m_GisLinePairList[0].PositiveLine); this.m_OppositePt = line2.GetJointPt(this.m_GisLinePairList[0].OppositeLine); polygon.Points.Add(this.m_OppositePt); polygon.Points.Add(this.m_PositivePt); region = new GeoPolygonRegion(true, PolygonCreationType.Union); region.AddGeoPolygon(polygon); this.m_BaseData.AddPolygonRegion(region); this.m_BaseData.RaiseDataChangedEvent(this, null); return true; } this.CreateHeadPolygon(); this.CreateInsidePolygonList(); this.CreateTailPolygon(); this.CreatePolyRegion(this.m_PolyList); return true; }
private void ReadRectangle(string[] contents) { double x = double.Parse(contents[1]); double y = double.Parse(contents[2]); double num3 = double.Parse(contents[3]); double num4 = double.Parse(contents[4]); GeoPolygon geoPolygon = new GeoPolygon(); geoPolygon.Points.Add(new GeoXYPoint(x, y)); geoPolygon.Points.Add(new GeoXYPoint(num3, y)); geoPolygon.Points.Add(new GeoXYPoint(num3, num4)); geoPolygon.Points.Add(new GeoXYPoint(x, num4)); GeoPolygonRegion region = new GeoPolygonRegion(); region.AddGeoPolygon(geoPolygon); try { BrushStyle brushStyle = null; PenStyle penStyle = null; this.BuildStyle(ref penStyle, ref brushStyle); GeoPolygonStyle style = this.BuildPolygonStyle(brushStyle, penStyle); GeoDisplayPolygonRegion item = new GeoDisplayPolygonRegion(region, style); this.m_RegionList.Add(item); } catch { } }
private void ReadPolygon(int numParts, int numPoints) { int[] numArray = new int[numParts]; for (int i = 0; i < numParts; i++) { numArray[i] = this.ReadInteger(ByteOrder.LittleEndian); } int index = 1; GeoPolygon geoPolygon = new GeoPolygon(); for (int j = 0; j < numPoints; j++) { double x = this.ReadDouble(ByteOrder.LittleEndian); double y = this.ReadDouble(ByteOrder.LittleEndian); GeoXYPoint point = new GeoXYPoint(x, y); if (index < numParts) { if (j < numArray[index]) { geoPolygon.Points.Add(point); } else { GeoPolygonRegion region = new GeoPolygonRegion(); region.AddGeoPolygon(geoPolygon); GeoDisplayPolygonRegion region2 = new GeoDisplayPolygonRegion(region, this.m_DefaultPolygonStyle); index++; } } else { geoPolygon.Points.Add(point); } } GeoPolygonRegion region3 = new GeoPolygonRegion(); region3.AddGeoPolygon(geoPolygon); GeoDisplayPolygonRegion item = new GeoDisplayPolygonRegion(region3, this.m_DefaultPolygonStyle); item.AddFeature("ID", this.CreateMapUnitId()); this.m_RegionList.Add(item); }
/// <summary> /// 读取地块 /// </summary> /// <param name="line"></param> private void GeometriesRead(String line) { int count = Methods.getCharCout(line, ','); //判断是否为地块信息行 if(count == 8) { if(geometries.Polygons.Count != 0) {//地块信息是否为空 geometries.Polygons.Add(polygon); project.Geometries.Add(geometries);//不为空则将该地块添加入批次中 } //初始化地块 geometries = new Geometries(); //初始化多边形 polygon = new GeoPolygon(); String[] geo = line.Split(','); geometries.Area = Double.Parse(geo[1]);//地块面积 geometries.Name = geo[3].ToString();//地块名称 } //判断是否为坐标点行 else if(count == 3) { GeoPoint point = new GeoPoint(); String[] geo = line.Split(','); point.X = Double.Parse(geo[3]); point.Y = Double.Parse(geo[2]); int circle = Int32.Parse(geo[1]); if(polygon.Circle != circle) {//判断当前圈号是否一致 if(polygon.Points.Count != 0) {//多边形信息是否为空 geometries.Polygons.Add(polygon);//不为空则将该地块加入地块中 } polygon = new GeoPolygon(); //不一致则初始化多边形 polygon.Circle = circle; //多边形圈号赋值 polygon.Points.Add(point); } else { polygon.Points.Add(point); } } }
private void GetBlockCellInfoColl(int blockCount, GeoPolygonRegion region) { this.m_BlockCellInfoArr = new List<PredictionBlockCellInfoColl>(); double maxValue = double.MaxValue; double minValue = double.MinValue; double bottom = double.MaxValue; double top = double.MinValue; ICellFilter cellFilter = this.m_Interfaces.CellFilterBuilder.GetCellFilter(); GeoPolygonRegion regionRectangle = cellFilter.GetRegionRectangle(region, this.m_Group.Resolution); List<Transceiver> list = new List<Transceiver>(); foreach (LTECellCalcInfo info in this.m_CalcLTECells) { list.Add(info.Tanceiver); } int num5 = (int)((regionRectangle.Top - regionRectangle.Bottom) / ((double)this.m_Group.Resolution)); int num6 = num5 % blockCount; int num7 = num5 / blockCount; for (int i = 0; i < blockCount; i++) { maxValue = regionRectangle.Left; minValue = regionRectangle.Right; top = regionRectangle.Top - ((i * num7) * this.m_Group.Resolution); if (i == (blockCount - 1)) { bottom = regionRectangle.Top - ((((i * num7) + num7) + num6) * this.m_Group.Resolution); } else { bottom = regionRectangle.Top - (((i * num7) + num7) * this.m_Group.Resolution); } GeoXYRect geoXYRect = new GeoXYRect(maxValue, minValue, bottom, top); GeoPolygon geoPolygon = new GeoPolygon(geoXYRect); GeoPolygonRegion region3 = new GeoPolygonRegion(); region3.AddGeoPolygon(geoPolygon); PredictionBlockCellInfoColl item = new PredictionBlockCellInfoColl(); item.BlockIndex = i; LTECalcCellsInfoCollection infos = new LTECalcCellsInfoCollection(); infos = cellFilter.GetCalculateCellsInfo(list, region3, this.m_Group.Resolution); item.CalCellColl = infos; this.m_BlockCellInfoArr.Add(item); } }
private static Polygon getBoundsBuffer(GeoPolygon polygon, GnomonicProjection projection, double distance, int pointsPerCircle, bool allowParallels) { Polygon temp = new Polygon(); List<Polygon> partialBuffers = new List<Polygon>(); GeographyCollection geographyCollection = new GeographyCollection(); ICollection<IGeometry> unionResult = null; int c = 0; foreach (GeoContour contour in polygon.Contours) { for (int i = 0; i < contour.Vertices.Count; i++) { GeoPoint p = contour.Vertices[i]; GeoPolygon tempPolygon = getPointBuffer(p, Math.Abs(distance), pointsPerCircle); geographyCollection.Clear(); geographyCollection.Add(tempPolygon); GeometryCollection gc = GeometrySpreader.GetGeometries(geographyCollection, projection); if(gc[0] is Polygon) unionResult = temp.Union((Polygon)gc[0]); if (unionResult.Count > 0) temp = (Polygon)((GeometryCollection)unionResult)[0]; c++; if (c == 3) { partialBuffers.Add(temp); temp = new Polygon(); c = 0; } } } if (temp.CoordinateCount > 0) partialBuffers.Add(temp); return mergePartialBuffers(partialBuffers, allowParallels); }
public GeoPolygonRegion GetRegionRectangle(GeoPolygonRegion polygon, float resolution) { this.GetPolygonRectangle(polygon, resolution); GeoXYRect geoXYRect = new GeoXYRect(this.m_polygonLeftTop.X, this.m_polygonRightBottom.X, this.m_polygonRightBottom.Y, this.m_polygonLeftTop.Y); GeoPolygon geoPolygon = new GeoPolygon(geoXYRect); GeoPolygonRegion region = new GeoPolygonRegion(); region.AddGeoPolygon(geoPolygon); return region; }
private void CreateTailPolygon() { int indexRef = 0; int num2 = 0; GeoPolygon item = new GeoPolygon(); int count = this.m_SourceLine.Points.Count; this.GetSlopeFromLinePair(count - 2, true, ref indexRef); double slope = this.CreateGisLine(this.m_SourceLine.Points[count - 1], this.m_SourceLine.Points[indexRef]).Slope; double num5 = (slope == 0.0) ? 1000.0 : (-1.0 / slope); GisLine line2 = this.GetPositionLine(this.m_SourceLine.Points[count - 1], this.m_SourceLine.Points[indexRef], slope, this.m_WidthOfStrip / 2.0); GeoXYPoint jointPt = line2.GetJointPt(this.GetSlopeFromLinePair(count - 2, true, ref indexRef).PositiveLine); GeoXYPoint point2 = line2.GetJointPt(this.GetSlopeFromLinePair(count - 2, true, ref indexRef).OppositeLine); item.Points.Add(jointPt); item.Points.Add(point2); double d = this.GetSlopeFromLinePair(count - 2, true, ref indexRef).PositiveLine.Slope; double num7 = this.GetSlopeFromLinePair(count - 3, true, ref num2).PositiveLine.Slope; double num8 = Math.Tan((Math.Atan(d) + Math.Atan(num7)) / 2.0); if (this.IsSlopeNeedTransform(this.m_SourceLine.Points[num2 + 1], this.m_SourceLine.Points[num2], this.m_SourceLine.Points[indexRef], this.m_SourceLine.Points[indexRef + 1])) { num8 = -1.0 / num8; } if (!(this.IsSlopeNeedTransform(this.m_SourceLine.Points[num2 + 1], this.m_SourceLine.Points[num2], this.m_SourceLine.Points[indexRef], this.m_SourceLine.Points[indexRef + 1]) || (Math.Abs((double) (Math.Atan(d) - Math.Atan(num7))) >= 0.8))) { num8 = -1.0 / num8; } if (num8 == double.NegativeInfinity) { num8 = 1000.0; } line2 = new GisLine(this.m_SourceLine.Points[indexRef], num8); this.m_PositivePt = line2.GetJointPt(this.GetSlopeFromLinePair(count - 2, true, ref indexRef).PositiveLine); this.m_OppositePt = line2.GetJointPt(this.GetSlopeFromLinePair(count - 2, true, ref indexRef).OppositeLine); item.Points.Add(this.m_OppositePt); item.Points.Add(this.m_PositivePt); this.m_PolyList.Add(item); }
private GeoPolygon[] GetPolygons(List<int> PolygonOrders, List<int> PointOrders, int type, List<double> xPositions, List<double> yPositions) { int num; List<int> list = new List<int>(); for (num = 0; num < PolygonOrders.Count; num++) { if (!list.Contains(PolygonOrders[num])) { list.Add(PolygonOrders[num]); } } GeoPolygon[] polygonArray = new GeoPolygon[list.Count]; for (num = 0; num < list.Count; num++) { polygonArray[num] = new GeoPolygon(); } Predicate<int> match = null; for (int i = 0; i < xPositions.Count; i++) { GeoXYPoint item = null; if (type == 1) { item = new GeoXYPoint(xPositions[i], yPositions[i]); } else if (type == 2) { item = this.m_Helper.LatToPlane(new GeoBLPoint(xPositions[i], yPositions[i])); } if (match == null) { match = delegate (int a) { return a.Equals(PolygonOrders[i]); }; } polygonArray[list.FindIndex(match)].Points.Add(item); } return polygonArray; }
public bool AddGeoPolygon(GeoPolygon geoPolygon) { return this.m_Region.AddGeoPolygon(geoPolygon); }
public bool AutoDistributeSiteMsg(GeoPolygon geoPolygon, out List<GeoSite> sites, out List<GeoCell> cells) { AutoDistributeSiteEventArgs args = new AutoDistributeSiteEventArgs(geoPolygon); return this.OnAutoDistributeSiteMsgChange(args, out sites, out cells); }
private void ReadRegion(string[] contents) { int num = int.Parse(contents[1]); int num2 = 0; GeoPolygonRegion region = new GeoPolygonRegion(); while (num2 < num) { GeoPolygon geoPolygon = new GeoPolygon(); int num3 = int.Parse(this.ReadValidLine()); int num4 = 0; string[] strArray = null; string[] separator = new string[] { " ", "\t" }; while (num4 < num3) { num4++; strArray = this.ReadValidLine().Split(separator, StringSplitOptions.RemoveEmptyEntries); double x = double.Parse(strArray[0]); double y = double.Parse(strArray[1]); geoPolygon.Points.Add(new GeoXYPoint(x, y)); } num2++; num2++; region.AddGeoPolygon(geoPolygon); } BrushStyle brushStyle = null; PenStyle penStyle = null; this.BuildStyle(ref penStyle, ref brushStyle); GeoPolygonStyle style = this.BuildPolygonStyle(brushStyle, penStyle); GeoDisplayPolygonRegion item = new GeoDisplayPolygonRegion(region, style); this.m_RegionList.Add(item); }
private static Polygon projectPolygon(GeoPolygon polygon, GnomonicProjection projection) { Polygon p = polygon.ToPlanarPolygon(false); foreach (Contour contour in p.Contours) { for (int i = 0; i < contour.Vertices.Count; i++) { double x, y; projection.Project(contour.Vertices[i].Y, contour.Vertices[i].X, out x, out y); contour.Vertices[i] = PlanimetryEnvironment.NewCoordinate(x, y); } } return p; }
private GeoPolygon[] GetPolygonsFromForm() { int num2; List<int> list = new List<int>(); int num = 0; for (num2 = 0; num2 < this.m_PolygonDataTable.Rows.Count; num2++) { int id = (int) this.m_PolygonDataTable.Rows[num2][0]; if (!list.Exists(delegate (int a) { return a.Equals(id); })) { list.Add(id); num++; } } GeoPolygon[] polygonArray = new GeoPolygon[num]; for (num2 = 0; num2 < num; num2++) { polygonArray[num2] = new GeoPolygon(); } Predicate<int> match = null; for (int i = 0; i < this.m_PolygonDataTable.Rows.Count; i++) { GeoXYPoint point; if ((this.m_PolygonDataTable.Rows[i][2] != DBNull.Value) && (this.m_PolygonDataTable.Rows[i][3] != DBNull.Value)) { point = new GeoXYPoint((double) this.m_PolygonDataTable.Rows[i][2], (double) this.m_PolygonDataTable.Rows[i][3]); } else { point = this.m_Helper.LatToPlane(new GeoBLPoint((double) this.m_PolygonDataTable.Rows[i][4], (double) this.m_PolygonDataTable.Rows[i][5])); } if (match == null) { match = delegate (int a) { return a.Equals((int) this.m_PolygonDataTable.Rows[i][0]); }; } polygonArray[list.FindIndex(match)].Points.Add(point); } return polygonArray; }
private void CreateHeadPolygon() { int indexRef = 0; int num2 = 0; GeoPolygon item = new GeoPolygon(); GisLine line = this.CreateGisLine(this.m_SourceLine.Points[0], this.m_SourceLine.Points[1]); GisLine line2 = this.GetPositionLine(this.m_SourceLine.Points[0], this.m_SourceLine.Points[1], line.Slope, this.m_WidthOfStrip / 2.0); GeoXYPoint jointPt = line2.GetJointPt(this.GetSlopeFromLinePair(0, false, ref indexRef).PositiveLine); GeoXYPoint point2 = line2.GetJointPt(this.GetSlopeFromLinePair(0, false, ref indexRef).OppositeLine); item.Points.Add(jointPt); item.Points.Add(point2); double slope = this.GetSlopeFromLinePair(0, false, ref indexRef).PositiveLine.Slope; double d = this.GetSlopeFromLinePair(1, false, ref num2).PositiveLine.Slope; double num5 = Math.Tan((Math.Atan(slope) + Math.Atan(d)) / 2.0); if (this.IsSlopeNeedTransform(this.m_SourceLine.Points[indexRef + 1], this.m_SourceLine.Points[indexRef], this.m_SourceLine.Points[num2], this.m_SourceLine.Points[num2 + 1])) { num5 = -1.0 / num5; } if (!(this.IsSlopeNeedTransform(this.m_SourceLine.Points[indexRef + 1], this.m_SourceLine.Points[indexRef], this.m_SourceLine.Points[num2], this.m_SourceLine.Points[num2 + 1]) || (Math.Abs((double) (Math.Atan(slope) - Math.Atan(d))) >= 0.8))) { num5 = -1.0 / num5; } if (num5 == double.NegativeInfinity) { num5 = 1000.0; } line2 = this.GetPositionLine(this.m_SourceLine.Points[1], this.m_SourceLine.Points[0], slope, this.m_WidthOfStrip / 2.0); this.m_PositivePt = line2.GetJointPt(this.GetSlopeFromLinePair(0, false, ref indexRef).PositiveLine); this.m_OppositePt = line2.GetJointPt(this.GetSlopeFromLinePair(0, false, ref indexRef).OppositeLine); item.Points.Add(this.m_OppositePt); item.Points.Add(this.m_PositivePt); this.m_PolyList.Add(item); }
private void GetBlockCellInfoColl(int blockCount, GeoPolygonRegion region) { BlockLTETransceiverColl coll; this.m_BlockTransceiverExCollArr = new List<BlockLTETransceiverColl>(); if (blockCount > 1) { double maxValue = double.MaxValue; double minValue = double.MinValue; double bottom = double.MaxValue; double top = double.MinValue; GeoPolygonRegion regionRectangle = this.m_ICellFilterBuilder.GetCellFilter().GetRegionRectangle(region, this.m_Group.Resolution); List<Transceiver> allTran = new List<Transceiver>(); foreach (LTETransceiverEX rex in this.m_CalTansceiverExColl.LTETransceiverEXList) { //modify 20110228 if (rex.LteCellExList.Count > 0) { allTran.Add(rex.Transceiver); } } int numOfPoint = (int)((regionRectangle.Top - regionRectangle.Bottom) / ((double)this.m_Group.Resolution)); int numOfblockPoint = numOfPoint % blockCount; int leftNumOfblockPoint = numOfPoint / blockCount; for (int i = 0; i < blockCount; i++) { maxValue = regionRectangle.Left; minValue = regionRectangle.Right; top = regionRectangle.Top - ((i * leftNumOfblockPoint) * this.m_Group.Resolution); if (i == (blockCount - 1)) { bottom = regionRectangle.Top - ((((i * leftNumOfblockPoint) + leftNumOfblockPoint) + numOfblockPoint) * this.m_Group.Resolution); } else { bottom = regionRectangle.Top - (((i * leftNumOfblockPoint) + leftNumOfblockPoint) * this.m_Group.Resolution); } GeoXYRect geoXYRect = new GeoXYRect(maxValue, minValue, bottom, top); GeoPolygon geoPolygon = new GeoPolygon(geoXYRect); GeoPolygonRegion polygon = new GeoPolygonRegion(PolygonCreationType.Other); polygon.AddGeoPolygon(geoPolygon); coll = new BlockLTETransceiverColl(); coll.BlockIndex = i; coll.TransceiverExColl = this.m_LteCellFilter.GetCalculateTransceiverInfo(ref allTran, polygon, this.m_Group.Resolution); this.FilterTranByFrequencyBand(coll.TransceiverExColl); this.InitialCalCarriers(coll.TransceiverExColl); this.m_BlockTransceiverExCollArr.Add(coll); } } else { coll = new BlockLTETransceiverColl(); coll.BlockIndex = 0; coll.TransceiverExColl = this.m_CalTansceiverExColl; this.m_BlockTransceiverExCollArr.Add(coll); } }
private static GeoPolygon getPolygonBuffer(GeoPolygon geoPolygon, double angleDistance, int pointsPerCircle, bool allowParallels) { geoPolygon = (GeoPolygon)geoPolygon.Clone(); double minAngle = Math.Sin(Math.Abs(angleDistance)) * Math.Sin(Math.PI / pointsPerCircle); geoPolygon.ReduceSegments(minAngle); geoPolygon.Densify(minAngle); GnomonicProjection projection; IGeometry geometry; projectGeography(geoPolygon, out projection, out geometry); Polygon planePolygon = (Polygon)geometry; Polygon boundaryBuffer = getBoundsBuffer(geoPolygon, projection, angleDistance, pointsPerCircle, allowParallels); ICollection<IGeometry> result; if (angleDistance > 0) result = planePolygon.Union(boundaryBuffer); else result = planePolygon.Difference(boundaryBuffer); GeographyCollection geographyCollection = GeometrySpreader.GetGeographies(result, projection); foreach (IGeography g in geographyCollection) if (g is GeoPolygon) return (GeoPolygon)g; return new GeoPolygon(); }
private GeoPolygonRegion CreateRegion(GisLine line) { GeoPolygonRegion region = new GeoPolygonRegion(true, PolygonCreationType.Union); GeoPolygon geoPolygon = new GeoPolygon(); double num = Math.Atan(line.Slope); double num2 = ((1.5707963267948966 + num) * 3.1415926535897931) / 180.0; for (int i = 0; i < 8; i++) { double a = num2 + (i * 0.39269908169872414); double num5 = (Math.Sin(a) * this.m_WidthOfStrip) / 2.0; double num6 = (Math.Cos(a) * this.m_WidthOfStrip) / 2.0; double x = line.StandardPt.X - num5; double y = line.StandardPt.Y - num6; geoPolygon.Points.Add(new GeoXYPoint(x, y)); } region.AddGeoPolygon(geoPolygon); return region; }
public void ResetStatus() { this.m_StartPlanePoint = new GeoXYPoint(); this.m_OuterBoundPolygon = new GeoPolygon(); this.m_OuterBoundPolygon.IsHollow = false; this.m_CapturePolygon = new GeoPolygon(); this.m_CapturePolygon.IsHollow = true; this.m_CaptureRegion = new GeoPolygonRegion(); this.m_CaptureRegion.AddGeoPolygon(this.m_OuterBoundPolygon); this.m_CaptureRegion.AddGeoPolygon(this.m_CapturePolygon); if (this.m_GlassPanel != null) { this.m_GlassPanel.RemoveVectors(this.m_VectorIdCollection); this.m_VectorIdCollection.Clear(); this.m_GlassPanel.AddPolygonRegion(this.m_CaptureRegion, this.m_RectangleStyle); this.m_VectorIdCollection.Add(this.m_CaptureRegion.ID); } this.m_EventMgr.SendSelectedAreaMsg(null); }
private static GeoPolygon unprojectPolygon(Polygon polygon, GnomonicProjection projection) { GeoPolygon geoPolygon = new GeoPolygon(); foreach (Contour contour in polygon.Contours) { GeoContour geoContour = new GeoContour(); geoContour.Layout = contour.Layout; foreach (ICoordinate p in contour.Vertices) geoContour.Vertices.Add(unprojectPoint(new PointD(p), projection)); geoPolygon.Contours.Add(geoContour); } return geoPolygon; }