import sys
import platform
try:
reduce
except NameError:
from functools import reduce
import operator
import weakref
import gc
import unittest
from pygame.tests.test_utils import SurfaceSubclass
try:
from pygame.tests.test_utils import arrinter
except NameError:
pass
import pygame
from pygame.compat import xrange_
PY3 = sys.version_info >= (3, 0, 0)
IS_PYPY = 'PyPy' == platform.python_implementation()
class TestMixin (object):
def assert_surfaces_equal (self, s1, s2):
# Assumes the surfaces are the same size.
w, h = s1.get_size ()
for x in range (w):
for y in range (h):
self.assertEqual (s1.get_at ((x, y)), s2.get_at ((x, y)),
"size: (%i, %i), position: (%i, %i)" %
(w, h, x, y))
class PixelArrayTypeTest (unittest.TestCase, TestMixin):
def test_compare(self):
# __doc__ (as of 2008-06-25) for pygame.pixelarray.PixelArray.compare:
# PixelArray.compare (array, distance=0, weights=(0.299, 0.587, 0.114)): Return PixelArray
# Compares the PixelArray with another one.
w = 10
h = 20
size = w, h
sf = pygame.Surface (size, 0, 32)
ar = pygame.PixelArray (sf)
sf2 = pygame.Surface (size, 0, 32)
self.assertRaises (TypeError, ar.compare, sf2)
ar2 = pygame.PixelArray (sf2)
ar3 = ar.compare (ar2)
self.assertTrue(isinstance (ar3, pygame.PixelArray))
self.assertEqual (ar3.shape, size)
sf2.fill (pygame.Color ('white'))
self.assert_surfaces_equal (sf2, ar3.surface)
del ar3
r = pygame.Rect (2, 5, 6, 13)
sf.fill (pygame.Color ('blue'), r)
sf2.fill (pygame.Color ('red'))
sf2.fill (pygame.Color ('blue'), r)
ar3 = ar.compare (ar2)
sf.fill (pygame.Color ('white'), r)
self.assert_surfaces_equal (sf, ar3.surface)
# FINISH ME!
# Test other bit depths, slices, and distance != 0.
def test_close(self):
""" does not crash when it is deleted.
"""
s = pygame.Surface((10,10))
a = pygame.PixelArray(s)
a.close()
del a
def test_close_raises(self):
""" when you try to do an operation after it is closed.
"""
s = pygame.Surface((10,10))
a = pygame.PixelArray(s)
a.close()
def do_operation():
a[:]
self.assertRaises (ValueError, do_operation)
def do_operation2():
a[:] = 1
self.assertRaises (ValueError, do_operation2)
def do_operation3():
a.make_surface()
self.assertRaises (ValueError, do_operation3)
def do_operation4():
for x in a:
pass
self.assertRaises (ValueError, do_operation4)
def test_context_manager(self):
""" closes properly.
"""
s = pygame.Surface((10,10))
with pygame.PixelArray(s) as a:
a[:]
def test_pixel_array (self):
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((10, 20), 0, bpp)
sf.fill ((0, 0, 0))
ar = pygame.PixelArray (sf)
self.assertEqual (ar._pixels_address, sf._pixels_address)
if sf.mustlock ():
self.assertTrue (sf.get_locked ())
self.assertEqual (len (ar), 10)
del ar
if sf.mustlock ():
self.assertFalse (sf.get_locked ())
def test_as_class (self):
# Check general new-style class freatures.
sf = pygame.Surface ((2, 3), 0, 32)
ar = pygame.PixelArray (sf)
self.assertRaises (AttributeError, getattr, ar, 'nonnative')
ar.nonnative = 'value'
self.assertEqual (ar.nonnative, 'value')
r = weakref.ref (ar)
self.assertTrue (r() is ar)
del ar
gc.collect ()
self.assertTrue (r() is None)
class C (pygame.PixelArray):
def __str__ (self):
return "string (%i, %i)" % self.shape
ar = C (sf)
self.assertEqual (str (ar), "string (2, 3)")
r = weakref.ref (ar)
self.assertTrue (r() is ar)
del ar
gc.collect ()
self.assertTrue (r() is None)
def test_pixelarray__subclassed_surface(self):
"""Ensure the PixelArray constructor accepts subclassed surfaces."""
surface = SurfaceSubclass((3, 5), 0, 32)
pixelarray = pygame.PixelArray(surface)
self.assertIsInstance(pixelarray, pygame.PixelArray)
# Sequence interfaces
def test_get_column (self):
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((6, 8), 0, bpp)
sf.fill ((0, 0, 255))
val = sf.map_rgb ((0, 0, 255))
ar = pygame.PixelArray (sf)
ar2 = ar.__getitem__ (1)
self.assertEqual (len(ar2), 8)
self.assertEqual (ar2.__getitem__ (0), val)
self.assertEqual (ar2.__getitem__ (1), val)
self.assertEqual (ar2.__getitem__ (2), val)
ar2 = ar.__getitem__ (-1)
self.assertEqual (len(ar2), 8)
self.assertEqual (ar2.__getitem__ (0), val)
self.assertEqual (ar2.__getitem__ (1), val)
self.assertEqual (ar2.__getitem__ (2), val)
def test_get_pixel (self):
w = 10
h = 20
size = w, h
bg_color = (0, 0, 255)
fg_color_y = (0, 0, 128)
fg_color_x = (0, 0, 11)
for bpp in (8, 16, 24, 32):
sf = pygame.Surface (size, 0, bpp)
mapped_bg_color = sf.map_rgb (bg_color)
mapped_fg_color_y = sf.map_rgb (fg_color_y)
mapped_fg_color_x = sf.map_rgb (fg_color_x)
self.assertNotEqual (mapped_fg_color_y, mapped_bg_color,
"Unusable test colors for bpp %i" % (bpp,))
self.assertNotEqual (mapped_fg_color_x, mapped_bg_color,
"Unusable test colors for bpp %i" % (bpp,))
self.assertNotEqual (mapped_fg_color_y, mapped_fg_color_x,
"Unusable test colors for bpp %i" % (bpp,))
sf.fill (bg_color)
ar = pygame.PixelArray (sf)
ar_y = ar.__getitem__ (1)
for y in xrange_ (h):
ar2 = ar_y.__getitem__ (y)
self.assertEqual (ar2, mapped_bg_color,
"ar[1][%i] == %i, mapped_bg_color == %i" %
(y, ar2, mapped_bg_color))
sf.set_at ((1, y), fg_color_y)
ar2 = ar_y.__getitem__ (y)
self.assertEqual (ar2, mapped_fg_color_y,
"ar[1][%i] == %i, mapped_fg_color_y == %i" %
(y, ar2, mapped_fg_color_y))
sf.set_at ((1, 1), bg_color)
for x in xrange_ (w):
ar2 = ar.__getitem__ (x).__getitem__ (1)
self.assertEqual (ar2, mapped_bg_color,
"ar[%i][1] = %i, mapped_bg_color = %i" %
(x, ar2, mapped_bg_color))
sf.set_at ((x, 1), fg_color_x)
ar2 = ar.__getitem__ (x).__getitem__ (1)
self.assertEqual (ar2, mapped_fg_color_x,
"ar[%i][1] = %i, mapped_fg_color_x = %i" %
(x, ar2, mapped_fg_color_x))
ar2 = ar.__getitem__ (0).__getitem__ (0)
self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))
ar2 = ar.__getitem__ (1).__getitem__ (0)
self.assertEqual (ar2, mapped_fg_color_y, "bpp = %i" % (bpp,))
ar2 = ar.__getitem__ (-4).__getitem__ (1)
self.assertEqual (ar2, mapped_fg_color_x, "bpp = %i" % (bpp,))
ar2 = ar.__getitem__ (-4).__getitem__ (5)
self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))
ar2 = ar.__getitem__ (-4).__getitem__ (0)
self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))
ar2 = ar.__getitem__ (-w + 1).__getitem__ (0)
self.assertEqual (ar2, mapped_fg_color_y, "bpp = %i" % (bpp,))
ar2 = ar.__getitem__ (-w).__getitem__ (0)
self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))
ar2 = ar.__getitem__ (5).__getitem__ (-4)
self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))
ar2 = ar.__getitem__ (5).__getitem__ (-h + 1)
self.assertEqual (ar2, mapped_fg_color_x, "bpp = %i" % (bpp,))
ar2 = ar.__getitem__ (5).__getitem__ (-h)
self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))
ar2 = ar.__getitem__ (0).__getitem__ (-h + 1)
self.assertEqual (ar2, mapped_fg_color_x, "bpp = %i" % (bpp,))
ar2 = ar.__getitem__ (0).__getitem__ (-h)
self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))
def test_set_pixel (self):
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((10, 20), 0, bpp)
sf.fill ((0, 0, 0))
ar = pygame.PixelArray (sf)
ar.__getitem__ (0).__setitem__ (0, (0, 255, 0))
self.assertEqual (ar[0][0], sf.map_rgb ((0, 255, 0)))
ar.__getitem__ (1).__setitem__ (1, (128, 128, 128))
self.assertEqual (ar[1][1], sf.map_rgb ((128, 128, 128)))
ar.__getitem__(-1).__setitem__ (-1, (128, 128, 128))
self.assertEqual (ar[9][19], sf.map_rgb ((128, 128, 128)))
ar.__getitem__ (-2).__setitem__ (-2, (128, 128, 128))
self.assertEqual (ar[8][-2], sf.map_rgb ((128, 128, 128)))
def test_set_column (self):
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((6, 8), 0, bpp)
sf.fill ((0, 0, 0))
ar = pygame.PixelArray (sf)
sf2 = pygame.Surface ((6, 8), 0, bpp)
sf2.fill ((0, 255, 255))
ar2 = pygame.PixelArray (sf2)
# Test single value assignment
ar.__setitem__ (2, (128, 128, 128))
self.assertEqual (ar[2][0], sf.map_rgb ((128, 128, 128)))
self.assertEqual (ar[2][1], sf.map_rgb ((128, 128, 128)))
ar.__setitem__ (-1, (0, 255, 255))
self.assertEqual (ar[5][0], sf.map_rgb ((0, 255, 255)))
self.assertEqual (ar[-1][1], sf.map_rgb ((0, 255, 255)))
ar.__setitem__ (-2, (255, 255, 0))
self.assertEqual (ar[4][0], sf.map_rgb ((255, 255, 0)))
self.assertEqual (ar[-2][1], sf.map_rgb ((255, 255, 0)))
# Test list assignment.
ar.__setitem__ (0, [(255, 255, 255)] * 8)
self.assertEqual (ar[0][0], sf.map_rgb ((255, 255, 255)))
self.assertEqual (ar[0][1], sf.map_rgb ((255, 255, 255)))
# Test tuple assignment.
# Changed in Pygame 1.9.2 - Raises an exception.
self.assertRaises (ValueError, ar.__setitem__, 1,
((204, 0, 204), (17, 17, 17), (204, 0, 204),
(17, 17, 17), (204, 0, 204), (17, 17, 17),
(204, 0, 204), (17, 17, 17)))
# Test pixel array assignment.
ar.__setitem__ (1, ar2.__getitem__ (3))
self.assertEqual (ar[1][0], sf.map_rgb ((0, 255, 255)))
self.assertEqual (ar[1][1], sf.map_rgb ((0, 255, 255)))
def test_get_slice (self):
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((10, 20), 0, bpp)
sf.fill ((0, 0, 0))
ar = pygame.PixelArray (sf)
self.assertEqual (len (ar[0:2]), 2)
self.assertEqual (len (ar[3:7][3]), 20)
self.assertEqual (ar[0:0], None)
self.assertEqual (ar[5:5], None)
self.assertEqual (ar[9:9], None)
# Has to resolve to ar[7:8]
self.assertEqual (len (ar[-3:-2]), 1) # 2D
self.assertEqual (len (ar[-3:-2][0]), 20) # 1D
# Try assignments.
# 2D assignment.
ar[2:5] = (255, 255, 255)
# 1D assignment
ar[3][3:7] = (10, 10, 10)
self.assertEqual (ar[3][5], sf.map_rgb ((10, 10, 10)))
self.assertEqual (ar[3][6], sf.map_rgb ((10, 10, 10)))
@unittest.skipIf(IS_PYPY, 'skipping for PyPy (segfaults on mac pypy3 6.0.0)')
def test_contains (self):
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((10, 20), 0, bpp)
sf.fill ((0, 0, 0))
sf.set_at ((8, 8), (255, 255, 255))
ar = pygame.PixelArray (sf)
self.assertTrue ((0, 0, 0) in ar)
self.assertTrue ((255, 255, 255) in ar)
self.assertFalse ((255, 255, 0) in ar)
self.assertFalse (0x0000ff in ar)
# Test sliced array
self.assertTrue ((0, 0, 0) in ar[8])
self.assertTrue ((255, 255, 255) in ar[8])
self.assertFalse ((255, 255, 0) in ar[8])
self.assertFalse (0x0000ff in ar[8])
def test_get_surface (self):
for bpp in (8, 16, 24, 32):
sf = pygame.Surface((10, 20), 0, bpp)
sf.fill((0, 0, 0))
ar = pygame.PixelArray(sf)
self.assertTrue(ar.surface is sf)
def test_get_surface__subclassed_surface(self):
"""Ensure the surface attribute can handle subclassed surfaces."""
expected_surface = SurfaceSubclass((5, 3), 0, 32)
pixelarray = pygame.PixelArray(expected_surface)
surface = pixelarray.surface
self.assertIs(surface, expected_surface)
self.assertIsInstance(surface, pygame.Surface)
self.assertIsInstance(surface, SurfaceSubclass)
def test_set_slice (self):
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((6, 8), 0, bpp)
sf.fill ((0, 0, 0))
ar = pygame.PixelArray (sf)
# Test single value assignment
val = sf.map_rgb ((128, 128, 128))
ar[0:2] = val
self.assertEqual (ar[0][0], val)
self.assertEqual (ar[0][1], val)
self.assertEqual (ar[1][0], val)
self.assertEqual (ar[1][1], val)
val = sf.map_rgb ((0, 255, 255))
ar[-3:-1] = val
self.assertEqual (ar[3][0], val)
self.assertEqual (ar[-2][1], val)
val = sf.map_rgb ((255, 255, 255))
ar[-3:] = (255, 255, 255)
self.assertEqual (ar[4][0], val)
self.assertEqual (ar[-1][1], val)
# Test array size mismatch.
# Changed in ver. 1.9.2
# (was "Test list assignment, this is a vertical assignment.")
val = sf.map_rgb ((0, 255, 0))
self.assertRaises (ValueError, ar.__setitem__, slice (2, 4),
[val] * 8)
# And the horizontal assignment.
val = sf.map_rgb ((255, 0, 0))
val2 = sf.map_rgb ((128, 0, 255))
ar[0:2] = [val, val2]
self.assertEqual (ar[0][0], val)
self.assertEqual (ar[1][0], val2)
self.assertEqual (ar[0][1], val)
self.assertEqual (ar[1][1], val2)
self.assertEqual (ar[0][4], val)
self.assertEqual (ar[1][4], val2)
self.assertEqual (ar[0][5], val)
self.assertEqual (ar[1][5], val2)
# Test pixelarray assignment.
ar[:] = (0, 0, 0)
sf2 = pygame.Surface ((6, 8), 0, bpp)
sf2.fill ((255, 0, 255))
val = sf.map_rgb ((255, 0, 255))
ar2 = pygame.PixelArray (sf2)
ar[:] = ar2[:]
self.assertEqual (ar[0][0], val)
self.assertEqual (ar[5][7], val)
# Ensure p1 ... pn are freed for array[...] = [p1, ..., pn]
# Bug fix: reference counting.
if hasattr(sys, 'getrefcount'):
class Int(int):
"""Unique int instances"""
pass
sf = pygame.Surface ((5, 2), 0, 32)
ar = pygame.PixelArray (sf)
pixel_list = [Int(i) for i in range(ar.shape[0])]
refcnts_before = [sys.getrefcount (i) for i in pixel_list]
ar[...] = pixel_list
refcnts_after = [sys.getrefcount (i) for i in pixel_list]
gc.collect ()
self.assertEqual (refcnts_after, refcnts_before)
def test_subscript (self):
# By default we do not need to work with any special __***__
# methods as map subscripts are the first looked up by the
# object system.
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((6, 8), 0, bpp)
sf.set_at ((1, 3), (0, 255, 0))
sf.set_at ((0, 0), (0, 255, 0))
sf.set_at ((4, 4), (0, 255, 0))
val = sf.map_rgb ((0, 255, 0))
ar = pygame.PixelArray (sf)
# Test single value requests.
self.assertEqual (ar[1,3], val)
self.assertEqual (ar[0,0], val)
self.assertEqual (ar[4,4], val)
self.assertEqual (ar[1][3], val)
self.assertEqual (ar[0][0], val)
self.assertEqual (ar[4][4], val)
# Test ellipse working.
self.assertEqual (len (ar[...,...]), 6)
self.assertEqual (len (ar[1,...]), 8)
self.assertEqual (len (ar[...,3]), 6)
# Test simple slicing
self.assertEqual (len (ar[:,:]), 6)
self.assertEqual (len (ar[:,]), 6)
self.assertEqual (len (ar[1,:]), 8)
self.assertEqual (len (ar[:,2]), 6)
# Empty slices
self.assertEqual (ar[4:4,], None)
self.assertEqual (ar[4:4,...], None)
self.assertEqual (ar[4:4,2:2], None)
self.assertEqual (ar[4:4,1:4], None)
self.assertEqual (ar[4:4:2,], None)
self.assertEqual (ar[4:4:-2,], None)
self.assertEqual (ar[4:4:1,...], None)
self.assertEqual (ar[4:4:-1,...], None)
self.assertEqual (ar[4:4:1,2:2], None)
self.assertEqual (ar[4:4:-1,1:4], None)
self.assertEqual (ar[...,4:4], None)
self.assertEqual (ar[1:4,4:4], None)
self.assertEqual (ar[...,4:4:1], None)
self.assertEqual (ar[...,4:4:-1], None)
self.assertEqual (ar[2:2,4:4:1], None)
self.assertEqual (ar[1:4,4:4:-1], None)
# Test advanced slicing
ar[0] = 0
ar[1] = 1
ar[2] = 2
ar[3] = 3
ar[4] = 4
ar[5] = 5
# We should receive something like [0,2,4]
self.assertEqual (ar[::2,1][0], 0)
self.assertEqual (ar[::2,1][1], 2)
self.assertEqual (ar[::2,1][2], 4)
# We should receive something like [2,2,2]
self.assertEqual (ar[2,::2][0], 2)
self.assertEqual (ar[2,::2][1], 2)
self.assertEqual (ar[2,::2][2], 2)
# Should create a 3x3 array of [0,2,4]
ar2 = ar[::2,::2]
self.assertEqual (len (ar2), 3)
self.assertEqual (ar2[0][0], 0)
self.assertEqual (ar2[0][1], 0)
self.assertEqual (ar2[0][2], 0)
self.assertEqual (ar2[2][0], 4)
self.assertEqual (ar2[2][1], 4)
self.assertEqual (ar2[2][2], 4)
self.assertEqual (ar2[1][0], 2)
self.assertEqual (ar2[2][0], 4)
self.assertEqual (ar2[1][1], 2)
# Should create a reversed 3x8 array over X of [1,2,3] -> [3,2,1]
ar2 = ar[3:0:-1]
self.assertEqual (len (ar2), 3)
self.assertEqual (ar2[0][0], 3)
self.assertEqual (ar2[0][1], 3)
self.assertEqual (ar2[0][2], 3)
self.assertEqual (ar2[0][7], 3)
self.assertEqual (ar2[2][0], 1)
self.assertEqual (ar2[2][1], 1)
self.assertEqual (ar2[2][2], 1)
self.assertEqual (ar2[2][7], 1)
self.assertEqual (ar2[1][0], 2)
self.assertEqual (ar2[1][1], 2)
# Should completely reverse the array over X -> [5,4,3,2,1,0]
ar2 = ar[::-1]
self.assertEqual (len (ar2), 6)
self.assertEqual (ar2[0][0], 5)
self.assertEqual (ar2[0][1], 5)
self.assertEqual (ar2[0][3], 5)
self.assertEqual (ar2[0][-1], 5)
self.assertEqual (ar2[1][0], 4)
self.assertEqual (ar2[1][1], 4)
self.assertEqual (ar2[1][3], 4)
self.assertEqual (ar2[1][-1], 4)
self.assertEqual (ar2[-1][-1], 0)
self.assertEqual (ar2[-2][-2], 1)
self.assertEqual (ar2[-3][-1], 2)
# Test advanced slicing
ar[:] = 0
ar2 = ar[:,1]
ar2[:] = [99] * len(ar2)
self.assertEqual (ar2[0], 99)
self.assertEqual (ar2[-1], 99)
self.assertEqual (ar2[-2], 99)
self.assertEqual (ar2[2], 99)
self.assertEqual (ar[0,1], 99)
self.assertEqual (ar[1,1], 99)
self.assertEqual (ar[2,1], 99)
self.assertEqual (ar[-1,1], 99)
self.assertEqual (ar[-2,1], 99)
# Cases where a 2d array should have a dimension of length 1.
ar2 = ar[1:2,:]
self.assertEqual (ar2.shape, (1, ar.shape[1]))
ar2 = ar[:,1:2]
self.assertEqual (ar2.shape, (ar.shape[0], 1))
sf2 = pygame.Surface ((1, 5), 0, 32)
ar2 = pygame.PixelArray (sf2)
self.assertEqual (ar2.shape, sf2.get_size ())
sf2 = pygame.Surface ((7, 1), 0, 32)
ar2 = pygame.PixelArray (sf2)
self.assertEqual (ar2.shape, sf2.get_size ())
# Array has a single ellipsis subscript: the identity operator
ar2 = ar[...]
self.assertTrue(ar2 is ar)
# Ensure x and y are freed for p = array[x, y]
# Bug fix: reference counting
if hasattr(sys, 'getrefcount'):
class Int(int):
"""Unique int instances"""
pass
sf = pygame.Surface ((2, 2), 0, 32)
ar = pygame.PixelArray (sf)
x, y = Int(0), Int(1)
rx_before, ry_before = sys.getrefcount (x), sys.getrefcount (y)
p = ar[x, y]
rx_after, ry_after = sys.getrefcount (x), sys.getrefcount (y)
self.assertEqual (rx_after, rx_before)
self.assertEqual (ry_after, ry_before)
def test_ass_subscript (self):
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((6, 8), 0, bpp)
sf.fill ((255, 255, 255))
ar = pygame.PixelArray (sf)
# Test ellipse working
ar[...,...] = (0, 0, 0)
self.assertEqual (ar[0,0], 0)
self.assertEqual (ar[1,0], 0)
self.assertEqual (ar[-1,-1], 0)
ar[...,] = (0, 0, 255)
self.assertEqual (ar[0,0], sf.map_rgb ((0, 0, 255)))
self.assertEqual (ar[1,0], sf.map_rgb ((0, 0, 255)))
self.assertEqual (ar[-1,-1], sf.map_rgb ((0, 0, 255)))
ar[:,...] = (255, 0, 0)
self.assertEqual (ar[0,0], sf.map_rgb ((255, 0, 0)))
self.assertEqual (ar[1,0], sf.map_rgb ((255, 0, 0)))
self.assertEqual (ar[-1,-1], sf.map_rgb ((255, 0, 0)))
ar[...] = (0, 255, 0)
self.assertEqual (ar[0,0], sf.map_rgb ((0, 255, 0)))
self.assertEqual (ar[1,0], sf.map_rgb ((0, 255, 0)))
self.assertEqual (ar[-1,-1], sf.map_rgb ((0, 255, 0)))
# Ensure x and y are freed for array[x, y] = p
# Bug fix: reference counting
if hasattr(sys, 'getrefcount'):
class Int(int):
"""Unique int instances"""
pass
sf = pygame.Surface ((2, 2), 0, 32)
ar = pygame.PixelArray (sf)
x, y = Int(0), Int(1)
rx_before, ry_before = sys.getrefcount (x), sys.getrefcount (y)
ar[x, y] = 0
rx_after, ry_after = sys.getrefcount (x), sys.getrefcount (y)
self.assertEqual (rx_after, rx_before)
self.assertEqual (ry_after, ry_before)
def test_pixels_field(self):
for bpp in [1, 2, 3, 4]:
sf = pygame.Surface ((11, 7), 0, bpp * 8)
ar = pygame.PixelArray (sf)
ar2 = ar[1:,:]
self.assertEqual (ar2._pixels_address - ar._pixels_address,
ar.itemsize)
ar2 = ar[:,1:]
self.assertEqual (ar2._pixels_address - ar._pixels_address,
ar.strides[1])
ar2 = ar[::-1,:]
self.assertEqual (ar2._pixels_address - ar._pixels_address,
(ar.shape[0] - 1) * ar.itemsize)
ar2 = ar[::-2,:]
self.assertEqual (ar2._pixels_address - ar._pixels_address,
(ar.shape[0] - 1) * ar.itemsize)
ar2 = ar[:,::-1]
self.assertEqual (ar2._pixels_address - ar._pixels_address,
(ar.shape[1] - 1) * ar.strides[1])
ar3 = ar2[::-1,:]
self.assertEqual (ar3._pixels_address - ar._pixels_address,
(ar.shape[0] - 1) * ar.strides[0] +
(ar.shape[1] - 1) * ar.strides[1])
ar2 = ar[:,::-2]
self.assertEqual (ar2._pixels_address - ar._pixels_address,
(ar.shape[1] - 1) * ar.strides[1])
ar2 = ar[2::,3::]
self.assertEqual (ar2._pixels_address - ar._pixels_address,
ar.strides[0] * 2 + ar.strides[1] * 3)
ar2 = ar[2::2,3::4]
self.assertEqual (ar2._pixels_address - ar._pixels_address,
ar.strides[0] * 2 + ar.strides[1] * 3)
ar2 = ar[9:2:-1,:]
self.assertEqual (ar2._pixels_address - ar._pixels_address,
ar.strides[0] * 9)
ar2 = ar[:,5:2:-1]
self.assertEqual (ar2._pixels_address - ar._pixels_address,
ar.strides[1] * 5)
##? ar2 = ar[:,9:2:-1]
def test_make_surface (self):
bg_color = pygame.Color (255, 255, 255)
fg_color = pygame.Color (128, 100, 0)
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((10, 20), 0, bpp)
bg_color_adj = sf.unmap_rgb (sf.map_rgb (bg_color))
fg_color_adj = sf.unmap_rgb (sf.map_rgb (fg_color))
sf.fill (bg_color_adj)
sf.fill (fg_color_adj, (2, 5, 4, 11))
ar = pygame.PixelArray (sf)
newsf = ar[::2,::2].make_surface ()
rect = newsf.get_rect ()
self.assertEqual (rect.width, 5)
self.assertEqual (rect.height, 10)
for p in [(0, 2), (0, 3), (1, 2),
(2, 2), (3, 2), (3, 3),
(0, 7), (0, 8), (1, 8),
(2, 8), (3, 8), (3, 7)]:
self.assertEqual (newsf.get_at (p), bg_color_adj)
for p in [(1, 3), (2, 3), (1, 5), (2, 5), (1, 7), (2, 7)]:
self.assertEqual (newsf.get_at (p), fg_color_adj)
# Bug when array width is not a multiple of the slice step.
w = 17
lst = list(range(w))
w_slice = len(lst[::2])
h = 3
sf = pygame.Surface ((w, h), 0, 32)
ar = pygame.PixelArray (sf)
ar2 = ar[::2,:]
sf2 = ar2.make_surface ()
w2, h2 = sf2.get_size ()
self.assertEqual (w2, w_slice)
self.assertEqual (h2, h)
# Bug when array height is not a multiple of the slice step.
# This can hang the Python interpreter.
h = 17
lst = list(range(h))
h_slice = len(lst[::2])
w = 3
sf = pygame.Surface ((w, h), 0, 32)
ar = pygame.PixelArray (sf)
ar2 = ar[:,::2]
sf2 = ar2.make_surface () # Hangs here.
w2, h2 = sf2.get_size ()
self.assertEqual (w2, w)
self.assertEqual (h2, h_slice)
def test_make_surface__subclassed_surface(self):
"""Ensure make_surface can handle subclassed surfaces."""
expected_size = (3, 5)
expected_flags = 0
expected_depth = 32
original_surface = SurfaceSubclass(expected_size, expected_flags,
expected_depth)
pixelarray = pygame.PixelArray(original_surface)
surface = pixelarray.make_surface()
self.assertIsNot(surface, original_surface)
self.assertIsInstance(surface, pygame.Surface)
self.assertNotIsInstance(surface, SurfaceSubclass)
self.assertEqual(surface.get_size(), expected_size)
self.assertEqual(surface.get_flags(), expected_flags)
self.assertEqual(surface.get_bitsize(), expected_depth)
def test_iter (self):
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((5, 10), 0, bpp)
ar = pygame.PixelArray (sf)
iterations = 0
for col in ar:
self.assertEqual (len (col), 10)
iterations += 1
self.assertEqual (iterations, 5)
def test_replace (self):
#print "replace start"
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((10, 10), 0, bpp)
sf.fill ((255, 0, 0))
rval = sf.map_rgb ((0, 0, 255))
oval = sf.map_rgb ((255, 0, 0))
ar = pygame.PixelArray (sf)
ar[::2].replace ((255, 0, 0), (0, 0, 255))
self.assertEqual (ar[0][0], rval)
self.assertEqual (ar[1][0], oval)
self.assertEqual (ar[2][3], rval)
self.assertEqual (ar[3][6], oval)
self.assertEqual (ar[8][9], rval)
self.assertEqual (ar[9][9], oval)
ar[::2].replace ((0, 0, 255), (255, 0, 0), weights=(10, 20, 50))
self.assertEqual (ar[0][0], oval)
self.assertEqual (ar[2][3], oval)
self.assertEqual (ar[3][6], oval)
self.assertEqual (ar[8][9], oval)
self.assertEqual (ar[9][9], oval)
#print "replace end"
def test_extract (self):
#print "extract start"
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((10, 10), 0, bpp)
sf.fill ((0, 0, 255))
sf.fill ((255, 0, 0), (2, 2, 6, 6))
white = sf.map_rgb ((255, 255, 255))
black = sf.map_rgb ((0, 0, 0))
ar = pygame.PixelArray (sf)
newar = ar.extract ((255, 0, 0))
self.assertEqual (newar[0][0], black)
self.assertEqual (newar[1][0], black)
self.assertEqual (newar[2][3], white)
self.assertEqual (newar[3][6], white)
self.assertEqual (newar[8][9], black)
self.assertEqual (newar[9][9], black)
newar = ar.extract ((255, 0, 0), weights=(10, 0.1, 50))
self.assertEqual (newar[0][0], black)
self.assertEqual (newar[1][0], black)
self.assertEqual (newar[2][3], white)
self.assertEqual (newar[3][6], white)
self.assertEqual (newar[8][9], black)
self.assertEqual (newar[9][9], black)
#print "extract end"
def test_2dslice_assignment (self):
w = 2 * 5 * 8
h = 3 * 5 * 9
sf = pygame.Surface ((w, h), 0, 32)
ar = pygame.PixelArray (sf)
size = (w, h)
strides = (1, w)
offset = 0
self._test_assignment (sf, ar, size, strides, offset)
xslice = slice (None, None, 2)
yslice = slice (None, None, 3)
ar, size, strides, offset = self._array_slice (
ar, size, (xslice, yslice), strides, offset)
self._test_assignment (sf, ar, size, strides, offset)
xslice = slice (5, None, 5)
yslice = slice (5, None, 5)
ar, size, strides, offset = self._array_slice (
ar, size, (xslice, yslice), strides, offset)
self._test_assignment (sf, ar, size, strides, offset)
def _test_assignment (self, sf, ar, ar_size, ar_strides, ar_offset):
self.assertEqual (ar.shape, ar_size)
ar_w, ar_h = ar_size
ar_xstride, ar_ystride = ar_strides
sf_w, sf_h = sf.get_size ()
black = pygame.Color ('black')
color = pygame.Color (0, 0, 12)
pxcolor = sf.map_rgb (color)
sf.fill (black)
for ar_x, ar_y in [(0, 0),
(0, ar_h - 4),
(ar_w - 3, 0),
(0, ar_h - 1),
(ar_w - 1, 0),
(ar_w - 1, ar_h - 1)]:
sf_offset = ar_offset + ar_x * ar_xstride + ar_y * ar_ystride
sf_y = sf_offset // sf_w
sf_x = sf_offset - sf_y * sf_w
sf_posn = (sf_x, sf_y)
sf_pix = sf.get_at (sf_posn)
self.assertEqual (sf_pix, black,
"at pixarr posn (%i, %i) (surf posn (%i, %i)): "
"%s != %s" %
(ar_x, ar_y, sf_x, sf_y, sf_pix, black))
ar[ar_x, ar_y] = pxcolor
sf_pix = sf.get_at (sf_posn)
self.assertEqual (sf_pix, color,
"at pixarr posn (%i, %i) (surf posn (%i, %i)): "
"%s != %s" %
(ar_x, ar_y, sf_x, sf_y, sf_pix, color))
def _array_slice (self, ar, size, slices, strides, offset):
ar = ar[slices]
xslice, yslice = slices
w, h = size
xstart, xstop, xstep = xslice.indices(w)
ystart, ystop, ystep = yslice.indices(h)
w = (xstop - xstart + xstep - 1) // xstep
h = (ystop - ystart + ystep - 1) // ystep
xstride, ystride = strides
offset += xstart * xstride + ystart * ystride
xstride *= xstep
ystride *= ystep
return ar, (w, h), (xstride, ystride), offset
def test_array_properties(self):
# itemsize, ndim, shape, and strides.
for bpp in [1, 2, 3, 4]:
sf = pygame.Surface ((2, 2), 0, bpp * 8)
ar = pygame.PixelArray (sf)
self.assertEqual (ar.itemsize, bpp)
for shape in [(4, 16), (5, 13)]:
w, h = shape
sf = pygame.Surface (shape, 0, 32)
bpp = sf.get_bytesize ()
pitch = sf.get_pitch ()
ar = pygame.PixelArray (sf)
self.assertEqual (ar.ndim, 2)
self.assertEqual (ar.shape, shape)
self.assertEqual (ar.strides, (bpp, pitch))
ar2 = ar[::2,:]
w2 = len(([0] * w)[::2])
self.assertEqual (ar2.ndim, 2)
self.assertEqual (ar2.shape, (w2, h))
self.assertEqual (ar2.strides, (2 * bpp, pitch))
ar2 = ar[:,::2]
h2 = len(([0] * h)[::2])
self.assertEqual (ar2.ndim, 2)
self.assertEqual (ar2.shape, (w, h2))
self.assertEqual (ar2.strides, (bpp, 2 * pitch))
ar2 = ar[1]
self.assertEqual (ar2.ndim, 1)
self.assertEqual (ar2.shape, (h,))
self.assertEqual (ar2.strides, (pitch,))
ar2 = ar[:,1]
self.assertEqual (ar2.ndim, 1)
self.assertEqual (ar2.shape, (w,))
self.assertEqual (ar2.strides, (bpp,))
def test_self_assign(self):
# This differs from NumPy arrays.
w = 10
max_x = w - 1
h = 20
max_y = h - 1
for bpp in [1, 2, 3, 4]:
sf = pygame.Surface ((w, h), 0, bpp * 8)
ar = pygame.PixelArray (sf)
for i in range (w * h):
ar[i % w, i // w] = i
ar[:,:] = ar[::-1,:]
for i in range (w * h):
self.assertEqual (ar[max_x - i % w, i // w], i)
ar = pygame.PixelArray (sf)
for i in range (w * h):
ar[i % w, i // w] = i
ar[:,:] = ar[:,::-1]
for i in range (w * h):
self.assertEqual (ar[i % w, max_y - i // w ], i)
ar = pygame.PixelArray (sf)
for i in range(w * h):
ar[i % w, i // w] = i
ar[:,:] = ar[::-1,::-1]
for i in range (w * h):
self.assertEqual (ar[max_x - i % w, max_y - i // w], i)
def test_color_value (self):
# Confirm that a PixelArray slice assignment distinguishes between
# pygame.Color and tuple objects as single (r, g, b[, a]) colors
# and other sequences as sequences of colors to be treated as
# slices.
sf = pygame.Surface ((5, 5), 0, 32)
ar = pygame.PixelArray (sf)
index = slice(None, None, 1)
ar.__setitem__ (index, (1, 2, 3))
self.assertEqual (ar[0, 0], sf.map_rgb ((1, 2, 3)))
ar.__setitem__ (index, pygame.Color (10, 11, 12))
self.assertEqual (ar[0, 0], sf.map_rgb ((10, 11, 12)))
self.assertRaises (ValueError, ar.__setitem__, index, (1, 2, 3, 4, 5))
self.assertRaises (ValueError, ar.__setitem__, (index, index),
(1, 2, 3, 4, 5))
self.assertRaises (ValueError, ar.__setitem__, index, [1, 2, 3])
self.assertRaises (ValueError, ar.__setitem__, (index, index),
[1, 2, 3])
sf = pygame.Surface ((3, 3), 0, 32)
ar = pygame.PixelArray (sf)
ar[:] = (20, 30, 40)
self.assertEqual (ar[0, 0], sf.map_rgb ((20, 30, 40)))
ar[:] = [20, 30, 40]
self.assertEqual (ar[0, 0], 20)
self.assertEqual (ar[1, 0], 30)
self.assertEqual (ar[2, 0], 40)
def test_transpose (self):
# PixelArray.transpose(): swap axis on a 2D array, add a length
# 1 x axis to a 1D array.
sf = pygame.Surface ((3, 7), 0, 32)
ar = pygame.PixelArray (sf)
w, h = ar.shape
dx, dy = ar.strides
for i in range (w * h):
x = i % w
y = i // w
ar[x, y] = i
ar_t = ar.transpose()
self.assertEqual (ar_t.shape, (h, w))
self.assertEqual (ar_t.strides, (dy, dx))
for i in range (w * h):
x = i % w
y = i // w
self.assertEqual (ar_t[y, x], ar[x, y])
ar1D = ar[0]
ar2D = ar1D.transpose()
self.assertEqual (ar2D.shape, (1, h))
for y in range (h):
self.assertEqual (ar1D[y], ar2D[0, y])
ar1D = ar[:,0]
ar2D = ar1D.transpose()
self.assertEqual (ar2D.shape, (1, w))
for x in range (2):
self.assertEqual (ar1D[x], ar2D[0, x])
def test_length_1_dimension_broadcast (self):
w = 5
sf = pygame.Surface ((w, w), 0, 32)
ar = pygame.PixelArray (sf)
# y-axis broadcast.
sf_x = pygame.Surface ((w, 1), 0, 32)
ar_x = pygame.PixelArray (sf_x)
for i in range (w):
ar_x[i, 0] = (w + 1) * 10
ar[...] = ar_x
for y in range (w):
for x in range (w):
self.assertEqual (ar[x, y], ar_x[x, 0])
# x-axis broadcast.
ar[...] = 0
sf_y = pygame.Surface ((1, w), 0, 32)
ar_y = pygame.PixelArray (sf_y)
for i in range (w):
ar_y[0, i] = (w + 1) * 10
ar[...] = ar_y
for x in range (w):
for y in range (w):
self.assertEqual (ar[x, y], ar_y[0, y])
# (1, 1) array broadcast.
ar[...] = 0
sf_1px = pygame.Surface ((1, 1), 0, 32)
ar_1px = pygame.PixelArray (sf_1px)
ar_1px[0, 0] = 42 # Well it had to show up somewhere.
ar[...] = ar_1px
for y in range (w):
for x in range (w):
self.assertEqual (ar[x, y], 42)
def test_assign_size_mismatch (self):
sf = pygame.Surface ((7, 11), 0, 32)
ar = pygame.PixelArray (sf)
self.assertRaises (ValueError, ar.__setitem__, Ellipsis, ar[:, 0:2])
self.assertRaises (ValueError, ar.__setitem__, Ellipsis, ar[0:2, :])
def test_repr (self):
# Python 3.x bug: the tp_repr slot function returned NULL instead
# of a Unicode string, triggering an exception.
sf = pygame.Surface ((3, 1), pygame.SRCALPHA, 16)
ar = pygame.PixelArray(sf)
ar[...] = 42
pixel = sf.get_at_mapped ((0, 0))
self.assertEqual(repr (ar),
type (ar).__name__ + "([\n [42, 42, 42]]\n)")
class PixelArrayArrayInterfaceTest(unittest.TestCase, TestMixin):
@unittest.skipIf(IS_PYPY, 'skipping for PyPy (why?)')
def test_basic (self):
# Check unchanging fields.
sf = pygame.Surface ((2, 2), 0, 32)
ar = pygame.PixelArray (sf)
ai = arrinter.ArrayInterface (ar)
self.assertEqual (ai.two, 2)
self.assertEqual (ai.typekind, 'u')
self.assertEqual (ai.nd, 2)
self.assertEqual (ai.data, ar._pixels_address)
@unittest.skipIf(IS_PYPY, 'skipping for PyPy (why?)')
def test_shape(self):
for shape in [[4, 16], [5, 13]]:
w, h = shape
sf = pygame.Surface (shape, 0, 32)
ar = pygame.PixelArray (sf)
ai = arrinter.ArrayInterface (ar)
ai_shape = [ai.shape[i] for i in range(ai.nd)]
self.assertEqual (ai_shape, shape)
ar2 = ar[::2,:]
ai2 = arrinter.ArrayInterface (ar2)
w2 = len(([0] * w)[::2])
ai_shape = [ai2.shape[i] for i in range(ai2.nd)]
self.assertEqual (ai_shape, [w2, h])
ar2 = ar[:,::2]
ai2 = arrinter.ArrayInterface (ar2)
h2 = len(([0] * h)[::2])
ai_shape = [ai2.shape[i] for i in range(ai2.nd)]
self.assertEqual (ai_shape, [w, h2])
@unittest.skipIf(IS_PYPY, 'skipping for PyPy (why?)')
def test_itemsize (self):
for bytes_per_pixel in range(1, 5):
bits_per_pixel = 8 * bytes_per_pixel
sf = pygame.Surface ((2, 2), 0, bits_per_pixel)
ar = pygame.PixelArray (sf)
ai = arrinter.ArrayInterface (ar)
self.assertEqual (ai.itemsize, bytes_per_pixel)
@unittest.skipIf(IS_PYPY, 'skipping for PyPy (why?)')
def test_flags (self):
aim = arrinter
common_flags = (aim.PAI_NOTSWAPPED | aim.PAI_WRITEABLE |
aim.PAI_ALIGNED)
s = pygame.Surface ((10, 2), 0, 32)
ar = pygame.PixelArray (s)
ai = aim.ArrayInterface (ar)
self.assertEqual (ai.flags, common_flags | aim.PAI_FORTRAN)
ar2 = ar[::2,:]
ai = aim.ArrayInterface (ar2)
self.assertEqual (ai.flags, common_flags)
s = pygame.Surface ((8, 2), 0, 24)
ar = pygame.PixelArray (s)
ai = aim.ArrayInterface (ar)
self.assertEqual (ai.flags, common_flags | aim.PAI_FORTRAN)
s = pygame.Surface ((7, 2), 0, 24)
ar = pygame.PixelArray (s)
ai = aim.ArrayInterface (ar)
self.assertEqual (ai.flags, common_flags)
def test_slicing (self):
# This will implicitly test data and strides fields.
#
# Need an 8 bit test surfaces because pixelcopy.make_surface
# returns an 8 bit surface for a 2d array.
factors = [7, 3, 11]
w = reduce (operator.mul, factors, 1)
h = 13
sf = pygame.Surface ((w, h), 0, 8)
color = sf.map_rgb ((1, 17, 128))
ar = pygame.PixelArray (sf)
for f in factors[:-1]:
w = w // f
sf.fill ((0, 0, 0))
ar = ar[f:f + w,:]
ar[0][0] = color
ar[-1][-2] = color
ar[0][-3] = color
sf2 = ar.make_surface ()
sf3 = pygame.pixelcopy.make_surface (ar)
self.assert_surfaces_equal (sf3, sf2)
h = reduce (operator.mul, factors, 1)
w = 13
sf = pygame.Surface ((w, h), 0, 8)
color = sf.map_rgb ((1, 17, 128))
ar = pygame.PixelArray (sf)
for f in factors[:-1]:
h = h // f
sf.fill ((0, 0, 0))
ar = ar[:,f:f + h]
ar[0][0] = color
ar[-1][-2] = color
ar[0][-3] = color
sf2 = ar.make_surface ()
sf3 = pygame.pixelcopy.make_surface (ar)
self.assert_surfaces_equal (sf3, sf2)
w = 20
h = 10
sf = pygame.Surface ((w, h), 0, 8)
color = sf.map_rgb ((1, 17, 128))
ar = pygame.PixelArray (sf)
for slices in [(slice (w), slice (h)),
(slice (0, w, 2), slice (h)),
(slice (0, w, 3), slice (h)),
(slice (w), slice (0, h, 2)),
(slice (w), slice (0, h, 3)),
(slice (0, w, 2), slice (0, h, 2)),
(slice (0, w, 3), slice (0, h, 3)),
]:
sf.fill ((0, 0, 0))
ar2 = ar[slices]
ar2[0][0] = color
ar2[-1][-2] = color
ar2[0][-3] = color
sf2 = ar2.make_surface ()
sf3 = pygame.pixelcopy.make_surface (ar2)
self.assert_surfaces_equal (sf3, sf2)
@unittest.skipIf(not pygame.HAVE_NEWBUF, 'newbuf not implemented')
class PixelArrayNewBufferTest(unittest.TestCase, TestMixin):
if pygame.HAVE_NEWBUF:
from pygame.tests.test_utils import buftools
bitsize_to_format = {8: 'B', 16: '=H', 24: '3x', 32: '=I'}
def test_newbuf_2D (self):
buftools = self.buftools
Importer = buftools.Importer
for bit_size in [8, 16, 24, 32]:
s = pygame.Surface ((10, 2), 0, bit_size)
ar = pygame.PixelArray (s)
format = self.bitsize_to_format[bit_size]
itemsize = ar.itemsize
shape = ar.shape
w, h = shape
strides = ar.strides
length = w * h * itemsize
imp = Importer (ar, buftools.PyBUF_FULL)
self.assertTrue (imp.obj, ar)
self.assertEqual (imp.len, length)
self.assertEqual (imp.ndim, 2)
self.assertEqual (imp.itemsize, itemsize)
self.assertEqual (imp.format, format)
self.assertFalse (imp.readonly)
self.assertEqual (imp.shape, shape)
self.assertEqual (imp.strides, strides)
self.assertTrue (imp.suboffsets is None)
self.assertEqual (imp.buf, s._pixels_address)
s = pygame.Surface ((8, 16), 0, 32)
ar = pygame.PixelArray (s)
format = self.bitsize_to_format[s.get_bitsize ()]
itemsize = ar.itemsize
shape = ar.shape
w, h = shape
strides = ar.strides
length = w * h * itemsize
imp = Importer (ar, buftools.PyBUF_SIMPLE)
self.assertTrue (imp.obj, ar)
self.assertEqual (imp.len, length)
self.assertEqual (imp.ndim, 0)
self.assertEqual (imp.itemsize, itemsize)
self.assertTrue (imp.format is None)
self.assertFalse (imp.readonly)
self.assertTrue (imp.shape is None)
self.assertTrue (imp.strides is None)
self.assertTrue (imp.suboffsets is None)
self.assertEqual (imp.buf, s._pixels_address)
imp = Importer (ar, buftools.PyBUF_FORMAT)
self.assertEqual (imp.ndim, 0)
self.assertEqual (imp.format, format)
imp = Importer (ar, buftools.PyBUF_WRITABLE)
self.assertEqual (imp.ndim, 0)
self.assertTrue (imp.format is None)
imp = Importer (ar, buftools.PyBUF_F_CONTIGUOUS)
self.assertEqual (imp.ndim, 2)
self.assertTrue (imp.format is None)
self.assertEqual (imp.shape, shape)
self.assertEqual (imp.strides, strides)
imp = Importer (ar, buftools.PyBUF_ANY_CONTIGUOUS)
self.assertEqual (imp.ndim, 2)
self.assertTrue (imp.format is None)
self.assertEqual (imp.shape, shape)
self.assertEqual (imp.strides, strides)
self.assertRaises (BufferError, Importer, ar,
buftools.PyBUF_C_CONTIGUOUS)
self.assertRaises (BufferError, Importer, ar, buftools.PyBUF_ND)
ar_sliced = ar[:,::2]
format = self.bitsize_to_format[s.get_bitsize ()]
itemsize = ar_sliced.itemsize
shape = ar_sliced.shape
w, h = shape
strides = ar_sliced.strides
length = w * h * itemsize
imp = Importer (ar_sliced, buftools.PyBUF_STRIDED)
self.assertEqual (imp.len, length)
self.assertEqual (imp.ndim, 2)
self.assertEqual (imp.itemsize, itemsize)
self.assertTrue (imp.format is None)
self.assertFalse (imp.readonly)
self.assertEqual (imp.shape, shape)
self.assertEqual (imp.strides, strides)
self.assertEqual (imp.buf, s._pixels_address)
self.assertRaises (BufferError, Importer, ar_sliced,
buftools.PyBUF_SIMPLE)
self.assertRaises (BufferError, Importer, ar_sliced,
buftools.PyBUF_ND)
self.assertRaises (BufferError, Importer, ar_sliced,
buftools.PyBUF_C_CONTIGUOUS)
self.assertRaises (BufferError, Importer, ar_sliced,
buftools.PyBUF_F_CONTIGUOUS)
self.assertRaises (BufferError, Importer, ar_sliced,
buftools.PyBUF_ANY_CONTIGUOUS)
ar_sliced = ar[::2,:]
format = self.bitsize_to_format[s.get_bitsize ()]
itemsize = ar_sliced.itemsize
shape = ar_sliced.shape
w, h = shape
strides = ar_sliced.strides
length = w * h * itemsize
imp = Importer (ar_sliced, buftools.PyBUF_STRIDED)
self.assertEqual (imp.len, length)
self.assertEqual (imp.ndim, 2)
self.assertEqual (imp.itemsize, itemsize)
self.assertTrue (imp.format is None)
self.assertFalse (imp.readonly)
self.assertEqual (imp.shape, shape)
self.assertEqual (imp.strides, strides)
self.assertEqual (imp.buf, s._pixels_address)
self.assertRaises (BufferError, Importer, ar_sliced,
buftools.PyBUF_SIMPLE)
self.assertRaises (BufferError, Importer, ar_sliced,
buftools.PyBUF_ND)
self.assertRaises (BufferError, Importer, ar_sliced,
buftools.PyBUF_C_CONTIGUOUS)
self.assertRaises (BufferError, Importer, ar_sliced,
buftools.PyBUF_F_CONTIGUOUS)
self.assertRaises (BufferError, Importer, ar_sliced,
buftools.PyBUF_ANY_CONTIGUOUS)
s2 = s.subsurface ((2, 3, 5, 7))
ar = pygame.PixelArray (s2)
format = self.bitsize_to_format[s.get_bitsize ()]
itemsize = ar.itemsize
shape = ar.shape
w, h = shape
strides = ar.strides
length = w * h * itemsize
imp = Importer (ar, buftools.PyBUF_STRIDES)
self.assertTrue (imp.obj, ar)
self.assertEqual (imp.len, length)
self.assertEqual (imp.ndim, 2)
self.assertEqual (imp.itemsize, itemsize)
self.assertTrue (imp.format is None)
self.assertFalse (imp.readonly)
self.assertEqual (imp.shape, shape)
self.assertEqual (imp.strides, strides)
self.assertTrue (imp.suboffsets is None)
self.assertEqual (imp.buf, s2._pixels_address)
self.assertRaises (BufferError, Importer, ar, buftools.PyBUF_SIMPLE)
self.assertRaises (BufferError, Importer, ar, buftools.PyBUF_FORMAT)
self.assertRaises (BufferError, Importer, ar, buftools.PyBUF_WRITABLE)
self.assertRaises (BufferError, Importer, ar, buftools.PyBUF_ND)
self.assertRaises (BufferError, Importer, ar,
buftools.PyBUF_C_CONTIGUOUS)
self.assertRaises (BufferError, Importer, ar,
buftools.PyBUF_F_CONTIGUOUS)
self.assertRaises (BufferError, Importer, ar,
buftools.PyBUF_ANY_CONTIGUOUS)
def test_newbuf_1D(self):
buftools = self.buftools
Importer = buftools.Importer
s = pygame.Surface ((2, 16), 0, 32)
ar_2D = pygame.PixelArray (s)
x = 0
ar = ar_2D[x]
format = self.bitsize_to_format[s.get_bitsize ()]
itemsize = ar.itemsize
shape = ar.shape
h = shape[0]
strides = ar.strides
length = h * itemsize
buf = s._pixels_address + x * itemsize
imp = Importer (ar, buftools.PyBUF_STRIDES)
self.assertTrue (imp.obj, ar)
self.assertEqual (imp.len, length)
self.assertEqual (imp.ndim, 1)
self.assertEqual (imp.itemsize, itemsize)
self.assertTrue (imp.format is None)
self.assertFalse (imp.readonly)
self.assertEqual (imp.shape, shape)
self.assertEqual (imp.strides, strides)
self.assertTrue (imp.suboffsets is None)
self.assertEqual (imp.buf, buf)
imp = Importer (ar, buftools.PyBUF_FULL)
self.assertEqual (imp.ndim, 1)
self.assertEqual (imp.format, format)
self.assertRaises (BufferError, Importer, ar,
buftools.PyBUF_SIMPLE)
self.assertRaises (BufferError, Importer, ar,
buftools.PyBUF_FORMAT)
self.assertRaises (BufferError, Importer, ar,
buftools.PyBUF_WRITABLE)
self.assertRaises (BufferError, Importer, ar,
buftools.PyBUF_ND)
self.assertRaises (BufferError, Importer, ar,
buftools.PyBUF_C_CONTIGUOUS)
self.assertRaises (BufferError, Importer, ar,
buftools.PyBUF_F_CONTIGUOUS)
self.assertRaises (BufferError, Importer, ar,
buftools.PyBUF_ANY_CONTIGUOUS)
y = 10
ar = ar_2D[:,y]
shape = ar.shape
w = shape[0]
strides = ar.strides
length = w * itemsize
buf = s._pixels_address + y * s.get_pitch()
imp = Importer (ar, buftools.PyBUF_FULL)
self.assertEqual (imp.len, length)
self.assertEqual (imp.ndim, 1)
self.assertEqual (imp.itemsize, itemsize)
self.assertEqual (imp.format, format)
self.assertFalse (imp.readonly)
self.assertEqual (imp.shape, shape)
self.assertEqual (imp.strides, strides)
self.assertEqual (imp.buf, buf)
self.assertTrue (imp.suboffsets is None)
imp = Importer (ar, buftools.PyBUF_SIMPLE)
self.assertEqual (imp.len, length)
self.assertEqual (imp.ndim, 0)
self.assertEqual (imp.itemsize, itemsize)
self.assertTrue (imp.format is None)
self.assertFalse (imp.readonly)
self.assertTrue (imp.shape is None)
self.assertTrue (imp.strides is None)
imp = Importer (ar, buftools.PyBUF_ND)
self.assertEqual (imp.len, length)
self.assertEqual (imp.ndim, 1)
self.assertEqual (imp.itemsize, itemsize)
self.assertTrue (imp.format is None)
self.assertFalse (imp.readonly)
self.assertEqual (imp.shape, shape)
self.assertTrue (imp.strides is None)
imp = Importer (ar, buftools.PyBUF_C_CONTIGUOUS)
self.assertEqual (imp.ndim, 1)
imp = Importer (ar, buftools.PyBUF_F_CONTIGUOUS)
self.assertEqual (imp.ndim, 1)
imp = Importer (ar, buftools.PyBUF_ANY_CONTIGUOUS)
self.assertEqual (imp.ndim, 1)
if __name__ == '__main__':
unittest.main()