add PIL library

tg2env/bin/pilconvert.py

@@ -0,0 +1,96 @@
+#!/home/daccorsi/sources/protos/pboard/tg2env/bin/python
+#
+# The Python Imaging Library.
+# $Id$
+#
+# convert image files
+#
+# History:
+# 0.1   96-04-20 fl     Created
+# 0.2   96-10-04 fl     Use draft mode when converting images
+# 0.3   96-12-30 fl     Optimize output (PNG, JPEG)
+# 0.4   97-01-18 fl     Made optimize an option (PNG, JPEG)
+# 0.5   98-12-30 fl     Fixed -f option (from Anthony Baxter)
+#
+
+import site
+import getopt, string, sys
+
+from PIL import Image
+
+def usage():
+    print "PIL Convert 0.5/1998-12-30 -- convert image files"
+    print "Usage: pilconvert [option] infile outfile"
+    print
+    print "Options:"
+    print
+    print "  -c <format>  convert to format (default is given by extension)"
+    print
+    print "  -g           convert to greyscale"
+    print "  -p           convert to palette image (using standard palette)"
+    print "  -r           convert to rgb"
+    print
+    print "  -o           optimize output (trade speed for size)"
+    print "  -q <value>   set compression quality (0-100, JPEG only)"
+    print
+    print "  -f           list supported file formats"
+    sys.exit(1)
+
+if len(sys.argv) == 1:
+    usage()
+
+try:
+    opt, argv = getopt.getopt(sys.argv[1:], "c:dfgopq:r")
+except getopt.error, v:
+    print v
+    sys.exit(1)
+
+format = None
+convert = None
+
+options = { }
+
+for o, a in opt:
+
+    if o == "-f":
+        Image.init()
+        id = Image.ID[:]
+        id.sort()
+        print "Supported formats (* indicates output format):"
+        for i in id:
+            if Image.SAVE.has_key(i):
+                print i+"*",
+            else:
+                print i,
+        sys.exit(1)
+
+    elif o == "-c":
+        format = a
+
+    if o == "-g":
+        convert = "L"
+    elif o == "-p":
+        convert = "P"
+    elif o == "-r":
+        convert = "RGB"
+
+    elif o == "-o":
+        options["optimize"] = 1
+    elif o == "-q":
+        options["quality"] = string.atoi(a)
+
+if len(argv) != 2:
+    usage()
+
+try:
+    im = Image.open(argv[0])
+    if convert and im.mode != convert:
+        im.draft(convert, im.size)
+        im = im.convert(convert)
+    if format:
+        apply(im.save, (argv[1], format), options)
+    else:
+        apply(im.save, (argv[1],), options)
+except:
+    print "cannot convert image",
+    print "(%s:%s)" % (sys.exc_type, sys.exc_value)

tg2env/bin/pildriver.py

