home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / test_imageop.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  6.7 KB  |  211 lines
  1. #! /usr/bin/env python
  2.  
  3. """Test script for the imageop module.  This has the side
  4.    effect of partially testing the imgfile module as well.
  5.    Roger E. Masse
  6. """
  7.  
  8. from test.test_support import verbose, unlink, import_module, run_unittest
  9.  
  10. imageop = import_module('imageop', deprecated=True)
  11. import uu, os, unittest
  12.  
  13.  
  14. SIZES = (1, 2, 3, 4)
  15. _VALUES = (1, 2, 2**10, 2**15-1, 2**15, 2**15+1, 2**31-2, 2**31-1)
  16. VALUES = tuple( -x for x in reversed(_VALUES) ) + (0,) + _VALUES
  17. AAAAA = "A" * 1024
  18. MAX_LEN = 2**20
  19.  
  20.  
  21. class InputValidationTests(unittest.TestCase):
  22.  
  23.     def _check(self, name, size=None, *extra):
  24.         func = getattr(imageop, name)
  25.         for height in VALUES:
  26.             for width in VALUES:
  27.                 strlen = abs(width * height)
  28.                 if size:
  29.                     strlen *= size
  30.                 if strlen < MAX_LEN:
  31.                     data = "A" * strlen
  32.                 else:
  33.                     data = AAAAA
  34.                 if size:
  35.                     arguments = (data, size, width, height) + extra
  36.                 else:
  37.                     arguments = (data, width, height) + extra
  38.                 try:
  39.                     func(*arguments)
  40.                 except (ValueError, imageop.error):
  41.                     pass
  42.  
  43.     def check_size(self, name, *extra):
  44.         for size in SIZES:
  45.             self._check(name, size, *extra)
  46.  
  47.     def check(self, name, *extra):
  48.         self._check(name, None, *extra)
  49.  
  50.     def test_input_validation(self):
  51.         self.check_size("crop", 0, 0, 0, 0)
  52.         self.check_size("scale", 1, 0)
  53.         self.check_size("scale", -1, -1)
  54.         self.check_size("tovideo")
  55.         self.check("grey2mono", 128)
  56.         self.check("grey2grey4")
  57.         self.check("grey2grey2")
  58.         self.check("dither2mono")
  59.         self.check("dither2grey2")
  60.         self.check("mono2grey", 0, 0)
  61.         self.check("grey22grey")
  62.         self.check("rgb2rgb8") # nlen*4 == len
  63.         self.check("rgb82rgb")
  64.         self.check("rgb2grey")
  65.         self.check("grey2rgb")
  66.  
  67.  
  68. def test_main():
  69.  
  70.     run_unittest(InputValidationTests)
  71.  
  72.     try:
  73.         import imgfile
  74.     except ImportError:
  75.         return
  76.  
  77.     # Create binary test files
  78.     uu.decode(get_qualified_path('testrgb'+os.extsep+'uue'), 'test'+os.extsep+'rgb')
  79.  
  80.     image, width, height = getimage('test'+os.extsep+'rgb')
  81.  
  82.     # Return the selected part of image, which should by width by height
  83.     # in size and consist of pixels of psize bytes.
  84.     if verbose:
  85.         print 'crop'
  86.     newimage = imageop.crop (image, 4, width, height, 0, 0, 1, 1)
  87.  
  88.     # Return image scaled to size newwidth by newheight. No interpolation
  89.     # is done, scaling is done by simple-minded pixel duplication or removal.
  90.     # Therefore, computer-generated images or dithered images will
  91.     # not look nice after scaling.
  92.     if verbose:
  93.         print 'scale'
  94.     scaleimage = imageop.scale(image, 4, width, height, 1, 1)
  95.  
  96.     # Run a vertical low-pass filter over an image. It does so by computing
  97.     # each destination pixel as the average of two vertically-aligned source
  98.     # pixels. The main use of this routine is to forestall excessive flicker
  99.     # if the image two vertically-aligned source pixels,  hence the name.
  100.     if verbose:
  101.         print 'tovideo'
  102.     videoimage = imageop.tovideo (image, 4, width, height)
  103.  
  104.     # Convert an rgb image to an 8 bit rgb
  105.     if verbose:
  106.         print 'rgb2rgb8'
  107.     greyimage = imageop.rgb2rgb8(image, width, height)
  108.  
  109.     # Convert an 8 bit rgb image to a 24 bit rgb image
  110.     if verbose:
  111.         print 'rgb82rgb'
  112.     image = imageop.rgb82rgb(greyimage, width, height)
  113.  
  114.     # Convert an rgb image to an 8 bit greyscale image
  115.     if verbose:
  116.         print 'rgb2grey'
  117.     greyimage = imageop.rgb2grey(image, width, height)
  118.  
  119.     # Convert an 8 bit greyscale image to a 24 bit rgb image
  120.     if verbose:
  121.         print 'grey2rgb'
  122.     image = imageop.grey2rgb(greyimage, width, height)
  123.  
  124.     # Convert a 8-bit deep greyscale image to a 1-bit deep image by
  125.     # thresholding all the pixels. The resulting image is tightly packed
  126.     # and is probably only useful as an argument to mono2grey.
  127.     if verbose:
  128.         print 'grey2mono'
  129.     monoimage = imageop.grey2mono (greyimage, width, height, 0)
  130.  
  131.     # monoimage, width, height = getimage('monotest.rgb')
  132.     # Convert a 1-bit monochrome image to an 8 bit greyscale or color image.
  133.     # All pixels that are zero-valued on input get value p0 on output and
  134.     # all one-value input pixels get value p1 on output. To convert a
  135.     # monochrome  black-and-white image to greyscale pass the values 0 and
  136.     # 255 respectively.
  137.     if verbose:
  138.         print 'mono2grey'
  139.     greyimage = imageop.mono2grey (monoimage, width, height, 0, 255)
  140.  
  141.     # Convert an 8-bit greyscale image to a 1-bit monochrome image using a
  142.     # (simple-minded) dithering algorithm.
  143.     if verbose:
  144.         print 'dither2mono'
  145.     monoimage = imageop.dither2mono (greyimage, width, height)
  146.  
  147.     # Convert an 8-bit greyscale image to a 4-bit greyscale image without
  148.     # dithering.
  149.     if verbose:
  150.         print 'grey2grey4'
  151.     grey4image = imageop.grey2grey4 (greyimage, width, height)
  152.  
  153.     # Convert an 8-bit greyscale image to a 2-bit greyscale image without
  154.     # dithering.
  155.     if verbose:
  156.         print 'grey2grey2'
  157.     grey2image = imageop.grey2grey2 (greyimage, width, height)
  158.  
  159.     # Convert an 8-bit greyscale image to a 2-bit greyscale image with
  160.     # dithering. As for dither2mono, the dithering algorithm is currently
  161.     # very simple.
  162.     if verbose:
  163.         print 'dither2grey2'
  164.     grey2image = imageop.dither2grey2 (greyimage, width, height)
  165.  
  166.     # Convert a 4-bit greyscale image to an 8-bit greyscale image.
  167.     if verbose:
  168.         print 'grey42grey'
  169.     greyimage = imageop.grey42grey (grey4image, width, height)
  170.  
  171.     # Convert a 2-bit greyscale image to an 8-bit greyscale image.
  172.     if verbose:
  173.         print 'grey22grey'
  174.     image = imageop.grey22grey (grey2image, width, height)
  175.  
  176.     # Cleanup
  177.     unlink('test'+os.extsep+'rgb')
  178.  
  179. def getimage(name):
  180.     """return a tuple consisting of
  181.        image (in 'imgfile' format) width and height
  182.     """
  183.     try:
  184.         sizes = imgfile.getsizes(name)
  185.     except imgfile.error:
  186.         name = get_qualified_path(name)
  187.         sizes = imgfile.getsizes(name)
  188.     if verbose:
  189.         print 'imgfile opening test image: %s, sizes: %s' % (name, str(sizes))
  190.  
  191.     image = imgfile.read(name)
  192.     return (image, sizes[0], sizes[1])
  193.  
  194. def get_qualified_path(name):
  195.     """ return a more qualified path to name"""
  196.     import sys
  197.     import os
  198.     path = sys.path
  199.     try:
  200.         path = [os.path.dirname(__file__)] + path
  201.     except NameError:
  202.         pass
  203.     for dir in path:
  204.         fullname = os.path.join(dir, name)
  205.         if os.path.exists(fullname):
  206.             return fullname
  207.     return name
  208.  
  209. if __name__ == '__main__':
  210.     test_main()
  211.