forked from s444420/AL-2020
654 lines
26 KiB
Python
654 lines
26 KiB
Python
import ctypes
|
|
import platform
|
|
import unittest
|
|
|
|
try:
|
|
from pygame.tests.test_utils import arrinter
|
|
except NameError:
|
|
pass
|
|
import pygame
|
|
from pygame.locals import *
|
|
from pygame.pixelcopy import (
|
|
surface_to_array, map_array, array_to_surface,
|
|
make_surface
|
|
)
|
|
|
|
IS_PYPY = 'PyPy' == platform.python_implementation()
|
|
|
|
|
|
def unsigned32(i):
|
|
"""cast signed 32 bit integer to an unsigned integer"""
|
|
return i & 0xFFFFFFFF
|
|
|
|
class PixelcopyModuleTest (unittest.TestCase):
|
|
|
|
bitsizes = [8, 16, 32]
|
|
|
|
test_palette = [(0, 0, 0, 255),
|
|
(10, 30, 60, 255),
|
|
(25, 75, 100, 255),
|
|
(100, 150, 200, 255),
|
|
(0, 100, 200, 255)]
|
|
|
|
surf_size = (10, 12)
|
|
test_points = [((0, 0), 1), ((4, 5), 1), ((9, 0), 2),
|
|
((5, 5), 2), ((0, 11), 3), ((4, 6), 3),
|
|
((9, 11), 4), ((5, 6), 4)]
|
|
|
|
def __init__(self, *args, **kwds):
|
|
pygame.display.init()
|
|
try:
|
|
unittest.TestCase.__init__(self, *args, **kwds)
|
|
self.sources = [self._make_src_surface(8),
|
|
self._make_src_surface(16),
|
|
self._make_src_surface(16, srcalpha=True),
|
|
self._make_src_surface(24),
|
|
self._make_src_surface(32),
|
|
self._make_src_surface(32, srcalpha=True)]
|
|
finally:
|
|
pygame.display.quit()
|
|
|
|
def _make_surface(self, bitsize, srcalpha=False, palette=None):
|
|
if palette is None:
|
|
palette = self.test_palette
|
|
flags = 0
|
|
if srcalpha:
|
|
flags |= SRCALPHA
|
|
surf = pygame.Surface(self.surf_size, flags, bitsize)
|
|
if bitsize == 8:
|
|
surf.set_palette([c[:3] for c in palette])
|
|
return surf
|
|
|
|
def _fill_surface(self, surf, palette=None):
|
|
if palette is None:
|
|
palette = self.test_palette
|
|
surf.fill(palette[1], (0, 0, 5, 6))
|
|
surf.fill(palette[2], (5, 0, 5, 6))
|
|
surf.fill(palette[3], (0, 6, 5, 6))
|
|
surf.fill(palette[4], (5, 6, 5, 6))
|
|
|
|
def _make_src_surface(self, bitsize, srcalpha=False, palette=None):
|
|
surf = self._make_surface(bitsize, srcalpha, palette)
|
|
self._fill_surface(surf, palette)
|
|
return surf
|
|
|
|
def setUp(self):
|
|
pygame.display.init()
|
|
|
|
def tearDown(self):
|
|
pygame.display.quit()
|
|
|
|
def test_surface_to_array_2d(self):
|
|
alpha_color = (0, 0, 0, 128)
|
|
|
|
for surf in self.sources:
|
|
src_bitsize = surf.get_bitsize()
|
|
for dst_bitsize in self.bitsizes:
|
|
# dst in a surface standing in for a 2 dimensional array
|
|
# of unsigned integers. The byte order is system dependent.
|
|
dst = pygame.Surface(surf.get_size(), 0, dst_bitsize)
|
|
dst.fill((0, 0, 0, 0))
|
|
view = dst.get_view('2')
|
|
self.assertFalse(surf.get_locked())
|
|
if dst_bitsize < src_bitsize:
|
|
self.assertRaises(ValueError, surface_to_array, view, surf)
|
|
self.assertFalse(surf.get_locked())
|
|
continue
|
|
surface_to_array(view, surf)
|
|
self.assertFalse(surf.get_locked())
|
|
for posn, i in self.test_points:
|
|
sp = surf.get_at_mapped(posn)
|
|
dp = dst.get_at_mapped(posn)
|
|
self.assertEqual(dp, sp,
|
|
"%s != %s: flags: %i"
|
|
", bpp: %i, posn: %s" %
|
|
(dp, sp,
|
|
surf.get_flags(), surf.get_bitsize(),
|
|
posn))
|
|
del view
|
|
|
|
if surf.get_masks()[3]:
|
|
dst.fill((0, 0, 0, 0))
|
|
view = dst.get_view('2')
|
|
posn = (2, 1)
|
|
surf.set_at(posn, alpha_color)
|
|
self.assertFalse(surf.get_locked())
|
|
surface_to_array(view, surf)
|
|
self.assertFalse(surf.get_locked())
|
|
sp = surf.get_at_mapped(posn)
|
|
dp = dst.get_at_mapped(posn)
|
|
self.assertEqual(dp, sp,
|
|
"%s != %s: bpp: %i" %
|
|
(dp, sp, surf.get_bitsize()))
|
|
|
|
if IS_PYPY:
|
|
return
|
|
# Swapped endian destination array
|
|
pai_flags = arrinter.PAI_ALIGNED | arrinter.PAI_WRITEABLE
|
|
for surf in self.sources:
|
|
for itemsize in [1, 2, 4, 8]:
|
|
if itemsize < surf.get_bytesize():
|
|
continue
|
|
a = arrinter.Array(surf.get_size(), 'u', itemsize,
|
|
flags=pai_flags)
|
|
surface_to_array(a, surf)
|
|
for posn, i in self.test_points:
|
|
sp = unsigned32(surf.get_at_mapped(posn))
|
|
dp = a[posn]
|
|
self.assertEqual(dp, sp,
|
|
"%s != %s: itemsize: %i, flags: %i"
|
|
", bpp: %i, posn: %s" %
|
|
(dp, sp, itemsize,
|
|
surf.get_flags(), surf.get_bitsize(),
|
|
posn))
|
|
|
|
def test_surface_to_array_3d(self):
|
|
self.iter_surface_to_array_3d((0xff, 0xff00, 0xff0000, 0))
|
|
self.iter_surface_to_array_3d((0xff0000, 0xff00, 0xff, 0))
|
|
|
|
def iter_surface_to_array_3d(self, rgba_masks):
|
|
dst = pygame.Surface(self.surf_size, 0, 24, masks=rgba_masks)
|
|
|
|
for surf in self.sources:
|
|
dst.fill((0, 0, 0, 0))
|
|
src_bitsize = surf.get_bitsize()
|
|
view = dst.get_view('3')
|
|
self.assertFalse(surf.get_locked())
|
|
surface_to_array(view, surf)
|
|
self.assertFalse(surf.get_locked())
|
|
for posn, i in self.test_points:
|
|
sc = surf.get_at(posn)[0:3]
|
|
dc = dst.get_at(posn)[0:3]
|
|
self.assertEqual(dc, sc,
|
|
"%s != %s: flags: %i"
|
|
", bpp: %i, posn: %s" %
|
|
(dc, sc,
|
|
surf.get_flags(), surf.get_bitsize(),
|
|
posn))
|
|
view = None
|
|
|
|
def test_map_array(self):
|
|
targets = [self._make_surface(8),
|
|
self._make_surface(16),
|
|
self._make_surface(16, srcalpha=True),
|
|
self._make_surface(24),
|
|
self._make_surface(32),
|
|
self._make_surface(32, srcalpha=True),
|
|
]
|
|
source = pygame.Surface(self.surf_size, 0, 24,
|
|
masks=[0xff, 0xff00, 0xff0000, 0])
|
|
self._fill_surface(source)
|
|
source_view = source.get_view('3') # (w, h, 3)
|
|
for t in targets:
|
|
map_array(t.get_view('2'), source_view, t)
|
|
for posn, i in self.test_points:
|
|
sc = t.map_rgb(source.get_at(posn))
|
|
dc = t.get_at_mapped(posn)
|
|
self.assertEqual(dc, sc,
|
|
"%s != %s: flags: %i"
|
|
", bpp: %i, posn: %s" %
|
|
(dc, sc,
|
|
t.get_flags(), t.get_bitsize(),
|
|
posn))
|
|
|
|
color = pygame.Color("salmon")
|
|
color.set_length(3)
|
|
for t in targets:
|
|
map_array(t.get_view('2'), color, t)
|
|
sc = t.map_rgb(color)
|
|
for posn, i in self.test_points:
|
|
dc = t.get_at_mapped(posn)
|
|
self.assertEqual(dc, sc,
|
|
"%s != %s: flags: %i"
|
|
", bpp: %i, posn: %s" %
|
|
(dc, sc,
|
|
t.get_flags(), t.get_bitsize(),
|
|
posn))
|
|
|
|
# mismatched shapes
|
|
w, h = source.get_size()
|
|
target = pygame.Surface((w, h + 1), 0, 32)
|
|
self.assertRaises(ValueError, map_array, target, source, target)
|
|
target = pygame.Surface((w - 1, h), 0, 32)
|
|
self.assertRaises(ValueError, map_array, target, source, target)
|
|
|
|
def test_array_to_surface_broadcasting(self):
|
|
# target surfaces
|
|
targets = [self._make_surface(8),
|
|
self._make_surface(16),
|
|
self._make_surface(16, srcalpha=True),
|
|
self._make_surface(24),
|
|
self._make_surface(32),
|
|
self._make_surface(32, srcalpha=True),
|
|
]
|
|
|
|
w, h = self.surf_size
|
|
|
|
# broadcast column
|
|
column = pygame.Surface((1, h), 0, 32)
|
|
for target in targets:
|
|
source = pygame.Surface((1, h), 0, target)
|
|
for y in range(h):
|
|
source.set_at((0, y),
|
|
pygame.Color(y + 1, y + h + 1, y + 2 * h + 1))
|
|
pygame.pixelcopy.surface_to_array(column.get_view('2'), source)
|
|
pygame.pixelcopy.array_to_surface(target, column.get_view('2'))
|
|
for x in range(w):
|
|
for y in range(h):
|
|
self.assertEqual(target.get_at_mapped((x, y)),
|
|
column.get_at_mapped((0, y)))
|
|
|
|
# broadcast row
|
|
row = pygame.Surface((w, 1), 0, 32)
|
|
for target in targets:
|
|
source = pygame.Surface((w, 1), 0, target)
|
|
for x in range(w):
|
|
source.set_at((x, 0),
|
|
pygame.Color(x + 1, x + w + 1, x + 2 * w + 1))
|
|
pygame.pixelcopy.surface_to_array(row.get_view('2'), source)
|
|
pygame.pixelcopy.array_to_surface(target, row.get_view('2'))
|
|
for x in range(w):
|
|
for y in range(h):
|
|
self.assertEqual(target.get_at_mapped((x, y)),
|
|
row.get_at_mapped((x, 0)))
|
|
|
|
# broadcast pixel
|
|
pixel = pygame.Surface((1, 1), 0, 32)
|
|
for target in targets:
|
|
source = pygame.Surface((1, 1), 0, target)
|
|
source.set_at((0, 0), pygame.Color(13, 47, 101))
|
|
pygame.pixelcopy.surface_to_array(pixel.get_view('2'), source)
|
|
pygame.pixelcopy.array_to_surface(target, pixel.get_view('2'))
|
|
p = pixel.get_at_mapped((0, 0))
|
|
for x in range(w):
|
|
for y in range(h):
|
|
self.assertEqual(target.get_at_mapped((x, y)), p)
|
|
|
|
|
|
class PixelCopyTestWithArray(unittest.TestCase):
|
|
try:
|
|
import numpy
|
|
except ImportError:
|
|
__tags__ = ['ignore', 'subprocess_ignore']
|
|
else:
|
|
pygame.surfarray.use_arraytype('numpy')
|
|
|
|
bitsizes = [8, 16, 32]
|
|
|
|
test_palette = [(0, 0, 0, 255),
|
|
(10, 30, 60, 255),
|
|
(25, 75, 100, 255),
|
|
(100, 150, 200, 255),
|
|
(0, 100, 200, 255)]
|
|
|
|
surf_size = (10, 12)
|
|
test_points = [((0, 0), 1), ((4, 5), 1), ((9, 0), 2),
|
|
((5, 5), 2), ((0, 11), 3), ((4, 6), 3),
|
|
((9, 11), 4), ((5, 6), 4)]
|
|
|
|
pixels2d = set([8, 16, 32])
|
|
pixels3d = set([24, 32])
|
|
array2d = set([8, 16, 24, 32])
|
|
array3d = set([24, 32])
|
|
|
|
def __init__(self, *args, **kwds):
|
|
import numpy
|
|
|
|
self.dst_types = [numpy.uint8, numpy.uint16, numpy.uint32]
|
|
try:
|
|
self.dst_types.append(numpy.uint64)
|
|
except AttributeError:
|
|
pass
|
|
pygame.display.init()
|
|
try:
|
|
unittest.TestCase.__init__(self, *args, **kwds)
|
|
self.sources = [self._make_src_surface(8),
|
|
self._make_src_surface(16),
|
|
self._make_src_surface(16, srcalpha=True),
|
|
self._make_src_surface(24),
|
|
self._make_src_surface(32),
|
|
self._make_src_surface(32, srcalpha=True)]
|
|
finally:
|
|
pygame.display.quit()
|
|
|
|
def _make_surface(self, bitsize, srcalpha=False, palette=None):
|
|
if palette is None:
|
|
palette = self.test_palette
|
|
flags = 0
|
|
if srcalpha:
|
|
flags |= SRCALPHA
|
|
surf = pygame.Surface(self.surf_size, flags, bitsize)
|
|
if bitsize == 8:
|
|
surf.set_palette([c[:3] for c in palette])
|
|
return surf
|
|
|
|
def _fill_surface(self, surf, palette=None):
|
|
if palette is None:
|
|
palette = self.test_palette
|
|
surf.fill(palette[1], (0, 0, 5, 6))
|
|
surf.fill(palette[2], (5, 0, 5, 6))
|
|
surf.fill(palette[3], (0, 6, 5, 6))
|
|
surf.fill(palette[4], (5, 6, 5, 6))
|
|
|
|
def _make_src_surface(self, bitsize, srcalpha=False, palette=None):
|
|
surf = self._make_surface(bitsize, srcalpha, palette)
|
|
self._fill_surface(surf, palette)
|
|
return surf
|
|
|
|
def setUp(self):
|
|
pygame.display.init()
|
|
|
|
def tearDown(self):
|
|
pygame.display.quit()
|
|
|
|
def test_surface_to_array_2d(self):
|
|
try:
|
|
from numpy import empty, dtype
|
|
except ImportError:
|
|
return
|
|
|
|
palette = self.test_palette
|
|
alpha_color = (0, 0, 0, 128)
|
|
|
|
dst_dims = self.surf_size
|
|
destinations = [empty(dst_dims, t) for t in self.dst_types]
|
|
if (pygame.get_sdl_byteorder() == pygame.LIL_ENDIAN):
|
|
swapped_dst = empty(dst_dims, dtype('>u4'))
|
|
else:
|
|
swapped_dst = empty(dst_dims, dtype('<u4'))
|
|
|
|
for surf in self.sources:
|
|
src_bytesize = surf.get_bytesize()
|
|
for dst in destinations:
|
|
if dst.itemsize < src_bytesize:
|
|
self.assertRaises(ValueError, surface_to_array, dst, surf)
|
|
continue
|
|
dst[...] = 0
|
|
self.assertFalse(surf.get_locked())
|
|
surface_to_array(dst, surf)
|
|
self.assertFalse(surf.get_locked())
|
|
for posn, i in self.test_points:
|
|
sp = unsigned32(surf.get_at_mapped(posn))
|
|
dp = dst[posn]
|
|
self.assertEqual(dp, sp,
|
|
"%s != %s: flags: %i"
|
|
", bpp: %i, dtype: %s, posn: %s" %
|
|
(dp, sp,
|
|
surf.get_flags(), surf.get_bitsize(),
|
|
dst.dtype,
|
|
posn))
|
|
|
|
if surf.get_masks()[3]:
|
|
posn = (2, 1)
|
|
surf.set_at(posn, alpha_color)
|
|
surface_to_array(dst, surf)
|
|
sp = unsigned32(surf.get_at_mapped(posn))
|
|
dp = dst[posn]
|
|
self.assertEqual(dp, sp, "%s != %s: bpp: %i" %
|
|
(dp, sp, surf.get_bitsize()))
|
|
|
|
swapped_dst[...] = 0
|
|
self.assertFalse(surf.get_locked())
|
|
surface_to_array(swapped_dst, surf)
|
|
self.assertFalse(surf.get_locked())
|
|
for posn, i in self.test_points:
|
|
sp = unsigned32(surf.get_at_mapped(posn))
|
|
dp = swapped_dst[posn]
|
|
self.assertEqual(dp, sp,
|
|
"%s != %s: flags: %i"
|
|
", bpp: %i, dtype: %s, posn: %s" %
|
|
(dp, sp,
|
|
surf.get_flags(), surf.get_bitsize(),
|
|
dst.dtype,
|
|
posn))
|
|
|
|
if surf.get_masks()[3]:
|
|
posn = (2, 1)
|
|
surf.set_at(posn, alpha_color)
|
|
self.assertFalse(surf.get_locked())
|
|
surface_to_array(swapped_dst, surf)
|
|
self.assertFalse(surf.get_locked())
|
|
sp = unsigned32(surf.get_at_mapped(posn))
|
|
dp = swapped_dst[posn]
|
|
self.assertEqual(dp, sp, "%s != %s: bpp: %i" %
|
|
(dp, sp, surf.get_bitsize()))
|
|
|
|
def test_surface_to_array_3d(self):
|
|
try:
|
|
from numpy import empty, dtype
|
|
except ImportError:
|
|
return
|
|
|
|
palette = self.test_palette
|
|
|
|
dst_dims = self.surf_size + (3,)
|
|
destinations = [empty(dst_dims, t) for t in self.dst_types]
|
|
if (pygame.get_sdl_byteorder() == pygame.LIL_ENDIAN):
|
|
swapped_dst = empty(dst_dims, dtype('>u4'))
|
|
else:
|
|
swapped_dst = empty(dst_dims, dtype('<u4'))
|
|
|
|
for surf in self.sources:
|
|
src_bitsize = surf.get_bitsize()
|
|
for dst in destinations:
|
|
dst[...] = 0
|
|
self.assertFalse(surf.get_locked())
|
|
surface_to_array(dst, surf)
|
|
self.assertFalse(surf.get_locked())
|
|
for posn, i in self.test_points:
|
|
r_surf, g_surf, b_surf, a_surf = surf.get_at(posn)
|
|
r_arr, g_arr, b_arr = dst[posn]
|
|
self.assertEqual(r_arr, r_surf,
|
|
"%i != %i, color: red, flags: %i"
|
|
", bpp: %i, posn: %s" %
|
|
(r_arr, r_surf,
|
|
surf.get_flags(), surf.get_bitsize(),
|
|
posn))
|
|
self.assertEqual(g_arr, g_surf,
|
|
"%i != %i, color: green, flags: %i"
|
|
", bpp: %i, posn: %s" %
|
|
(r_arr, r_surf,
|
|
surf.get_flags(), surf.get_bitsize(),
|
|
posn))
|
|
self.assertEqual(b_arr, b_surf,
|
|
"%i != %i, color: blue, flags: %i"
|
|
", bpp: %i, posn: %s" %
|
|
(r_arr, r_surf,
|
|
surf.get_flags(), surf.get_bitsize(),
|
|
posn))
|
|
|
|
swapped_dst[...] = 0
|
|
self.assertFalse(surf.get_locked())
|
|
surface_to_array(swapped_dst, surf)
|
|
self.assertFalse(surf.get_locked())
|
|
for posn, i in self.test_points:
|
|
r_surf, g_surf, b_surf, a_surf = surf.get_at(posn)
|
|
r_arr, g_arr, b_arr = swapped_dst[posn]
|
|
self.assertEqual(r_arr, r_surf,
|
|
"%i != %i, color: red, flags: %i"
|
|
", bpp: %i, posn: %s" %
|
|
(r_arr, r_surf,
|
|
surf.get_flags(), surf.get_bitsize(),
|
|
posn))
|
|
self.assertEqual(g_arr, g_surf,
|
|
"%i != %i, color: green, flags: %i"
|
|
", bpp: %i, posn: %s" %
|
|
(r_arr, r_surf,
|
|
surf.get_flags(), surf.get_bitsize(),
|
|
posn))
|
|
self.assertEqual(b_arr, b_surf,
|
|
"%i != %i, color: blue, flags: %i"
|
|
", bpp: %i, posn: %s" %
|
|
(r_arr, r_surf,
|
|
surf.get_flags(), surf.get_bitsize(),
|
|
posn))
|
|
|
|
def test_map_array(self):
|
|
try:
|
|
from numpy import array, zeros, uint8, int32, alltrue
|
|
except ImportError:
|
|
return
|
|
|
|
surf = pygame.Surface((1, 1), 0, 32)
|
|
|
|
# color fill
|
|
color = array([11, 17, 59], uint8)
|
|
target = zeros((5, 7), int32)
|
|
map_array(target, color, surf)
|
|
|
|
self.assertTrue(alltrue(target == surf.map_rgb(color)))
|
|
|
|
# array column stripes
|
|
stripe = array([[2, 5, 7], [11, 19, 23], [37, 53, 101]], uint8)
|
|
target = zeros((4, stripe.shape[0]), int32)
|
|
map_array(target, stripe, surf)
|
|
target_stripe = array([surf.map_rgb(c) for c in stripe], int32)
|
|
|
|
self.assertTrue(alltrue(target == target_stripe))
|
|
|
|
# array row stripes
|
|
stripe = array([[[2, 5, 7]],
|
|
[[11, 19, 24]],
|
|
[[10, 20, 30]],
|
|
[[37, 53, 101]]], uint8)
|
|
target = zeros((stripe.shape[0], 3), int32)
|
|
map_array(target, stripe, surf)
|
|
target_stripe = array([[surf.map_rgb(c)] for c in stripe[:,0]], int32)
|
|
|
|
self.assertTrue(alltrue(target == target_stripe))
|
|
|
|
# mismatched shape
|
|
w = 4
|
|
h = 5
|
|
source = zeros((w, h, 3), uint8)
|
|
target = zeros((w,), int32)
|
|
self.assertRaises(ValueError, map_array, target, source, surf)
|
|
source = zeros((12, w, h + 1), uint8)
|
|
self.assertRaises(ValueError, map_array, target, source, surf)
|
|
source = zeros((12, w - 1, 5), uint8)
|
|
self.assertRaises(ValueError, map_array, target, source, surf)
|
|
|
|
## def test_array_to_surface(self):
|
|
## array_to_surface gets a good workout in the surfarray module's
|
|
## unit tests under the alias blit_array.
|
|
|
|
try:
|
|
numpy
|
|
except NameError:
|
|
# Ensure no methods requiring numpy are run when
|
|
# pixelcopy_test is '__main__'.
|
|
del __init__
|
|
del test_surface_to_array_2d
|
|
del test_surface_to_array_3d
|
|
del test_map_array
|
|
else:
|
|
del numpy
|
|
|
|
|
|
@unittest.skipIf(not pygame.HAVE_NEWBUF, 'newbuf not implemented')
|
|
class PixelCopyTestWithArray(unittest.TestCase):
|
|
|
|
if pygame.HAVE_NEWBUF:
|
|
from pygame.tests.test_utils import buftools
|
|
class Array2D(buftools.Exporter):
|
|
def __init__(self, initializer):
|
|
from ctypes import cast, POINTER, c_uint32
|
|
|
|
Array2D = PixelCopyTestWithArray.Array2D
|
|
super(Array2D, self).__init__((3, 5),
|
|
format='=I',
|
|
strides=(20, 4))
|
|
self.content = cast(self.buf, POINTER(c_uint32))
|
|
for i, v in enumerate(initializer):
|
|
self.content[i] = v
|
|
def __getitem__(self, key):
|
|
byte_index = key[0] * 5 + key[1]
|
|
if not (0 <= byte_index < 15):
|
|
raise IndexError("%s is out of range", key)
|
|
return self.content[byte_index]
|
|
|
|
class Array3D(buftools.Exporter):
|
|
def __init__(self, initializer):
|
|
from ctypes import cast, POINTER, c_uint8
|
|
|
|
Array3D = PixelCopyTestWithArray.Array3D
|
|
super(Array3D, self).__init__((3, 5, 3),
|
|
format='B',
|
|
strides=(20, 4, 1))
|
|
self.content = cast(self.buf, POINTER(c_uint8))
|
|
for i, v in enumerate(initializer):
|
|
self.content[i] = v
|
|
def __getitem__(self, key):
|
|
byte_index = key[0] * 20 + key[1] * 4 + key[2]
|
|
if not (0 <= byte_index < 60):
|
|
raise IndexError("%s is out of range", key)
|
|
return self.content[byte_index]
|
|
|
|
|
|
surface = pygame.Surface((3, 5), 0, 32)
|
|
|
|
def setUp(self):
|
|
surf = self.surface
|
|
for y in range(5):
|
|
for x in range(3):
|
|
surf.set_at((x, y), (x + 1, 0, y + 1))
|
|
|
|
def assertCopy2D(self, surface, array):
|
|
for x in range(0, 3):
|
|
for y in range(0, 5):
|
|
self.assertEqual(surface.get_at_mapped((x, y)),
|
|
array[x, y])
|
|
|
|
def test_surface_to_array_newbuf(self):
|
|
array = self.Array2D(range(0, 15))
|
|
self.assertNotEqual(array.content[0],
|
|
self.surface.get_at_mapped((0, 0)))
|
|
surface_to_array(array, self.surface)
|
|
self.assertCopy2D(self.surface, array)
|
|
|
|
def test_array_to_surface_newbuf(self):
|
|
array = self.Array2D(range(0, 15))
|
|
self.assertNotEqual(array.content[0],
|
|
self.surface.get_at_mapped((0, 0)))
|
|
array_to_surface(self.surface, array)
|
|
self.assertCopy2D(self.surface, array)
|
|
|
|
def test_map_array_newbuf(self):
|
|
array2D = self.Array2D([0] * 15)
|
|
elements = [i + (255 - i << 8) + (99 << 16) for i in range(0,15)]
|
|
array3D = self.Array3D(elements)
|
|
map_array(array2D, array3D, self.surface)
|
|
for x in range(0, 3):
|
|
for y in range(0, 5):
|
|
p = array3D[x, y, 0], array3D[x, y, 1], array3D[x, y, 2]
|
|
self.assertEqual(self.surface.unmap_rgb(array2D[x, y]), p)
|
|
|
|
def test_make_surface_newbuf(self):
|
|
array = self.Array2D(range(10, 160, 10))
|
|
surface = make_surface(array)
|
|
self.assertCopy2D(surface, array)
|
|
|
|
def test_format_newbuf(self):
|
|
Exporter = self.buftools.Exporter
|
|
surface = self.surface
|
|
shape = surface.get_size()
|
|
w, h = shape
|
|
for format in ['=i', '=I', '=l', '=L', '=q', '=Q', '<i', '>i',
|
|
'!i', '1i', '=1i', '@q', 'q', '4x', '8x']:
|
|
surface.fill((255, 254, 253))
|
|
exp = Exporter(shape, format=format)
|
|
exp._buf[:] = [42] * exp.buflen
|
|
array_to_surface(surface, exp)
|
|
for x in range(w):
|
|
for y in range(h):
|
|
self.assertEqual(surface.get_at((x, y)), (42, 42, 42, 255))
|
|
# Some unsupported formats for array_to_surface and a 32 bit surface
|
|
for format in ['f', 'd', '?', 'x',
|
|
'1x', '2x', '3x', '5x', '6x', '7x', '9x']:
|
|
exp = Exporter(shape, format=format)
|
|
self.assertRaises(ValueError, array_to_surface, surface, exp)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|