def create_image_url_v2(minlon, minlat, maxlon, maxlat, minzoom, maxzoom,
basetileurl, rootpath):
for zoom in range(minzoom, maxzoom + 1):
mintile = Tile.for_latitude_longitude(latitude=minlat,
longitude=minlon,
zoom=zoom)
maxtile = Tile.for_latitude_longitude(latitude=maxlat,
longitude=maxlon,
zoom=zoom)
print('mintile', 'X:', mintile.tms_x, 'Y:', mintile.tms_y, 'zoom:',
mintile.zoom)
print('maxtile', 'Y:', maxtile.tms_x, 'Y:', maxtile.tms_y, 'zoom:',
maxtile.zoom)
mintms_x, mintms_y = mintile.tms_x, mintile.tms_y
maxtms_x, maxtms_y = maxtile.tms_x, maxtile.tms_y
create_image_path(rootpath, zoom)
imagelists = []
for x in range(mintms_x, maxtms_x + 1):
for y in range(maxtms_y, mintms_y + 1):
savepath = './%s/%d/%d_%d.png' % (rootpath, zoom, x, y)
tileurl = basetileurl + '&x=%d&y=%d&z=%d' % (x, y, zoom)
imagelists.append((tileurl, savepath))
return imagelists
def main():
shp_df = gpd.GeoDataFrame.from_file(shp_file, encoding='utf-8')
base_df = gpd.GeoDataFrame.from_file(base_file, encoding='utf-8')
base_df['coords'] = base_df['geometry'].apply(
lambda x: x.representative_point().coords[:])
base_df['coords'] = [coords[0] for coords in base_df['coords']]
shp_df['coords'] = shp_df['geometry'].apply(
lambda x: x.representative_point().coords[:])
shp_df['coords'] = [coords[0] for coords in shp_df['coords']]
im_list = []
for zoom in range(min_zoom, max_zoom + 1):
print("----- genrate {} image -----".format(zoom))
right_buttom_tile = Tile.for_latitude_longitude(latitude=-22.380080,
longitude=115.425220,
zoom=zoom)
left_top_tile = Tile.for_latitude_longitude(latitude=-23.966600,
longitude=113.816970,
zoom=zoom)
mintms_x, mintms_y = left_top_tile.tms_x, left_top_tile.tms_y
maxtms_x, maxtms_y = right_buttom_tile.tms_x, right_buttom_tile.tms_y
im = genrate_im(base_df,
shp_df,
mintms_x,
maxtms_x,
mintms_y,
maxtms_y,
zoom,
fontsize=18,
plt_dpi=plt_dpi)
save_path = "./tile/tile_{}".format(zoom)
im_list.append(
(im, mintms_x, maxtms_x, mintms_y, maxtms_y, zoom, save_path))
print("----- end {} -----".format(zoom))
del base_df
del shp_df
gc.collect()
start = time.perf_counter()
loop = asyncio.get_event_loop()
print("----- start -----")
tasks = []
for im, mintms_x, maxtms_x, mintms_y, maxtms_y, zoom, save_path in im_list:
print("------------------------")
#task = loop.create_task(genrate_tile(im, mintms_x, maxtms_x, mintms_y, maxtms_y, zoom, save_path))
tasks.append(
asyncio.ensure_future(
genrate_tile(im, mintms_x, maxtms_x, mintms_y, maxtms_y, zoom,
save_path)))
print("---- end ----")
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
# asyncio.run(handler(im_list)) # python 3.7 support
print("Cost {} s".format(time.perf_counter() - start))
def _get_quadrant_tiles(tile):
"""Return indicies of tiles at one higher zoom (in TMS tiling scheme)"""
ul = (tile.tms[0] * 2, tile.tms[1] * 2)
return [Tile.from_tms(ul[0], ul[1], tile.zoom + 1), # UL
Tile.from_tms(ul[0], ul[1] + 1, tile.zoom + 1), # LL
Tile.from_tms(ul[0] + 1, ul[1], tile.zoom + 1), # UR
Tile.from_tms(ul[0] + 1, ul[1] + 1, tile.zoom + 1)] # LR
def test_roundtrip():
zoom_level = 18
t = Tile.from_tms(139423, 171197, zoom_level)
minx, maxy = t.bounds[0].pixels(zoom_level)
maxx, miny = t.bounds[1].pixels(zoom_level)
p = Point.from_pixel(maxx, maxy, zoom=zoom_level)
mx, my = p.meters
t2 = Tile.for_meters(mx, my, zoom_level)
assert t.quad_tree == t2.quad_tree
def test_get_quadrant_tiles(self):
"""Test ability to get tile children on level of increased zoom."""
tile = Tile.from_google(0, 0, 0)
child_tiles = _get_quadrant_tiles(tile)
self.assertEqual(child_tiles, [
Tile.from_google(0, 0, 1),
Tile.from_google(0, 1, 1),
Tile.from_google(1, 0, 1),
Tile.from_google(1, 1, 1)
])
def get_quadrant_tiles(tile):
"""Return indicies of tiles at one higher zoom (in google tiling scheme)"""
ul = (tile.google[0] * 2, tile.google[1] * 2)
return [
Tile.from_google(ul[0], ul[1], tile.zoom + 1), # UL
Tile.from_google(ul[0], ul[1] + 1, tile.zoom + 1), # LL
Tile.from_google(ul[0] + 1, ul[1], tile.zoom + 1), # UR
Tile.from_google(ul[0] + 1, ul[1] + 1, tile.zoom + 1)
] # LR
def test_finding_child_tiles(self):
"""Check if 4 correct child tiles can be found from a parent tile."""
parent_tile = Tile.from_tms(1412, 3520, 17)
ground_truth = [
Tile.from_tms(x, y, z)
for x, y, z in [(2825, 7041, 18), (2825, 7040,
18), (2824, 7041,
18), (2824, 7040, 18)]
]
children_tiles = _get_quadrant_tiles(parent_tile)
self.assertCountEqual(ground_truth, children_tiles)
def get_tiles_bbox(tms_bbox: Tuple[int, int, int, int], zoom: int) -> Tuple[float, float, float, float]:
# language=rst
"""
Returns bbox of geo coordinates for tiles from tms_bbox area
:param tms_bbox: area of the tms coordinates in the form of:
`(min_x, min_y, max_x, max_y)`
:param zoom:
:return: bbox of geo coordinates in the form: `(min_lat, min_lon, max_lat, max_lon)`
"""
points = Tile.from_tms(*tms_bbox[:2], zoom).bounds + Tile.from_tms(*tms_bbox[2:], zoom).bounds
latitudes, longitudes = zip(*(p.latitude_longitude for p in points))
return min(latitudes), min(longitudes), max(latitudes), max(longitudes)
def georeference(self):
"""
:return:
"""
print('Georeferencing ...')
# tile_start = Tile.for_latitude_longitude(self.lat_start, self.lon_start, self.zoom)
# tile_stop = Tile.for_latitude_longitude(self.lat_stop, self.lon_stop, self.zoom)
Xs, Ys = self.tiles_in_dir()
start_x, start_y = min(Xs), min(Ys)
stop_x, stop_y = max(Xs), max(Ys)
tile_start = Tile.from_google(start_x, start_y, self.zoom)
tile_stop = Tile.from_google(stop_x, stop_y, self.zoom)
point_start = Point.from_latitude_longitude(
max(tile_start.bounds[0][0], tile_start.bounds[1][0]),
min(tile_start.bounds[0][1], tile_start.bounds[1][1]))
point_stop = Point.from_latitude_longitude(
min(tile_stop.bounds[0][0], tile_stop.bounds[1][0]),
max(tile_stop.bounds[0][1], tile_stop.bounds[1][1]))
# print(point_start.meters, point_stop.meters)
if 'bing' in self.map or 'google' in self.map:
a_srs = 'EPSG:3857'
else:
a_srs = 'EPSG:4326'
# Georeferencing
os.system(
"gdal_translate -of GTiff -co BIGTIFF=YES -co NUM_THREADS=8 -a_ullr "
+ str(point_start.meters[0]) + " " + str(point_start.meters[1]) +
" " + str(point_stop.meters[0]) + " " + str(point_stop.meters[1]) +
" " + "-a_srs " + a_srs + " " + self.map + "_" + self.mode +
"_stitched.tif result.tif")
# warping with conversion to RGBA
# --config GDAL_CACHEMAX 32000 - wm 1500
os.system(
"gdalwarp -dstalpha -srcnodata 0 -dstnodata 0 -overwrite -wo NUM_THREADS=8 "
+ "-co COMPRESS=PACKBITS -co BIGTIFF=YES " + "-s_srs " + a_srs +
" -t_srs EPSG:4326 result.tif " + self.map + "_" + self.mode +
"_gcps.tif")
os.remove('result.tif')
print('Georeferencing Complete!')
def test_cross_check(tms, google, quad_tree, zoom):
tile = Tile.from_quad_tree(quad_tree=quad_tree)
assert tile.tms == tms
assert tile.zoom == zoom
assert tile.google == google
assert tile.quad_tree == quad_tree
def get_bbox_in_tms(bbox: Tuple[float, float, float, float], zoom: int) -> Tuple[int, int, int, int]:
# language=rst
"""
Returns tms coordinates of the tiles bbox
:param bbox: area of the geo coordinates in the form of:
`(min_lat, min_lon, max_lat, max_lon)`
:param zoom:
:return: bbox of tms tile coordinates in the form: `(min_x, min_y, max_x, max_y)`
"""
tile1 = Tile.for_latitude_longitude(*bbox[:2], zoom)
tile2 = Tile.for_latitude_longitude(*bbox[2:], zoom)
min_x, max_x = sorted([tile1.tms_x, tile2.tms_x])
min_y, max_y = sorted([tile1.tms_y, tile2.tms_y])
return min_x, min_y, max_x, max_y
def test_pixel_bounds_chicago(chicago_quad_tree, chicago_pixel_bounds):
tile = Tile.from_quad_tree(chicago_quad_tree)
point_min, point_max = tile.bounds
assert chicago_pixel_bounds[0] == point_min.pixels(zoom=tile.zoom)
assert chicago_pixel_bounds[1] == point_max.pixels(zoom=tile.zoom)
def _tile_at(point, zoom):
"""Return the map tile located at the given point in Spherical
Mercator coordinates with the specified zoom level.
"""
point = PyGeoPoint.from_meters(point[0], point[1])
tile = PyGeoTile.for_point(point, zoom)
return tile.google
def _merge_tiles(path: Union[Path, str], tiles_dir: Union[Path, str],
tms_bbox: Tuple[int, int, int, int], zoom: int,
tiles_format: ImageFormat) -> None:
# language=rst
"""
Merge tiles from `tms_bbox` area from `tiles_dir` with `zoom` zoomlevel and `tiles_format` image format
in image file with `path` without georeference
:param path:
:param tiles_dir:
:param tms_bbox: area of the tms coordinates in the form of:
`(min_x, min_y, max_x, max_y)`
:param zoom:
:param tiles_format:
:return:
"""
min_x, min_y, max_x, max_y = tms_bbox
rows = list()
for y in range(max_y, min_y - 1, -1):
row = list()
for x in range(min_x, max_x + 1):
tile_path = get_filename(Tile.from_tms(x, y, zoom), tiles_format,
tiles_dir)
row.append(cv2.imread(str(tile_path)))
row_img = cv2.hconcat(row)
rows.append(row_img)
data = cv2.vconcat(rows)
cv2.imwrite(path, data)
def test_assert_google_y(google_y, zoom):
google_x = 0
with pytest.raises(AssertionError) as assertion_info:
_ = Tile.from_google(google_x=google_x, google_y=google_y, zoom=zoom)
assert 'Google Y needs to be a value between 0 and (2^zoom) -1.' in str(
assertion_info.value)
def test_for_latitude_longitude(chicago_latitude_longitude, chicago_zoom,
chicago_tms):
latitude, longitude = chicago_latitude_longitude
tile = Tile.for_latitude_longitude(latitude=latitude,
longitude=longitude,
zoom=chicago_zoom)
assert tile.tms == chicago_tms
def test_for_point(chicago_latitude_longitude, chicago_zoom, chicago_tms):
latitude, longitude = chicago_latitude_longitude
point = Point.from_latitude_longitude(latitude=latitude,
longitude=longitude)
tile = Tile.for_point(point=point, zoom=chicago_zoom)
assert tile.tms == chicago_tms
assert tile.zoom == chicago_zoom
def test_assert_tms_y(tms_y, zoom):
tms_x = 0
with pytest.raises(AssertionError) as assertion_info:
_ = Tile.from_tms(tms_x=tms_x, tms_y=tms_y, zoom=zoom)
assert 'TMS Y needs to be a value between 0 and (2^zoom) -1.' in str(
assertion_info.value)
def test_georeference():
tile = Tile.from_tms(139423, 171197, 18)
img_path = os.path.join(os.getcwd(), "test", "data", "18_139423_171197.tif")
m = MarchingSquares.from_file(img_path)
points = m.find_contour()
geo_points = georeference(points, tile)
p = geometry.Polygon(geo_points)
print(p.wkt)
assert p.wkt == "POLYGON ((11.46890044212341 48.1641425687818, 11.46890580654145 48.1641425687818, 11.46890580654145 48.16404238298088, 11.46879851818085 48.16404238298088, 11.46879851818085 48.16413899072083, 11.46890044212341 48.16413899072083, 11.46890044212341 48.1641425687818))"
def _build_tile_url(
url_format: UrlFormat, url_template: str, z: int, x: int, y: int
) -> str:
if url_format == UrlFormat.QUADKEY:
return url_template.format(
q=Tile.from_google(google_x=x, google_y=y, zoom=z).quad_tree
)
if url_format == UrlFormat.XYZ:
return url_template.format(z=z, x=x, y=y)
def qt_convert(lat, lng, zoom=19):
'''
lat, lng, zoom=18(default)
'''
from pygeotile.tile import Tile
try:
return Tile.for_latitude_longitude(lat, lng, zoom=zoom).quad_tree
except:
pass
def test_for_meters_chicago(chicago_pixel, chicago_zoom, chicago_tms):
pixel_x, pixel_y = chicago_pixel
point = Point.from_pixel(pixel_x=pixel_x,
pixel_y=pixel_y,
zoom=chicago_zoom)
meter_x, meter_y = point.meters
tile = Tile.for_meters(meter_x=meter_x, meter_y=meter_y, zoom=chicago_zoom)
assert tile.tms == chicago_tms
def tile_cover(geometry, z):
import geopandas as gpd
from supermercado import burntiles, super_utils
from pygeotile.tile import Tile
geo = gpd.GeoSeries([geometry]).__geo_interface__['features'][0]
geo = [f for f in super_utils.filter_polygons([geo])]
return [
Tile.from_google(*geo).quad_tree
for geo in [f for f in burntiles.burn(geo, z)]
]
def tile_to_geo_boundary(key):
a = Tile.from_quad_tree(key)
return ("Polygon ((" + f"{a.bounds[0].longitude}" + " " +
f"{a.bounds[0].latitude}" + "," + f"{a.bounds[0].longitude}" +
" " + f"{a.bounds[1].latitude}" + "," +
f"{a.bounds[1].longitude}" + " " + f"{a.bounds[1].latitude}" +
"," + f"{a.bounds[1].longitude}" + " " +
f"{a.bounds[0].latitude}" + "," + f"{a.bounds[0].longitude}" +
" " + f"{a.bounds[0].latitude}" + "))")
def test_string_output(self):
"""Test that tile details are correctly printed."""
tile = Tile.from_google(3, 1, 2)
self.assertEqual(format_tile(tile, 'google'), '3 1 2')
self.assertEqual(format_tile(tile, 'tms'), '3 2 2')
self.assertEqual(format_tile(tile, 'quad_tree'), '13')
self.assertEqual(format_tile(tile, 'google', '{z}-{x}-{y}'), '2-3-1')
self.assertEqual(format_tile(tile, 'tms', '{z}-{x}-{y}'), '2-3-2')
def cvtLatlon2xyz(z, *bounds_):
logging.info('calculating xyz...')
cross_lat = (bounds_[0] + bounds_[2]) / 2
cross_lon = (bounds_[1] + bounds_[3]) / 2
t = Tile.for_latitude_longitude(longitude=cross_lon,
latitude=cross_lat,
zoom=z)
x, y = t.google
google_xyz = [x, y, z]
#print x, y
return google_xyz
def png2GeoTif(src_filename, dst_filename, google_x, google_y, zoom, pixels,
epsg):
"""
This function make image georeference adn convert to .tif format to be able to load it in qgis
:param src_filename: '/path/to/source.tif'
:param dst_filename: '/path/to/destination.tif'
:param google_x:
:param google_y:
:param zoom: 15
:param pixels:
:param epsg: 4326 #Es el eps de los puntos del IDEAM y el que retorna pygeotile
:return:
"""
# Opens source dataset
src_ds = gdal.Open(src_filename)
format = "GTiff"
driver = gdal.GetDriverByName(format)
# Open destination dataset
dst_ds = driver.CreateCopy(dst_filename, src_ds, 0)
#Optener los puntos de referencia
tile = Tile.from_google(google_x, google_y, zoom)
bounds = tile.bounds #Retorna el punto sur occidental y el punto nororiental del tile.
p1 = bounds[
0] #Point(latitude=2.6357885741666065, longitude=-72.388916015625)
p2 = bounds[1]
uperleftx = min([p1[1], p2[1]])
uperlefty = max([p1[0], p2[0]])
scalex = abs(p1[1] - p2[1]) / pixels
scaley = abs(p1[0] - p2[0]) / pixels
# Specify raster location through geotransform array
# (uperleftx, scalex, skewx, uperlefty, skewy, scaley)
# Scale = size of one pixel in units of raster projection
# this example below assumes 100x100
gt = [uperleftx, scalex, 0, uperlefty, 0, -scaley]
#print(gt)
# Set location
dst_ds.SetGeoTransform(gt)
# Get raster projection
srs = osr.SpatialReference()
srs.ImportFromEPSG(epsg)
dest_wkt = srs.ExportToWkt()
# Set projection
dst_ds.SetProjection(dest_wkt)
# Close files
dst_ds = None
src_ds = None
def chipTiles(p, z):
"""
find Planet Tile for a give point p at given zool level z
:param p: (lat, long)
:param z: 15
:return: x,y,z tile google xyz tile grid
"""
latitude, longitude, zoom = p[0], p[1], z
tile = Tile.for_latitude_longitude(latitude, longitude, zoom)
tile = tile.google
return tile
def geoTiles_conveter(position):
"""
converter geo coordenadas para quadTrees
"""
lat, lon = position
tile = Tile.for_latitude_longitude(latitude=lat, longitude=lon, zoom=18)
return tile.quad_tree
def getTMSBBox(x, y, zoom):
tile = Tile.from_tms(tms_x=x, tms_y=y, zoom=zoom)
bounds = tile.bounds
minLong = bounds[0].longitude
minLat = bounds[0].latitude
maxLong = bounds[1].longitude
maxLat = bounds[1].latitude
minLong, minLat = pointTo3857(minLong, minLat)
maxLong, maxLat = pointTo3857(maxLong, maxLat)
return np.array([minLong, maxLong, minLat, maxLat])
def open_tile(filename, outdir='./'):
""" Open a tile image and assign projection and geotransform """
img = gippy.GeoImage(filename)
z, x, y = map(int, img.basename().split('-'))
tile = Tile.from_tms(tms_x=x, tms_y=y, zoom=z)
img[0] = (img[0] == 255)
fout = os.path.join(outdir, img.basename() + '.tif')
geoimg = img.save(fout, options={'COMPRESS': 'DEFLATE'})
geoimg.set_srs('EPSG:3857')
minpt = tile.bounds[0].meters
maxpt = tile.bounds[1].meters
affine = np.array(
[
minpt[0], (maxpt[0]-minpt[0])/geoimg.xsize(), 0.0,
abs(minpt[1]), 0.0, -(maxpt[1]-minpt[1])/geoimg.ysize()
])
geoimg.set_affine(affine)
return geoimg
