Bing Maps Tile System Bing地图瓦片体系

原文链接：http://msdn.microsoft.com/en-us/library/bb259689.aspx

Bing Maps provides a world map that users can directly manipulate to pan and zoom. To make this interaction as fast and responsive as possible, we chose to pre-render the map at many different levels of detail, and to cut each map into tiles for quick retrieval and display. This document describes the projection, coordinate systems, and addressing scheme of the map tiles, which collectively are called the Bing Maps Tile System.

Bing地图提供了用户可以直接交互的世界地图。为了使地图的交互响应速度进可能的快，

我们选择预渲染不同等级的地图（Lod），并且为了快速检索和显示将地图切割到不同的瓦片

这篇文档描述了投影，坐标系统和地图瓦片的定位方法，这个地图瓦片被称作BMTS，Bing地图瓦片体系。

Map Projection地图投影

To make the map seamless, and to ensure that aerial images from different sources line up properly, we have to use a single projection for the entire world. We chose to use the Mercator projection, which looks like this:

为了实现地图的无缝，保证不同数据源的一系列影像正常的上线，我们不得不给整个世界选择一个统一的投影，这里选择墨卡托投影，形式如下：

Although the Mercator projection significantly distorts scale and area (particularly near the poles), it has two important properties that outweigh the scale distortion:

尽管墨卡托有显著的尺度形变和面积形变（尤其是近极地地区），它有两个比长度形变更重要的属性

  1. It’s a conformal projection, which means that it preserves the shape of relatively small objects. This is especially important when showing aerial imagery, because we want to avoid distorting the shape of buildings. Square buildings should appear square, not rectangular.

它是一个正形投影（等角投影），具有保持形状。这在显示航空影像时是尤其重要的。因为我们想避免建筑物形状的形变。方形的建筑物应该看着是方形的，不是长方形的。

  1. It’s a cylindrical projection, which means that north and south are always straight up and down, and west and east are always straight left and right.

它是圆柱投影，北极和南极总是指向上下。东西总是指向左右。

Since the Mercator projection goes to infinity at the poles, it doesn’t actually show the entire world. Using a square aspect ratio for the map, the maximum latitude shown is approximately 85.05 degrees.

To simplify the calculations, we use the spherical form of this projection, not the ellipsoidal form. Since the projection is used only for map display, and not for displaying numeric coordinates, we don’t need the extra precision of an ellipsoidal projection. The spherical projection causes approximately 0.33% scale distortion in the Y direction, which is not visually noticeable.

因为墨卡托投影在两极地区趋于无限，并不显示整个世界。为地图设定一个square比例，最大的显示纬度接近85.05度。为了简化计算，我们采用球进行投影，不是椭球。由于投影是为了地图的显示，不是为了展示坐标数值，我们没有必要采用高精度的椭球投影。球形投影产生大约0.33%的y方向的长度变形，这不会明显的可以察觉。

Ground Resolution and Map Scale地面分辨率和地图比例尺

In addition to the projection, the ground resolution or map scale must be specified in order to render a map. At the lowest level of detail (Level 1), the map is 512 x 512 pixels. At each successive level of detail, the map width and height grow by a factor of 2: Level 2 is 1024 x 1024 pixels, Level 3 is 2048 x 2048 pixels, Level 4 is 4096 x 4096 pixels, and so on. In general, the width and height of the map (in pixels) can be calculated as:

map width = map height = 256 * 2 level pixels

除了投影之外，为了展示地图，地面分辨率和地图比例尺必须被定义。在最低一级Level1，地图是512x512像素的。在每个Lod系列，地图的宽度和高度按照2倍比例增长：Level2是1024x1024像素，Level3是2048x2048像素，level4是4096x4096像素，依次…通常，宽度和高度的计算公式如下：

The ground resolution indicates the distance on the ground that’s represented by a single pixel in the map. For example, at a ground resolution of 10 meters/pixel, each pixel represents a ground distance of 10 meters. The ground resolution varies depending on the level of detail and the latitude at which it’s measured. Using an earth radius of 6378137 meters, the ground resolution (in meters per pixel) can be calculated as:

ground resolution = cos(latitude * pi/180) * earth circumference / map width

