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)
python类PixelArray()的实例源码
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_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_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)")
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)
def addMessage(self, message=None, message_arr=None, color=None):
old_messages = self.messages
for msg in self.messages:
arr = pygame.PixelArray(msg)
arr.replace(self.color, self.old_message_color)
if not(color):
color = self.color
if message:
self.messages.append(self.pen.render(message, True, color))
if message_arr:
for msg in message_arr:
self.messages.append(self.pen.render(msg, True, color))
self.dirty = True
def _draw_using_pixel_array(self):
pxarray = pygame.PixelArray(self._background)
for y in range(min(self.END_DRAW_Y - self.START_DRAW_Y, self.FRAME_HEIGHT)):
for x in range(self.FRAME_WIDTH):
pxarray[x][y] = self._display_lines[y][x]
del pxarray
def pix_Array():
# get a pixel array of the surface
global pixArray
pixArray = pygame.PixelArray(windowSurface)
#pixArray[480][380] = BLACK
pixArray[480][800] = BLACK
del pixArray
return
def todo_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.
self.fail()
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)
if PY3:
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)
else:
self.assertEqual (len (ar.__getslice__ (0, 2)), 2)
self.assertEqual (len (ar.__getslice__ (3, 7)[3]), 20)
self.assertEqual (ar.__getslice__ (0, 0), None)
self.assertEqual (ar.__getslice__ (5, 5), None)
self.assertEqual (ar.__getslice__ (9, 9), None)
# Has to resolve to ar[7:8]
self.assertEqual (len (ar[-3:-2]), 20)
# Try assignments.
# 2D assignment.
if PY3:
ar[2:5] = (255, 255, 255)
else:
ar.__setslice__ (2, 5, (255, 255, 255))
self.assertEqual (ar[3][3], sf.map_rgb ((255, 255, 255)))
# 1D assignment
if PY3:
ar[3][3:7] = (10, 10, 10)
else:
ar[3].__setslice__ (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)))
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.assertEqual (sf, ar.surface)
def test_make_surface (self):
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((10, 20), 0, bpp)
sf.fill ((255, 255, 255))
ar = pygame.PixelArray (sf)
newsf = ar[::2,::2].make_surface ()
rect = newsf.get_rect ()
self.assertEqual (rect.width, 5)
self.assertEqual (rect.height, 10)
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 todo_test_surface(self):
# __doc__ (as of 2008-08-02) for pygame.pixelarray.PixelArray.surface:
# PixelArray.surface: Return Surface
# Gets the Surface the PixelArray uses.
#
# The Surface, the PixelArray was created for.
self.fail()
def add_colour(self, canvas, fg_surf, border_surf=None):
cs = self.colourstate.get_sample(2 + (border_surf is not None))
# replace background
pygame.PixelArray(canvas).replace((255,255,255), (cs[0],cs[0],cs[0]), distance=1.0)
# replace foreground
pygame.PixelArray(fg_surf).replace((0,0,0), (cs[1],cs[1],cs[1]), distance=0.99)
def format_surface_render(self, surface):
resized_surface = pygame.transform.smoothscale(pygame.PixelArray(surface).make_surface(), (52, 68)) # (W, H)
formatted_array = np.zeros((68, 52), dtype="uint8")
for i in range(68):
for j in range(52):
red, green, blue, alpha = resized_surface.get_at((j, i)) # (x, y)
formatted_array[i, j] = int((red + green + blue) / 3)
return formatted_array
