def apply(self, img, n=0):
"Modify image based on equation provided"
srf, size = self.srfSize(img, True)
h = size[1]
pxa = PixelArray(srf)
x = 0
for pxCol in pxa:
y = self.eqn(x, n, size)
if type(y) is tuple: y, above = y
else: above = True
if type(y) is float: y = int(y)
if above:
if y < h - 1:
if y < 0: y = 0
pxCol[y:] = self.fill
elif y > 0:
if y > h: y = h
pxCol[:y] = self.fill
x += 1
return srf
python类PixelArray()的实例源码
def display_test():
pygame.init()
screen = pygame.display.set_mode((800,400))
pygame.display.set_caption('Pygame')
pygame.mouse.set_visible(0)
background = pygame.Surface(screen.get_size())
background = background.convert()
background.fill((250,250,250))
pxarray = pygame.PixelArray(background)
pxarray[:] = (i%250,i%25,i%150)
del pxarray
screen.blit(background, (0,0))
pygame.display.flip()
time.sleep(3)
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_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_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_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_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_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_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])
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_pxarray_ref (self):
sf = pygame.Surface ((5, 5))
ar = pygame.PixelArray (sf)
ar2 = pygame.PixelArray (sf)
self.assertEquals (sf.get_locked (), True)
self.assertEquals (sf.get_locks (), (ar, ar2))
del ar
self.assertEquals (sf.get_locked (), True)
self.assertEquals (sf.get_locks (), (ar2,))
ar = ar2[:]
self.assertEquals (sf.get_locked (), True)
self.assertEquals (sf.get_locks (), (ar2,))
del ar
self.assertEquals (sf.get_locked (), True)
self.assertEquals (len (sf.get_locks ()), 1)
def __init__(self, *args):
# 'default_color' is used by stella init, need to set before super
self.default_color = 0
self._colors = PygameColors()
super(PygameStella, self).__init__(*args)
# Test if 'PixelArray' is part of pygame
# pygame_cffi, may not have PixelArray
if has_numpy:
# Use a faster blit with a numpy array, if available.
self.driver_draw_display = self._draw_using_numpy_array
elif hasattr(pygame, 'PixelArray'):
self.driver_draw_display = self._draw_using_pixel_array
else:
self.driver_draw_display = self._draw_using_set_at
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)
if sf.mustlock():
self.assertTrue (sf.get_locked ())
self.assertEqual (len (ar), 10)
del ar
if sf.mustlock():
self.assertFalse (sf.get_locked ())
# 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):
for bpp in (8, 16, 24, 32):
sf = pygame.Surface ((10, 20), 0, bpp)
sf.fill ((0, 0, 255))
for x in xrange_ (20):
sf.set_at ((1, x), (0, 0, 11))
for x in xrange_ (10):
sf.set_at ((x, 1), (0, 0, 11))
ar = pygame.PixelArray (sf)
ar2 = ar.__getitem__ (0).__getitem__ (0)
self.assertEqual (ar2, sf.map_rgb ((0, 0, 255)))
ar2 = ar.__getitem__ (1).__getitem__ (0)
self.assertEqual (ar2, sf.map_rgb ((0, 0, 11)))
ar2 = ar.__getitem__ (-4).__getitem__ (1)
self.assertEqual (ar2, sf.map_rgb ((0, 0, 11)))
ar2 = ar.__getitem__ (-4).__getitem__ (5)
self.assertEqual (ar2, sf.map_rgb ((0, 0, 255)))
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_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_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)))
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_pxarray_ref (self):
sf = pygame.Surface ((5, 5))
ar = pygame.PixelArray (sf)
ar2 = pygame.PixelArray (sf)
self.assertEquals (sf.get_locked (), True)
self.assertEquals (sf.get_locks (), (ar, ar2))
del ar
self.assertEquals (sf.get_locked (), True)
self.assertEquals (sf.get_locks (), (ar2,))
ar = ar2[:]
self.assertEquals (sf.get_locked (), True)
self.assertEquals (sf.get_locks (), (ar2,))
del ar
self.assertEquals (sf.get_locked (), True)
self.assertEquals (len (sf.get_locks ()), 1)
def createByImage(path = "map.png"):
m = GameMap()
try:
mapdata = pygame.image.load(path)
except:
return m
size = mapdata.get_size()
black = mapdata.map_rgb((0, 0, 0))
mapdata = pygame.PixelArray(mapdata)
m.setWidth(size[0])
m.setHeight(size[1])
for x in xrange(size[0]):
for y in xrange(size[1]):
if mapdata[x][y] == black:
m._invalidPositions.add((x, y))
return m
def apply(self, img, n=0):
srf = self.srfSize(img)
d = self.dist * (1 - n)
pygame.PixelArray(srf).replace(self.color1, self.color2, d)
return img
def apply(self, img, n):
"Apply pixel-by-pixel effect"
srf = self.srfSize(img)
pxa = PixelArray(srf)
x = 0
for pxCol in pxa:
for y in range(len(pxCol)):
c = pxCol[y]
px = self.pixel(n, x, y, c)
if px != c: pxCol[y] = px
x += 1
return srf
def __init__(self, colors=None):
img = Image.fromBytes(sc8prData("robot"))
if colors:
px = pygame.PixelArray(img.image)
for i in range(2):
c = 255 * (1 - i), 0, 255*i
px.replace(c, rgba(colors[i]))
img = img.tiles(2)
super().__init__(img)
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.assert_ (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_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')
self.assertTrue ('nonnative' in ar.__dict__)
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)
# Sequence interfaces
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)))
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.assert_ (ar.surface is sf)
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]
