def add_some_objects(vcd):
#########################################
# Cuboids
#########################################
uid1 = vcd.add_object(name="", semantic_type="Car", frame_value=0)
cuboid1 = types.cuboid(name="box3D",
val=(15.0, 0.0, 0.7, 0.0, 0.0,
(15.0 * np.pi) / 180.0, 4.2, 1.8, 1.4),
coordinate_system="vehicle-iso8855")
vcd.add_object_data(uid1, cuboid1, frame_value=0)
uid2 = vcd.add_object(name="", semantic_type="Van", frame_value=0)
cuboid2 = types.cuboid(name="box3D",
val=(-9.0, 4.0, 1.25, 0.0, 0.0,
(0.0 * np.pi) / 180.0, 8.0, 3.1, 2.5),
coordinate_system="vehicle-iso8855")
vcd.add_object_data(uid2, cuboid2, frame_value=0)
#########################################
# Points3d (Walls)
#########################################
xm, ym, zm = utils.generate_grid(x_params=(0, 20, 21),
y_params=(-20, 20, 41),
z_params=(0, 0, 1))
points3d_4xN = utils.grid_as_4xN_points3d(xm, ym, zm)
uid_wall_1 = vcd.add_object(name="ground_x_pos",
semantic_type="Ground",
frame_value=0)
mat_wall = types.mat(name="wall",
val=points3d_4xN.flatten().tolist(),
channels=1,
width=points3d_4xN.shape[1],
height=points3d_4xN.shape[0],
dataType='float',
coordinate_system="vehicle-iso8855")
#mat_wall.add_attribute(types.vec(name="color",
# val=(255, 0, 0)))
vcd.add_object_data(uid_wall_1, mat_wall, frame_value=0)
xm, ym, zm = utils.generate_grid(x_params=(0, -20, 21),
y_params=(-20, 20, 41),
z_params=(0, 0, 1))
points3d_4xN = utils.grid_as_4xN_points3d(xm, ym, zm)
uid_wall_2 = vcd.add_object(name="ground_x_neg",
semantic_type="Ground",
frame_value=0)
mat_wall = types.mat(name="wall",
val=points3d_4xN.flatten().tolist(),
channels=1,
width=points3d_4xN.shape[1],
height=points3d_4xN.shape[0],
dataType='float',
coordinate_system="vehicle-iso8855")
#mat_wall.add_attribute(types.vec(name="color",
# val=(255, 255, 0)))
vcd.add_object_data(uid_wall_2, mat_wall, frame_value=0)
xm, ym, zm = utils.generate_grid(x_params=(20, 20, 1),
y_params=(-20, 20, 41),
z_params=(0, 2, 21))
points3d_4xN = utils.grid_as_4xN_points3d(xm, ym, zm)
uid_wall_3 = vcd.add_object(name="wall_front",
semantic_type="Wall",
frame_value=0)
mat_wall = types.mat(name="wall",
val=points3d_4xN.flatten().tolist(),
channels=1,
width=points3d_4xN.shape[1],
height=points3d_4xN.shape[0],
dataType='float',
coordinate_system="vehicle-iso8855")
#mat_wall.add_attribute(types.vec(name="color",
# val=(0, 255, 0)))
vcd.add_object_data(uid_wall_3, mat_wall, frame_value=0)
xm, ym, zm = utils.generate_grid(x_params=(-20, -20, 1),
y_params=(-20, 20, 41),
z_params=(0, 2, 21))
points3d_4xN = utils.grid_as_4xN_points3d(xm, ym, zm)
uid_wall_4 = vcd.add_object(name="wall_rear",
semantic_type="Wall",
frame_value=0)
mat_wall = types.mat(name="wall",
val=points3d_4xN.flatten().tolist(),
channels=1,
width=points3d_4xN.shape[1],
height=points3d_4xN.shape[0],
dataType='float',
coordinate_system="vehicle-iso8855")
#mat_wall.add_attribute(types.vec(name="color",
# val=(0, 255, 255)))
vcd.add_object_data(uid_wall_4, mat_wall, frame_value=0)
xm, ym, zm = utils.generate_grid(x_params=(-20, 20, 41),
y_params=(20, 20, 1),
z_params=(0, 2, 21))
points3d_4xN = utils.grid_as_4xN_points3d(xm, ym, zm)
uid_wall_5 = vcd.add_object(name="wall_right",
semantic_type="Wall",
frame_value=0)
mat_wall = types.mat(name="wall",
val=points3d_4xN.flatten().tolist(),
channels=1,
width=points3d_4xN.shape[1],
height=points3d_4xN.shape[0],
dataType='float',
coordinate_system="vehicle-iso8855")
#mat_wall.add_attribute(types.vec(name="color",
# val=(255, 0, 255)))
vcd.add_object_data(uid_wall_5, mat_wall, frame_value=0)
xm, ym, zm = utils.generate_grid(x_params=(-20, 20, 41),
y_params=(-20, -20, 1),
z_params=(0, 2, 21))
points3d_4xN = utils.grid_as_4xN_points3d(xm, ym, zm)
uid_wall_6 = vcd.add_object(name="wall_left",
semantic_type="Wall",
frame_value=0)
mat_wall = types.mat(name="wall",
val=points3d_4xN.flatten().tolist(),
channels=1,
width=points3d_4xN.shape[1],
height=points3d_4xN.shape[0],
dataType='float',
coordinate_system="vehicle-iso8855")
#mat_wall.add_attribute(types.vec(name="color",
# val=(255, 255, 0)))
vcd.add_object_data(uid_wall_6, mat_wall, frame_value=0)
#########################################
# Lines3d
#########################################
# TODO
#########################################
# Ego-vehicle
#########################################
vcd.add_object(name="Ego-car", semantic_type="Ego-car", uid=str(-2))
cuboid_ego = types.cuboid(name="box3D",
val=(1.35, 0.0, 0.736, 0.0, 0.0, 0.0, 4.765,
1.82, 1.47),
coordinate_system="vehicle-iso8855")
vcd.add_object_data(str(-2), cuboid_ego)
return vcd
def __copy_elements(self, vcd_430, root, frame_num=None):
if 'objects' in root:
for object in root['objects']:
uid = str(object['uid']) # Let's convert to string here
name = object['name']
ontologyUID = None
if 'ontologyUID' in object:
ontologyUID = str(object['ontologyUID']) # Let's convert to string here
typeSemantic = object.get('type', '') # In VCD 4.3.0 type is required, but it VCD 3.3.0 seems to be not
if not vcd_430.has(core.ElementType.object, uid):
vcd_430.add_object(name, typeSemantic, frame_num, uid, ontologyUID)
if 'objectDataContainer' in object:
objectDataContainer = object['objectDataContainer']
for key, value in objectDataContainer.items():
for object_data in value:
inStream = None
if 'inStream' in object_data:
inStream = object_data['inStream']
if 'val' in object_data:
val = object_data['val']
currentObjectData = None
# Create main object_data body
# NOTE: in the following calls, I am using direct access to dictionary for required fields, e.g.
# object_data['name'], etc.
# For optional fields, I am using get() function, e.g. object_data.get('mode') which defaults to
# None
if key == 'num':
if len(val) == 1:
# Single value, this is a num
currentObjectData = types.num(object_data['name'], val[0], inStream)
else:
# Multiple values, this is a vec
currentObjectData = types.vec(object_data['name'], val, inStream)
elif key == 'bool':
currentObjectData = types.boolean(object_data['name'], val, inStream)
elif key == 'text':
currentObjectData = types.text(object_data['name'], val, inStream)
elif key == 'image':
currentObjectData = types.image(
object_data['name'], val,
object_data['mimeType'], object_data['encoding'],
inStream
)
elif key == 'binary':
currentObjectData = types.binary(
object_data['name'], val,
object_data['dataType'], object_data['encoding'],
inStream
)
elif key == 'vec':
currentObjectData = types.vec(object_data['name'], val, inStream)
elif key == 'bbox':
currentObjectData = types.bbox(object_data['name'], val, inStream)
elif key == 'cuboid':
currentObjectData = types.cuboid(object_data['name'], val, inStream)
elif key == 'mat':
currentObjectData = types.mat(
object_data['name'], val,
object_data['channels'], object_data['width'], object_data['height'],
object_data['dataType'],
inStream
)
elif key == 'point2D':
currentObjectData = types.point2d(object_data['name'], val, object_data.get('id'), inStream)
elif key == 'point3D':
currentObjectData = types.point3d(object_data['name'], val, object_data.get('id'), inStream)
elif key == "poly2D":
mode_int = object_data['mode']
currentObjectData = types.poly2d(
object_data['name'], val, types.Poly2DType(mode_int), object_data['closed'], inStream
)
elif key == "poly3D":
currentObjectData = types.poly3d(object_data['name'], val, object_data['closed'], inStream)
elif key == "mesh":
currentObjectData = types.mesh(object_data['name'])
if 'point3D' in object_data:
for p3d_330 in object_data['point3D']:
# Create a types.point3d object and add it to the mesh
id = p3d_330['id']
name = p3d_330['name']
val = p3d_330['val']
p3d_430 = types.point3d(name, val)
self.__add_attributes(p3d_330, p3d_430)
currentObjectData.add_vertex(p3d_430, id)
if 'lineReference' in object_data:
for lref_330 in object_data['lineReference']:
# Create a types.line_reference object and add it to the mesh
id = lref_330['id']
name = lref_330['name']
referenceType = lref_330['referenceType']
assert(referenceType == "point3D")
val = lref_330.get('val') # defaults to None, needed for the constructor
lref_430 = types.lineReference(name, val, types.ObjectDataType.point3d)
self.__add_attributes(lref_330, lref_430)
currentObjectData.add_edge(lref_430, id)
if 'areaReference' in object_data:
for aref_330 in object_data['areaReference']:
# Create a types.area_reference object and add it to the mesh
id = aref_330['id']
name = aref_330['name']
referenceType = aref_330['referenceType']
assert (referenceType == "point3D" or referenceType == "lineReference")
val = aref_330.get('val') # defaults to None, needed for the constructor
if referenceType == "point3D":
aref_430 = types.areaReference(name, val, types.ObjectDataType.point3d)
else:
aref_430 = types.areaReference(name, val, types.ObjectDataType.line_reference)
self.__add_attributes(aref_330, aref_430)
currentObjectData.add_area(aref_430, id)
# Add any attributes
self.__add_attributes(object_data, currentObjectData)
# Add the object_data to the object
vcd_430.add_object_data(uid, currentObjectData, frame_num)
if 'actions' in root:
for action in root['actions']:
uid = str(action['uid'])
name = action['name']
ontologyUID = None
if 'ontologyUID' in action:
ontologyUID = str(action['ontologyUID'])
typeSemantic = action.get('type', '') # required in VCD 4.0, not in VCD 3.3.0
vcd_430.add_action(name, typeSemantic, frame_num, uid, ontologyUID)
if 'events' in root:
for event in root['events']:
uid = str(event['uid'])
name = event['name']
ontologyUID = None
if 'ontologyUID' in event:
ontologyUID = str(event['ontologyUID'])
typeSemantic = event.get('type', '')
vcd_430.add_event(name, typeSemantic, frame_num, uid, ontologyUID)
if 'contexts' in root:
for context in root['contexts']:
uid = str(context['uid'])
name = context['name']
ontologyUID = None
if 'ontologyUID' in context:
ontologyUID = str(context['ontologyUID'])
typeSemantic = context.get('type', '')
vcd_430.add_context(name, typeSemantic, frame_num, uid, ontologyUID)
if 'relations' in root:
for relation in root['relations']:
uid = str(relation['uid'])
name = relation['name']
ontologyUID = None
if 'ontologyUID' in relation:
ontologyUID = str(relation['ontologyUID'])
predicate = relation.get('predicate', '')
rdf_objects = relation.get('rdf_objects', None)
rdf_subjects = relation.get('rdf_subjects', None)
vcd_430.add_relation(name, predicate, frame_value=frame_num, uid=uid, ont_uid=ontologyUID)
relation = vcd_430.get_element(core.ElementType.relation, uid)
if not 'rdf_objects' in relation or len(relation['rdf_objects']) == 0: # just add once
for rdf_object in rdf_objects:
element_type = None
rdf_object_type_str = rdf_object['type']
if rdf_object_type_str == "Object":
element_type = core.ElementType.object
elif rdf_object_type_str == "Action":
element_type = core.ElementType.action
elif rdf_object_type_str == "Event":
element_type = core.ElementType.event
elif rdf_object_type_str == "Context":
element_type = core.ElementType.context
else:
warnings.warn("ERROR: Unrecognized Element type. Must be Object, Action, Event or Context.")
vcd_430.add_rdf(uid, core.RDF.object, str(rdf_object['uid']), element_type)
if not 'rdf_subjects' in relation or len(relation['rdf_subjects']) == 0: # just add once
for rdf_subject in rdf_subjects:
element_type = None
rdf_object_type_str = rdf_subject['type']
if rdf_object_type_str == "Object":
element_type = core.ElementType.object
elif rdf_object_type_str == "Action":
element_type = core.ElementType.action
elif rdf_object_type_str == "Event":
element_type = core.ElementType.event
elif rdf_object_type_str == "Context":
element_type = core.ElementType.context
else:
warnings.warn("ERROR: Unrecognized Element type. Must be Object, Action, Event or Context.")
vcd_430.add_rdf(uid, core.RDF.subject, str(rdf_subject['uid']), element_type)
def create_reprojections(vcd):
scene = scl.Scene(vcd)
# Read the "ground" objects and reproject from image to world
# Assuming data for frame 0
for object_id, object in vcd.data['vcd']['objects'].items():
name = object['name']
if 'ground' in name:
vcd_frame = vcd.get_frame(0)
object_data = vcd_frame['objects'][object_id]['object_data']['mat'][0]
#ground_x_neg = vcd_frame['objects'][object_id]['object_data']['mat'][1]
width = object_data['width']
height = object_data['height']
points_cs = object_data['coordinate_system']
'''
# DEBUG: distord-undistort cycle: works!
cam = scene.get_camera('CAM_FRONT', 0)
original_undistorted = np.array([1537, 846, 1]).reshape(3, 1)
distorted = cam.distort_points2d(original_undistorted)
undistorted = cam.undistort_points2d(distorted)
original_distorted = np.array([1481, 823, 1]).reshape(3, 1)
undistorted = cam.undistort_points2d(original_distorted)
distorted = cam.distort_points2d(undistorted)
'''
# Read 3d points
points3d_4xN = np.array(object_data['val']).reshape(height, width)
N = points3d_4xN.shape[1]
# Project into image
points2d_3xN, idx_valid_proj = scene.project_points3d_4xN(points3d_4xN, points_cs, 'CAM_FRONT')
# Re-project into plane
points2d_3xN_filt = points2d_3xN[:, idx_valid_proj]
points3d_4xN_rep, idx_valid_rep = scene.reproject_points2d_3xN(points2d_3xN_filt, (0, 0, 1, 0), 'CAM_FRONT', 'vehicle-iso8855')
# Create output object
mat_ground_reprojected = types.mat(name="points",
val=points3d_4xN_rep.flatten().tolist(),
channels=1,
width=points3d_4xN_rep.shape[1],
height=points3d_4xN_rep.shape[0],
dataType='float',
coordinate_system="vehicle-iso8855")
mat_ground_reprojected.add_attribute(types.vec(name="color",
val=(0, 0, 255)))
vcd.add_object_data(object_id, mat_ground_reprojected, frame_value=0)
# Filter out those not valid during projection and reprojection from original set of 3D points...
if len(idx_valid_rep) > 0:
temp1 = points3d_4xN[:, idx_valid_proj]
temp2 = temp1[:, idx_valid_rep]
# ... so we can compare with the valid reprojected 3D points
temp3 = points3d_4xN_rep[:, idx_valid_rep]
temp4 = temp3 - temp2
error = np.linalg.norm(temp4)
print("Reprojection error:", error, " - Num. points: ", temp2.shape[1])