|
| 1 | +import os |
| 2 | +import re |
| 3 | +import sys |
| 4 | +from concurrent.futures import ThreadPoolExecutor |
| 5 | +from datetime import datetime |
| 6 | + |
| 7 | +import cv2 as cv |
| 8 | +import matplotlib.pyplot as plt |
| 9 | +import numpy as np |
| 10 | +import pytesseract |
| 11 | + |
| 12 | + |
| 13 | +def is_display_attached(): |
| 14 | + # Check if the DISPLAY environment variable is set |
| 15 | + return "DISPLAY" in os.environ |
| 16 | + |
| 17 | + |
| 18 | +def extract_text_from_region(image, x, y, font_size, length): |
| 19 | + """ |
| 20 | + Extracts text from a specific region of the image. |
| 21 | + :param image: The image to extract text from. |
| 22 | + :param x: The x-coordinate of the top-left corner of the region. |
| 23 | + :param y: The y-coordinate of the top-left corner of the region. |
| 24 | + :param font_size: The font size of the text. |
| 25 | + :param length: The length of the text to extract. |
| 26 | + :return: The extracted text. |
| 27 | + """ |
| 28 | + margin = 5 |
| 29 | + y_adjusted = max(0, y - margin) |
| 30 | + x_adjusted = max(0, x - margin) |
| 31 | + height = y + font_size + margin |
| 32 | + width = x + length + margin |
| 33 | + # Define the region of interest (ROI) for text extraction |
| 34 | + roi = image[y_adjusted:height, x_adjusted:width] |
| 35 | + |
| 36 | + # Use Tesseract to extract text from the ROI |
| 37 | + return pytesseract.image_to_string(roi, lang="eng") |
| 38 | + |
| 39 | + |
| 40 | +def process_frame(frame_idx, frame): |
| 41 | + print("Processing Frame: ", frame_idx) |
| 42 | + |
| 43 | + timestamp_format = "%H:%M:%S:%f" |
| 44 | + timestamp_pattern = r"\b\d{2}:\d{2}:\d{2}:\d{3}\b" |
| 45 | + |
| 46 | + # Convert frame to grayscale for better OCR performance |
| 47 | + frame = cv.cvtColor(frame, cv.COLOR_BGR2GRAY) |
| 48 | + |
| 49 | + line_1 = extract_text_from_region(frame, 10, 10, 40, 600) |
| 50 | + line_2 = extract_text_from_region(frame, 10, 70, 40, 600) |
| 51 | + |
| 52 | + # Find the timestamps(Type: string) in the extracted text using regex |
| 53 | + tx_time = re.search(timestamp_pattern, line_1) |
| 54 | + rx_time = re.search(timestamp_pattern, line_2) |
| 55 | + |
| 56 | + if tx_time is None or rx_time is None: |
| 57 | + print("Error: Timestamp not found in the expected format.") |
| 58 | + return 0 |
| 59 | + |
| 60 | + # Convert the timestamps(Type: string) to time (Type: datetime) |
| 61 | + tx_time = datetime.strptime(tx_time.group(), timestamp_format) |
| 62 | + rx_time = datetime.strptime(rx_time.group(), timestamp_format) |
| 63 | + |
| 64 | + if tx_time is None or rx_time is None: |
| 65 | + print("Error: Timestamp not found in the expected format.") |
| 66 | + return 0 |
| 67 | + |
| 68 | + if tx_time > rx_time: |
| 69 | + print("Error: Transmit time is greater than receive time.") |
| 70 | + return 0 |
| 71 | + |
| 72 | + time_difference = rx_time - tx_time |
| 73 | + time_difference_ms = time_difference.total_seconds() * 1000 |
| 74 | + return time_difference_ms |
| 75 | + |
| 76 | + |
| 77 | +def main(): |
| 78 | + if len(sys.argv) < 2: |
| 79 | + print("Usage: python text-detection.py <input_video_file> <output_image_name>") |
| 80 | + sys.exit(1) |
| 81 | + |
| 82 | + input_video_file = sys.argv[1] |
| 83 | + cap = cv.VideoCapture(input_video_file) |
| 84 | + if not cap.isOpened(): |
| 85 | + print("Fatal: Could not open video file.") |
| 86 | + sys.exit(1) |
| 87 | + |
| 88 | + frame_idx = 0 |
| 89 | + time_differences = [] |
| 90 | + |
| 91 | + with ThreadPoolExecutor(max_workers=40) as executor: |
| 92 | + futures = [] |
| 93 | + while True: |
| 94 | + ret, frame = cap.read() |
| 95 | + if not ret: |
| 96 | + break |
| 97 | + |
| 98 | + futures.append(executor.submit(process_frame, frame_idx, frame)) |
| 99 | + frame_idx += 1 |
| 100 | + |
| 101 | + for future in futures: |
| 102 | + time_differences.append(future.result()) |
| 103 | + |
| 104 | + # Filter out zero values from time_differences |
| 105 | + non_zero_time_differences = [td for td in time_differences if td != 0] |
| 106 | + |
| 107 | + # Calculate the average latency excluding zero values |
| 108 | + if non_zero_time_differences: |
| 109 | + average_latency = np.mean(non_zero_time_differences) |
| 110 | + |
| 111 | + # Filter out anomaly peaks that differ more than 25% from the average for average calculation |
| 112 | + filtered_time_differences = [ |
| 113 | + td |
| 114 | + for td in non_zero_time_differences |
| 115 | + if abs(td - average_latency) <= 0.25 * average_latency |
| 116 | + ] |
| 117 | + |
| 118 | + # Calculate the average latency using the filtered data |
| 119 | + filtered_average_latency = np.mean(filtered_time_differences) |
| 120 | + else: |
| 121 | + print( |
| 122 | + "Fatal: No timestamps recognized in the video. No data for calculating latency." |
| 123 | + ) |
| 124 | + sys.exit(1) |
| 125 | + |
| 126 | + # Plot the non-zero data |
| 127 | + plt.plot(non_zero_time_differences, marker="o") |
| 128 | + plt.title("End-to-End Latency — Media Transport Library") |
| 129 | + plt.xlabel("Frame Index") |
| 130 | + plt.ylabel("Latency, ms") |
| 131 | + plt.grid(True) |
| 132 | + |
| 133 | + # Adjust the layout to create more space for the text |
| 134 | + plt.subplots_adjust(bottom=0.5) |
| 135 | + |
| 136 | + # Prepare text for display and stdout |
| 137 | + average_latency_text = ( |
| 138 | + f"Average End-to-End Latency: {filtered_average_latency:.2f} ms" |
| 139 | + ) |
| 140 | + file_name = os.path.basename(input_video_file) |
| 141 | + file_mod_time = datetime.fromtimestamp(os.path.getmtime(input_video_file)).strftime( |
| 142 | + "%Y-%m-%d %H:%M:%S" |
| 143 | + ) |
| 144 | + file_info_text = f"File: {file_name} | Last modified: {file_mod_time} UTC" |
| 145 | + width = int(cap.get(cv.CAP_PROP_FRAME_WIDTH)) |
| 146 | + height = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT)) |
| 147 | + fps = cap.get(cv.CAP_PROP_FPS) |
| 148 | + video_properties_text = f"Resolution: {width}x{height} | FPS: {fps:.2f}" |
| 149 | + |
| 150 | + cap.release() |
| 151 | + |
| 152 | + # Display text on the plot |
| 153 | + plt.text( |
| 154 | + 0.5, |
| 155 | + -0.55, |
| 156 | + average_latency_text, |
| 157 | + horizontalalignment="center", |
| 158 | + verticalalignment="center", |
| 159 | + transform=plt.gca().transAxes, |
| 160 | + ) |
| 161 | + plt.text( |
| 162 | + 0.5, |
| 163 | + -0.85, |
| 164 | + file_info_text, |
| 165 | + horizontalalignment="center", |
| 166 | + verticalalignment="center", |
| 167 | + transform=plt.gca().transAxes, |
| 168 | + ) |
| 169 | + plt.text( |
| 170 | + 0.5, |
| 171 | + -1, |
| 172 | + video_properties_text, |
| 173 | + horizontalalignment="center", |
| 174 | + verticalalignment="center", |
| 175 | + transform=plt.gca().transAxes, |
| 176 | + ) |
| 177 | + if is_display_attached(): |
| 178 | + plt.show() |
| 179 | + |
| 180 | + if len(sys.argv) == 3: |
| 181 | + filename = sys.argv[2] |
| 182 | + if not filename.endswith(".jpg"): |
| 183 | + filename += ".jpg" |
| 184 | + print("Saving the latency chart to: ", filename) |
| 185 | + plt.savefig(filename, format="jpg", dpi=300) |
| 186 | + |
| 187 | + # Print text to stdout |
| 188 | + print(file_info_text) |
| 189 | + print(video_properties_text) |
| 190 | + print(average_latency_text) |
| 191 | + |
| 192 | + |
| 193 | +main() |
0 commit comments