mirror of
https://github.com/AdaCore/cpython.git
synced 2026-02-12 12:57:15 -08:00
e0ed2d75c8
requires them. Disable executable bits and shebang lines in test and benchmark files in order to prevent using a random system python, and in source files of modules which don't provide command line interface.
210 lines
6.7 KiB
Python
210 lines
6.7 KiB
Python
"""Test script for the imageop module. This has the side
|
|
effect of partially testing the imgfile module as well.
|
|
Roger E. Masse
|
|
"""
|
|
|
|
from test.test_support import verbose, unlink, import_module, run_unittest
|
|
|
|
imageop = import_module('imageop', deprecated=True)
|
|
import uu, os, unittest
|
|
|
|
|
|
SIZES = (1, 2, 3, 4)
|
|
_VALUES = (1, 2, 2**10, 2**15-1, 2**15, 2**15+1, 2**31-2, 2**31-1)
|
|
VALUES = tuple( -x for x in reversed(_VALUES) ) + (0,) + _VALUES
|
|
AAAAA = "A" * 1024
|
|
MAX_LEN = 2**20
|
|
|
|
|
|
class InputValidationTests(unittest.TestCase):
|
|
|
|
def _check(self, name, size=None, *extra):
|
|
func = getattr(imageop, name)
|
|
for height in VALUES:
|
|
for width in VALUES:
|
|
strlen = abs(width * height)
|
|
if size:
|
|
strlen *= size
|
|
if strlen < MAX_LEN:
|
|
data = "A" * strlen
|
|
else:
|
|
data = AAAAA
|
|
if size:
|
|
arguments = (data, size, width, height) + extra
|
|
else:
|
|
arguments = (data, width, height) + extra
|
|
try:
|
|
func(*arguments)
|
|
except (ValueError, imageop.error):
|
|
pass
|
|
|
|
def check_size(self, name, *extra):
|
|
for size in SIZES:
|
|
self._check(name, size, *extra)
|
|
|
|
def check(self, name, *extra):
|
|
self._check(name, None, *extra)
|
|
|
|
def test_input_validation(self):
|
|
self.check_size("crop", 0, 0, 0, 0)
|
|
self.check_size("scale", 1, 0)
|
|
self.check_size("scale", -1, -1)
|
|
self.check_size("tovideo")
|
|
self.check("grey2mono", 128)
|
|
self.check("grey2grey4")
|
|
self.check("grey2grey2")
|
|
self.check("dither2mono")
|
|
self.check("dither2grey2")
|
|
self.check("mono2grey", 0, 0)
|
|
self.check("grey22grey")
|
|
self.check("rgb2rgb8") # nlen*4 == len
|
|
self.check("rgb82rgb")
|
|
self.check("rgb2grey")
|
|
self.check("grey2rgb")
|
|
|
|
|
|
def test_main():
|
|
|
|
run_unittest(InputValidationTests)
|
|
|
|
try:
|
|
import imgfile
|
|
except ImportError:
|
|
return
|
|
|
|
# Create binary test files
|
|
uu.decode(get_qualified_path('testrgb'+os.extsep+'uue'), 'test'+os.extsep+'rgb')
|
|
|
|
image, width, height = getimage('test'+os.extsep+'rgb')
|
|
|
|
# Return the selected part of image, which should by width by height
|
|
# in size and consist of pixels of psize bytes.
|
|
if verbose:
|
|
print 'crop'
|
|
newimage = imageop.crop (image, 4, width, height, 0, 0, 1, 1)
|
|
|
|
# Return image scaled to size newwidth by newheight. No interpolation
|
|
# is done, scaling is done by simple-minded pixel duplication or removal.
|
|
# Therefore, computer-generated images or dithered images will
|
|
# not look nice after scaling.
|
|
if verbose:
|
|
print 'scale'
|
|
scaleimage = imageop.scale(image, 4, width, height, 1, 1)
|
|
|
|
# Run a vertical low-pass filter over an image. It does so by computing
|
|
# each destination pixel as the average of two vertically-aligned source
|
|
# pixels. The main use of this routine is to forestall excessive flicker
|
|
# if the image two vertically-aligned source pixels, hence the name.
|
|
if verbose:
|
|
print 'tovideo'
|
|
videoimage = imageop.tovideo (image, 4, width, height)
|
|
|
|
# Convert an rgb image to an 8 bit rgb
|
|
if verbose:
|
|
print 'rgb2rgb8'
|
|
greyimage = imageop.rgb2rgb8(image, width, height)
|
|
|
|
# Convert an 8 bit rgb image to a 24 bit rgb image
|
|
if verbose:
|
|
print 'rgb82rgb'
|
|
image = imageop.rgb82rgb(greyimage, width, height)
|
|
|
|
# Convert an rgb image to an 8 bit greyscale image
|
|
if verbose:
|
|
print 'rgb2grey'
|
|
greyimage = imageop.rgb2grey(image, width, height)
|
|
|
|
# Convert an 8 bit greyscale image to a 24 bit rgb image
|
|
if verbose:
|
|
print 'grey2rgb'
|
|
image = imageop.grey2rgb(greyimage, width, height)
|
|
|
|
# Convert a 8-bit deep greyscale image to a 1-bit deep image by
|
|
# thresholding all the pixels. The resulting image is tightly packed
|
|
# and is probably only useful as an argument to mono2grey.
|
|
if verbose:
|
|
print 'grey2mono'
|
|
monoimage = imageop.grey2mono (greyimage, width, height, 0)
|
|
|
|
# monoimage, width, height = getimage('monotest.rgb')
|
|
# Convert a 1-bit monochrome image to an 8 bit greyscale or color image.
|
|
# All pixels that are zero-valued on input get value p0 on output and
|
|
# all one-value input pixels get value p1 on output. To convert a
|
|
# monochrome black-and-white image to greyscale pass the values 0 and
|
|
# 255 respectively.
|
|
if verbose:
|
|
print 'mono2grey'
|
|
greyimage = imageop.mono2grey (monoimage, width, height, 0, 255)
|
|
|
|
# Convert an 8-bit greyscale image to a 1-bit monochrome image using a
|
|
# (simple-minded) dithering algorithm.
|
|
if verbose:
|
|
print 'dither2mono'
|
|
monoimage = imageop.dither2mono (greyimage, width, height)
|
|
|
|
# Convert an 8-bit greyscale image to a 4-bit greyscale image without
|
|
# dithering.
|
|
if verbose:
|
|
print 'grey2grey4'
|
|
grey4image = imageop.grey2grey4 (greyimage, width, height)
|
|
|
|
# Convert an 8-bit greyscale image to a 2-bit greyscale image without
|
|
# dithering.
|
|
if verbose:
|
|
print 'grey2grey2'
|
|
grey2image = imageop.grey2grey2 (greyimage, width, height)
|
|
|
|
# Convert an 8-bit greyscale image to a 2-bit greyscale image with
|
|
# dithering. As for dither2mono, the dithering algorithm is currently
|
|
# very simple.
|
|
if verbose:
|
|
print 'dither2grey2'
|
|
grey2image = imageop.dither2grey2 (greyimage, width, height)
|
|
|
|
# Convert a 4-bit greyscale image to an 8-bit greyscale image.
|
|
if verbose:
|
|
print 'grey42grey'
|
|
greyimage = imageop.grey42grey (grey4image, width, height)
|
|
|
|
# Convert a 2-bit greyscale image to an 8-bit greyscale image.
|
|
if verbose:
|
|
print 'grey22grey'
|
|
image = imageop.grey22grey (grey2image, width, height)
|
|
|
|
# Cleanup
|
|
unlink('test'+os.extsep+'rgb')
|
|
|
|
def getimage(name):
|
|
"""return a tuple consisting of
|
|
image (in 'imgfile' format) width and height
|
|
"""
|
|
import imgfile
|
|
try:
|
|
sizes = imgfile.getsizes(name)
|
|
except imgfile.error:
|
|
name = get_qualified_path(name)
|
|
sizes = imgfile.getsizes(name)
|
|
if verbose:
|
|
print 'imgfile opening test image: %s, sizes: %s' % (name, str(sizes))
|
|
|
|
image = imgfile.read(name)
|
|
return (image, sizes[0], sizes[1])
|
|
|
|
def get_qualified_path(name):
|
|
""" return a more qualified path to name"""
|
|
import sys
|
|
import os
|
|
path = sys.path
|
|
try:
|
|
path = [os.path.dirname(__file__)] + path
|
|
except NameError:
|
|
pass
|
|
for dir in path:
|
|
fullname = os.path.join(dir, name)
|
|
if os.path.exists(fullname):
|
|
return fullname
|
|
return name
|
|
|
|
if __name__ == '__main__':
|
|
test_main()
|