/// <summary> /// Creates the tile specified by level. /// </summary> /// <param name="level"> /// Zoom level. /// </param> /// <param name="tileX"> /// X tile coordinate. /// </param> /// <param name="tileY"> /// Y tile coordinate. /// </param> public void Create(int level, int tileX, int tileY) { // Pre-compute tables to map from pixel position to global (longitude, latitude). // Map size at this level. double tileSize = (double)(((long)Constants.TileSize) << level); // Compute longitudes across the tile (px = 0 at left edge); double[] longitudes = new double[Constants.TileSize]; long pixelX = checked (tileX * Constants.TileSize); for (int px = 0; px < Constants.TileSize; px++) { double x = ((pixelX + px) + 0.5) / tileSize; longitudes[px] = 360.0 * x - 180.0; } // Compute latitudes across the tile (py = 0 at top edge). double[] latitudes = new double[Constants.TileSize]; long pixelY = checked (tileY * Constants.TileSize); for (int py = 0; py < Constants.TileSize; py++) { double y = 0.5 - (((pixelY + py) + 0.5) / tileSize); latitudes[py] = 90.0 - (360.0 * Math.Atan(Math.Exp(-y * 2.0 * Math.PI)) / Math.PI); } int[] colors = new int[Constants.TileSize * Constants.TileSize]; bool hasData = false; int position = -1; for (int py = 0; py < Constants.TileSize; py++) { for (int px = 0; px < Constants.TileSize; px++) { // Map geo location to an ARGB value. Color color = this.ColorMap.GetColor(longitudes[px], latitudes[py]); // Store and update bit indicating whether actual data is present or not. position++; colors[position] = color.ToArgb(); if (hasData == false) { hasData = (color != Color.Transparent); } } } if (hasData) { TileHelper.ToBitmap(level, tileX, tileY, colors, this.TileSerializer); } colors = null; longitudes = null; latitudes = null; }
/// <summary> /// Creates base tiles and the pyramid. /// </summary> /// <param name="level"> /// Zoom level. /// </param> /// <param name="tileX"> /// X tile coordinate. /// </param> /// <param name="tileY"> /// Y tile coordinate. /// </param> public void Create(int level, int tileX, int tileY) { // Size of the image to extract before scaling it down to (side x side) int tileSize = Constants.TileSize * (int)Math.Pow(2, MaximumLevelsOfDetail - level); Bitmap tile = this.ExtractTile((tileX * tileSize), (tileY * tileSize), tileSize); if (tile != null) { if (tileSize > Constants.TileSize) { tile = TileHelper.ResizeBitmap(tile, Constants.TileSize, Constants.TileSize); } this.TileSerializer.Serialize(tile, level, tileX, tileY); } }
/// <summary> /// Creates a DEM tile creator instance for the specified projection type. /// </summary> /// <param name="map"> /// Color map used. /// </param> /// <param name="projectionType"> /// Projection type desired. /// </param> /// <param name="path"> /// Location where the tiles should be serialized. /// </param> /// <returns> /// ITileCreator instance. /// </returns> public static ITileCreator CreateImageTileCreator(IColorMap map, ProjectionTypes projectionType, string path) { if (map == null) { throw new ArgumentNullException("map"); } if (string.IsNullOrEmpty(path)) { throw new ArgumentNullException("path"); } IImageTileSerializer serializer = new ImageTileSerializer(TileHelper.GetDefaultImageTilePathTemplate(path), ImageFormat.Png); return(CreateImageTileCreator(map, projectionType, serializer)); }
private void Initialize(Bitmap bitmap) { this.imageWidth = bitmap.Width; this.imageHeight = bitmap.Height; // Compute the maximum level of detail that this image supports. // This is a function of size of the image. this.MaximumLevelsOfDetail = TileHelper.CalculateMaximumLevel(this.imageHeight, this.imageWidth, this.inputBoundary); // Get starting pixel values for x and y Helper.LatLongToPixelXY(this.inputBoundary.Bottom, this.inputBoundary.Left, this.MaximumLevelsOfDetail, out startX, out startY); // Get ending pixel values for x and y Helper.LatLongToPixelXY(this.inputBoundary.Top, this.inputBoundary.Right, this.MaximumLevelsOfDetail, out endX, out endY); // Get image data this.imageData = TileHelper.BitmapToBytes(bitmap); }
/// <summary> /// Creates the tile specified by level. /// </summary> /// <param name="level"> /// Zoom level. /// </param> /// <param name="tileX"> /// X tile coordinate. /// </param> /// <param name="tileY"> /// Y tile coordinate. /// </param> public void Create(int level, int tileX, int tileY) { // Map to convert from pixel position to global (longitude, latitude). OctTileMap tileMap = new OctTileMap(level, tileX, tileY); int[] colors = new int[Constants.TileSize * Constants.TileSize]; bool hasData = false; int position = -1; for (int pixelY = 0; pixelY < Constants.TileSize; pixelY++) { for (int pixelX = 0; pixelX < Constants.TileSize; pixelX++) { // Map pixel (u, v) position to (longitude, latitude). double u = (0.5 + pixelX) / ((double)Constants.TileSize); double v = (0.5 + pixelY) / ((double)Constants.TileSize); Vector2d location = tileMap.PointToRaDec(new Vector2d(u, v)); double latitude = location.Y; double longitude = location.X; // For Toast projection, Longitude spans from 0 to +360 and latitude from +90 to -90. // So we need to convert from -180 to +180 => 0 to +360. longitude -= 180.0; // Map geo location to an ARGB value. Color color = this.ColorMap.GetColor(longitude, latitude); // Store and update bit indicating whether actual data is present or not. position++; colors[position] = color.ToArgb(); if (hasData == false) { hasData = (color != Color.Transparent); } } } if (hasData) { TileHelper.ToBitmap(level, tileX, tileY, colors, this.TileSerializer); } colors = null; }
public static void ToBitmap(int level, int tileX, int tileY, int[] values, IImageTileSerializer serializer, IImageTileSerializer referenceImageSerializer) { byte[] referenceImage = null; using (Bitmap image = new Bitmap(Constants.TileSize, Constants.TileSize, PixelFormat.Format32bppArgb)) { // Set the data row by row Rectangle dimension = new Rectangle(0, 0, Constants.TileSize, Constants.TileSize); BitmapData imageData = image.LockBits(dimension, ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb); byte[] rgb = new byte[imageData.Stride]; int position = -1; if (referenceImageSerializer != null) { referenceImage = TileHelper.BitmapToBytes(referenceImageSerializer.Deserialize(level, tileX, tileY)); } for (int pixelY = 0; pixelY < Constants.TileSize; pixelY++) { Array.Clear(rgb, 0, rgb.Length); int pos = 0; Color referenceColor = Color.White; for (int pixelX = 0; pixelX < Constants.TileSize; pixelX++) { Color color = Color.Transparent; position++; if (referenceImage != null) { if (referenceImage != null && referenceImage[(position * 4)] == referenceColor.B && referenceImage[(position * 4) + 1] == referenceColor.G && referenceImage[(position * 4) + 2] == referenceColor.R) { if (values != null) { color = Color.FromArgb(values[position]); } } } else { if (values != null) { color = Color.FromArgb(values[position]); } } rgb[pos++] = color.B; rgb[pos++] = color.G; rgb[pos++] = color.R; rgb[pos++] = color.A; } IntPtr p = new IntPtr(imageData.Scan0.ToInt64() + (pixelY * imageData.Stride)); System.Runtime.InteropServices.Marshal.Copy(rgb, 0, p, rgb.Length); } image.UnlockBits(imageData); if (serializer != null) { serializer.Serialize(image, level, tileX, tileY); } imageData = null; rgb = null; } }
public static void ToBitmap(int level, int tileX, int tileY, int[] values, IImageTileSerializer serializer) { TileHelper.ToBitmap(level, tileX, tileY, values, serializer, null); }
/// <summary> /// Aggregates lower level image tiles to construct upper level tiles. /// </summary> /// <param name="level"> /// Zoom level. /// </param> /// <param name="tileX"> /// X coordinate. /// </param> /// <param name="tileY"> /// Y coordinate. /// </param> public void CreateParent(int level, int tileX, int tileY) { TileHelper.CreateParent(level, tileX, tileY, this.TileSerializer); }