= (cos(latitude * pi/180) * 2 * pi * 6378137 meters) / (256 * 2 level pixels)

地面分辨率指示地图上一个象素代表地面距离。例如，地面分辨率10m/pixel，每个像素代表地面距离10m。地面分辨率变量依赖被量测的Lod和纬度。采用地球半径6378137米，地面分辨率（m/pixel）按如下公式计算：

The map scale indicates the ratio between map distance and ground distance, when measured in the same units. For instance, at a map scale of 1 : 100,000, each inch on the map represents a ground distance of 100,000 inches. Like the ground resolution, the map scale varies with the level of detail and the latitude of measurement. It can be calculated from the ground resolution as follows, given the screen resolution in dots per inch, typically 96 dpi:

map scale = 1 : ground resolution * screen dpi / 0.0254 meters/inch

= 1 : (cos(latitude * pi/180) * 2 * pi * 6378137 * screen dpi) / (256 * 2 level * 0.0254)

地图比例尺是指图上距离和实际距离的比值，以同样的测量单位。

例如，地图比例尺1 : 100,000，每英寸的地图距离代表地面100,000英寸的距离。和地面分辨率一样，地图比例尺随Lod和纬度变化。可以根据地面分辨率计算，方法如下：已知屏幕分辨率每英寸像素点数，一般为96dpi：

This table shows each of these values at each level of detail, as measured at the Equator. (Note that the ground resolution and map scale also vary with the latitude, as shown in the equations above, but not shown in the table below.)

下表显示了不同Lod在地球赤道测量的地面分辨率和比例尺的值。（提醒：地面分辨率和地图比例尺还随纬度变化，如上面的方程那样，但没有在下面的表格中显示。）

Level of Detail

Map Width and Height (pixels)

Ground Resolution (meters / pixel)

Map Scale
(at 96 dpi)

1

512

78,271.5170

1 : 295,829,355.45

2

1,024

39,135.7585

1 : 147,914,677.73

3

2,048

19,567.8792

1 : 73,957,338.86

4

4,096

9,783.9396

1 : 36,978,669.43

5

8,192

4,891.9698

1 : 18,489,334.72

6

16,384

2,445.9849

1 : 9,244,667.36

7

32,768

1,222.9925

1 : 4,622,333.68

8

65,536

611.4962

1 : 2,311,166.84

9

131,072

305.7481

1 : 1,155,583.42

10

262,144

152.8741

1 : 577,791.71

11

524,288

76.4370

1 : 288,895.85

12

1,048,576

38.2185

1 : 144,447.93

13

2,097,152

19.1093

1 : 72,223.96

14

4,194,304

9.5546

1 : 36,111.98

15

8,388,608

4.7773

1 : 18,055.99

16

16,777,216

2.3887

1 : 9,028.00

17

33,554,432

1.1943

1 : 4,514.00

18

67,108,864

0.5972

1 : 2,257.00

19

134,217,728

0.2986

1 : 1,128.50

20

268,435,456

0.1493

1 : 564.25

21

536,870,912

0.0746

1 : 282.12

22

1,073,741,824

0.0373

1 : 141.06

23

2,147,483,648

0.0187

1 : 70.53

Pixel Coordinates像素坐标

Having chosen the projection and scale to use at each level of detail, we can convert geographic coordinates into pixel coordinates. Since the map width and height is different at each level, so are the pixel coordinates. The pixel at the upper-left corner of the map always has pixel coordinates (0, 0). The pixel at the lower-right corner of the map has pixel coordinates (width-1, height-1), or referring to the equations in the previous section, (256 * 2level–1, 256 * 2level–1). For example, at level 3, the pixel coordinates range from (0, 0) to (2047, 2047), like this:

选择了投影和不同Lod的比例尺，我们可以将地理坐标转换到像素坐标。由于每级地图的宽度和高度不同，同样的像素坐标也不相同。左上角的像素坐标总是（0，0）。右下角的地图象素坐标为（width-1,heght-1）,或者参照上一节的方程， 。例如，在Level3，象素坐标的范围是(0.0)到(2047,2047)，如下：

Given latitude and longitude in degrees, and the level of detail, the pixel XY coordinates can be calculated as follows:

