private static byte[] CreateMapSynchronized(IPRecord record, int zoomLevel, int desiredWidth, int desiredHeight, string mapFile) { byte[] sourceMapCompressed = File.ReadAllBytes("maps/" + mapFile); byte[] rgb = JpegCodec.Decode(sourceMapCompressed, out int w, out int h); RGBImage image = new RGBImage(rgb, w, h, rgb.Length / h); // Mark the image at the location of the IPRecord TileSystem.LatLongToPixelXY(record.latitude, record.longitude, zoomLevel, out int pixelX, out int pixelY); Color color = Color.Red; image.SetPixel(pixelX, pixelY, color); for (int i = 1; i < 8; i++) { image.SetPixel(pixelX + i, pixelY, color); image.SetPixel(pixelX - i, pixelY, color); image.SetPixel(pixelX, pixelY + i, color); image.SetPixel(pixelX, pixelY - i, color); } // Crop to desired size image = image.SubImage(pixelX - (desiredWidth / 2), pixelY - (desiredHeight / 2), desiredWidth, desiredHeight); byte[] jpegData = JpegCodec.Encode(image.rgb, image.width, image.height, 90); return(jpegData); }
private List <Tile> MakeTileMatrix(int levelOfDetail, List <List <AltitudeResponse> > altitudes) { List <Tile> tileMatrix = new List <Tile>(); foreach (var line in altitudes) { foreach (var point in line) { TileSystem.LatLongToPixelXY(point.Location.Lat, point.Location.Lng, levelOfDetail, out var pixelX, out var pixelY); TileSystem.PixelXYToTileXY(pixelX, pixelY, out var tileX, out var tileY); TileSystem.MapPixelXYToTileInnerPixelXY(pixelX, pixelY, out var tileInnerX, out var tileInnerY); MapPoint mapPoint = new MapPoint(tileInnerX, tileInnerY, point.Elevation); if (mapPoint.Z > 0) { Tile tile = tileMatrix.FirstOrDefault(t => t.TileX == tileX && t.TileY == tileY); if (tile == null) { tile = new Tile(levelOfDetail, tileX, tileY); tileMatrix.Add(tile); } tile.Points.Add(mapPoint); } } } return(tileMatrix); }
public static Vector2Int GetVector2IntPixelCoords(int levelofDetail, double lat, double lng) { TileSystem.LatLongToPixelXY(lat, lng, levelofDetail, out var pixx, out var pixy); var rv = new Vector2Int(pixx, pixy); return(rv); }
public static QkTile GetQktileFromLatLng(LatLng ll, int lod) { TileSystem.LatLongToPixelXY(ll.lat, ll.lng, lod, out var pixx, out var pixy); var vi = new Vector2Int(pixx, pixy); var rv = GetQktileFromPix(vi, lod); return(rv); }
public static Vector2 GetMeterCoords(int levelofDetail, double lat, double lng) { TileSystem.LatLongToPixelXY(lat, lng, levelofDetail, out var pixx, out var pixy); var fak = (float)TileSystem.GroundResolution(lat, levelofDetail); var rv = new Vector2(pixx * fak, pixy * fak); return(rv); }
/// <summary> /// Simple fast grid cluster algorithm with no object location shift /// Find the first object in each grid cell and make it the cluster /// Contains all the other objects in that cell /// </summary> /// <param name="clusterableMapLayerObjects">items to cluster</param> /// <param name="worker">thread to check in cancelled</param> /// <param name="zoomLevel">zoom level of map</param> /// <param name="bounds">The bounds of the map control</param> /// <returns>Was the action cancelled?</returns> private bool GridCluster(IEnumerable <IClusterable> clusterableMapLayerObjects, BackgroundWorker worker, int zoomLevel, LocationRect bounds) { //get width and height from bounds int x1; int x2; int y1; int y2; TileSystem.LatLongToPixelXY(bounds.North, bounds.West, zoomLevel, out x1, out y1); TileSystem.LatLongToPixelXY(bounds.South, bounds.East, zoomLevel, out x2, out y2); double width = Math.Abs(x2 - x1); // Break the map up into a grid var numXCells = (int)Math.Ceiling(width / clusterwidth); // Create an array to store the clusters var clusters = new Dictionary <int, IClusterable>(); foreach (var clusterableMapObject in clusterableMapLayerObjects) { if (clusterableMapObject.Initalized) { //what cluster cell does this belong to? var x = (int)Math.Floor((clusterableMapObject.ProjectedPoints[zoomLevel].X - x1) / clusterwidth); var y = (int)Math.Floor((clusterableMapObject.ProjectedPoints[zoomLevel].Y - y1) / clusterheight); var index = x + y * numXCells; //if this is the first it is the cluster if (!clusters.ContainsKey(index)) { clusters.Add(index, clusterableMapObject); clusterableMapObject.IsCluster = true; } else { //else add to existing cluster clusters[index].ClusteredElements.Add(clusterableMapObject); clusterableMapObject.IsClustered = true; } } else { //listen for event when it is ready clusterableMapObject.ProjectionComplete += (o, e) => { isDirty = true; startMapMovementWorker(); }; } //exit loop if thread cancelled if (worker != null && worker.CancellationPending) { return(false); } } return(true); }
public IEnumerable <Hexagon> ProcessHexagonsFromGeoData(IEnumerable <GeoData> geoData, LayersLoaderTarget[] targets, BoundingBox boundingBox) { foreach (var geo in geoData) { bool intersectsBoundingBox = false; foreach (PointXY[] coordinates in geo.Points) { foreach (PointXY point in coordinates) { //Check if point is outside the specified bounds if (boundingBox == null || point.X > boundingBox.West && point.X < boundingBox.West && point.Y > boundingBox.South && point.Y < boundingBox.North) { intersectsBoundingBox = true; } (point.X, point.Y) = TileSystem.LatLongToPixelXY(point.Y, point.X, hexagonDefinition.ReferenceZoom); } } if (intersectsBoundingBox) { switch (geo.DataType) { case DataType.Area: { foreach (Hexagon hexagon in ProcessArea(geo, targets)) { yield return(hexagon); } break; } case DataType.Path: { foreach (Hexagon hexagon in ProcessPath(geo, targets)) { yield return(hexagon); } break; } case DataType.Pixel: { foreach (Hexagon hexagon in ProcessPixel(geo, targets)) { yield return(hexagon); } break; } } } } }
public void LatLonToPixelXYTest(double lon, double lat, int pixelX, int pixelY, int zoom) { PointXY pixel = new PointXY(); (pixel.X, pixel.Y) = TileSystem.LatLongToPixelXY(lat, lon, zoom); Assert.Equal(pixelX, pixel.X); Assert.Equal(pixelY, pixel.Y); }
public void AddRowLngLat(LegLatLng ll, int lod, double pixToMeters, Vector2d org) { TileSystem.LatLongToPixelXY(ll.lat, ll.lng, lod, out var pixx, out var pixz); var x = pixx * pixToMeters - org.x; var z = pixz * pixToMeters - org.y; mapdata.Add(new LegMapCoordPoint { lng = (float)ll.lng, lat = (float)ll.lat, x = (float)x, z = (float)z }); }
public static RelativePixel GetRelativePixel(double lat, double lon, int zoom) { TileSystem.LatLongToPixelXY(lat, lon, zoom, out int pixelX, out int pixelY); TileSystem.PixelXYToTileXY(pixelX, pixelY, out int tileX, out int tileY); return(new RelativePixel() { pixel = new Point(pixelX - (256 * tileX), pixelY - (256 * tileY)), tile = new Point(tileX, tileY) }); }
public void LatLongToPixelXY_ShouldReturnCorrectPixelXYCoordinates() { double latitude = 14.5995; double longitude = 120.9842; int levelOfDetail = 12; (int pileX, int pileY)expected = (876680, 481296); (int pileX, int pileY)actual = TileSystem.LatLongToPixelXY(latitude, longitude, levelOfDetail); Assert.Equal(expected, actual); }
public Quilt(double latitude1, double longitude1, double latitude2, double longitude2, int maxLevelOfDetail = 23) { TileSystem.LatLongToPixelXY(latitude1, longitude1, maxLevelOfDetail, out int pixelX1, out int pixelY1); TileSystem.LatLongToPixelXY(latitude2, longitude2, maxLevelOfDetail, out int pixelX2, out int pixelY2); quilt = new Bitmap(Math.Abs(pixelX1 - pixelX2), Math.Abs(pixelY1 - pixelY2)); graphics = Graphics.FromImage(quilt); originX = Math.Min(pixelX1, pixelX2); originY = Math.Min(pixelY1, pixelY2); this.maxLevelOfDetail = maxLevelOfDetail; }
private void projectionWorkerDoWork(object sender, DoWorkEventArgs args) { var worker = sender as BackgroundWorker; for (int i = 21; i > 0; i--) { if (worker != null && worker.CancellationPending) { args.Cancel = true; break; } int pixelX; int pixelY; TileSystem.LatLongToPixelXY(Location.Latitude, Location.Longitude, i, out pixelX, out pixelY); ProjectedPoints.Add(i, new Point(pixelX, pixelY)); } Initalized = true; }
/// <summary> /// This will list all the affected assets affected by lightning strikes. /// </summary> /// <returns>A collection of Asset objects.</returns> public List <Asset> ListAffectedAssets() { // This will get the data of lightning strikes. var strikes = _dataContext.Strikes .Where(x => x.FlashType == FlashType.CloudToGround); // This will initialize the quad key collection. var quadKeys = new List <string>(); // This will iterate through the collection of lightning strikes. foreach (var item in strikes) { // This will initialize the required values int pixelX, pixelY, tileX, tileY; // This will convert the inital longitude and latitude value to pixel x and y values. TileSystem.LatLongToPixelXY(item.Latitude, item.Longitude, 12, out pixelX, out pixelY); // This will convert the pixel x and y values to tile x and y values. TileSystem.PixelXYToTileXY(pixelX, pixelY, out tileX, out tileY); // This will convert the tile x and y values to a usable quad key. var quadKey = TileSystem.TileXYToQuadKey(tileX, tileY, 12); // This will determine if the resulting quad key already exists in the collection. if (!quadKeys.Contains(quadKey)) { // This will add the quad key to the quad key collection. quadKeys.Add(quadKey); } } // This will extract the affected assets by their quad key. var affectedAssets = _dataContext.Assets.Where(x => quadKeys.Contains(x.QuadKey)); return(affectedAssets.ToList()); }
internal static void Process(HexagonDataToMapArgs opts) { Stopwatch stopwatch = Stopwatch.StartNew(); HexagonDefinition hexagonDefinition = opts.GetHexagonDefinition(); //1.1. Get Bounding box coordinates BoundingBox bb = null; if (!string.IsNullOrEmpty(opts.Tile)) { string[] tileSegments = opts.Tile.Split(":"); if (tileSegments.Length != 3) { throw new NotSupportedException($"A tile format must be supplied as z:x:y"); } int zoom = int.Parse(tileSegments[0]); int tileX = int.Parse(tileSegments[1]); int tileY = int.Parse(tileSegments[2]); var(pixelXLeft, pixelYTop) = TileSystem.TileXYToPixelXY(tileX, tileY); var(n, w) = TileSystem.PixelXYToLatLong(pixelXLeft, pixelYTop, opts.HexagonReferenceZoom); var(pixelXRight, pixelYBottom) = TileSystem.TileXYToPixelXY(tileX + 1, tileY + 1); var(s, e) = TileSystem.PixelXYToLatLong(pixelXRight, pixelYBottom, opts.HexagonReferenceZoom); bb = new BoundingBox { East = e, West = w, North = n, South = s }; } else if (!string.IsNullOrEmpty(opts.East) && !string.IsNullOrEmpty(opts.West) && !string.IsNullOrEmpty(opts.North) && !string.IsNullOrEmpty(opts.South)) { bb = new BoundingBox { East = double.Parse(opts.East), West = double.Parse(opts.West), North = double.Parse(opts.North), South = double.Parse(opts.South) }; } List <object> hexagons; var hexagonDataReader = new SQLiteHexagonReader(opts.Input); if (bb == null) { hexagons = hexagonDataReader.Read(opts.DataProperties.ToArray()).ToList(); } else { var(left, top) = TileSystem.LatLongToPixelXY(bb.North, bb.West, opts.HexagonReferenceZoom); var(right, bottom) = TileSystem.LatLongToPixelXY(bb.South, bb.East, opts.HexagonReferenceZoom); hexagons = hexagonDataReader.Read(left, right, top, bottom, opts.DataProperties.ToArray()).ToList(); } using (StreamWriter outfile = new StreamWriter(opts.Output)) { GeojsonExporter exporter = new GeojsonExporter(); var result = exporter.GenerateMap(hexagons, hexagonDefinition, opts.HexagonReferenceZoom); outfile.Write(result); } stopwatch.Stop(); Console.WriteLine($"Process took {stopwatch.ElapsedMilliseconds} ms"); }
public static Point LatLonToTileCoordinate(double latitude, double longitude, int zoomFactor) { TileSystem.LatLongToPixelXY(latitude, longitude, zoomFactor, out int pixelX, out int pixelY); TileSystem.PixelXYToTileXY(pixelX, pixelY, out int tileX, out int tileY); return(new Point(tileX, tileY)); }