def test_first_quarter(self):
ray = Ray(Point(20, 70), Point(40, 80))
point1 = Point((51, 86))
point2 = Point((14, 67))
self.assertTrue(ray.BelongsCollinearPoint(point1))
self.assertFalse(ray.BelongsCollinearPoint(point2))
def test_1(self):
roc1 = CarRecord()
roc1.pos = Point([10, 11])
roc1.rot = 12
roc1.radarRecord.pos = Point([7, 8])
roc1.radarRecord.rot = 9
for i in range(3):
ror = RangefinderRecord()
ror.LoadFromLine("2 3 4 5 6 ")
roc1.radarRecord.listOfRangefinderRecords[i] = ror
blackbox1 = comparable_BlackBox()
for i in range(3):
blackbox1.AddCarRecord(copy.deepcopy(roc1))
blackbox2 = comparable_BlackBox()
blackbox2.LoadFromLines([
"3", "10 11 12", "7 8 9", "2 3 4 5 6 ", "2 3 4 5 6 ", "2 3 4 5 6 ",
"10 11 12", "7 8 9", "2 3 4 5 6 ", "2 3 4 5 6 ", "2 3 4 5 6 ",
"10 11 12", "7 8 9", "2 3 4 5 6 ", "2 3 4 5 6 ", "2 3 4 5 6 "
])
a = 2
self.assertTrue(blackbox1 == blackbox2)
def test_parallel_to_x_plus(self):
ray = Ray(Point(80, 80), Point(100, 80))
point1 = Point((113, 80))
point2 = Point((68, 70))
self.assertTrue(ray.BelongsCollinearPoint(point1))
self.assertFalse(ray.BelongsCollinearPoint(point2))
def test_parallel_to_y_plus(self):
ray = Ray(Point(90, 30), Point(90, 50))
point1 = Point((90, 45))
point2 = Point((90, 21))
self.assertTrue(ray.BelongsCollinearPoint(point1))
self.assertFalse(ray.BelongsCollinearPoint(point2))
def test_parallel_to_x_minus(self):
ray = Ray(Point(90, 70), Point(70, 70))
point1 = Point((58, 70))
point2 = Point((106, 70))
self.assertTrue(ray.BelongsCollinearPoint(point1))
self.assertFalse(ray.BelongsCollinearPoint(point2))
def test_second_quarter(self):
ray = Ray(Point(30, 50), Point(10, 60))
point1 = Point((16, 57))
point2 = Point((50, 40))
self.assertTrue(ray.BelongsCollinearPoint(point1))
self.assertFalse(ray.BelongsCollinearPoint(point2))
def test_third_quarter(self):
ray = Ray(Point(30, 40), Point(10, 30))
point1 = Point((2, 26))
point2 = Point((50, 51))
self.assertTrue(ray.BelongsCollinearPoint(point1))
self.assertFalse(ray.BelongsCollinearPoint(point2))
def test_parallel_to_y_minus(self):
ray = Ray(Point(110, 40), Point(110, 20))
point1 = Point((110, 15))
point2 = Point((110, 53))
self.assertTrue(ray.BelongsCollinearPoint(point1))
self.assertFalse(ray.BelongsCollinearPoint(point2))
def test_fourth_quarter(self):
ray = Ray(Point(30, 20), Point(50, 10))
point1 = Point((56, 7))
point2 = Point((23, 24))
self.assertTrue(ray.BelongsCollinearPoint(point1))
self.assertFalse(ray.BelongsCollinearPoint(point2))
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_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))
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))
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_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_1(self):
ror1 = comparable_RecordOfRangefinder()
ror1.pos = Point([2, 3])
ror1.rot = 4
ror1.posOfBarrier = Point([5, 6])
ror2 = comparable_RecordOfRangefinder()
ror2.LoadFromLine("2 3 4 5 6 ")
self.assertEqual(ror1, ror2)
def test_1(self):
roc1 = CarRecord()
roc1.pos = Point([10, 11])
roc1.rot = 12
roc1.radarRecord.pos = Point([7, 8])
roc1.radarRecord.rot = 9
for i in range(3):
ror = RangefinderRecord()
ror.LoadFromLine("2 3 4 5 6 ")
roc1.radarRecord.listOfRangefinderRecords[i] = ror
blackbox1 = BlackBox()
for i in range(3):
blackbox1.AddCarRecord(copy.deepcopy(roc1))
blackbox2 = copy.deepcopy(blackbox1)
track1 = Track()
track1.AddBlackBox(blackbox1)
track1.AddBlackBox(blackbox2)
track2 = copy.deepcopy(track1)
track3 = copy.deepcopy(track1)
album1 = comparable_Album()
album1.AddTrack(track1)
album1.AddTrack(track2)
album1.AddTrack(track3)
album2 = comparable_Album()
album2.LoadFromLines([
"5 2", "5 6", "3", "10 11 12", "7 8 9", "2 3 4 5 6 ", "2 3 4 5 6 ",
"2 3 4 5 6 ", "10 11 12", "7 8 9", "2 3 4 5 6 ", "2 3 4 5 6 ",
"2 3 4 5 6 ", "10 11 12", "7 8 9", "2 3 4 5 6 ", "2 3 4 5 6 ",
"2 3 4 5 6 ", "3", "10 11 12", "7 8 9", "2 3 4 5 6 ", "2 3 4 5 6 ",
"2 3 4 5 6 ", "10 11 12", "7 8 9", "2 3 4 5 6 ", "2 3 4 5 6 ",
"2 3 4 5 6 ", "10 11 12", "7 8 9", "2 3 4 5 6 ", "2 3 4 5 6 ",
"2 3 4 5 6 ", "5 6", "3", "10 11 12", "7 8 9", "2 3 4 5 6 ",
"2 3 4 5 6 ", "2 3 4 5 6 ", "10 11 12", "7 8 9", "2 3 4 5 6 ",
"2 3 4 5 6 ", "2 3 4 5 6 ", "10 11 12", "7 8 9", "2 3 4 5 6 ",
"2 3 4 5 6 ", "2 3 4 5 6 ", "3", "10 11 12", "7 8 9", "2 3 4 5 6 ",
"2 3 4 5 6 ", "2 3 4 5 6 ", "10 11 12", "7 8 9", "2 3 4 5 6 ",
"2 3 4 5 6 ", "2 3 4 5 6 ", "10 11 12", "7 8 9", "2 3 4 5 6 ",
"2 3 4 5 6 ", "2 3 4 5 6 ", "5 6", "3", "10 11 12", "7 8 9",
"2 3 4 5 6 ", "2 3 4 5 6 ", "2 3 4 5 6 ", "10 11 12", "7 8 9",
"2 3 4 5 6 ", "2 3 4 5 6 ", "2 3 4 5 6 ", "10 11 12", "7 8 9",
"2 3 4 5 6 ", "2 3 4 5 6 ", "2 3 4 5 6 ", "3", "10 11 12", "7 8 9",
"2 3 4 5 6 ", "2 3 4 5 6 ", "2 3 4 5 6 ", "10 11 12", "7 8 9",
"2 3 4 5 6 ", "2 3 4 5 6 ", "2 3 4 5 6 ", "10 11 12", "7 8 9",
"2 3 4 5 6 ", "2 3 4 5 6 ", "2 3 4 5 6 "
])
self.assertTrue(album1 == album2)
def test_parallel_to_each_and_one_of_axes(self):
line1 = LinearEntity(Point(100, 100), Point(100, 200))
line2 = LinearEntity(Point(500, 300), Point(500, 200))
self.assertEqual(func1(line1.IntersectionBetweenLinesContainting(line2)), None)
line1 = LinearEntity(Point(100, 100), Point(200, 100))
line2 = LinearEntity(Point(500, 300), Point(400, 300))
self.assertEqual(func1(line1.IntersectionBetweenLinesContainting(line2)), None)
def __init__(self):
super(random_RecordOfRadar, self).__init__()
self.pos = Point([random_int(), random_int()])
self.rot = random_int()
for index in range(len(self.listOfRangefinderRecords)):
self.listOfRangefinderRecords[index] = random_RecordOfRangefinder()
def LoadFromFile(self, filename):
''' Load map from file.
Example of proper constructed file:
" line_1: 100 200 270 // car: position (2 first), rotation (lat one)
line_2: 300 400 90 2.5 0.5 // 1st barrier: position (2 first), rotation (middle), scale (2 last)
line_3: 600 700 180 2 1 // 2nd barrier: position (2 first), rotation (middle), scale (2 last)
line_4: 100 100 45 1.2 1.2 // 3rd barrier: position (2 first), rotation (middle), scale (2 last)
.
.
.
line_n+1: 350 100 30 1.5 1.5 // n'st barrier: position (2 first), rotation (middle), scale (2 last)
'''
lines = FilesManager.LinesFromFile(filename)
# Divide the data into parts for the car and barriers respectively
firstLine, rest = lines[0], lines[1:]
# Convert to list of floats
firstLine = BuiltInTypesConverter.StringToFloats(firstLine)
# Unpack
rawCarSuggestedPos, rawCarSuggestedRot = firstLine[0:2], firstLine[4]
# Convert to our coordinate system.
carSuggestedPos, carSuggestedRot = Map.ConvertPos(
rawCarSuggestedPos), Map.ConvertRot(rawCarSuggestedRot)
# Create the right objects.
self.carSuggestedPos, self.carSuggestedRot = Point(
carSuggestedPos), carSuggestedRot
# Steps in loop below are similar to steps above.
for line in rest:
line = BuiltInTypesConverter.StringToFloats(line)
rawPos, rawRot, rawScale = line[0:2], line[4], line[2:4]
pos, rot, scale = Map.ConvertPos(rawPos), Map.ConvertRot(
rawRot), Map.ConvertScale(rawScale)
barrier = Barrier()
barrier.pos, barrier.rot, barrier.scale = Point(pos), rot, Vector(
scale)
# Calculate parameters necessary for algorithms.
barrier.Create()
self.listOfBarriers.append(barrier)
def __init__(self, listOfRangefinders=None):
self.pos = Point()
self.rot = None
self.listOfRangefinderRecords = [RangefinderRecord()] * self.__class__.numberOfRangefinderRecords
if listOfRangefinders is not None:
for _ in range(self.__class__.numberOfRangefinderRecords):
self.listOfRangefinderRecords[_] = listOfRangefinders[_].record
def __init__(self, radarRecord=None):
self.pos = Point()
self.rot = None
if radarRecord is None:
self.radarRecord = RadarRecord()
else:
self.radarRecord = radarRecord
self.number = None
def test_1(self):
roc1 = comparable_RecordOfCar()
roc1.pos = Point([10, 11])
roc1.rot = 12
# roc1.recordOfRadar = RadarRecord()
roc1.radarRecord.pos = Point([7, 8])
roc1.radarRecord.rot = 9
for i in range(3):
ror = RangefinderRecord()
ror.LoadFromLine("2 3 4 5 6 ")
roc1.radarRecord.listOfRangefinderRecords[i] = ror
roc2 = comparable_RecordOfCar()
roc2.radarRecord = RadarRecord()
roc2.LoadFromLines(
["10 11 12", "7 8 9", "2 3 4 5 6 ", "2 3 4 5 6 ", "2 3 4 5 6 "])
self.assertEqual(roc1, roc2)
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 MeasureDistance(self):
''' Calculate how far is car from the environment in direction designated by rangefinder.
'''
# Create ray from car in direction designated by rangefinder
ray = Ray(Point(self.pos), rot=self.rot)
# "SetOfRects" (elements of environment) has to be set before following line. That "set" is common
# for all rangefinders and all moments, so this way has better performance.
self.posOfBarrier = ray.BeginningProjectionOnSetOfRects()
# Calculate distance. Distance is None when there is no point on the ray.
try:
self.distance = self.pos.Distance(self.posOfBarrier)
except AttributeError:
self.distance = None
def test_1(self):
rorad1 = comparable_RecordOfRadar()
rorad1.pos = Point([7, 8])
rorad1.rot = 9
for i in range(3):
ror = RangefinderRecord()
ror.LoadFromLine("2 3 4 5 6 ")
rorad1.listOfRangefinderRecords[i] = ror
rorad2 = comparable_RecordOfRadar()
rorad2.LoadFromLines(
["7 8 9", "2 3 4 5 6 ", "2 3 4 5 6 ", "2 3 4 5 6 "])
a = 2
self.assertEqual(rorad1, rorad2)
def test_only(self):
self.assertEqual(Point([2, 3]).Distance(Point([5, 7])), 5)
self.assertEqual(Point([0, 0]).Distance(Point([10, 5])), 11)
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 __init__(self):
super(random_RecordOfCar, self).__init__()
self.pos = Point([random_int(), random_int()])
self.rot = random_int()
self.radarRecord = random_RecordOfRadar()
def test_normal(self):
segment = Segment(Point(100, 200), Point(300, 400))
self.assertEqual(segment.type.value,
Segment.TypeOfSegment.NORMAL.value)
def __init__(self):
super(random_RecordOfRangefinder, self).__init__()
self.pos = Point([random_int(), random_int()])
self.rot = random_int()
self.posOfBarrier = Point([random_int(), random_int()])