sinLatitude = sin(latitude * pi/180)

pixelX = ((longitude + 180) / 360) * 256 * 2 level

pixelY = (0.5 – log((1 + sinLatitude) / (1 – sinLatitude)) / (4 * pi)) * 256 * 2 level

给定经纬度和Lod等级，像素坐标可以按如下方式计算：

The latitude and longitude are assumed to be on the WGS 84 datum. Even though Bing Maps uses a spherical projection, it’s important to convert all geographic coordinates into a common datum, and WGS 84 was chosen to be that datum. The longitude is assumed to range from -180 to +180 degrees, and the latitude must be clipped to range from -85.05112878 to 85.05112878. This avoids a singularity at the poles, and it causes the projected map to be square.

经纬度假定在WGS84基准面。尽管Bing地图采用墨卡托投影，将地理坐标转换到通常的基准面是十分重要的，WGS84被作为基准面。经度范围-180到180，纬度范围必须被裁减在范围(-85.05112878 , 85.05112878)。这样可以避免极地的异常，它使投影的地图为方形的。

Tile Coordinates and Quadkeys瓦片坐标和四叉树键

To optimize the performance of map retrieval and display, the rendered map is cut into tiles of 256 x 256 pixels each. As the number of pixels differs at each level of detail, so does the number of tiles:

map width = map height = 2 level tiles

为了优化地图的检索和显示，渲染地图被切割成256x256像素。不同Lod等级的象素数目不同，同样瓦片数目也不相同：

Each tile is given XY coordinates ranging from (0, 0) in the upper left to (2level–1, 2level–1) in the lower right. For example, at level 3 the tile coordinates range from (0, 0) to (7, 7) as follows:

每个瓦片给定xy坐标范围左上角(0, 0)，右下角(2level–1, 2level–1)。例如Level3的瓦片坐标范围(0, 0)到(7, 7)

Given a pair of pixel XY coordinates, you can easily determine the tile XY coordinates of the tile containing that pixel:

tileX = floor(pixelX / 256)

tileY = floor(pixelY / 256)

给定一组像素坐标XY，可以容易的计算包含该像素的瓦片的xy坐标。

To optimize the indexing and storage of tiles, the two-dimensional tile XY coordinates are combined into one-dimensional strings called quadtree keys, or “quadkeys” for short. Each quadkey uniquely identifies a single tile at a particular level of detail, and it can be used as an key in common database B-tree indexes. To convert tile coordinates into a quadkey, the bits of the Y and X coordinates are interleaved, and the result is interpreted as a base-4 number (with leading zeros maintained) and converted into a string. For instance, given tile XY coordinates of (3, 5) at level 3, the quadkey is determined as follows:

tileX = 3 = 011 2

tileY = 5 = 101 2

quadkey = 100111 2 = 213 4 = “213”

为了优化瓦片存储的索引，二维的瓦片坐标被包含在一维的字符串中，称为“四叉树键”，或者简称“四叉键”。每个四叉键唯一的定义了在特定Lod级别的一个瓦片，可以被用来作为通用数据库的b-tree索引。为了将瓦片坐标转换到四叉键，y和x坐标的位是隔行读取的，结果形成了4进制数，转换成字符串。例如，给定xy坐标(3, 5) 等级level 3，四叉键为下值：

Quadkeys have several interesting properties. First, the length of a quadkey (the number of digits) equals the level of detail of the corresponding tile. Second, the quadkey of any tile starts with the quadkey of its parent tile (the containing tile at the previous level). As shown in the example below, tile 2 is the parent of tiles 20 through 23, and tile 13 is the parent of tiles 130 through 133:

四叉键有一些有趣的属性。

首先，四叉键的长度等于Lod对应的瓦片等级。

第二，任何瓦片的四叉键开始于其父亲瓦片的四叉键。如下所示，瓦片2是瓦片20到23的父节点，瓦片13是瓦片130到133的父节点。

Finally, quadkeys provide a one-dimensional index key that usually preserves the proximity of tiles in XY space. In other words, two tiles that have nearby XY coordinates usually have quadkeys that are relatively close together. This is important for optimizing database performance, because neighboring tiles are usually requested in groups, and it’s desirable to keep those tiles on the same disk blocks, in order to minimize the number of disk reads.

