1 #! /usr/bin/env python

     2 

     3 """Simple test script for imgfile.c

     4    Roger E. Masse

     5 """

     6 

     7 from test.test_support import verbose, unlink, findfile, import_module

     8 

     9 imgfile = import_module('imgfile', deprecated=True)

    10 import uu

    11 

    12 

    13 def testimage(name):

    14     """Run through the imgfile's battery of possible methods

    15        on the image passed in name.

    16     """

    17 

    18     import sys

    19     import os

    20 

    21     outputfile = '/tmp/deleteme'

    22 

    23     # try opening the name directly

    24     try:

    25         # This function returns a tuple (x, y, z) where x and y are the size

    26         # of the image in pixels and z is the number of bytes per pixel. Only

    27         # 3 byte RGB pixels and 1 byte greyscale pixels are supported.

    28         sizes = imgfile.getsizes(name)

    29     except imgfile.error:

    30         # get a more qualified path component of the script...

    31         if __name__ == '__main__':

    32             ourname = sys.argv[0]

    33         else: # ...or the full path of the module

    34             ourname = sys.modules[__name__].__file__

    35 

    36         parts = ourname.split(os.sep)

    37         parts[-1] = name

    38         name = os.sep.join(parts)

    39         sizes = imgfile.getsizes(name)

    40     if verbose:

    41         print 'Opening test image: %s, sizes: %s' % (name, str(sizes))

    42     # This function reads and decodes the image on the specified file,

    43     # and returns it as a python string. The string has either 1 byte

    44     # greyscale pixels or 4 byte RGBA pixels. The bottom left pixel

    45     # is the first in the string. This format is suitable to pass

    46     # to gl.lrectwrite, for instance.

    47     image = imgfile.read(name)

    48 

    49     # This function writes the RGB or greyscale data in data to

    50     # image file file. x and y give the size of the image, z is

    51     # 1 for 1 byte greyscale images or 3 for RGB images (which

    52     # are stored as 4 byte values of which only the lower three

    53     # bytes are used). These are the formats returned by gl.lrectread.

    54     if verbose:

    55         print 'Writing output file'

    56     imgfile.write (outputfile, image, sizes[0], sizes[1], sizes[2])

    57 

    58 

    59     if verbose:

    60         print 'Opening scaled test image: %s, sizes: %s' % (name, str(sizes))

    61     # This function is identical to read but it returns an image that

    62     # is scaled to the given x and y sizes. If the filter and blur

    63     # parameters are omitted scaling is done by simply dropping

    64     # or duplicating pixels, so the result will be less than perfect,

    65     # especially for computer-generated images.  Alternatively,

    66     # you can specify a filter to use to smoothen the image after

    67     # scaling. The filter forms supported are 'impulse', 'box',

    68     # 'triangle', 'quadratic' and 'gaussian'. If a filter is

    69     # specified blur is an optional parameter specifying the

    70     # blurriness of the filter. It defaults to 1.0.  readscaled

    71     # makes no attempt to keep the aspect ratio correct, so that

    72     # is the users' responsibility.

    73     if verbose:

    74         print 'Filtering with "impulse"'

    75     simage = imgfile.readscaled (name, sizes[0]/2, sizes[1]/2, 'impulse', 2.0)

    76 

    77     # This function sets a global flag which defines whether the

    78     # scan lines of the image are read or written from bottom to

    79     # top (flag is zero, compatible with SGI GL) or from top to

    80     # bottom(flag is one, compatible with X). The default is zero.

    81     if verbose:

    82         print 'Switching to X compatibility'

    83     imgfile.ttob (1)

    84 

    85     if verbose:

    86         print 'Filtering with "triangle"'

    87     simage = imgfile.readscaled (name, sizes[0]/2, sizes[1]/2, 'triangle', 3.0)

    88     if verbose:

    89         print 'Switching back to SGI compatibility'

    90     imgfile.ttob (0)

    91 

    92     if verbose: print 'Filtering with "quadratic"'

    93     simage = imgfile.readscaled (name, sizes[0]/2, sizes[1]/2, 'quadratic')

    94     if verbose: print 'Filtering with "gaussian"'

    95     simage = imgfile.readscaled (name, sizes[0]/2, sizes[1]/2, 'gaussian', 1.0)

    96 

    97     if verbose:

    98         print 'Writing output file'

    99     imgfile.write (outputfile, simage, sizes[0]/2, sizes[1]/2, sizes[2])

   100 

   101     os.unlink(outputfile)

   102 

   103 

   104 def test_main():

   105 

   106     uu.decode(findfile('testrgb.uue'), 'test.rgb')

   107     uu.decode(findfile('greyrgb.uue'), 'greytest.rgb')

   108 

   109     # Test a 3 byte color image

   110     testimage('test.rgb')

   111 

   112     # Test a 1 byte greyscale image

   113     testimage('greytest.rgb')

   114 

   115     unlink('test.rgb')

   116     unlink('greytest.rgb')

   117 

   118 if __name__ == '__main__':

   119     test_main()