home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2141 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  33.0 KB  |  1,287 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. VERSION = '1.1.6'
  5.  
  6. try:
  7.     import warnings
  8. except ImportError:
  9.     warnings = None
  10.  
  11.  
  12. class _imaging_not_installed:
  13.     
  14.     def __getattr__(self, id):
  15.         raise ImportError('The _imaging C module is not installed')
  16.  
  17.  
  18.  
  19. try:
  20.     __import__('FixTk')
  21. except ImportError:
  22.     pass
  23.  
  24.  
  25. try:
  26.     import _imaging
  27.     core = _imaging
  28.     del _imaging
  29. except ImportError:
  30.     v = None
  31.     core = _imaging_not_installed()
  32.     if str(v)[:20] == 'Module use of python' and warnings:
  33.         warnings.warn('The _imaging extension was built for another version of Python; most PIL functions will be disabled', RuntimeWarning)
  34.     
  35. except:
  36.     warnings
  37.  
  38. import ImageMode
  39. import ImagePalette
  40. import os
  41. import string
  42. import sys
  43. from types import IntType, StringType, TupleType
  44.  
  45. try:
  46.     UnicodeStringType = type(unicode(''))
  47.     
  48.     def isStringType(t):
  49.         if not isinstance(t, StringType):
  50.             pass
  51.         return isinstance(t, UnicodeStringType)
  52.  
  53. except NameError:
  54.     
  55.     def isStringType(t):
  56.         return isinstance(t, StringType)
  57.  
  58.  
  59.  
  60. def isTupleType(t):
  61.     return isinstance(t, TupleType)
  62.  
  63.  
  64. def isImageType(t):
  65.     return hasattr(t, 'im')
  66.  
  67.  
  68. def isDirectory(f):
  69.     if isStringType(f):
  70.         pass
  71.     return os.path.isdir(f)
  72.  
  73. from operator import isNumberType, isSequenceType
  74. DEBUG = 0
  75. NONE = 0
  76. FLIP_LEFT_RIGHT = 0
  77. FLIP_TOP_BOTTOM = 1
  78. ROTATE_90 = 2
  79. ROTATE_180 = 3
  80. ROTATE_270 = 4
  81. AFFINE = 0
  82. EXTENT = 1
  83. PERSPECTIVE = 2
  84. QUAD = 3
  85. MESH = 4
  86. NONE = 0
  87. NEAREST = 0
  88. ANTIALIAS = 1
  89. LINEAR = BILINEAR = 2
  90. CUBIC = BICUBIC = 3
  91. NONE = 0
  92. NEAREST = 0
  93. ORDERED = 1
  94. RASTERIZE = 2
  95. FLOYDSTEINBERG = 3
  96. WEB = 0
  97. ADAPTIVE = 1
  98. NORMAL = 0
  99. SEQUENCE = 1
  100. CONTAINER = 2
  101. ID = []
  102. OPEN = { }
  103. MIME = { }
  104. SAVE = { }
  105. EXTENSION = { }
  106. _MODEINFO = {
  107.     '1': ('L', 'L', ('1',)),
  108.     'L': ('L', 'L', ('L',)),
  109.     'I': ('L', 'I', ('I',)),
  110.     'F': ('L', 'F', ('F',)),
  111.     'P': ('RGB', 'L', ('P',)),
  112.     'RGB': ('RGB', 'L', ('R', 'G', 'B')),
  113.     'RGBX': ('RGB', 'L', ('R', 'G', 'B', 'X')),
  114.     'RGBA': ('RGB', 'L', ('R', 'G', 'B', 'A')),
  115.     'CMYK': ('RGB', 'L', ('C', 'M', 'Y', 'K')),
  116.     'YCbCr': ('RGB', 'L', ('Y', 'Cb', 'Cr')) }
  117. if sys.byteorder == 'little':
  118.     _ENDIAN = '<'
  119. else:
  120.     _ENDIAN = '>'
  121. _MODE_CONV = {
  122.     '1': ('|b1', None),
  123.     'L': ('|u1', None),
  124.     'I': ('%si4' % _ENDIAN, None),
  125.     'F': ('%sf4' % _ENDIAN, None),
  126.     'P': ('|u1', None),
  127.     'RGB': ('|u1', 3),
  128.     'RGBX': ('|u1', 4),
  129.     'RGBA': ('|u1', 4),
  130.     'CMYK': ('|u1', 4),
  131.     'YCbCr': ('|u1', 4) }
  132.  
  133. def _conv_type_shape(im):
  134.     shape = im.size[::-1]
  135.     (typ, extra) = _MODE_CONV[im.mode]
  136.     if extra is None:
  137.         return (shape, typ)
  138.     return (shape + (extra,), typ)
  139.  
  140. MODES = _MODEINFO.keys()
  141. MODES.sort()
  142. _MAPMODES = ('L', 'P', 'RGBX', 'RGBA', 'CMYK', 'I;16', 'I;16B')
  143.  
  144. def getmodebase(mode):
  145.     return ImageMode.getmode(mode).basemode
  146.  
  147.  
  148. def getmodetype(mode):
  149.     return ImageMode.getmode(mode).basetype
  150.  
  151.  
  152. def getmodebandnames(mode):
  153.     return ImageMode.getmode(mode).bands
  154.  
  155.  
  156. def getmodebands(mode):
  157.     return len(ImageMode.getmode(mode).bands)
  158.  
  159. _initialized = 0
  160.  
  161. def preinit():
  162.     global _initialized
  163.     if _initialized >= 1:
  164.         return None
  165.     
  166.     try:
  167.         import BmpImagePlugin
  168.     except ImportError:
  169.         _initialized >= 1
  170.         _initialized >= 1
  171.     except:
  172.         _initialized >= 1
  173.  
  174.     
  175.     try:
  176.         import GifImagePlugin
  177.     except ImportError:
  178.         _initialized >= 1
  179.         _initialized >= 1
  180.     except:
  181.         _initialized >= 1
  182.  
  183.     
  184.     try:
  185.         import JpegImagePlugin
  186.     except ImportError:
  187.         _initialized >= 1
  188.         _initialized >= 1
  189.     except:
  190.         _initialized >= 1
  191.  
  192.     
  193.     try:
  194.         import PpmImagePlugin
  195.     except ImportError:
  196.         _initialized >= 1
  197.         _initialized >= 1
  198.     except:
  199.         _initialized >= 1
  200.  
  201.     
  202.     try:
  203.         import PngImagePlugin
  204.     except ImportError:
  205.         _initialized >= 1
  206.         _initialized >= 1
  207.     except:
  208.         _initialized >= 1
  209.  
  210.     _initialized = 1
  211.  
  212.  
  213. def init():
  214.     global _initialized
  215.     if _initialized >= 2:
  216.         return None
  217.     visited = { }
  218.     directories = sys.path
  219.     
  220.     try:
  221.         directories = directories + [
  222.             os.path.dirname(__file__)]
  223.     except NameError:
  224.         _initialized >= 2
  225.         _initialized >= 2
  226.     except:
  227.         _initialized >= 2
  228.  
  229.     for directory in filter(isDirectory, directories):
  230.         fullpath = os.path.abspath(directory)
  231.         if visited.has_key(fullpath):
  232.             continue
  233.         
  234.         for file in os.listdir(directory):
  235.             if file[-14:] == 'ImagePlugin.py':
  236.                 (f, e) = os.path.splitext(file)
  237.                 
  238.                 try:
  239.                     sys.path.insert(0, directory)
  240.                     
  241.                     try:
  242.                         __import__(f, globals(), locals(), [])
  243.                     finally:
  244.                         del sys.path[0]
  245.  
  246.                 except ImportError:
  247.                     if DEBUG:
  248.                         print 'Image: failed to import', f, ':', sys.exc_value
  249.                     
  250.                 except:
  251.                     DEBUG
  252.                 
  253.  
  254.             None<EXCEPTION MATCH>ImportError
  255.         
  256.         visited[fullpath] = None
  257.     
  258.     if OPEN or SAVE:
  259.         _initialized = 2
  260.     
  261.  
  262.  
  263. def _getdecoder(mode, decoder_name, args, extra = ()):
  264.     if args is None:
  265.         args = ()
  266.     elif not isTupleType(args):
  267.         args = (args,)
  268.     
  269.     
  270.     try:
  271.         decoder = getattr(core, decoder_name + '_decoder')
  272.         return apply(decoder, (mode,) + args + extra)
  273.     except AttributeError:
  274.         raise IOError('decoder %s not available' % decoder_name)
  275.  
  276.  
  277.  
  278. def _getencoder(mode, encoder_name, args, extra = ()):
  279.     if args is None:
  280.         args = ()
  281.     elif not isTupleType(args):
  282.         args = (args,)
  283.     
  284.     
  285.     try:
  286.         encoder = getattr(core, encoder_name + '_encoder')
  287.         return apply(encoder, (mode,) + args + extra)
  288.     except AttributeError:
  289.         raise IOError('encoder %s not available' % encoder_name)
  290.  
  291.  
  292.  
  293. class _E:
  294.     
  295.     def __init__(self, data):
  296.         self.data = data
  297.  
  298.     
  299.     def __coerce__(self, other):
  300.         return (self, _E(other))
  301.  
  302.     
  303.     def __add__(self, other):
  304.         return _E((self.data, '__add__', other.data))
  305.  
  306.     
  307.     def __mul__(self, other):
  308.         return _E((self.data, '__mul__', other.data))
  309.  
  310.  
  311.  
  312. def _getscaleoffset(expr):
  313.     stub = [
  314.         'stub']
  315.     data = expr(_E(stub)).data
  316.     
  317.     try:
  318.         (a, b, c) = data
  319.         if a is stub and b == '__mul__' and isNumberType(c):
  320.             return (c, 0)
  321.         if a is stub and b == '__add__' and isNumberType(c):
  322.             return (1, c)
  323.     except TypeError:
  324.         pass
  325.  
  326.     
  327.     try:
  328.         (a, b, c) = ()
  329.         d = data
  330.         e = None
  331.         if a is stub and b == '__mul__' and isNumberType(c) and d == '__add__' and isNumberType(e):
  332.             return (c, e)
  333.     except TypeError:
  334.         pass
  335.  
  336.     raise ValueError('illegal expression')
  337.  
  338.  
  339. class Image:
  340.     format = None
  341.     format_description = None
  342.     
  343.     def __init__(self):
  344.         self.im = None
  345.         self.mode = ''
  346.         self.size = (0, 0)
  347.         self.palette = None
  348.         self.info = { }
  349.         self.category = NORMAL
  350.         self.readonly = 0
  351.  
  352.     
  353.     def _new(self, im):
  354.         new = Image()
  355.         new.im = im
  356.         new.mode = im.mode
  357.         new.size = im.size
  358.         new.palette = self.palette
  359.         if im.mode == 'P':
  360.             new.palette = ImagePalette.ImagePalette()
  361.         
  362.         
  363.         try:
  364.             new.info = self.info.copy()
  365.         except AttributeError:
  366.             new.info = { }
  367.             for k, v in self.info:
  368.                 new.info[k] = v
  369.             
  370.  
  371.         return new
  372.  
  373.     _makeself = _new
  374.     
  375.     def _copy(self):
  376.         self.load()
  377.         self.im = self.im.copy()
  378.         self.readonly = 0
  379.  
  380.     
  381.     def _dump(self, file = None, format = None):
  382.         import tempfile
  383.         if not file:
  384.             file = tempfile.mktemp()
  385.         
  386.         self.load()
  387.         if not format or format == 'PPM':
  388.             self.im.save_ppm(file)
  389.         else:
  390.             file = file + '.' + format
  391.             self.save(file, format)
  392.         return file
  393.  
  394.     
  395.     def __getattr__(self, name):
  396.         if name == '__array_interface__':
  397.             new = { }
  398.             (shape, typestr) = _conv_type_shape(self)
  399.             new['shape'] = shape
  400.             new['typestr'] = typestr
  401.             new['data'] = self.tostring()
  402.             return new
  403.         raise AttributeError(name)
  404.  
  405.     
  406.     def tostring(self, encoder_name = 'raw', *args):
  407.         if len(args) == 1 and isTupleType(args[0]):
  408.             args = args[0]
  409.         
  410.         if encoder_name == 'raw' and args == ():
  411.             args = self.mode
  412.         
  413.         self.load()
  414.         e = _getencoder(self.mode, encoder_name, args)
  415.         e.setimage(self.im)
  416.         bufsize = max(65536, self.size[0] * 4)
  417.         data = []
  418.         while None:
  419.             (l, s, d) = e.encode(bufsize)
  420.             if s:
  421.                 break
  422.                 continue
  423.             continue
  424.             if s < 0:
  425.                 raise RuntimeError('encoder error %d in tostring' % s)
  426.             s < 0
  427.             return string.join(data, '')
  428.  
  429.     
  430.     def tobitmap(self, name = 'image'):
  431.         self.load()
  432.         if self.mode != '1':
  433.             raise ValueError('not a bitmap')
  434.         self.mode != '1'
  435.         data = self.tostring('xbm')
  436.         return string.join([
  437.             '#define %s_width %d\n' % (name, self.size[0]),
  438.             '#define %s_height %d\n' % (name, self.size[1]),
  439.             'static char %s_bits[] = {\n' % name,
  440.             data,
  441.             '};'], '')
  442.  
  443.     
  444.     def fromstring(self, data, decoder_name = 'raw', *args):
  445.         if len(args) == 1 and isTupleType(args[0]):
  446.             args = args[0]
  447.         
  448.         if decoder_name == 'raw' and args == ():
  449.             args = self.mode
  450.         
  451.         d = _getdecoder(self.mode, decoder_name, args)
  452.         d.setimage(self.im)
  453.         s = d.decode(data)
  454.         if s[0] >= 0:
  455.             raise ValueError('not enough image data')
  456.         s[0] >= 0
  457.         if s[1] != 0:
  458.             raise ValueError('cannot decode image data')
  459.         s[1] != 0
  460.  
  461.     
  462.     def load(self):
  463.         if self.im and self.palette and self.palette.dirty:
  464.             apply(self.im.putpalette, self.palette.getdata())
  465.             self.palette.dirty = 0
  466.             self.palette.mode = 'RGB'
  467.             self.palette.rawmode = None
  468.             if self.info.has_key('transparency'):
  469.                 self.im.putpalettealpha(self.info['transparency'], 0)
  470.                 self.palette.mode = 'RGBA'
  471.             
  472.         
  473.         if self.im:
  474.             return self.im.pixel_access(self.readonly)
  475.  
  476.     
  477.     def verify(self):
  478.         pass
  479.  
  480.     
  481.     def convert(self, mode = None, data = None, dither = None, palette = WEB, colors = 256):
  482.         if not mode:
  483.             if self.mode == 'P':
  484.                 self.load()
  485.                 if self.palette:
  486.                     mode = self.palette.mode
  487.                 else:
  488.                     mode = 'RGB'
  489.             else:
  490.                 return self.copy()
  491.         self.mode == 'P'
  492.         self.load()
  493.         if data:
  494.             if mode not in ('L', 'RGB'):
  495.                 raise ValueError('illegal conversion')
  496.             mode not in ('L', 'RGB')
  497.             im = self.im.convert_matrix(mode, data)
  498.             return self._new(im)
  499.         if mode == 'P' and palette == ADAPTIVE:
  500.             im = self.im.quantize(colors)
  501.             return self._new(im)
  502.         
  503.         try:
  504.             im = self.im.convert(mode, dither)
  505.         except ValueError:
  506.             None if dither is None else data
  507.             None if dither is None else data
  508.             
  509.             try:
  510.                 im = self.im.convert(getmodebase(self.mode))
  511.                 im = im.convert(mode, dither)
  512.             except KeyError:
  513.                 raise ValueError('illegal conversion')
  514.             except:
  515.                 None<EXCEPTION MATCH>KeyError
  516.             
  517.  
  518.             None<EXCEPTION MATCH>KeyError
  519.  
  520.         return self._new(im)
  521.  
  522.     
  523.     def quantize(self, colors = 256, method = 0, kmeans = 0, palette = None):
  524.         self.load()
  525.         if palette:
  526.             palette.load()
  527.             if palette.mode != 'P':
  528.                 raise ValueError('bad mode for palette image')
  529.             palette.mode != 'P'
  530.             if self.mode != 'RGB' and self.mode != 'L':
  531.                 raise ValueError('only RGB or L mode images can be quantized to a palette')
  532.             self.mode != 'L'
  533.             im = self.im.convert('P', 1, palette.im)
  534.             return self._makeself(im)
  535.         im = self.im.quantize(colors, method, kmeans)
  536.         return self._new(im)
  537.  
  538.     
  539.     def copy(self):
  540.         self.load()
  541.         im = self.im.copy()
  542.         return self._new(im)
  543.  
  544.     
  545.     def crop(self, box = None):
  546.         self.load()
  547.         if box is None:
  548.             return self.copy()
  549.         return _ImageCrop(self, box)
  550.  
  551.     
  552.     def draft(self, mode, size):
  553.         pass
  554.  
  555.     
  556.     def _expand(self, xmargin, ymargin = None):
  557.         if ymargin is None:
  558.             ymargin = xmargin
  559.         
  560.         self.load()
  561.         return self._new(self.im.expand(xmargin, ymargin, 0))
  562.  
  563.     
  564.     def filter(self, filter):
  565.         self.load()
  566.         Filter = Filter
  567.         import ImageFilter
  568.         if not isinstance(filter, Filter):
  569.             filter = filter()
  570.         
  571.         if self.im.bands == 1:
  572.             return self._new(filter.filter(self.im))
  573.         ims = []
  574.         for c in range(self.im.bands):
  575.             ims.append(self._new(filter.filter(self.im.getband(c))))
  576.         
  577.         return merge(self.mode, ims)
  578.  
  579.     
  580.     def getbands(self):
  581.         return ImageMode.getmode(self.mode).bands
  582.  
  583.     
  584.     def getbbox(self):
  585.         self.load()
  586.         return self.im.getbbox()
  587.  
  588.     
  589.     def getcolors(self, maxcolors = 256):
  590.         self.load()
  591.         if self.mode in ('1', 'L', 'P'):
  592.             h = self.im.histogram()
  593.             out = []
  594.             for i in range(256):
  595.                 if h[i]:
  596.                     out.append((h[i], i))
  597.                     continue
  598.             
  599.             if len(out) > maxcolors:
  600.                 return None
  601.             return out
  602.         return self.im.getcolors(maxcolors)
  603.  
  604.     
  605.     def getdata(self, band = None):
  606.         self.load()
  607.         if band is not None:
  608.             return self.im.getband(band)
  609.         return self.im
  610.  
  611.     
  612.     def getextrema(self):
  613.         self.load()
  614.         if self.im.bands > 1:
  615.             extrema = []
  616.             for i in range(self.im.bands):
  617.                 extrema.append(self.im.getband(i).getextrema())
  618.             
  619.             return tuple(extrema)
  620.         return self.im.getextrema()
  621.  
  622.     
  623.     def getim(self):
  624.         self.load()
  625.         return self.im.ptr
  626.  
  627.     
  628.     def getpalette(self):
  629.         self.load()
  630.         
  631.         try:
  632.             return map(ord, self.im.getpalette())
  633.         except ValueError:
  634.             return None
  635.  
  636.  
  637.     
  638.     def getpixel(self, xy):
  639.         self.load()
  640.         return self.im.getpixel(xy)
  641.  
  642.     
  643.     def getprojection(self):
  644.         self.load()
  645.         (x, y) = self.im.getprojection()
  646.         return (map(ord, x), map(ord, y))
  647.  
  648.     
  649.     def histogram(self, mask = None, extrema = None):
  650.         self.load()
  651.         if mask:
  652.             mask.load()
  653.             return self.im.histogram((0, 0), mask.im)
  654.         if self.mode in ('I', 'F'):
  655.             if extrema is None:
  656.                 extrema = self.getextrema()
  657.             
  658.             return self.im.histogram(extrema)
  659.         return self.im.histogram()
  660.  
  661.     
  662.     def offset(self, xoffset, yoffset = None):
  663.         if warnings:
  664.             warnings.warn("'offset' is deprecated; use 'ImageChops.offset' instead", DeprecationWarning, stacklevel = 2)
  665.         
  666.         import ImageChops
  667.         return ImageChops.offset(self, xoffset, yoffset)
  668.  
  669.     
  670.     def paste(self, im, box = None, mask = None):
  671.         if isImageType(box) and mask is None:
  672.             mask = box
  673.             box = None
  674.         
  675.         if box is None:
  676.             box = (0, 0) + self.size
  677.         
  678.         if len(box) == 2:
  679.             if isImageType(im):
  680.                 size = im.size
  681.             elif isImageType(mask):
  682.                 size = mask.size
  683.             else:
  684.                 raise ValueError('cannot determine region size; use 4-item box')
  685.             box = isImageType(im) + (box[0] + size[0], box[1] + size[1])
  686.         
  687.         if isStringType(im):
  688.             import ImageColor
  689.             im = ImageColor.getcolor(im, self.mode)
  690.         elif isImageType(im):
  691.             im.load()
  692.             if self.mode != im.mode:
  693.                 if self.mode != 'RGB' or im.mode not in ('RGBA', 'RGBa'):
  694.                     im = im.convert(self.mode)
  695.                 
  696.             
  697.             im = im.im
  698.         
  699.         self.load()
  700.         if self.readonly:
  701.             self._copy()
  702.         
  703.         if mask:
  704.             mask.load()
  705.             self.im.paste(im, box, mask.im)
  706.         else:
  707.             self.im.paste(im, box)
  708.  
  709.     
  710.     def point(self, lut, mode = None):
  711.         self.load()
  712.         if not isSequenceType(lut):
  713.             if self.mode in ('I', 'I;16', 'F'):
  714.                 (scale, offset) = _getscaleoffset(lut)
  715.                 return self._new(self.im.point_transform(scale, offset))
  716.             lut = map(lut, range(256)) * self.im.bands
  717.         
  718.         if self.mode == 'F':
  719.             raise ValueError('point operation not supported for this mode')
  720.         self.mode == 'F'
  721.         return self._new(self.im.point(lut, mode))
  722.  
  723.     
  724.     def putalpha(self, alpha):
  725.         self.load()
  726.         if self.readonly:
  727.             self._copy()
  728.         
  729.         if self.mode not in ('LA', 'RGBA'):
  730.             
  731.             try:
  732.                 mode = getmodebase(self.mode) + 'A'
  733.                 
  734.                 try:
  735.                     self.im.setmode(mode)
  736.                 except (AttributeError, ValueError):
  737.                     im = self.im.convert(mode)
  738.                     if im.mode not in ('LA', 'RGBA'):
  739.                         raise ValueError
  740.                     im.mode not in ('LA', 'RGBA')
  741.                     self.im = im
  742.  
  743.                 self.mode = self.im.mode
  744.             except (KeyError, ValueError):
  745.                 raise ValueError('illegal image mode')
  746.             except:
  747.                 None<EXCEPTION MATCH>(KeyError, ValueError)
  748.             
  749.  
  750.         None<EXCEPTION MATCH>(KeyError, ValueError)
  751.         if self.mode == 'LA':
  752.             band = 1
  753.         else:
  754.             band = 3
  755.         if isImageType(alpha):
  756.             if alpha.mode not in ('1', 'L'):
  757.                 raise ValueError('illegal image mode')
  758.             alpha.mode not in ('1', 'L')
  759.             alpha.load()
  760.             if alpha.mode == '1':
  761.                 alpha = alpha.convert('L')
  762.             
  763.         else:
  764.             
  765.             try:
  766.                 self.im.fillband(band, alpha)
  767.             except (AttributeError, ValueError):
  768.                 alpha = new('L', self.size, alpha)
  769.  
  770.             return None
  771.         isImageType(alpha).im.putband(alpha.im, band)
  772.  
  773.     
  774.     def putdata(self, data, scale = 1, offset = 0):
  775.         self.load()
  776.         if self.readonly:
  777.             self._copy()
  778.         
  779.         self.im.putdata(data, scale, offset)
  780.  
  781.     
  782.     def putpalette(self, data, rawmode = 'RGB'):
  783.         self.load()
  784.         if self.mode not in ('L', 'P'):
  785.             raise ValueError('illegal image mode')
  786.         self.mode not in ('L', 'P')
  787.         if not isStringType(data):
  788.             data = string.join(map(chr, data), '')
  789.         
  790.         self.mode = 'P'
  791.         self.palette = ImagePalette.raw(rawmode, data)
  792.         self.palette.mode = 'RGB'
  793.         self.load()
  794.  
  795.     
  796.     def putpixel(self, xy, value):
  797.         self.load()
  798.         if self.readonly:
  799.             self._copy()
  800.         
  801.         return self.im.putpixel(xy, value)
  802.  
  803.     
  804.     def resize(self, size, resample = NEAREST):
  805.         if resample not in (NEAREST, BILINEAR, BICUBIC, ANTIALIAS):
  806.             raise ValueError('unknown resampling filter')
  807.         resample not in (NEAREST, BILINEAR, BICUBIC, ANTIALIAS)
  808.         self.load()
  809.         if self.mode in ('1', 'P'):
  810.             resample = NEAREST
  811.         
  812.         if resample == ANTIALIAS:
  813.             
  814.             try:
  815.                 im = self.im.stretch(size, resample)
  816.             except AttributeError:
  817.                 raise ValueError('unsupported resampling filter')
  818.             except:
  819.                 None<EXCEPTION MATCH>AttributeError
  820.             
  821.  
  822.         None<EXCEPTION MATCH>AttributeError
  823.         im = self.im.resize(size, resample)
  824.         return self._new(im)
  825.  
  826.     
  827.     def rotate(self, angle, resample = NEAREST, expand = 0):
  828.         if expand:
  829.             import math
  830.             angle = -angle * math.pi / 180
  831.             matrix = [
  832.                 math.cos(angle),
  833.                 math.sin(angle),
  834.                 0,
  835.                 -math.sin(angle),
  836.                 math.cos(angle),
  837.                 0]
  838.             
  839.             def transform(x, y, .2 = matrix):
  840.                 (a, b, c, d, e, f) = .2
  841.                 return (a * x + b * y + c, d * x + e * y + f)
  842.  
  843.             (w, h) = self.size
  844.             xx = []
  845.             yy = []
  846.             for x, y in ((0, 0), (w, 0), (w, h), (0, h)):
  847.                 (x, y) = transform(x, y)
  848.                 xx.append(x)
  849.                 yy.append(y)
  850.             
  851.             w = int(math.ceil(max(xx)) - math.floor(min(xx)))
  852.             h = int(math.ceil(max(yy)) - math.floor(min(yy)))
  853.             (x, y) = transform(w / 2, h / 2)
  854.             matrix[2] = self.size[0] / 2 - x
  855.             matrix[5] = self.size[1] / 2 - y
  856.             return self.transform((w, h), AFFINE, matrix)
  857.         if resample not in (NEAREST, BILINEAR, BICUBIC):
  858.             raise ValueError('unknown resampling filter')
  859.         resample not in (NEAREST, BILINEAR, BICUBIC)
  860.         self.load()
  861.         if self.mode in ('1', 'P'):
  862.             resample = NEAREST
  863.         
  864.         return self._new(self.im.rotate(angle, resample))
  865.  
  866.     
  867.     def save(self, fp, format = None, **params):
  868.         if isStringType(fp):
  869.             filename = fp
  870.         elif hasattr(fp, 'name') and isStringType(fp.name):
  871.             filename = fp.name
  872.         else:
  873.             filename = ''
  874.         self.load()
  875.         self.encoderinfo = params
  876.         self.encoderconfig = ()
  877.         preinit()
  878.         ext = string.lower(os.path.splitext(filename)[1])
  879.         if not format:
  880.             
  881.             try:
  882.                 format = EXTENSION[ext]
  883.             except KeyError:
  884.                 init()
  885.                 
  886.                 try:
  887.                     format = EXTENSION[ext]
  888.                 except KeyError:
  889.                     raise KeyError(ext)
  890.                 except:
  891.                     None<EXCEPTION MATCH>KeyError
  892.                 
  893.  
  894.                 None<EXCEPTION MATCH>KeyError
  895.             
  896.  
  897.         None<EXCEPTION MATCH>KeyError
  898.         
  899.         try:
  900.             save_handler = SAVE[string.upper(format)]
  901.         except KeyError:
  902.             init()
  903.             save_handler = SAVE[string.upper(format)]
  904.  
  905.         if isStringType(fp):
  906.             import __builtin__
  907.             fp = __builtin__.open(fp, 'wb')
  908.             close = 1
  909.         else:
  910.             close = 0
  911.         
  912.         try:
  913.             save_handler(self, fp, filename)
  914.         finally:
  915.             if close:
  916.                 fp.close()
  917.             
  918.  
  919.  
  920.     
  921.     def seek(self, frame):
  922.         if frame != 0:
  923.             raise EOFError
  924.         frame != 0
  925.  
  926.     
  927.     def show(self, title = None, command = None):
  928.         _showxv(self, title, command)
  929.  
  930.     
  931.     def split(self):
  932.         ims = []
  933.         self.load()
  934.         for i in range(self.im.bands):
  935.             ims.append(self._new(self.im.getband(i)))
  936.         
  937.         return tuple(ims)
  938.  
  939.     
  940.     def tell(self):
  941.         return 0
  942.  
  943.     
  944.     def thumbnail(self, size, resample = NEAREST):
  945.         (x, y) = self.size
  946.         if x > size[0]:
  947.             y = max(y * size[0] / x, 1)
  948.             x = size[0]
  949.         
  950.         if y > size[1]:
  951.             x = max(x * size[1] / y, 1)
  952.             y = size[1]
  953.         
  954.         size = (x, y)
  955.         if size == self.size:
  956.             return None
  957.         self.draft(None, size)
  958.         self.load()
  959.         
  960.         try:
  961.             im = self.resize(size, resample)
  962.         except ValueError:
  963.             size == self.size
  964.             size == self.size
  965.             if resample != ANTIALIAS:
  966.                 raise 
  967.             resample != ANTIALIAS
  968.             im = self.resize(size, NEAREST)
  969.         except:
  970.             size == self.size
  971.  
  972.         self.im = im.im
  973.         self.mode = im.mode
  974.         self.size = size
  975.         self.readonly = 0
  976.  
  977.     
  978.     def transform(self, size, method, data = None, resample = NEAREST, fill = 1):
  979.         import ImageTransform
  980.         if isinstance(method, ImageTransform.Transform):
  981.             (method, data) = method.getdata()
  982.         
  983.         if data is None:
  984.             raise ValueError('missing method data')
  985.         data is None
  986.         im = new(self.mode, size, None)
  987.         if method == MESH:
  988.             for box, quad in data:
  989.                 im._Image__transformer(box, self, QUAD, quad, resample, fill)
  990.             
  991.         else:
  992.             im._Image__transformer((0, 0) + size, self, method, data, resample, fill)
  993.         return im
  994.  
  995.     
  996.     def __transformer(self, box, image, method, data, resample = NEAREST, fill = 1):
  997.         w = box[2] - box[0]
  998.         h = box[3] - box[1]
  999.         if method == AFFINE:
  1000.             data = (data[2], data[0], data[1], data[5], data[3], data[4])
  1001.         elif method == EXTENT:
  1002.             (x0, y0, x1, y1) = data
  1003.             xs = float(x1 - x0) / w
  1004.             ys = float(y1 - y0) / h
  1005.             method = AFFINE
  1006.             data = (x0 + xs / 2, xs, 0, y0 + ys / 2, 0, ys)
  1007.         elif method == PERSPECTIVE:
  1008.             data = (data[2], data[0], data[1], data[5], data[3], data[4], data[6], data[7])
  1009.         elif method == QUAD:
  1010.             nw = data[0:2]
  1011.             sw = data[2:4]
  1012.             se = data[4:6]
  1013.             ne = data[6:8]
  1014.             (x0, y0) = nw
  1015.             As = 1 / w
  1016.             At = 1 / h
  1017.             data = (x0, (ne[0] - x0) * As, (sw[0] - x0) * At, ((se[0] - sw[0] - ne[0]) + x0) * As * At, y0, (ne[1] - y0) * As, (sw[1] - y0) * At, ((se[1] - sw[1] - ne[1]) + y0) * As * At)
  1018.         else:
  1019.             raise ValueError('unknown transformation method')
  1020.         if method == AFFINE not in (NEAREST, BILINEAR, BICUBIC):
  1021.             raise ValueError('unknown resampling filter')
  1022.         method == AFFINE not in (NEAREST, BILINEAR, BICUBIC)
  1023.         image.load()
  1024.         self.load()
  1025.         if image.mode in ('1', 'P'):
  1026.             resample = NEAREST
  1027.         
  1028.         self.im.transform2(box, image.im, method, data, resample, fill)
  1029.  
  1030.     
  1031.     def transpose(self, method):
  1032.         self.load()
  1033.         im = self.im.transpose(method)
  1034.         return self._new(im)
  1035.  
  1036.  
  1037.  
  1038. class _ImageCrop(Image):
  1039.     
  1040.     def __init__(self, im, box):
  1041.         Image.__init__(self)
  1042.         (x0, y0, x1, y1) = box
  1043.         if x1 < x0:
  1044.             x1 = x0
  1045.         
  1046.         if y1 < y0:
  1047.             y1 = y0
  1048.         
  1049.         self.mode = im.mode
  1050.         self.size = (x1 - x0, y1 - y0)
  1051.         self._ImageCrop__crop = (x0, y0, x1, y1)
  1052.         self.im = im.im
  1053.  
  1054.     
  1055.     def load(self):
  1056.         if self._ImageCrop__crop:
  1057.             self.im = self.im.crop(self._ImageCrop__crop)
  1058.             self._ImageCrop__crop = None
  1059.         
  1060.  
  1061.  
  1062.  
  1063. def _wedge():
  1064.     return Image()._new(core.wedge('L'))
  1065.  
  1066.  
  1067. def new(mode, size, color = 0):
  1068.     if color is None:
  1069.         return Image()._new(core.new(mode, size))
  1070.     if isStringType(color):
  1071.         import ImageColor
  1072.         color = ImageColor.getcolor(color, mode)
  1073.     
  1074.     return Image()._new(core.fill(mode, size, color))
  1075.  
  1076.  
  1077. def fromstring(mode, size, data, decoder_name = 'raw', *args):
  1078.     if len(args) == 1 and isTupleType(args[0]):
  1079.         args = args[0]
  1080.     
  1081.     if decoder_name == 'raw' and args == ():
  1082.         args = mode
  1083.     
  1084.     im = new(mode, size)
  1085.     im.fromstring(data, decoder_name, args)
  1086.     return im
  1087.  
  1088.  
  1089. def frombuffer(mode, size, data, decoder_name = 'raw', *args):
  1090.     if len(args) == 1 and isTupleType(args[0]):
  1091.         args = args[0]
  1092.     
  1093.     if decoder_name == 'raw':
  1094.         if args == ():
  1095.             if warnings:
  1096.                 warnings.warn("the frombuffer defaults may change in a future release; for portability, change the call to read:\n  frombuffer(mode, size, data, 'raw', mode, 0, 1)", RuntimeWarning, stacklevel = 2)
  1097.             
  1098.             args = (mode, 0, -1)
  1099.         
  1100.         if args[0] in _MAPMODES:
  1101.             im = new(mode, (1, 1))
  1102.             im = im._new(core.map_buffer(data, size, decoder_name, None, 0, args))
  1103.             im.readonly = 1
  1104.             return im
  1105.     
  1106.     return apply(fromstring, (mode, size, data, decoder_name, args))
  1107.  
  1108.  
  1109. def fromarray(obj, mode = None):
  1110.     arr = obj.__array_interface__
  1111.     shape = arr['shape']
  1112.     ndim = len(shape)
  1113.     
  1114.     try:
  1115.         strides = arr['strides']
  1116.     except KeyError:
  1117.         strides = None
  1118.  
  1119.     if mode is None:
  1120.         typestr = arr['typestr']
  1121.         if not typestr[0] == '|' and typestr[0] == _ENDIAN or typestr[1:] not in ('u1', 'b1', 'i4', 'f4'):
  1122.             raise TypeError('cannot handle data-type')
  1123.         typestr[1:] not in ('u1', 'b1', 'i4', 'f4')
  1124.         typestr = typestr[:2]
  1125.         if typestr == 'i4':
  1126.             mode = 'I'
  1127.         elif typestr == 'f4':
  1128.             mode = 'F'
  1129.         elif typestr == 'b1':
  1130.             mode = '1'
  1131.         elif ndim == 2:
  1132.             mode = 'L'
  1133.         elif ndim == 3:
  1134.             mode = 'RGB'
  1135.         elif ndim == 4:
  1136.             mode = 'RGBA'
  1137.         else:
  1138.             raise TypeError('Do not understand data.')
  1139.     typestr == 'i4'
  1140.     ndmax = 4
  1141.     bad_dims = 0
  1142.     if mode in ('1', 'L', 'I', 'P', 'F'):
  1143.         ndmax = 2
  1144.     elif mode == 'RGB':
  1145.         ndmax = 3
  1146.     
  1147.     if ndim > ndmax:
  1148.         raise ValueError('Too many dimensions.')
  1149.     ndim > ndmax
  1150.     size = shape[:2][::-1]
  1151.     if strides is not None:
  1152.         obj = obj.tostring()
  1153.     
  1154.     return frombuffer(mode, size, obj, 'raw', mode, 0, 1)
  1155.  
  1156.  
  1157. def open(fp, mode = 'r'):
  1158.     if mode != 'r':
  1159.         raise ValueError('bad mode')
  1160.     mode != 'r'
  1161.     if isStringType(fp):
  1162.         import __builtin__
  1163.         filename = fp
  1164.         fp = __builtin__.open(fp, 'rb')
  1165.     else:
  1166.         filename = ''
  1167.     prefix = fp.read(16)
  1168.     preinit()
  1169.     for i in ID:
  1170.         
  1171.         try:
  1172.             (factory, accept) = OPEN[i]
  1173.             if not accept or accept(prefix):
  1174.                 fp.seek(0)
  1175.                 return factory(fp, filename)
  1176.         continue
  1177.         except (SyntaxError, IndexError, TypeError):
  1178.             continue
  1179.         
  1180.  
  1181.     
  1182.     init()
  1183.     for i in ID:
  1184.         
  1185.         try:
  1186.             (factory, accept) = OPEN[i]
  1187.             if not accept or accept(prefix):
  1188.                 fp.seek(0)
  1189.                 return factory(fp, filename)
  1190.         continue
  1191.         except (SyntaxError, IndexError, TypeError):
  1192.             None<EXCEPTION MATCH>(SyntaxError, IndexError, TypeError)
  1193.             None<EXCEPTION MATCH>(SyntaxError, IndexError, TypeError)
  1194.             continue
  1195.         
  1196.  
  1197.     
  1198.     raise IOError('cannot identify image file')
  1199.  
  1200.  
  1201. def blend(im1, im2, alpha):
  1202.     im1.load()
  1203.     im2.load()
  1204.     return im1._new(core.blend(im1.im, im2.im, alpha))
  1205.  
  1206.  
  1207. def composite(image1, image2, mask):
  1208.     image = image2.copy()
  1209.     image.paste(image1, None, mask)
  1210.     return image
  1211.  
  1212.  
  1213. def eval(image, *args):
  1214.     return image.point(args[0])
  1215.  
  1216.  
  1217. def merge(mode, bands):
  1218.     if getmodebands(mode) != len(bands) or '*' in mode:
  1219.         raise ValueError('wrong number of bands')
  1220.     '*' in mode
  1221.     for im in bands[1:]:
  1222.         if im.mode != getmodetype(mode):
  1223.             raise ValueError('mode mismatch')
  1224.         im.mode != getmodetype(mode)
  1225.         if im.size != bands[0].size:
  1226.             raise ValueError('size mismatch')
  1227.         im.size != bands[0].size
  1228.     
  1229.     im = core.new(mode, bands[0].size)
  1230.     for i in range(getmodebands(mode)):
  1231.         bands[i].load()
  1232.         im.putband(bands[i].im, i)
  1233.     
  1234.     return bands[0]._new(im)
  1235.  
  1236.  
  1237. def register_open(id, factory, accept = None):
  1238.     id = string.upper(id)
  1239.     ID.append(id)
  1240.     OPEN[id] = (factory, accept)
  1241.  
  1242.  
  1243. def register_mime(id, mimetype):
  1244.     MIME[string.upper(id)] = mimetype
  1245.  
  1246.  
  1247. def register_save(id, driver):
  1248.     SAVE[string.upper(id)] = driver
  1249.  
  1250.  
  1251. def register_extension(id, extension):
  1252.     EXTENSION[string.lower(extension)] = string.upper(id)
  1253.  
  1254.  
  1255. def _showxv(image, title = None, command = None):
  1256.     if os.name == 'nt':
  1257.         format = 'BMP'
  1258.     elif sys.platform == 'darwin':
  1259.         format = 'JPEG'
  1260.         if not command:
  1261.             command = 'open -a /Applications/Preview.app'
  1262.         
  1263.     else:
  1264.         format = None
  1265.         if not command:
  1266.             command = 'xv'
  1267.             if title:
  1268.                 command = command + ' -name "%s"' % title
  1269.             
  1270.         
  1271.     if image.mode == 'I;16':
  1272.         base = 'L'
  1273.     else:
  1274.         base = getmodebase(image.mode)
  1275.     if base != image.mode and image.mode != '1':
  1276.         file = image.convert(base)._dump(format = format)
  1277.     else:
  1278.         file = image._dump(format = format)
  1279.     if os.name == 'nt':
  1280.         command = 'start /wait %s && del /f %s' % (file, file)
  1281.     elif sys.platform == 'darwin':
  1282.         command = '(%s %s; sleep 20; rm -f %s)&' % (command, file, file)
  1283.     else:
  1284.         command = '(%s %s; rm -f %s)&' % (command, file, file)
  1285.     os.system(command)
  1286.  
  1287.