219 lines
8.8 KiB
Python
219 lines
8.8 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
|
|
if args.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 if args.output != '-' else sys.stdout, "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()
|