def random_mask(size = (100,100)):
"""random_mask(size=(100,100)): return Mask
Create a mask of the given size, with roughly half the bits set at
random."""
m = Mask(size)
for i in range(size[0] * size[1] // 2):
x, y = random.randint(0,size[0] - 1), random.randint(0, size[1] - 1)
m.set_at(x, y)
return m
def test_convolve__point_identities(self):
"""Convolving with a single point is the identity, while
convolving a point with something flips it."""
m = random_mask((100,100))
k = Mask((1,1))
k.set_at((0,0))
self.assertMaskEquals(m,m.convolve(k))
self.assertMaskEquals(m,k.convolve(k.convolve(m)))
def test_pygame2_mask_Mask_copy (self):
m = Mask (10, 10)
for x in range (0, 10, 2):
for y in range (0, 10, 2):
m.set_at (x, y)
self.assertEqual (m.count, 25)
m2 = m.copy ()
for x in range (0, 10, 2):
for y in range (0, 10, 2):
self.assertEqual (m2.get_at (x, y), 1)
def test_pygame2_mask_Mask_count(self):
# __doc__ (as of 2008-11-03) for pygame2.mask.Mask.count:
# Gets the amount of bits in the Mask.
m = Mask (10, 10)
for x in range (10):
for y in range (10):
m.set_at (x, y)
self.assertEqual (m.count, 100)
m.clear ()
self.assertEqual (m.count, 0)
def test_pygame2_mask_Mask_connected_components(self):
# __doc__ (as of 2008-11-03) for pygame2.mask.Mask.connected_components:
# Mask.connected_component (x=None, y=None) -> Mask
#
# Returns a Mask of a connected region of pixels.
#
# This uses the SAUF algorithm to find a connected component in
# the Mask. It checks 8 point connectivity. By default, it will
# return the largest connected component in the
# image. Optionally, a coordinate pair of a pixel can be
# specified, and the connected component containing it will be
# returned. In the event the pixel at that location is not set,
# the returned Mask will be empty. The Mask returned is the same
# size as the original Mask.
m = Mask(10,10)
self.assertEqual(repr(m.connected_components()), "[]")
comp = m.connected_component()
self.assertEqual(m.count, comp.count)
m.set_at(0,0, 1)
m.set_at(1,1, 1)
comp = m.connected_component()
comps = m.connected_components()
comps1 = m.connected_components(1)
comps2 = m.connected_components(2)
comps3 = m.connected_components(3)
self.assertEqual(comp.count, comps[0].count)
self.assertEqual(comps1[0].count, 2)
self.assertEqual(comps2[0].count, 2)
self.assertEqual(repr(comps3), "[]")
m.set_at(9, 9, 1)
comp = m.connected_component()
comp1 = m.connected_component(1, 1)
comp2 = m.connected_component(2, 2)
comps = m.connected_components()
comps1 = m.connected_components(1)
comps2 = m.connected_components(2)
comps3 = m.connected_components(3)
self.assertEqual(comp.count, 2)
self.assertEqual(comp1.count, 2)
self.assertEqual(comp2.count, 0)
self.assertEqual(len(comps), 2)
self.assertEqual(len(comps1), 2)
self.assertEqual(len(comps2), 1)
self.assertEqual(len(comps3), 0)
def test_convolve__with_output(self):
"""checks that convolution modifies only the correct portion of
the output"""
m = random_mask((10,10))
k = Mask((2,2))
k.set_at((0,0))
o = Mask((50,50))
test = Mask((50,50))
m.convolve(k,o)
test.draw(m,(1,1))
self.assertMaskEquals(o, test)
o.clear()
test.clear()
m.convolve(k,o, (10,10))
test.draw(m,(11,11))
self.assertMaskEquals(o, test)
def test_pygame2_mask_Mask_invert(self):
# __doc__ (as of 2008-11-03) for pygame2.mask.Mask.invert:
# Mask.invert () -> None
#
# Inverts all bits in the Mask.
m = Mask (10, 10)
for x in range (10):
for y in range (10):
m.set_at (x, y)
self.assertEqual (m.count, 100)
m.invert ()
self.assertEqual (m.count, 0)
m.set_at (4, 4)
m.invert ()
self.assertEqual (m.count, 99)
self.assertEqual (m.get_at (4, 4), 0)
for x in range (10):
for y in range (10):
if x == y == 4:
self.assertEqual (m.get_at (x, y), 0)
else:
self.assertEqual (m.get_at (x, y), 1)
def test_pygame2_mask_Mask_outline(self):
# __doc__ (as of 2008-11-03) for pygame2.mask.Mask.outline:
m = Mask (20, 20)
self.assertEqual(m.outline(), [])
m.set_at(10, 10, 1)
self.assertEqual(m.outline(), [(10,10)])
m.set_at( 10, 12, 1)
self.assertEqual(m.outline(10), [(10,10)])
m.set_at(11, 11, 1)
self.assertEqual(m.outline(), [(10,10), (11,11), (10,12), (11,11),
(10,10)])
self.assertEqual(m.outline(2), [(10,10), (10,12), (10,10)])
def test_pygame2_mask_Mask_set_at(self):
# __doc__ (as of 2008-11-03) for pygame2.mask.Mask.set_at:
# Mask.set_at (x, y) -> None
#
# Sets the bit value at the desired location.
m = Mask (10, 10)
m.set_at (0, 0, 1)
self.assertEqual(m.get_at(0, 0), 1)
m.set_at(9, 0, 1)
self.assertEqual(m.get_at(9, 0), 1)
# out of bounds, should get IndexError
self.assertRaises(IndexError, lambda : m.get_at (-1,0) )
self.assertRaises(IndexError, lambda : m.set_at (-1, 0, 1) )
self.assertRaises(IndexError, lambda : m.set_at (10, 0, 1) )
self.assertRaises(IndexError, lambda : m.set_at (0, 10, 1) )
def test_pygame2_mask_Mask_get_bounding_rects(self):
# __doc__ (as of 2008-11-03) for pygame2.mask.Mask.get_bounding_rects:
# Mask.get_bounding_rects () -> [Mask, Mask ...]
#
# Returns a list of bounding rects of regions of set pixels.
#
# This gets a bounding rect of connected regions of set bits. A
# bounding rect is one for which each of the connected pixels is
# inside the rect.
m = Mask (10, 10)
m.set_at(0, 0, 1)
m.set_at(1, 0, 1)
m.set_at(0, 1, 1)
m.set_at(0,3, 1)
m.set_at(3,3, 1)
r = m.get_bounding_rects()
self.assertEqual(repr(r),
"[Rect(0, 0, 2, 2), Rect(0, 3, 1, 1), Rect(3, 3, 1, 1)]")
#1100
#1111
m = Mask(4,2)
m.set_at(0,0, 1)
m.set_at(1,0, 1)
m.set_at(2,0, 0)
m.set_at(3,0, 0)
m.set_at(0,1, 1)
m.set_at(1,1, 1)
m.set_at(2,1, 1)
m.set_at(3,1, 1)
r = m.get_bounding_rects()
self.assertEqual(repr(r), "[Rect(0, 0, 4, 2)]")
#00100
#01110
#00100
m = Mask(5,3)
m.set_at(0,0, 0)
m.set_at(1,0, 0)
m.set_at(2,0, 1)
m.set_at(3,0, 0)
m.set_at(4,0, 0)
m.set_at(0,1, 0)
m.set_at(1,1, 1)
m.set_at(2,1, 1)
m.set_at(3,1, 1)
m.set_at(4,1, 0)
m.set_at(0,2, 0)
m.set_at(1,2, 0)
m.set_at(2,2, 1)
m.set_at(3,2, 0)
m.set_at(4,2, 0)
r = m.get_bounding_rects()
self.assertEqual(repr(r), "[Rect(1, 0, 3, 3)]")
#00010
#00100
#01000
m = Mask(5,3)
m.set_at(0,0, 0)
m.set_at(1,0, 0)
m.set_at(2,0, 0)
m.set_at(3,0, 1)
m.set_at(4,0, 0)
m.set_at(0,1, 0)
m.set_at(1,1, 0)
m.set_at(2,1, 1)
m.set_at(3,1, 0)
m.set_at(4,1, 0)
m.set_at(0,2, 0)
m.set_at(1,2, 1)
m.set_at(2,2, 0)
m.set_at(3,2, 0)
m.set_at(4,2, 0)
r = m.get_bounding_rects()
self.assertEqual(repr(r), "[Rect(1, 0, 3, 3)]")
#00011
#11111
m = Mask(5,2)
m.set_at(0,0, 0)
m.set_at(1,0, 0)
m.set_at(2,0, 0)
m.set_at(3,0, 1)
m.set_at(4,0, 1)
m.set_at(0,1, 1)
m.set_at(1,1, 1)
m.set_at(2,1, 1)
m.set_at(3,1, 1)
m.set_at(3,1, 1)
r = m.get_bounding_rects()
self.assertEqual(repr(r), "[Rect(0, 0, 5, 2)]")
