def test_scale_returns_new_circle_which_is_a_scaled_version_of_input_one(
self):
circle = Circle(Point(3, 0), 10)
new_circle = circle.offset(Point(3, 3))
self.assertEqual(new_circle.x(), 6)
self.assertEqual(new_circle.y(), 3)
self.assertEqual(new_circle.radius(), 10)
def test_contains_point_returns_true_if_the_specified_point_is_within_radius(
self):
circle = Circle(Point(0, 0), 10)
point_center = Point(0, 0)
self.assertTrue(circle.contains_point(point_center))
point_middle = Point(5, 5)
self.assertTrue(circle.contains_point(point_middle))
def test_draw_circle_thickness_equals_one(self):
img = Image.blank(40, 40)
circle = Circle(Point(20, 20), 10)
img.draw_circle(circle, Color(200, 200, 200), 1)
self.assertEquals(img.img[10][20][1], 200)
self.assertEquals(img.img[9][20][1], 0)
self.assertEquals(img.img[11][20][1], 0)
def _sanitize_circles(raw_circles):
circles = []
if raw_circles is not None:
for raw in raw_circles[0]:
center = Point(int(raw[0]), int(raw[1]))
radius = int(raw[2])
circles.append(Circle(center, radius))
return circles
def CIRCLES_DEMO():
""" Draw a set of axes and a random set of circles. Perform a series of
random transformations on the circles.
"""
# Create a set of random circles
points = []
for i in range(10):
X = (random.random()) * 200
Y = (random.random()) * 200
points.append(Point(X, Y))
for i in range(10):
# Create random transformation
angle = random.random() * 2 * math.pi
scale = random.random() * 3
delX = (random.random() - 0.5) * 200
delY = (random.random() - 0.5) * 200
translate = Point(delX, delY)
trs = Transform(translate, angle, scale)
# Display on image
image = Image.blank(1000, 800)
image.draw_offset = IMG_CENTER
draw_axes(image, 300)
# Draw the circles and transformed circles on the image
radius = 10
for p in points:
circle = Circle(p, radius)
trans_circle = Circle(trs.transform(p), radius * trs.zoom)
image.draw_circle(circle, Color.Red())
image.draw_circle(trans_circle, Color.Blue())
# Write the transformation on the image
image.draw_text(trs.__str__(),
Point(-450, 350),
Color.White(),
centered=False,
scale=0.5,
thickness=1)
# Show the image
image.popup()
def test_circle_is_correctly_detected_when_there_there_are_two_circles_in_the_image_not_intersecting(
self):
img = Image.blank(100, 100)
circle_a = Circle(Point(20, 20), 10)
circle_b = Circle(Point(50, 50), 10)
img.draw_circle(circle_a, Color(10, 50, 100), 2)
img.draw_circle(circle_b, Color(10, 50, 100), 2)
grey = img.to_grayscale()
decorator = CircleDetector()
decorator.set_maximum_radius(20)
decorator.set_minimum_radius(5)
decorator.set_accumulator_threshold(30)
decorator.set_canny_threshold(30)
decorator.set_minimum_separation(10)
list = decorator.find_circles(grey)
self.assertEqual(list.__len__(), 2)
def test_circle_is_correctly_detected_when_there_is_one_circle_in_the_image(
self):
img = Image.blank(40, 40)
circle = Circle(Point(20, 20), 10)
img.draw_circle(circle, Color(200, 200, 200), 2)
grey = img.to_grayscale()
#parameters of the detector very important - a bit dubious test
decorator = CircleDetector()
decorator.set_maximum_radius(20)
decorator.set_minimum_radius(5)
decorator.set_accumulator_threshold(20)
decorator.set_canny_threshold(20)
list = decorator.find_circles(grey)
self.assertEqual(list.__len__(), 1)
# self.assertEqual(list[0].radius(), circle.radius())
#self.assertEqual(list[0].center().x, circle.center().x + 1)
#self.assertEqual(list[0].center().y, circle.center().y + 1)
self.assertEqual(list[0].area(), circle.area())
def deserialize(string):
""" Generate a BlankGeometry object from a string representation. """
circle_strs = string.split(BlankGeometry._SERIAL_DELIM)
barcode_bounds = []
for string in circle_strs:
circle = Circle.deserialize(string)
barcode_bounds.append(circle)
geo = BlankGeometry([])
geo._barcode_bounds = barcode_bounds
return geo
def test_draw_circle_thickness_equals_four(self):
img = Image.blank(40, 40)
circle = Circle(Point(20, 20), 10)
img.draw_circle(circle, Color(200, 200, 200), 4)
self.assertEquals(img.img[6][20][1], 0)
self.assertEquals(img.img[7][20][1], 0) #!!
self.assertEquals(img.img[8][20][1], 200)
self.assertEquals(img.img[10][20][1], 200)
self.assertEquals(img.img[9][20][1], 200)
self.assertEquals(img.img[11][20][1], 200)
self.assertEquals(img.img[12][20][1], 200)
self.assertEquals(img.img[13][20][1], 0) #!!
self.assertEquals(img.img[14][20][1], 0)
def test_draw_circle_centre_is_kept(self):
img = Image.blank(40, 40)
circle = Circle(Point(20, 20), 1)
img.draw_circle(circle, Color(200, 200, 200), 1)
self.assertEquals(img.img[18][20][1], 0)
self.assertEquals(img.img[19][20][1], 200)
self.assertEquals(img.img[20][20][1], 0)
self.assertEquals(img.img[21][20][1], 200)
self.assertEquals(img.img[22][20][1], 0)
self.assertEquals(img.img[20][18][1], 0)
self.assertEquals(img.img[20][19][1], 200)
self.assertEquals(img.img[20][20][1], 0)
self.assertEquals(img.img[20][21][1], 200)
self.assertEquals(img.img[20][22][1], 0)
def calculate_slot_bounds(center, radius, rotation):
""" Calculates the bounds (position and radius) of all of the slots in the puck, based on the
puck's geometry (position, size, and angle)."""
# Calculate pin slot locations
layer_counts = Template.N
layer_radii = Template.LAYER_RADII
slot_radius = radius * Template.SLOT_RADIUS
slot_bounds = []
for i, layer_count in enumerate(layer_counts):
layer_radius = layer_radii[i] * radius
for j in range(layer_count):
angle = (2.0 * math.pi * -j / layer_count) - (math.pi /
2.0) + rotation
x = int(center.x + layer_radius * math.cos(angle))
y = int(center.y + layer_radius * math.sin(angle))
slot_center = Point(x, y)
bounds = Circle(slot_center, slot_radius)
slot_bounds.append(bounds)
return slot_bounds
def center_bounds(self):
return Circle(self._center, self.center_radius())
def bounds(self):
return Circle(self._center, self._radius)
def test_intersects_returns_false_when_two_circles_touch_with_boarders(
self):
circle_a = Circle(Point(0, 0), 10)
circle_b = Circle(Point(20, 0), 10)
self.assertFalse(circle_a.intersects(circle_b))
self.assertFalse(circle_b.intersects(circle_a))
def test_intersect_returns_false_when_circles_dont_touch(self):
circle_a = Circle(Point(0, 0), 10)
circle_b = Circle(Point(20, 0), 2)
self.assertFalse(circle_a.intersects(circle_b))
self.assertFalse(circle_b.intersects(circle_a))
def test_intersects_returns_true_when_two_circles_properly_intersect(self):
circle_a = Circle(Point(0, 0), 10)
circle_b = Circle(Point(20, 0), 15)
self.assertTrue(circle_a.intersects(circle_b))
self.assertTrue(circle_b.intersects(circle_a))
def test_intersects_returns_true_for_two_same_circles(self):
circle_a = Circle(Point(4, 5), 14)
circle_b = Circle(Point(4, 5), 14)
self.assertTrue(circle_a.intersects(circle_b))
self.assertTrue(circle_b.intersects(circle_a))
def test_circumference_is_2pi_r(self):
new_circle = Circle(Point(4, 0), 4)
self.assertEqual(new_circle.circumference(), math.pi * 8)
def test_string_representation_of_circle(self):
new_circle = Circle(Point(0, 0), 10)
self.assertEqual(new_circle.__str__(),
"Circle - center = (0.00, 0.00); radius = 10.00")
def test_center_returns_correct_point(self):
new_circle = Circle(Point(1, 2), 3)
self.assertEqual(new_circle.center().x, 1)
self.assertEqual(new_circle.center().y, 2)
def test_x_y_radius_return_correct_values(self):
new_circle = Circle(Point(4, 5), 10)
self.assertEqual(new_circle.x(), 4)
self.assertEqual(new_circle.y(), 5)
self.assertEqual(new_circle.radius(), 10)
def test_offset_returns_new_circe_of_same_radius_but_shifted_center(self):
circle = Circle(Point(3, 0), 10)
new_circle = circle.offset(Point(3, 3))
self.assertEqual(new_circle.x(), 6)
self.assertEqual(new_circle.y(), 3)
self.assertEqual(new_circle.radius(), 10)
def test_area_is_2pi_r2(self):
new_circle = Circle(Point(9, 0), 10)
self.assertEqual(new_circle.area(), math.pi * 100)
def test_intersects_returns_true_when_one_circle_inside_the_other(self):
circle_a = Circle(Point(0, 0), 10)
circle_b = Circle(Point(0, 0), 5)
self.assertTrue(circle_a.intersects(circle_b))
self.assertTrue(circle_b.intersects(circle_a))
def _set_barcode_bounds(self, barcodes):
self._barcode_bounds = []
for barcode in barcodes:
bounds = barcode.bounds()
bounds = Circle(bounds.center(), int(bounds.radius()))
self._barcode_bounds.append(bounds)
def test_diameter_twice_radius(self):
new_circle = Circle(Point(0, 0), 4)
self.assertEqual(new_circle.diameter(), 8)
def test_contains_point_returns_false_if_the_specified_point_is_on_the_edge(
self):
circle = Circle(Point(0, 0), 10)
point_edge = Point(10, 0)
self.assertFalse(
circle.contains_point(point_edge)) # edge points not included
def test_contains_point_returns_false_if_the_specified_point_is_not_within_radius(
self):
circle = Circle(Point(0, 0), 10)
point_external = Point(20, 0)
self.assertFalse(circle.contains_point(point_external))