@@ -0,0 +1,524 @@
+#!/home/daccorsi/sources/protos/pboard/tg2env/bin/python
+"""PILdriver, an image-processing calculator using PIL.
+
+An instance of class PILDriver is essentially a software stack machine
+(Polish-notation interpreter) for sequencing PIL image
+transformations.  The state of the instance is the interpreter stack.
+
+The only method one will normally invoke after initialization is the
+`execute' method.  This takes an argument list of tokens, pushes them
+onto the instance's stack, and then tries to clear the stack by
+successive evaluation of PILdriver operators.  Any part of the stack
+not cleaned off persists and is part of the evaluation context for
+the next call of the execute method.
+
+PILDriver doesn't catch any exceptions, on the theory that these
+are actually diagnostic information that should be interpreted by
+the calling code.
+
+When called as a script, the command-line arguments are passed to
+a PILDriver instance.  If there are no command-line arguments, the
+module runs an interactive interpreter, each line of which is split into
+space-separated tokens and passed to the execute method.
+
+In the method descriptions below, a first line beginning with the string
+`usage:' means this method can be invoked with the token that follows
+it.  Following <>-enclosed arguments describe how the method interprets
+the entries on the stack.  Each argument specification begins with a
+type specification: either `int', `float', `string', or `image'.
+
+All operations consume their arguments off the stack (use `dup' to
+keep copies around).  Use `verbose 1' to see the stack state displayed
+before each operation.
+
+Usage examples:
+
+    `show crop 0 0 200 300 open test.png' loads test.png, crops out a portion
+of its upper-left-hand corner and displays the cropped portion.
+
+    `save rotated.png rotate 30 open test.tiff' loads test.tiff, rotates it
+30 degrees, and saves the result as rotated.png (in PNG format).
+"""
+# by Eric S. Raymond <esr@thyrsus.com>
+# $Id$
+
+# TO DO:
+# 1. Add PILFont capabilities, once that's documented.
+# 2. Add PILDraw operations.
+# 3. Add support for composing and decomposing multiple-image files.
+#
+
+from PIL import Image
+import string
+
+class PILDriver:
+
+    verbose = 0
+
+    def do_verbose(self):
+        """usage: verbose <int:num>
+
+        Set verbosity flag from top of stack.
+        """
+        self.verbose = self.do_pop()
+
+    # The evaluation stack (internal only)
+
+    stack = []          # Stack of pending operations
+
+    def push(self, item):
+        "Push an argument onto the evaluation stack."
+        self.stack = [item] + self.stack
+
+    def top(self):
+        "Return the top-of-stack element."
+        return self.stack[0]
+
+    # Stack manipulation (callable)
+
+    def do_clear(self):
+        """usage: clear
+
+        Clear the stack.
+        """
+        self.stack = []
+
+    def do_pop(self):
+        """usage: pop
+
+        Discard the top element on the stack.
+        """
+        top = self.stack[0]
+        self.stack = self.stack[1:]
+        return top
+
+    def do_dup(self):
+        """usage: dup
+
+        Duplicate the top-of-stack item.
+        """
+        if hasattr(self, 'format'):     # If it's an image, do a real copy
+            dup = self.stack[0].copy()
+        else:
+            dup = self.stack[0]
+        self.stack = [dup] + self.stack
+
+    def do_swap(self):
+        """usage: swap
+
+        Swap the top-of-stack item with the next one down.
+        """
+        self.stack = [self.stack[1], self.stack[0]] + self.stack[2:]
+
+    # Image module functions (callable)
+
+    def do_new(self):
+        """usage: new <int:xsize> <int:ysize> <int:color>:
+
+        Create and push a greyscale image of given size and color.
+        """
+        xsize = int(self.do_pop())
+        ysize = int(self.do_pop())
+        color = int(self.do_pop())
+        self.push(Image.new("L", (xsize, ysize), color))
+
+    def do_open(self):
+        """usage: open <string:filename>
+
+        Open the indicated image, read it, push the image on the stack.
+        """
+        self.push(Image.open(self.do_pop()))
+
+    def do_blend(self):
+        """usage: blend <image:pic1> <image:pic2> <float:alpha>
+
+        Replace two images and an alpha with the blended image.
+        """
+        image1 = self.do_pop()
+        image2 = self.do_pop()
+        alpha = float(self.do_pop())
+        self.push(Image.blend(image1, image2, alpha))
+
+    def do_composite(self):
+        """usage: composite <image:pic1> <image:pic2> <image:mask>
+
+        Replace two images and a mask with their composite.
+        """
+        image1 = self.do_pop()
+        image2 = self.do_pop()
+        mask = self.do_pop()
+        self.push(Image.composite(image1, image2, mask))
+
+    def do_merge(self):
+        """usage: merge <string:mode> <image:pic1> [<image:pic2> [<image:pic3> [<image:pic4>]]]
+
+        Merge top-of stack images in a way described by the mode.
+        """
+        mode = self.do_pop()
+        bandlist = []
+        for band in mode:
+            bandlist.append(self.do_pop())
+        self.push(Image.merge(mode, bandlist))
+
+    # Image class methods
+
+    def do_convert(self):
+        """usage: convert <string:mode> <image:pic1>
+
+        Convert the top image to the given mode.
+        """
+        mode = self.do_pop()
+        image = self.do_pop()
+        self.push(image.convert(mode))
+
+    def do_copy(self):
+        """usage: copy <image:pic1>
+
+        Make and push a true copy of the top image.
+        """
+        self.dup()
+
+    def do_crop(self):
+        """usage: crop <int:left> <int:upper> <int:right> <int:lower> <image:pic1>
+
+        Crop and push a rectangular region from the current image.
+        """
+        left = int(self.do_pop())
+        upper = int(self.do_pop())
+        right = int(self.do_pop())
+        lower = int(self.do_pop())
+        image = self.do_pop()
+        self.push(image.crop((left, upper, right, lower)))
+
+    def do_draft(self):
+        """usage: draft <string:mode> <int:xsize> <int:ysize>
+
+        Configure the loader for a given mode and size.
+        """
+        mode = self.do_pop()
+        xsize = int(self.do_pop())
+        ysize = int(self.do_pop())
+        self.push(self.draft(mode, (xsize, ysize)))
+
+    def do_filter(self):
+        """usage: filter <string:filtername> <image:pic1>
+
+        Process the top image with the given filter.
+        """
+        import ImageFilter
+        filter = eval("ImageFilter." + string.upper(self.do_pop()))
+        image = self.do_pop()
+        self.push(image.filter(filter))
+
+    def do_getbbox(self):
+        """usage: getbbox
+
+        Push left, upper, right, and lower pixel coordinates of the top image.
+        """
+        bounding_box = self.do_pop().getbbox()
+        self.push(bounding_box[3])
+        self.push(bounding_box[2])
+        self.push(bounding_box[1])
+        self.push(bounding_box[0])
+
+    def do_getextrema(self):
+        """usage: extrema
+
+        Push minimum and maximum pixel values of the top image.
+        """
+        extrema = self.do_pop().extrema()
+        self.push(extrema[1])
+        self.push(extrema[0])
+
+    def do_offset(self):
+        """usage: offset <int:xoffset> <int:yoffset> <image:pic1>
+
+        Offset the pixels in the top image.
+        """
+        xoff = int(self.do_pop())
+        yoff = int(self.do_pop())
+        image = self.do_pop()
+        self.push(image.offset(xoff, yoff))
+
+    def do_paste(self):
+        """usage: paste <image:figure> <int:xoffset> <int:yoffset> <image:ground>
+
+        Paste figure image into ground with upper left at given offsets.
+        """
+        figure = self.do_pop()
+        xoff = int(self.do_pop())
+        yoff = int(self.do_pop())
+        ground = self.do_pop()
+        if figure.mode == "RGBA":
+            ground.paste(figure, (xoff, yoff), figure)
+        else:
+            ground.paste(figure, (xoff, yoff))
+        self.push(ground)
+
+    def do_resize(self):
+        """usage: resize <int:xsize> <int:ysize> <image:pic1>
+
+        Resize the top image.
+        """
+        ysize = int(self.do_pop())
+        xsize = int(self.do_pop())
+        image = self.do_pop()
+        self.push(image.resize((xsize, ysize)))
+
+    def do_rotate(self):
+        """usage: rotate <int:angle> <image:pic1>
+
+        Rotate image through a given angle
+        """
+        angle = int(self.do_pop())
+        image = self.do_pop()
+        self.push(image.rotate(angle))
+
+    def do_save(self):
+        """usage: save <string:filename> <image:pic1>
+
+        Save image with default options.
+        """
+        filename = self.do_pop()
+        image = self.do_pop()
+        image.save(filename)
+
+    def do_save2(self):
+        """usage: save2 <string:filename> <string:options> <image:pic1>
+
+        Save image with specified options.
+        """
+        filename = self.do_pop()
+        options = self.do_pop()
+        image = self.do_pop()
+        image.save(filename, None, options)
+
+    def do_show(self):
+        """usage: show <image:pic1>
+
+        Display and pop the top image.
+        """
+        self.do_pop().show()
+
+    def do_thumbnail(self):
+        """usage: thumbnail <int:xsize> <int:ysize> <image:pic1>
+
+        Modify the top image in the stack to contain a thumbnail of itself.
+        """
+        ysize = int(self.do_pop())
+        xsize = int(self.do_pop())
+        self.top().thumbnail((xsize, ysize))
+
+    def do_transpose(self):
+        """usage: transpose <string:operator> <image:pic1>
+
+        Transpose the top image.
+        """
+        transpose = string.upper(self.do_pop())
+        image = self.do_pop()
+        self.push(image.transpose(transpose))
+
+    # Image attributes
+
+    def do_format(self):
+        """usage: format <image:pic1>
+
+        Push the format of the top image onto the stack.
+        """
+        self.push(self.pop().format)
+
+    def do_mode(self):
+        """usage: mode <image:pic1>
+
+        Push the mode of the top image onto the stack.
+        """
+        self.push(self.pop().mode)
+
+    def do_size(self):
+        """usage: size <image:pic1>
+
+        Push the image size on the stack as (y, x).
+        """
+        size = self.pop().size
+        self.push(size[0])
+        self.push(size[1])
+
+    # ImageChops operations
+
+    def do_invert(self):
+        """usage: invert <image:pic1>
+
+        Invert the top image.
+        """
+        import ImageChops
+        self.push(ImageChops.invert(self.do_pop()))
+
+    def do_lighter(self):
+        """usage: lighter <image:pic1> <image:pic2>
+
+        Pop the two top images, push an image of the lighter pixels of both.
+        """
+        import ImageChops
+        image1 = self.do_pop()
+        image2 = self.do_pop()
+        self.push(ImageChops.lighter(image1, image2))
+
+    def do_darker(self):
+        """usage: darker <image:pic1> <image:pic2>
+
+        Pop the two top images, push an image of the darker pixels of both.
+        """
+        import ImageChops
+        image1 = self.do_pop()
+        image2 = self.do_pop()
+        self.push(ImageChops.darker(image1, image2))
+
+    def do_difference(self):
+        """usage: difference <image:pic1> <image:pic2>
+
+        Pop the two top images, push the difference image
+        """
+        import ImageChops
+        image1 = self.do_pop()
+        image2 = self.do_pop()
+        self.push(ImageChops.difference(image1, image2))
+
+    def do_multiply(self):
+        """usage: multiply <image:pic1> <image:pic2>
+
+        Pop the two top images, push the multiplication image.
+        """
+        import ImageChops
+        image1 = self.do_pop()
+        image2 = self.do_pop()
+        self.push(ImageChops.multiply(image1, image2))
+
+    def do_screen(self):
+        """usage: screen <image:pic1> <image:pic2>
+
+        Pop the two top images, superimpose their inverted versions.
+        """
+        import ImageChops
+        image2 = self.do_pop()
+        image1 = self.do_pop()
+        self.push(ImageChops.screen(image1, image2))
+
+    def do_add(self):
+        """usage: add <image:pic1> <image:pic2> <int:offset> <float:scale>
+
+        Pop the two top images, produce the scaled sum with offset.
+        """
+        import ImageChops
+        image1 = self.do_pop()
+        image2 = self.do_pop()
+        scale = float(self.do_pop())
+        offset = int(self.do_pop())
+        self.push(ImageChops.add(image1, image2, scale, offset))
+
+    def do_subtract(self):
+        """usage: subtract <image:pic1> <image:pic2> <int:offset> <float:scale>
+
+        Pop the two top images, produce the scaled difference with offset.
+        """
+        import ImageChops
+        image1 = self.do_pop()
+        image2 = self.do_pop()
+        scale = float(self.do_pop())
+        offset = int(self.do_pop())
+        self.push(ImageChops.subtract(image1, image2, scale, offset))
+
+    # ImageEnhance classes
+
+    def do_color(self):
+        """usage: color <image:pic1>
+
+        Enhance color in the top image.
+        """
+        import ImageEnhance
+        factor = float(self.do_pop())
+        image = self.do_pop()
+        enhancer = ImageEnhance.Color(image)
+        self.push(enhancer.enhance(factor))
+
+    def do_contrast(self):
+        """usage: contrast <image:pic1>
+
+        Enhance contrast in the top image.
+        """
+        import ImageEnhance
+        factor = float(self.do_pop())
+        image = self.do_pop()
+        enhancer = ImageEnhance.Color(image)
+        self.push(enhancer.enhance(factor))
+
+    def do_brightness(self):
+        """usage: brightness <image:pic1>
+
+        Enhance brightness in the top image.
+        """
+        import ImageEnhance
+        factor = float(self.do_pop())
+        image = self.do_pop()
+        enhancer = ImageEnhance.Color(image)
+        self.push(enhancer.enhance(factor))
+
+    def do_sharpness(self):
+        """usage: sharpness <image:pic1>
+
+        Enhance sharpness in the top image.
+        """
+        import ImageEnhance
+        factor = float(self.do_pop())
+        image = self.do_pop()
+        enhancer = ImageEnhance.Color(image)
+        self.push(enhancer.enhance(factor))
+
+    # The interpreter loop
+
+    def execute(self, list):
+        "Interpret a list of PILDriver commands."
+        list.reverse()
+        while len(list) > 0:
+            self.push(list[0])
+            list = list[1:]
+            if self.verbose:
+                print "Stack: " + `self.stack`
+            top = self.top()
+            if type(top) != type(""):
+                continue;
+            funcname = "do_" + top
+            if not hasattr(self, funcname):
+                continue
+            else:
+                self.do_pop()
+                func = getattr(self, funcname)
+                func()
+
+if __name__ == '__main__':
+    import sys
+    try:
+        import readline
+    except ImportError:
+        pass # not available on all platforms
+
+    # If we see command-line arguments, interpret them as a stack state
+    # and execute.  Otherwise go interactive.
+
+    driver = PILDriver()
+    if len(sys.argv[1:]) > 0:
+        driver.execute(sys.argv[1:])
+    else:
+        print "PILDriver says hello."
+        while 1:
+            try:
+                line = raw_input('pildriver> ');
+            except EOFError:
+                print "\nPILDriver says goodbye."
+                break
+            driver.execute(string.split(line))
+            print driver.stack
+
+# The following sets edit modes for GNU EMACS
+# Local Variables:
+# mode:python
+# End:

tg2env/bin/pilfile.py

@@ -0,0 +1,94 @@
+#!/home/daccorsi/sources/protos/pboard/tg2env/bin/python
+#
+# The Python Imaging Library.
+# $Id$
+#
+# a utility to identify image files
+#
+# this script identifies image files, extracting size and
+# pixel mode information for known file formats.  Note that
+# you don't need the PIL C extension to use this module.
+#
+# History:
+# 0.0 1995-09-01 fl   Created
+# 0.1 1996-05-18 fl   Modified options, added debugging mode
+# 0.2 1996-12-29 fl   Added verify mode
+# 0.3 1999-06-05 fl   Don't mess up on class exceptions (1.5.2 and later)
+# 0.4 2003-09-30 fl   Expand wildcards on Windows; robustness tweaks
+#
+
+import site
+import getopt, glob, sys
+
+from PIL import Image
+
+if len(sys.argv) == 1:
+    print "PIL File 0.4/2003-09-30 -- identify image files"
+    print "Usage: pilfile [option] files..."
+    print "Options:"
+    print "  -f  list supported file formats"
+    print "  -i  show associated info and tile data"
+    print "  -v  verify file headers"
+    print "  -q  quiet, don't warn for unidentified/missing/broken files"
+    sys.exit(1)
+
+try:
+    opt, args = getopt.getopt(sys.argv[1:], "fqivD")
+except getopt.error, v:
+    print v
+    sys.exit(1)
+
+verbose = quiet = verify = 0
+
+for o, a in opt:
+    if o == "-f":
+        Image.init()
+        id = Image.ID[:]
+        id.sort()
+        print "Supported formats:"
+        for i in id:
+            print i,
+        sys.exit(1)
+    elif o == "-i":
+        verbose = 1
+    elif o == "-q":
+        quiet = 1
+    elif o == "-v":
+        verify = 1
+    elif o == "-D":
+        Image.DEBUG = Image.DEBUG + 1
+
+def globfix(files):
+    # expand wildcards where necessary
+    if sys.platform == "win32":
+        out = []
+        for file in files:
+            if glob.has_magic(file):
+                out.extend(glob.glob(file))
+            else:
+                out.append(file)
+        return out
+    return files
+
+for file in globfix(args):
+    try:
+        im = Image.open(file)
+        print "%s:" % file, im.format, "%dx%d" % im.size, im.mode,
+        if verbose:
+            print im.info, im.tile,
+        print
+        if verify:
+            try:
+                im.verify()
+            except:
+                if not quiet:
+                    print "failed to verify image",
+                    print "(%s:%s)" % (sys.exc_type, sys.exc_value)
+    except IOError, v:
+        if not quiet:
+            print file, "failed:", v
+    except:
+        import traceback
+        if not quiet:
+            print file, "failed:", "unexpected error"
+            traceback.print_exc(file=sys.stdout)

