import cpan-explorermaster

1 files changed, 222 insertions, 0 deletions

diff --git a/doc/tilemaker.py b/doc/tilemaker.py
new file mode 100644
index 0000000..a02c7d2
--- /dev/null
+++ b/doc/tilemaker.py
@@ -0,0 +1,222 @@
+#!/usr/bin/env python
+
+"""
+This program assists with cutting down large images into square tiles.  It can
+take an image of arbitrary size and create tiles of any size.
+
+python tilemaker.py -s256 -Q9 -t"tile-%d-%d-%d.png" -bFFFFFF -v canvas.png
+
+Copyright, 2005-2006: Michal Migurski, Serge Wroclawski
+License: Apache 2.0
+"""
+
+import math
+from os.path import split, splitext
+from PIL import Image
+
+chatty_default = False
+background_default = "FFFFFF"
+efficient_default = True
+scaling_filter = Image.BICUBIC
+
+from sys import exit
+
+def main():
+    """Main method"""
+    from optparse import OptionParser
+    
+    parser = OptionParser(usage = "usage: %prog [options] filename")
+    # Now, Dan wants tile height and width.
+    parser.add_option('-s', '--tile-size', dest = "size", type="int",
+                      default=512, help = 'The tile height/width')
+    parser.add_option('-t', '--template', dest = "template",
+                      default = None,
+                      help = "Template filename pattern")
+    parser.add_option('-v', '--verbose', dest = "verbosity",
+                      action = "store_true", default = False,
+                      help = "Increase verbosity")
+    parser.add_option('-Q', '--quality', dest="quality", type="int",
+                      help = 'Set the quality level of the image')
+    parser.add_option('-b', '--background', dest="background",
+                      help = 'Set the background color')
+    
+    # Location based arguments are always a pain
+    (options, args) = parser.parse_args()
+    if len(args) != 1:
+        parser.error("incorrect number of arguments")
+    filename = args[0]
+    if not options.template:
+        fname, extension = splitext(split(filename)[1])
+        options.template = fname + '-%d-%d-%d' + extension
+    if not options.background:
+        options.background = background_default
+
+    verbosity = options.verbosity
+    size = options.size
+    quality = options.quality
+    template = options.template
+    background = options.background
+    
+    # Split the image up into "squares"
+    img = prepare(filename, bgcolor = background, chatty = verbosity)
+
+    subdivide(img, size = (size, size),
+              quality = quality, filename = template, chatty = verbosity)
+
+
+def prepare(filename, bgcolor = background_default, chatty = chatty_default):
+    """
+    Prepare a large image for tiling.
+    
+    Load an image from a file. Resize the image so that it is square,
+    with dimensions that are an even power of two in length (e.g. 512,
+    1024, 2048, ...). Then, return it.
+    """
+
+    src = Image.open(filename)
+
+    if chatty:
+        print "original size: %s" % str(src.size)
+    
+    full_size = (1, 1)
+
+    while full_size[0] < src.size[0] or full_size[1] < src.size[1]:
+        full_size = (full_size[0] * 2, full_size[1] * 2)
+    
+    img = Image.new('RGBA', full_size)
+    img.paste("#" + bgcolor)
+    
+    src.thumbnail(full_size, scaling_filter)
+    img.paste(src, (int((full_size[0] - src.size[0]) / 2),
+                    int((full_size[1] - src.size[1]) / 2)))
+    
+    if chatty:
+        print "full size: %s" % str(full_size)
+        
+    return img
+
+
+
+def tile(im, level, quadrant=(0, 0), size=(512, 512),
+         efficient=efficient_default, chatty=chatty_default):
+    """
+    Extract a single tile from a larger image.
+    
+    Given an image, a zoom level (int), a quadrant (column, row tuple;
+    ints), and an output size, crop and size a portion of the larger
+    image. If the given zoom level would result in scaling the image up,
+    throw an error - no need to create information where none exists.
+    """
+
+    scale = int(math.pow(2, level))
+    
+    if efficient:
+        #efficient: crop out the area of interest first, then scale and copy it
+
+        inverse_size    = (float(im.size[0]) / float(size[0] * scale),
+                           float(im.size[1]) / float(size[1] * scale))
+        top_left        = (int(quadrant[0] *  size[0] * inverse_size[0]),
+                           int(quadrant[1] *  size[1] * inverse_size[1]))
+        bottom_right    = (int(top_left[0] + (size[0] * inverse_size[0])),
+                           int(top_left[1] + (size[1] * inverse_size[1])))
+    
+        if inverse_size[0] < 1.0 or inverse_size[1] < 1.0:
+            raise Exception('Requested zoom level (%d) is too high' % level)
+    
+        if chatty:
+            print "crop(%s).resize(%s)" % (str(top_left + bottom_right),
+                                           str(size))
+
+        zoomed = im.crop(top_left + bottom_right).resize(size, scaling_filter).copy()
+        return zoomed
+
+    else:
+        # inefficient: copy the whole image, scale it and then crop
+        # out the area of interest
+
+        new_size        = (size[0] * scale,         size[1] * scale)
+        top_left        = (quadrant[0] * size[0],   quadrant[1] * size[1])
+        bottom_right    = (top_left[0] + size[0],   top_left[1] + size[1])
+        
+        if new_size[0] > im.size[0] or new_size[1] > im.size[1]:
+            raise Exception('Requested zoom level (%d) is too high' % level)
+    
+        if chatty:
+            print "resize(%s).crop(%s)" % (str(new_size),
+                                           str(top_left + bottom_right))
+
+        zoomed = im.copy().resize(new_size, scaling_filter).crop(top_left + bottom_right).copy()
+        return zoomed
+
+
+
+def subdivide(img, level=0, quadrant=(0, 0), size=(512, 512),
+              filename='tile-%d-%d-%d.jpg',
+              quality = None, chatty = chatty_default):
+    """
+    Recursively subdivide a large image into small tiles.
+
+    Given an image, a zoom level (int), a quadrant (column, row tuple;
+    ints), and an output size, cut the image into even quarters and
+    recursively subdivide each, then generate a combined tile from the
+    resulting subdivisions. If further subdivision would result in
+    scaling the image up, use tile() to turn the image itself into a
+    tile.
+    """
+
+    if img.size[0] <= size[0] * math.pow(2, level):
+
+        # looks like we've reached the bottom - the image can't be
+        # subdivided further. # extract a tile from the passed image.
+        out_img = tile(img, level, quadrant=quadrant, size=size)
+        out_img.save(filename % (level, quadrant[0], quadrant[1]))
+
+        if chatty:
+            print '.', '  ' * level, filename % (level, quadrant[0], quadrant[1])
+        return out_img
+
+    # haven't reach the bottom.
+    # subdivide deeper, construct the current image out of deeper images.
+    out_img = Image.new('RGBA', (size[0] * 2, size[1] * 2))
+    out_img.paste(subdivide(img = img,
+                            level = (level + 1),
+                            quadrant=((quadrant[0] * 2) + 0,
+                                      (quadrant[1] * 2) + 0),
+                            size = size,
+                            filename=filename, chatty=chatty), (0,0))
+    out_img.paste(subdivide(img = img,
+                            level=(level + 1),
+                            quadrant=((quadrant[0] * 2) + 0,
+                                      (quadrant[1] * 2) + 1),
+                            size = size,
+                            filename=filename, chatty=chatty), (0,size[1]))
+    out_img.paste(subdivide(img = img,
+                            level=(level + 1),
+                            quadrant=((quadrant[0] * 2) + 1,
+                                      (quadrant[1] * 2) + 0),
+                            size = size,
+                            filename=filename, chatty=chatty), (size[0], 0))
+    out_img.paste(subdivide(img,
+                            level=(level + 1),
+                            quadrant=((quadrant[0] * 2) + 1,
+                                      (quadrant[1] * 2) + 1),
+                            size = size,
+                            filename=filename, chatty=chatty), (size[0], size[1]))
+
+    out_img = out_img.resize(size, scaling_filter)
+
+    # In the future, we may want to verify the quality. Right now we let
+    # the underlying code handle bad values (other than a non-int)
+    if not quality:
+        out_img.save(filename % (level, quadrant[0], quadrant[1]))
+    else:
+        out_img.save(filename % (level, quadrant[0], quadrant[1]),
+                     quality=quality)
+    if chatty:
+        print '-', '  ' * level, filename % (level, quadrant[0], quadrant[1])
+    return out_img
+
+
+
+if __name__ == '__main__':
+    exit(main())