def test_constructor(self):
# Test empty library
a = AnimationLibrary()
self.assertEqual(a.size(), 0)
a = AnimationLibrary([])
self.assertEqual(a.size(), 0)
# Test with a single argument
a = AnimationLibrary([Animation()])
self.assertEqual(a.size(), 1)
# Test with multiple arguments
a = AnimationLibrary([Animation(), Animation()])
self.assertEqual(a.size(), 2)
self.assertEqual(a.animations()[0], a.animations()[1])
# Test for value errors
with self.assertRaises(ValueError):
AnimationLibrary("wrong_type")
with self.assertRaises(ValueError):
AnimationLibrary(["wrong_type"])
with self.assertRaises(ValueError):
AnimationLibrary([Animation(), "wrong_type"])
library_animation1 = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
library_animation2 = Animation(np.array([[2, 3, 4], [1, 2, 3]]))
library_animation3 = Animation(np.array([[2, 3, 4], [1, 2, 2.5]]))
AnimationLibrary(
[library_animation1, library_animation2, library_animation3])
def test_equal_length_single_animation_comparison(self):
rec_anim = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
lib_anim1 = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
lib_anim2 = Animation(np.array([[2, 3, 4], [1, 2, 3]]))
lib_anim3 = Animation(np.array([[2, 3, 4], [1, 2, 2.5]]))
lib_anim4 = Animation(np.array([[2, 3, 4], [1, 2, 2.5], [1, 2, 2.5]]))
ar = AnimationRecognition()
score = ar.compare_equal_length_single_animations(rec_anim, lib_anim1)
self.assertEqual(score, ScoreSpaceElement(0, anim=lib_anim1))
score = ar.compare_equal_length_single_animations(rec_anim, lib_anim2)
self.assertEqual(score, ScoreSpaceElement(1, anim=lib_anim2))
score = ar.compare_equal_length_single_animations(lib_anim2, rec_anim)
self.assertEqual(score, ScoreSpaceElement(1, anim=rec_anim))
score = ar.compare_equal_length_single_animations(rec_anim, lib_anim3)
self.assertEqual(score, ScoreSpaceElement(1.5, anim=lib_anim3))
score = ar.compare_equal_length_single_animations(lib_anim3, rec_anim)
self.assertEqual(score, ScoreSpaceElement(1.5, anim=rec_anim))
# Check that assertion is raised if animation sizes are not equal
with self.assertRaises(ValueError):
ar.compare_equal_length_single_animations(rec_anim, lib_anim4)
def test_single_library_animation_moving_window_no_scale(self):
"""
Take a single recorded animation and a single library animation.
Slide the library animation through the recorded animation.
Return the resulting scores.
"""
rec_anim = Animation(
np.array([[1, 3, 4], [1, 2, 3], [1, 2, 2], [1, 2, 1], [1, 2, 1]]))
lib_anim1 = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
anim_lib = AnimationLibrary([lib_anim1])
ar = AnimationRecognition()
desired_scores = [[
ScoreSpaceElement(0, 0, lib_anim1),
ScoreSpaceElement(3, 1, lib_anim1),
ScoreSpaceElement(5, 2, lib_anim1),
ScoreSpaceElement(6, 3, lib_anim1)
]]
calculated_scores = ar.get_anim_library_moving_window_scores(
rec_anim, anim_lib)
self.assertEqual(desired_scores, calculated_scores)
desired_scores = [[
ScoreSpaceElement(0, 0, lib_anim1),
ScoreSpaceElement(3, 1, lib_anim1),
ScoreSpaceElement(5, 2, lib_anim1),
ScoreSpaceElement(6, 3, lib_anim1)
]]
calculated_scores = ar.get_anim_library_moving_window_scores(
rec_anim, anim_lib, window_step=1)
self.assertEqual(desired_scores, calculated_scores)
desired_scores = [[
ScoreSpaceElement(0, 0, lib_anim1),
ScoreSpaceElement(5, 2, lib_anim1)
]]
calculated_scores = ar.get_anim_library_moving_window_scores(
rec_anim, anim_lib, window_step=2)
self.assertEqual(desired_scores, calculated_scores)
desired_scores = [[ScoreSpaceElement(0, 0, lib_anim1)]]
calculated_scores = ar.get_anim_library_moving_window_scores(
rec_anim, anim_lib, window_step=5)
self.assertEqual(desired_scores, calculated_scores)
desired_scores = [[ScoreSpaceElement(0, 0, lib_anim1)]]
calculated_scores = ar.get_anim_library_moving_window_scores(
rec_anim, anim_lib, window_step=5)
self.assertEqual(desired_scores, calculated_scores)
def test_getitem(self):
library_animation1 = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
library_animation2 = Animation(np.array([[2, 3, 4], [1, 2, 3]]))
library_animation3 = Animation(np.array([[2, 3, 4], [1, 2, 2.5]]))
anim_library = AnimationLibrary(
[library_animation1, library_animation2, library_animation3])
self.assertEqual(anim_library[0], library_animation1)
self.assertEqual(anim_library[1], library_animation2)
self.assertEqual(anim_library[2], library_animation3)
def test_diff_score(self):
a1 = Animation(np.array([[1, 2, 4], [1, 2, 3]]))
a2 = Animation(np.array([[1, 2, 4], [1, 2, 3]]))
a3 = Animation(np.array([[1, 2, 3], [1, 2, 3]]))
a4 = Animation(np.array([[1.5, 2, 3], [1, 2, 3]]))
self.assertEqual(
a1.diff_score(a2, diff_type="square", score_type="sum"), 0)
self.assertEqual(
a1.diff_score(a3, diff_type="square", score_type="sum"), 1)
self.assertEqual(
a2.diff_score(a3, diff_type="square", score_type="sum"), 1)
self.assertEqual(
a3.diff_score(a2, diff_type="square", score_type="sum"), 1)
self.assertEqual(
a3.diff_score(a1, diff_type="square", score_type="sum"), 1)
self.assertEqual(
a1.diff_score(a4, diff_type="square", score_type="sum"), 1.25)
self.assertEqual(
a4.diff_score(a1, diff_type="square", score_type="sum"), 1.25)
self.assertEqual(a1.diff_score(a4), 1.25)
self.assertEqual(a4.diff_score(a1), 1.25)
self.assertEqual(a4.diff_score(a1, diff_type="abs", score_type="sum"),
1.5)
self.assertEqual(a1.diff_score(a4, diff_type="abs", score_type="sum"),
1.5)
self.assertEqual(a1.diff_score(a4, diff_type="sub", score_type="sum"),
0.5)
self.assertEqual(a4.diff_score(a1, diff_type="sub", score_type="sum"),
-0.5)
self.assertEqual(a1.diff_score(a4, diff_type="sub"), 0.5)
self.assertEqual(a4.diff_score(a1, diff_type="sub"), -0.5)
# Check the type errors
with self.assertRaises(TypeError):
a1.diff_score(1)
with self.assertRaises(TypeError):
a1.diff_score(a4, diff_type=1)
with self.assertRaises(TypeError):
a1.diff_score(a4, diff_type="sub", score_type=1)
def test_compare_animations(self):
a1 = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
a2 = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
a3 = Animation(np.array([[1, 3.5, 4], [1, 2, 3]]))
a4 = Animation(np.array([[1, 3, 4], [1, 2, 3], [1, 2, 3]]))
self.assertEqual(a1, a2)
self.assertNotEqual(a1, a3)
self.assertNotEqual(a2, a3)
self.assertNotEqual(a1, a4)
self.assertNotEqual(a1, None)
self.assertNotEqual(a1, [])
def test_add_animation(self):
anim1 = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
anim2 = Animation(np.array([[2, 3, 4], [1, 2, 3]]))
anim3 = Animation(np.array([[2, 3, 4], [1, 2, 2.5]]))
anim_library = AnimationLibrary()
anim_library.append(anim1)
self.assertEqual(1, anim_library.size())
self.assertEqual(anim1, anim_library[0])
anim_library.append(anim2)
self.assertEqual(2, anim_library.size())
self.assertEqual(anim2, anim_library[1])
def setUp(self) -> None:
# Prepare data for processing
self.anim = Animation(
np.array([[1, 3, 4], [1, 2, 3], [1, 2, 2], [1, 2, 1], [1, 2, 1]]))
self.lib_anim1 = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
self.lib_anim2 = Animation(np.array([[1, 2, 4], [1, 2, 3]]))
self.lib_anim3 = Animation(np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]))
self.lib = AnimationLibrary(
[self.lib_anim1, self.lib_anim2, self.lib_anim3])
# Pack the data into the AnimationRecognitionProcessorInputData structure
self.data = AnimationRecognitionProcessorInputData(self.anim, self.lib)
def test_cut_window(self):
recorded_animation = Animation(
np.array([[1, 3, 4], [1, 2, 3], [1, 2, 2], [1, 2, 1], [1, 2, 0],
[1, 2, -1], [1, 2, 0], [1, 2, 1]]))
anim1 = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
anim2 = Animation(np.array([[1, 2, 3], [1, 2, 2]]))
anim3 = Animation(np.array([[1, 2, 0], [1, 2, 1]]))
anim4 = Animation(np.array([[1, 2, 0]]))
anim5 = Animation(np.array([[1, 2, 1], [1, 2, 0], [1, 2, -1]]))
self.assertEqual(recorded_animation.cut_window(0, 2), anim1)
self.assertEqual(recorded_animation.cut_window(1, 2), anim2)
self.assertEqual(recorded_animation.cut_window(6, 2), anim3)
self.assertEqual(recorded_animation.cut_window(6, 1), anim4)
self.assertEqual(recorded_animation.cut_window(3, 3), anim5)
with self.assertRaises(ValueError):
recorded_animation.cut_window(7, 0)
with self.assertRaises(ValueError):
recorded_animation.cut_window(7, 2)
with self.assertRaises(ValueError):
recorded_animation.cut_window(-1, 2)
def read_from_string(string: str) -> Animation:
if len(string.strip()) == 0:
raise EmptyInputError("Input chan data is empty")
parsed_lines = AnimationReader.read_multiple_lines(string)
str_length = [len(x) for x in parsed_lines]
if len(str_length) == 0:
raise EmptyInputError("Input chan data is empty")
if min(str_length) != max(str_length):
raise LineLengthDoesNotMatchError("Lines lengths does not match")
return Animation(np.array(parsed_lines))
def test_iter(self):
library_animation1 = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
library_animation2 = Animation(np.array([[2, 3, 4], [1, 2, 3]]))
library_animation3 = Animation(np.array([[2, 3, 4], [1, 2, 2.5]]))
anim_library = AnimationLibrary([library_animation1])
for anim in anim_library:
self.assertEqual(anim, library_animation1)
anim_library = AnimationLibrary(
[library_animation1, library_animation2, library_animation3])
i = 0
for anim in anim_library:
if i == 0:
self.assertEqual(anim, library_animation1)
elif i == 1:
self.assertEqual(anim, library_animation2)
elif i == 2:
self.assertEqual(anim, library_animation3)
i += 1
def test_equal_length_animation_library_comparison(self):
rec_anim = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
lib_anim1 = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
lib_anim2 = Animation(np.array([[2, 3, 4], [1, 2, 3]]))
lib_anim3 = Animation(np.array([[2, 3, 4], [1, 2, 2.5]]))
lib_anim4 = Animation(np.array([[2, 3, 4], [1, 2, 2.5], [1, 2, 2.5]]))
lib_anim5 = Animation(np.array([[2, 3], [1, 2]]))
ar = AnimationRecognition()
anim_lib = AnimationLibrary()
scores = ar.compare_equal_length_library_animations(rec_anim, anim_lib)
self.assertListEqual(scores, [])
anim_lib = AnimationLibrary([lib_anim3])
scores = ar.compare_equal_length_library_animations(rec_anim, anim_lib)
self.assertListEqual(scores, [ScoreSpaceElement(1.5, anim=lib_anim3)])
anim_lib = AnimationLibrary([lib_anim1, lib_anim2, lib_anim3])
scores = ar.compare_equal_length_library_animations(rec_anim, anim_lib)
self.assertListEqual(scores, [
ScoreSpaceElement(0, anim=lib_anim1),
ScoreSpaceElement(1, anim=lib_anim2),
ScoreSpaceElement(1.5, anim=lib_anim3)
])
# Test with List[Animation]
scores = ar.compare_equal_length_library_animations(rec_anim, [])
self.assertListEqual(scores, [])
scores = ar.compare_equal_length_library_animations(
rec_anim, [lib_anim3])
self.assertListEqual(scores, [ScoreSpaceElement(1.5, anim=lib_anim3)])
scores = ar.compare_equal_length_library_animations(
rec_anim, [lib_anim1, lib_anim2, lib_anim3])
self.assertListEqual(scores, [
ScoreSpaceElement(0, anim=lib_anim1),
ScoreSpaceElement(1, anim=lib_anim2),
ScoreSpaceElement(1.5, anim=lib_anim3)
])
# The animation with different size
with self.assertRaises(ValueError):
ar.compare_equal_length_library_animations(rec_anim, [lib_anim4])
# The animation with different num_features
with self.assertRaises(ValueError):
ar.compare_equal_length_library_animations(rec_anim, [lib_anim5])
def test_read_from_string(self):
"""
Test reading animation from string
"""
string = """
# rx ry rz
1.2 0.5 0
7 4 6
"""
expected = Animation(np.array([[1.2, 0.5, 0], [7, 4, 6]]))
result = AnimationReader.read_from_string(string)
self.assertEqual(expected, result)
string = """
1.2 0.5 0
7 4
"""
with self.assertRaises(LineLengthDoesNotMatchError):
AnimationReader.read_from_string(string)
# Empty string should throw EmptyInputError
string = """ """
with self.assertRaises(EmptyInputError):
AnimationReader.read_from_string(string)
# String with only header should also throw EmptyInputError
string = """
# a b c
"""
with self.assertRaises(EmptyInputError):
AnimationReader.read_from_string(string)
string = """
1.2 0.5 0
7 4 A
"""
with self.assertRaises(ParsingLineFailedError):
AnimationReader.read_from_string(string)
def test_diff_animations(self):
# Input animations
a1 = Animation(np.array([[1, 2, 4], [1, 2, 3]]))
a2 = Animation(np.array([[1, 3, 2], [0.5, 2, 3]]))
a3 = Animation(np.array([[1, 3, 2], [0.5, 2, 3], [0.5, 2, 3]]))
#
# Test simple subtraction difference (sub)
diff = np.array([[0, -1, 2], [0.5, 0, 0]])
self.assertTrue(np.array_equal(diff, a1.diff(a2, diff_type="sub")))
#
# Test absolute difference (abs)
diff_abs = np.array([[0, 1, 2], [0.5, 0, 0]])
self.assertTrue(np.array_equal(diff_abs, a1.diff(a2, diff_type="abs")))
#
# Test square difference (square)
diff_square = np.array([[0, 1, 4], [0.25, 0, 0]])
self.assertTrue(np.array_equal(diff_square, a1.diff(a2)))
self.assertTrue(
np.array_equal(diff_square, a1.diff(a2, diff_type="square")))
#
# Test that diff() throws exception if diff_type argument is wrong
with self.assertRaises(ValueError):
self.assertTrue(
np.array_equal(diff, a1.diff(a2, diff_type="wrong_arg")))
#
# Test that args of other types raise error
with self.assertRaises(TypeError):
a1.diff([])
with self.assertRaises(TypeError):
a1.diff(None)
with self.assertRaises(TypeError):
a1.diff(a2, diff_type=1)
# Check that with the different matrix sizes we have ValueError
with self.assertRaises(ValueError):
self.assertTrue(np.array_equal(diff, a1.diff(a3)))
def test_read_from_file(self):
"""
Test reading animation from file
"""
import os
expected = Animation(np.array([[1.2, 0.5, 0], [7, 4, 6]]))
this_folder = os.path.dirname(__file__)
result = AnimationReader.read_from_chan_file(this_folder +
"/data/test_data1.chan")
self.assertEqual(expected, result)
with self.assertRaises(EmptyInputError):
AnimationReader.read_from_chan_file(this_folder +
"/data/test_data_empty.chan")
# Read a more complex chan file exported from Maya using Chan Exporter
anim = AnimationReader.read_from_chan_file(
this_folder + '/data/VideoPose3D_output_demo.chan')
self.assertEqual(1391, anim.num_frames())
self.assertEqual(39, anim.num_features())
def test_single_animation_moving_window_no_scale(self):
"""
Take a single recorded animation and single library animation.
Slide the library animation through the recorded animation.
Return the resulting scores.
"""
rec_anim = Animation(
np.array([[1, 3, 4], [1, 2, 3], [1, 2, 2], [1, 2, 1], [1, 2, 1]]))
lib_anim = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
wrong_length_lib_anim = Animation(np.array([[2, 3], [1, 2]]))
ar = AnimationRecognition()
desired_scores = [
ScoreSpaceElement(0, 0, lib_anim),
ScoreSpaceElement(3, 1, lib_anim),
ScoreSpaceElement(5, 2, lib_anim),
ScoreSpaceElement(6, 3, lib_anim)
]
calculated_scores = ar.get_single_anim_moving_window_scores(
rec_anim, lib_anim)
self.assertEqual(desired_scores, calculated_scores)
desired_scores = [
ScoreSpaceElement(0, 0, lib_anim),
ScoreSpaceElement(3, 1, lib_anim),
ScoreSpaceElement(5, 2, lib_anim),
ScoreSpaceElement(6, 3, lib_anim)
]
calculated_scores = ar.get_single_anim_moving_window_scores(
rec_anim, lib_anim, window_step=1)
self.assertEqual(desired_scores, calculated_scores)
desired_scores = [
ScoreSpaceElement(0, 0, lib_anim),
ScoreSpaceElement(5, 2, lib_anim)
]
calculated_scores = ar.get_single_anim_moving_window_scores(
rec_anim, lib_anim, window_step=2)
self.assertEqual(desired_scores, calculated_scores)
desired_scores = [ScoreSpaceElement(0, 0, lib_anim)]
calculated_scores = ar.get_single_anim_moving_window_scores(
rec_anim, lib_anim, window_step=5)
self.assertEqual(desired_scores, calculated_scores)
desired_scores = [ScoreSpaceElement(0, 0, rec_anim)]
calculated_scores = ar.get_single_anim_moving_window_scores(
rec_anim, rec_anim, window_step=5)
self.assertEqual(desired_scores, calculated_scores)
# The length of rec_anim is less than anim - raise ValueError
with self.assertRaises(ValueError):
ar.get_single_anim_moving_window_scores(rec_anim=lib_anim,
anim=rec_anim)
# The animations with different num_features - raise ValueError
with self.assertRaises(ValueError):
ar.compare_equal_length_library_animations(rec_anim,
[wrong_length_lib_anim])
def test_get_matrix(self):
orig_matrix = np.array([[1, 3, 4], [1, 2, 3]])
a = Animation(orig_matrix)
self.assertTrue(np.array_equal(orig_matrix, a.matrix()))
def test_multiple_library_animations_moving_window_no_scale(self):
"""
Take a single recorded animation and several library animations.
Slide the library animations through the recorded animation.
Return the resulting scores.
"""
rec_anim = Animation(
np.array([[1, 3, 4], [1, 2, 3], [1, 2, 2], [1, 2, 1], [1, 2, 1]]))
lib_anim1 = Animation(np.array([[1, 3, 4], [1, 2, 3]]))
lib_anim2 = Animation(np.array([[1, 2, 4], [1, 2, 3]]))
lib_anim3 = Animation(np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]))
anim_lib = AnimationLibrary([lib_anim1, lib_anim2, lib_anim3])
ar = AnimationRecognition()
desired_scores = [[
ScoreSpaceElement(0, 0, lib_anim1),
ScoreSpaceElement(3, 1, lib_anim1),
ScoreSpaceElement(5, 2, lib_anim1),
ScoreSpaceElement(6, 3, lib_anim1)
],
[
ScoreSpaceElement(1, 0, lib_anim2),
ScoreSpaceElement(2, 1, lib_anim2),
ScoreSpaceElement(4, 2, lib_anim2),
ScoreSpaceElement(5, 3, lib_anim2)
],
[
ScoreSpaceElement(10, 0, lib_anim3),
ScoreSpaceElement(6, 1, lib_anim3),
ScoreSpaceElement(4, 2, lib_anim3)
]]
calculated_scores = ar.get_anim_library_moving_window_scores(
rec_anim, anim_lib)
self.assertEqual(desired_scores, calculated_scores)
desired_scores = [[
ScoreSpaceElement(0, 0, lib_anim1),
ScoreSpaceElement(3, 1, lib_anim1),
ScoreSpaceElement(5, 2, lib_anim1),
ScoreSpaceElement(6, 3, lib_anim1)
],
[
ScoreSpaceElement(1, 0, lib_anim2),
ScoreSpaceElement(2, 1, lib_anim2),
ScoreSpaceElement(4, 2, lib_anim2),
ScoreSpaceElement(5, 3, lib_anim2)
],
[
ScoreSpaceElement(10, 0, lib_anim3),
ScoreSpaceElement(6, 1, lib_anim3),
ScoreSpaceElement(4, 2, lib_anim3)
]]
calculated_scores = ar.get_anim_library_moving_window_scores(
rec_anim, anim_lib, window_step=1)
self.assertEqual(desired_scores, calculated_scores)
desired_scores = [[
ScoreSpaceElement(0, 0, lib_anim1),
ScoreSpaceElement(5, 2, lib_anim1)
],
[
ScoreSpaceElement(1, 0, lib_anim2),
ScoreSpaceElement(4, 2, lib_anim2)
],
[
ScoreSpaceElement(10, 0, lib_anim3),
ScoreSpaceElement(4, 2, lib_anim3)
]]
calculated_scores = ar.get_anim_library_moving_window_scores(
rec_anim, anim_lib, window_step=2)
self.assertEqual(desired_scores, calculated_scores)
desired_scores = [[ScoreSpaceElement(0, 0, lib_anim1)],
[ScoreSpaceElement(1, 0, lib_anim2)],
[ScoreSpaceElement(10, 0, lib_anim3)]]
calculated_scores = ar.get_anim_library_moving_window_scores(
rec_anim, anim_lib, window_step=5)
self.assertEqual(desired_scores, calculated_scores)
desired_scores = [[ScoreSpaceElement(0, 0, lib_anim1)],
[ScoreSpaceElement(1, 0, lib_anim2)],
[ScoreSpaceElement(10, 0, lib_anim3)]]
calculated_scores = ar.get_anim_library_moving_window_scores(
rec_anim, anim_lib, window_step=5)
self.assertEqual(desired_scores, calculated_scores)
# lib_anim4 has wrong num features - raise ValueError
lib_anim4 = Animation(np.array([[1, 1], [1, 1], [1, 1]]))
anim_lib = AnimationLibrary(
[lib_anim1, lib_anim2, lib_anim3, lib_anim4])
with self.assertRaises(ValueError):
ar.get_anim_library_moving_window_scores(rec_anim, anim_lib)
# lib_anim5 is longer than rec_anim - raise ValueError
lib_anim5 = Animation(
np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1],
[1, 1, 1], [1, 1, 1]]))
anim_lib = AnimationLibrary(
[lib_anim1, lib_anim2, lib_anim3, lib_anim5])
with self.assertRaises(ValueError):
ar.get_anim_library_moving_window_scores(rec_anim, anim_lib)
