ProjektAI/venv/Lib/site-packages/pygame/tests/mask_test.py

2051 lines
74 KiB
Python
Raw Normal View History

2020-04-20 22:51:16 +02:00
from collections import OrderedDict
import random
import unittest
import pygame
import pygame.mask
from pygame.locals import *
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 = pygame.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 maskFromSurface(surface, threshold = 127):
mask = pygame.Mask(surface.get_size())
key = surface.get_colorkey()
if key:
for y in range(surface.get_height()):
for x in range(surface.get_width()):
if surface.get_at((x+0.1,y+0.1)) != key:
mask.set_at((x,y),1)
else:
for y in range(surface.get_height()):
for x in range (surface.get_width()):
if surface.get_at((x,y))[3] > threshold:
mask.set_at((x,y),1)
return mask
class MaskTypeTest(unittest.TestCase):
ORIGIN_OFFSETS = ((0, 0), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1),
(-1, -1), (-1, 0), (-1, 1))
def _assertMaskEqual(self, m1, m2, msg=None):
# Checks to see if the 2 given masks are equal.
m1_count = m1.count()
self.assertEqual(m1.get_size(), m2.get_size(), msg=msg)
self.assertEqual(m1_count, m2.count(), msg=msg)
self.assertEqual(m1_count, m1.overlap_area(m2, (0, 0)), msg=msg)
# This can be used to help debug exact locations.
##for i in range(m1.get_size()[0]):
## for j in range(m1.get_size()[1]):
## self.assertEqual(m1.get_at((i, j)), m2.get_at((i, j)))
def test_mask(self):
"""Ensure masks are created correctly without fill parameter."""
expected_count = 0
expected_size = (11, 23)
mask1 = pygame.mask.Mask(expected_size)
mask2 = pygame.mask.Mask(size=expected_size)
self.assertEqual(mask1.count(), expected_count)
self.assertEqual(mask1.get_size(), expected_size)
self.assertEqual(mask2.count(), expected_count)
self.assertEqual(mask2.get_size(), expected_size)
def test_mask__negative_size(self):
"""Ensure the mask constructor handles negative sizes correctly."""
for size in ((1, -1), (-1, 1), (-1, -1)):
with self.assertRaises(ValueError):
mask = pygame.Mask(size)
def test_mask__fill_kwarg(self):
"""Ensure masks are created correctly using the fill keyword."""
width, height = 37, 47
expected_size = (width, height)
fill_counts = {True : width * height, False : 0 }
for fill, expected_count in fill_counts.items():
msg = 'fill={}'.format(fill)
mask = pygame.mask.Mask(expected_size, fill=fill)
self.assertEqual(mask.count(), expected_count, msg)
self.assertEqual(mask.get_size(), expected_size, msg)
def test_mask__fill_arg(self):
"""Ensure masks are created correctly using a fill arg."""
width, height = 59, 71
expected_size = (width, height)
fill_counts = {True : width * height, False : 0 }
for fill, expected_count in fill_counts.items():
msg = 'fill={}'.format(fill)
mask = pygame.mask.Mask(expected_size, fill)
self.assertEqual(mask.count(), expected_count, msg)
self.assertEqual(mask.get_size(), expected_size, msg)
def test_mask__size_kwarg(self):
"""Ensure masks are created correctly using the size keyword."""
width, height = 73, 83
expected_size = (width, height)
fill_counts = {True : width * height, False : 0 }
for fill, expected_count in fill_counts.items():
msg = 'fill={}'.format(fill)
mask1 = pygame.mask.Mask(fill=fill, size=expected_size)
mask2 = pygame.mask.Mask(size=expected_size, fill=fill)
self.assertEqual(mask1.count(), expected_count, msg)
self.assertEqual(mask2.count(), expected_count, msg)
self.assertEqual(mask1.get_size(), expected_size, msg)
self.assertEqual(mask2.get_size(), expected_size, msg)
def test_get_size(self):
"""Ensure a mask's size is correctly retrieved."""
expected_size = (93, 101)
mask = pygame.mask.Mask(expected_size)
self.assertEqual(mask.get_size(), expected_size)
def test_get_at(self):
"""Ensure individual mask bits are correctly retrieved."""
width, height = 5, 7
mask0 = pygame.mask.Mask((width, height))
mask1 = pygame.mask.Mask((width, height), fill=True)
mask0_expected_bit = 0
mask1_expected_bit = 1
pos = (width - 1, height - 1)
# Check twice to make sure bits aren't toggled.
self.assertEqual(mask0.get_at(pos), mask0_expected_bit)
self.assertEqual(mask0.get_at(pos), mask0_expected_bit)
self.assertEqual(mask1.get_at(pos), mask1_expected_bit)
self.assertEqual(mask1.get_at(pos), mask1_expected_bit)
def test_get_at__out_of_bounds(self):
"""Ensure get_at() checks bounds."""
width, height = 11, 3
mask = pygame.mask.Mask((width, height))
with self.assertRaises(IndexError):
mask.get_at((width, 0))
with self.assertRaises(IndexError):
mask.get_at((0, height))
with self.assertRaises(IndexError):
mask.get_at((-1, 0))
with self.assertRaises(IndexError):
mask.get_at((0, -1))
def test_set_at(self):
"""Ensure individual mask bits are set to 1."""
width, height = 13, 17
mask0 = pygame.mask.Mask((width, height))
mask1 = pygame.mask.Mask((width, height), fill=True)
mask0_expected_count = 1
mask1_expected_count = mask1.count()
expected_bit = 1
pos = (width - 1, height - 1)
mask0.set_at(pos, expected_bit) # set 0 to 1
mask1.set_at(pos, expected_bit) # set 1 to 1
self.assertEqual(mask0.get_at(pos), expected_bit)
self.assertEqual(mask0.count(), mask0_expected_count)
self.assertEqual(mask1.get_at(pos), expected_bit)
self.assertEqual(mask1.count(), mask1_expected_count)
def test_set_at__to_0(self):
"""Ensure individual mask bits are set to 0."""
width, height = 11, 7
mask0 = pygame.mask.Mask((width, height))
mask1 = pygame.mask.Mask((width, height), fill=True)
mask0_expected_count = 0
mask1_expected_count = mask1.count() - 1
expected_bit = 0
pos = (width - 1, height - 1)
mask0.set_at(pos, expected_bit) # set 0 to 0
mask1.set_at(pos, expected_bit) # set 1 to 0
self.assertEqual(mask0.get_at(pos), expected_bit)
self.assertEqual(mask0.count(), mask0_expected_count)
self.assertEqual(mask1.get_at(pos), expected_bit)
self.assertEqual(mask1.count(), mask1_expected_count)
def test_set_at__default_value(self):
"""Ensure individual mask bits are set using the default value."""
width, height = 3, 21
mask0 = pygame.mask.Mask((width, height))
mask1 = pygame.mask.Mask((width, height), fill=True)
mask0_expected_count = 1
mask1_expected_count = mask1.count()
expected_bit = 1
pos = (width - 1, height - 1)
mask0.set_at(pos) # set 0 to 1
mask1.set_at(pos) # set 1 to 1
self.assertEqual(mask0.get_at(pos), expected_bit)
self.assertEqual(mask0.count(), mask0_expected_count)
self.assertEqual(mask1.get_at(pos), expected_bit)
self.assertEqual(mask1.count(), mask1_expected_count)
def test_set_at__out_of_bounds(self):
"""Ensure set_at() checks bounds."""
width, height = 11, 3
mask = pygame.mask.Mask((width, height))
with self.assertRaises(IndexError):
mask.set_at((width, 0))
with self.assertRaises(IndexError):
mask.set_at((0, height))
with self.assertRaises(IndexError):
mask.set_at((-1, 0))
with self.assertRaises(IndexError):
mask.set_at((0, -1))
def test_overlap(self):
"""Ensure the overlap intersection is correctly calculated.
Testing the different combinations of full/empty masks:
(mask1-filled) 1 overlap 1 (mask2-filled)
(mask1-empty) 0 overlap 1 (mask2-filled)
(mask1-filled) 1 overlap 0 (mask2-empty)
(mask1-empty) 0 overlap 0 (mask2-empty)
"""
expected_size = (4, 4)
offset = (0, 0)
expected_default = None
expected_overlaps = {(True, True) : offset}
for fill2 in (True, False):
mask2 = pygame.mask.Mask(expected_size, fill=fill2)
mask2_count = mask2.count()
for fill1 in (True, False):
key = (fill1, fill2)
msg = 'key={}'.format(key)
mask1 = pygame.mask.Mask(expected_size, fill=fill1)
mask1_count = mask1.count()
expected_pos = expected_overlaps.get(key, expected_default)
overlap_pos = mask1.overlap(mask2, offset)
self.assertEqual(overlap_pos, expected_pos, msg)
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count, msg)
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask1.get_size(), expected_size, msg)
self.assertEqual(mask2.get_size(), expected_size, msg)
def test_overlap__offset(self):
"""Ensure an offset overlap intersection is correctly calculated."""
mask1 = pygame.mask.Mask((65, 3), fill=True)
mask2 = pygame.mask.Mask((66, 4), fill=True)
mask1_count = mask1.count()
mask2_count = mask2.count()
mask1_size = mask1.get_size()
mask2_size = mask2.get_size()
for offset in self.ORIGIN_OFFSETS:
msg = 'offset={}'.format(offset)
expected_pos = (max(offset[0], 0), max(offset[1], 0))
overlap_pos = mask1.overlap(mask2, offset)
self.assertEqual(overlap_pos, expected_pos, msg)
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count, msg)
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask1.get_size(), mask1_size, msg)
self.assertEqual(mask2.get_size(), mask2_size, msg)
def test_overlap__offset_with_unset_bits(self):
"""Ensure an offset overlap intersection is correctly calculated
when (0, 0) bits not set."""
mask1 = pygame.mask.Mask((65, 3), fill=True)
mask2 = pygame.mask.Mask((66, 4), fill=True)
unset_pos = (0, 0)
mask1.set_at(unset_pos, 0)
mask2.set_at(unset_pos, 0)
mask1_count = mask1.count()
mask2_count = mask2.count()
mask1_size = mask1.get_size()
mask2_size = mask2.get_size()
for offset in self.ORIGIN_OFFSETS:
msg = 'offset={}'.format(offset)
x, y = offset
expected_y = max(y, 0)
if 0 == y:
expected_x = max(x + 1, 1)
elif 0 < y:
expected_x = max(x + 1, 0)
else:
expected_x = max(x, 1)
overlap_pos = mask1.overlap(mask2, offset)
self.assertEqual(overlap_pos, (expected_x, expected_y), msg)
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count, msg)
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask1.get_size(), mask1_size, msg)
self.assertEqual(mask2.get_size(), mask2_size, msg)
self.assertEqual(mask1.get_at(unset_pos), 0, msg)
self.assertEqual(mask2.get_at(unset_pos), 0, msg)
def test_overlap__no_overlap(self):
"""Ensure an offset overlap intersection is correctly calculated
when there is no overlap."""
mask1 = pygame.mask.Mask((65, 3), fill=True)
mask1_count = mask1.count()
mask1_size = mask1.get_size()
mask2_w, mask2_h = 67, 5
mask2_size = (mask2_w, mask2_h)
mask2 = pygame.mask.Mask(mask2_size)
set_pos = (mask2_w - 1, mask2_h - 1)
mask2.set_at(set_pos)
mask2_count = 1
for offset in self.ORIGIN_OFFSETS:
msg = 'offset={}'.format(offset)
overlap_pos = mask1.overlap(mask2, offset)
self.assertIsNone(overlap_pos, msg)
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count, msg)
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask1.get_size(), mask1_size, msg)
self.assertEqual(mask2.get_size(), mask2_size, msg)
self.assertEqual(mask2.get_at(set_pos), 1, msg)
def test_overlap__offset_boundary(self):
"""Ensures overlap handles offsets and boundaries correctly."""
mask1 = pygame.mask.Mask((13, 3), fill=True)
mask2 = pygame.mask.Mask((7, 5), fill=True)
mask1_count = mask1.count()
mask2_count = mask2.count()
mask1_size = mask1.get_size()
mask2_size = mask2.get_size()
# Check the 4 boundaries.
offsets = ((mask1_size[0], 0), # off right
(0, mask1_size[1]), # off bottom
(-mask2_size[0], 0), # off left
(0, -mask2_size[1])) # off top
for offset in offsets:
msg = 'offset={}'.format(offset)
overlap_pos = mask1.overlap(mask2, offset)
self.assertIsNone(overlap_pos, msg)
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count, msg)
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask1.get_size(), mask1_size, msg)
self.assertEqual(mask2.get_size(), mask2_size, msg)
def test_overlap__invalid_mask_arg(self):
"""Ensure overlap handles invalid mask arguments correctly."""
size = (5, 3)
offset = (0, 0)
mask = pygame.mask.Mask(size)
invalid_mask = pygame.Surface(size)
with self.assertRaises(TypeError):
overlap_pos = mask.overlap(invalid_mask, offset)
def test_overlap__invalid_offset_arg(self):
"""Ensure overlap handles invalid offset arguments correctly."""
size = (2, 7)
offset = '(0, 0)'
mask1 = pygame.mask.Mask(size)
mask2 = pygame.mask.Mask(size)
with self.assertRaises(TypeError):
overlap_pos = mask1.overlap(mask2, offset)
def test_overlap_area(self):
"""Ensure the overlap_area is correctly calculated.
Testing the different combinations of full/empty masks:
(mask1-filled) 1 overlap_area 1 (mask2-filled)
(mask1-empty) 0 overlap_area 1 (mask2-filled)
(mask1-filled) 1 overlap_area 0 (mask2-empty)
(mask1-empty) 0 overlap_area 0 (mask2-empty)
"""
expected_size = width, height = (4, 4)
offset = (0, 0)
expected_default = 0
expected_counts = {(True, True) : width * height}
for fill2 in (True, False):
mask2 = pygame.mask.Mask(expected_size, fill=fill2)
mask2_count = mask2.count()
for fill1 in (True, False):
key = (fill1, fill2)
msg = 'key={}'.format(key)
mask1 = pygame.mask.Mask(expected_size, fill=fill1)
mask1_count = mask1.count()
expected_count = expected_counts.get(key, expected_default)
overlap_count = mask1.overlap_area(mask2, offset)
self.assertEqual(overlap_count, expected_count, msg)
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count, msg)
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask1.get_size(), expected_size, msg)
self.assertEqual(mask2.get_size(), expected_size, msg)
def test_overlap_area__offset(self):
"""Ensure an offset overlap_area is correctly calculated."""
mask1 = pygame.mask.Mask((65, 3), fill=True)
mask2 = pygame.mask.Mask((66, 4), fill=True)
mask1_count = mask1.count()
mask2_count = mask2.count()
mask1_size = mask1.get_size()
mask2_size = mask2.get_size()
# Using rects to help determine the overlapping area.
rect1 = pygame.Rect((0, 0), mask1_size)
rect2 = pygame.Rect((0, 0), mask2_size)
for offset in self.ORIGIN_OFFSETS:
msg = 'offset={}'.format(offset)
rect2.topleft = offset
overlap_rect = rect1.clip(rect2)
expected_count = overlap_rect.w * overlap_rect.h
overlap_count = mask1.overlap_area(mask2, offset)
self.assertEqual(overlap_count, expected_count, msg)
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count, msg)
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask1.get_size(), mask1_size, msg)
self.assertEqual(mask2.get_size(), mask2_size, msg)
def test_overlap_area__offset_boundary(self):
"""Ensures overlap_area handles offsets and boundaries correctly."""
mask1 = pygame.mask.Mask((11, 3), fill=True)
mask2 = pygame.mask.Mask((5, 7), fill=True)
mask1_count = mask1.count()
mask2_count = mask2.count()
mask1_size = mask1.get_size()
mask2_size = mask2.get_size()
expected_count = 0
# Check the 4 boundaries.
offsets = ((mask1_size[0], 0), # off right
(0, mask1_size[1]), # off bottom
(-mask2_size[0], 0), # off left
(0, -mask2_size[1])) # off top
for offset in offsets:
msg = 'offset={}'.format(offset)
overlap_count = mask1.overlap_area(mask2, offset)
self.assertEqual(overlap_count, expected_count, msg)
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count, msg)
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask1.get_size(), mask1_size, msg)
self.assertEqual(mask2.get_size(), mask2_size, msg)
def test_overlap_area__invalid_mask_arg(self):
"""Ensure overlap_area handles invalid mask arguments correctly."""
size = (3, 5)
offset = (0, 0)
mask = pygame.mask.Mask(size)
invalid_mask = pygame.Surface(size)
with self.assertRaises(TypeError):
overlap_count = mask.overlap_area(invalid_mask, offset)
def test_overlap_area__invalid_offset_arg(self):
"""Ensure overlap_area handles invalid offset arguments correctly."""
size = (7, 2)
offset = '(0, 0)'
mask1 = pygame.mask.Mask(size)
mask2 = pygame.mask.Mask(size)
with self.assertRaises(TypeError):
overlap_count = mask1.overlap_area(mask2, offset)
def test_overlap_mask(self):
"""Ensure overlap_mask's mask has correct bits set.
Testing the different combinations of full/empty masks:
(mask1-filled) 1 overlap_mask 1 (mask2-filled)
(mask1-empty) 0 overlap_mask 1 (mask2-filled)
(mask1-filled) 1 overlap_mask 0 (mask2-empty)
(mask1-empty) 0 overlap_mask 0 (mask2-empty)
"""
expected_size = (4, 4)
offset = (0, 0)
expected_default = pygame.mask.Mask(expected_size)
expected_masks = {
(True, True) : pygame.mask.Mask(expected_size, fill=True)}
for fill2 in (True, False):
mask2 = pygame.mask.Mask(expected_size, fill=fill2)
mask2_count = mask2.count()
for fill1 in (True, False):
key = (fill1, fill2)
msg = 'key={}'.format(key)
mask1 = pygame.mask.Mask(expected_size, fill=fill1)
mask1_count = mask1.count()
expected_mask = expected_masks.get(key, expected_default)
overlap_mask = mask1.overlap_mask(mask2, offset)
self._assertMaskEqual(overlap_mask, expected_mask, msg)
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count, msg)
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask1.get_size(), expected_size, msg)
self.assertEqual(mask2.get_size(), expected_size, msg)
def test_overlap_mask__bits_set(self):
"""Ensure overlap_mask's mask has correct bits set."""
mask1 = pygame.mask.Mask((50, 50), fill=True)
mask2 = pygame.mask.Mask((300, 10), fill=True)
mask1_count = mask1.count()
mask2_count = mask2.count()
mask1_size = mask1.get_size()
mask2_size = mask2.get_size()
mask3 = mask1.overlap_mask(mask2, (-1, 0))
for i in range(50):
for j in range(10):
self.assertEqual(mask3.get_at((i, j)), 1,
'({}, {})'.format(i, j))
for i in range(50):
for j in range(11, 50):
self.assertEqual(mask3.get_at((i, j)), 0,
'({}, {})'.format(i, j))
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count)
self.assertEqual(mask2.count(), mask2_count)
self.assertEqual(mask1.get_size(), mask1_size)
self.assertEqual(mask2.get_size(), mask2_size)
def test_overlap_mask__offset(self):
"""Ensure an offset overlap_mask's mask is correctly calculated."""
mask1 = pygame.mask.Mask((65, 3), fill=True)
mask2 = pygame.mask.Mask((66, 4), fill=True)
mask1_count = mask1.count()
mask2_count = mask2.count()
expected_size = mask1.get_size()
mask2_size = mask2.get_size()
# Using rects to help determine the overlapping area.
rect1 = pygame.Rect((0, 0), expected_size)
rect2 = pygame.Rect((0, 0), mask2_size)
for offset in self.ORIGIN_OFFSETS:
msg = 'offset={}'.format(offset)
rect2.topleft = offset
overlap_rect = rect1.clip(rect2)
expected_count = overlap_rect.w * overlap_rect.h
overlap_mask = mask1.overlap_mask(mask2, offset)
self.assertEqual(overlap_mask.count(), expected_count, msg)
self.assertEqual(overlap_mask.get_size(), expected_size, msg)
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count, msg)
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask1.get_size(), expected_size, msg)
self.assertEqual(mask2.get_size(), mask2_size, msg)
def test_overlap_mask__offset_boundary(self):
"""Ensures overlap_mask handles offsets and boundaries correctly."""
mask1 = pygame.mask.Mask((9, 3), fill=True)
mask2 = pygame.mask.Mask((11, 5), fill=True)
mask1_count = mask1.count()
mask2_count = mask2.count()
mask1_size = mask1.get_size()
mask2_size = mask2.get_size()
expected_count = 0
expected_size = mask1_size
# Check the 4 boundaries.
offsets = ((mask1_size[0], 0), # off right
(0, mask1_size[1]), # off bottom
(-mask2_size[0], 0), # off left
(0, -mask2_size[1])) # off top
for offset in offsets:
msg = 'offset={}'.format(offset)
overlap_mask = mask1.overlap_mask(mask2, offset)
self.assertEqual(overlap_mask.count(), expected_count, msg)
self.assertEqual(overlap_mask.get_size(), expected_size, msg)
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count, msg)
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask1.get_size(), mask1_size, msg)
self.assertEqual(mask2.get_size(), mask2_size, msg)
def test_overlap_mask__invalid_mask_arg(self):
"""Ensure overlap_mask handles invalid mask arguments correctly."""
size = (3, 2)
offset = (0, 0)
mask = pygame.mask.Mask(size)
invalid_mask = pygame.Surface(size)
with self.assertRaises(TypeError):
overlap_mask = mask.overlap_mask(invalid_mask, offset)
def test_overlap_mask__invalid_offset_arg(self):
"""Ensure overlap_mask handles invalid offset arguments correctly."""
size = (5, 2)
offset = '(0, 0)'
mask1 = pygame.mask.Mask(size)
mask2 = pygame.mask.Mask(size)
with self.assertRaises(TypeError):
overlap_mask = mask1.overlap_mask(mask2, offset)
def test_mask_access( self ):
""" do the set_at, and get_at parts work correctly?
"""
m = pygame.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)
#s = pygame.Surface((10,10))
#s.set_at((1,0), (0, 0, 1, 255))
#self.assertEqual(s.get_at((1,0)), (0, 0, 1, 255))
#s.set_at((-1,0), (0, 0, 1, 255))
# 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_fill(self):
"""Ensure a mask can be filled."""
width, height = 11, 23
expected_count = width * height
expected_size = (width, height)
mask = pygame.mask.Mask(expected_size)
mask.fill()
self.assertEqual(mask.count(), expected_count)
self.assertEqual(mask.get_size(), expected_size)
def test_clear(self):
"""Ensure a mask can be cleared."""
expected_count = 0
expected_size = (13, 27)
mask = pygame.mask.Mask(expected_size, fill=True)
mask.clear()
self.assertEqual(mask.count(), expected_count)
self.assertEqual(mask.get_size(), expected_size)
def test_invert(self):
"""Ensure a mask can be inverted."""
side = 73
expected_size = (side, side)
mask1 = pygame.mask.Mask(expected_size)
mask2 = pygame.mask.Mask(expected_size, fill=True)
expected_count1 = side * side
expected_count2 = 0
for i in range(side):
expected_count1 -= 1
expected_count2 += 1
pos = (i, i)
mask1.set_at(pos)
mask2.set_at(pos, 0)
mask1.invert()
mask2.invert()
self.assertEqual(mask1.count(), expected_count1)
self.assertEqual(mask2.count(), expected_count2)
self.assertEqual(mask1.get_size(), expected_size)
self.assertEqual(mask2.get_size(), expected_size)
for i in range(side):
pos = (i, i)
msg = 'pos={}'.format(pos)
self.assertEqual(mask1.get_at(pos), 0, msg)
self.assertEqual(mask2.get_at(pos), 1, msg)
def test_invert__full(self):
"""Ensure a full mask can be inverted."""
expected_count = 0
expected_size = (43, 97)
mask = pygame.mask.Mask(expected_size, fill=True)
mask.invert()
self.assertEqual(mask.count(), expected_count)
self.assertEqual(mask.get_size(), expected_size)
def test_invert__empty(self):
"""Ensure an empty mask can be inverted."""
width, height = 43, 97
expected_size = (width, height)
expected_count = width * height
mask = pygame.mask.Mask(expected_size)
mask.invert()
self.assertEqual(mask.count(), expected_count)
self.assertEqual(mask.get_size(), expected_size)
def test_scale(self):
"""Ensure a mask can be scaled."""
width, height = 43, 61
original_size = (width, height)
for fill in (True, False):
original_mask = pygame.mask.Mask(original_size, fill=fill)
original_count = width * height if fill else 0
# Test a range of sizes. Also tests scaling to 'same'
# size when new_w, new_h = width, height
for new_w in range(width - 10, width + 10):
for new_h in range(height - 10, height + 10):
expected_size = (new_w, new_h)
expected_count = new_w * new_h if fill else 0
msg = 'size={}'.format(expected_size)
mask = original_mask.scale(expected_size)
self.assertEqual(mask.count(), expected_count, msg)
self.assertEqual(mask.get_size(), expected_size)
# Ensure the original mask is unchanged.
self.assertEqual(original_mask.count(), original_count,
msg)
self.assertEqual(original_mask.get_size(), original_size,
msg)
def test_scale__negative_size(self):
"""Ensure scale handles negative sizes correctly."""
mask = pygame.Mask((100, 100))
with self.assertRaises(ValueError):
mask.scale((-1, -1))
with self.assertRaises(ValueError):
mask.scale((-1, 10))
with self.assertRaises(ValueError):
mask.scale((10, -1))
def test_draw(self):
"""Ensure a mask can be drawn onto another mask.
Testing the different combinations of full/empty masks:
(mask1-filled) 1 draw 1 (mask2-filled)
(mask1-empty) 0 draw 1 (mask2-filled)
(mask1-filled) 1 draw 0 (mask2-empty)
(mask1-empty) 0 draw 0 (mask2-empty)
"""
expected_size = (4, 4)
offset = (0, 0)
expected_default = pygame.mask.Mask(expected_size, fill=True)
expected_masks = {(False, False) : pygame.mask.Mask(expected_size)}
for fill2 in (True, False):
mask2 = pygame.mask.Mask(expected_size, fill=fill2)
mask2_count = mask2.count()
for fill1 in (True, False):
key = (fill1, fill2)
msg = 'key={}'.format(key)
mask1 = pygame.mask.Mask(expected_size, fill=fill1)
expected_mask = expected_masks.get(key, expected_default)
mask1.draw(mask2, offset)
self._assertMaskEqual(mask1, expected_mask, msg)
# Ensure mask2 unchanged.
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask2.get_size(), expected_size, msg)
def test_draw__offset(self):
"""Ensure an offset mask can be drawn onto another mask."""
mask1 = pygame.mask.Mask((65, 3))
mask2 = pygame.mask.Mask((66, 4), fill=True)
mask2_count = mask2.count()
mask1_size = mask1.get_size()
mask2_size = mask2.get_size()
# Using rects to help determine the overlapping area.
rect1 = pygame.Rect((0, 0), mask1_size)
rect2 = pygame.Rect((0, 0), mask2_size)
for offset in self.ORIGIN_OFFSETS:
msg = 'offset={}'.format(offset)
rect2.topleft = offset
overlap_rect = rect1.clip(rect2)
expected_count = overlap_rect.w * overlap_rect.h
mask1.clear() # Ensure it's empty for testing each offset.
mask1.draw(mask2, offset)
self.assertEqual(mask1.count(), expected_count, msg)
self.assertEqual(mask1.get_size(), mask1_size, msg)
# Ensure mask2 unchanged.
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask2.get_size(), mask2_size, msg)
def test_draw__offset_boundary(self):
"""Ensures draw handles offsets and boundaries correctly."""
mask1 = pygame.mask.Mask((13, 5))
mask2 = pygame.mask.Mask((7, 3), fill=True)
mask1_count = mask1.count()
mask2_count = mask2.count()
mask1_size = mask1.get_size()
mask2_size = mask2.get_size()
# Check the 4 boundaries.
offsets = ((mask1_size[0], 0), # off right
(0, mask1_size[1]), # off bottom
(-mask2_size[0], 0), # off left
(0, -mask2_size[1])) # off top
for offset in offsets:
msg = 'offset={}'.format(offset)
mask1.draw(mask2, offset)
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count, msg)
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask1.get_size(), mask1_size, msg)
self.assertEqual(mask2.get_size(), mask2_size, msg)
def test_draw__invalid_mask_arg(self):
"""Ensure draw handles invalid mask arguments correctly."""
size = (7, 3)
offset = (0, 0)
mask = pygame.mask.Mask(size)
invalid_mask = pygame.Surface(size)
with self.assertRaises(TypeError):
mask.draw(invalid_mask, offset)
def test_draw__invalid_offset_arg(self):
"""Ensure draw handles invalid offset arguments correctly."""
size = (5, 7)
offset = '(0, 0)'
mask1 = pygame.mask.Mask(size)
mask2 = pygame.mask.Mask(size)
with self.assertRaises(TypeError):
mask1.draw(mask2, offset)
def test_erase(self):
"""Ensure a mask can erase another mask.
Testing the different combinations of full/empty masks:
(mask1-filled) 1 erase 1 (mask2-filled)
(mask1-empty) 0 erase 1 (mask2-filled)
(mask1-filled) 1 erase 0 (mask2-empty)
(mask1-empty) 0 erase 0 (mask2-empty)
"""
expected_size = (4, 4)
offset = (0, 0)
expected_default = pygame.mask.Mask(expected_size)
expected_masks = {
(True, False) : pygame.mask.Mask(expected_size, fill=True)}
for fill2 in (True, False):
mask2 = pygame.mask.Mask(expected_size, fill=fill2)
mask2_count = mask2.count()
for fill1 in (True, False):
key = (fill1, fill2)
msg = 'key={}'.format(key)
mask1 = pygame.mask.Mask(expected_size, fill=fill1)
expected_mask = expected_masks.get(key, expected_default)
mask1.erase(mask2, offset)
self._assertMaskEqual(mask1, expected_mask, msg)
# Ensure mask2 unchanged.
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask2.get_size(), expected_size, msg)
def test_erase__offset(self):
"""Ensure an offset mask can erase another mask."""
mask1 = pygame.mask.Mask((65, 3))
mask2 = pygame.mask.Mask((66, 4), fill=True)
mask2_count = mask2.count()
mask1_size = mask1.get_size()
mask2_size = mask2.get_size()
# Using rects to help determine the overlapping area.
rect1 = pygame.Rect((0, 0), mask1_size)
rect2 = pygame.Rect((0, 0), mask2_size)
rect1_area = rect1.w * rect1.h
for offset in self.ORIGIN_OFFSETS:
msg = 'offset={}'.format(offset)
rect2.topleft = offset
overlap_rect = rect1.clip(rect2)
expected_count = rect1_area - (overlap_rect.w * overlap_rect.h)
mask1.fill() # Ensure it's filled for testing each offset.
mask1.erase(mask2, offset)
self.assertEqual(mask1.count(), expected_count, msg)
self.assertEqual(mask1.get_size(), mask1_size, msg)
# Ensure mask2 unchanged.
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask2.get_size(), mask2_size, msg)
def test_erase__offset_boundary(self):
"""Ensures erase handles offsets and boundaries correctly."""
mask1 = pygame.mask.Mask((7, 11), fill=True)
mask2 = pygame.mask.Mask((3, 13), fill=True)
mask1_count = mask1.count()
mask2_count = mask2.count()
mask1_size = mask1.get_size()
mask2_size = mask2.get_size()
# Check the 4 boundaries.
offsets = ((mask1_size[0], 0), # off right
(0, mask1_size[1]), # off bottom
(-mask2_size[0], 0), # off left
(0, -mask2_size[1])) # off top
for offset in offsets:
msg = 'offset={}'.format(offset)
mask1.erase(mask2, offset)
# Ensure mask1/mask2 unchanged.
self.assertEqual(mask1.count(), mask1_count, msg)
self.assertEqual(mask2.count(), mask2_count, msg)
self.assertEqual(mask1.get_size(), mask1_size, msg)
self.assertEqual(mask2.get_size(), mask2_size, msg)
def test_erase__invalid_mask_arg(self):
"""Ensure erase handles invalid mask arguments correctly."""
size = (3, 7)
offset = (0, 0)
mask = pygame.mask.Mask(size)
invalid_mask = pygame.Surface(size)
with self.assertRaises(TypeError):
mask.erase(invalid_mask, offset)
def test_erase__invalid_offset_arg(self):
"""Ensure erase handles invalid offset arguments correctly."""
size = (7, 5)
offset = '(0, 0)'
mask1 = pygame.mask.Mask(size)
mask2 = pygame.mask.Mask(size)
with self.assertRaises(TypeError):
mask1.erase(mask2, offset)
def test_count(self):
"""Ensure a mask's set bits are correctly counted."""
side = 67
expected_size = (side, side)
expected_count = 0
mask = pygame.mask.Mask(expected_size)
for i in range(side):
expected_count += 1
mask.set_at((i, i))
count = mask.count()
self.assertEqual(count, expected_count)
self.assertEqual(mask.get_size(), expected_size)
def test_count__full_mask(self):
"""Ensure a full mask's set bits are correctly counted."""
width, height = 17, 97
expected_size = (width, height)
expected_count = width * height
mask = pygame.mask.Mask(expected_size, fill=True)
count = mask.count()
self.assertEqual(count, expected_count)
self.assertEqual(mask.get_size(), expected_size)
def test_count__empty_mask(self):
"""Ensure an empty mask's set bits are correctly counted."""
expected_count = 0
expected_size = (13, 27)
mask = pygame.mask.Mask(expected_size)
count = mask.count()
self.assertEqual(count, expected_count)
self.assertEqual(mask.get_size(), expected_size)
def todo_test_centroid(self):
"""Ensure a mask's centroid is correctly calculated."""
self.fail()
def test_centroid__empty_mask(self):
"""Ensure an empty mask's centroid is correctly calculated."""
expected_centroid = (0, 0)
expected_size = (101, 103)
mask = pygame.mask.Mask(expected_size)
centroid = mask.centroid()
self.assertEqual(centroid, expected_centroid)
self.assertEqual(mask.get_size(), expected_size)
def todo_test_angle(self):
"""Ensure a mask's orientation angle is correctly calculated."""
self.fail()
def test_angle__empty_mask(self):
"""Ensure an empty mask's angle is correctly calculated."""
expected_angle = 0.0
expected_size = (107, 43)
mask = pygame.mask.Mask(expected_size)
angle = mask.angle()
self.assertIsInstance(angle, float)
self.assertAlmostEqual(angle, expected_angle)
self.assertEqual(mask.get_size(), expected_size)
def test_drawing(self):
""" Test fill, clear, invert, draw, erase
"""
m = pygame.Mask((100,100))
self.assertEqual(m.count(), 0)
m.fill()
self.assertEqual(m.count(), 10000)
m2 = pygame.Mask((10, 10), fill=True)
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_outline(self):
"""
"""
m = pygame.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)])
#TODO: Test more corner case outlines.
def test_convolve__size(self):
sizes = [(1,1), (31,31), (32,32), (100,100)]
for s1 in sizes:
m1 = pygame.Mask(s1)
for s2 in sizes:
m2 = pygame.Mask(s2)
o = m1.convolve(m2)
for i in (0,1):
self.assertEqual(o.get_size()[i],
m1.get_size()[i] + m2.get_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 = pygame.Mask((1,1))
k.set_at((0,0))
self._assertMaskEqual(m, m.convolve(k))
self._assertMaskEqual(m, k.convolve(k.convolve(m)))
def test_convolve__with_output(self):
"""checks that convolution modifies only the correct portion of the output"""
m = random_mask((10,10))
k = pygame.Mask((2,2))
k.set_at((0,0))
o = pygame.Mask((50,50))
test = pygame.Mask((50,50))
m.convolve(k,o)
test.draw(m,(1,1))
self._assertMaskEqual(o, test)
o.clear()
test.clear()
m.convolve(k,o, (10,10))
test.draw(m,(11,11))
self._assertMaskEqual(o, test)
def test_convolve__out_of_range(self):
full = pygame.Mask((2, 2), fill=True)
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(self):
"""Tests the definition of convolution"""
m1 = random_mask((100,100))
m2 = random_mask((100,100))
conv = m1.convolve(m2)
for i in range(conv.get_size()[0]):
for j in range(conv.get_size()[1]):
self.assertEqual(conv.get_at((i,j)) == 0,
m1.overlap(m2, (i - 99, j - 99)) is None)
def _draw_component_pattern_box(self, mask, size, pos, inverse=False):
# Helper method to create/draw a 'box' pattern for testing.
#
# 111
# 101 3x3 example pattern
# 111
pattern = pygame.mask.Mask((size, size), fill=True)
pattern.set_at((size // 2, size // 2), 0)
if inverse:
mask.erase(pattern, pos)
pattern.invert()
else:
mask.draw(pattern, pos)
return pattern
def _draw_component_pattern_x(self, mask, size, pos, inverse=False):
# Helper method to create/draw an 'X' pattern for testing.
#
# 101
# 010 3x3 example pattern
# 101
pattern = pygame.mask.Mask((size, size))
ymax = size - 1
for y in range(size):
for x in range(size):
if x == y or x == ymax - y:
pattern.set_at((x, y))
if inverse:
mask.erase(pattern, pos)
pattern.invert()
else:
mask.draw(pattern, pos)
return pattern
def _draw_component_pattern_plus(self, mask, size, pos, inverse=False):
# Helper method to create/draw a '+' pattern for testing.
#
# 010
# 111 3x3 example pattern
# 010
pattern = pygame.mask.Mask((size, size))
xmid = ymid = size // 2
for y in range(size):
for x in range(size):
if x == xmid or y == ymid:
pattern.set_at((x, y))
if inverse:
mask.erase(pattern, pos)
pattern.invert()
else:
mask.draw(pattern, pos)
return pattern
def test_connected_component(self):
"""Ensure a mask's connected component is correctly calculated."""
width, height = 41, 27
expected_size = (width, height)
original_mask = pygame.mask.Mask(expected_size)
patterns = [] # Patterns and offsets.
# Draw some connected patterns on the original mask.
offset = (0, 0)
pattern = self._draw_component_pattern_x(original_mask, 3, offset)
patterns.append((pattern, offset))
size = 4
offset = (width - size, 0)
pattern = self._draw_component_pattern_plus(original_mask, size,
offset)
patterns.append((pattern, offset))
# Make this one the largest connected component.
offset = (width // 2, height // 2)
pattern = self._draw_component_pattern_box(original_mask, 7, offset)
patterns.append((pattern, offset))
expected_pattern, expected_offset = patterns[-1]
expected_count = expected_pattern.count()
original_count = sum(p.count() for p, _ in patterns)
mask = original_mask.connected_component()
self.assertEqual(mask.count(), expected_count)
self.assertEqual(mask.get_size(), expected_size)
self.assertEqual(mask.overlap_area(expected_pattern, expected_offset),
expected_count)
# Ensure the original mask is unchanged.
self.assertEqual(original_mask.count(), original_count)
self.assertEqual(original_mask.get_size(), expected_size)
for pattern, offset in patterns:
self.assertEqual(original_mask.overlap_area(pattern, offset),
pattern.count())
def test_connected_component__full_mask(self):
"""Ensure a mask's connected component is correctly calculated
when the mask is full."""
expected_size = (23, 31)
original_mask = pygame.mask.Mask(expected_size, fill=True)
expected_count = original_mask.count()
mask = original_mask.connected_component()
self.assertEqual(mask.count(), expected_count)
self.assertEqual(mask.get_size(), expected_size)
# Ensure the original mask is unchanged.
self.assertEqual(original_mask.count(), expected_count)
self.assertEqual(original_mask.get_size(), expected_size)
def test_connected_component__empty_mask(self):
"""Ensure a mask's connected component is correctly calculated
when the mask is empty."""
expected_size = (37, 43)
original_mask = pygame.mask.Mask(expected_size)
original_count = original_mask.count()
expected_count = 0
mask = original_mask.connected_component()
self.assertEqual(mask.count(), expected_count)
self.assertEqual(mask.get_size(), expected_size)
# Ensure the original mask is unchanged.
self.assertEqual(original_mask.count(), original_count)
self.assertEqual(original_mask.get_size(), expected_size)
def test_connected_component__one_set_bit(self):
"""Ensure a mask's connected component is correctly calculated
when the coordinate's bit is set with a connected component of 1 bit.
"""
width, height = 71, 67
expected_size = (width, height)
original_mask = pygame.mask.Mask(expected_size, fill=True)
xset, yset = width // 2, height // 2
set_pos = (xset, yset)
expected_offset = (xset - 1, yset - 1)
# This isolates the bit at set_pos from all the other bits.
expected_pattern = self._draw_component_pattern_box(original_mask, 3,
expected_offset, inverse=True)
expected_count = 1
original_count = original_mask.count()
mask = original_mask.connected_component(set_pos)
self.assertEqual(mask.count(), expected_count)
self.assertEqual(mask.get_size(), expected_size)
self.assertEqual(mask.overlap_area(expected_pattern, expected_offset),
expected_count)
# Ensure the original mask is unchanged.
self.assertEqual(original_mask.count(), original_count)
self.assertEqual(original_mask.get_size(), expected_size)
self.assertEqual(original_mask.overlap_area(
expected_pattern, expected_offset), expected_count)
def test_connected_component__multi_set_bits(self):
"""Ensure a mask's connected component is correctly calculated
when the coordinate's bit is set with a connected component of > 1 bit.
"""
expected_size = (113, 67)
original_mask = pygame.mask.Mask(expected_size)
p_width, p_height = 11, 13
set_pos = xset, yset = 11, 21
expected_offset = (xset - 1, yset - 1)
expected_pattern = pygame.mask.Mask((p_width, p_height), fill=True)
# Make an unsymmetrical pattern. All the set bits need to be connected
# in the resulting pattern for this to work properly.
for y in range(3, p_height):
for x in range(1, p_width):
if x == y or x == y - 3 or x == p_width - 4:
expected_pattern.set_at((x, y), 0)
expected_count = expected_pattern.count()
original_mask.draw(expected_pattern, expected_offset)
mask = original_mask.connected_component(set_pos)
self.assertEqual(mask.count(), expected_count)
self.assertEqual(mask.get_size(), expected_size)
self.assertEqual(mask.overlap_area(expected_pattern, expected_offset),
expected_count)
# Ensure the original mask is unchanged.
self.assertEqual(original_mask.count(), expected_count)
self.assertEqual(original_mask.get_size(), expected_size)
self.assertEqual(original_mask.overlap_area(
expected_pattern, expected_offset), expected_count)
def test_connected_component__unset_bit(self):
"""Ensure a mask's connected component is correctly calculated
when the coordinate's bit is unset.
"""
width, height = 109, 101
expected_size = (width, height)
original_mask = pygame.mask.Mask(expected_size, fill=True)
unset_pos = (width // 2, height // 2)
original_mask.set_at(unset_pos, 0)
original_count = original_mask.count()
expected_count = 0
mask = original_mask.connected_component(unset_pos)
self.assertEqual(mask.count(), expected_count)
self.assertEqual(mask.get_size(), expected_size)
# Ensure the original mask is unchanged.
self.assertEqual(original_mask.count(), original_count)
self.assertEqual(original_mask.get_size(), expected_size)
self.assertEqual(original_mask.get_at(unset_pos), 0)
def test_connected_component__out_of_bounds(self):
"""Ensure connected_component() checks bounds."""
width, height = 19, 11
original_size = (width, height)
original_mask = pygame.mask.Mask(original_size, fill=True)
original_count = original_mask.count()
for pos in ((0, -1), (-1, 0), (0, height + 1), (width + 1, 0)):
with self.assertRaises(IndexError):
mask = original_mask.connected_component(pos)
# Ensure the original mask is unchanged.
self.assertEqual(original_mask.count(), original_count)
self.assertEqual(original_mask.get_size(), original_size)
def test_connected_components(self):
"""
"""
m = pygame.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_get_bounding_rects(self):
"""
"""
m = pygame.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 = pygame.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 = pygame.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 = pygame.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 = pygame.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()
#TODO: this should really make one bounding rect.
#self.assertEqual(repr(r), "[<rect(0, 0, 5, 2)>]")
def test_zero_mask(self):
mask = pygame.mask.Mask((0, 0))
self.assertEqual(mask.get_size(), (0, 0))
mask = pygame.mask.Mask((100, 0))
self.assertEqual(mask.get_size(), (100, 0))
mask = pygame.mask.Mask((0, 100))
self.assertEqual(mask.get_size(), (0, 100))
def test_zero_mask_get_size(self):
"""Ensures get_size correctly handles zero sized masks."""
for expected_size in ((41, 0), (0, 40), (0, 0)):
mask = pygame.mask.Mask(expected_size)
size = mask.get_size()
self.assertEqual(size, expected_size)
def test_zero_mask_get_at(self):
"""Ensures get_at correctly handles zero sized masks."""
for size in ((51, 0), (0, 50), (0, 0)):
mask = pygame.mask.Mask(size)
with self.assertRaises(IndexError):
value = mask.get_at((0, 0))
def test_zero_mask_set_at(self):
"""Ensures set_at correctly handles zero sized masks."""
for size in ((31, 0), (0, 30), (0, 0)):
mask = pygame.mask.Mask(size)
with self.assertRaises(IndexError):
mask.set_at((0, 0))
def test_zero_mask_overlap(self):
sizes = ((100, 0), (0, 100), (0, 0))
for size in sizes:
mask = pygame.mask.Mask(size)
mask2 = pygame.mask.Mask((100, 100))
self.assertEqual(mask.overlap(mask2, (0, 0)), None)
self.assertEqual(mask2.overlap(mask, (0, 0)), None)
def test_zero_mask_overlap_area(self):
sizes = ((100, 0), (0, 100), (0, 0))
for size in sizes:
mask = pygame.mask.Mask(size)
mask2 = pygame.mask.Mask((100, 100))
self.assertEqual(mask.overlap_area(mask2, (0, 0)), 0)
self.assertEqual(mask2.overlap_area(mask, (0, 0)), 0)
def test_zero_mask_overlap_mask(self):
sizes = ((100, 0), (0, 100), (0, 0))
for size in sizes:
mask = pygame.mask.Mask(size)
mask2 = pygame.mask.Mask((100, 100))
overlap_mask = mask.overlap_mask(mask2, (0, 0))
overlap_mask2 = mask2.overlap_mask(mask, (0, 0))
self.assertEqual(mask.get_size(), overlap_mask.get_size())
self.assertEqual(mask2.get_size(), overlap_mask2.get_size())
def test_zero_mask_fill(self):
sizes = ((100, 0), (0, 100), (0, 0))
for size in sizes:
mask = pygame.mask.Mask(size, fill=True)
self.assertEqual(mask.count(), 0)
def test_zero_mask_clear(self):
sizes = ((100, 0), (0, 100), (0, 0))
for size in sizes:
mask = pygame.mask.Mask(size)
mask.clear()
self.assertEqual(mask.count(), 0)
def test_zero_mask_flip(self):
sizes = ((100, 0), (0, 100), (0, 0))
for size in sizes:
mask = pygame.mask.Mask(size)
mask.invert()
self.assertEqual(mask.count(), 0)
def test_zero_mask_scale(self):
sizes = ((100, 0), (0, 100), (0, 0))
for size in sizes:
mask = pygame.mask.Mask(size)
mask2 = mask.scale((2, 3))
self.assertEqual(mask2.get_size(), (2, 3))
def test_zero_mask_draw(self):
sizes = ((100, 0), (0, 100), (0, 0))
for size in sizes:
mask = pygame.mask.Mask(size)
mask2 = pygame.mask.Mask((100, 100), fill=True)
before = [mask2.get_at((x, y)) for x in range(100) for y in range(100)]
mask.draw(mask2, (0, 0))
after = [mask2.get_at((x, y)) for x in range(100) for y in range(100)]
self.assertEqual(before, after)
def test_zero_mask_erase(self):
sizes = ((100, 0), (0, 100), (0, 0))
for size in sizes:
mask = pygame.mask.Mask(size)
mask2 = pygame.mask.Mask((100, 100), fill=True)
before = [mask2.get_at((x, y)) for x in range(100) for y in range(100)]
mask.erase(mask2, (0, 0))
after = [mask2.get_at((x, y)) for x in range(100) for y in range(100)]
self.assertEqual(before, after)
def test_zero_mask_count(self):
sizes = ((100, 0), (0, 100), (0, 0))
for size in sizes:
mask = pygame.mask.Mask(size, fill=True)
self.assertEqual(mask.count(), 0)
def test_zero_mask_centroid(self):
sizes = ((100, 0), (0, 100), (0, 0))
for size in sizes:
mask = pygame.mask.Mask(size)
self.assertEqual(mask.centroid(), (0, 0))
def test_zero_mask_angle(self):
sizes = ((100, 0), (0, 100), (0, 0))
for size in sizes:
mask = pygame.mask.Mask(size)
self.assertEqual(mask.angle(), 0.0)
def test_zero_mask_outline(self):
"""Ensures outline correctly handles zero sized masks."""
expected_points = []
for size in ((61, 0), (0, 60), (0, 0)):
mask = pygame.mask.Mask(size)
points = mask.outline()
self.assertListEqual(points, expected_points,
'size={}'.format(size))
def test_zero_mask_outline__with_arg(self):
"""Ensures outline correctly handles zero sized masks
when using the skip pixels argument."""
expected_points = []
for size in ((66, 0), (0, 65), (0, 0)):
mask = pygame.mask.Mask(size)
points = mask.outline(10)
self.assertListEqual(points, expected_points,
'size={}'.format(size))
def test_zero_mask_convolve(self):
"""Ensures convolve correctly handles zero sized masks.
Tests the different combinations of sized and zero sized masks.
"""
for size1 in ((17, 13), (71, 0), (0, 70), (0, 0)):
mask1 = pygame.mask.Mask(size1, fill=True)
for size2 in ((11, 7), (81, 0), (0, 60), (0, 0)):
msg = 'sizes={}, {}'.format(size1, size2)
mask2 = pygame.mask.Mask(size2, fill=True)
expected_size = (max(0, size1[0] + size2[0] - 1),
max(0, size1[1] + size2[1] - 1))
mask = mask1.convolve(mask2)
self.assertIsNot(mask, mask2, msg)
self.assertEqual(mask.get_size(), expected_size, msg)
def test_zero_mask_convolve__with_output_mask(self):
"""Ensures convolve correctly handles zero sized masks
when using an output mask argument.
Tests the different combinations of sized and zero sized masks.
"""
for size1 in ((11, 17), (91, 0), (0, 90), (0, 0)):
mask1 = pygame.mask.Mask(size1, fill=True)
for size2 in ((13, 11), (83, 0), (0, 62), (0, 0)):
mask2 = pygame.mask.Mask(size2, fill=True)
for output_size in ((7, 5), (71, 0), (0, 70), (0, 0)):
msg = 'sizes={}, {}, {}'.format(size1, size2, output_size)
output_mask = pygame.mask.Mask(output_size)
mask = mask1.convolve(mask2, output_mask)
self.assertIs(mask, output_mask, msg)
self.assertEqual(mask.get_size(), output_size, msg)
def test_zero_mask_connected_component(self):
"""Ensures connected_component correctly handles zero sized masks."""
expected_count = 0
for size in ((81, 0), (0, 80), (0, 0)):
mask = pygame.mask.Mask(size)
cc_mask = mask.connected_component()
self.assertEqual(cc_mask.get_size(), size)
self.assertEqual(cc_mask.count(), expected_count,
'size={}'.format(size))
def test_zero_mask_connected_component__indexed(self):
"""Ensures connected_component correctly handles zero sized masks
when using an index argument."""
for size in ((91, 0), (0, 90), (0, 0)):
mask = pygame.mask.Mask(size)
with self.assertRaises(IndexError):
cc_mask = mask.connected_component((0, 0))
def test_zero_mask_connected_components(self):
"""Ensures connected_components correctly handles zero sized masks."""
expected_cc_masks = []
for size in ((11, 0), (0, 10), (0, 0)):
mask = pygame.mask.Mask(size)
cc_masks = mask.connected_components()
self.assertListEqual(cc_masks, expected_cc_masks,
'size={}'.format(size))
def test_zero_mask_get_bounding_rects(self):
"""Ensures get_bounding_rects correctly handles zero sized masks."""
expected_bounding_rects = []
for size in ((21, 0), (0, 20), (0, 0)):
mask = pygame.mask.Mask(size)
bounding_rects = mask.get_bounding_rects()
self.assertListEqual(bounding_rects, expected_bounding_rects,
'size={}'.format(size))
class MaskModuleTest(unittest.TestCase):
# The @unittest.expectedFailure decorator can be removed when issue #897
# is fixed.
@unittest.expectedFailure
def test_from_surface(self):
"""Ensures from_surface creates a mask with the correct bits set.
This test checks the masks created by the from_surface function using
16 and 32 bit surfaces. Each alpha value (0-255) is tested against
several different threshold values.
Note: On 16 bit surface the requested alpha value can differ from what
is actually set. This test uses the value read from the surface.
"""
threshold_count = 256
surface_color = [55, 155, 255, 0]
expected_size = (11, 9)
all_set_count = expected_size[0] * expected_size[1]
none_set_count = 0
for depth in (16, 32):
surface = pygame.Surface(expected_size, SRCALPHA, depth)
for alpha in range(threshold_count):
surface_color[3] = alpha
surface.fill(surface_color)
if depth < 32:
# On surfaces with depths < 32 the requested alpha can be
# different than what gets set. Use the value read from the
# surface.
alpha = surface.get_at((0, 0))[3]
# Test the mask created at threshold values low, high and
# around alpha.
threshold_test_values = set(
[-1, 0, alpha - 1, alpha, alpha + 1, 255, 256])
for threshold in threshold_test_values:
msg = 'depth={}, alpha={}, threshold={}'.format(
depth, alpha, threshold)
if alpha > threshold:
expected_count = all_set_count
else:
expected_count = none_set_count
mask = pygame.mask.from_surface(surface, threshold)
self.assertEqual(mask.get_size(), expected_size, msg)
self.assertEqual(mask.count(), expected_count, msg)
def test_from_surface__different_alphas_32bit(self):
"""Ensures from_surface creates a mask with the correct bits set
when pixels have different alpha values (32 bits surfaces).
This test checks the masks created by the from_surface function using
a 32 bit surface. The surface is created with each pixel having a
different alpha value (0-255). This surface is tested over a range
of threshold values (0-255).
"""
offset = (0, 0)
threshold_count = 256
surface_color = [10, 20, 30, 0]
expected_size = (threshold_count, 1)
expected_mask = pygame.Mask(expected_size, fill=True)
surface = pygame.Surface(expected_size, SRCALPHA, 32)
# Give each pixel a different alpha.
surface.lock() # Lock for possible speed up.
for a in range(threshold_count):
surface_color[3] = a
surface.set_at((a, 0), surface_color)
surface.unlock()
# Test the mask created for each different alpha threshold.
for threshold in range(threshold_count):
msg = 'threshold={}'.format(threshold)
expected_mask.set_at((threshold, 0), 0)
expected_count = expected_mask.count()
mask = pygame.mask.from_surface(surface, threshold)
self.assertEqual(mask.get_size(), expected_size, msg)
self.assertEqual(mask.count(), expected_count, msg)
self.assertEqual(mask.overlap_area(expected_mask, offset),
expected_count, msg)
# The @unittest.expectedFailure decorator can be removed when issue #897
# is fixed.
@unittest.expectedFailure
def test_from_surface__different_alphas_16bit(self):
"""Ensures from_surface creates a mask with the correct bits set
when pixels have different alpha values (16 bit surfaces).
This test checks the masks created by the from_surface function using
a 16 bit surface. Each pixel of the surface is set with a different
alpha value (0-255), but since this is a 16 bit surface the requested
alpha value can differ from what is actually set. The resulting surface
will have groups of alpha values which complicates the test as the
alpha groups will all be set/unset at a given threshold. The setup
calculates these groups and an expected mask for each. This test data
is then used to test each alpha grouping over a range of threshold
values.
"""
threshold_count = 256
surface_color = [110, 120, 130, 0]
expected_size = (threshold_count, 1)
surface = pygame.Surface(expected_size, SRCALPHA, 16)
# Give each pixel a different alpha.
surface.lock() # Lock for possible speed up.
for a in range(threshold_count):
surface_color[3] = a
surface.set_at((a, 0), surface_color)
surface.unlock()
alpha_thresholds = OrderedDict()
special_thresholds = set()
# Create the threshold ranges and identify any thresholds that need
# special handling.
for threshold in range(threshold_count):
# On surfaces with depths < 32 the requested alpha can be different
# than what gets set. Use the value read from the surface.
alpha = surface.get_at((threshold, 0))[3]
if alpha not in alpha_thresholds:
alpha_thresholds[alpha] = [threshold]
else:
alpha_thresholds[alpha].append(threshold)
if threshold < alpha:
special_thresholds.add(threshold)
# Use each threshold group to create an expected mask.
test_data = [] # [(from_threshold, to_threshold, expected_mask), ...]
offset = (0, 0)
erase_mask = pygame.Mask(expected_size)
exp_mask = pygame.Mask(expected_size, fill=True)
for thresholds in alpha_thresholds.values():
for threshold in thresholds:
if threshold in special_thresholds:
# Any special thresholds just reuse previous exp_mask.
test_data.append((threshold, threshold + 1, exp_mask))
else:
to_threshold = thresholds[-1] + 1
# Make the expected mask by erasing the unset bits.
for thres in range(to_threshold):
erase_mask.set_at((thres, 0), 1)
exp_mask = pygame.Mask(expected_size, fill=True)
exp_mask.erase(erase_mask, offset)
test_data.append((threshold, to_threshold, exp_mask))
break
# All the setup is done. Now test the masks created over the threshold
# ranges.
for from_threshold, to_threshold, expected_mask in test_data:
expected_count = expected_mask.count()
for threshold in range(from_threshold, to_threshold):
msg = 'threshold={}'.format(threshold)
mask = pygame.mask.from_surface(surface, threshold)
self.assertEqual(mask.get_size(), expected_size, msg)
self.assertEqual(mask.count(), expected_count, msg)
self.assertEqual(mask.overlap_area(expected_mask, offset),
expected_count, msg)
def todo_test_from_surface__with_colorkey(self):
"""Ensures from_surface creates a mask with the correct bits set
when the surface uses a colorkey.
"""
self.fail()
def test_from_threshold(self):
""" Does mask.from_threshold() work correctly?
"""
a = [16, 24, 32]
for i in a:
surf = pygame.surface.Surface((70,70), 0, i)
surf.fill((100,50,200),(20,20,20,20))
mask = pygame.mask.from_threshold(surf,(100,50,200,255),(10,10,10,255))
rects = mask.get_bounding_rects()
self.assertEqual(mask.count(), 400)
self.assertEqual(mask.get_bounding_rects(), [pygame.Rect((20,20,20,20))])
for i in a:
surf = pygame.surface.Surface((70,70), 0, i)
surf2 = pygame.surface.Surface((70,70), 0, i)
surf.fill((100,100,100))
surf2.fill((150,150,150))
surf2.fill((100,100,100), (40,40,10,10))
mask = pygame.mask.from_threshold(surf, (0,0,0,0), (10,10,10,255), surf2)
self.assertEqual(mask.count(), 100)
self.assertEqual(mask.get_bounding_rects(), [pygame.Rect((40,40,10,10))])
def test_zero_size_from_surface(self):
"""Ensures from_surface can create masks from zero sized surfaces."""
for size in ((100, 0), (0, 100), (0, 0)):
mask = pygame.mask.from_surface(pygame.Surface(size))
self.assertIsInstance(mask, pygame.mask.MaskType,
'size={}'.format(size))
self.assertEqual(mask.get_size(), size)
def test_zero_size_from_threshold(self):
a = [16, 24, 32]
sizes = ((100, 0), (0, 100), (0, 0))
for size in sizes:
for i in a:
surf = pygame.surface.Surface(size, 0, i)
surf.fill((100, 50, 200), (20, 20, 20, 20))
mask = pygame.mask.from_threshold(surf, (100, 50, 200, 255), (10, 10, 10, 255))
self.assertEqual(mask.count(), 0)
rects = mask.get_bounding_rects()
self.assertEqual(rects, [])
for i in a:
surf = pygame.surface.Surface(size, 0, i)
surf2 = pygame.surface.Surface(size, 0, i)
surf.fill((100, 100, 100))
surf2.fill((150, 150, 150))
surf2.fill((100, 100, 100), (40, 40, 10, 10))
mask = pygame.mask.from_threshold(surf, (0, 0, 0, 0), (10, 10, 10, 255), surf2)
self.assertEqual(mask.count(), 0)
rects = mask.get_bounding_rects()
self.assertEqual(rects, [])
if __name__ == '__main__':
unittest.main()