def test_end_to_end(self):
expected = ud.UData().ExpectedResults[0]
frames = ud.UData().ExpectedFrames
segments = m.Query.FindVideoSegments(self.experiment,
space=1,
start=expected.Start,
end=expected.End)
m.VideoSegment.Match(segments, frames)
m.VideoSegment.Match(segments, expected.Trajectories)
m.VideoSegment.Match(segments, expected.Interactions)
self.assertEqual(len(segments), len(expected.VideoSegments[1]))
for s, e in zip(segments, expected.VideoSegments[1]):
self.assertVideoSegmentEqual(s, e)
expectedSegment = expected.VideoSegments[1][0]
cap = cv2.VideoCapture(str(expectedSegment.AbsoluteFilePath))
with m.VideoSequence(segments) as sequence:
for i, (frame, data) in enumerate(sequence):
ret, expectedFrame = cap.read()
self.assertTrue(ret)
self.assertVideoFrameDataEqual(data, expectedSegment.Data[i])
self.assertEqual(cap.get(cv2.CAP_PROP_POS_FRAMES), expectedSegment.End)
segments = m.Query.FindVideoSegments(self.experiment, space=2)
self.assertEqual(len(segments), 0)
segments = m.Query.FindVideoSegments(self.experiment, space=3)
self.assertEqual(len(segments), 0)
def test_TDD_manipulation(self):
foragingID = self.experiment.CreateSpace("foraging").ID
nestID = self.experiment.CreateSpace("nest").ID
foragingTDDPath = ud.UData().ForagingDataDirs[0].AbsoluteFilePath
nestTDDPath = ud.UData().NestDataDirs[0].AbsoluteFilePath
badTDDPath = ud.UData().Basedir / "does-not-exist.0000"
with self.assertRaises(IndexError):
self.experiment.AddTrackingDataDirectory(42, str(foragingTDDPath))
with self.assertRaises(RuntimeError):
self.experiment.AddTrackingDataDirectory(foragingID,
str(badTDDPath))
URI = self.experiment.AddTrackingDataDirectory(foragingID,
str(foragingTDDPath))
self.assertEqual(URI, foragingTDDPath.name)
with self.assertRaises(ValueError):
self.experiment.AddTrackingDataDirectory(foragingID,
str(nestTDDPath))
with self.assertRaises(ValueError):
self.experiment.AddTrackingDataDirectory(nestID,
str(foragingTDDPath))
URI = self.experiment.AddTrackingDataDirectory(nestID,
str(nestTDDPath))
self.assertEqual(URI, nestTDDPath.name)
with self.assertRaises(ValueError):
self.experiment.RemoveTrackingDataDirectory(badTDDPath.name)
self.experiment.RemoveTrackingDataDirectory(URI)
def test_can_locate_movie_frame(self):
self.experiment = m.Experiment.Open(
str(ud.UData().CurrentVersionFile.AbsoluteFilePath))
tddInfo = ud.UData().WithVideoDataDir
filepath, frame = self.experiment.Spaces[1].LocateMovieFrame(
tddInfo.Start)
self.assertEqual(filepath,
str(tddInfo.AbsoluteFilePath / "stream.0000.mp4"))
self.assertEqual(frame, 0)
with self.assertRaises(IndexError):
filepath, frame = self.experiment.Spaces[1].LocateMovieFrame(
tddInfo.End)
def test_get_metadata_key_ranges(self):
experiment = m.Experiment(
os.path.join(ud.UData().Basedir, "foo.myrmidon"))
experiment.SetMetaDataKey("alive", True)
experiment.CreateAnt()
a = experiment.CreateAnt()
a.SetValue(key="alive", value=False, time=m.Time())
a = experiment.CreateAnt()
a.SetValue(key="alive", value=False, time=m.Time.SinceEver())
a.SetValue(key="alive", value=True, time=m.Time())
a.SetValue(key="alive", value=True, time=m.Time().Add(1))
a.SetValue(key="alive", value=False, time=m.Time().Add(2))
a.SetValue(key="alive", value=True, time=m.Time().Add(3))
ranges = m.Query.GetMetaDataKeyRanges(experiment,
key="alive",
value=True)
self.assertEqual(len(ranges), 4)
self.assertEqual(ranges[0], (1, m.Time.SinceEver(), m.Time.Forever()))
self.assertEqual(ranges[1], (2, m.Time.SinceEver(), m.Time()))
self.assertEqual(ranges[2], (3, m.Time(), m.Time().Add(2)))
self.assertEqual(ranges[3], (3, m.Time().Add(3), m.Time.Forever()))
with self.assertRaises(IndexError):
m.Query.GetMetaDataKeyRanges(experiment, key="isDead", value=True)
with self.assertRaises(ValueError):
m.Query.GetMetaDataKeyRanges(experiment, key="alive", value=42.0)
def test_identify_frames(self):
identifieds = m.Query.IdentifyFrames(self.experiment)
expected = ud.UData().ExpectedFrames
self.assertEqual(len(identifieds), len(expected))
for i, e in enumerate(expected):
self.assertIdentifiedFrameEqual(identifieds[i], e[0])
t = ud.UData().NestDataDirs[0].End
expectedNumber = 0
for identified, collision in expected:
if identified.FrameTime > t:
break
else:
expectedNumber += 1
identifieds = m.Query.IdentifyFrames(self.experiment, end=t)
self.assertEqual(len(identifieds), expectedNumber)
for i, e in enumerate(expected[:expectedNumber]):
self.assertIdentifiedFrameEqual(identifieds[i], e[0])
def test_collide_frames(self):
expected = ud.UData().ExpectedFrames
results = m.Query.CollideFrames(self.experiment)
self.assertEqual(len(results), len(expected))
for idx, e in enumerate(expected):
self.assertIdentifiedFrameEqual(results[idx][0], e[0])
self.assertCollisionFrameEqual(results[idx][1], e[1])
def test_file_manipulation(self):
dirs = [
ud.UData().Basedir / "test-manipulation",
ud.UData().Basedir / "test-manipulation-new"
]
for d in dirs:
try:
os.makedirs(d)
except FileExistsError:
pass
filepath = str(dirs[0] / "test.myrmidon")
goodNewPath = str(dirs[0] / "test2.myrmidon")
badNewPath = str(dirs[1] / "test.myrmidon")
e = m.Experiment(filepath)
e.Save(filepath)
e.Save(goodNewPath)
with self.assertRaises(ValueError):
e.Save(badNewPath)
def test_frame_selection(self):
firstDate = min(ud.UData().NestDataDirs[0].Start,
ud.UData().ForagingDataDirs[0].Start)
data = m.Query.IdentifyFrames(self.experiment, start=firstDate)
self.assertEqual(len(data), len(ud.UData().ExpectedFrames))
data = m.Query.IdentifyFrames(self.experiment,
start=firstDate,
end=firstDate.Add(1))
self.assertTrue(len(data) > 0)
self.assertTrue(len(data) <= 2)
self.assertTimeEqual(data[0].FrameTime, firstDate)
if len(data) == 2:
self.assertTimeEqual(data[1].FrameTime, firstDate)
data = m.Query.IdentifyFrames(self.experiment,
start=firstDate,
end=firstDate)
self.assertEqual(len(data), 0)
def test_can_open_corrupted_data_dir(self):
s = self.experiment.CreateSpace("main")
corruptedPath = str(ud.UData().CorruptedDataDir.AbsoluteFilePath)
with self.assertRaises(m.FixableError):
self.experiment.AddTrackingDataDirectory(spaceID=s.ID,
filepath=corruptedPath)
URI = self.experiment.AddTrackingDataDirectory(spaceID=s.ID,
filepath=corruptedPath,
fixCorruptedData=True)
self.experiment.RemoveTrackingDataDirectory(URI)
self.experiment.AddTrackingDataDirectory(spaceID=s.ID,
filepath=corruptedPath)
def test_compute_ant_trajectories(self):
for expectedResult in ud.UData().ExpectedResults:
trajectories = m.Query.ComputeAntTrajectories(
self.experiment,
start=expectedResult.Start,
end=expectedResult.End,
maximumGap=expectedResult.MaximumGap,
matcher=expectedResult.Matches)
self.assertEqual(len(trajectories),
len(expectedResult.Trajectories))
trajectories = sorted(trajectories,
key=functools.cmp_to_key(
QueryTestCase.compare_trajectories))
for i, expected in enumerate(expectedResult.Trajectories):
self.assertAntTrajectoryEqual(trajectories[i], expected)
def test_video_edge_cases(self):
expected = ud.UData().ExpectedResults[0]
segments = expected.VideoSegments[1].deepcopy()
segments[0].Data.pop(len(segments[0].Data)-1)
segments[0].Data.append(m.VideoFrameData(
position=segments[0].End, time=m.Time.SinceEver()))
segments[0].End += 2
with m.VideoSequence(segments) as sequence:
for _, data in sequence:
fi = (d for d in segments[0].Data
if d.Position == data.Position)
try:
self.assertVideoFrameDataEqual(data, next(fi))
except StopIteration:
e = m.VideoFrameData(position=data.Position,
time=m.Time.SinceEver())
self.assertVideoFrameDataEqual(data, e)
def test_space_manipulation(self):
spaces = [
self.experiment.CreateSpace("nest"),
self.experiment.CreateSpace("foraging"),
]
self.assertEqual(len(self.experiment.Spaces), 2)
for s in spaces:
self.assertEqual(self.experiment.Spaces[s.ID], s)
with self.assertRaises(IndexError):
self.experiment.DeleteSpace(42)
self.experiment.DeleteSpace(spaces[0].ID)
self.assertEqual(len(self.experiment.Spaces), 1)
self.assertFalse(spaces[0].ID in self.experiment.Spaces)
self.assertTrue(spaces[1].ID in self.experiment.Spaces)
tddInfo = ud.UData().ForagingDataDirs[0]
self.experiment.AddTrackingDataDirectory(spaces[1].ID,
str(tddInfo.AbsoluteFilePath))
with self.assertRaises(RuntimeError):
self.experiment.DeleteSpace(spaces[1].ID)
def test_fields_manipulation(self):
self.assertEqual(self.experiment.Name, "")
self.experiment.Name = "foo"
self.assertEqual(self.experiment.Name, "foo")
self.assertEqual(self.experiment.Author, "")
self.experiment.Author = "bar"
self.assertEqual(self.experiment.Author, "bar")
self.assertEqual(self.experiment.Comment, "")
self.experiment.Comment = "baz"
self.assertEqual(self.experiment.Comment, "baz")
self.assertEqual(self.experiment.Family, m.TagFamily.Undefined)
spaceID = self.experiment.CreateSpace("foraging").ID
tddInfo = ud.UData().ForagingDataDirs[0]
self.experiment.AddTrackingDataDirectory(spaceID,
str(tddInfo.AbsoluteFilePath))
self.assertEqual(self.experiment.Family, tddInfo.Family)
self.assertEqual(self.experiment.DefaultTagSize, 1.0)
self.experiment.DefaultTagSize = 2.5
self.assertEqual(self.experiment.DefaultTagSize, 2.5)
def test_compute_ant_interactions(self):
for expectedResult in ud.UData().ExpectedResults:
trajectories, interactions = m.Query.ComputeAntInteractions(
self.experiment,
start=expectedResult.Start,
end=expectedResult.End,
maximumGap=expectedResult.MaximumGap,
matcher=expectedResult.Matches)
self.assertEqual(len(trajectories),
len(expectedResult.InteractionTrajectories))
self.assertEqual(len(interactions),
len(expectedResult.Interactions))
trajectories = sorted(trajectories,
key=functools.cmp_to_key(
QueryTestCase.compare_trajectories))
for i, expected in enumerate(
expectedResult.InteractionTrajectories):
self.assertAntTrajectoryEqual(trajectories[i], expected)
for i, expected in enumerate(expectedResult.Interactions):
self.assertAntInteractionEqual(interactions[i], expected)
trajectories, interactions = m.Query.ComputeAntInteractions(
self.experiment,
start=expectedResult.Start,
end=expectedResult.End,
maximumGap=expectedResult.MaximumGap,
matcher=expectedResult.Matches,
reportFullTrajectories=False)
expectedSummarized = expectedResult.Summarized()
self.assertEqual(len(trajectories), 0)
self.assertEqual(len(interactions), len(expectedSummarized))
for i, expected in enumerate(expectedSummarized):
self.assertAntInteractionEqual(interactions[i], expected)
def setUp(self):
self.experiment = m.Experiment(
str(ud.UData().Basedir / "zone-utests.myrmidon"))
self.space = self.experiment.CreateSpace("nest")
def test_opening_dataless(self):
self.experiment = m.Experiment.Open(
str(ud.UData().CurrentVersionFile.AbsoluteFilePath))
self.assertTrue(self.experiment != None)
dataInformation = m.Query.GetDataInformations(self.experiment)
self.assertEqual(len(dataInformation.Spaces), 2)
self.assertEqual(
len(dataInformation.Spaces[1].TrackingDataDirectories),
len(ud.UData().NestDataDirs))
for idx, info in enumerate(ud.UData().NestDataDirs):
self.assertEqual(
dataInformation.Spaces[1].TrackingDataDirectories[idx].URI,
info.AbsoluteFilePath.name)
self.assertEqual(
len(dataInformation.Spaces[2].TrackingDataDirectories),
len(ud.UData().ForagingDataDirs))
for idx, info in enumerate(ud.UData().ForagingDataDirs):
self.assertEqual(
dataInformation.Spaces[2].TrackingDataDirectories[idx].URI,
info.AbsoluteFilePath.name)
dataless = m.Experiment.OpenDataLess(
str(ud.UData().CurrentVersionFile.AbsoluteFilePath))
dataInformation = m.Query.GetDataInformations(dataless)
self.assertEqual(len(dataInformation.Spaces), 2)
self.assertEqual(
len(dataInformation.Spaces[1].TrackingDataDirectories), 0)
self.assertEqual(
len(dataInformation.Spaces[2].TrackingDataDirectories), 0)
self.assertEqual(len(self.experiment.Ants), 3)
self.assertEqual(len(dataless.Ants), 3)
for antID, expected in self.experiment.Ants.items():
self.assertTrue(antID in dataless.Ants)
ant = dataless.Ants[antID]
self.assertEqual(len(ant.Capsules), len(expected.Capsules))
for i, tc in enumerate(expected.Capsules):
eShapeType, eCapsule = tc
shapeType, capsule = ant.Capsules[i]
self.assertEqual(shapeType, eShapeType)
self.assertCapsuleEqual(capsule, eCapsule)
self.assertEqual(len(ant.Identifications),
len(expected.Identifications))
for i, eIdentification in enumerate(expected.Identifications):
identification = ant.Identifications[i]
self.assertEqual(identification.TagValue,
eIdentification.TagValue)
self.assertTimeEqual(identification.Start,
eIdentification.Start)
self.assertTimeEqual(identification.End, eIdentification.End)
self.assertEqual(self.experiment.AbsoluteFilePath,
str(ud.UData().CurrentVersionFile.AbsoluteFilePath))
self.assertEqual(dataless.AbsoluteFilePath,
str(ud.UData().CurrentVersionFile.AbsoluteFilePath))
with self.assertRaises(RuntimeError):
e = m.Experiment.Open(
str(ud.UData().Basedir / "does-not-exists.myrmidon"))
with self.assertRaises(RuntimeError):
e = m.Experiment.OpenDataLess(
str(ud.UData().Basedir / "does-not-exists.myrmidon"))
def setUp(self):
self.experiment = m.Experiment(
str(ud.UData().Basedir / "identification-utest.myrmidon"))
self.ant = self.experiment.CreateAnt()
self.i = self.experiment.AddIdentification(self.ant.ID, 123)
def setUp(self):
self.experiment = m.Experiment.Open(
str(ud.UData().CurrentVersionFile.AbsoluteFilePath))
self.solver = self.experiment.CompileTrackingSolver()
def setUp(self):
self.experiment = m.Experiment(
str(ud.UData().Basedir / 'public-experiment.myrmidon'))
def setUp(self):
self.experiment = m.Experiment.Open(
str(ud.UData().CurrentVersionFile.AbsoluteFilePath))
def test_tag_statistics(self):
tagStats = m.Query.ComputeTagStatistics(self.experiment)
self.assertTagStatisticsEqual(tagStats,
ud.UData().ExpectedTagStatistics)