def GetObjectsList(name,expansion): path_yolo=os.path.abspath("yolo.h5") video=VideoFileClip(f"{path}.{expansion}") video=video.set_fps(1) video=video.without_audio() video=video.fx(vfx.speedx,5) video.write_videofile(f"{name}_temp.{expansion}") ListObjects=[] def forFrame(frame_number, output_array, output_count): for k in output_array: if k["name"] in ListObjects: pass else: ListObjects.append(k["name"]) video_detector = VideoObjectDetection() video_detector.setModelTypeAsYOLOv3() video_detector.setModelPath(path_yolo) video_detector.loadModel() video_detector.detectObjectsFromVideo(input_file_path=f"{name}_temp.{expansion}", save_detected_video=False, per_frame_function=forFrame, minimum_percentage_probability=70,log_progress=False,display_percentage_probability=False) os.remove(f"{name}_temp.{expansion}") return ListObjects
def main(): execution_path = os.getcwd() dic = {} def forFrame(frame_number, output_array, output_count): print("Frame Number : ", frame_number) dic[frame_number] = output_array video_detector = VideoObjectDetection() video_detector.setModelTypeAsYOLOv3() video_detector.setModelPath(os.path.join(execution_path, "yolo.h5")) video_detector.loadModel(detection_speed="fast") video_detector.detectObjectsFromVideo(input_file_path=os.path.join( execution_path, "video.mp4"), save_detected_video=False, frames_per_second=20, per_frame_function=forFrame, minimum_percentage_probability=30) for k, v in dic.items(): print(str(k) + " : " + str(v)) video_path = video_detector.detectObjectsFromVideo( input_file_path=os.path.join(execution_path, "video.mp4"), output_file_path=os.path.join(execution_path, "video_output"), frames_per_second=29, minimum_percentage_probability=30)
class VideoThread(Thread): opencvCamera = None; ShouldClose = False Video_Detect = None OutPath = VideoPath #OutPath = r"C:\Users\JackXu\PycharmProjects\untitled\VideoProcessing" def __init__(self,CameraObj): Thread.__init__(self) self.opencvCamera = CameraObj def run(self): if (self.ShouldClose) == True: self.exit() else: self.Video_Detect = VideoObjectDetection() self.Video_Detect.setModelTypeAsYOLOv3() #BeginTime = time.time() self.Video_Detect.setModelPath(ModelPath) #EndTime = time.time() #print(" How long to set and load", EndTime - BeginTime) #self.Video_Detect.setModelPath(r"C:\Users\JackXu\PycharmProjects\untitled\yolo.h5") self.Video_Detect.loadModel("fastest") self.Video_Detect.detectObjectsFromVideo(camera_input= self.opencvCamera,return_detected_frame=True, output_file_path=VideoPath, frames_per_second=30, minimum_percentage_probability=40, per_frame_function=showCV, save_detected_video=False) self.ShouldClose = True
def detect(var_name, var_model_path): # ## var_in_path = os.path.join(os.getcwd(), "cache", var_name + "IN.mp4") var_temp_path = os.path.join(os.getcwd(), "cache", var_name + "TEMP") # var_out_path = os.path.join(os.getcwd(), "cache", var_name + "OUT.mp4") # ## Initiate the detector. var_detector = VideoObjectDetection() var_detector.setModelTypeAsRetinaNet() var_detector.setModelPath(var_model_path) var_detector.loadModel(detection_speed="fast") # ## Perform the object detection. var_detector.detectObjectsFromVideo(input_file_path=var_in_path, output_file_path=var_temp_path, frames_per_second=30, log_progress=True, frame_detection_interval=1, minimum_percentage_probability=15) # ## Convert the format of output video to MP4. var_clip = moviepy.VideoFileClip("cache/" + var_name + "TEMP.avi") var_clip.write_videofile("cache/" + var_name + "OUT.mp4") os.remove(var_temp_path + ".avi") return "Detect Finish!"
def detect(): """ Count number of people in test video per second """ execution_path = os.getcwd() # Add your camera credential # camera = cv2.VideoCapture('rtsp://*****:*****@0.0.0.0') # Test Video camera = cv2.VideoCapture('test.mp4') def getSizeVD(vcap): """ Get Size of Camera Frame """ if vcap.isOpened(): width = vcap.get(3) height = vcap.get(4) return width*height video_size = getSizeVD(camera) def forFrame(frame_number, output_array, output_count): """ Get size of person on frame """ size_list = [] for item in output_array: if item.get('name', '') is 'person': if item.get('box_points', []): [x1,y1,x2,y2] = item.get('box_points', []) size = (x2 - x1) * (y2 - y1) size_list.append(size) if size_list: if max(size_list) > video_size * PERCENT: # Add your shell script print("Detected Closed Person") # Create Video Detection Module based on Yolo video_detector = VideoObjectDetection() video_detector.setModelTypeAsYOLOv3() video_detector.setModelPath(os.path.join(execution_path, "yolo.h5")) video_detector.loadModel() video_detector.detectObjectsFromVideo( camera_input=camera, output_file_path=os.path.join(execution_path, "test"), # save_detected_video=False, frames_per_second=10, per_frame_function=forFrame, minimum_percentage_probability=30 )
def start(self): detector = VideoObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(self.execution_path, "resnet50_coco_best_v2.0.1.h5")) detector.loadModel() detector.detectObjectsFromVideo(camera_input=self.cap, output_file_path=os.path.join( self.execution_path, "video_frame_analysis"), frames_per_second=30, per_frame_function=forFrame, minimum_percentage_probability=70, return_detected_frame=True)
def car_type_more_tell_video(path): execution_path = os.getcwd() detector = VideoObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(execution_path, "resnet50_coco_best_v2.0.1.h5")) detector.loadModel("fast") detector.detectObjectsFromVideo( input_file_path=os.path.join(execution_path, path), output_file_path=os.path.join(execution_path, "test"), frames_per_second=20, log_progress=True) print("success")
def detect_with_imageai_retinanet(): def forFrame(frame_number, output_array, output_count): """Детекция bounding box'ов""" print("ДЛЯ КАДРА " , frame_number) print('Объект:', output_array[0]['name']) print('Вероятность:', output_array[0]['percentage_probability']) print('Bounding box:', output_array[0]['box_points']) print("Уникальных объектов: ", output_count[output_array[0]['name']]) print("------------END OF A FRAME --------------\n\n") execution_path = os.getcwd() camera = cv2.VideoCapture(0) detector = VideoObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath(os.path.join(execution_path, "weights/resnet50_coco_best_v2.0.1.h5")) detector.loadModel() video_model = detector.detectObjectsFromVideo(camera_input=camera, output_file_path=os.path.join(execution_path, "camera_detected_video"), frames_per_second=20, per_frame_function=forFrame, minimum_percentage_probability=40)
def detect_with_imageai_yolov3(): """ <-- CODE IF YOU NEED TO LOAD SOME VIDEO --> execution_path = os.getcwd() detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath(os.path.join(execution_path, "weights/yolo.h5")) detector.loadModel() video_path = detector.detectObjectsFromVideo( input_file_path=os.path.join(execution_path, "example_video.mp4"), output_file_path=os.path.join(execution_path, "Yolo.mp4"), frames_per_second=20, log_progress=True ) """ execution_path = os.getcwd() camera = cv2.VideoCapture(0) detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath(os.path.join(execution_path, "weights/yolo.h5")) detector.loadModel() video_model = detector.detectObjectsFromVideo(camera_input=camera, output_file_path=os.path.join(execution_path, "camera_detected_video"), frames_per_second=20, log_progress=True, minimum_percentage_probability=40)
class MyDetector: myDetector = None def __init__(self): execution_path = os.getcwd() self.myDetector = VideoObjectDetection() # self.myDetector.setModelTypeAsYOLOv3() # self.myDetector.setModelPath(os.path.join(execution_path, "yolo.h5")) #self.myDetector.loadModel(detection_speed="flash") def process_ml(self): execution_path = os.getcwd() self.myDetector = VideoObjectDetection() self.myDetector.setModelTypeAsYOLOv3() self.myDetector.setModelPath(os.path.join(execution_path, "yolo.h5")) self.myDetector.loadModel(detection_speed="flash") video_path = self.myDetector.detectObjectsFromVideo(input_file_path=os.path.join(execution_path, "input.mp4"), output_file_path=os.path.join(execution_path, "upload/output_detected_1"), frames_per_second=29, per_frame_function=forFrame, per_second_function=forSeconds, per_minute_function=forMinute, video_complete_function=forFull, minimum_percentage_probability=10, log_progress=True) return video_path
def capture(self, callback, gray=False): if not self.cap: sys.exit('The capture is not ready') while True: # esc, q ch = cv2.waitKey(10) & 0xFF if ch == 27 or ch == ord('q'): break t = cv2.getTickCount() execution_path = os.getcwd() detector = VideoObjectDetection() detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(os.path.join(execution_path , "yolo-tiny.h5")) detector.loadModel() video_path = detector.detectObjectsFromVideo( camera_input=self.cap, output_file_path=os.path.join(execution_path, "camera_detected_video"), frames_per_second=10, log_progress=True, minimum_percentage_probability=30) print(video_path) if self.openni: if not self.cap.grab(): sys.exit('Grabs the next frame failed') ret, depth = self.cap.retrieve(cv2.CAP_OPENNI_DEPTH_MAP)
def test_video_detection_retinanet_analysis(): try: keras.backend.clear_session() except: None detector = VideoObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath(model_path=os.path.join( main_folder, "data-models", "resnet50_coco_best_v2.0.1.h5")) detector.loadModel(detection_speed="fastest") video_path = detector.detectObjectsFromVideo( input_file_path=video_file, output_file_path=video_file_output, save_detected_video=True, frames_per_second=30, log_progress=True, per_frame_function=forFrame, per_second_function=forSecond, return_detected_frame=True) assert os.path.exists(video_file_output + ".avi") assert isinstance(video_path, str) os.remove(video_file_output + ".avi")
def start(): global vf ifp = entry_file_path.get() ofp = entry_file_path1.get() if vf == 0: try: print("Starting to render video") detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath(os.path.join(exec_path, "yolo.h5")) detector.loadModel() except: wget.download( "https://github.com/OlafenwaMoses/ImageAI/releases/download/1.0/yolo.h5" ) print("Starting to render video") detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath(os.path.join(exec_path, "yolo.h5")) detector.loadModel() list = detector.detectObjectsFromVideo( input_file_path=os.path.join(exec_path, ifp), output_file_path=os.path.join(exec_path, ofp), frames_per_second=20) label = Label(root, text="Succeful!", fg="green") label.pack() elif vf == 1: try: print("Starting to render photo") detector = ObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(exec_path, "resnet50_coco_best_v2.0.1.h5")) detector.loadModel() except OSError: wget.download( "https://github.com/OlafenwaMoses/ImageAI/releases/download/1.0/resnet50_coco_best_v2.0.1.h5" ) print("Starting to render photo") detector = ObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(exec_path, "resnet50_coco_best_v2.0.1.h5")) detector.loadModel() list = detector.detectObjectsFromImage( input_image=os.path.join(exec_path, ifp), output_image_path=os.path.join(exec_path, ofp), display_percentage_probability=True, display_object_name=True) label = Label(root, text="Succeful!", fg="green") label.pack() elif vf == 2: image = face_recognition.load_image_file(exec_path + "/" + ifp) face_landmarks_list = face_recognition.face_landmarks(image) pil_image = Image.fromarray(image) d = ImageDraw.Draw(pil_image) for face_landmarks in face_landmarks_list: for facial_feature in face_landmarks.keys(): d.line(face_landmarks[facial_feature], width=5) pil_image.show()
def detected(): form = detectForm(request.args) if form.validate(): input_path = form.data['inputpath'] output_path = form.data['outputpath'] videoName = form.data['videoname'] try: detector = VideoObjectDetection() start = time.time() detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(input_path, "resnet50_coco_best_v2.0.1.h5")) detector.loadModel(detection_speed="fastest") video_path = detector.detectObjectsFromVideo( input_file_path=output_path, output_file_path=os.path.join(input_path, "detected" + videoName), frames_per_second=10, log_progress=True) convert(video_path, input_path + "/dectected" + videoName) end = time.time() processtime = end - start return jsonify({ 'video_path': video_path, 'processtime': processtime }) except Exception as e: raise e return jsonify({'error': 'no correct form'})
def object_detection(input_file, out_name, model='ResNet'): video_detector = VideoObjectDetection() if model == "ResNet": video_detector.setModelTypeAsRetinaNet() video_detector.setModelPath( os.path.join(execution_path, "pretranined_models/resnet50_coco_best_v2.0.1.h5")) elif model == "Yolo": video_detector.setModelTypeAsYOLOv3() video_detector.setModelPath( os.path.join(execution_path, "pretranined_models/yolo.h5")) else: video_detector.setModelTypeAsTinyYOLOv3() video_detector.setModelPath( os.path.join(execution_path, "pretranined_models/yolo-tiny.h5")) video_detector.loadModel() vi = video_detector.detectObjectsFromVideo( input_file_path=os.path.join(execution_path, input_file), output_file_path=os.path.join(execution_path, out_name), frames_per_second=10, per_second_function=forSeconds, per_frame_function=forFrame, per_minute_function=forMinute, minimum_percentage_probability=30)
def detectObjects(self): detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath("yolo.h5") detector.loadModel() video_path = detector.detectObjectsFromVideo(camera_input=self.cam, save_detected_video = True, per_frame_function = self.forFrame, output_file_path = "temp.avi" , log_progress=True, return_detected_frame= True) return
def test_video_detection_tiny_yolov3(clear_keras_session): detector = VideoObjectDetection() detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(model_path=os.path.join(main_folder, "data-models", "yolo-tiny.h5")) detector.loadModel(detection_speed="fast") video_path = detector.detectObjectsFromVideo(input_file_path=video_file, output_file_path=video_file_output, save_detected_video=True, frames_per_second=30, log_progress=True) assert os.path.exists(video_file_output + ".avi") assert isinstance(video_path, str) os.remove(video_file_output + ".avi")
def detecting(): video_detector = VideoObjectDetection() video_detector.setModelTypeAsRetinaNet() video_detector.setModelPath(os.path.join(execution_path, "resnet50_coco_best_v2.0.1_4.h5")) # video_detector.setModelPath(os.path.join(execution_path, "v2.h5")) video_detector.loadModel() vidcap = VideoCap() camera = vidcap.camera() video_path = video_detector.detectObjectsFromVideo(camera_input=camera, save_detected_video = False, frames_per_second=20, log_progress=True, minimum_percentage_probability=30, per_frame_function=forFrame, return_detected_frame=True)
def detect_text(file, output_name): detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath("yolo.h5") detector.loadModel() video_path = detector.detectObjectsFromVideo(input_file_path=file, output_file_path=output_name, frames_per_second=29, log_progress=True) return video_path
def tinyYoloVideo(video, model, output): detector = VideoObjectDetection() detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(model) detector.loadModel() start_time = time.time() video_path = detector.detectObjectsFromVideo(input_file_path=video, output_file_path=output, frames_per_second=29, log_progress=True) print(video_path) print("Total time: %s seconds" % (time.time() - start_time))
class Detection: def __init__(self): self.path = os.getcwd() self.detector = VideoObjectDetection() self.detector.setModelTypeAsYOLOv3() self.detector.setModelPath("ObjectDetectionTensorflow/yolo.h5") self.detector.loadModel(detection_speed="fast") self.imgDetector = ObjectDetection() self.imgDetector.setModelTypeAsYOLOv3() self.imgDetector.setModelPath("ObjectDetectionTensorflow/yolo.h5") self.imgDetector.loadModel() self.camera = cv2.VideoCapture(0) def liveVideo(self): #Live to Video videoPath = self.detector.detectObjectsFromVideo( camera_input=self.camera, output_file_path=os.path.join(self.path, "Loaded_Video"), frames_per_second=30, log_progress=True, minimum_percentage_probability=80) print(videoPath) cv2.imshow('video', videoPath) def liveVideoShow(self): #Live video detection while True: ret, frame = self.camera.read() img = PIL.Image.fromarray(frame) img.save("ObjectDetectionTensorflow/images/pic.png") detected = self.imgDetector.detectCustomObjectsFromImage( input_image="ObjectDetectionTensorflow/images/pic.png", output_image_path="ObjectDetectionTensorflow/images/pic.png", minimum_percentage_probability=40) for eachObject in detected: print(eachObject["name"], " : ", eachObject["percentage_probability"], " : ", eachObject["box_points"]) print("--------------------------------") if cv2.waitKey(33) == ord('a'): break img = mpimg.imread("ObjectDetectionTensorflow/images/pic.png") cv2.imshow('video', img)
def getVideo(request): if request.method == "POST": try: file = request.FILES['sentFile'] # except: return render(request, 'homepage.html') import uuid unique_filename = str(uuid.uuid4()) file_name = default_storage.save(unique_filename, file) # Reading file from storage file = default_storage.open(file_name) file_url = default_storage.url(file_name) detector = VideoObjectDetection() detector.setModelTypeAsRetinaNet() path = os.path.join(settings.MODELS, "resnet50_coco_best_v2.0.1.h5") detector.setModelPath(path) detector.loadModel(detection_speed='faster') item = set() def forFrame(frame_number, output_array, output_count): for i in output_array: item.add(i['name']) video_path = detector.detectObjectsFromVideo(input_file_path='media/'+unique_filename, output_file_path='media/imagetest_video' , frames_per_second=20, log_progress=True, minimum_percentage_probability=30,save_detected_video=True,per_frame_function=forFrame) categoryName = objectCategory.objects.filter(object__in=item).values_list('categoryName', flat=True) ac = AdvertisementCategory.objects.filter(id__in=categoryName) ads = Advertisement.objects.filter(categoryName__in=ac) if len(ads)==0: return render(request, 'failPredictions.html') context = { 'ac': ac, 'ads': ads, } return render(request, 'vid_predictions.html',context) else: return render(request, 'homepage2.html')
def videoIdentify(input_dir, output_dir): execution_path = os.getcwd() detector = VideoObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(execution_path, "resnet50_coco_best_v2.0.1.h5")) detector.loadModel() video_path = detector.detectObjectsFromVideo(input_file_path=input_dir, output_file_path=output_dir, frames_per_second=20, log_progress=True) print(video_path)
def test_object_default(path_in, path_out, suffix='object_default', path_model=os.path.join(os.getcwd(), '../models/yolo.h5'), speed='fast'): detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath(path_model) detector.loadModel(detection_speed=speed) #fast, faster, fastest, flash print(f'starting {suffix}') time_0 = time.time() detector.detectObjectsFromVideo(input_file_path=path_in, output_file_path=f'{path_out}_{suffix}', frames_per_second=20, per_frame_function=pfh.per_frame_handler, minimum_percentage_probability=10, return_detected_frame=True) print(f'mode {suffix} finished, elapsed time : {time.time() - time_0}s')
def detect_objects(input_file_path, detection_confidence_threshold=60): # detection_confidence_threshold (int between 1 and 99) is the minimum detector confidence needed to include an object # Create object detector based on RetinaNet and load model weights detector = VideoObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath('resnet50_coco_best_v2.0.1.h5') detector.loadModel() all_frames = [] # Generates a record of all objects detected def forFrame(frame_number, output_array, output_count): all_frames.append(output_array) if frame_number % 100 == 0: print(input_file_path + ' Frame ' + str(frame_number)) detector.detectObjectsFromVideo( input_file_path=input_file_path, output_file_path='labeled_video', frames_per_second=30, per_frame_function=forFrame, minimum_percentage_probability=detection_confidence_threshold) return all_frames
def detect_with_imageai_yolotiny(): execution_path = os.getcwd() camera = cv2.VideoCapture(0) detector = VideoObjectDetection() detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(os.path.join(execution_path, "weights/yolo_tiny.h5")) detector.loadModel() video_model = detector.detectObjectsFromVideo(camera_input=camera, output_file_path=os.path.join(execution_path, "camera_detected_video"), frames_per_second=20, log_progress=True, minimum_percentage_probability=40)
def object_detect(time): execution_path = os.getcwd() camera = cv2.VideoCapture(0) detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath(os.path.join(execution_path, "yolo.h5")) detector.loadModel() video_path = detector.detectObjectsFromVideo( camera_input=camera, output_file_path=os.path.join(execution_path, "camera_detected_video"), frames_per_second=20, per_frame_function=forFrame, minimum_percentage_probability=50, save_detected_video=True) return redirect(index)
def start_analys_frames(): path = 'Data/' file = ['yolo.h5', 'video.avi', 'frames'] detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath(path + file[0]) detector.loadModel() video_path = detector.detectObjectsFromVideo( input_file_path=path + file[1], output_file_path=path + file[2], minimum_percentage_probability=40, frames_per_second=30, log_progress=True) c.convert()
def test_video_detection_retinanet(): detector = VideoObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath(model_path=os.path.join( main_folder, "data-models", "resnet50_coco_best_v2.0.1.h5")) detector.loadModel(detection_speed="fastest") video_path = detector.detectObjectsFromVideo( input_file_path=video_file, output_file_path=video_file_output, save_detected_video=True, frames_per_second=30, log_progress=True) assert os.path.exists(video_file_output + ".avi") assert isinstance(video_path, str) os.remove(video_file_output + ".avi")
class itemCamSaveFile(): def __init__(self, setModePath): self.execution_path = os.getcwd() self.detector = VideoObjectDetection() self.detector.setModelTypeAsYOLOv3() self.detector.setModelPath( os.path.join(self.execution_path, setModePath)) self.detector.loadModel() def item_CamSaveFile(self, camera, outputFile): video_path = self.detector.detectObjectsFromVideo( camera_input=camera, output_file_path=os.path.join(self.execution_path, outputFile), frames_per_second=10, log_progress=True, minimum_percentage_probability=20) print(video_path)
from imageai.Detection import VideoObjectDetection import os execution_path = os.getcwd() detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath( os.path.join(execution_path , "yolo.h5")) detector.loadModel() video_path = detector.detectObjectsFromVideo(input_file_path=os.path.join(execution_path, "traffic.mp4"), output_file_path=os.path.join(execution_path, "traffic_detected") , frames_per_second=20, log_progress=True) print(video_path)
this_colors.append(color_index[eachItem]) global resized if (resized == False): manager = plt.get_current_fig_manager() manager.resize(width=1000, height=500) resized = True plt.subplot(1, 2, 1) plt.title("Frame : " + str(frame_number)) plt.axis("off") plt.imshow(returned_frame, interpolation="none") plt.subplot(1, 2, 2) plt.title("Analysis: " + str(frame_number)) plt.pie(sizes, labels=labels, colors=this_colors, shadow=True, startangle=140, autopct="%1.1f%%") plt.pause(0.01) video_detector = VideoObjectDetection() video_detector.setModelTypeAsYOLOv3() video_detector.setModelPath(os.path.join(execution_path, "yolo.h5")) video_detector.loadModel() plt.show() video_detector.detectObjectsFromVideo(input_file_path=os.path.join(execution_path, "traffic.mp4"), output_file_path=os.path.join(execution_path, "video_frame_analysis") , frames_per_second=20, per_frame_function=forFrame, minimum_percentage_probability=30, return_detected_frame=True)