tg2env/bin/pilfont.py

@@ -0,0 +1,54 @@
+#
+# The Python Imaging Library
+# $Id$
+#
+# PIL raster font compiler
+#
+# history:
+# 1997-08-25 fl   created
+# 2002-03-10 fl   use "from PIL import"
+#
+
+VERSION = "0.4"
+
+import site
+import glob, os, sys
+
+# drivers
+from PIL import BdfFontFile
+from PIL import PcfFontFile
+
+if len(sys.argv) <= 1:
+    print "PILFONT", VERSION, "-- PIL font compiler."
+    print
+    print "Usage: pilfont fontfiles..."
+    print
+    print "Convert given font files to the PIL raster font format."
+    print "This version of pilfont supports X BDF and PCF fonts."
+    sys.exit(1)
+
+files = []
+for f in sys.argv[1:]:
+    files = files + glob.glob(f)
+
+for f in files:
+
+    print f + "...",
+
+    try:
+
+        fp = open(f, "rb")
+
+        try:
+            p = PcfFontFile.PcfFontFile(fp)
+        except SyntaxError:
+            fp.seek(0)
+            p = BdfFontFile.BdfFontFile(fp)
+
+        p.save(f)
+
+    except (SyntaxError, IOError):
+        print "failed"
+
+    else:
+        print "OK"

