def test_numerical_protocol():

    c1 = Circle(2)
    c2 = Circle(6)
    assert print(c1 + c2) == print(Circle(8))
    assert print(c2 * 3) == print(Circle(18))
    assert print(3 * c2) == print(Circle(18))
Example #2
0
 def setUp(self):
     self.p1 = Point(-30, 30)
     self.p2 = Point(40, 40)
     self.p3 = Point(-40, 40)
     self.p4 = Point(-40, -40)
     self.o = Point(0, 0)
     self.circle1 = Circle.circleFromGrid(self.o, self.p1)
     self.circle2 = Circle.circleFromGrid(self.o, self.p2)
def test_augmented():
    c1 = Circle(2)
    c1 += 5

    assert print(c1) == print(Circle(7))

    c1 += Circle(12)

    assert print(c1) == print(Circle(19))
def test_comparisons():

    c1 = Circle(2)
    c2 = Circle(6)

    assert (c1 < c2) is True
    assert (c1 <= c2) is True
    assert (c1 == c2) is False
    assert (c1 != c2) is True
    assert (c1 > c2) is False
    assert (c1 >= c2) is False
Example #5
0
class TestCircle(unittest.TestCase):
    def setUp(self):
        self.c1 = Circle(0, 0, 4)
        self.c2 = Circle(0, 0, 2)
        self.c3 = Circle(2, 2, 2)
        self.c4 = Circle(3, 4, 2)

    def test_init(self):
        self.assertRaises(ValueError, Circle, 0, 0, -1)
        self.assertRaises(ValueError, Circle, 3, 3, -6)
        self.assertRaises(ValueError, Circle, 4, 6, -18)

    def test_repr(self):
        self.assertEqual(repr(self.c1), "Circle(0, 0, 4)")
        self.assertEqual(repr(self.c2), "Circle(0, 0, 2)")
        self.assertEqual(repr(self.c3), "Circle(2, 2, 2)")

    def test_eq(self):
        self.assertTrue(self.c1 == Circle(0, 0, 4))
        self.assertTrue(self.c2 == Circle(0, 0, 2))
        self.assertTrue(self.c3 == Circle(2, 2, 2))
        self.assertFalse(self.c1 == Circle(4, 3, 2))

    def test_ne(self):
        self.assertTrue(self.c1 != Circle(0, 8, 2))
        self.assertTrue(self.c2 != Circle(3, 3, 3))
        self.assertTrue(self.c3 != Circle(12, 43, 123))
        self.assertFalse(self.c4 != Circle(3, 4, 2))

    def test_area(self):
        self.assertEqual(self.c1.area(), 16 * pi)
        self.assertEqual(self.c2.area(), 4 * pi)
        self.assertEqual(self.c3.area(), 4 * pi)

    def test_move(self):
        self.assertEqual(self.c1.move(2, 2), Circle(2, 2, 4))
        self.assertEqual(self.c2.move(1, 4), Circle(1, 4, 2))
        self.assertEqual(Circle(5, 5, 5).move(4, 5), Circle(9, 10, 5))

    def test_cover(self):
        self.assertEqual(
            Circle(0, 0, 4).cover(Circle(0, 0, 1)), Circle(0, 0, 4))
        self.assertEqual(
            Circle(0, 0, 5).cover(Circle(0, 4, 1)), Circle(0, 0, 5))
        self.assertEqual(
            Circle(0, 0, 2).cover(Circle(0, 3, 1)), Circle(0, 1, 3))
        self.assertEqual(
            Circle(0, 0, 1).cover(Circle(3, 4, 1)), Circle(1.5, 2, 3.5))
        self.assertEqual(
            Circle(1, 1, 2).cover(Circle(2, 1, 1)), Circle(1, 1, 2))
Example #6
0
    def _place_circle(self, r, c_idx=None):
        """Attempt to place a circle of radius r within the image figure.
 
        c_idx is a list of indexes into the self.colours list, from which
        the circle's colour will be chosen. If None, use all colours.

        """

        if not c_idx:
            c_idx = range(len(self.colours))

        # Get the coordinates of all non-zero image pixels
        img_coords = np.nonzero(self.img)
        if not img_coords:
            return False

        # The guard number: if we don't place a circle within this number
        # of trials, we give up.
        guard = self.guard
        # For this method, r must be an integer. Ensure that it's at least 1.
        r = max(1, int(r))
        while guard:
            # Pick a random candidate pixel...
            i = np.random.randint(len(img_coords[0]))
            icx, icy = img_coords[0][i], img_coords[1][i]
            # ... and see if the circle fits there
            if self._circle_fits(icx, icy, r):
                self.apply_circle_mask(icx, icy, r)
                circle = Circle(icx, icy, r, icolour=np.random.choice(c_idx))
                self.circles.append(circle)
                return True
            guard -= 1
        print('guard reached.')
        return False
