def test_mix_new_and_get():
from kwiver.sprokit.pipeline import datum
from kwiver.vital import types as kvt
# Try creating with generic constructor first, retrieving with
# type specific get function
datum_inst = datum.new("string_value")
check_same_type(datum_inst.get_string(), "string_value")
datum_inst = datum.new(kvt.Timestamp(1000000000, 10))
check_same_type(datum_inst.get_timestamp(), kvt.Timestamp(1000000000, 10))
datum_inst = datum.new(datum.VectorString(["element1", "element2"]))
check_same_type(datum_inst.get_string_vector(),
datum.VectorString(["element1", "element2"]))
# Now try the opposite
datum_inst = datum.new_string("string_value")
check_same_type(datum_inst.get_datum(), "string_value")
datum_inst = datum.new_timestamp(kvt.Timestamp(1000000000, 10))
check_same_type(datum_inst.get_datum(), kvt.Timestamp(1000000000, 10))
datum_inst = datum.new_string_vector(
datum.VectorString(["element1", "element2"]))
check_same_type(datum_inst.get_datum(),
datum.VectorString(["element1", "element2"]))
def test_add_get_vital_types():
from kwiver.vital import types as kvt
from kwiver.sprokit.adapters import adapter_data_set
ads = adapter_data_set.AdapterDataSet.create()
add_get_helper(
ads,
ads._add_bounding_box,
ads._get_port_data_bounding_box,
kvt.BoundingBoxD(1, 1, 2, 2),
"bounding_box",
)
add_get_helper(
ads,
ads._add_timestamp,
ads._get_port_data_timestamp,
kvt.Timestamp(),
"timestamp",
)
add_get_helper(
ads,
ads._add_f2f_homography,
ads._get_port_data_f2f_homography,
kvt.F2FHomography(1),
"f2f_homography",
)
def test_mix_add_and_get():
from kwiver.sprokit.adapters import adapter_data_set
from kwiver.vital import types as kvt
ads = adapter_data_set.AdapterDataSet.create()
# Try adding with generic adder first, retrieving with
# type specific get function
ads["string_port"] = "string_value"
check_same_type(
ads._get_port_data_string("string_port"), "string_value", "string_port"
)
ads["timestamp_port"] = kvt.Timestamp(1000000000, 10)
check_same_type(
ads._get_port_data_timestamp("timestamp_port"),
kvt.Timestamp(1000000000, 10),
"timestamp_port",
)
ads["vector_string_port"] = adapter_data_set.VectorString(["element1", "element2"])
check_same_type(
ads._get_port_data_string_vector("vector_string_port"),
adapter_data_set.VectorString(["element1", "element2"]),
"vector_string_port",
)
# Now try the opposite
ads._add_string("string_port", "string_value")
check_same_type(ads["string_port"], "string_value", "string_port")
ads._add_timestamp("timestamp_port", kvt.Timestamp(1000000000, 10))
check_same_type(
ads["timestamp_port"], kvt.Timestamp(1000000000, 10), "timestamp_port"
)
ads._add_string_vector(
"vector_string_port", adapter_data_set.VectorString(["element1", "element2"])
)
check_same_type(
ads["vector_string_port"],
adapter_data_set.VectorString(["element1", "element2"]),
"vector_string_port",
)
def test_add_get_vital_types():
from kwiver.sprokit.pipeline import datum
from kwiver.vital import types as kvt
datum_inst = datum.new_bounding_box(kvt.BoundingBoxD(1, 1, 2, 2))
retrieved_val = datum_inst.get_bounding_box()
check_same_type(retrieved_val, kvt.BoundingBoxD(1, 1, 2, 2))
datum_inst = datum.new_timestamp(kvt.Timestamp())
retrieved_val = datum_inst.get_timestamp()
check_same_type(retrieved_val, kvt.Timestamp())
datum_inst = datum.new_f2f_homography(kvt.F2FHomography(1))
retrieved_val = datum_inst.get_f2f_homography()
check_same_type(retrieved_val, kvt.F2FHomography(1))
check_automatic_conversion(kvt.BoundingBoxD(1, 1, 2, 2))
check_automatic_conversion(kvt.Timestamp())
check_automatic_conversion(kvt.F2FHomography(1))
def _create_ads():
from kwiver.vital import types as kvt
from kwiver.sprokit.adapters import adapter_data_set
ads = adapter_data_set.AdapterDataSet.create()
# Construct a few elements
ads["string_port"] = "string_value"
ads["timestamp_port"] = kvt.Timestamp(1000000000, 10)
ads["vector_string_port"] = adapter_data_set.VectorString(["element1", "element2"])
return ads
def test_overwrite():
from kwiver.vital import types as kvt
from kwiver.sprokit.adapters import adapter_data_set
OVERWRITE_PORT = "test_overwrite_port"
ads = adapter_data_set.AdapterDataSet.create()
# Overwriting with same datum
ads.add_datum(OVERWRITE_PORT, datum.new("d2"))
overwrite_helper(
ads.add_datum,
ads.get_port_data,
datum.new("d3"),
"datum_string",
OVERWRITE_PORT,
)
# Overwriting with completely different types
overwrite_helper(
ads.add_datum, ads.get_port_data, datum.new(12), "datum_int", OVERWRITE_PORT
)
overwrite_helper(
ads._add_string_vector,
ads._get_port_data_string_vector,
adapter_data_set.VectorString(["baz", "qux"]),
"string_vector",
OVERWRITE_PORT,
)
overwrite_helper(
ads._add_timestamp,
ads._get_port_data_timestamp,
kvt.Timestamp(100, 10),
"timestamp",
OVERWRITE_PORT,
)
overwrite_helper(ads.add_value, ads.get_port_data, 15, "int", OVERWRITE_PORT)
overwrite_helper(
ads._add_double_vector,
ads._get_port_data_double_vector,
adapter_data_set.VectorDouble([4, 8]),
"double_vector",
OVERWRITE_PORT,
)
def test_iter():
from kwiver.vital import types as kvt
from kwiver.sprokit.adapters import adapter_data_set
ads = _create_ads()
for port, dat in ads:
if port == "string_port":
if dat.get_datum() != "string_value":
test_error("Didn't retrieve correct string value on first iteration")
elif port == "timestamp_port":
if dat.get_datum() != kvt.Timestamp(1000000000, 10):
test_error(
"Didn't retrieve correct timestamp value on second iteration"
)
elif port == "vector_string_port":
if dat.get_datum() != datum.VectorString(["element1", "element2"]):
test_error("Didn't retrieve correct string vector on third iteration")
else:
test_error("unknown port: {}".format(port))