def osd_sink_pad_buffer_probe(pad,info,u_data):
frame_number=0
#Intiallizing object counter with 0.
obj_counter = {
PGIE_CLASS_ID_VEHICLE:0,
PGIE_CLASS_ID_PERSON:0,
PGIE_CLASS_ID_BICYCLE:0,
PGIE_CLASS_ID_ROADSIGN:0
}
num_rects=0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number=frame_meta.frame_num
num_rects = frame_meta.num_obj_meta
l_obj=frame_meta.obj_meta_list
#### BERK
client.send_message("/frame_number", frame_number)
client.send_message("/num_rects", num_rects)
lcounter = 0
#### BERK
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta=pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
### BERK
class_id = obj_meta.class_id
# agent = class_id + long_to_int(obj_meta.object_id)
top = obj_meta.rect_params.top
left = obj_meta.rect_params.left
width = obj_meta.rect_params.width
height = obj_meta.rect_params.height
# confidence = obj_meta.confidence
client.send_message("/oxywhc", [lcounter, left, top, width, height, class_id])
###
try:
l_obj=l_obj.next
lcounter = lcounter + 1
except StopIteration:
break
### BERK
client.send_message("/num_vehicles", obj_counter[PGIE_CLASS_ID_VEHICLE])
client.send_message("/num_people", obj_counter[PGIE_CLASS_ID_PERSON])
###
# Acquiring a display meta object. The memory ownership remains in
# the C code so downstream plugins can still access it. Otherwise
# the garbage collector will claim it when this probe function exits.
display_meta=pyds.nvds_acquire_display_meta_from_pool(batch_meta)
display_meta.num_labels = 1
py_nvosd_text_params = display_meta.text_params[0]
# Setting display text to be shown on screen
# Note that the pyds module allocates a buffer for the string, and the
# memory will not be claimed by the garbage collector.
# Reading the display_text field here will return the C address of the
# allocated string. Use pyds.get_string() to get the string content.
py_nvosd_text_params.display_text = "Frame Number={} Number of Objects={} Vehicle_count={} Person_count={}".format(frame_number, num_rects, obj_counter[PGIE_CLASS_ID_VEHICLE], obj_counter[PGIE_CLASS_ID_PERSON])
# Now set the offsets where the string should appear
py_nvosd_text_params.x_offset = 10
py_nvosd_text_params.y_offset = 12
# Font , font-color and font-size
py_nvosd_text_params.font_params.font_name = "Serif"
py_nvosd_text_params.font_params.font_size = 10
# set(red, green, blue, alpha); set to White
py_nvosd_text_params.font_params.font_color.set(1.0, 1.0, 1.0, 1.0)
# Text background color
py_nvosd_text_params.set_bg_clr = 1
# set(red, green, blue, alpha); set to Black
py_nvosd_text_params.text_bg_clr.set(0.0, 0.0, 0.0, 1.0)
# Using pyds.get_string() to get display_text as string
print(pyds.get_string(py_nvosd_text_params.display_text))
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
try:
l_frame=l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def osd_sink_pad_buffer_probe(pad,info,u_data):
frame_number=0
#Intiallizing object counter with 0.
obj_counter = {
PGIE_CLASS_ID_VEHICLE:0,
PGIE_CLASS_ID_PERSON:0,
PGIE_CLASS_ID_BICYCLE:0,
PGIE_CLASS_ID_ROADSIGN:0
}
num_rects=0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number=frame_meta.frame_num
num_rects = frame_meta.num_obj_meta
l_obj=frame_meta.obj_meta_list
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta=pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
try:
l_obj=l_obj.next
except StopIteration:
break
# Acquiring a display meta object. The memory ownership remains in
# the C code so downstream plugins can still access it. Otherwise
# the garbage collector will claim it when this probe function exits.
display_meta=pyds.nvds_acquire_display_meta_from_pool(batch_meta)
display_meta.num_labels = 1
py_nvosd_text_params = display_meta.text_params[0]
# Setting display text to be shown on screen
# Note that the pyds module allocates a buffer for the string, and the
# memory will not be claimed by the garbage collector.
# Reading the display_text field here will return the C address of the
# allocated string. Use pyds.get_string() to get the string content.
py_nvosd_text_params.display_text = "Frame Number={} Number of Objects={} Vehicle_count={} Person_count={}".format(frame_number, num_rects, obj_counter[PGIE_CLASS_ID_VEHICLE], obj_counter[PGIE_CLASS_ID_PERSON])
# Now set the offsets where the string should appear
py_nvosd_text_params.x_offset = 10
py_nvosd_text_params.y_offset = 12
# Font , font-color and font-size
py_nvosd_text_params.font_params.font_name = "Serif"
py_nvosd_text_params.font_params.font_size = 10
# set(red, green, blue, alpha); set to White
py_nvosd_text_params.font_params.font_color.set(1.0, 1.0, 1.0, 1.0)
# Text background color
py_nvosd_text_params.set_bg_clr = 1
# set(red, green, blue, alpha); set to Black
py_nvosd_text_params.text_bg_clr.set(0.0, 0.0, 0.0, 1.0)
# Using pyds.get_string() to get display_text as string
print(pyds.get_string(py_nvosd_text_params.display_text))
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
try:
l_frame=l_frame.next
except StopIteration:
break
#past traking meta data
if(past_tracking_meta[0]==1):
l_user=batch_meta.batch_user_meta_list
while l_user is not None:
try:
# Note that l_user.data needs a cast to pyds.NvDsUserMeta
# The casting is done by pyds.NvDsUserMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone
user_meta=pyds.NvDsUserMeta.cast(l_user.data)
except StopIteration:
break
if(user_meta and user_meta.base_meta.meta_type==pyds.NvDsMetaType.NVDS_TRACKER_PAST_FRAME_META):
try:
# Note that user_meta.user_meta_data needs a cast to pyds.NvDsPastFrameObjBatch
# The casting is done by pyds.NvDsPastFrameObjBatch.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone
pPastFrameObjBatch = pyds.NvDsPastFrameObjBatch.cast(user_meta.user_meta_data)
except StopIteration:
break
for trackobj in pyds.NvDsPastFrameObjBatch.list(pPastFrameObjBatch):
print("streamId=",trackobj.streamID)
print("surfaceStreamID=",trackobj.surfaceStreamID)
for pastframeobj in pyds.NvDsPastFrameObjStream.list(trackobj):
print("numobj=",pastframeobj.numObj)
print("uniqueId=",pastframeobj.uniqueId)
print("classId=",pastframeobj.classId)
print("objLabel=",pastframeobj.objLabel)
for objlist in pyds.NvDsPastFrameObjList.list(pastframeobj):
print('frameNum:', objlist.frameNum)
print('tBbox.left:', objlist.tBbox.left)
print('tBbox.width:', objlist.tBbox.width)
print('tBbox.top:', objlist.tBbox.top)
print('tBbox.right:', objlist.tBbox.height)
print('confidence:', objlist.confidence)
print('age:', objlist.age)
try:
l_user=l_user.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def tiler_src_pad_buffer_probe(pad, info, u_data):
frame_number = 0
num_rects = 0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
'''
print("Frame Number is ", frame_meta.frame_num)
print("Source id is ", frame_meta.source_id)
print("Batch id is ", frame_meta.batch_id)
print("Source Frame Width ", frame_meta.source_frame_width)
print("Source Frame Height ", frame_meta.source_frame_height)
print("Num object meta ", frame_meta.num_obj_meta)
'''
frame_number = frame_meta.frame_num
l_obj = frame_meta.obj_meta_list
num_rects = frame_meta.num_obj_meta
obj_counter = {
PGIE_CLASS_ID_VEHICLE: 0,
PGIE_CLASS_ID_PERSON: 0,
PGIE_CLASS_ID_BICYCLE: 0,
PGIE_CLASS_ID_ROADSIGN: 0
}
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
try:
l_obj = l_obj.next
except StopIteration:
break
"""display_meta=pyds.nvds_acquire_display_meta_from_pool(batch_meta)
display_meta.num_labels = 1
py_nvosd_text_params = display_meta.text_params[0]
py_nvosd_text_params.display_text = "Frame Number={} Number of Objects={} Vehicle_count={}
Person_count={}".format(frame_number, num_rects, vehicle_count, person)
py_nvosd_text_params.x_offset = 10;
py_nvosd_text_params.y_offset = 12;
py_nvosd_text_params.font_params.font_name = "Serif"
py_nvosd_text_params.font_params.font_size = 10
py_nvosd_text_params.font_params.font_color.red = 1.0
py_nvosd_text_params.font_params.font_color.green = 1.0
py_nvosd_text_params.font_params.font_color.blue = 1.0
py_nvosd_text_params.font_params.font_color.alpha = 1.0
py_nvosd_text_params.set_bg_clr = 1
py_nvosd_text_params.text_bg_clr.red = 0.0
py_nvosd_text_params.text_bg_clr.green = 0.0
py_nvosd_text_params.text_bg_clr.blue = 0.0
py_nvosd_text_params.text_bg_clr.alpha = 1.0
#print("Frame Number=", frame_number, "Number of Objects=",num_rects,"Vehicle_count=",vehicle_count,
"Person_count=",person)
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)"""
print("Frame Number=", frame_number, "Number of Objects=", num_rects,
"Vehicle_count=", obj_counter[PGIE_CLASS_ID_VEHICLE],
"Person_count=", obj_counter[PGIE_CLASS_ID_PERSON])
# Get frame rate through this probe
fps_streams["stream{0}".format(frame_meta.pad_index)].get_fps()
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def sgie_sink_pad_buffer_probe(pad, info, u_data):
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number = frame_meta.frame_num
num_rects = frame_meta.num_obj_meta
l_obj = frame_meta.obj_meta_list
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
l_user = obj_meta.obj_user_meta_list
print(f'obj_meta.obj_user_meta_list {l_user}')
# while l_user is not None:
# print('Inside l_user = obj_meta.obj_user_meta_list Loop')
# try:
# # Casting l_obj.data to pyds.NvDsObjectMeta
# user_meta=pyds.NvDsUserMeta.cast(l_user.data)
# except StopIteration:
# break
# if (
# user_meta.base_meta.meta_type
# != pyds.NvDsMetaType.NVDSINFER_TENSOR_OUTPUT_META
# ):
# continue
# tensor_meta = pyds.NvDsInferTensorMeta.cast(user_meta.user_meta_data)
# # Boxes in the tensor meta should be in network resolution which is
# # found in tensor_meta.network_info. Use this info to scale boxes to
# # the input frame resolution.
# layers_info = []
# for i in range(tensor_meta.num_output_layers):
# layer = pyds.get_nvds_LayerInfo(tensor_meta, i)
# layers_info.append(layer)
# print(f'Layer: {i}, Layer name: {layer.layerName}')
# try:
# l_user = l_user.next
# except StopIteration:
# break
try:
l_obj = l_obj.next
except StopIteration:
break
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def overlay_display_type(self, gst_buffer, client_data):
# cast the C void* client_data back to a py_object pointer and deref
meta_data = cast(client_data, POINTER(py_object)).contents.value
meta_data.mutex.acquire()
frame_number = 0
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
if meta_data.active_display_type is not None:
display_meta = pyds.nvds_acquire_display_meta_from_pool(
batch_meta)
display_meta.num_lines = 0
display_meta.num_rects = 0
if 'Line' in meta_data.active_display_type:
line = meta_data.active_display_type['Line']
py_nvosd_line_params = display_meta.line_params[
display_meta.num_lines]
display_meta.num_lines += 1
py_nvosd_line_params = line.copy(py_nvosd_line_params)
elif 'Polygon' in meta_data.active_display_type:
lines = meta_data.active_display_type['Polygon']
for line in lines:
if line:
py_nvosd_line_params = display_meta.line_params[
display_meta.num_lines]
display_meta.num_lines += 1
py_nvosd_line_params = line.copy(
py_nvosd_line_params)
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
try:
l_frame = l_frame.next
except StopIteration:
break
meta_data.mutex.release()
return True
def sink_pad_buffer_probe(pad, info, u_data):
gst_buffer = info.get_buffer()
if not gst_buffer:
sys.stderr.write("Unable to get GstBuffer")
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
frame_list = batch_meta.frame_meta_list
while frame_list is not None:
try:
frame_meta = pyds.NvDsFrameMeta.cast(frame_list.data)
except StopIteration:
break
list_of_objects = frame_meta.obj_meta_list
while list_of_objects is not None:
try:
object_meta = pyds.NvDsObjectMeta.cast(list_of_objects.data)
# https://docs.nvidia.com/metropolis/deepstream/5.0DP/python-api/NvDsMeta/NvDsObjectMeta.html
if object_meta.object_id not in detectedObjectsIds:
t = time.localtime()
current_time = time.strftime("%H:%M:%S", t)
detectedObjectsIds.append(object_meta.object_id)
detectedObjects.append({
'id':
str(object_meta.object_id),
'label':
str(object_meta.obj_label),
'time':
current_time,
'confidence':
str(object_meta.confidence)
})
except StopIteration:
break
# obj_counter[object_meta.class_id] += 1
try:
list_of_objects = list_of_objects.next
except StopIteration:
break
try:
frame_list = frame_list.next
except StopIteration:
break
display_meta = pyds.nvds_acquire_display_meta_from_pool(batch_meta)
display_meta.num_labels = 1
py_nvosd_text_params = display_meta.text_params[0]
textDisplay = "DETECTED OBJECTS:\n\n"
if len(detectedObjects) > 10:
detectedObjectsList = detectedObjects[-10]
else:
detectedObjectsList = detectedObjects
for _object in detectedObjectsList:
textDisplay = textDisplay + _object[
"time"] + ": Detected: \"" + _object[
"label"] + "\", ID: " + _object[
"id"] + ", Confidence: " + _object["confidence"] + "\n"
print(textDisplay)
py_nvosd_text_params.display_text = textDisplay
py_nvosd_text_params.x_offset = 10
py_nvosd_text_params.y_offset = 12
py_nvosd_text_params.font_params.font_name = "Serif"
py_nvosd_text_params.font_params.font_size = 10
py_nvosd_text_params.font_params.font_color.set(1.0, 1.0, 1.0, 1.0)
py_nvosd_text_params.set_bg_clr = 1
py_nvosd_text_params.text_bg_clr.set(0.0, 0.0, 0.0, 1.0)
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
return Gst.PadProbeReturn.OK
def sgie_sink_pad_buffer_probe(pad, info, u_data):
frame_number = 0
num_rects = 0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number = frame_meta.frame_num
num_rects = frame_meta.num_obj_meta
l_obj = frame_meta.obj_meta_list
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
l_user = obj_meta.obj_user_meta_list
# if obj_meta.class_id == SGIE_CLASS_ID_FACE:
# print(f'obj_meta.obj_user_meta_list {l_user}')
while l_user is not None:
try:
# Casting l_user.data to pyds.NvDsUserMeta
user_meta = pyds.NvDsUserMeta.cast(l_user.data)
except StopIteration:
break
if (user_meta.base_meta.meta_type !=
pyds.NvDsMetaType.NVDSINFER_TENSOR_OUTPUT_META):
continue
# Converting to tensor metadata
# Casting user_meta.user_meta_data to NvDsInferTensorMeta
tensor_meta = pyds.NvDsInferTensorMeta.cast(
user_meta.user_meta_data)
# Get output layer as NvDsInferLayerInfo
layer = pyds.get_nvds_LayerInfo(tensor_meta, 0)
# Convert NvDsInferLayerInfo buffer to numpy array
ptr = ctypes.cast(pyds.get_ptr(layer.buffer),
ctypes.POINTER(ctypes.c_float))
v = np.ctypeslib.as_array(ptr, shape=(128, ))
# Pridict face neme
yhat = v.reshape((1, -1))
face_to_predict_embedding = normalize_vectors(yhat)
result = predict_using_classifier(faces_embeddings, labels,
face_to_predict_embedding)
result = (str(result).title())
# print('Predicted name: %s' % result)
# Generate classifer metadata and attach to obj_meta
# Get NvDsClassifierMeta object
classifier_meta = pyds.nvds_acquire_classifier_meta_from_pool(
batch_meta)
# Pobulate classifier_meta data with pridction result
classifier_meta.unique_component_id = tensor_meta.unique_id
label_info = pyds.nvds_acquire_label_info_meta_from_pool(
batch_meta)
label_info.result_prob = 0
label_info.result_class_id = 0
pyds.nvds_add_label_info_meta_to_classifier(
classifier_meta, label_info)
pyds.nvds_add_classifier_meta_to_object(
obj_meta, classifier_meta)
display_text = pyds.get_string(
obj_meta.text_params.display_text)
obj_meta.text_params.display_text = f'{display_text} {result}'
try:
l_user = l_user.next
except StopIteration:
break
try:
l_obj = l_obj.next
except StopIteration:
break
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def tiler_src_pad_buffer_probe(pad, info, u_data):
frame_number = 0
num_rects = 0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
'''
print("Frame Number is ", frame_meta.frame_num)
print("Source id is ", frame_meta.source_id)
print("Batch id is ", frame_meta.batch_id)
print("Source Frame Width ", frame_meta.source_frame_width)
print("Source Frame Height ", frame_meta.source_frame_height)
print("Num object meta ", frame_meta.num_obj_meta)
'''
frame_number = frame_meta.frame_num
l_obj = frame_meta.obj_meta_list
bboxes = []
classids = []
num_rects = frame_meta.num_obj_meta
obj_counter = {
PGIE_CLASS_ID_VEHICLE: 0,
PGIE_CLASS_ID_PERSON: 0,
PGIE_CLASS_ID_BICYCLE: 0,
PGIE_CLASS_ID_ROADSIGN: 0
}
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
bos = np.array([
int(obj_meta.rect_params.left),
int(obj_meta.rect_params.top),
int(obj_meta.rect_params.left + obj_meta.rect_params.width),
int(obj_meta.rect_params.top + obj_meta.rect_params.height)
])
bboxes.append(bos.astype("int"))
classids.append(obj_meta.class_id)
try:
l_obj = l_obj.next
except StopIteration:
break
boxes_dic[frame_meta.source_id] = bboxes
frameTime = int(datetime.now().timestamp())
if tracker_status == 1:
counter, counts, trackers = trackers_list[
frame_meta.source_id].detectandkalmtrack(
boxes_dic[frame_meta.source_id],
classids,
frameTime=frameTime)
for index, values in counts.items():
counters = list(values.keys())
#print(f' This {frame_meta.source_id + 1} Tracker {classes[index]} -- {counters[0]} ----{str(values["inCount"])} ------ {counters[1]}---- {str(values["outCount"])}')
"""display_meta=pyds.nvds_acquire_display_meta_from_pool(batch_meta)
display_meta.num_labels = 1
py_nvosd_text_params = display_meta.text_params[0]
py_nvosd_text_params.display_text = "Frame Number={} Number of Objects={} Vehicle_count={} Person_count={}".format(frame_number, num_rects, vehicle_count, person)
py_nvosd_text_params.x_offset = 10;
py_nvosd_text_params.y_offset = 12;
py_nvosd_text_params.font_params.font_name = "Serif"
py_nvosd_text_params.font_params.font_size = 10
py_nvosd_text_params.font_params.font_color.red = 1.0
py_nvosd_text_params.font_params.font_color.green = 1.0
py_nvosd_text_params.font_params.font_color.blue = 1.0
py_nvosd_text_params.font_params.font_color.alpha = 1.0
py_nvosd_text_params.set_bg_clr = 1
py_nvosd_text_params.text_bg_clr.red = 0.0
py_nvosd_text_params.text_bg_clr.green = 0.0
py_nvosd_text_params.text_bg_clr.blue = 0.0
py_nvosd_text_params.text_bg_clr.alpha = 1.0
#print("Frame Number=", frame_number, "Number of Objects=",num_rects,"Vehicle_count=",vehicle_count,"Person_count=",person)
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)"""
#print("Frame Number=", frame_number, "Number of Objects=",num_rects,"Vehicle_count=",obj_counter[PGIE_CLASS_ID_VEHICLE],"Person_count=",obj_counter[PGIE_CLASS_ID_PERSON])
framenumber = 0
display_meta = pyds.nvds_acquire_display_meta_from_pool(batch_meta)
x1, y1, x2, y2, x3, y3, x4, y4 = Roi_points_list[frame_meta.source_id]
line_params = display_meta.line_params[framenumber]
framenumber += 1
line_params.x1 = x1
line_params.y1 = y1
line_params.x2 = x2
line_params.y2 = y2
line_params.line_width = 4
line_params.line_color.red = 1.0
line_params.line_color.green = 1.0
line_params.line_color.blue = 0.0
line_params.line_color.alpha = 0.7
display_meta.num_lines = display_meta.num_lines + 1
line_params = display_meta.line_params[framenumber]
framenumber += 1
line_params.x1 = x2
line_params.y1 = y2
line_params.x2 = x3
line_params.y2 = y3
line_params.line_width = 4
line_params.line_color.red = 1.0
line_params.line_color.green = 1.0
line_params.line_color.blue = 0.0
line_params.line_color.alpha = 0.7
display_meta.num_lines = display_meta.num_lines + 1
line_params = display_meta.line_params[framenumber]
framenumber += 1
line_params.x1 = x3
line_params.y1 = y3
line_params.x2 = x4
line_params.y2 = y4
line_params.line_width = 4
line_params.line_color.red = 1.0
line_params.line_color.green = 1.0
line_params.line_color.blue = 0.0
line_params.line_color.alpha = 0.7
display_meta.num_lines = display_meta.num_lines + 1
line_params = display_meta.line_params[framenumber]
framenumber += 1
line_params.x1 = x4
line_params.y1 = y4
line_params.x2 = x1
line_params.y2 = y1
line_params.line_width = 4
line_params.line_color.red = 1.0
line_params.line_color.green = 1.0
line_params.line_color.blue = 0.0
line_params.line_color.alpha = 0.7
display_meta.num_lines = display_meta.num_lines + 1
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
# Get frame rate through this probe
fps_streams["stream{0}".format(frame_meta.pad_index)].get_fps()
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def tiler_sink_pad_buffer_probe(pad, info, u_data):
frame_number = 0
num_rects = 0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number = frame_meta.frame_num
l_obj = frame_meta.obj_meta_list
num_rects = frame_meta.num_obj_meta
is_first_obj = True
save_image = False
obj_counter = {
PGIE_CLASS_ID_PERSON: 0,
PGIE_CLASS_ID_BAG: 0,
PGIE_CLASS_ID_FACE: 0
}
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
# osd_rect_params = pyds.NvOSD_RectParams.cast(obj_meta.rect_params)
# Draw black patch to cover faces (class_id = 2), can change to other colors
if (obj_meta.class_id == PGIE_CLASS_ID_FACE):
obj_meta.rect_params.border_width = 0
obj_meta.rect_params.has_bg_color = 1
obj_meta.rect_params.bg_color.red = 0.0
obj_meta.rect_params.bg_color.green = 0.0
obj_meta.rect_params.bg_color.blue = 0.0
obj_meta.rect_params.bg_color.alpha = 1.0
elif (obj_meta.class_id == PGIE_CLASS_ID_PERSON ) :
obj_meta.rect_params.border_width = 0
obj_meta.rect_params.has_bg_color = 1
obj_meta.rect_params.bg_color.red = 0.0
obj_meta.rect_params.bg_color.green = 0.0
obj_meta.rect_params.bg_color.blue = 0.0
obj_meta.rect_params.bg_color.alpha = 0.5
# Periodically check for objects and save the annotated object to file.
if saved_count["stream_{}".format(frame_meta.pad_index)] % 10 == 0 and obj_meta.class_id == PGIE_CLASS_ID_FACE :
if is_first_obj:
is_first_obj = False
# Getting Image data using nvbufsurface
# the input should be address of buffer and batch_id
n_frame = pyds.get_nvds_buf_surface(hash(gst_buffer), frame_meta.batch_id)
n_frame = crop_object(n_frame, obj_meta)
# convert python array into numpy array format in the copy mode.
frame_copy = np.array(n_frame, copy=True, order='C')
# convert the array into cv2 default color format
frame_copy = cv2.cvtColor(frame_copy, cv2.COLOR_RGBA2BGRA)
save_image = True
try:
l_obj = l_obj.next
except StopIteration:
break
print("Frame Number=", frame_number, "Number of Objects=", num_rects, "Face_count=",
obj_counter[PGIE_CLASS_ID_FACE], "Person_count=", obj_counter[PGIE_CLASS_ID_PERSON])
# Get frame rate through this probe
fps_streams["stream{0}".format(frame_meta.pad_index)].get_fps()
if save_image:
img_path = "{}/stream_{}/frame_{}.jpg".format(folder_name, frame_meta.pad_index, frame_number)
cv2.imwrite(img_path, frame_copy)
saved_count["stream_{}".format(frame_meta.pad_index)] += 1
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def src_pad_buffer_probe(pad, info, u_data):
#Intiallizing object counter with 0.
obj_counter = {
PGIE_CLASS_ID_VEHICLE: 0,
PGIE_CLASS_ID_PERSON: 0,
PGIE_CLASS_ID_BICYCLE: 0,
PGIE_CLASS_ID_ROADSIGN: 0
}
# Set frame_number & rectangles to draw as 0
frame_number = 0
num_rects = 0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
# Get frame number , number of rectables to draw and object metadata
frame_number = frame_meta.frame_num
num_rects = frame_meta.num_obj_meta
l_obj = frame_meta.obj_meta_list
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
# Increment Object class by 1
obj_counter[obj_meta.class_id] += 1
try:
l_obj = l_obj.next
except StopIteration:
break
print(
"Frame Number={} Number of Objects={} Vehicle_count={} Person_count={}"
.format(frame_number, num_rects,
obj_counter[PGIE_CLASS_ID_VEHICLE],
obj_counter[PGIE_CLASS_ID_PERSON]))
# FPS Probe
fps_streams_new["stream{0}".format(frame_meta.pad_index)].get_fps()
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def tiler_src_pad_buffer_probe(pad, info, u_data):
# Intiallizing object counter with 0.
obj_counter = {
PGIE_CLASS_ID_VEHICLE: 0,
PGIE_CLASS_ID_PERSON: 0,
PGIE_CLASS_ID_BICYCLE: 0,
PGIE_CLASS_ID_ROADSIGN: 0
}
frame_number = 0
num_rects = 0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
previous = service.get_previous()
while l_frame is not None:
try:
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number = frame_meta.frame_num
service.set_frame_counter(frame_number)
l_obj = frame_meta.obj_meta_list
num_rects = frame_meta.num_obj_meta
ids = []
boxes = []
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
x = obj_meta.rect_params.left
y = obj_meta.rect_params.top
obj_id = obj_meta.object_id
# Service Aforo (in and out)
ids.append(obj_id)
boxes.append((x, y))
# service.counting_in_and_out_first_detection((x, y), obj_id) In and out counting when the object finally desapears
service.counting_in_and_out_when_changing_area((x, y), obj_id, ids,
previous)
# Service People counting
if previous:
service.people_counting_last_time_detected(ids)
service.people_counting_storing_fist_time(obj_id)
try:
l_obj = l_obj.next
except StopIteration:
break
# Service Social Distance
if previous:
service.get_distances_between_detected_elements_from_centroid(
boxes, ids)
if not service.get_previous():
service.set_previous(True)
previous = service.get_previous()
# Service Aforo (in and out)
# service.count_in_and_out_when_object_leaves_the_frame(ids) In and out counting when the object finally desapears
display_meta = pyds.nvds_acquire_display_meta_from_pool(batch_meta)
display_meta.num_labels = 1
py_nvosd_text_params = display_meta.text_params[0]
fps_streams["stream{0}".format(frame_meta.pad_index)].get_fps()
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def osd_sink_pad_buffer_probe(pad, info, u_data):
# Intiallizing object counter with 0.
obj_counter = {
PGIE_CLASS_ID_VEHICLE: 0,
PGIE_CLASS_ID_PERSON: 0,
PGIE_CLASS_ID_BICYCLE: 0,
PGIE_CLASS_ID_ROADSIGN: 0
}
frame_number = 0
num_rects = 0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
previous = pc.get_previous()
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number = frame_meta.frame_num
pc.set_frame_counter(frame_number)
l_obj = frame_meta.obj_meta_list
num_rects = frame_meta.num_obj_meta
ids = []
boxes = []
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
x = obj_meta.rect_params.left
y = obj_meta.rect_params.top
obj_id = obj_meta.object_id
# Service Aforo (in and out)
pc.counting_in_and_out_first_detection((x, y), obj_id)
ids.append(obj_id)
boxes.append((x, y))
# Service People counting
if previous:
pc.people_counting_last_time_detected(ids)
pc.people_counting_storing_fist_time(obj_id)
try:
l_obj = l_obj.next
except StopIteration:
break
# Service Social Distance
if previous:
pc.get_distances_between_detected_elements_from_centroid(boxes, ids)
pc.set_previous(True)
previous = pc.get_previous()
# Service Aforo (in and out)
pc.count_in_and_out_when_object_leaves_the_frame(ids)
# Acquiring a display meta object. The memory ownership remains in
# the C code so downstream plugins can still access it. Otherwise
# the garbage collector will claim it when this probe function exits.
display_meta = pyds.nvds_acquire_display_meta_from_pool(batch_meta)
display_meta.num_labels = 1
py_nvosd_text_params = display_meta.text_params[0]
# Setting display text to be shown on screen
# Note that the pyds module allocates a buffer for the string, and the
# memory will not be claimed by the garbage collector.
# Reading the display_text field here will return the C address of the
# allocated string. Use pyds.get_string() to get the string content.
py_nvosd_text_params.display_text = \
"Frame Number={} Number of Objects={} Vehicle_count={} Person_count={}"\
.format(frame_number, num_rects, obj_counter[PGIE_CLASS_ID_VEHICLE], obj_counter[PGIE_CLASS_ID_PERSON])
# Now set the offsets where the string should appear
py_nvosd_text_params.x_offset = 10
py_nvosd_text_params.y_offset = 12
# Font , font-color and font-size
py_nvosd_text_params.font_params.font_name = "Serif"
py_nvosd_text_params.font_params.font_size = 10
# set(red, green, blue, alpha); set to White
py_nvosd_text_params.font_params.font_color.set(1.0, 1.0, 1.0, 1.0)
# Text background color
py_nvosd_text_params.set_bg_clr = 1
# set(red, green, blue, alpha); set to Black
py_nvosd_text_params.text_bg_clr.set(0.0, 0.0, 0.0, 1.0)
# Using pyds.get_string() to get display_text as string
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
# Get frame rate through this probe
# fps_streams["stream{0}".format(frame_meta.pad_index)].get_fps()
# try:
# l_frame = l_frame.next
# except StopIteration:
# break
return Gst.PadProbeReturn.OK
def seg_src_pad_buffer_probe(pad, info, u_data):
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number = frame_meta.frame_num
l_user = frame_meta.frame_user_meta_list
while l_user is not None:
try:
# Note that l_user.data needs a cast to pyds.NvDsUserMeta
# The casting is done by pyds.NvDsUserMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
seg_user_meta = pyds.NvDsUserMeta.cast(l_user.data)
except StopIteration:
break
if seg_user_meta and seg_user_meta.base_meta.meta_type == \
pyds.NVDSINFER_SEGMENTATION_META:
try:
# Note that seg_user_meta.user_meta_data needs a cast to
# pyds.NvDsInferSegmentationMeta
# The casting is done by pyds.NvDsInferSegmentationMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
segmeta = pyds.NvDsInferSegmentationMeta.cast(seg_user_meta.user_meta_data)
except StopIteration:
break
# Retrieve mask data in the numpy format from segmeta
# Note that pyds.get_segmentation_masks() expects object of
# type NvDsInferSegmentationMeta
masks = pyds.get_segmentation_masks(segmeta)
masks = np.array(masks, copy=True, order='C')
# map the obtained masks to colors of 2 classes.
frame_image = map_mask_as_display_bgr(masks)
cv2.imwrite(folder_name + "/" + str(frame_number) + ".jpg", frame_image)
try:
l_user = l_user.next
except StopIteration:
break
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def tiler_sink_pad_buffer_probe(pad, info, u_data):
frame_number = 0
num_rects = 0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number = frame_meta.frame_num
l_obj = frame_meta.obj_meta_list
num_rects = frame_meta.num_obj_meta
is_first_obj = True
save_image = False
obj_counter = {
PGIE_CLASS_ID_VEHICLE: 0,
PGIE_CLASS_ID_PERSON: 0,
PGIE_CLASS_ID_BICYCLE: 0,
PGIE_CLASS_ID_ROADSIGN: 0
}
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
# Periodically check for objects with borderline confidence value that may be false positive detections.
# If such detections are found, annoate the frame with bboxes and confidence value.
# Save the annotated frame to file.
if ((saved_count["stream_" + str(frame_meta.pad_index)] % 30 == 0)
and
(obj_meta.confidence > 0.3 and obj_meta.confidence < 0.31)):
if is_first_obj:
is_first_obj = False
# Getting Image data using nvbufsurface
# the input should be address of buffer and batch_id
n_frame = pyds.get_nvds_buf_surface(
hash(gst_buffer), frame_meta.batch_id)
#convert python array into numy array format.
frame_image = np.array(n_frame, copy=True, order='C')
#covert the array into cv2 default color format
frame_image = cv2.cvtColor(frame_image,
cv2.COLOR_RGBA2BGRA)
save_image = True
frame_image = draw_bounding_boxes(frame_image, obj_meta,
obj_meta.confidence)
try:
l_obj = l_obj.next
except StopIteration:
break
print("Frame Number=", frame_number, "Number of Objects=", num_rects,
"Vehicle_count=", obj_counter[PGIE_CLASS_ID_VEHICLE],
"Person_count=", obj_counter[PGIE_CLASS_ID_PERSON])
# Get frame rate through this probe
fps_streams["stream{0}".format(frame_meta.pad_index)].get_fps()
if save_image:
cv2.imwrite(
folder_name + "/stream_" + str(frame_meta.pad_index) +
"/frame_" + str(frame_number) + ".jpg", frame_image)
saved_count["stream_" + str(frame_meta.pad_index)] += 1
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def pgie_src_pad_buffer_probe(pad, info, u_data, label_path):
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
detection_params = DetectionParam(CLASS_NB, ACCURACY_ALL_CLASS)
box_size_param = BoxSizeParam(IMAGE_HEIGHT, IMAGE_WIDTH, MIN_BOX_WIDTH,
MIN_BOX_HEIGHT)
nms_param = NmsParam(TOP_K, IOU_THRESHOLD)
label_names = get_label_names_from_file(label_path)
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
l_user = frame_meta.frame_user_meta_list
while l_user is not None:
try:
# Note that l_user.data needs a cast to pyds.NvDsUserMeta
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
user_meta = pyds.NvDsUserMeta.cast(l_user.data)
except StopIteration:
break
if (user_meta.base_meta.meta_type !=
pyds.NvDsMetaType.NVDSINFER_TENSOR_OUTPUT_META):
continue
tensor_meta = pyds.NvDsInferTensorMeta.cast(
user_meta.user_meta_data)
# Boxes in the tensor meta should be in network resolution which is
# found in tensor_meta.network_info. Use this info to scale boxes to
# the input frame resolution.
layers_info = []
for i in range(tensor_meta.num_output_layers):
layer = pyds.get_nvds_LayerInfo(tensor_meta, i)
layers_info.append(layer)
frame_object_list = nvds_infer_parse_custom_tf_ssd(
layers_info, detection_params, box_size_param, nms_param)
try:
l_user = l_user.next
except StopIteration:
break
for frame_object in frame_object_list:
add_obj_meta_to_frame(frame_object, batch_meta, frame_meta,
label_names)
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def tiler_src_pad_buffer_probe(pad, info, u_data):
# Intiallizing object counter with 0.
# version mask detection solo reconoce mascarillas y sin mascarilla
obj_counter = {
PGIE_CLASS_ID_FACE: 0,
PGIE_CLASS_ID_PLATES: 0,
}
frame_number = 0
num_rects = 0 # numero de objetos en el frame
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
#====================== Definicion de valores de mensajes a pantalla
display_meta = pyds.nvds_acquire_display_meta_from_pool(batch_meta)
current_pad_index = pyds.NvDsFrameMeta.cast(l_frame.data).pad_index
camera_id = get_camera_id(current_pad_index)
#aforo_info = get_aforo(camera_id)
#is_aforo_enabled = aforo_info['enabled']
#social_distance_info = get_social_distance(camera_id)
#is_social_distance_enabled = social_distance_info['enabled']
#people_counting_info = get_people_counting(camera_id)
#is_people_counting_enabled = people_counting_info['enabled']
# Falta el servicio de Plates Detection
#
#
#print( "entro al tiler_src_pad_buffer_probe")
# Todos los servicios requieren impresion de texto solo para Aforo se requiere una linea y un rectangulo
display_meta.num_labels = 1 # numero de textos
py_nvosd_text_params = display_meta.text_params[0]
# Setup del label de impresion en pantalla
py_nvosd_text_params.x_offset = 100
py_nvosd_text_params.y_offset = 120
py_nvosd_text_params.font_params.font_name = "Arial"
py_nvosd_text_params.font_params.font_size = 10
py_nvosd_text_params.font_params.font_color.red = 1.0
py_nvosd_text_params.font_params.font_color.green = 1.0
py_nvosd_text_params.font_params.font_color.blue = 1.0
py_nvosd_text_params.font_params.font_color.alpha = 1.0
py_nvosd_text_params.set_bg_clr = 1
py_nvosd_text_params.text_bg_clr.red = 0.0
py_nvosd_text_params.text_bg_clr.green = 0.0
py_nvosd_text_params.text_bg_clr.blue = 0.0
py_nvosd_text_params.text_bg_clr.alpha = 1.0
#no_mask_ids = get_no_mask_ids_dict(camera_id)
# por que ponerlo en 1 ????
#frame_number = 1 # to avoid not definition issue
client = boto3.client('rekognition')
while l_frame is not None:
try:
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
#print( "primer ciclo")
frame_number = frame_meta.frame_num
#print(" fps:",frame_meta.num_surface_per_frame)
l_obj = frame_meta.obj_meta_list
num_rects = frame_meta.num_obj_meta
is_first_obj = True
save_image = False
#print(num_rects) ID numero de stream
ids = set()
# Ciclo interno donde se evaluan los objetos dentro del frame
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
#print(obj_meta.confidence," ",obj_meta.object_id)
#print(obj_counter[obj_meta.class_id]," ",obj_counter[obj_meta.class_id]%5)
# and (obj_meta.confidence > 0.9 )
print(frame_number)
if ((obj_meta.class_id == 1) and (frame_number % 8 == 0)):
if is_first_obj:
is_first_obj = False
# Getting Image data using nvbufsurface
# the input should be address of buffer and batch_id
n_frame = pyds.get_nvds_buf_surface(
hash(gst_buffer), frame_meta.batch_id)
#convert python array into numy array format.
frame_image = np.array(n_frame, copy=True, order='C')
#covert the array into cv2 default color format
frame_image = cv2.cvtColor(frame_image,
cv2.COLOR_RGBA2BGRA)
save_image = True
frame_image = draw_bounding_boxes(frame_image, obj_meta,
obj_meta.confidence)
response = client.detect_labels(Image={'Bytes': frame_image})
print('Detected labels in ')
for label in response['Labels']:
print(label['Name'] + ' : ' + str(label['Confidence']))
#py_nvosd_text_params.display_text = "Frame Number={} Number of Objects={} Mask={} NoMaks={}".format(frame_number, num_rects, obj_counter[PGIE_CLASS_ID_FACE], obj_counter[PGIE_CLASS_ID_PLATES])
try:
l_obj = l_obj.next
except StopIteration:
break
#pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
fps_streams["stream{0}".format(frame_meta.pad_index)].get_fps()
#print(save_image)
#print(folder_name)
if save_image:
print("Entre a guardar imagen")
print(obj_meta.class_id)
cv2.imwrite(
folder_name + "/stream_" + str(frame_meta.pad_index) +
"/frame_" + str(frame_number) + ".jpg", frame_image)
saved_count["stream_" + str(frame_meta.pad_index)] += 1
try:
l_frame = l_frame.next
except StopIteration:
break
'''
if frame_number % 43 == 0:
new_dict = {}
no_mask_ids = get_no_mask_ids_dict(camera_id)
for item in ids:
if item in no_mask_ids:
value = no_mask_ids[item]
new_dict.update({item: value})
set_no_mask_ids_dict(camera_id, new_dict)
# Lo manda a directo streaming
'''
return Gst.PadProbeReturn.OK
def osd_sink_pad_buffer_probe(pad, info, u_datat, label_path):
frame_number = 0
# Intiallizing object counter with 0.
obj_counter = dict(enumerate([0] * CLASS_NB))
num_rects = 0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number = frame_meta.frame_num
num_rects = frame_meta.num_obj_meta
l_obj = frame_meta.obj_meta_list
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
try:
l_obj = l_obj.next
except StopIteration:
break
# Acquiring a display meta object. The memory ownership remains in
# the C code so downstream plugins can still access it. Otherwise
# the garbage collector will claim it when this probe function exits.
display_meta = pyds.nvds_acquire_display_meta_from_pool(batch_meta)
display_meta.num_labels = 1
py_nvosd_text_params = display_meta.text_params[0]
# Setting display text to be shown on screen
# Note that the pyds module allocates a buffer for the string, and the
# memory will not be claimed by the garbage collector.
# Reading the display_text field here will return the C address of the
# allocated string. Use pyds.get_string() to get the string content.
id_dict = {
val: index
for index, val in enumerate(get_label_names_from_file(label_path))
}
disp_string = "Frame Number={} Number of Objects={} Person_count={}"
py_nvosd_text_params.display_text = disp_string.format(
frame_number, num_rects, obj_counter[id_dict["person"]])
# Now set the offsets where the string should appear
py_nvosd_text_params.x_offset = 10
py_nvosd_text_params.y_offset = 12
# Font , font-color and font-size
py_nvosd_text_params.font_params.font_name = "Serif"
py_nvosd_text_params.font_params.font_size = 10
# set(red, green, blue, alpha); set to White
py_nvosd_text_params.font_params.font_color.set(1.0, 1.0, 1.0, 1.0)
# Text background color
py_nvosd_text_params.set_bg_clr = 1
# set(red, green, blue, alpha); set to Black
py_nvosd_text_params.text_bg_clr.set(0.0, 0.0, 0.0, 1.0)
# Using pyds.get_string() to get display_text as string
print(pyds.get_string(py_nvosd_text_params.display_text))
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
fps_streams["stream{0}".format(frame_meta.pad_index)].get_fps()
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def get_lva_MediaStreamMessage(self, buffer, gst_lva_message, ih, iw): msg = extension_pb2.MediaStreamMessage() msg.ack_sequence_number = gst_lva_message.sequence_number msg.media_sample.timestamp = gst_lva_message.timestamp # # Retrieve batch metadata from the gst_buffer # # Note that pyds.gst_buffer_get_nvds_batch_meta() expects the # # C address of gst_buffer as input, which is obtained with hash(gst_buffer) batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(buffer)) frame = batch_meta.frame_meta_list while frame is not None: try: # Note that frame.data needs a cast to pyds.NvDsFrameMeta # The casting is done by pyds.NvDsFrameMeta.cast() # The casting also keeps ownership of the underlying memory # in the C code, so the Python garbage collector will leave # it alone. frame_meta = pyds.NvDsFrameMeta.cast(frame.data) objInference = frame_meta.obj_meta_list frameWidth = frame_meta.source_frame_width frameHeight = frame_meta.source_frame_height # iterate through objects while objInference is not None: try: # Casting objInference.data to pyds.NvDsObjectMeta obj_meta=pyds.NvDsObjectMeta.cast(objInference.data) except StopIteration: break inference = msg.media_sample.inferences.add() attributes = [] obj_label = None obj_confidence = 0 obj_left = 0 obj_width = 0 obj_top = 0 obj_width = 0 color = '' # Classification attribute = None if(obj_meta.class_id == 0 and obj_meta.classifier_meta_list is not None): classifier_meta = obj_meta.classifier_meta_list while classifier_meta is not None: classifierItem = pyds.NvDsClassifierMeta.cast(classifier_meta.data) if(classifierItem is not None): label_meta = classifierItem.label_info_list while label_meta is not None: labelItem = pyds.NvDsLabelInfo.cast(label_meta.data) prob = round(labelItem.result_prob, 2) attrValue = labelItem.result_label attrName = 'unknown' if(classifierItem.unique_component_id == PGIE_CLASS_ID_VEHICLE_COLOR): attrName = 'color' else: attrName = 'type' attributes.append([attrName, attrValue, prob]) try: label_meta=label_meta.next except StopIteration: break try: classifier_meta=classifier_meta.next except StopIteration: break rect_params=obj_meta.rect_params top=int(rect_params.top) left=int(rect_params.left) width=int(rect_params.width) height=int(rect_params.height) obj_confidence = obj_meta.confidence obj_label = obj_meta.obj_label obj_left = left / iw obj_top = top / ih obj_width = width/ iw obj_height = height / ih obj_id = None # Tracking: Active tracking bbox information if(self.trackinEnabled): obj_id = obj_meta.object_id obj_active_tracking = obj_meta.tracker_bbox_info tracking_coord = obj_active_tracking.org_bbox_coords if(tracking_coord is not None and tracking_coord.left > 0 and tracking_coord.width > 0 and tracking_coord.top > 0 and tracking_coord.height > 0): obj_left = tracking_coord.left / iw obj_top = tracking_coord.top / ih obj_width = tracking_coord.width/ iw obj_height = tracking_coord.height / ih inference.type = inferencing_pb2.Inference.InferenceType.ENTITY if obj_label is not None: try: entity = inferencing_pb2.Entity( tag = inferencing_pb2.Tag( value = obj_label, confidence = obj_confidence ), box = inferencing_pb2.Rectangle( l = obj_left, t = obj_top, w = obj_width, h = obj_height ) ) if(self.trackinEnabled and obj_id is not None): entity.id = str(obj_id) for attr in attributes: attribute = inferencing_pb2.Attribute( name = attr[0], value = attr[1], confidence = attr[2] ) entity.attributes.append(attribute) except: PrintGetExceptionDetails() inference.entity.CopyFrom(entity) try: objInference=objInference.next except StopIteration: break except StopIteration: break try: frame = frame.next except StopIteration: break return msg
def tiler_src_pad_buffer_probe(pad, info, u_data):
# Intiallizing object counter with 0.
# version 2.1 solo personas
servicios_habilitados = service.emulate_reading_from_server()
#print("Valor Aforo :", servicios_habilitados[AFORO_ENT_SAL_SERVICE],servicios_habilitados[PEOPLE_COUNTING_SERVICE],servicios_habilitados[SOCIAL_DISTANCE_SERVICE])
obj_counter = {
PGIE_CLASS_ID_VEHICLE: 0,
PGIE_CLASS_ID_PERSON: 0,
PGIE_CLASS_ID_BICYCLE: 0,
PGIE_CLASS_ID_ROADSIGN: 0
}
frame_number = 0
num_rects = 0 # numero de objetos en el frame
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
previous = service.get_previous()
#====================== Definicion de valores de mensajes a pantalla
display_meta = pyds.nvds_acquire_display_meta_from_pool(batch_meta)
display_meta.num_labels = 1 # numero de textos
display_meta.num_lines = 1 # numero de lineas
display_meta.num_rects = 1 # numero de rectangulos
py_nvosd_text_params = display_meta.text_params[0]
py_nvosd_line_params = display_meta.line_params[0]
py_nvosd_rect_params = display_meta.rect_params[0]
# Setup del label de impresion en pantalla
py_nvosd_text_params.x_offset = 100
py_nvosd_text_params.y_offset = 120
py_nvosd_text_params.font_params.font_name = "Arial"
py_nvosd_text_params.font_params.font_size = 10
py_nvosd_text_params.font_params.font_color.red = 1.0
py_nvosd_text_params.font_params.font_color.green = 1.0
py_nvosd_text_params.font_params.font_color.blue = 1.0
py_nvosd_text_params.font_params.font_color.alpha = 1.0
py_nvosd_text_params.set_bg_clr = 1
py_nvosd_text_params.text_bg_clr.red = 0.0
py_nvosd_text_params.text_bg_clr.green = 0.0
py_nvosd_text_params.text_bg_clr.blue = 0.0
py_nvosd_text_params.text_bg_clr.alpha = 1.0
# Setup de la linea de Ent/Sal
# los valos de las coordenadas tienen que ser obtenidos del archivo de configuracion
# en este momento estan hardcode
py_nvosd_line_params.x1 = 510
py_nvosd_line_params.y1 = 740
py_nvosd_line_params.x2 = 1050
py_nvosd_line_params.y2 = 740
py_nvosd_line_params.line_width = 5
py_nvosd_line_params.line_color.red = 1.0
py_nvosd_line_params.line_color.green = 1.0
py_nvosd_line_params.line_color.blue = 1.0
py_nvosd_line_params.line_color.alpha = 1.0
# setup del rectangulo de Ent/Sal
# de igual manera que los parametros de linea,
# los valores del rectangulo se calculan en base a
# los valoes del archivo de configuracion
py_nvosd_rect_params.left = 500
py_nvosd_rect_params.height = 120
py_nvosd_rect_params.top = 680
py_nvosd_rect_params.width = 560
py_nvosd_rect_params.border_width = 4
py_nvosd_rect_params.border_color.red = 0.0
py_nvosd_rect_params.border_color.green = 0.0
py_nvosd_rect_params.border_color.blue = 1.0
py_nvosd_rect_params.border_color.alpha = 1.0
#======================
while l_frame is not None:
try:
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
# que hace esta funcion ????
#if get_counter() == 60:
# set_counter()
# if get_current_time() > get_offset_time():
# print('aca...............')
# service.emulate_reading_from_server()
# set_offset_time()
# else:
# set_current_time()
#else:
# increment()
frame_number = frame_meta.frame_num
l_obj = frame_meta.obj_meta_list
num_rects = frame_meta.num_obj_meta
#
#print("stream_"+str(frame_meta.pad_index)) El numero de fuente viene en el pad_index
# este valor debe usarse para identificar que servicio se debe ejecutar en el ciclo interno
#
ids = []
boxes = []
#
# Ciclo interno donde se evaluan los objetos dentro del frame
#
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
# validacion de solo personas, solo para control de debug
# print(" Class ID ", pgie_classes_str[obj_meta.class_id])
obj_counter[obj_meta.class_id] += 1
x = obj_meta.rect_params.left
y = obj_meta.rect_params.top
# Service Aforo (in and out)
ids.append(obj_meta.object_id)
boxes.append((x, y))
#print(servicios_habilitados[AFORO_ENT_SAL_SERVICE])
if servicios_habilitados[AFORO_ENT_SAL_SERVICE]:
#print("Servicio de Aforo habilitado")
entrada, salida = service.aforo((x, y), obj_meta.object_id,
ids, previous)
#print("Valor Direccion ", entrada, salida)
#if direction == 1:
# contador_entrada += 1
# print("Entrada", contador_entrada)
#elif direction == 0:
# print("Salida", contador_salida)
# contador_salida += 1
# Service People counting
#if previous:
# service.people_counting_last_time_detected(ids)
# service.people_counting_storing_fist_time(obj_meta.object_id)
try:
l_obj = l_obj.next
except StopIteration:
break
# Nota 18-Agst-2020
# El codigo de Social Distance se esta en este momento ejecutando fuera del ciclo de identificacion
# de objetos dentro del frame, creo que no debe ser asi
# Service Social Distance
if servicios_habilitados[SOCIAL_DISTANCE_SERVICE]:
boxes_length = len(boxes)
if boxes_length > 1:
service.set_frame_counter(frame_number)
service.tracked_on_time_social_distance(
boxes, ids, boxes_length)
if not previous:
previous = service.set_previous()
# Impresion en el video de los valores que nos interesan
# Dibujo de la linea de Ent/Sal
#
#py_nvosd_text_params.display_text = "Frame Number={} Number of Objects={} Vehicle_count={} Person_count={}".format(frame_number, num_rects, obj_counter[PGIE_CLASS_ID_VEHICLE],obj_counter[PGIE_CLASS_ID_PERSON])
py_nvosd_text_params.display_text = "Source ID={} Source Number={} Person_count={} Entradas=={} Salidas=={}".format(
frame_meta.source_id, frame_meta.pad_index,
obj_counter[PGIE_CLASS_ID_PERSON], entrada, salida)
# Lo manda a directo streaming
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
# Lo manda a terminal, siguientes 2 lineas, hacen lo mismo, diferentes funciones
#print(pyds.get_string(py_nvosd_text_params.display_text))
#print("Frame Number=", frame_number, "Number of Objects=",num_rects,"Vehicle_count=",vehicle_count,"Person_count=",person)
fps_streams["stream{0}".format(frame_meta.pad_index)].get_fps()
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def analytics_meta_buffer_probe(pad, info, u_data):
# Get the buffer from the pipeline
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer")
return Gst.PadProbeReturn.OK
# With the pyds wrapper get the batch of metadata from the buffer
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
# From the batch of metadata get the list of frames
list_of_frames = batch_meta.frame_meta_list
# Iterate thru the list of frames
while list_of_frames is not None:
try:
# Get the metadata on the current frame
# The next frame is set at the end of the while loop
frame_meta = pyds.NvDsFrameMeta.cast(list_of_frames.data)
except StopIteration:
break
# INFORMATION THAT IS PRESENT THE FRAME
#
# - frame_meta.frame_num
# - frame_meta.frame_num
# - frame_meta.source_id
# - frame_meta.batch_id
# - frame_meta.source_frame_width
# - frame_meta.source_frame_height
# - frame_meta.num_obj_meta
# Print the frame width and height to see what positions can the bounding boxed be drawed
# print('Frame Width: ' + str(frame_meta.source_frame_width)) = 1920
# print('Frame Height: ' + str(frame_meta.source_frame_height)) = 1080
# In the information of the frame we can get a list of objects detected on the frame.
list_of_objects = frame_meta.obj_meta_list
# Iterate thru the list of objects
while list_of_objects is not None:
try:
# Get the metadata for each object in the frame
object_meta = pyds.NvDsObjectMeta.cast(list_of_objects.data)
except StopIteration:
break
# Go to the next object in the list
l_user_meta = object_meta.obj_user_meta_list
while l_user_meta:
try:
pass
# user_meta = pyds.NvDsUserMeta.cast(l_user_meta.data)
# print(user_meta.base_meta.meta_type)
# if user_meta.base_meta.meta_type == pyds.nvds_get_user_meta_type("NVIDIA.DSANALYTICSOBJ.USER_META"):
# user_meta_data = pyds.NvDsAnalyticsObjInfo.cast(user_meta.user_meta_data)
# if user_meta_data.dirStatus: print("Object {0} moving in direction: {1}".format(object_meta.object_id, user_meta_data.dirStatus))
# if user_meta_data.lcStatus: print("Object {0} line crossing status: {1}".format(object_meta.object_id, user_meta_data.lcStatus))
# if user_meta_data.ocStatus: print("Object {0} overcrowding status: {1}".format(object_meta.object_id, user_meta_data.ocStatus))
# if user_meta_data.roiStatus: print("Object {0} roi status: {1}".format(object_meta.object_id, user_meta_data.roiStatus))
except StopIteration:
break
try:
list_of_objects = list_of_objects.next
except StopIteration:
break
# When there is no more object in the list of objects
# we continue here
# INFORMATION OF THE OBJECT METADATA
#
# - object_meta.class_id
# - object_meta.confidence
# - object_meta.obj_label
# - object_meta.object_id (If not tracker present on the pipeline, the ID is the same for all objects)
# - object_meta.rect_params
# Get the display meta from the batch meta, this is another metadata different that the frame meta collected
# befor
display_meta = pyds.nvds_acquire_display_meta_from_pool(batch_meta)
# Define the number of rects that we are going to draw
# Draw the boxes on the frame
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
try:
# Go to the next frame in the list
list_of_frames = list_of_frames.next
except StopIteration:
break
# When there are not frames in the buffer we end here, and the function returns ok
return Gst.PadProbeReturn.OK
def osd_sink_pad_buffer_probe(pad, info, u_data):
global fps_stream, face_counter
frame_number = 0
#Intiallizing object counter with 0.
vehicle_count = 0
person_count = 0
face_count = 0
lp_count = 0
num_rects = 0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.glist_get_nvds_frame_meta()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number = frame_meta.frame_num
num_rects = frame_meta.num_obj_meta
l_obj = frame_meta.obj_meta_list
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
if obj_meta.unique_component_id == PRIMARY_DETECTOR_UID:
if obj_meta.class_id == PGIE_CLASS_ID_VEHICLE:
vehicle_count += 1
if obj_meta.class_id == PGIE_CLASS_ID_PERSON:
person_count += 1
if obj_meta.unique_component_id == SECONDARY_DETECTOR_UID:
if obj_meta.class_id == SGIE_CLASS_ID_FACE:
face_count += 1
if obj_meta.class_id == SGIE_CLASS_ID_LP:
lp_count += 1
try:
l_obj = l_obj.next
except StopIteration:
break
fps_stream.get_fps()
# Acquiring a display meta object. The memory ownership remains in
# the C code so downstream plugins can still access it. Otherwise
# the garbage collector will claim it when this probe function exits.
display_meta = pyds.nvds_acquire_display_meta_from_pool(batch_meta)
display_meta.num_labels = 1
py_nvosd_text_params = display_meta.text_params[0]
# Setting display text to be shown on screen
# Note that the pyds module allocates a buffer for the string, and the
# memory will not be claimed by the garbage collector.
# Reading the display_text field here will return the C address of the
# allocated string. Use pyds.get_string() to get the string content.
py_nvosd_text_params.display_text = "Frame Number={} Number of Objects={} Person_count={} Face Count={}".format(
frame_number, num_rects, person_count, face_count)
face_counter.append(face_count)
# Now set the offsets where the string should appear
py_nvosd_text_params.x_offset = 10
py_nvosd_text_params.y_offset = 12
# Font , font-color and font-size
py_nvosd_text_params.font_params.font_name = "Serif"
py_nvosd_text_params.font_params.font_size = 10
# set(red, green, blue, alpha); set to White
py_nvosd_text_params.font_params.font_color.set(1.0, 1.0, 1.0, 1.0)
# Text background color
py_nvosd_text_params.set_bg_clr = 1
# set(red, green, blue, alpha); set to Black
py_nvosd_text_params.text_bg_clr.set(0.0, 0.0, 0.0, 1.0)
# Using pyds.get_string() to get display_text as string
print(pyds.get_string(py_nvosd_text_params.display_text))
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def tiler_sink_pad_buffer_probe(self, pad, info, u_data):
frame_number = 0
num_rects = 0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number = frame_meta.frame_num
l_obj = frame_meta.obj_meta_list
num_rects = frame_meta.num_obj_meta
is_first_obj = True
save_image = False
obj_counter = {
PGIE_CLASS_ID_VEHICLE: 0,
PGIE_CLASS_ID_BICYCLE: 0,
PGIE_CLASS_ID_PERSON: 0,
PGIE_CLASS_ID_ROADSIGN: 0
}
# Message for output of detection inference
msg = Detection2DArray()
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
l_classifier = obj_meta.classifier_meta_list
# If object is a car (class ID 0), perform attribute classification
if obj_meta.class_id == 0 and l_classifier is not None:
# Creating and publishing message with output of classification inference
msg2 = Classification2D()
while l_classifier is not None:
result = ObjectHypothesis()
try:
classifier_meta = pyds.glist_get_nvds_classifier_meta(
l_classifier.data)
except StopIteration:
print('Could not parse MetaData: ')
break
classifier_id = classifier_meta.unique_component_id
l_label = classifier_meta.label_info_list
label_info = pyds.glist_get_nvds_label_info(
l_label.data)
classifier_class = label_info.result_class_id
if classifier_id == 2:
result.id = class_color[classifier_class]
elif classifier_id == 3:
result.id = class_make[classifier_class]
else:
result.id = class_type[classifier_class]
result.score = label_info.result_prob
msg2.results.append(result)
l_classifier = l_classifier.next
self.publisher_classification.publish(msg2)
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
# Creating message for output of detection inference
result = ObjectHypothesisWithPose()
result.id = str(class_obj[obj_meta.class_id])
result.score = obj_meta.confidence
left = obj_meta.rect_params.left
top = obj_meta.rect_params.top
width = obj_meta.rect_params.width
height = obj_meta.rect_params.height
bounding_box = BoundingBox2D()
bounding_box.center.x = float(left + (width / 2))
bounding_box.center.y = float(top - (height / 2))
bounding_box.size_x = width
bounding_box.size_y = height
detection = Detection2D()
detection.results.append(result)
detection.bbox = bounding_box
msg.detections.append(detection)
# Periodically check for objects with borderline confidence value that may be false positive detections.
# If such detections are found, annotate the frame with bboxes and confidence value.
# Save the annotated frame to file.
if ((saved_count["stream_" + str(frame_meta.pad_index)] % 30
== 0) and (obj_meta.confidence > 0.3
and obj_meta.confidence < 0.31)):
if is_first_obj:
is_first_obj = False
# Getting Image data using nvbufsurface
# the input should be address of buffer and batch_id
n_frame = pyds.get_nvds_buf_surface(
hash(gst_buffer), frame_meta.batch_id)
#convert python array into numy array format.
frame_image = np.array(n_frame, copy=True, order='C')
#covert the array into cv2 default color format
frame_image = cv2.cvtColor(frame_image,
cv2.COLOR_RGBA2BGRA)
save_image = True
frame_image = draw_bounding_boxes(frame_image, obj_meta,
obj_meta.confidence)
try:
l_obj = l_obj.next
except StopIteration:
break
# Get frame rate through this probe
fps_streams["stream{0}".format(frame_meta.pad_index)].get_fps()
# Publishing message with output of detection inference
self.publisher_detection.publish(msg)
if save_image:
cv2.imwrite(
folder_name + "/stream_" + str(frame_meta.pad_index) +
"/frame_" + str(frame_number) + ".jpg", frame_image)
saved_count["stream_" + str(frame_meta.pad_index)] += 1
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def osd_sink_pad_buffer_probe(pad, info, u_data):
frame_number = 0
#Intiallizing object counter with 0.
obj_counter = {
PGIE_CLASS_ID_PERSON: 0,
PGIE_CLASS_ID_FACE: 0,
}
num_rects = 0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number = frame_meta.frame_num
num_rects = frame_meta.num_obj_meta
l_obj = frame_meta.obj_meta_list
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
l_user = obj_meta.obj_user_meta_list
# print(l_user)
while l_user is not None:
print('Inside l_user = obj_meta.obj_user_meta_list Loop')
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
user_meta = pyds.NvDsUserMeta.cast(l_user.data)
except StopIteration:
break
if (user_meta.base_meta.meta_type !=
pyds.NvDsMetaType.NVDSINFER_TENSOR_OUTPUT_META):
continue
tensor_meta = pyds.NvDsInferTensorMeta.cast(
user_meta.user_meta_data)
# Boxes in the tensor meta should be in network resolution which is
# found in tensor_meta.network_info. Use this info to scale boxes to
# the input frame resolution.
layers_info = []
for i in range(tensor_meta.num_output_layers):
layer = pyds.get_nvds_LayerInfo(tensor_meta, i)
layers_info.append(layer)
print(f'Layer: {i}, Layer name: {layer.layerName}')
try:
l_user = l_user.next
except StopIteration:
break
try:
l_obj = l_obj.next
except StopIteration:
break
# Acquiring a display meta object. The memory ownership remains in
# the C code so downstream plugins can still access it. Otherwise
# the garbage collector will claim it when this probe function exits.
display_meta = pyds.nvds_acquire_display_meta_from_pool(batch_meta)
display_meta.num_labels = 1
py_nvosd_text_params = display_meta.text_params[0]
# Setting display text to be shown on screen
# Note that the pyds module allocates a buffer for the string, and the
# memory will not be claimed by the garbage collector.
# Reading the display_text field here will return the C address of the
# allocated string. Use pyds.get_string() to get the string content.
py_nvosd_text_params.display_text = "Frame Number={} Number of Objects={} Person_count={} Face_count={}".format(
frame_number, num_rects, obj_counter[PGIE_CLASS_ID_PERSON],
obj_counter[PGIE_CLASS_ID_FACE])
# Now set the offsets where the string should appear
py_nvosd_text_params.x_offset = 10
py_nvosd_text_params.y_offset = 12
# Font , font-color and font-size
py_nvosd_text_params.font_params.font_name = "Serif"
py_nvosd_text_params.font_params.font_size = 10
# set(red, green, blue, alpha); set to White
py_nvosd_text_params.font_params.font_color.set(1.0, 1.0, 1.0, 1.0)
# Text background color
py_nvosd_text_params.set_bg_clr = 1
# set(red, green, blue, alpha); set to Black
py_nvosd_text_params.text_bg_clr.set(0.0, 0.0, 0.0, 1.0)
# Using pyds.get_string() to get display_text as string
print(pyds.get_string(py_nvosd_text_params.display_text))
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def osd_sink_pad_buffer_probe(pad,info,u_data):
frame_number=0
#Intiallizing object counter with 0.
obj_counter = {
PGIE_CLASS_ID_VEHICLE:0,
PGIE_CLASS_ID_PERSON:0,
PGIE_CLASS_ID_BICYCLE:0,
PGIE_CLASS_ID_ROADSIGN:0
}
is_first_object=True
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
if not batch_meta:
return Gst.PadProbeReturn.OK
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
continue
is_first_object = True;
'''
print("Frame Number is ", frame_meta.frame_num)
print("Source id is ", frame_meta.source_id)
print("Batch id is ", frame_meta.batch_id)
print("Source Frame Width ", frame_meta.source_frame_width)
print("Source Frame Height ", frame_meta.source_frame_height)
print("Num object meta ", frame_meta.num_obj_meta)
'''
frame_number=frame_meta.frame_num
l_obj=frame_meta.obj_meta_list
while l_obj is not None:
try:
obj_meta=pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
continue
# Update the object text display
txt_params=obj_meta.text_params
# Set display_text. Any existing display_text string will be
# freed by the bindings module.
txt_params.display_text = pgie_classes_str[obj_meta.class_id]
obj_counter[obj_meta.class_id] += 1
# Font , font-color and font-size
txt_params.font_params.font_name = "Serif"
txt_params.font_params.font_size = 10
# set(red, green, blue, alpha); set to White
txt_params.font_params.font_color.set(1.0, 1.0, 1.0, 1.0);
# Text background color
txt_params.set_bg_clr = 1
# set(red, green, blue, alpha); set to Black
txt_params.text_bg_clr.set(0.0, 0.0, 0.0, 1.0);
# Ideally NVDS_EVENT_MSG_META should be attached to buffer by the
# component implementing detection / recognition logic.
# Here it demonstrates how to use / attach that meta data.
if(is_first_object and not (frame_number%30)):
# Frequency of messages to be send will be based on use case.
# Here message is being sent for first object every 30 frames.
# Allocating an NvDsEventMsgMeta instance and getting reference
# to it. The underlying memory is not manged by Python so that
# downstream plugins can access it. Otherwise the garbage collector
# will free it when this probe exits.
msg_meta=pyds.alloc_nvds_event_msg_meta()
msg_meta.bbox.top = obj_meta.rect_params.top
msg_meta.bbox.left = obj_meta.rect_params.left
msg_meta.bbox.width = obj_meta.rect_params.width
msg_meta.bbox.height = obj_meta.rect_params.height
msg_meta.frameId = frame_number
msg_meta.trackingId = long_to_int(obj_meta.object_id)
msg_meta.confidence = obj_meta.confidence
msg_meta = generate_event_msg_meta(msg_meta, obj_meta.class_id)
user_event_meta = pyds.nvds_acquire_user_meta_from_pool(batch_meta)
if(user_event_meta):
user_event_meta.user_meta_data = msg_meta;
user_event_meta.base_meta.meta_type = pyds.NvDsMetaType.NVDS_EVENT_MSG_META
# Setting callbacks in the event msg meta. The bindings layer
# will wrap these callables in C functions. Currently only one
# set of callbacks is supported.
pyds.user_copyfunc(user_event_meta, meta_copy_func)
pyds.user_releasefunc(user_event_meta, meta_free_func)
pyds.nvds_add_user_meta_to_frame(frame_meta, user_event_meta)
else:
print("Error in attaching event meta to buffer\n")
is_first_object = False
try:
l_obj=l_obj.next
except StopIteration:
break
try:
l_frame=l_frame.next
except StopIteration:
break
print("Frame Number =",frame_number,"Vehicle Count =",obj_counter[PGIE_CLASS_ID_VEHICLE],"Person Count =",obj_counter[PGIE_CLASS_ID_PERSON])
return Gst.PadProbeReturn.OK
def osd_sink_pad_buffer_probe(pad, info, u_data):
frame_number = 0
obj_counter = {
PGIE_CLASS_ID_VEHICLE: 0,
PGIE_CLASS_ID_PERSON: 0,
PGIE_CLASS_ID_BICYCLE: 0,
PGIE_CLASS_ID_ROADSIGN: 0
}
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GSTBuffer")
return
# Retrieve batch metadata from the GST Buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects
# the C address of gst_buffer as input,
# which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
if not batch_meta:
return Gst.PadProbeReturn.OK
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDSFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collection
# will leave it alone
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
continue
frame_number = frame_meta.frame_num
l_obj = frame_meta.obj_meta_list
while l_obj is not None:
try:
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
continue
obj_counter[obj_meta.class_id] += 1
if ((frame_number % 30) == 0):
# Allocating an NvDsEventMsgMeta instance and getting reference
# to it. The underlying memory is not managed by Python so that
# downstream plugins can access it. Otherwise the garbage collector
# will free it when this probe exits.
# See the "MetaData Access" section at this link:
# https://docs.nvidia.com/metropolis/deepstream/dev-guide/index.html#page/DeepStream_Development_Guide/deepstream_Python_sample_apps.html
# See also the struct fields here (C++ API reference):
# https://docs.nvidia.com/metropolis/deepstream/5.0/dev-guide/DeepStream_Development_Guide/baggage/structNvDsEventMsgMeta.html
msg_meta = pyds.alloc_nvds_event_msg_meta()
msg_meta.bbox.top = obj_meta.rect_params.top
msg_meta.bbox.left = obj_meta.rect_params.left
msg_meta.bbox.width = obj_meta.rect_params.width
msg_meta.bbox.height = obj_meta.rect_params.height
msg_meta.frameId = frame_number
msg_meta.trackingId = long_to_int(obj_meta.object_id)
msg_meta.confidence = obj_meta.confidence
# What is this msg_meta thing even for? Can we get rid of this bit?
# https://docs.nvidia.com/metropolis/deepstream/python-api/NvDsMeta_Schema/NvDsEventMsgMeta.html
# No we can't this is the thing that actually sends it out
# TODO I need to understand what this is
msg_meta = generate_event_msg_meta(msg_meta, obj_meta.class_id)
user_event_meta = pyds.nvds_acquire_user_meta_from_pool(
batch_meta)
if (user_event_meta):
user_event_meta.user_meta_data = msg_meta
user_event_meta.base_meta.meta_type = pyds.NvDsMetaType.NVDS_EVENT_MSG_META
# Custom MetaData added to NvDsUserMeta require
# custom copy and release functions.
# The MetaData library relies on these custom functions to perform deep-copy of the custom structure,
# and free allocated resources.
# These functions are registered as callback function pointers in the NvDsUserMeta structure.
# Setting callbacks in the event msg meta. The bindings layer
# will wrap these callables in C functions. Currently only one
# set of callbacks is supported.
# pyds.set_user_copyfunc(user_event_meta, meta_copy_func)
# pyds.set_user_releasefunc(user_event_meta, meta_free_func)
pyds.nvds_add_user_meta_to_frame(frame_meta,
user_event_meta)
else:
print("Error in attaching event meta to buffer\n")
try:
l_obj = l_obj.next
except StopIteration:
break
try:
l_frame = l_frame.next
except StopIteration:
break
print(
f"Frame Number = {frame_number}, Person Count = {obj_counter[PGIE_CLASS_ID_PERSON]}"
)
return Gst.PadProbeReturn.OK
def set_event_message_meta_probe(pad, info, u_data):
logging.info("set_event_message_meta_probe: BEGIN")
add_message_when_no_objects_found = True
gst_buffer = info.get_buffer()
if gst_buffer:
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
if batch_meta:
for frame_meta_raw in glist_iterator(batch_meta.frame_meta_list):
frame_meta = pyds.NvDsFrameMeta.cast(frame_meta_raw)
logging.info(
"set_event_message_meta_probe: %20s:%-8s: pts=%23s, dts=%23s, duration=%23s, size=%8d"
% (pad.get_parent_element().name, pad.name,
format_clock_time(
gst_buffer.pts), format_clock_time(gst_buffer.dts),
format_clock_time(
gst_buffer.duration), gst_buffer.get_size()))
pravega_timestamp = PravegaTimestamp.from_nanoseconds(
frame_meta.buf_pts)
logging.info(
"set_event_message_meta_probe: %20s:%-8s: buf_pts=%s, pravega_timestamp=%s, ntp_timestamp=%s"
% (pad.get_parent_element().name, pad.name,
format_clock_time(frame_meta.buf_pts),
pravega_timestamp, str(frame_meta.ntp_timestamp)))
if not pravega_timestamp.is_valid():
logging.info(
"set_event_message_meta_probe: Timestamp %s is invalid."
% pravega_timestamp)
else:
added_message = False
for obj_meta_raw in glist_iterator(
frame_meta.obj_meta_list):
obj_meta = pyds.NvDsObjectMeta.cast(obj_meta_raw)
logging.info(
"set_event_message_meta_probe: obj_meta.class_id=%d"
% (obj_meta.class_id, ))
# We can only identify a single object in an NvDsEventMsgMeta.
# For now, we identify the first object in the frame.
# TODO: Create multiple NvDsEventMsgMeta instances per frame or use a custom user metadata class to identify multiple objects.
if not added_message:
# Allocating an NvDsEventMsgMeta instance and getting reference
# to it. The underlying memory is not manged by Python so that
# downstream plugins can access it. Otherwise the garbage collector
# will free it when this probe exits.
msg_meta = pyds.alloc_nvds_event_msg_meta()
msg_meta.bbox.top = obj_meta.rect_params.top
msg_meta.bbox.left = obj_meta.rect_params.left
msg_meta.bbox.width = obj_meta.rect_params.width
msg_meta.bbox.height = obj_meta.rect_params.height
msg_meta.frameId = frame_meta.frame_num
msg_meta.trackingId = long_to_int(
obj_meta.object_id)
msg_meta.confidence = obj_meta.confidence
msg_meta = generate_event_msg_meta(
msg_meta, obj_meta.class_id, pravega_timestamp)
user_event_meta = pyds.nvds_acquire_user_meta_from_pool(
batch_meta)
if user_event_meta is None:
raise Exception(
"Error in attaching event meta to buffer")
user_event_meta.user_meta_data = msg_meta
user_event_meta.base_meta.meta_type = pyds.NvDsMetaType.NVDS_EVENT_MSG_META
# Setting callbacks in the event msg meta. The bindings layer
# will wrap these callables in C functions. Currently only one
# set of callbacks is supported.
pyds.set_user_copyfunc(user_event_meta,
meta_copy_func)
pyds.set_user_releasefunc(user_event_meta,
meta_free_func)
pyds.nvds_add_user_meta_to_frame(
frame_meta, user_event_meta)
added_message = True
if add_message_when_no_objects_found and not added_message:
msg_meta = pyds.alloc_nvds_event_msg_meta()
msg_meta.frameId = frame_meta.frame_num
msg_meta = generate_event_msg_meta(
msg_meta, PGIE_CLASS_ID_NONE, pravega_timestamp)
user_event_meta = pyds.nvds_acquire_user_meta_from_pool(
batch_meta)
if user_event_meta is None:
raise Exception(
"Error in attaching event meta to buffer")
user_event_meta.user_meta_data = msg_meta
user_event_meta.base_meta.meta_type = pyds.NvDsMetaType.NVDS_EVENT_MSG_META
pyds.set_user_copyfunc(user_event_meta, meta_copy_func)
pyds.set_user_releasefunc(user_event_meta,
meta_free_func)
pyds.nvds_add_user_meta_to_frame(
frame_meta, user_event_meta)
added_message = True
logging.info("set_event_message_meta_probe: END")
return Gst.PadProbeReturn.OK
def nvanalytics_src_pad_buffer_probe(pad, info, u_data):
frame_number = 0
num_rects = 0
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return Gst.PadProbeReturn.OK
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame:
try:
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
l_obj = frame_meta.obj_meta_list
while l_obj:
try:
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
l_user_meta = obj_meta.obj_user_meta_list
while l_user_meta:
try:
user_meta = pyds.NvDsUserMeta.cast(l_user_meta.data)
if user_meta.base_meta.meta_type == pyds.nvds_get_user_meta_type(
"NVIDIA.DSANALYTICSOBJ.USER_META"):
user_meta_data = pyds.NvDsAnalyticsObjInfo.cast(
user_meta.user_meta_data)
# if user_meta_data.dirStatus: print("Object {0} moving in direction: {1}".format(obj_meta.object_id, user_meta_data.dirStatus))
# if user_meta_data.lcStatus: print("Object {0} line crossing status: {1}".format(obj_meta.object_id, user_meta_data.lcStatus))
except StopIteration:
break
try:
l_user_meta = l_user_meta.next
except StopIteration:
break
try:
l_obj = l_obj.next
except StopIteration:
break
l_user = frame_meta.frame_user_meta_list
while l_user:
try:
user_meta = pyds.NvDsUserMeta.cast(l_user.data)
if user_meta.base_meta.meta_type == pyds.nvds_get_user_meta_type(
"NVIDIA.DSANALYTICSFRAME.USER_META"):
user_meta_data = pyds.NvDsAnalyticsFrameMeta.cast(
user_meta.user_meta_data)
if user_meta_data.objLCCumCnt:
print("Linecrossing Cumulative: {0}".format(
user_meta_data.objLCCumCnt))
# if user_meta_data.objLCCurrCnt: print("Linecrossing Current Frame: {0}".format(user_meta_data.objLCCurrCnt))
except StopIteration:
break
try:
l_user = l_user.next
except StopIteration:
break
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def get_lva_MediaStreamMessage(self, buffer, gst_lva_message, ih, iw):
msg = extension_pb2.MediaStreamMessage()
msg.ack_sequence_number = gst_lva_message.sequence_number
msg.media_sample.timestamp = gst_lva_message.timestamp
# # Retrieve batch metadata from the gst_buffer
# # Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# # C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(buffer))
frame = batch_meta.frame_meta_list
while frame is not None:
try:
# Note that frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.NvDsFrameMeta.cast()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
frame_meta = pyds.NvDsFrameMeta.cast(frame.data)
objInference = frame_meta.obj_meta_list
frameWidth = frame_meta.source_frame_width
frameHeight = frame_meta.source_frame_height
inference = msg.media_sample.inferences.add()
attributes = []
obj_label = None
obj_confidence = 0
obj_left = 0
obj_width = 0
obj_top = 0
obj_width = 0
# iterate through objects
while objInference is not None:
try:
# Casting objInference.data to pyds.NvDsObjectMeta
obj_meta = pyds.NvDsObjectMeta.cast(objInference.data)
except StopIteration:
break
rect_params = obj_meta.rect_params
top = int(rect_params.top)
left = int(rect_params.left)
width = int(rect_params.width)
height = int(rect_params.height)
obj_confidence = obj_meta.confidence
objLabel = obj_meta.obj_label
obj_label = objLabel
obj_left = left / iw
obj_top = top / ih
obj_width = width / iw
obj_height = height / ih
inference.type = inferencing_pb2.Inference.InferenceType.ENTITY
try:
objInference = objInference.next
except StopIteration:
break
if obj_label is not None:
try:
entity = inferencing_pb2.Entity(
tag=inferencing_pb2.Tag(value=obj_label,
confidence=obj_confidence),
box=inferencing_pb2.Rectangle(l=obj_left,
t=obj_top,
w=obj_width,
h=obj_height))
for attr in attributes:
attribute = inferencing_pb2.Attribute(
name=attr[0],
value=attr[1],
confidence=attr[2])
entity.attributes.append(attribute)
except:
PrintGetExceptionDetails()
inference.entity.CopyFrom(entity)
except StopIteration:
break
try:
frame = frame.next
except StopIteration:
break
return msg
def osd_sink_pad_buffer_probe(pad, info, u_data):
obj_counter = {
PGIE_CLASS_ID_VEHICLE: 0,
PGIE_CLASS_ID_PERSON: 0,
PGIE_CLASS_ID_BICYCLE: 0,
PGIE_CLASS_ID_ROADSIGN: 0
}
gst_buffer = info.get_buffer()
if not gst_buffer:
print("Unable to get GstBuffer ")
return
# Retrieve batch metadata from the gst_buffer
# Note that pyds.gst_buffer_get_nvds_batch_meta() expects the
# C address of gst_buffer as input, which is obtained with hash(gst_buffer)
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
l_frame = batch_meta.frame_meta_list
while l_frame is not None:
try:
# Note that l_frame.data needs a cast to pyds.NvDsFrameMeta
# The casting is done by pyds.glist_get_nvds_frame_meta()
# The casting also keeps ownership of the underlying memory
# in the C code, so the Python garbage collector will leave
# it alone.
# frame_meta = pyds.glist_get_nvds_frame_meta(l_frame.data)
frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
except StopIteration:
break
frame_number = frame_meta.frame_num
num_rects = frame_meta.num_obj_meta
l_obj = frame_meta.obj_meta_list
while l_obj is not None:
try:
# Casting l_obj.data to pyds.NvDsObjectMeta
# obj_meta=pyds.glist_get_nvds_object_meta(l_obj.data)
obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
obj_meta.rect_params.border_color.set(0.0, 0.0, 1.0, 0.0)
try:
l_obj = l_obj.next
except StopIteration:
break
# Acquiring a display meta object. The memory ownership remains in
# the C code so downstream plugins can still access it. Otherwise
# the garbage collector will claim it when this probe function exits.
display_meta = pyds.nvds_acquire_display_meta_from_pool(batch_meta)
display_meta.num_labels = 1
py_nvosd_text_params = display_meta.text_params[0]
# Setting display text to be shown on screen
# Note that the pyds module allocates a buffer for the string, and the
# memory will not be claimed by the garbage collector.
# Reading the display_text field here will return the C address of the
# allocated string. Use pyds.get_string() to get the string content.
fps_stream.get_fps()
py_nvosd_text_params.display_text = "Frame Number={} Number of Objects={} Vehicle_count={} Person_count={}" \
.format(frame_number, num_rects, obj_counter[PGIE_CLASS_ID_VEHICLE], obj_counter[PGIE_CLASS_ID_PERSON])
# Now set the offsets where the string should appear
py_nvosd_text_params.x_offset = 10
py_nvosd_text_params.y_offset = 12
# Font , font-color and font-size
py_nvosd_text_params.font_params.font_name = "Serif"
py_nvosd_text_params.font_params.font_size = 10
# set(red, green, blue, alpha); set to White
py_nvosd_text_params.font_params.font_color.set(1.0, 1.0, 1.0, 1.0)
# Text background color
py_nvosd_text_params.set_bg_clr = 1
# set(red, green, blue, alpha); set to Black
py_nvosd_text_params.text_bg_clr.set(0.0, 0.0, 0.0, 1.0)
# Using pyds.get_string() to get display_text as string
print(pyds.get_string(py_nvosd_text_params.display_text))
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
# if WRITE_FRAMES:
# n_frame = pyds.get_nvds_buf_surface(hash(gst_buffer), frame_meta.batch_id)
# # convert python array into numy array format.
# frame_image = np.array(n_frame, copy=True, order='C')
# # covert the array into cv2 default color format
# frame_image = cv2.cvtColor(frame_image, cv2.COLOR_RGBA2BGRA)
# cv2.imwrite("./frame_" + str(frame_number) + ".jpg",
# frame_image)
# print('saved to')
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
def set_event_message_meta_probe(pad, info, u_data):
logging.info("set_event_message_meta_probe: BEGIN")
gst_buffer = info.get_buffer()
if gst_buffer:
batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
if batch_meta:
for frame_meta_raw in glist_iterator(batch_meta.frame_meta_list):
frame_meta = pyds.NvDsFrameMeta.cast(frame_meta_raw)
# TODO: It appears that the timestamp may be incorrect by up to 1 second.
pravega_video_timestamp = pts_to_pravega_video_timestamp(
frame_meta.buf_pts)
logging.info(
"set_event_message_meta_probe: pad=%s:%s, pts=%s, buf_pts=%s, pravega_video_timestamp=%d, ntp_timestamp=%s"
% (pad.get_parent_element().name, pad.name,
format_clock_time(gst_buffer.pts),
format_clock_time(frame_meta.buf_pts),
pravega_video_timestamp, str(frame_meta.ntp_timestamp)))
if pravega_video_timestamp <= 0:
logging.info(
"set_event_message_meta_probe: Timestamp is invalid. It may take a few seconds for RTSP timestamps to be valid."
)
else:
is_first_object = True
for obj_meta_raw in glist_iterator(
frame_meta.obj_meta_list):
obj_meta = pyds.NvDsObjectMeta.cast(obj_meta_raw)
logging.info(
"set_event_message_meta_probe: obj_meta.class_id=%d"
% (obj_meta.class_id, ))
# We can only identify a single object in an NvDsEventMsgMeta.
# For now, we identify the first object in the frame.
# TODO: Create multiple NvDsEventMsgMeta instances per frame or use a custom user metadata class to identify multiple objects.
if is_first_object:
# Allocating an NvDsEventMsgMeta instance and getting reference
# to it. The underlying memory is not manged by Python so that
# downstream plugins can access it. Otherwise the garbage collector
# will free it when this probe exits.
msg_meta = pyds.alloc_nvds_event_msg_meta()
msg_meta.bbox.top = obj_meta.rect_params.top
msg_meta.bbox.left = obj_meta.rect_params.left
msg_meta.bbox.width = obj_meta.rect_params.width
msg_meta.bbox.height = obj_meta.rect_params.height
msg_meta.frameId = frame_meta.frame_num
msg_meta.trackingId = long_to_int(
obj_meta.object_id)
msg_meta.confidence = obj_meta.confidence
msg_meta = generate_event_msg_meta(
msg_meta, obj_meta.class_id,
pravega_video_timestamp)
user_event_meta = pyds.nvds_acquire_user_meta_from_pool(
batch_meta)
if user_event_meta:
user_event_meta.user_meta_data = msg_meta
user_event_meta.base_meta.meta_type = pyds.NvDsMetaType.NVDS_EVENT_MSG_META
# Setting callbacks in the event msg meta. The bindings layer
# will wrap these callables in C functions. Currently only one
# set of callbacks is supported.
pyds.set_user_copyfunc(user_event_meta,
meta_copy_func)
pyds.set_user_releasefunc(
user_event_meta, meta_free_func)
pyds.nvds_add_user_meta_to_frame(
frame_meta, user_event_meta)
else:
raise Exception(
"Error in attaching event meta to buffer")
is_first_object = False
logging.info("set_event_message_meta_probe: END")
return Gst.PadProbeReturn.OK
