def test_is_free_corner(self):
a = Area(Rectangle(Field(0, 0), Field(7, 7)), 1)
r = Rectangle(Field(2, 1), Field(5, 5))
for c in r.corners():
with self.assertRaises(Exception):
c.is_free_corner()
a += r
for c in r.corners():
self.assertTrue(c.is_free_corner())
# We will add a new rectangle which is in contact with the former
r2 = Rectangle(Field(1, 6), Field(5, 7))
a += r2
self.assertTrue(r.bottom_left.is_free_corner())
self.assertTrue(r.bottom_right.is_free_corner())
# Not free anymore
self.assertFalse(r.top_left.is_free_corner())
self.assertFalse(r.top_right.is_free_corner())
# Now for the second
self.assertFalse(r2.bottom_left.is_free_corner())
self.assertFalse(r2.bottom_right.is_free_corner())
self.assertTrue(r2.top_left.is_free_corner())
self.assertTrue(r2.top_right.is_free_corner())
def test_is_in_contact(self):
r1 = Rectangle(Field(3, 3), Field(5, 5))
r2 = Rectangle(Field(6, 6), Field(8, 8))
r3 = Rectangle(Field(6, 3), Field(8, 5))
r4 = Rectangle(Field(9, 3), Field(12, 5))
self.assertTrue(r1.is_in_contact(r2))
self.assertTrue(r2.is_in_contact(r3))
self.assertTrue(r3.is_in_contact(r2))
self.assertTrue(r2.is_in_contact(r4))
self.assertTrue(r3.is_in_contact(r2))
self.assertFalse(r1.is_in_contact(r4))
# Diagonal
self.assertTrue(r1.is_in_contact_diagonal(r2))
self.assertTrue(r2.is_in_contact_diagonal(r4))
self.assertFalse(r1.is_in_contact_diagonal(r3))
self.assertFalse(r1.is_in_contact_diagonal(r4))
self.assertFalse(r2.is_in_contact_diagonal(r3))
self.assertFalse(r3.is_in_contact_diagonal(r4))
# Not diagonal
self.assertFalse(r1.is_in_contact_v_h(r2))
self.assertFalse(r2.is_in_contact_v_h(r4))
self.assertTrue(r1.is_in_contact_v_h(r3))
self.assertFalse(r1.is_in_contact_v_h(r4))
self.assertTrue(r2.is_in_contact_v_h(r3))
self.assertTrue(r3.is_in_contact_v_h(r4))
def __init__(self, main, resolution=1, parent=None):
if isinstance(main, Rectangle):
if main.height() == main.width() and is_power2(main.height()):
self.main = main
self.parent = parent
self.resolution = resolution
# Subindexes
if resolution > 1:
self.top_left = Area(
Rectangle(self.main.top_left,
self.main.middle().top_left), resolution - 1,
self)
self.top_right = Area(
Rectangle(self.main.middle().top_right,
self.main.top_right), resolution - 1, self)
self.bottom_left = Area(
Rectangle(self.main.bottom_left,
self.main.middle().bottom_left),
resolution - 1, self)
self.bottom_right = Area(
Rectangle(self.main.bottom_right,
self.main.middle().bottom_right),
resolution - 1, self)
self.children = [
self.top_left, self.top_right, self.bottom_left,
self.bottom_right
]
self.rectangles = []
def test_remove3(self):
a = Area(Rectangle(Field(0, 0), Field(15, 15)), 3)
r = Rectangle(Field(8, 10), Field(10, 11))
self.assertFalse(r in a.top_right.bottom_left.rectangles)
a += r
self.assertTrue(r in a.top_right.bottom_left.rectangles)
a -= r
self.assertFalse(r in a.top_right.bottom_left.rectangles)
def test_remove(self):
a = Area(Rectangle(Field(0, 0), Field(7, 7)), 1)
r = Rectangle(Field(0, 0), Field(4, 4))
self.assertFalse(r in a.rectangles)
a += r
self.assertTrue(r in a.rectangles)
a -= r
self.assertFalse(r in a.rectangles)
def test_hash_true(self):
first = Field(0, 0)
second = Field(9, 9)
rect1 = Rectangle(first, second)
rect2 = Rectangle(first, second)
self.assertEqual(rect1.__hash__(), rect2.__hash__())
def test_remove2(self):
a = Area(Rectangle(Field(0, 0), Field(15, 15)), 2)
r = Rectangle(Field(0, 0), Field(6, 6))
self.assertFalse(r in a.bottom_left.rectangles)
a += r
self.assertTrue(r in a.bottom_left.rectangles)
a -= r
self.assertFalse(r in a.bottom_left.rectangles)
def test_init_subindexes(self):
a = Area(Rectangle(Field(0, 0), Field(7, 7)), 2)
self.assertTrue(
a.bottom_left.main == Rectangle(Field(0, 0), Field(3, 3)))
self.assertTrue(
a.bottom_right.main == Rectangle(Field(4, 0), Field(7, 3)))
self.assertTrue(a.top_left.main == Rectangle(Field(0, 4), Field(3, 7)))
self.assertTrue(
a.top_right.main == Rectangle(Field(4, 4), Field(7, 7)))
def test_init_area(self):
a = Area(Rectangle(Field(0, 0), Field(31, 31)), 2)
rect = Rectangle(Field(5, 5), Field(10, 10))
a += rect
for c in rect.corners():
self.assertEqual(c.rectangle.area, a)
def test_all_rectangles(self):
a = Area(Rectangle(Field(0, 0), Field(127, 127)), 4)
original = set()
for i in range(0, 100):
rect = Rectangle(Field(i, i), Field(i, i))
original.add(rect)
a += rect
result = a.all_rectangles()
self.assertEqual(original, result)
def test_corner_shell(self):
test_cases = {
Rectangle(Field(0, 0), Field(5, 5)):
Rectangle(Point(-0.5, -0.5), Point(5.5, 5.5)),
Rectangle(Field(2, 2), Field(4, 4)):
Rectangle(Point(1.5, 1.5), Point(4.5, 4.5))
}
for case, expected in test_cases.items():
self.assertEqual(case.corner_shell(), expected)
def test_and_none(self):
big1 = Field(5, 5)
big2 = Field(10, 10)
small1 = Field(1, 1)
small2 = Field(4, 4)
big = Rectangle(big1, big2)
small = Rectangle(small1, small2)
self.assertEqual(None, big & small)
def area():
a = Area.of_size(16)
rectangles = [
Rectangle(Field(3, 3), Field(12, 3), type=FieldType.inaccessible),
Rectangle(Field(3, 12), Field(12, 12), type=FieldType.inaccessible),
Rectangle(Field(7, 6), Field(8, 9), type=FieldType.inaccessible),
]
a += rectangles
return a
def test_init_subsubindexes(self):
a = Area(Rectangle(Field(0, 0), Field(7, 7)), 3)
self.assertTrue(a.bottom_left.bottom_left.main == Rectangle(
Field(0, 0), Field(1, 1)))
self.assertTrue(a.bottom_left.bottom_right.main == Rectangle(
Field(2, 0), Field(3, 1)))
self.assertTrue(
a.bottom_left.top_left.main == Rectangle(Field(0, 2), Field(1, 3)))
self.assertTrue(a.bottom_left.top_right.main == Rectangle(
Field(2, 2), Field(3, 3)))
def test_and_contains(self):
big1 = Field(0, 0)
big2 = Field(10, 10)
small1 = Field(4, 4)
small2 = Field(8, 8)
big = Rectangle(big1, big2)
small = Rectangle(small1, small2)
self.assertEqual(small, big & small)
self.assertEqual(small & big, big & small)
def test_add_multiple_list(self):
a = Area(Rectangle(Field(0, 0), Field(15, 15)), 1)
rectangles = [
Rectangle(Field(2, 2), Field(3, 3)),
Rectangle(Field(2, 5), Field(3, 5)),
Rectangle(Field(5, 2), Field(6, 3)),
Rectangle(Field(5, 5), Field(6, 6))
]
a += rectangles
# Check
self.assertEqual(set(rectangles), a.all_rectangles())
def test_all_rectangles_complex(self):
a = Area(Rectangle(Field(0, 0), Field(511, 511)), 4)
original = set()
for i in range(1, 20):
for j in range(1, 20):
rect = (Rectangle(Field(i * 6, j * 6),
Field(i * 6 + 2, j * 6 + 2)))
original.add(rect)
a += rect
result = a.all_rectangles()
self.assertEqual(original, result)
def area():
a = Area.of_size(8)
rectangles = [
Rectangle(Field(2, 2), Field(3, 3), type=FieldType.inaccessible),
Rectangle(Field(2, 5), Field(3, 6), type=FieldType.inaccessible),
Rectangle(Field(5, 2), Field(6, 3), type=FieldType.inaccessible),
Rectangle(Field(5, 5), Field(6, 6), type=FieldType.inaccessible)
]
a += rectangles
return a
def area():
a = Area.of_size(8)
rectangles = [
Rectangle(Field(0, 0), Field(0, 5), type=FieldType.inaccessible),
Rectangle(Field(3, 0), Field(3, 5), type=FieldType.inaccessible),
Rectangle(Field(4, 5), Field(6, 5), type=FieldType.inaccessible),
Rectangle(Field(6, 3), Field(7, 3), type=FieldType.inaccessible)
]
a += rectangles
return a
def test_and_2to0_intersection_vertical_right(self):
first_s = Field(0, 10)
first_e = Field(10, 20)
second_s = Field(4, 5)
second_e = Field(8, 15)
result = Rectangle(Field(4, 10), Field(8, 15))
first = Rectangle(first_s, first_e)
second = Rectangle(second_s, second_e)
self.assertTrue(result == first & second)
def test_root(self):
a = Area(Rectangle(Field(0, 0), Field(1023, 1023)), 8)
other = Area(Rectangle(Field(0, 0), Field(1023, 1023)), 8)
for child in a.children:
while child.is_subindexed():
child = child.bottom_left
self.assertEquals(child.get_root(), a)
# Abusive
self.assertNotEqual(child.get_root(), child)
self.assertNotEqual(child.get_root(), child.parent)
self.assertNotEqual(child.get_root(), other)
def test_add_multiple(self):
a = Area(Rectangle(Field(0, 0), Field(15, 15)), 2)
r = Rectangle(Field(6, 6), Field(10, 10))
self.assertFalse(r in a.bottom_left.rectangles)
self.assertFalse(r in a.bottom_right.rectangles)
self.assertFalse(r in a.top_left.rectangles)
self.assertFalse(r in a.top_right.rectangles)
a += r
self.assertTrue(r in a.bottom_left.rectangles)
self.assertTrue(r in a.bottom_right.rectangles)
self.assertTrue(r in a.top_left.rectangles)
self.assertTrue(r in a.top_right.rectangles)
def gen_area(self):
# DO NOT CHANGE!!!
a = Area(Rectangle(Field(0, 0), Field(15, 15)), 1)
rectangles = [
Rectangle(Field(2, 2), Field(3, 3), type=FieldType.inaccessible),
Rectangle(Field(2, 5), Field(3, 6), type=FieldType.inaccessible),
Rectangle(Field(5, 2), Field(6, 3), type=FieldType.inaccessible),
Rectangle(Field(6, 5), Field(6, 5), type=FieldType.inaccessible)
]
a += rectangles
return a
def test_and_1to1_intersection(self):
first_s = Field(0, 0)
first_e = Field(9, 11)
second_s = Field(4, 3)
second_e = Field(12, 12)
result = Rectangle(Field(4, 3), Field(9, 11))
first = Rectangle(first_s, first_e)
second = Rectangle(second_s, second_e)
self.assertEqual(result, first & second)
def test_and_2to0_intersection_horizontal_right(self):
first_s = Field(10, 0)
first_e = Field(20, 10)
second_s = Field(8, 4)
second_e = Field(16, 9)
result = Rectangle(Field(10, 4), Field(16, 9))
first = Rectangle(first_s, first_e)
second = Rectangle(second_s, second_e)
self.assertTrue(result == first & second)
def gen_area(self):
a = Area(Rectangle(Field(0, 0), Field(7, 7)), 1)
rectangles = [
Rectangle(Field(2, 2), Field(3, 3), type=FieldType.inaccessible),
Rectangle(Field(2, 5), Field(3, 6), type=FieldType.inaccessible),
Rectangle(Field(5, 2), Field(6, 3), type=FieldType.inaccessible),
Rectangle(Field(5, 5), Field(6, 6), type=FieldType.inaccessible)
]
a.main.size = MagicMock(return_value=64)
a.all_rectangles = MagicMock(return_value=set(rectangles))
a += rectangles # TODO: Mocking should work without this instruction
return a
def test_init_area_big(self):
a = Area(Rectangle(Field(0, 0), Field(1023, 1023)), 5)
rect1 = Rectangle(Field(5, 5), Field(10, 10))
rect2 = Rectangle(Field(200, 500), Field(1001, 700))
rect3 = Rectangle(Field(201, 201), Field(201, 201))
rectangles = {rect1, rect2, rect3}
for r in rectangles:
a += r
for c in r.corners():
self.assertEqual(c.rectangle.area, a)
def test_add_coinciding(self):
a = Area(Rectangle(Field(0, 0), Field(15, 15)), 2)
base = Rectangle(Field(6, 6), Field(10, 10))
r1 = Rectangle(Field(6, 6), Field(10, 10))
r2 = Rectangle(Field(4, 4), Field(8, 8))
r3 = Rectangle(Field(10, 10), Field(13, 13))
rs = [r1, r2, r3]
a += base
for r in rs:
with self.assertRaises(Exception):
a += r
def test_contains(self):
big1 = Field(0, 0)
big2 = Field(10, 10)
small1 = Field(0, 0)
small2 = Field(8, 8)
tiny1 = Field(5, 5)
big = Rectangle(big1, big2)
small = Rectangle(small1, small2)
tiny = Rectangle(tiny1, tiny1)
self.assertTrue(small in big)
self.assertTrue(tiny in small)
def find_enemies(full_gray_np, game_phase=1) -> Tuple[List[Rectangle], Any]:
# Assert
assert_rectangle_shape(
full_gray_np, screen_template,
f'Shape of the image should be {screen_template.shape()}')
assert_gray_img(full_gray_np)
roi_gray_np = utils.crop_image(full_gray_np, enemy_segment_template)
mask = None
if game_phase == 2:
roi_gray_np = cv2.bitwise_not(roi_gray_np)
_, mask = cv2.threshold(roi_gray_np, 150, 240, cv2.THRESH_BINARY_INV)
kernel = np.ones((3, 10), np.uint8)
dilation = cv2.dilate(mask, kernel)
_, contours, _ = cv2.findContours(dilation, cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)
to_return = list()
for cnt in contours:
x, y, w, h = cv2.boundingRect(cnt)
if h < 8:
continue
rectangle = Rectangle(x, y, x + w, y + h)
to_return.append(rectangle)
return to_return, enemy_segment_template.shape()
