def test_convolve__out_of_range(self):
full = Mask((2,2))
full.fill()
self.assertEqual(full.convolve(full, None, ( 0, 3)).count, 0)
self.assertEqual(full.convolve(full, None, ( 0, 2)).count, 3)
self.assertEqual(full.convolve(full, None, (-2, -2)).count, 1)
self.assertEqual(full.convolve(full, None, (-3, -3)).count, 0)
def test_convolve__size(self):
sizes = [(1,1), (31,31), (32,32), (100,100)]
for s1 in sizes:
m1 = Mask(s1)
for s2 in sizes:
m2 = Mask(s2)
o = m1.convolve(m2)
for i in (0,1):
self.assertEqual(o.size[i], m1.size[i] + m2.size[i] - 1)
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 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_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_fill(self):
# __doc__ (as of 2008-11-03) for pygame2.mask.Mask.fill:
# Mask.fill () -> None
#
# Sets all bits to 1 within the Mask.
m = Mask(100, 100)
self.assertEqual(m.count, 0)
m.fill()
self.assertEqual(m.count, 10000)
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_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_at(self):
# __doc__ (as of 2008-11-03) for pygame2.mask.Mask.get_at:
# Mask.get_at (x, y) -> int
#
# Gets the bit value at the desired location.
m = Mask (100, 100)
for x in range (100):
for y in range (100):
self.assertEqual (m.get_at (x, y), 0)
m = random_mask ()
pair = (0, 1)
for x in range (100):
for y in range (100):
self.assertTrue (m.get_at (x, y) in pair)
self.assertRaises (IndexError, m.get_at, -1, 0)
self.assertRaises (IndexError, m.get_at, -7, 3)
self.assertRaises (IndexError, m.get_at, -1, -1)
self.assertRaises (IndexError, m.get_at, 0, -1)
self.assertRaises (IndexError, m.get_at, 8, -10)
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_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_pygame2_mask_Mask_draw(self):
# __doc__ (as of 2008-11-03) for pygame2.mask.Mask.draw:
# Mask.draw (mask, x, y) -> None
#
# Draws the passed Mask onto the Mask.
#
# This performs a bitwise OR operation upon the calling Mask. The
# passed mask's start offset for the draw operation will be the x and
# y offset passed to the method.
m = Mask (100, 100)
self.assertEqual(m.count, 0)
m.fill()
self.assertEqual(m.count, 10000)
m2 = Mask (10,10)
m2.fill()
m.erase (m2, (50, 50))
self.assertEqual(m.count, 9900)
m.invert()
self.assertEqual(m.count, 100)
m.draw(m2, (0,0))
self.assertEqual(m.count, 200)
m.clear()
self.assertEqual(m.count, 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 todo_test_pygame2_mask_Mask_erase(self):
# __doc__ (as of 2008-11-03) for pygame2.mask.Mask.erase:
# Mask.erase (mask, x, y) -> None
#
# Erases the passed Mask from the Mask.
#
# This performs a bitwise NAND operation upon the calling Mask.
# The passed mask's start offfset for the erase operation will
# be the x and y offset passed to the method.
m1 = Mask (10, 10)
m1.fill ()
m2 = Mask (10, 10)
m2.fill ()
m1.erase (m2, 0, 0)
self.assertEqual (m1.count, 0)
m1.fill ()
m1.erase (m2, 1, 1)
self.assertEqual (m1.count, 19)
m1.fill ()
m1.erase (m2, 2, 0)
self.assertEqual (m1.count, 20)
m1.fill ()
m1.erase (m2, 0, 10)
self.assertEqual (m1.count, 100)
m1.fill ()
m1.erase (m2, 10, 0)
self.assertEqual (m1.count, 100)
m1.fill ()
m1.erase (m2, -1, 0)
self.assertEqual (m1.count, 10)
m1.fill ()
m1.erase (m2, 0, -1)
self.assertEqual (m1.count, 10)
def test_drawing (self):
""" Test fill, clear, invert, draw, erase
"""
m = Mask((100,100))
self.assertEqual(m.count, 0)
m.fill()
self.assertEqual(m.count, 10000)
m2 = Mask((10,10))
m2.fill()
m.erase(m2, (50,50))
self.assertEqual(m.count, 9900)
m.invert()
self.assertEqual(m.count, 100)
m.draw(m2, (0,0))
self.assertEqual(m.count, 200)
m.clear()
self.assertEqual(m.count, 0)
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)]")
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)
