#!/usr/bin/python
## Copyright (c) 2008, Kapil Thangavelu <kapil.foss@gmail.com>
## All rights reserved.
## Redistribution and use in source and binary forms, with or without
## modification, are permitted provided that the following conditions are
## met:
## Redistributions of source code must retain the above copyright
## notice, this list of conditions and the following disclaimer.
## Redistributions in binary form must reproduce the above copyright
## notice, this list of conditions and the following disclaimer in the
## documentation and/or other materials provided with the
## distribution. The names of its authors/contributors may be used to
## endorse or promote products derived from this software without
## specific prior written permission.
## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
## "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
## LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
## FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
## COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
## INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
## (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
## SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
## HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
## STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
## ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
## OF THE POSSIBILITY OF SUCH DAMAGE.
"""
Implements a Deep Zoom / Seadragon Composer in Python
For use with the seajax viewer
reversed from the excellent blog description at
http://gashi.ch/blog/inside-deep-zoom-2
from Daniel Gasienica
incidentally he's got an updated version of this script that supports collections
thats included in the openzoom project
http://code.google.com/p/open-zoom/source/browse/trunk/src/main/python/deepzoom/deepzoom.py
Author: Kapil Thangavelu
Date: 11/29/2008
License: BSD
"""
import math, os, optparse, sys
from PIL import Image
xml_template = '''\
<?xml version="1.0" encoding="UTF-8"?>
<Image TileSize="%(tile_size)s" Overlap="%(overlap)s" Format="%(format)s"
xmlns="http://schemas.microsoft.com/deepzoom/2008">
<Size Width="%(width)s" Height="%(height)s"/>
</Image>
'''
filter_map = {
'cubic' : Image.CUBIC,
'bilinear' : Image.BILINEAR,
'bicubic' : Image.BICUBIC,
'nearest' : Image.NEAREST,
'antialias' : Image.ANTIALIAS,
}
class PyramidComposer( object ):
def __init__( self, image, tile_size=256.0, overlap=1, format="png", filter=None):
self.image = image
self.tile_size = tile_size
self.overlap = overlap
self.format = format
self.width, self.height = self.image.size
self._levels = None
self.filter = filter
@property
def levels( self ):
""" number of levels in an image pyramid """
if self._levels is not None:
return self._levels
self._levels = int( math.ceil( math.log( max( (self.width, self.height) ), 2) ) )
return self._levels
def getLevelDimensions( self, level ):
assert level <= self.levels and level >= 0, "Invalid Pyramid Level"
scale = self.getLevelScale( level )
return math.ceil( self.width * scale) , math.ceil( self.height * scale )
def getLevelScale( self, level ):
#print math.pow( 0.5, self.levels - level )
return 1.0 / (1 << ( self.levels - level ) )
def getLevelRowCol( self, level ):
w, h = self.getLevelDimensions( level )
return ( math.ceil( w / self.tile_size ), math.ceil( h / self.tile_size ) )
def getTileBox( self, level, column, row ):
""" return a bounding box (x1,y1,x2,y2)"""
# find start position for current tile
# python's ternary operator doesn't like zero as true condition result
# ie. True and 0 or 1 -> returns 1
if not column:
px = 0
else:
px = self.tile_size * column - self.overlap
if not row:
py = 0
else:
py = self.tile_size * row - self.overlap
# scaled dimensions for this level
dsw, dsh = self.getLevelDimensions( level )
# find the dimension of the tile, adjust for no overlap data on top and left edges
sx = self.tile_size + ( column == 0 and 1 or 2 ) * self.overlap
sy = self.tile_size + ( row == 0 and 1 or 2 ) * self.overlap
# adjust size for single-tile levels where the image size is smaller
# than the regular tile size, and for tiles on the bottom and right
# edges that would exceed the image bounds
sx = min( sx, dsw-px )
sy = min( sy, dsh-py )
return px, py, px+sx, py+sy
def getLevelImage( self, level ):
w, h = self.getLevelDimensions( level )
w, h = int(w), int(h)
# don't transform to what we already have
if self.width == w and self.height == h:
return self.image
if not self.filter:
return self.image.resize( (w,h) )
return self.image.resize( (w,h), self.filter)
def iterTiles( self, level ):
col, row = self.getLevelRowCol( level )
for w in range( 0, int( col ) ):
for h in range( 0, int( row ) ):
yield (w,h), ( self.getTileBox( level, w, h ) )
def __len__( self ):
return self.levels
def save( self, parent_directory, name ):
dir_path = ensure( os.path.join( ensure( expand( parent_directory ) ), "%s_files"%name ) )
# store images
for n in range( self.levels + 1 ):
level_dir = ensure( os.path.join( dir_path, str( n ) ) )
level_image = self.getLevelImage( n )
for ( col, row), box in self.iterTiles( n ):
tile = level_image.crop( map(int, box) )
tile_path = os.path.join( level_dir, "%s_%s.%s"%( col, row, self.format ) )
tile_file = open( tile_path, 'wb+')
tile.save( tile_file )
# store dzi file
fh = open( os.path.join( parent_directory, "%s.dzi"%(name)), 'w+' )
fh.write( xml_template%( self.__dict__ ) )
fh.close()
def info( self ):
for n in range( self.levels +1 ):
print "Level", n, self.getLevelDimensions( n ), self.getLevelScale( n ), self.getLevelRowCol( n )
for (col, row ), box in self.iterTiles( n ):
if n > self.levels*.75 and n < self.levels*.95:
print " ", "%s/%s_%s"%(n, col, row ), box
def expand( d):
return os.path.abspath( os.path.expanduser( os.path.expandvars( d ) ) )
def ensure( d ):
if not os.path.exists( d ):
os.mkdir( d )
return d
def main( ):
parser = optparse.OptionParser(usage = "usage: %prog [options] filename")
parser.add_option('-s', '--tile-size', dest = "size", type="int",
default=256, help = 'The tile height/width')
parser.add_option('-q', '--quality', dest="quality", type="int",
help = 'Set the quality level of the image')
parser.add_option('-f', '--format', dest="format",
default="jpg", help = 'Set the Image Format (jpg or png)')
parser.add_option('-n', '--name', dest="name", help = 'Set the name of the output directory/dzi')
parser.add_option('-p', '--path', dest="path", help = 'Set the path of the output directory/dzi')
parser.add_option('-t', '--transform', dest="transform", default="antialias",
help = 'Type of Transform (bicubic, nearest, antialias, bilinear')
parser.add_option('-d', '--debug', dest="debug", action="store_true", default=False,
help = 'Output debug information relating to box makeup')
(options, args ) = parser.parse_args()
if not args:
parser.print_help()
sys.exit(1)
image_path = expand( args[0] )
if not os.path.exists( image_path ):
print "Invalid File", image_path
sys.exit(1)
if not options.name:
options.name = os.path.splitext( os.path.basename( image_path ) )[0]
if not options.path:
options.path = os.path.dirname( image_path )
if options.transform and options.transform in filter_map:
options.transform = filter_map[ options.transform ]
img = Image.open( image_path )
composer = PyramidComposer( img, tile_size=options.size, format=options.format, filter=options.transform )
if options.debug:
composer.info()
sys.exit()
composer.save( options.path, options.name )
if __name__ == '__main__':
main()
