Updated remaining docstrings | closes #29

Author: FabianPlum

utils/darknet_sub_process/opencv_direct_darknet.py

@@ -4,15 +4,15 @@
 import time
 
 img = cv.imread(
-    "C:/Users/Legos/AppData/Roaming/Blender Foundation/Blender/3.2/scripts/addons/omni_trax/darknet_sub_process/ant3.jpg"
+	"C:/Users/Legos/AppData/Roaming/Blender Foundation/Blender/3.2/scripts/addons/omni_trax/darknet_sub_process/ant3.jpg"
 )
 cv.imshow("window", img)
 cv.waitKey(1)
 
 # Give the configuration and weight files for the model and load the network.
 net = cv.dnn.readNetFromDarknet(
-    "C:/Users/Legos/Documents/PhD/Blender/OmniTrax/trained_networks/atta_single_class/yolov4-big_and_small_ants_480.cfg",
-    "C:/Users/Legos/Documents/PhD/Blender/OmniTrax/trained_networks/atta_single_class/yolov4-big_and_small_ants_HPC_final.weights",
+	"C:/Users/Legos/Documents/PhD/Blender/OmniTrax/trained_networks/atta_single_class/yolov4-big_and_small_ants_480.cfg",
+	"C:/Users/Legos/Documents/PhD/Blender/OmniTrax/trained_networks/atta_single_class/yolov4-big_and_small_ants_HPC_final.weights",
 )
 net.setPreferableBackend(cv.dnn.DNN_BACKEND_CUDA)
 net.setPreferableTarget(cv.dnn.DNN_TARGET_CUDA)
@@ -21,12 +21,12 @@
 
 # Load names of classes and get random colors
 classes = (
-    open(
-        "C:/Users/Legos/Documents/PhD/Blender/OmniTrax/trained_networks/atta_single_class/obj.names"
-    )
-    .read()
-    .strip()
-    .split("\n")
+	open(
+		"C:/Users/Legos/Documents/PhD/Blender/OmniTrax/trained_networks/atta_single_class/obj.names"
+	)
+	.read()
+	.strip()
+	.split("\n")
 )
 np.random.seed(42)
 colors = np.random.randint(0, 255, size=(len(classes), 3), dtype="uint8")
@@ -52,37 +52,37 @@
 
 print(len(outputs))
 for out in outputs:
-    print(out.shape)
+	print(out.shape)
 
 boxes = []
 confidences = []
 classIDs = []
 h, w = img.shape[:2]
 
 for output in outputs:
-    for detection in output:
-        scores = detection[5:]
-        classID = np.argmax(scores)
-        confidence = scores[classID]
-        if confidence > 0.5:
-            box = detection[:4] * np.array([w, h, w, h])
-            (centerX, centerY, width, height) = box.astype("int")
-            x = int(centerX - (width / 2))
-            y = int(centerY - (height / 2))
-            box = [x, y, int(width), int(height)]
-            boxes.append(box)
-            confidences.append(float(confidence))
-            classIDs.append(classID)
+	for detection in output:
+		scores = detection[5:]
+		classID = np.argmax(scores)
+		confidence = scores[classID]
+		if confidence > 0.5:
+			box = detection[:4] * np.array([w, h, w, h])
+			(centerX, centerY, width, height) = box.astype("int")
+			x = int(centerX - (width / 2))
+			y = int(centerY - (height / 2))
+			box = [x, y, int(width), int(height)]
+			boxes.append(box)
+			confidences.append(float(confidence))
+			classIDs.append(classID)
 
 indices = cv.dnn.NMSBoxes(boxes, confidences, 0.2, 0.4)
 if len(indices) > 0:
-    for i in indices.flatten():
-        (x, y) = (boxes[i][0], boxes[i][1])
-        (w, h) = (boxes[i][2], boxes[i][3])
-        color = [int(c) for c in colors[classIDs[i]]]
-        cv.rectangle(img, (x, y), (x + w, y + h), color, 2)
-        text = "{}: {:.4f}".format(classes[classIDs[i]], confidences[i])
-        cv.putText(img, text, (x, y - 5), cv.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
+	for i in indices.flatten():
+		(x, y) = (boxes[i][0], boxes[i][1])
+		(w, h) = (boxes[i][2], boxes[i][3])
+		color = [int(c) for c in colors[classIDs[i]]]
+		cv.rectangle(img, (x, y), (x + w, y + h), color, 2)
+		text = "{}: {:.4f}".format(classes[classIDs[i]], confidences[i])
+		cv.putText(img, text, (x, y - 5), cv.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
 
 cv.imshow("window", img)
 cv.waitKey(0)
@@ -93,89 +93,89 @@
 # initialize the video stream, pointer to output video file, and
 # frame dimensions
 vs = cv.VideoCapture(
-    "C:/Users/Legos/Desktop/yolov4/example_recordings/first_half_hour_resized.mp4"
+	"C:/Users/Legos/Desktop/yolov4/example_recordings/first_half_hour_resized.mp4"
 )
 writer = None
 (W, H) = (None, None)
 # try to determine the total number of frames in the video file
 try:
-    prop = cv.CAP_PROP_FRAME_COUNT
-    total = int(vs.get(prop))
-    print("[INFO] {} total frames in video".format(total))
+	prop = cv.CAP_PROP_FRAME_COUNT
+	total = int(vs.get(prop))
+	print("[INFO] {} total frames in video".format(total))
 # an error occurred while trying to determine the total
 # number of frames in the video file
 except:
-    print("[INFO] could not determine # of frames in video")
-    print("[INFO] no approx. completion time can be provided")
-    total = -1
+	print("[INFO] could not determine # of frames in video")
+	print("[INFO] no approx. completion time can be provided")
+	total = -1
 # loop over frames from the video file stream
 while True:
-    # read the next frame from the file
-    (grabbed, frame) = vs.read()
-    # if the frame was not grabbed, then we have reached the end
-    # of the stream
-    if not grabbed:
-        break
-    # if the frame dimensions are empty, grab them
-    if W is None or H is None:
-        (H, W) = frame.shape[:2]
-    # construct a blob from the input frame and then perform a forward
-    # pass of the YOLO object detector, giving us our bounding boxes
-    # and associated probabilities
-    blob = cv.dnn.blobFromImage(frame, 1 / 255.0, (416, 416), swapRB=True, crop=False)
-    net.setInput(blob)
-    start = time.time()
-    layerOutputs = net.forward(ln)
-    end = time.time()
-    # initialize our lists of detected bounding boxes, confidences,
-    # and class IDs, respectively
-    boxes = []
-    confidences = []
-    classIDs = []
-
-    # loop over each of the layer outputs
-    for output in layerOutputs:
-        # loop over each of the detections
-        for detection in output:
-            # extract the class ID and confidence (i.e., probability)
-            # of the current object detection
-            scores = detection[5:]
-            classID = np.argmax(scores)
-            confidence = scores[classID]
-            # filter out weak predictions by ensuring the detected
-            # probability is greater than the minimum probability
-            if confidence > 0.5:
-                # scale the bounding box coordinates back relative to
-                # the size of the image, keeping in mind that YOLO
-                # actually returns the center (x, y)-coordinates of
-                # the bounding box followed by the boxes' width and
-                # height
-                box = detection[0:4] * np.array([W, H, W, H])
-                (centerX, centerY, width, height) = box.astype("int")
-                # use the center (x, y)-coordinates to derive the top
-                # and and left corner of the bounding box
-                x = int(centerX - (width / 2))
-                y = int(centerY - (height / 2))
-                # update our list of bounding box coordinates,
-                # confidences, and class IDs
-                boxes.append([x, y, int(width), int(height)])
-                confidences.append(float(confidence))
-                classIDs.append(classID)
-
-    # apply non-maxima suppression to suppress weak, overlapping
-    # bounding boxes
-    indices = cv.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)
-    # ensure at least one detection exists
-    if len(indices) > 0:
-        for i in indices.flatten():
-            (x, y) = (boxes[i][0], boxes[i][1])
-            (w, h) = (boxes[i][2], boxes[i][3])
-            color = [int(c) for c in colors[classIDs[i]]]
-            cv.rectangle(frame, (x, y), (x + w, y + h), color, 2)
-            text = "{}: {:.4f}".format(classes[classIDs[i]], confidences[i])
-            cv.putText(frame, text, (x, y - 5), cv.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
-
-    cv.imshow("test", frame)
-    cv.waitKey(1)
+	# read the next frame from the file
+	(grabbed, frame) = vs.read()
+	# if the frame was not grabbed, then we have reached the end
+	# of the stream
+	if not grabbed:
+		break
+	# if the frame dimensions are empty, grab them
+	if W is None or H is None:
+		(H, W) = frame.shape[:2]
+	# construct a blob from the input frame and then perform a forward
+	# pass of the YOLO object detector, giving us our bounding boxes
+	# and associated probabilities
+	blob = cv.dnn.blobFromImage(frame, 1 / 255.0, (416, 416), swapRB=True, crop=False)
+	net.setInput(blob)
+	start = time.time()
+	layerOutputs = net.forward(ln)
+	end = time.time()
+	# initialize our lists of detected bounding boxes, confidences,
+	# and class IDs, respectively
+	boxes = []
+	confidences = []
+	classIDs = []
+
+	# loop over each of the layer outputs
+	for output in layerOutputs:
+		# loop over each of the detections
+		for detection in output:
+			# extract the class ID and confidence (i.e., probability)
+			# of the current object detection
+			scores = detection[5:]
+			classID = np.argmax(scores)
+			confidence = scores[classID]
+			# filter out weak predictions by ensuring the detected
+			# probability is greater than the minimum probability
+			if confidence > 0.5:
+				# scale the bounding box coordinates back relative to
+				# the size of the image, keeping in mind that YOLO
+				# actually returns the center (x, y)-coordinates of
+				# the bounding box followed by the boxes' width and
+				# height
+				box = detection[0:4] * np.array([W, H, W, H])
+				(centerX, centerY, width, height) = box.astype("int")
+				# use the center (x, y)-coordinates to derive the top
+				# and and left corner of the bounding box
+				x = int(centerX - (width / 2))
+				y = int(centerY - (height / 2))
+				# update our list of bounding box coordinates,
+				# confidences, and class IDs
+				boxes.append([x, y, int(width), int(height)])
+				confidences.append(float(confidence))
+				classIDs.append(classID)
+
+	# apply non-maxima suppression to suppress weak, overlapping
+	# bounding boxes
+	indices = cv.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)
+	# ensure at least one detection exists
+	if len(indices) > 0:
+		for i in indices.flatten():
+			(x, y) = (boxes[i][0], boxes[i][1])
+			(w, h) = (boxes[i][2], boxes[i][3])
+			color = [int(c) for c in colors[classIDs[i]]]
+			cv.rectangle(frame, (x, y), (x + w, y + h), color, 2)
+			text = "{}: {:.4f}".format(classes[classIDs[i]], confidences[i])
+			cv.putText(frame, text, (x, y - 5), cv.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
+
+	cv.imshow("test", frame)
+	cv.waitKey(1)
 
 cv.destroyAllWindows()

utils/setup/operators.py

@@ -62,20 +62,25 @@ def __init__(self, dt, u_x, u_y, std_acc, x_std_meas, y_std_meas, initial_state)
 		self.P = np.eye(self.A.shape[1])
 
 	def predict(self):
-		# Refer to :Eq.(9) and Eq.(10)
-		# in https://machinelearningspace.com/object-tracking-python/
-		# Update time state
-		# x_k =Ax_(k-1) + Bu_(k-1)     Eq.(9)
+		"""
+		Extrapolate the track based on its current position and velocity
+		Refer to :Eq.(9) and Eq.(10)
+		in https://machinelearningspace.com/object-tracking-python/
+		x_k =Ax_(k-1) + Bu_(k-1)     Eq.(9)
+		"""
 		self.x = np.dot(self.A, self.x) + np.dot(self.B, self.u)
 		# Calculate error covariance
 		# P= A*P*A' + Q               Eq.(10)
 		self.P = np.dot(np.dot(self.A, self.P), self.A.T) + self.Q
 		return self.x[0:2]
 
 	def update(self, z, flag):
+		"""
+		Update time state of the filter
 		# Refer to :Eq.(11), Eq.(12) and Eq.(13)  in
 		# https://machinelearningspace.com/object-tracking-python/
 		# S = H*P*H'+R
+		"""
 		if not flag:
 			# use prediction of previous
 			z = self.x[0:2]  # + (self.dt * self.x[:2])