e6d4ed8068
This also allows us to print to stderr, which is handy and means all program text output (i.e. argument parser and script messages) will be on stderr.
218 lines
8.7 KiB
Python
218 lines
8.7 KiB
Python
"""
|
|
Outputs one huge PNG file using the tiles from an Overviewer map.
|
|
"""
|
|
|
|
from __future__ import print_function
|
|
|
|
import sys
|
|
from argparse import ArgumentParser
|
|
from glob import glob
|
|
from os.path import exists, join, split
|
|
|
|
from PIL import Image
|
|
|
|
|
|
def main():
|
|
parser = ArgumentParser()
|
|
|
|
parser.add_argument('--memory-limit', '-m', metavar='SIZE', type=int, dest='memory_limit',
|
|
required=True, help="Limit the amount of RAM to use in MiB. If it is "
|
|
"expected that we'll exceed the limit, the script will abort.")
|
|
parser.add_argument('--zoom-level', '-z', metavar='LEVEL', type=int, dest='zoom_level',
|
|
required=True, help="Which zoom level to use from the Overviewer map. "
|
|
"NOTE: the RAM usage will increase exponentially with the zoom level.")
|
|
parser.add_argument('--crop', '-c', metavar='CROP', type=int, dest='crop', default=0,
|
|
help="Crop a frame around the image, as a percentage of the original. "
|
|
"For example in a image of 1000x2000 pixels, a 10%% crop will crop 100 "
|
|
"pixels in the left and right sides and 200 pixels in the bottom and "
|
|
"top sides. NOTE: this is not exact but will be rounded to the nearest "
|
|
"Overviewer map tile.")
|
|
parser.add_argument('--center', '-e', metavar='X,Y', dest='center', default=None,
|
|
help="Mark what will be the center of the image, two comma separated "
|
|
"percentage values.")
|
|
parser.add_argument('--autocrop', '-a', dest='autocrop', default=False, action='store_true',
|
|
help="Calculate the center and crop vales automatically to show all the "
|
|
"tiles in the smallest possible image size. Unless you want a very "
|
|
"specific image this option is recommended.")
|
|
parser.add_argument('--output', '-o', type=str, dest='output', default="output.png",
|
|
metavar='OUTPUT', help="Path for the resulting PNG. The image will be "
|
|
"saved as a PNG file, no matter what extension you use.")
|
|
parser.add_argument('tileset', metavar='TILESET')
|
|
|
|
args = parser.parse_args()
|
|
|
|
if args.autocrop and (args.center or args.crop):
|
|
parser.error("You cannot specify --center or --crop with --autocrop.")
|
|
|
|
# check for the output
|
|
folder, filename = split(args.output)
|
|
if folder != '' and not exists(folder):
|
|
parser.error("The destination folder '{0}' doesn't exist.".format(folder))
|
|
|
|
# calculate stuff
|
|
n = args.zoom_level
|
|
length_in_tiles = 2**n
|
|
tile_size = (384, 384)
|
|
px_size = 4 # bytes
|
|
|
|
# create a list with all the images in the zoom level
|
|
path = args.tileset
|
|
for i in range(args.zoom_level):
|
|
path = join(path, "?")
|
|
path += ".png"
|
|
|
|
all_images = glob(path)
|
|
if not all_images:
|
|
print("Error! No images found in this zoom level. Is this really an Overviewer tile set "
|
|
"directory?", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
# autocrop will calculate the center and crop values automagically
|
|
if args.autocrop:
|
|
min_x = min_y = length_in_tiles
|
|
max_x = max_y = 0
|
|
counter = 0
|
|
total = len(all_images)
|
|
print("Checking tiles for autocrop calculations:", file=sys.stderr)
|
|
# get the maximum and minimum tiles coordinates of the map
|
|
for path in all_images:
|
|
t = get_tuple_coords(args, path)
|
|
c = get_tile_coords_from_tuple(args, t)
|
|
min_x = min(min_x, c[0])
|
|
min_y = min(min_y, c[1])
|
|
max_x = max(max_x, c[0])
|
|
max_y = max(max_y, c[1])
|
|
counter += 1
|
|
if (counter % 100 == 0 or counter == total or counter == 1):
|
|
print("Checked {0} of {1}.".format(counter, total), file=sys.stderr)
|
|
|
|
# the center of the map will be in the middle of the occupied zone
|
|
center = (int((min_x + max_x) / 2.0), int((min_y + max_y) / 2.0))
|
|
# see the next next comment to know what center_vector is
|
|
center_vector = (int(center[0] - (length_in_tiles / 2.0 - 1)),
|
|
int(center[1] - (length_in_tiles / 2.0 - 1)))
|
|
# I'm not completely sure why, but the - 1 factor in ^ makes everything nicer.
|
|
|
|
# min_x - center_vector[0] will be the unused amount of tiles in
|
|
# the left and the right of the map (and this is true because we
|
|
# are in the actual center of the map)
|
|
crop = (min_x - center_vector[0], min_y - center_vector[1])
|
|
|
|
else:
|
|
# center_vector is the vector that joins the center tile with
|
|
# the new center tile in tile coords
|
|
# tile coords are how many tile are on the left, x, and
|
|
# how many above, y. The top-left tile has coords (0,0)
|
|
if args.center:
|
|
center_x, center_y = args.center.split(",")
|
|
center_x = int(center_x)
|
|
center_y = int(center_y)
|
|
center_tile_x = int(2**n * (center_x / 100.0))
|
|
center_tile_y = int(2**n * (center_y / 100.0))
|
|
center_vector = (int(center_tile_x - length_in_tiles / 2.0),
|
|
int(center_tile_y - length_in_tiles / 2.0))
|
|
else:
|
|
center_vector = (0, 0)
|
|
|
|
# crop if needed
|
|
tiles_to_crop = int(2**n * (args.crop / 100.0))
|
|
crop = (tiles_to_crop, tiles_to_crop)
|
|
|
|
final_img_size = (tile_size[0] * length_in_tiles, tile_size[1] * length_in_tiles)
|
|
final_cropped_img_size = (final_img_size[0] - 2 * crop[0] * tile_size[0],
|
|
final_img_size[1] - 2 * crop[1] * tile_size[1])
|
|
|
|
mem = final_cropped_img_size[0] * final_cropped_img_size[1] * px_size # bytes!
|
|
print("The image size will be {0}x{1}."
|
|
.format(final_cropped_img_size[0], final_cropped_img_size[1]), file=sys.stderr)
|
|
print("A total of {0} MB of memory will be used.".format(mem / 1024**2), file=sys.stderr)
|
|
if mem / 1024.0**2.0 > args.memory_limit:
|
|
print("Error! The expected RAM usage exceeds the specified limit. Exiting.",
|
|
file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
# Create a new huge image
|
|
final_img = Image.new("RGBA", final_cropped_img_size, (26, 26, 26, 0))
|
|
|
|
# Paste ALL the images
|
|
total = len(all_images)
|
|
counter = 0
|
|
print("Pasting images:", file=sys.stderr)
|
|
for path in all_images:
|
|
img = Image.open(path)
|
|
t = get_tuple_coords(args, path)
|
|
x, y = get_cropped_centered_img_coords(args, tile_size, center_vector, crop, t)
|
|
final_img.paste(img, (x, y))
|
|
counter += 1
|
|
if (counter % 100 == 0 or counter == total or counter == 1):
|
|
print("Pasted {0} of {1}.".format(counter, total), file=sys.stderr)
|
|
print("Done!", file=sys.stderr)
|
|
print("Saving image... (this may take a while)", file=sys.stderr)
|
|
final_img.save(args.output, "PNG")
|
|
|
|
|
|
def get_cropped_centered_img_coords(options, tile_size, center_vector, crop, t):
|
|
""" Returns the new image coords used to paste tiles in the big
|
|
image. Takes options, the size of tiles, center vector, crop value
|
|
(see calculate stuff) and a tuple from get_tuple_coords. """
|
|
x, y = get_tile_coords_from_tuple(options, t)
|
|
new_tile_x = x - crop[0] - center_vector[0]
|
|
new_tile_y = y - crop[1] - center_vector[1]
|
|
|
|
new_img_x = new_tile_x * tile_size[0]
|
|
new_img_y = new_tile_y * tile_size[1]
|
|
|
|
return new_img_x, new_img_y
|
|
|
|
|
|
def get_tile_coords_from_tuple(options, t):
|
|
""" Gets a tuple of coords from get_tuple_coords and returns
|
|
the number of tiles from the top left corner to this tile.
|
|
The top-left tile has coordinates (0,0) """
|
|
x = 0
|
|
y = 0
|
|
z = options.zoom_level
|
|
n = 1
|
|
|
|
for i in t:
|
|
if i == 1:
|
|
x += 2**(z - n)
|
|
elif i == 2:
|
|
y += 2**(z - n)
|
|
elif i == 3:
|
|
x += 2**(z - n)
|
|
y += 2**(z - n)
|
|
n += 1
|
|
return (x, y)
|
|
|
|
|
|
def get_tuple_coords(options, path):
|
|
""" Extracts the "quadtree coordinates" (the numbers in the folder
|
|
of the tile sets) from an image path. Returns a tuple with them.
|
|
The upper most folder is in the left of the tuple."""
|
|
l = []
|
|
path, head = split(path)
|
|
head = head.split(".")[0] # remove the .png
|
|
l.append(int(head))
|
|
for i in range(options.zoom_level - 1):
|
|
path, head = split(path)
|
|
l.append(int(head))
|
|
# the list is reversed
|
|
l.reverse()
|
|
return tuple(l)
|
|
|
|
|
|
def get_image(tileset, t):
|
|
""" Returns the path of an image, takes a tuple with the
|
|
"quadtree coordinates", these are the numbers in the folders of the
|
|
tile set. """
|
|
path = tileset
|
|
for d in t:
|
|
path = join(path, str(d))
|
|
path += ".png"
|
|
return path
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|