def test_is_similar_except_in_size_all_objects():
for definition_1 in ALL_DEFINITIONS:
for definition_2 in ALL_DEFINITIONS:
if definition_1 != definition_2:
x_size_1 = definition_1['dimensions']['x']
x_size_2 = definition_2['dimensions']['x']
y_size_1 = definition_1['dimensions']['y']
y_size_2 = definition_2['dimensions']['y']
z_size_1 = definition_1['dimensions']['z']
z_size_2 = definition_2['dimensions']['z']
expected = (
definition_1['type'] == definition_2['type'] and
definition_1['materialCategory'] ==
definition_2['materialCategory'] and
(
(x_size_1 + 0.05) < x_size_2 or
(x_size_1 - 0.05) > x_size_2 or
(y_size_1 + 0.05) < y_size_2 or
(y_size_1 - 0.05) > y_size_2 or
(z_size_1 + 0.05) < z_size_2 or
(z_size_1 - 0.05) > z_size_2
)
)
actual = is_similar_except_in_size(definition_1, definition_2)
if actual != expected:
print(f'ONE={definition_1}')
print(f'TWO={definition_2}')
assert actual == expected
def test_is_similar_except_in_size():
definition_1 = {
'type': 'a',
'materialCategory': ['x'],
'dimensions': {'x': 1, 'y': 1, 'z': 1}
}
definition_2 = {
'type': 'b',
'materialCategory': ['x'],
'dimensions': {'x': 1, 'y': 1, 'z': 1}
}
definition_3 = {
'type': 'a',
'materialCategory': ['y'],
'dimensions': {'x': 1, 'y': 1, 'z': 1}
}
definition_4 = {
'type': 'a',
'materialCategory': ['x', 'y'],
'dimensions': {'x': 1, 'y': 1, 'z': 1}
}
definition_5 = {
'type': 'a',
'materialCategory': ['x'],
'dimensions': {'x': 2, 'y': 1, 'z': 1}
}
definition_6 = {
'type': 'a',
'materialCategory': ['x'],
'dimensions': {'x': 0.5, 'y': 1, 'z': 1}
}
definition_7 = {
'type': 'a',
'materialCategory': ['x'],
'dimensions': {'x': 1.05, 'y': 1, 'z': 1}
}
definition_8 = {
'type': 'a',
'materialCategory': ['x'],
'dimensions': {'x': 0.95, 'y': 1, 'z': 1}
}
assert not is_similar_except_in_size(definition_1, definition_2)
assert not is_similar_except_in_size(definition_1, definition_3)
assert not is_similar_except_in_size(definition_1, definition_4)
assert is_similar_except_in_size(definition_1, definition_5)
assert is_similar_except_in_size(definition_1, definition_6)
assert not is_similar_except_in_size(definition_1, definition_7)
assert not is_similar_except_in_size(definition_1, definition_8)
def test_intuitive_physics_fall_down_complex_objects_untrained_sizes():
definition_list = util.retrieve_complete_definition_list(
[objects.get_intuitive_physics(True, False, True)]
)[0]
trained_list = util.retrieve_trained_definition_list([definition_list])[0]
untrained_list = util.retrieve_untrained_definition_list(
[definition_list],
tags.SCENE.UNTRAINED_SIZE
)[0]
for definition_1 in trained_list:
option_list = [
definition_2 for definition_2 in untrained_list
if util.is_similar_except_in_size(definition_1, definition_2,
True)
]
# We want at least two possible untrained objects.
assert len(option_list) >= 2
def test_similarity_pacifier():
# Not similar because materialCategory is not defined.
assert not is_similar_except_in_color(PACIFIER, PACIFIER)
assert not is_similar_except_in_shape(PACIFIER, PACIFIER)
assert not is_similar_except_in_size(PACIFIER, PACIFIER)
def verify_hypercube_variations(
hypercube_variations_list,
hypercube_target_list,
hypercube_non_target_list,
scene_target_list,
scene_non_target_list,
expected_target_length,
expected_non_target_length
):
assert len(scene_target_list) == expected_target_length
assert len(hypercube_target_list) == expected_target_length
assert len(hypercube_variations_list) == (
expected_target_length + expected_non_target_length
)
for i in range(expected_target_length):
assert scene_target_list[i] == hypercube_target_list[i]
assert (
scene_target_list[i] == hypercube_variations_list[i].get('trained')
)
for i in range(expected_non_target_length):
assert scene_non_target_list[i] == hypercube_non_target_list[i]
assert (
scene_non_target_list[i] == hypercube_variations_list[
i + expected_target_length
].get('trained')
)
for variations in hypercube_variations_list:
trained_default = variations.get('trained')
different_shape = variations.get('different_shape')
untrained_shape = variations.get('untrained_shape')
untrained_different_shape = (
variations.get('untrained_different_shape')
)
untrained_size = variations.get('untrained_size')
assert untrained_shape.get('untrainedShape', False)
assert untrained_different_shape.get('untrainedShape', False)
assert not trained_default.get('untrainedShape', False)
assert not trained_default.get('untrainedSize', False)
assert not different_shape.get('untrainedShape', False)
assert not different_shape.get('untrainedSize', False)
assert not untrained_shape.get('untrainedSize', False)
assert untrained_shape.get('untrainedShape', False)
assert not untrained_different_shape.get('untrainedSize', False)
assert untrained_different_shape.get('untrainedShape', False)
assert not untrained_size.get('untrainedShape', False)
assert untrained_size.get('untrainedSize', False)
assert util.is_similar_except_in_shape(
trained_default,
different_shape,
only_x_dimension=True
)
assert util.is_similar_except_in_shape(
trained_default,
untrained_shape,
only_x_dimension=True
)
assert util.is_similar_except_in_shape(
untrained_shape,
untrained_different_shape,
only_x_dimension=True
)
assert util.is_similar_except_in_size(
trained_default,
untrained_size,
only_x_dimension=True
)
assert trained_default['materials'] == different_shape['materials']
assert trained_default['materials'] == untrained_shape['materials']
assert (
trained_default['materials'] ==
untrained_different_shape['materials']
)
assert trained_default['materials'] == untrained_size['materials']
return True