最后，四叉键提供了一维的索引键，通常保存了邻近瓦片的XY空间。换言之，两个瓦片具有相邻的xy坐标通常具有相邻的四叉键。这对于优化数据库性能十分重要，因为相邻的瓦片通常会作为组进行请求，这样的描述可以保证这些瓦片在相同的硬盘块，减少磁盘的读取次数。

Sample Code

The following sample C# code illustrates how to implement the functions described in this document. These functions can be easily translated into other programming languages as needed.

如下的C# 代码阐述了如何实现本文的方法，这些方法可以很容易的转换到其他语言。

  1 //------------------------------------------------------------------------------
  2
  3 // <copyright company="Microsoft">
  4
  5 //     Copyright (c) 2006-2009 Microsoft Corporation.  All rights reserved.
  6
  7 // </copyright>
  8
  9 //------------------------------------------------------------------------------
 10
 11
 12
 13 using System;
 14
 15 using System.Text;
 16
 17
 18
 19 namespace Microsoft.MapPoint
 20
 21 {
 22
 23     static class TileSystem
 24
 25     {
 26
 27         private const double EarthRadius = 6378137;
 28
 29         private const double MinLatitude = -85.05112878;
 30
 31         private const double MaxLatitude = 85.05112878;
 32
 33         private const double MinLongitude = -180;
 34
 35         private const double MaxLongitude = 180;
 36
 37
 38
 39
 40
 41         /// <summary>
 42
 43         /// Clips a number to the specified minimum and maximum values.
 44
 45         /// </summary>
 46
 47         /// <param name="n">The number to clip.</param>
 48
 49         /// <param name="minValue">Minimum allowable value.</param>
 50
 51         /// <param name="maxValue">Maximum allowable value.</param>
 52
 53         /// <returns>The clipped value.</returns>
 54
 55         private static double Clip(double n, double minValue, double maxValue)
 56
 57         {
 58
 59             return Math.Min(Math.Max(n, minValue), maxValue);
 60
 61         }
 62
 63
 64
 65
 66
 67
 68
 69         /// <summary>
 70
 71         /// Determines the map width and height (in pixels) at a specified level
 72
 73         /// of detail.
 74
 75         /// </summary>
 76
 77         /// <param name="levelOfDetail">Level of detail, from 1 (lowest detail)
 78
 79         /// to 23 (highest detail).</param>
 80
 81         /// <returns>The map width and height in pixels.</returns>
 82
 83         public static uint MapSize(int levelOfDetail)
 84
 85         {
 86
 87             return (uint) 256 << levelOfDetail;
 88
 89         }
 90
 91
 92
 93
 94
 95
 96
 97         /// <summary>
 98
 99         /// Determines the ground resolution (in meters per pixel) at a specified
100
101         /// latitude and level of detail.
102
103         /// </summary>
104
105         /// <param name="latitude">Latitude (in degrees) at which to measure the
106
107         /// ground resolution.</param>
108
109         /// <param name="levelOfDetail">Level of detail, from 1 (lowest detail)
110
111         /// to 23 (highest detail).</param>
112
113         /// <returns>The ground resolution, in meters per pixel.</returns>
114
115         public static double GroundResolution(double latitude, int levelOfDetail)
116
117         {
118
119             latitude = Clip(latitude, MinLatitude, MaxLatitude);
120
121             return Math.Cos(latitude * Math.PI / 180) * 2 * Math.PI * EarthRadius / MapSize(levelOfDetail);
122
123         }
124
125
126
127
128
129
130
131         /// <summary>
132
133         /// Determines the map scale at a specified latitude, level of detail,
134
135         /// and screen resolution.
136
137         /// </summary>
138
139         /// <param name="latitude">Latitude (in degrees) at which to measure the
140
141         /// map scale.</param>
142
143         /// <param name="levelOfDetail">Level of detail, from 1 (lowest detail)
144
145         /// to 23 (highest detail).</param>
146
147         /// <param name="screenDpi">Resolution of the screen, in dots per inch.</param>
148
149         /// <returns>The map scale, expressed as the denominator N of the ratio 1 : N.</returns>
150
151         public static double MapScale(double latitude, int levelOfDetail, int screenDpi)
152
153         {
154
155             return GroundResolution(latitude, levelOfDetail) * screenDpi / 0.0254;
156
157         }
158
159
160
161
162
163
164
165         /// <summary>
166
167         /// Converts a point from latitude/longitude WGS-84 coordinates (in degrees)
168
169         /// into pixel XY coordinates at a specified level of detail.
170
171         /// </summary>
172
173         /// <param name="latitude">Latitude of the point, in degrees.</param>
174
175         /// <param name="longitude">Longitude of the point, in degrees.</param>
176
177         /// <param name="levelOfDetail">Level of detail, from 1 (lowest detail)
178
179         /// to 23 (highest detail).</param>
180
181         /// <param name="pixelX">Output parameter receiving the X coordinate in pixels.</param>
182
183         /// <param name="pixelY">Output parameter receiving the Y coordinate in pixels.</param>
184
185         public static void LatLongToPixelXY(double latitude, double longitude, int levelOfDetail, out int pixelX, out int pixelY)
186
187         {
188
189             latitude = Clip(latitude, MinLatitude, MaxLatitude);
190
191             longitude = Clip(longitude, MinLongitude, MaxLongitude);
192
193
194
195             double x = (longitude + 180) / 360;
196
197             double sinLatitude = Math.Sin(latitude * Math.PI / 180);
198
199             double y = 0.5 - Math.Log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * Math.PI);
200
201
202
203             uint mapSize = MapSize(levelOfDetail);
204
205             pixelX = (int) Clip(x * mapSize + 0.5, 0, mapSize - 1);
206
207             pixelY = (int) Clip(y * mapSize + 0.5, 0, mapSize - 1);
208
209         }
210
211
212
213
214
215
216
217         /// <summary>
218
219         /// Converts a pixel from pixel XY coordinates at a specified level of detail
220
221         /// into latitude/longitude WGS-84 coordinates (in degrees).
222
223         /// </summary>
224
225         /// <param name="pixelX">X coordinate of the point, in pixels.</param>
226
227         /// <param name="pixelY">Y coordinates of the point, in pixels.</param>
228
229         /// <param name="levelOfDetail">Level of detail, from 1 (lowest detail)
230
231         /// to 23 (highest detail).</param>
232
233         /// <param name="latitude">Output parameter receiving the latitude in degrees.</param>
234
235         /// <param name="longitude">Output parameter receiving the longitude in degrees.</param>
236
237         public static void PixelXYToLatLong(int pixelX, int pixelY, int levelOfDetail, out double latitude, out double longitude)
238
239         {
240
241             double mapSize = MapSize(levelOfDetail);
242
243             double x = (Clip(pixelX, 0, mapSize - 1) / mapSize) - 0.5;
244
245             double y = 0.5 - (Clip(pixelY, 0, mapSize - 1) / mapSize);
246
247
248
249             latitude = 90 - 360 * Math.Atan(Math.Exp(-y * 2 * Math.PI)) / Math.PI;
250
251             longitude = 360 * x;
252
253         }
254
255
256
257
258
259
260
261         /// <summary>
262
263         /// Converts pixel XY coordinates into tile XY coordinates of the tile containing
264
265         /// the specified pixel.
266
267         /// </summary>
268
269         /// <param name="pixelX">Pixel X coordinate.</param>
270
271         /// <param name="pixelY">Pixel Y coordinate.</param>
272
273         /// <param name="tileX">Output parameter receiving the tile X coordinate.</param>
274
275         /// <param name="tileY">Output parameter receiving the tile Y coordinate.</param>
276
277         public static void PixelXYToTileXY(int pixelX, int pixelY, out int tileX, out int tileY)
278
279         {
280
281             tileX = pixelX / 256;
282
283             tileY = pixelY / 256;
284
285         }
286
287
288
289
290
291
292
293         /// <summary>
294
295         /// Converts tile XY coordinates into pixel XY coordinates of the upper-left pixel
296
297         /// of the specified tile.
298
299         /// </summary>
300
301         /// <param name="tileX">Tile X coordinate.</param>
302
303         /// <param name="tileY">Tile Y coordinate.</param>
304
305         /// <param name="pixelX">Output parameter receiving the pixel X coordinate.</param>
306
307         /// <param name="pixelY">Output parameter receiving the pixel Y coordinate.</param>
308
309         public static void TileXYToPixelXY(int tileX, int tileY, out int pixelX, out int pixelY)
310
311         {
312
313             pixelX = tileX * 256;
314
315             pixelY = tileY * 256;
316
317         }
318
319
320
321
322
323
324
325         /// <summary>
326
327         /// Converts tile XY coordinates into a QuadKey at a specified level of detail.
328
329         /// </summary>
330
331         /// <param name="tileX">Tile X coordinate.</param>
332
333         /// <param name="tileY">Tile Y coordinate.</param>
334
335         /// <param name="levelOfDetail">Level of detail, from 1 (lowest detail)
336
337         /// to 23 (highest detail).</param>
338
339         /// <returns>A string containing the QuadKey.</returns>
340
341         public static string TileXYToQuadKey(int tileX, int tileY, int levelOfDetail)
342
343         {
344
345             StringBuilder quadKey = new StringBuilder();
346
347             for (int i = levelOfDetail; i > 0; i--)
348
349             {
350
351                 char digit = '0';
352
353                 int mask = 1 << (i - 1);
354
355                 if ((tileX & mask) != 0)
356
357                 {
358
359                     digit++;
360
361                 }
362
363                 if ((tileY & mask) != 0)
364
365                 {
366
367                     digit++;
368
369                     digit++;
370
371                 }
372
373                 quadKey.Append(digit);
374
375             }
376
377             return quadKey.ToString();
378
379         }
380
381
382
383
384
385
386
387         /// <summary>
388
389         /// Converts a QuadKey into tile XY coordinates.
390
391         /// </summary>
392
393         /// <param name="quadKey">QuadKey of the tile.</param>
394
395         /// <param name="tileX">Output parameter receiving the tile X coordinate.</param>
396
397         /// <param name="tileY">Output parameter receiving the tile Y coordinate.</param>
398
399         /// <param name="levelOfDetail">Output parameter receiving the level of detail.</param>
400
401         public static void QuadKeyToTileXY(string quadKey, out int tileX, out int tileY, out int levelOfDetail)
402
403         {
404
405             tileX = tileY = 0;
406
407             levelOfDetail = quadKey.Length;
408
409             for (int i = levelOfDetail; i > 0; i--)
410
411             {
412
413                 int mask = 1 << (i - 1);
414
415                 switch (quadKey[levelOfDetail - i])
416
417                 {
418
419                     case '0':
420
421                         break;
422
423
424
425                     case '1':
426
427                         tileX |= mask;
428
429                         break;
430
431
432
433                     case '2':
434
435                         tileY |= mask;
436
437                         break;
438
439
440
441                     case '3':
442
443                         tileX |= mask;
444
445                         tileY |= mask;
446
447                         break;
448
449
450
451                     default:
452
453                         throw new ArgumentException("Invalid QuadKey digit sequence.");
454
455                 }
456
457             }
458
459         }
460
461     }
462
463 }