Example #7
0
def newCircle():
    x, y = randint(0, w - 1), randint(0, h - 1)
    for other in circles:
        d = ((x - other.x)**2 + (y - other.y)**2)**(0.5)
        if d < other.r + 3 or inputImg[y, x, 0] == 0:
            return None
    if len(circles) == 0 and inputImg[y, x, 0] == 0:
        return None
    return Circle(x, y, thickness)
Example #8
0
 def test_circle_validation(self):
     # Test radius(r) validation
     # Test string
     self.assertRaises(ValueError, Circle, "hi")
     # Test object input
     self.assertRaises(ValueError, Circle, Circle(5))
     # Test negative
     self.assertRaises(ValueError, Circle, -5)
     # Test complex
     self.assertRaises(ValueError, Circle, 5j)
Example #9
0
def read_circle_data(filename):
    circles = []
    with open(filename, 'r') as file:
        reader = csv.reader(file)
        for row in reader:
            lat = float(row[3])
            lng = float(row[4])
            radius = float(row[5])
            center = Point(lat, lng)
            circle = Circle(center, radius)
            circles.append(circle)
    return circles
def test_radius():

    c = Circle(5)
    assert c.radius == 5
Example #11
0
 def test_circle_diameter(self):
     # Test circle perimeter calculation
     self.assertAlmostEqual(Circle(3).diameter(), 2 * 3)
     self.assertAlmostEqual(Circle(1).diameter(), 2)
     self.assertAlmostEqual(Circle(4.57).diameter(), 2 * 4.57)
Example #12
0
 def test_circle_perimeter(self):
     # Test circle perimeter calculation
     self.assertAlmostEqual(Circle(5).perimeter(), 2 * pi * 5)
     self.assertAlmostEqual(Circle(1).perimeter(), 2 * pi)
     self.assertAlmostEqual(Circle(1.52).perimeter(), 2 * pi * 1.52)
def test_circle_from_diameter():

    c = Circle.from_diameter(10)
    assert c.radius == 5
    assert c.diameter == 10
def test_print():

    c = Circle(4)
    print_output = str(c)
    assert print_output.startswith('Circle with radius:') is True
    assert "4" in print_output
def test_diameter_setter():

    c = Circle(5)
    c.diameter = 20
    assert c.radius == 10
    assert c.diameter == 20
def test_area_getter():

    c = Circle(5)
    assert c.area == math.pi * (c.radius**2)
Example #17
0
 def test_circle_area_int(self):
     # Test Area function accuracy with integers
     self.assertAlmostEqual(Circle(1).area(), pi)
     self.assertAlmostEqual(Circle(5).area(), 5**2 * pi)
def test_diameter():

    c = Circle(5)
    assert c.diameter == 10
Example #19
0
 def test_eq(self):
     self.assertTrue(self.c1 == Circle(0, 0, 4))
     self.assertTrue(self.c2 == Circle(0, 0, 2))
     self.assertTrue(self.c3 == Circle(2, 2, 2))
     self.assertFalse(self.c1 == Circle(4, 3, 2))
Example #20
0
ax.set_xlim([0,100]) # axis setting
ax.set_ylim([0,100])
plt.rcParams["legend.markerscale"] = 0.3 # scale the marker
ims = [] # array to store each image flame
# Set up formatting for the movie files
Writer = animation.writers['ffmpeg']
writer = Writer(fps=int(1.0/time_step), metadata=dict(artist='Momoko'), bitrate=1800)

""" generate random circles """
for i in range(circle_num):
    # generate random velocity and position
    vel = Vector2D(np.random.randint(1,50), np.random.randint(1,50)) # generate 10~50 int randomly
    pos = Vector2D(np.random.randint(10, 100), np.random.randint(10, 100))
    radius = 10.0
    mass = 1.0 # [kg]
    circle = Circle(radius = radius, initial_center = pos, initial_velocity = vel, mass = mass) # setup
    circles.append(circle) # add one more circles


"""" ============ THIS PART IS MAIN PART ============ """

""" Move circles """
for i in range(int(duration/time_step)):
    # move circles
    move_all_circles(circles, circle_num, time_step)

    # wall collision check
    # If collisiong with wall, bound back the circle assuming perfect elastic collision
    wall_collide_check_and_move(circles, circle_num, wall)

    # Check if it collides with other circles's and move
Example #21
0
 def test_ne(self):
     self.assertTrue(self.c1 != Circle(0, 8, 2))
     self.assertTrue(self.c2 != Circle(3, 3, 3))
     self.assertTrue(self.c3 != Circle(12, 43, 123))
     self.assertFalse(self.c4 != Circle(3, 4, 2))