tg2env/bin/pilprint.py

@@ -0,0 +1,93 @@
+#!/home/daccorsi/sources/protos/pboard/tg2env/bin/python
+#
+# The Python Imaging Library.
+# $Id$
+#
+# print image files to postscript printer
+#
+# History:
+# 0.1   1996-04-20 fl   Created
+# 0.2   1996-10-04 fl   Use draft mode when converting.
+# 0.3   2003-05-06 fl   Fixed a typo or two.
+#
+
+VERSION = "pilprint 0.3/2003-05-05"
+
+from PIL import Image
+from PIL import PSDraw
+
+letter = ( 1.0*72, 1.0*72, 7.5*72, 10.0*72 )
+
+def description(file, image):
+    import os
+    title = os.path.splitext(os.path.split(file)[1])[0]
+    format = " (%dx%d "
+    if image.format:
+        format = " (" + image.format + " %dx%d "
+    return title + format % image.size + image.mode + ")"
+
+import getopt, os, sys
+
+if len(sys.argv) == 1:
+    print "PIL Print 0.2a1/96-10-04 -- print image files"
+    print "Usage: pilprint files..."
+    print "Options:"
+    print "  -c            colour printer (default is monochrome)"
+    print "  -p            print via lpr (default is stdout)"
+    print "  -P <printer>  same as -p but use given printer"
+    sys.exit(1)
+
+try:
+    opt, argv = getopt.getopt(sys.argv[1:], "cdpP:")
+except getopt.error, v:
+    print v
+    sys.exit(1)
+
+printer = None # print to stdout
+monochrome = 1 # reduce file size for most common case
+
+for o, a in opt:
+    if o == "-d":
+        # debug: show available drivers
+        Image.init()
+        print Image.ID
+        sys.exit(1)
+    elif o == "-c":
+        # colour printer
+        monochrome = 0
+    elif o == "-p":
+        # default printer channel
+        printer = "lpr"
+    elif o == "-P":
+        # printer channel
+        printer = "lpr -P%s" % a
+
+for file in argv:
+    try:
+
+        im = Image.open(file)
+
+        title = description(file, im)
+
+        if monochrome and im.mode not in ["1", "L"]:
+            im.draft("L", im.size)
+            im = im.convert("L")
+
+        if printer:
+            fp = os.popen(printer, "w")
+        else:
+            fp = sys.stdout
+
+        ps = PSDraw.PSDraw(fp)
+
+        ps.begin_document()
+        ps.setfont("Helvetica-Narrow-Bold", 18)
+        ps.text((letter[0], letter[3]+24), title)
+        ps.setfont("Helvetica-Narrow-Bold", 8)
+        ps.text((letter[0], letter[1]-30), VERSION)
+        ps.image(letter, im)
+        ps.end_document()
+
+    except:
+        print "cannot print image",
+        print "(%s:%s)" % (sys.exc_type, sys.exc_value)