View Code

翻译：Bing地图瓦片体系相关推荐

  1. Bing地图瓦片体系

    Bing地图瓦片体系称作BMTS. Bing使用墨卡托投影. 为了优化地图的检索和显示,渲染地图被切割成256x256像素.不同Lod等级的象素数目不同,同样瓦片数目也不相同: 每个瓦片给定xy坐标范 ...

  2. python下载谷歌地图瓦片_python获取bing地图发布自己的TMS服务（一）下载瓦片

    部分结果 bing地图瓦片使用QuadKey作为命名方式. QuadKey简介 如何计算quadkey 在给定level下,把行号tileY和列号tileX转换为2进制,然后行列交叉存储,再转换为4进 ...

  3. Bing地图切片原理

    Bing地图切片系统 Bing地图提供了一个可以直接平移和缩放的世界地图.为了让地图操作更加平滑和及时响应,我们选择提前渲染地图不同层级的细节,并把每个层级的地图切割成为瓦片以便快速的还原展示.这篇文 ...

  4. GIS开发二：批量下载和拼接地图瓦片

    文章目录 1.简介 1.1 Web墨卡托投影 1.2 经纬度坐标系 1.3 瓦片定义 1.4 瓦片编号 1.5 瓦片和像素 1.6 瓦片计算公式 1.7 网络地图服务(WMS) 1.8 切片地图服务( ...

  5. 地图瓦片相关学习总结

    瓦片地图 瓦片地图金字塔模型是一种多分辨率层次模型,从瓦片金字塔的底层到顶层,分辨率越来越低,但表示 的地理范围不变. 中文名 瓦片地图 模    型层次模型 软    件ArcGIS软件 发     ...

  6. 高德地图加载谷歌地图瓦片

    简介 苦逼外业实验需要用到无人机采集数据,遂利用高德地图SDK和DJI Mobile SDK开发了一款无人机航线规划软件.当地也不算偏僻,然而高德卫星地图缩放等级约为16,无法满足作业需求.调查了其他 ...

  7. 谷歌地图离线地图瓦片下载_如何下载Google地图以供离线使用

    谷歌地图离线地图瓦片下载 If you've ever wanted to be able to download Google Maps data for offline use, you shou ...

  8. 地图瓦片切片方案汇总

    文章目录 前言 地图切片 主流切片方案 谷歌XYZ TMS QuadTree 百度XYZ 天地图 总结 前言 我们日常使用的地图都是经过web墨卡托(参考这里)形成的平面地图,地图就变为平面的一张地图 ...

  9. Google地图瓦片拼图算法解析

    Google地图瓦片拼图算法解析 概述:主要是阐述如何将瓦片地图图片拼接成完整地图的一些概念以及相关算法. 基本概念: 地图瓦片地址:http://mt2.google.cn/vt/lyrs=m@16 ...

最新文章

  1. js 上传头像img
  2. 威纶通触摸屏与仪表通讯_西门子S7-200PLC与威纶通HMI的通信案例
  3. 索尼笔记本如何进Bios设置U盘启动
  4. 并不对劲的bzoj5475:loj2983:p5206:[wc2019]数树
  5. 阻止SPY++类似的程序捕捉软件窗口
  6. demo12 webpack 处理 scss
  7. 【都挺好】追求一生的科技住宅原来在这！
  8. 听说面试很少有人答出：距离最近点对问题
  9. 3款强大的BootStrap的可视化制作工具推荐
  10. 限制firefox上传框宽度
  11. c md5加密 和java不一样_C#的MD5加密为什么和JAVA的加密出来的结果不一样？
  12. C++ 链表结构的常用操作（单链表）
  13. 在自动驾驶技术上，一向自信满满的马斯克也承认了特斯拉的不足
  14. 以虎嗅网4W+文章的文本挖掘为例，展现数据分析的一整套流程
  15. 《活法》读后感--发paper思想准备
  16. CSS高级常用应用技巧汇总
  17. 紫外 LED 灯生产厂家调研
  18. allegro 对齐元器件_Allegro怎么对元器件进行对齐？
  19. 通过access口加vlan标签吗_7.3.2 将Access端口添加到VLAN中
  20. win7开机黑屏只有鼠标怎么办？

热门文章

  1. Fiddler 模拟网络限速
  2. react+antd，关于使用loding的加载前后实现方式
  3. 《FreeSWITCH: VoIP实战》：FreeSWITCH 初步
  4. 如何看待Meta（恺明）最新论文ViTDet：如何看待Meta（恺明）论文ViTDet：只用ViT做backbone的检测模型？...
  5. java 特殊字符 乱码_Java中文乱码特殊字符解决方案
  6. mysql-5.0.83删除_【实验】WindowsXP + MySQL5 + Apache2 + PHP5 + phpMyAdmin环境搭建
  7. 将已经在git仓库的文件从仓库中移除，但在本地保留
  8. RAID卡的接口类型：IDE SCSI SATA SAS
  9. 2021年汽车修理工（初级）报名考试及汽车修理工（初级）最新解析
  10. 怎样在 Android 上手动备份你的短信/彩信？