def test_sorting():
    circles = [
        Circle(6),
        Circle(7),
        Circle(8),
        Circle(4),
        Circle(0),
        Circle(2),
        Circle(3),
        Circle(5),
        Circle(9),
        Circle(1)
    ]

    circles.sort()

    assert circles == [
        Circle(0),
        Circle(1),
        Circle(2),
        Circle(3),
        Circle(4),
        Circle(5),
        Circle(6),
        Circle(7),
        Circle(8),
        Circle(9)
    ]
Example #23
0
 def setUp(self):
     self.c1 = Circle(0, 0, 4)
     self.c2 = Circle(0, 0, 2)
     self.c3 = Circle(2, 2, 2)
     self.c4 = Circle(3, 4, 2)
Example #24
0
 def test_cover(self):
     self.assertEqual(
         Circle(0, 0, 4).cover(Circle(0, 0, 1)), Circle(0, 0, 4))
     self.assertEqual(
         Circle(0, 0, 5).cover(Circle(0, 4, 1)), Circle(0, 0, 5))
     self.assertEqual(
         Circle(0, 0, 2).cover(Circle(0, 3, 1)), Circle(0, 1, 3))
     self.assertEqual(
         Circle(0, 0, 1).cover(Circle(3, 4, 1)), Circle(1.5, 2, 3.5))
     self.assertEqual(
         Circle(1, 1, 2).cover(Circle(2, 1, 1)), Circle(1, 1, 2))
Example #25
0
 def test_move(self):
     self.assertEqual(self.c1.move(2, 2), Circle(2, 2, 4))
     self.assertEqual(self.c2.move(1, 4), Circle(1, 4, 2))
     self.assertEqual(Circle(5, 5, 5).move(4, 5), Circle(9, 10, 5))
Example #26
0
class TestCircles():
    circle_test_data = [(Point(0, 0), Circle(Point(0, 0), 10), True),
                        (Point(10, 0), Circle(Point(0, 0), 10), True),
                        (Point(5, 5), Circle(Point(0, 0), 10), True),
                        (Point(37, 25), Circle(Point(30, 18), 10), True),
                        (Point(37, 25), Circle(Point(27, 15), 10), False)]

    rect1_test_data = [
        (Rectangle(Point(0, 0), 3, 4), Circle(Point(0, 0), 5), True),
        (Rectangle(Point(0, 0), 3, 4), Circle(Point(0, 0), 4), False),
        (Rectangle(Point(100, 100), 3, 4), Circle(Point(100, 100), 6), True),
        (Rectangle(Point(0, 0), 3, 4.5), Circle(Point(0, 0), 5), False),
        (Rectangle(Point(-3, 0), 3, 4.5), Circle(Point(0, 0), 5), False),
        (Rectangle(Point(0, -4.5), 3, 4.5), Circle(Point(0, 0), 5), False),
        (Rectangle(Point(-3, -4.5), 3, 4.5), Circle(Point(0, 0), 5), False),
        (Rectangle(Point(-3, -4), 3, 4), Circle(Point(0, 0), 5), True),
    ]

    rect2_test_data = [
        (Rectangle(Point(0, 0), 3, 4), Circle(Point(4, 5), 1), False),
        (Rectangle(Point(0, 0), 3, 4.5), Circle(Point(0, 0), 5), True),
        (Rectangle(Point(-3, 0), 3, 4.5), Circle(Point(0, 0), 5), True),
        (Rectangle(Point(0, -4.5), 3, 4.5), Circle(Point(0, 0), 5), True),
        (Rectangle(Point(-3, -4.5), 3, 4.5), Circle(Point(0, 0), 5), True),
        (Rectangle(Point(-3, -4), 3, 4), Circle(Point(0, 0), 5), True),
    ]

    @pytest.mark.parametrize('point, circle, expected', circle_test_data)
    def test_point_in_circle_on_test_data(self, point, circle, expected):
        assert point_in_circle(point, circle) == expected

    @pytest.mark.parametrize('rect, circle, expected', rect1_test_data)
    def test_rect_in_circle_on_test_data(self, rect, circle, expected):
        assert rect_in_circle(rect, circle) == expected

    @pytest.mark.parametrize('rect, circle, expected', rect2_test_data)
    def test_rect_circle_overlap_on_test_data(self, rect, circle, expected):
        assert rect_circle_overlap(rect, circle) == expected
Example #27
0
 def test_circle_area_float(self):
     # Test float calculation of area
     self.assertAlmostEqual(Circle(5.5).area(), 5.5**2 * pi)
     self.assertAlmostEqual(Circle(5.98).area(), 5.98**2 * pi)