예제 #1
0
    def test_normal(self):
        segment = Segment(Point(100, 50), Point(250, 100))
        point1 = Point((200, 83))
        point2 = Point((50, 33))
        point3 = Point((300, 117))

        self.assertTrue(segment.BelongsCollinearPoint(point1))
        self.assertFalse(segment.BelongsCollinearPoint(point2))
        self.assertFalse(segment.BelongsCollinearPoint(point3))
예제 #2
0
    def test_parallel_to_y(self):
        segment = Segment(Point(200, 400), Point(200, 600))
        point1 = Point((200, 500))
        point2 = Point((200, 200))
        point3 = Point((200, 700))

        self.assertTrue(segment.BelongsCollinearPoint(point1))
        self.assertFalse(segment.BelongsCollinearPoint(point2))
        self.assertFalse(segment.BelongsCollinearPoint(point3))
예제 #3
0
    def test_parallel_to_x(self):
        segment = Segment(Point(100, 200), Point(300, 200))
        point1 = Point((200, 200))
        point2 = Point((50, 200))
        point3 = Point((350, 200))

        self.assertTrue(segment.BelongsCollinearPoint(point1))
        self.assertFalse(segment.BelongsCollinearPoint(point2))
        self.assertFalse(segment.BelongsCollinearPoint(point3))
    def test_normal(self):
        self.rangefinder.pos = (100, 100)
        self.rangefinder.rot = 315
        ProjectionCalculator.currentRay = Ray(Point(self.rangefinder.pos),
                                              rot=self.rangefinder.rot)
        ray = ProjectionCalculator.currentRay

        segment = Segment(Point(150, 0), Point(150, 200))

        self.modAssertEqual(ray.IntersectionWithSegment(segment),
                            Point((150, 150)))
        segment = Segment(Point(50, 0), Point(50, 200))
        self.modAssertEqual(ray.IntersectionWithSegment(segment), None)
        segment = Segment(Point(150, 200), Point(150, 300))
        self.modAssertEqual(ray.IntersectionWithSegment(segment), None)
    def test_parallelToEachOther(self):
        self.rangefinder.pos = (100, 100)
        self.rangefinder.rot = 315
        ProjectionCalculator.currentRay = Ray(Point(self.rangefinder.pos),
                                              rot=self.rangefinder.rot)
        ray = ProjectionCalculator.currentRay

        segment = Segment(Point(200, 100), Point(300, 200))
        self.modAssertEqual(ray.IntersectionWithSegment(segment), None)
    def test_parallelToAxes(self):
        self.rangefinder.pos = (100, 100)
        self.rangefinder.rot = 0
        ProjectionCalculator.currentRay = Ray(Point(self.rangefinder.pos),
                                              rot=self.rangefinder.rot)
        ray = ProjectionCalculator.currentRay
        segment = Segment(Point(200, 50), Point(200, 150))

        self.modAssertEqual(ray.IntersectionWithSegment(segment),
                            Point((200, 100)))
 def test_normal(self):
     segment = Segment(Point(100, 200), Point(300, 400))
     self.assertEqual(segment.type.value,
                      Segment.TypeOfSegment.NORMAL.value)
 def test_parallel_to_y(self):
     segment = Segment(Point(100, 200), Point(100, 400))
     self.assertEqual(segment.type.value,
                      Segment.TypeOfSegment.PARALLEL_TO_Y.value)
def func1(point):
    if point is not None:
        return [point.x, point.y]
    else:
        return None


rangefinder = Rangefinder()
rangefinder.pos = (100, 100)
rangefinder.rot = 90
ProjectionCalculator.currentRay = Ray(Point(rangefinder.pos),
                                      rot=rangefinder.rot)
ray = ProjectionCalculator.currentRay

segment = Segment(Point(50, 50), Point(150, 50))

start = time.time()
ray.IntersectionWithSegment(segment)
end = time.time()
print("Time of one calculation is equal: ", end - start)


class TestIfCurrentRayIntersectSegment(unittest.TestCase):
    def setUp(self):
        self.rangefinder = Rangefinder()

    def modAssertEqual(self, point1, point2):
        self.assertEqual(func1(point1), func1(point2))

    def test_normal(self):
 def test_normal(self):
     segment = Segment(Point((100, 20)), Point((40, 80)))
     self.assertEqual(segment.min_x, 40)
     self.assertEqual(segment.max_x, 100)
     self.assertEqual(segment.min_y, 20)
     self.assertEqual(segment.max_y, 80)
예제 #11
0
    def test_nearly_parallel(self):
        segment = Segment(Point(991, 49), Point(992, 377))
        point1 = Point((992, 456))

        self.assertFalse(segment.BelongsCollinearPoint(point1))