def meta_copy_func(data, user_data):
# Cast data to pyds.NvDsUserMeta
user_meta = pyds.NvDsUserMeta.cast(data)
src_meta_data = user_meta.user_meta_data
# Cast src_meta_data to pyds.NvDsEventMsgMeta
srcmeta = pyds.NvDsEventMsgMeta.cast(src_meta_data)
# Duplicate the memory contents of srcmeta to dstmeta
# First use pyds.get_ptr() to get the C address of srcmeta, then
# use pyds.memdup() to allocate dstmeta and copy srcmeta into it.
# pyds.memdup returns C address of the allocated duplicate.
dstmeta_ptr = pyds.memdup(pyds.get_ptr(srcmeta),
sys.getsizeof(pyds.NvDsEventMsgMeta))
# Cast the duplicated memory to pyds.NvDsEventMsgMeta
dstmeta = pyds.NvDsEventMsgMeta.cast(dstmeta_ptr)
# Duplicate contents of ts field. Note that reading srcmeat.ts
# returns its C address. This allows to memory operations to be
# performed on it.
dstmeta.ts = pyds.memdup(srcmeta.ts, MAX_TIME_STAMP_LEN + 1)
# Copy the sensorStr. This field is a string property.
# The getter (read) returns its C address. The setter (write)
# takes string as input, allocates a string buffer and copies
# the input string into it.
# pyds.get_string() takes C address of a string and returns
# the reference to a string object and the assignment inside the binder copies content.
# dstmeta.sensorStr=pyds.get_string(srcmeta.sensorStr)
if (srcmeta.objSignature.size > 0):
dstmeta.objSignature.signature = pyds.memdup(
srcmeta.objSignature.signature, srcMeta.objSignature.size)
dstmeta.objSignature.size = srcmeta.objSignature.size
if (srcmeta.extMsgSize > 0):
if (srcmeta.objType == pyds.NvDsObjectType.NVDS_OBJECT_TYPE_VEHICLE):
srcobj = pyds.NvDsVehicleObject.cast(srcmeta.extMsg)
obj = pyds.alloc_nvds_vehicle_object()
obj.type = pyds.get_string(srcobj.type)
obj.make = pyds.get_string(srcobj.make)
obj.model = pyds.get_string(srcobj.model)
obj.color = pyds.get_string(srcobj.color)
obj.license = pyds.get_string(srcobj.license)
obj.region = pyds.get_string(srcobj.region)
dstmeta.extMsg = obj
dstmeta.extMsgSize = sys.getsizeof(pyds.NvDsVehicleObject)
if (srcmeta.objType == pyds.NvDsObjectType.NVDS_OBJECT_TYPE_PERSON):
srcobj = pyds.NvDsPersonObject.cast(srcmeta.extMsg)
obj = pyds.alloc_nvds_person_object()
obj.age = srcobj.age
obj.gender = pyds.get_string(srcobj.gender)
obj.cap = pyds.get_string(srcobj.cap)
obj.hair = pyds.get_string(srcobj.hair)
obj.apparel = pyds.get_string(srcobj.apparel)
dstmeta.extMsg = obj
dstmeta.extMsgSize = sys.getsizeof(pyds.NvDsVehicleObject)
return dstmeta
def frame_function(batch_meta, frame_meta, dict_data):
obj_counter = dict_data["obj_counter"]
pgie_class_id = dict_data["pgie_class_id"]
frame_number = frame_meta.frame_num
num_rects = frame_meta.num_obj_meta
display_meta = pyds.nvds_acquire_display_meta_from_pool(batch_meta)
make_text_display(display_meta, frame_number, num_rects, obj_counter)
# Using pyds.get_string() to get display_text as string
py_nvosd_text_params = display_meta.text_params[0]
print(pyds.get_string(py_nvosd_text_params.display_text))
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
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.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.
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):
# 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
global total_cars # explicit mention of the global variable inside the function
global x11, x12, x13, x14, x21, x22, x23, x24 # lanes
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)
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)
if obj_meta.class_id == PGIE_CLASS_ID_VEHICLE:
if obj_meta.rect_params.top >= y1 and obj_meta.rect_params.top <= y2:
car_found = 0
for x in gate_list:
if x.vehicle_id == obj_meta.object_id:
x.frames_list.append(frame_number)
x.x_list.append(obj_meta.rect_params.left)
x.y_list.append(obj_meta.rect_params.top)
x.xc_list.append(
int(obj_meta.rect_params.left +
(obj_meta.rect_params.width / 2)))
x.yc_list.append(
int(obj_meta.rect_params.top +
(obj_meta.rect_params.height / 2)))
x.x_smallest = min(x.x_list)
x.x_largest = max(x.x_list)
x.y_smallest = min(x.y_list)
x.y_largest = max(x.y_list)
x_center = int(obj_meta.rect_params.left +
(obj_meta.rect_params.width /
2))
y_center = int(obj_meta.rect_params.top +
(obj_meta.rect_params.height /
2))
if x_center > min(x13, x23):
x.lane.append('fast')
elif x_center > min(x12, x22):
x.lane.append('medium')
elif x_center > min(x11, x21):
x.lane.append('slow')
else:
x.lane.append('shoulder')
car_found = 1
break
if car_found == 0:
frame_temp_list = []
frame_temp_list.append(frame_number)
x_temp_list = []
x_temp_list.append(obj_meta.rect_params.left)
y_temp_list = []
y_temp_list.append(obj_meta.rect_params.top)
xc_temp_list = []
xc_temp_list.append(
int(obj_meta.rect_params.left +
(obj_meta.rect_params.width / 2)))
yc_temp_list = []
yc_temp_list.append(
int(obj_meta.rect_params.top +
(obj_meta.rect_params.height / 2)))
x_center = int(obj_meta.rect_params.left +
(obj_meta.rect_params.width / 2))
y_center = int(obj_meta.rect_params.top +
(obj_meta.rect_params.height / 2))
lane_temp_list = []
if x_center > min(x13, x23):
lane_temp_list.append('fast')
elif x_center > min(x12, x22):
lane_temp_list.append('medium')
elif x_center > min(x11, x21):
lane_temp_list.append('slow')
else:
lane_temp_list.append('shoulder')
gate_list.append(
Gate(obj_meta.object_id, min(x_temp_list),
max(x_temp_list), min(y_temp_list),
max(y_temp_list), frame_temp_list,
x_temp_list, y_temp_list, xc_temp_list,
yc_temp_list, lane_temp_list))
if obj_meta.object_id > total_cars:
total_cars = obj_meta.object_id # total cars assigned unique tracing IDs
print('Vehicle ID = ', obj_meta.object_id,
', Frame Number = ', frame_number, ', Top X = ',
obj_meta.rect_params.left, ', Top Y = ',
obj_meta.rect_params.top, ', Width = ',
obj_meta.rect_params.width, ', Height = ',
obj_meta.rect_params.height)
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={} Vehicles in Frame={} Total Objects in Stream={}".format(
frame_number, num_rects, obj_counter[PGIE_CLASS_ID_VEHICLE],
total_cars)
# 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
print(pyds.get_string(py_nvosd_text_params.display_text))
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
# Draw x11_x21
py_nvosd_line_params = display_meta.line_params[0]
py_nvosd_line_params.x1 = x11
py_nvosd_line_params.y1 = y1
py_nvosd_line_params.x2 = x21
py_nvosd_line_params.y2 = y2
py_nvosd_line_params.line_width = 5
py_nvosd_line_params.line_color.set(0.0, 1.0, 0.0, 1.0)
display_meta.num_lines = display_meta.num_lines + 1
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
x11 = py_nvosd_line_params.x1
x21 = py_nvosd_line_params.x2
# Draw x12_x22
py_nvosd_line_params = display_meta.line_params[1]
py_nvosd_line_params.x1 = x12
py_nvosd_line_params.y1 = y1
py_nvosd_line_params.x2 = x22
py_nvosd_line_params.y2 = y2
py_nvosd_line_params.line_width = 5
py_nvosd_line_params.line_color.set(0.0, 1.0, 0.0, 1.0)
display_meta.num_lines = display_meta.num_lines + 1
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
x12 = py_nvosd_line_params.x1
x22 = py_nvosd_line_params.x2
# Draw x13_x23
py_nvosd_line_params = display_meta.line_params[2]
py_nvosd_line_params.x1 = x13
py_nvosd_line_params.y1 = y1
py_nvosd_line_params.x2 = x23
py_nvosd_line_params.y2 = y2
py_nvosd_line_params.line_width = 5
py_nvosd_line_params.line_color.set(0.0, 1.0, 0.0, 1.0)
display_meta.num_lines = display_meta.num_lines + 1
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
x13 = py_nvosd_line_params.x1
x23 = py_nvosd_line_params.x2
# Draw x14_x24
py_nvosd_line_params = display_meta.line_params[3]
py_nvosd_line_params.x1 = x14
py_nvosd_line_params.y1 = y1
py_nvosd_line_params.x2 = x24
py_nvosd_line_params.y2 = y2
py_nvosd_line_params.line_width = 5
py_nvosd_line_params.line_color.set(0.0, 1.0, 0.0, 1.0)
display_meta.num_lines = display_meta.num_lines + 1
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
x14 = py_nvosd_line_params.x1
x24 = py_nvosd_line_params.x2
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 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
is_first_obj = True
print("===")
print("frame_meta.frame_num={0}".format(frame_meta.frame_num))
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
print("---")
print("obj_meta.object_id={0}".format(obj_meta.object_id))
print("obj_meta.class_id={0}".format(obj_meta.class_id))
#get secondary classifier data
l_classifier = obj_meta.classifier_meta_list
if l_classifier is not None: # and class_id==XXX #apply classifier for a specific class
classifier_meta = pyds.glist_get_nvds_classifier_meta(
l_classifier.data)
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
print("sgie class={0}", classifier_class)
obj_counter[obj_meta.class_id] += 1
# Cv2 stuff
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)
#recognize license plate data
recognize_license_plate(frame_image, obj_meta, obj_meta.confidence)
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={}".format(
frame_number, num_rects)
# 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 tiler_sink_pad_buffer_probe(pad,info,u_data):
global x11, x12, x13, x14, x21, x22, x23, x24 # lanes
global vehicle_count
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)
if obj_meta.class_id == PGIE_CLASS_ID_VEHICLE: # vehicle detected
if obj_meta.rect_params.top >= y1 and obj_meta.rect_params.top <= y2:
car_found = 0
for x in vehicle_list:
if x.vehicle_id == obj_meta.object_id:
x.frames_list.append(frame_number)
x.x_list.append(obj_meta.rect_params.left)
x.y_list.append(obj_meta.rect_params.top)
x.xc_list.append(int(obj_meta.rect_params.left + (obj_meta.rect_params.width / 2)))
x.yc_list.append(int(obj_meta.rect_params.top + (obj_meta.rect_params.height / 2)))
x.width_list.append(obj_meta.rect_params.width)
x.height_list.append(obj_meta.rect_params.height)
x_center = int(obj_meta.rect_params.left + (obj_meta.rect_params.width / 2))
if x_center > min(x13, x23):
x.lane_list.append('shoulder')
elif x_center > min(x12, x22):
x.lane_list.append('slow')
elif x_center > min(x11, x21):
x.lane_list.append('medium')
else:
x.lane_list.append('fast')
car_found = 1
break
if car_found == 0:
frames_temp_list = []
frames_temp_list.append(frame_number)
x_temp_list = []
x_temp_list.append(obj_meta.rect_params.left)
y_temp_list = []
y_temp_list.append(obj_meta.rect_params.top)
xc_temp_list = []
xc_temp_list.append(int(obj_meta.rect_params.left + (obj_meta.rect_params.width / 2)))
yc_temp_list = []
yc_temp_list.append(int(obj_meta.rect_params.top + (obj_meta.rect_params.height / 2)))
width_temp_list = []
width_temp_list.append(obj_meta.rect_params.width)
height_temp_list = []
height_temp_list.append(obj_meta.rect_params.height)
x_center = int(obj_meta.rect_params.left + (obj_meta.rect_params.width / 2))
lane_temp_list = []
if x_center > min(x13, x23):
lane_temp_list.append('shoulder')
elif x_center > min(x12, x22):
lane_temp_list.append('slow')
elif x_center > min(x11, x21):
lane_temp_list.append('medium')
else:
lane_temp_list.append('fast')
vehicle_list.append(Vehicle(obj_meta.object_id, frames_temp_list, x_temp_list, y_temp_list, xc_temp_list, yc_temp_list, width_temp_list, height_temp_list, lane_temp_list))
vehicle_count += 1
print('Vehicle ID = ', obj_meta.object_id, ', Frame Number = ', frame_number, ', Top X = ', obj_meta.rect_params.left,', Top Y = ', obj_meta.rect_params.top, ', Width = ', obj_meta.rect_params.width, ', Height = ', obj_meta.rect_params.height)
for i, o in enumerate(vehicle_list):
frame_lag = abs(int(o.frames_list[-1]) - int(frame_number))
if (frame_lag > 20) and int(len(o.frames_list)) <= 6: # vehicle count rectifier; eliminates false tracking instances
print('inadequate number of frames in train, deleting...', '\n')
del vehicle_list[i]
vehicle_count -= 1
break
if frame_lag > 20 and frame_lag < 100: # optimal frame extractor
midpoint = int((y1 + y2) / 2)
my_array = np.array(o.yc_list)
pos = (np.abs(my_array - midpoint)).argmin()
temp_frame_number = o.frames_list[pos]
temp_id = o.vehicle_id
with open('optimal_frame_extraction.txt', 'a') as the_file:
the_file.write(str(o.frames_list[pos]))
the_file.write(' ')
the_file.write(str(o.vehicle_id))
the_file.write(' ')
the_file.write(str(o.width_list[pos]))
the_file.write(' ')
the_file.write(str(o.height_list[pos]))
the_file.write(' ')
the_file.write(str(o.x_list[pos]))
the_file.write(' ')
the_file.write(str(o.y_list[pos]))
the_file.write('\n')
xx1 = int(o.x_list[pos])
xx2 = int(o.x_list[pos]) + int(o.width_list[pos])
yy1 = int(o.y_list[pos])
yy2 = int(o.y_list[pos]) + int(o.height_list[pos])
del vehicle_list[i]
finder = 0
for f in rgb_frames_list:
if f.frame_iterator == temp_frame_number:
break
else:
finder += 1
crop = (rgb_frames_list[finder].rgb_image)[yy1:yy2, xx1:xx2]
cv2.imwrite(folder_name+"/stream_"+str(0)+"/frame_id="+str(temp_frame_number)+'_'+str(temp_id)+".jpg", crop)
break
if frame_lag > 100: # vehicle buffer cleaner; eliminates expired tracking instances
print('train expired, deleting...', '\n')
del vehicle_list[i]
break
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
try:
l_obj=l_obj.next
except StopIteration:
break
print("Frame Number =", frame_number, "Number of Objects in frame =",num_rects,"Vehicles in frame =",obj_counter[PGIE_CLASS_ID_VEHICLE],"Total Vehicles Detected =",vehicle_count)
# 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
# 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={} Total Vehicles Detected={}".format(frame_number, num_rects, obj_counter[PGIE_CLASS_ID_VEHICLE], vehicle_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)
# Draw x11_x21
py_nvosd_line_params = display_meta.line_params[0]
py_nvosd_line_params.x1 = x11
py_nvosd_line_params.y1 = y1
py_nvosd_line_params.x2 = x21
py_nvosd_line_params.y2 = y2
py_nvosd_line_params.line_width = 5
py_nvosd_line_params.line_color.set(0.0, 1.0, 0.0, 1.0)
display_meta.num_lines = display_meta.num_lines + 1
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
x11 = py_nvosd_line_params.x1
x21 = py_nvosd_line_params.x2
# Draw x12_x22
py_nvosd_line_params = display_meta.line_params[1]
py_nvosd_line_params.x1 = x12
py_nvosd_line_params.y1 = y1
py_nvosd_line_params.x2 = x22
py_nvosd_line_params.y2 = y2
py_nvosd_line_params.line_width = 5
py_nvosd_line_params.line_color.set(0.0, 1.0, 0.0, 1.0)
display_meta.num_lines = display_meta.num_lines + 1
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
x12 = py_nvosd_line_params.x1
x22 = py_nvosd_line_params.x2
# Draw x13_x23
py_nvosd_line_params = display_meta.line_params[2]
py_nvosd_line_params.x1 = x13
py_nvosd_line_params.y1 = y1
py_nvosd_line_params.x2 = x23
py_nvosd_line_params.y2 = y2
py_nvosd_line_params.line_width = 5
py_nvosd_line_params.line_color.set(0.0, 1.0, 0.0, 1.0)
display_meta.num_lines = display_meta.num_lines + 1
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
x13 = py_nvosd_line_params.x1
x23 = py_nvosd_line_params.x2
# Draw x14_x24
py_nvosd_line_params = display_meta.line_params[3]
py_nvosd_line_params.x1 = x14
py_nvosd_line_params.y1 = y1
py_nvosd_line_params.x2 = x24
py_nvosd_line_params.y2 = y2
py_nvosd_line_params.line_width = 5
py_nvosd_line_params.line_color.set(0.0, 1.0, 0.0, 1.0)
display_meta.num_lines = display_meta.num_lines + 1
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
x14 = py_nvosd_line_params.x1
x24 = py_nvosd_line_params.x2
# save current frame to rgb_frames_list
n_frame=pyds.get_nvds_buf_surface(hash(gst_buffer),frame_meta.batch_id)
frame_image=np.array(n_frame,copy=True,order='C')
frame_image=cv2.cvtColor(frame_image,cv2.COLOR_RGBA2BGRA)
rgb_frames_list.append(RGB_Frame(frame_number, frame_image))
if len(rgb_frames_list) > 120:
for x in range(20):
del rgb_frames_list[x]
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 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 osd_sink_pad_buffer_probe(pad, info, u_data):
global start, prt
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:
now = time.time()
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)
'''
img = pyds.get_nvds_buf_surface(hash(gst_buffer), frame_meta.batch_id)
img = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)
red = (0, 0, 255)
location = (20, 50)
font = cv2.FONT_ITALIC # italic font
cv2.putText(img, 'OpenCV Cooking', location, font, fontScale = 2, color = red, thickness = 3)
#cv2.imshow('Hello', img)
#cv2.waitKey(0)
'''
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)
'''
print('class_id={}'.format(type(obj_meta.class_id)))
print('confidence={}'.format(type(obj_meta.confidence)))
print('detector_bbox_info={}'.format(type(obj_meta.detector_bbox_info)))
print('obj_label={}'.format(type(obj_meta.obj_label)))
print('object_id={}'.format(type(obj_meta.object_id)))
print('rect_params={}'.format(type(obj_meta.rect_params)))
'''
#print('mask_params={}'.format(type(obj_meta.mask_params))) #Not binded
print(' rect_params bg_color alpha={}'.format(
type(obj_meta.rect_params.bg_color)))
print(' rect_params border_width={}'.format(
type(obj_meta.rect_params.border_width)))
print(' rect_params border_width={}'.format(
obj_meta.rect_params.border_width))
print(' rect_params color_id={}'.format(
type(obj_meta.rect_params.color_id)))
print(' rect_params color_id={}'.format(
obj_meta.rect_params.color_id))
print(' rect_params has_color_info={}'.format(
type(obj_meta.rect_params.has_color_info)))
'''
if True:
print(' === obj_meta ===')
print('class_id={}'.format(obj_meta.class_id))
print('confidence={}'.format(obj_meta.confidence))
print('detector_bbox_info={}'.format(obj_meta.detector_bbox_info))
#print('mask_params={}'.format(obj_meta.mask_params))
print('obj_label={}'.format(obj_meta.obj_label))
print('object_id={}'.format(obj_meta.object_id))
print('rect_params={}'.format(obj_meta.rect_params))
print(' rect_params bg_color alpha={}'.format(obj_meta.rect_params.bg_color.alpha))
print(' rect_params bg_color blue={}'.format(obj_meta.rect_params.bg_color.blue))
print(' rect_params bg_color green={}'.format(obj_meta.rect_params.bg_color.green))
print(' rect_params bg_color red={}'.format(obj_meta.rect_params.bg_color.red))
print(' rect_params border_color alpha={}'.format(obj_meta.rect_params.border_color.alpha))
print(' rect_params border_color blue={}'.format(obj_meta.rect_params.border_color.blue))
print(' rect_params border_color green={}'.format(obj_meta.rect_params.border_color.green))
print(' rect_params border_color red={}'.format(obj_meta.rect_params.border_color.red))
print(' rect_params border_width={}'.format(obj_meta.rect_params.border_width))
print(' rect_params color_id={}'.format(obj_meta.rect_params.color_id))
print(' rect_params has_bg_color={}'.format(obj_meta.rect_params.has_bg_color))
print(' rect_params has_color_info={}'.format(obj_meta.rect_params.has_color_info))
print(' rect_params height={}'.format(obj_meta.rect_params.height))
print(' rect_params left={}'.format(obj_meta.rect_params.left))
print(' rect_params top={}'.format(obj_meta.rect_params.top))
print(' rect_params width={}'.format(obj_meta.rect_params.width))
print(' rect_params reserved={}'.format(obj_meta.rect_params.reserved))
print('tracker_bbox_info={}'.format(obj_meta.tracker_bbox_info))
print('tracker_confidence={}'.format(obj_meta.tracker_confidence))
'''
except StopIteration:
break
obj_meta.rect_params.has_bg_color = 1
obj_meta.rect_params.bg_color.set(
0.0, 0.0, 1.0, 0.2
) #It seems that only the alpha channel is working. RGB value is reflected.
obj_counter[obj_meta.class_id] += 1
obj_meta.rect_params.border_color.set(
0.0, 1.0, 1.0, 0.0
) # It seems that only the alpha channel is not working. (red, green, blue , alpha)
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={} FPS={}".format(
frame_number, num_rects, obj_counter[PGIE_CLASS_ID_VEHICLE],
obj_counter[PGIE_CLASS_ID_PERSON], (1 / (now - start)))
# 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 = "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"
py_nvosd_text_params.font_params.font_size = 20
# set(red, green, blue, alpha); set to White
py_nvosd_text_params.font_params.font_color.set(
0.2, 0.2, 1.0, 1) # (red, green, blue , alpha)
# 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.2, 0.2, 0.2, 0.3)
# Using pyds.get_string() to get display_text as string
if prt:
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
prt = False
start = now
return Gst.PadProbeReturn.OK #DROP, HANDLED, OK, PASS, REMOVE
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
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)
if obj_meta.class_id == PGIE_CLASS_ID_VEHICLE: # vehicle detected
if obj_meta.rect_params.top > (
0.25 * 1080
): # discard detection instances for vehicles too far from the camera
car_found = 0 # vehicle id flag
for x in vehicle_list:
if x.vehicle_id == obj_meta.object_id: # vehicle id found in the list of vehicle metadata
x.frames_list.append(frame_number)
x.x_list.append(int(obj_meta.rect_params.left))
x.y_list.append(int(obj_meta.rect_params.top))
x.xc_list.append(
int(obj_meta.rect_params.left +
(obj_meta.rect_params.width / 2)))
x.yc_list.append(
int(obj_meta.rect_params.top +
(obj_meta.rect_params.height / 2)))
car_found = 1 # vehicle metadata was already initialized
break
if car_found == 0: # vehicle metadata was not initialized in the list
frames_temp_list = []
frames_temp_list.append(frame_number)
x_temp_list = []
x_temp_list.append(int(obj_meta.rect_params.left))
y_temp_list = []
y_temp_list.append(int(obj_meta.rect_params.top))
xc_temp_list = []
xc_temp_list.append(
int(obj_meta.rect_params.left +
(obj_meta.rect_params.width / 2)))
yc_temp_list = []
yc_temp_list.append(
int(obj_meta.rect_params.top +
(obj_meta.rect_params.height / 2)))
vehicle_list.append(
Vehicle(obj_meta.object_id, frames_temp_list,
x_temp_list, y_temp_list, xc_temp_list,
yc_temp_list))
print('Vehicle ID = ', obj_meta.object_id,
', Frame Number = ', frame_number, ', Top X = ',
obj_meta.rect_params.left, ', Top Y = ',
obj_meta.rect_params.top, ', Width = ',
obj_meta.rect_params.width, ', Height = ',
obj_meta.rect_params.height
) # initialize vehicle metadata
except StopIteration:
break
obj_counter[obj_meta.class_id] += 1
try:
l_obj = l_obj.next
except StopIteration:
break
print("Frame Number =", frame_number, "Number of Objects in frame =",
num_rects, "Vehicles in frame =",
obj_counter[PGIE_CLASS_ID_VEHICLE]
) # object bounding box metadata overlay
# Get frame rate through this probe
fps_streams["stream{0}".format(frame_meta.pad_index)].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={} Vehicle_count={}".format(
frame_number, num_rects, obj_counter[PGIE_CLASS_ID_VEHICLE])
# 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 frame_number == 500: # when the stream should stop; increase this value to extend the life of video stream
y_min_list = []
y_max_list = []
for car_object in vehicle_list:
if len(
car_object.frames_list
) > 10: # ignore tracking instances with a life of less than ten frames
print(car_object.vehicle_id,
car_object.frames_list,
car_object.y_list,
len(car_object.frames_list),
'\n',
sep=' ')
y_min_list.append(min(car_object.y_list))
y_max_list.append(max(car_object.y_list))
y_min_list.sort()
y_max_list.sort()
print('y_min:', y_min_list, len(y_min_list), '\n')
print('y_max:', y_max_list, len(y_max_list), '\n')
print('Optimal Frame Range:')
print('y:', min(y_max_list) - 100, max(y_min_list))
with open(
'/opt/nvidia/deepstream/deepstream-5.0/sources/deepstream_python_apps/apps/optimal_frame_extractor/road.txt',
'r'
) as file: # input file of the frame extractor application
data = file.readlines()
data[10] = str('y1 ') + str(min(y_max_list) - 100) + str(
' #opt_frm_inf_start') + str('\n')
data[11] = str('y2 ') + str(
max(y_min_list)) + str(' #opt_frm_inf_end')
with open(
'/opt/nvidia/deepstream/deepstream-5.0/sources/deepstream_python_apps/apps/optimal_frame_extractor/road.txt',
'w') as file:
file.writelines(data)
sys.exit()
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
}
# 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 and Set Box border to Red color
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
################## Setting Metadata Display configruation ###############
# Acquiring a display meta object.
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
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 to print in notebook
print(pyds.get_string(py_nvosd_text_params.display_text))
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 osd_sink_pad_buffer_probe(pad, info, u_data):
frame_number = 0
is_first_obj = True
# 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
vehicles_types = []
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
center_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
## vehicle type detection ##
# Filter detections by PGIE1 network and don't include RoadSign class
if (obj_meta.unique_component_id == PGIE_UNIQUE_ID
and obj_meta.class_id !=
PGIE_CLASS_ID_ROADSIGN # Exclude RoadSign
and obj_meta.class_id !=
PGIE_CLASS_ID_BICYCLE # Exclude Bicycle
and
obj_meta.class_id != PGIE_CLASS_ID_PERSON # Exclude Person
):
#####################################
## vehicle type classification ##
#####################################
l_classifier = obj_meta.classifier_meta_list
sgie_class = -1
if l_classifier is not None: # and class_id==XXX #apply classifier for a specific class
classifier_meta = pyds.glist_get_nvds_classifier_meta(
l_classifier.data)
l_label = classifier_meta.label_info_list
label_info = pyds.glist_get_nvds_label_info(l_label.data)
sgie_class = label_info.result_class_id
rect_params = obj_meta.rect_params
w = int(rect_params.width)
h = int(rect_params.height)
center = (w // 2, h // 2)
center_list.append(center)
# vehicles_coords.append(center)
if frame_number > 0 and frame_number % DUMPINTERVAL == 0:
vehicles_types.append(SGIE_LABELS_DICT[sgie_class])
#####################################
## licence plate recognition stage ##
#####################################
# # Cv2 stuff
# 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)
# # recognize license plate data
# alrp_output = lpdetector.alpr_frame(
# frame_image, obj_meta, obj_meta.confidence, frame_number)
# print("alrp out >>> ", alrp_output)
obj_counter[obj_meta.class_id] += 1
#print("obj_meta: gie_id={0}; object_id={1}; class_id={2}; classifier_class={3}".format(obj_meta.unique_component_id,obj_meta.object_id,obj_meta.class_id,sgie_class))
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])
vcoords.vec_coords.append(center_list)
if frame_number > 0 and frame_number % DUMPINTERVAL == 0:
# return degree estimate for every vehicle
# degrees = estimate_entery_exit_degrees(vehicles_coords)
py_nvosd_text_params.display_text = "Time Stamp={} Vehicle_types={} Vehicles_coords_across dump interval {} ".format(
datetime.datetime.now(), vehicles_types, vcoords.vec_coords)
# 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
# where data is dumped
if frame_number > 0 and frame_number % DUMPINTERVAL == 0:
print(pyds.get_string(py_nvosd_text_params.display_text))
vehicle_types = []
vcoords.vec_coords = []
center_list = []
pyds.nvds_add_display_meta_to_frame(frame_meta, display_meta)
try:
l_frame = l_frame.next
except StopIteration:
break
return Gst.PadProbeReturn.OK
