def Crop_video(self, params): global input_video if 'videoName' in params.keys(): input_video = str(params['videoName']) print(input_video) else: return "Error: No Video Name field provided. Please specify an url." detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath( os.path.join(parent, 'Mobilaty\\project\\public\\yolo.h5')) detector.loadModel() custom_objects = detector.CustomObjects(cell_phone=True) video_path = detector.detectCustomObjectsFromVideo( custom_objects=custom_objects, input_file_path=os.path.join(Base_Video_path, input_video), output_file_path=os.path.join(Base_Video_path, "traffic_custom_detected"), save_detected_video=False, frames_per_second=1, per_frame_function=forFrame) os.remove(os.path.join(Base_Video_path, "traffic_custom_detected")) return "Done!"
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 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 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()
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 detection(input_path, output_path, yolo_model_path): """The function opens the input video and goes through each frame. Performs object recognition for each frame by using a YOLO model and writes the frame including the detection to the output video. :param input_path: input video path :type input_path: string :param output_path: output video path :type output_path: string :param yolo_model_path: YOLO model path :type yolo_model_path: string :return: None """ detector = VideoObjectDetection() # this function sets the model type of the object # detection instance you created to the YOLOv3 model detector.setModelTypeAsYOLOv3() # this function accepts a string that must be the # path to the model file, it must correspond to the # model typeset for the object detection instance detector.setModelPath(yolo_model_path) # this function loads the model from the path given detector.loadModel() # the function performs object detection on a video # file or video live-feed after the model has been # loaded into the instance that was created detector.detectCustomObjectsFromVideo(input_file_path=input_path, output_file_path=output_path, frames_per_second=20, log_progress=True)
def objectDection(execution_path, save_path, fileName): ''' detecting object for each frame ''' detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath(os.path.join(execution_path, "yolo.h5")) detector.loadModel() global FILENAME FILENAME = fileName.split('.')[0] custom_objects = detector.CustomObjects(car=True, truck=True, bus=True) video_path = detector.detectCustomObjectsFromVideo( custom_objects=custom_objects, input_file_path=os.path.join(execution_path, fileName), output_file_path=os.path.join(save_path, fileName.split(".")[0] + "_detected"), frames_per_second=30, frame_detection_interval=1, per_frame_function=forFrame, # per_second_function= forSecond, minimum_percentage_probability=79, # return_detected_frame=True, log_progress=True) return (fileName.split(".")[0] + "_detected.avi")
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 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 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)
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 load_model(): global detector global graph detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath(os.path.join(execution_path, "video-yolo.h5")) detector.loadModel() graph = tf.get_default_graph()
def test_video_detection_yolov3(clear_keras_session): detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath(model_path=os.path.join(main_folder, "data-models", "yolo.h5")) detector.loadModel(detection_speed="faster") 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 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 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
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 videoDetectorInit() : showThreadInfo("VI") global video_detector if video_detector == None : video_detector = VideoObjectDetection() video_detector.setModelTypeAsYOLOv3() video_detector.setModelPath(os.path.join(execution_path, "yolo.h5")) # Download the model via this link https://github.com/OlafenwaMoses/ImageAI/releases/tag/1.0 loginfo("model startload ", datetime.datetime.now()) video_detector.loadModel(detection_speed="normal") loginfo("videoDetector init: ", video_detector) loginfo("model loaded ", datetime.datetime.now()) return
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)
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)
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 Object_detect(): filename = filedialog.askopenfilename(initialdir="/", title="Select file", filetypes=(("jpeg files", "*.mp4"), ("all files", "*.*"))) detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath(os.path.join(execution_path, "yolo.h5")) detector.loadModel() video_path = detector.detectObjectsFromVideo( input_file_path=filename, output_file_path=os.path.join(execution_path, "traffic_mini_detected_1"), frames_per_second=20, per_second_function=forSeconds, minimum_percentage_probability=30, return_detected_frame=False, log_progress=True) print(video_path)
def detect_objects_yolo(filename, fps=30): # 0,1 is recording from the camera camera = cv2.VideoCapture(0) detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath(os.path.join(os.getcwd(), "models/yolo.h5")) detector.loadModel() plt.show() video_path = detector.detectObjectsFromVideo( camera_input=camera, output_file_path=filename, frames_per_second=fps, log_progress=True, #per_second_function=forSecond, return_detected_frame=True, minimum_percentage_probability=40) camera.release() # Close the window / Release webcam # De-allocate any associated memory usage cv2.destroyAllWindows()
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')
class VideoProcessor(): def __init__(self): self.execution_path = os.getcwd() self.configureVideoDetector() def configureVideoDetector(self): self.detector = VideoObjectDetection() self.detector.setModelTypeAsYOLOv3() self.detector.setModelPath( os.path.join(self.execution_path , yolo_network_path)) self.detector.loadModel() def detectObjectsFromVideo(self, filePath: str): video_file_path = filePath outPath = 'out/' + video_file_path.replace('/', '-') video_path = self.detector.detectObjectsFromVideo(input_file_path=os.path.join( self.execution_path, video_file_path), output_file_path = os.path.join(self.execution_path, outPath), frames_per_second = frames_per_second, log_progress = True) # Check for the information we can have processing the video print(video_path)
print("Output average count for unique objects in the last second: ", average_output_count) print("------------END OF A SECOND --------------") def forMinute(minute_number, output_arrays, count_arrays, average_output_count): print("MINUTE : ", minute_number) print("Array for the outputs of each frame ", output_arrays) print("Array for output count for unique objects in each frame : ", count_arrays) print("Output average count for unique objects in the last minute: ", average_output_count) print("------------END OF A MINUTE --------------") video_detector = VideoObjectDetection() video_detector.setModelTypeAsYOLOv3() video_detector.setModelPath(os.path.join(execution_path, "yolo.h5")) video_detector.loadModel(detection_speed="faster") video_path = video_detector.detectObjectsFromVideo( input_file_path=os.path.join(execution_path, "1080p_test.mp4"), output_file_path=os.path.join(execution_path, "test1080"), frames_per_second=30, log_progress=True) print(video_path) e = time.time() totaltime = s - e print(totaltime)
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)
import cv2 as cv from imageai.Detection import VideoObjectDetection import os execution_path = os.getcwd() fourcc = cv.VideoWriter_fourcc(*'XVID') out = cv.VideoWriter('output.avi', fourcc, 29.97, (1280, 720)) def forFrame(frame_number, output_array, output_count, detected_frame): frame = detected_frame frame = cv.cvtColor(frame, cv.COLOR_BGR2RGB) out.write(frame) detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath(os.path.join(execution_path, "yolo.h5")) detector.loadModel() detector.detectObjectsFromVideo(input_file_path=os.path.join( execution_path, "piter2.mp4"), save_detected_video=False, frames_per_second=29.97, log_progress=True, per_frame_function=forFrame, return_detected_frame=True) out.release()
def predict(): data = request.get_json(force=True) body = data.get('data') filew = body.get('file') print(filew) decoded_string = base64.b64decode(filew) with open('1.mp4', 'wb') as wfile: wfile.write(decoded_string) video = cv2.VideoCapture("1.mp4") # Find OpenCV version (major_ver, minor_ver, subminor_ver) = (cv2.__version__).split('.') fps = 0 if int(major_ver) < 3: fps = round(video.get(cv2.cv.CV_CAP_PROP_FPS)) print("Frames per second using video.get(cv2.cv.CV_CAP_PROP_FPS): {0}". format(fps)) else: fps = round(video.get(cv2.CAP_PROP_FPS)) print( "Frames per second using video.get(cv2.CAP_PROP_FPS) : {0}".format( fps)) video.release() # def incr(): # global varib # varib = 'bbbbbbbb' # incr() # print("varib", varib) def forSeconds(second_number, output_arrays, count_arrays, average_output_count): print("SECOND : ", second_number) # print("Array for the outputs of each frame ", output_arrays) # print("Array for output count for unique objects in each frame : ", count_arrays) # print("Output average count for unique objects in the last second: ", average_output_count) # print("------------END OF A SECOND --------------") def forFull(output_arrays, count_arrays, average_output_count): #Perform action on the 3 parameters returned into the function # print("Array for the outputs of each frame ", output_arrays) # print("Array for output count for unique objects in each frame : ", count_arrays) # print("Output average count for unique objects in the last second: ", average_output_count) global objects objects = output_arrays video_detector = VideoObjectDetection() video_detector.setModelTypeAsYOLOv3() video_detector.setModelPath(os.path.join(execution_path, "yolo.h5")) video_detector.loadModel() video_detector.detectObjectsFromVideo( input_file_path=os.path.join(execution_path, "1.mp4"), output_file_path=os.path.join(execution_path, "traffic_detected"), frames_per_second=fps, per_second_function=forSeconds, video_complete_function=forFull, minimum_percentage_probability=30) def convert_avi_to_mp4(avi_file_path, output_name): os.popen( "ffmpeg -i '{input}' -ac 2 -b:v 2000k -c:a aac -c:v libx264 -b:a 160k -vprofile high -bf 0 -strict experimental -f mp4 './static/{output}.mp4'" .format(input=avi_file_path, output=output_name)) return True convert_avi_to_mp4("traffic_detected.avi", "converted") json_dump = pd.Series(objects).to_json(orient='values') print("==============", json_dump) return json_dump
class appearance(): def load_model(self): from imageai.Detection import VideoObjectDetection # Program starts from model loading for image recognition. Object detection from all cameras use a model loaded here. #print("Model loading is about to start. Please wait...") #print(tf.__version__) try: self.label_loading = tk.Label(self.frame, text="Loading...", bg=self.bgcolor, fg="#9EF79F") self.label_loading.config(font=("Courier", 16)) self.label_loading.place(relx=0.0, rely=0.0, relwidth=1, relheight=1) except: () # AI MODEL LOADING # Getting AI information from DB _sqlite.getAI() for row in _sqlite.getAI.result: self.ai_model_type = row[1] self.ai_model_file = row[2] self.ai_detection_speed = row[3] self.ai_minimum_percentage = row[4] #print("Model type: " + self.ai_model_type + " File: " + self.ai_model_file + " Speed: " + self.ai_detection_speed + " Percentage: " + self.ai_minimum_percentage) self.execution_path = os.getcwd() self.video_detector = VideoObjectDetection() if self.ai_model_type == "setModelTypeAsTinyYOLOv3": self.video_detector.setModelTypeAsTinyYOLOv3() elif self.ai_model_type == "setModelTypeAsYOLOv3": self.video_detector.setModelTypeAsYOLOv3() elif self.ai_model_type == "setModelTypeAsRetinaNet": self.video_detector.setModelTypeAsRetinaNet() self.video_detector.setModelPath(os.path.join(self.execution_path, self.ai_model_file)) self.video_detector.loadModel(detection_speed=self.ai_detection_speed) # Tensorflow graph used for loading a model should be the same as we use for object detection in AIMain function. global graph graph = tf.get_default_graph() if 'label_loading' in dir(self): self.label_loading.destroy() def program_start(self): # Getting VISUAL information from DB _sqlite.getVisual() for row in _sqlite.getVisual.result: self.schemename = row[1] self.transparency = row[2] self.bgcolor = row[3] # Root window self.root = tk.Tk() self.root.attributes('-alpha', self.transparency) self.root.iconbitmap(default='icon.ico') self.root.title('Terra Object Detection') # container with its initial values HEIGHT = 620 WIDTH = 1100 self.canvas = tk.Canvas(self.root, height=HEIGHT, width=WIDTH, bg="blue") # real canvas for use self.canvas.pack() # menu on a top self.menubar() # main program's screen self.main_screen(program_just_started=True) #MENUBAR# def menubar(self): menubar = tk.Menu(self.root) self.root.config(menu=menubar) settingsMenu = tk.Menu(menubar, tearoff=0) menubar.add_cascade(label="Settings", menu=settingsMenu) settingsMenu.add_command(label="Visual Settings", command=self.visual_settings) settingsMenu.add_command(label="Cameras Settings", command=self.cameras_settings) settingsMenu.add_command(label="Sound Settings", command=self.sound_settings) settingsMenu.add_command(label="Artificial Intelligence Settings", command=self.ai_settings) programMenu = tk.Menu(menubar, tearoff=0) menubar.add_cascade(label="Program", menu=programMenu) programMenu.add_command(label="Disconnect All Cameras/Refresh Screen", command=lambda: [_f.functionality().videoCaptureStopAll(), self.main_screen(program_just_started=False)]) programMenu.add_command(label="About Program", command=self.about) programMenu.add_command(label="Exit", command=self.program_exit) #MAIN SCREEN# def main_screen(self, program_just_started): # Getting SOUND information from DB _sqlite.getSound() for row in _sqlite.getSound.result: self.soundname = row[1] self.soundfile = row[2] #print("Sound: " + self.soundname + " Title: " + self.soundfile) if 'frame' in dir(self): self.frame.destroy() # destroying frame if it existed before (in case if main_screen # is not launching the first time but is being refreshed). Necessary in order to # 'forget' all old buttons and other widgets that are placed within that frame # Frame for all widgets on a main screen self.frame = tk.Frame(self.root, bg=self.bgcolor) self.frame.place(relx=0.00, rely=0.00, relwidth=1, relheight=1) if program_just_started == True: # Calling a function to load an AI model self.thread = threading.Thread(target=self.load_model, args=()) self.thread.start() else: () # Calling function to get a cameras list from DB _sqlite.getCameras() # Creating buttons for each camera for row in _sqlite.getCameras.result: # Creating necessary variables for each database output globals()["id" + str(row[0])] = row[0] globals()["name" + str(row[0])] = row[1] globals()["ipcam_streaming_url" + str(row[0])] = row[2] _sqlite.connClose() # Initial buttons - pressing an initial button initiates a video capture from camera # Every initial button has an id (camnum) which is passed to buttonsWhenCameraOn function for the purpose # to create additional buttons next to initial ones for enabling functionality to each camera (location of later generated # buttons depends on which initial button was pressed - id1, id2, id3...) ttk.Style().map("C.TButton", background=[('pressed', 'yellow')], foreground=[('pressed', 'black')]) if 'id1' in globals(): if name1 != "" and ipcam_streaming_url1 != "": button1 = ttk.Button(self.frame, text=name1, style="C.TButton", command=lambda: _f.functionality().videoCaptureStart(id1, name1, ipcam_streaming_url1, self.execution_path, self.video_detector, graph, self.ai_minimum_percentage, self.bgcolor, self.soundfile)) #command=_f.functionality().videoCaptureStart button1.place(relx=0.01, rely=0.05, relwidth=0.10, relheight=0.05) if 'id2' in globals(): if name2 != "" and ipcam_streaming_url2 != "": button2 = ttk.Button(self.frame, text=name2, style="C.TButton", command=lambda: _f.functionality().videoCaptureStart(id2, name2, ipcam_streaming_url2, self.execution_path, self.video_detector, graph, self.ai_minimum_percentage, self.bgcolor, self.soundfile)) button2.place(relx=0.01, rely=0.12, relwidth=0.10, relheight=0.05) if 'id3' in globals(): if name3 != "" and ipcam_streaming_url3 != "": button3 = ttk.Button(self.frame, text=name3, style="C.TButton", command=lambda: _f.functionality().videoCaptureStart(id3, name3, ipcam_streaming_url3, self.execution_path, self.video_detector, graph, self.ai_minimum_percentage, self.bgcolor, self.soundfile)) button3.place(relx=0.01, rely=0.19, relwidth=0.10, relheight=0.05) if 'id4' in globals(): if name4 != "" and ipcam_streaming_url4 != "": button4 = ttk.Button(self.frame, text=name4, style="C.TButton", command=lambda: _f.functionality().videoCaptureStart(id4, name4, ipcam_streaming_url4, self.execution_path, self.video_detector, graph, self.ai_minimum_percentage, self.bgcolor, self.soundfile)) button4.place(relx=0.01, rely=0.26, relwidth=0.10, relheight=0.05) if 'id5' in globals(): if name5 != "" and ipcam_streaming_url5 != "": button5 = ttk.Button(self.frame, text=name5, style="C.TButton", command=lambda: _f.functionality().videoCaptureStart(id5, name5, ipcam_streaming_url5, self.execution_path, self.video_detector, graph, self.ai_minimum_percentage, self.bgcolor, self.soundfile)) button5.place(relx=0.01, rely=0.33, relwidth=0.10, relheight=0.05) if 'id6' in globals(): if name6 != "" and ipcam_streaming_url6 != "": button6 = ttk.Button(self.frame, text=name6, style="C.TButton", command=lambda: _f.functionality().videoCaptureStart(id6, name6, ipcam_streaming_url6, self.execution_path, self.video_detector, graph, self.ai_minimum_percentage, self.bgcolor, self.soundfile)) button6.place(relx=0.01, rely=0.40, relwidth=0.10, relheight=0.05) if 'id7' in globals(): if name7 != "" and ipcam_streaming_url7 != "": button7 = ttk.Button(self.frame, text=name7, style="C.TButton", command=lambda: _f.functionality().videoCaptureStart(id7, name7, ipcam_streaming_url7, self.execution_path, self.video_detector, graph, self.ai_minimum_percentage, self.bgcolor, self.soundfile)) button7.place(relx=0.01, rely=0.47, relwidth=0.10, relheight=0.05) if 'id8' in globals(): if name8 != "" and ipcam_streaming_url8 != "": button8 = ttk.Button(self.frame, text=name8, style="C.TButton", command=lambda: _f.functionality().videoCaptureStart(id8, name8, ipcam_streaming_url8, self.execution_path, self.video_detector, graph, self.ai_minimum_percentage, self.bgcolor, self.soundfile)) button8.place(relx=0.01, rely=0.54, relwidth=0.10, relheight=0.05) button_openFolder = ttk.Button(self.frame, text="Open Detections Folder", command=lambda: os.system("start frames\ ")) button_openFolder.place(relx=0.45, rely=0.87, relwidth=0.50, relheight=0.05) # set a callback to handle when the main window is closed; trying to close all working cameras if user initiates program closure (DOESN'T WORK YET) self.root.wm_protocol("WM_DELETE_WINDOW", self.program_exit) # runs application self.root.mainloop() def visual_settings(self): visual_window = tk.Toplevel() visual_window.geometry('260x180+180+80') visual_window.attributes('-alpha', self.transparency) visual_window.resizable(width=False, height=False) visual_window.title('Visual Settings') canvas = tk.Canvas(visual_window, height=180, width=260) canvas.pack() frame = tk.Frame(visual_window, bg=self.bgcolor) frame.place(relx=0.00, rely=0.00, relwidth=1, relheight=1) label1 = tk.Label(frame, text="Current scheme: " + self.schemename, anchor='center') label1.place(relx=0.01, rely=0.05, relwidth=0.98, relheight=0.14) label2 = tk.Label(frame, text="Choose scheme:", anchor='w') label2.place(relx=0.01, rely=0.24, relwidth=0.48, relheight=0.14) Entry1List = [self.schemename, "Standard Dark", "Standard Bright", "Dark Transparent", "Navy Transparent"] entry1 = tk.StringVar(frame) entry1.set(Entry1List[0]) opt = ttk.OptionMenu(frame, entry1, *Entry1List) opt.place(relx=0.51, rely=0.24, relwidth=0.48, relheight=0.14) button = ttk.Button(frame, text="Apply", command=lambda: [_sqlite.updateVisual(entry1.get()), visual_window.destroy()]) button.place(relx=0.51, rely=0.43, relwidth=0.48, relheight=0.14) label3 = tk.Label(frame, text="Important: you must restart the program \n for the visual changes to take effect.", anchor='center') label3.place(relx=0.01, rely=0.62, relwidth=0.98, relheight=0.30) def cameras_settings(self): cameras_window = tk.Toplevel() cameras_window.grab_set() #this forces all focus on the this top level window until it is closed cameras_window.geometry('650x400+180+80') cameras_window.attributes('-alpha', self.transparency) cameras_window.resizable(width=False, height=False) cameras_window.title('Cameras Settings') canvas = tk.Canvas(cameras_window, height=400, width=650) canvas.pack() frame = tk.Frame(cameras_window, bg=self.bgcolor) frame.place(relx=0.00, rely=0.00, relwidth=1, relheight=1) label1 = tk.Label(frame, text="Id") label1.place(relx=0.01, rely=0.05, relwidth=0.20, relheight=0.05) label2 = tk.Label(frame, text="Camera Name") label2.place(relx=0.01, rely=0.12, relwidth=0.20, relheight=0.05) label3 = tk.Label(frame, text="Camera address") label3.place(relx=0.01, rely=0.19, relwidth=0.20, relheight=0.05) # We allow to choose camera id from the list (range 1-8), not to type any number Entry1List = ["1", "1", "2", "3", "4", "5", "6", "7", "8"] entry1 = tk.StringVar(frame) entry1.set(Entry1List[0]) opt = ttk.OptionMenu(frame, entry1, *Entry1List) opt.place(relx=0.22, rely=0.05, relwidth=0.20, relheight=0.05) entry2 = tk.Entry(frame) entry2.place(relx=0.22, rely=0.12, relwidth=0.20, relheight=0.05) entry3 = tk.Entry(frame) entry3.place(relx=0.22, rely=0.19, relwidth=0.20, relheight=0.05) # By pressing button, we are submitting entries to updateCameras, stopping all currently working cameras and refreshing the main_screen button = ttk.Button(frame, text="Submit", command=lambda: [_sqlite.updateCameras(entry1.get(), entry2.get(), entry3.get()), cameras_window.destroy(), self.cameras_settings(), _f.functionality().videoCaptureStopAll(), self.main_screen(program_just_started=False)]) button.place(relx=0.22, rely=0.26, relwidth=0.20, relheight=0.05) label4 = tk.Label(frame, text="Note: when you press 'Submit', all \n currently connected cameras disconnect.", anchor='center') label4.place(relx=0.01, rely=0.33, relwidth=0.41, relheight=0.15) # Showing the actual information about cameras in the database to the user _sqlite.getCameras() label = tk.Label(frame, text="Cameras information (" + str(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")) + ")") label.place(relx=0.45, rely=0.05, relwidth=0.54, relheight=0.05) # Inserting cameras addresses to the list rely = 0.11 for row in _sqlite.getCameras.result: id_label = tk.Label(frame, text=(row[0])) id_label.place(relx=0.45, rely=rely, relwidth=0.05, relheight=0.05) name_label = tk.Label(frame, text=(row[1])) name_label.place(relx=0.51, rely=rely, relwidth=0.20, relheight=0.05) ipcam_streaming_url_entry = tk.Entry(frame) ipcam_streaming_url_entry.configure(state='normal') ipcam_streaming_url_entry.insert(0, (row[2])) ipcam_streaming_url_entry.configure(state='readonly') ipcam_streaming_url_entry.place(relx=0.72, rely=rely, relwidth=0.27, relheight=0.05) rely += 0.06 _sqlite.connClose() def sound_settings(self): sound_window = tk.Toplevel() sound_window.geometry('260x210+180+80') sound_window.attributes('-alpha', self.transparency) sound_window.resizable(width=False, height=False) sound_window.title('Sound Settings') canvas = tk.Canvas(sound_window, height=180, width=260) canvas.pack() frame = tk.Frame(sound_window, bg=self.bgcolor) frame.place(relx=0.00, rely=0.00, relwidth=1, relheight=1) label1 = tk.Label(frame, text="Current alarm sound: " + self.soundname, anchor='center') label1.place(relx=0.01, rely=0.04, relwidth=0.98, relheight=0.12) label2 = tk.Label(frame, text="Choose sound:", anchor='w') label2.place(relx=0.01, rely=0.20, relwidth=0.48, relheight=0.12) Entry1List = [self.soundname, "alarm", "clang", "crow", "glass", "harp_run", "meadow_lark", "trolley_bell"] entry1 = tk.StringVar(frame) entry1.set(Entry1List[0]) opt = ttk.OptionMenu(frame, entry1, *Entry1List) opt.place(relx=0.51, rely=0.20, relwidth=0.48, relheight=0.12) button_listen = ttk.Button(frame, text="Play selected sound", command=lambda:play_sound(entry1.get())) button_listen.place(relx=0.51, rely=0.36, relwidth=0.48, relheight=0.12) button = ttk.Button(frame, text="Apply", command=lambda: [_sqlite.updateSound(entry1.get()), sound_window.destroy(), _f.functionality().videoCaptureStopAll(), self.main_screen(program_just_started=False)]) button.place(relx=0.51, rely=0.52, relwidth=0.48, relheight=0.12) label3 = tk.Label(frame, text="Note: when you press 'Apply', all \n currently connected cameras disconnect.", anchor='center') label3.place(relx=0.01, rely=0.68, relwidth=0.98, relheight=0.26) def play_sound(sound): winsound.PlaySound("sounds/" + sound + ".wav", winsound.SND_FILENAME) def ai_settings(self): ai_window = tk.Toplevel() ai_window.grab_set() # this forces all focus on the this top level window until it is closed ai_window.geometry('500x400+180+80') ai_window.attributes('-alpha', self.transparency) ai_window.resizable(width=False, height=False) ai_window.title('Artificial Intelligence Settings') canvas = tk.Canvas(ai_window, height=400, width=500) canvas.pack() frame = tk.Frame(ai_window, bg=self.bgcolor) frame.place(relx=0.00, rely=0.00, relwidth=1, relheight=1) if self.ai_model_file == "yolo-tiny.h5": ai_model = "TinyYOLOv3" elif self.ai_model_file == "yolo.h5": ai_model = "YOLOv3" elif self.ai_model_file == "resnet50_coco_best_v2.0.1.h5": ai_model = "RetinaNet" label1 = tk.Label(frame, text="Current parameters: " + ai_model + "; " + self.ai_detection_speed + "; " + self.ai_minimum_percentage + ".", anchor='center') label1.place(relx=0.01, rely=0.05, relwidth=0.98, relheight=0.05) label2 = tk.Label(frame, text="AI Model") label2.place(relx=0.01, rely=0.12, relwidth=0.48, relheight=0.05) label3 = tk.Label(frame, text="Detection Speed") label3.place(relx=0.01, rely=0.19, relwidth=0.48, relheight=0.05) label4 = tk.Label(frame, text="Minimum Percentage") label4.place(relx=0.01, rely=0.26, relwidth=0.48, relheight=0.05) # We allow to choose ai model from the list Entry1List = [ai_model, "TinyYOLOv3", "YOLOv3"] # "RetinaNet" - program supports it but is not included here (reasons: loads slowly, detects slowly, low detection confidence, does not work after disconnect) entry1 = tk.StringVar(frame) entry1.set(Entry1List[0]) opt1 = ttk.OptionMenu(frame, entry1, *Entry1List) opt1.place(relx=0.51, rely=0.12, relwidth=0.48, relheight=0.05) Entry2List = [self.ai_detection_speed, "normal", "fast", "faster", "fastest", "flash"] entry2 = tk.StringVar(frame) entry2.set(Entry2List[0]) opt2 = ttk.OptionMenu(frame, entry2, *Entry2List) opt2.place(relx=0.51, rely=0.19, relwidth=0.48, relheight=0.05) Entry3List = [self.ai_minimum_percentage, "20", "25", "30", "35", "40", "45", "50", "55", "60", "65", "70", "75", "80", "85", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99"] entry3 = tk.StringVar(frame) entry3.set(Entry3List[0]) opt3 = ttk.OptionMenu(frame, entry3, *Entry3List) opt3.place(relx=0.51, rely=0.26, relwidth=0.48, relheight=0.05) # By pressing button, we are submitting entries to updateAI and closing the ai_window button = ttk.Button(frame, text="Submit", command=lambda: [_sqlite.updateAI(entry1.get(), entry2.get(), entry3.get()), ai_window.destroy()]) button.place(relx=0.51, rely=0.33, relwidth=0.48, relheight=0.05) label5 = tk.Label(frame, text="Important: you must restart the program \n for the changes to take effect.", anchor='center') label5.place(relx=0.01, rely=0.40, relwidth=0.98, relheight=0.15) instructions_scrollbar = ttk.Scrollbar(frame) instructions_text = tk.Text(frame, height=4, width=50) instructions_scrollbar.place(relx=0.01, rely=0.57, relwidth=0.98, relheight=0.39) instructions_text.place(relx=0.01, rely=0.57, relwidth=0.98, relheight=0.39) instructions_scrollbar.config(command=instructions_text.yview) instructions_text.config(yscrollcommand=instructions_scrollbar.set, state=tk.NORMAL, font=("Courier", 10)) quote = """ Approximate parameters for different types of devices 1. Machines with advanced dedicated graphics (For the best performance) GeForce GTX 1050 and better AI Model: YOLOv3; Detection Speed: normal; Minimum Percentage: >90 2. Machines with dedicated graphics (For Optimal performance) AI Model: YOLOv3 or TinyYOLOv3; Detection Speed: faster; Minimum Percentage: ~50 3. Machines with integrated graphics (For increasing detection speed) Due to limited resources, only the low performance mode may be available. It is not recommended to connect more than 1 or 2 cameras simultaneously. AI Model: TinyYOLOv3; Detection Speed: flash; Minimum Percentage: ~20 """ instructions_text.insert(tk.END, quote) instructions_text.config(yscrollcommand=instructions_scrollbar.set, state=tk.DISABLED) # After entering text, making DISABLED def about(self): about_window = tk.Toplevel() about_window.geometry('500x300+180+80') about_window.attributes('-alpha', self.transparency) about_window.resizable(width=False, height=False) about_window.title('Terra Object Detection') canvas = tk.Canvas(about_window, height=120, width=240) canvas.pack() frame = tk.Frame(about_window, bg=self.bgcolor) frame.place(relx=0.00, rely=0.00, relwidth=1, relheight=1) self.label1= tk.Label(frame, text="Terra Object Detection \n v. 0.9.0 Beta \n [email protected]", anchor='center', bg=self.bgcolor, fg="#9EF79F") self.label1.config(font=("Courier", 12)) self.label1.place(relx=0.25, rely=0.35, relwidth=0.5, relheight=0.3) #self.label2 = tk.Label(frame, text="*****@*****.**", anchor='n', bg=self.bgcolor, fg="red") #self.label2.config(font=("Courier", 10)) #self.label2.place(relx=0.0, rely=0.5, relwidth=1, relheight=0.5) def program_exit(self): # self.root.destroy - destroys root but keeps cameras loops working, shouldn't be used sys.exit()
def real_runDetection(): video = self.video_path.get() output = self.location.get() name = self.output_name.get() obj = self.objects.get().lower() self.progress.grid(row=7, column=1, columnspan=2, sticky="EW", padx=10, pady=10) self.progress.start() flag = 0 obj_list = [] all_obj_list = [ "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light", "fire hydrant", "stop_sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donot", "cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet", "sink", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "hair dryer", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear", "toothbrush" ] if not os.path.exists(video): flag = 1 messagebox.showerror("Input Video", "Input video path not defined!") self.progress.stop() self.progress.grid_forget() self.process_button['state'] = 'normal' return if not os.path.exists(output): flag = 1 messagebox.showerror("Output Video", "Output video path not defined!") self.progress.stop() self.progress.grid_forget() self.process_button['state'] = 'normal' return if name == "" or name == "Enter the desired video name": flag = 1 messagebox.showerror("Output Video", "Output video name not defined!") self.progress.stop() self.progress.grid_forget() self.process_button['state'] = 'normal' return for x in all_obj_list: if x != obj: flag = 2 else: flag = 0 break if flag == 2: messagebox.showerror( "Objects Error", "Object values do not match with any recognised objects!") self.progress.stop() self.progress.grid_forget() self.process_button['state'] = 'normal' return if flag == 0: try: execution_path = os.getcwd() detector = VideoObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath("yolo.h5") detector.loadModel(detection_speed="flash") def saveFrames(): brackets = [] index = -1 for i in range(0, totalFrames): if i % video_fps == 0: index += 1 brackets.append([]) brackets[index].append(i + 1) else: brackets[index].append(i + 1) index = 0 cap = cv.VideoCapture(video) for i in obj_list: if index > len(brackets): break for j in brackets[index]: if i == j: cap.set(1, i - 1) ret, frame = cap.read() cv.imwrite( os.path.join(output, str(i) + ".jpg"), frame) index += 1 break cap.release() def forFrames(frame_number, output_array, output_count): self.frame_processing.set("Processing frame: " + str(frame_number)) for key in output_count: if key == obj: obj_list.append(frame_number) ouput = detector.detectObjectsFromVideo( input_file_path=video, output_file_path=os.path.join(output, name), frames_per_second=video_fps, log_progress=True, per_frame_function=forFrames, minimum_percentage_probability=30) self.frame_processing.set( "Processing done, now saving matched frames if any...") saveFrames() self.progress.stop() self.progress.grid_forget() self.frame_label.grid_forget() messagebox.showinfo( "Processing Success", "Video was successfully processed and saved in desired location, to open it click on Open Folder." ) self.process_button['state'] = 'normal' except: self.progress.stop() self.progress.grid_forget() self.frame_label.grid_forget() self.process_button['state'] = 'normal' messagebox.showerror("Processing Error", "Processing failed!")
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)
dt = ObjectDetection() dt.setModelTypeAsRetinaNet() dt.setModelPath(os.path.join(exec_path, "resnet50_coco_best_v2.1.0.h5")) dt.loadModel() list = dt.detectCustomObjectsFromImage( input_image=os.path.join(exec_path, "Firenze.jpg"), output_image_path=os.path.join(exec_path, "new2.jpg"), minimum_percentage_probability=50, display_percentage_probability=False, display_object_name=True ) ''' from imageai.Detection import VideoObjectDetection import os execution_path = os.getcwd() dt = VideoObjectDetection() dt.setModelTypeAsYOLOv3() dt.setModelPath(os.path.join(execution_path, "yolo.h5")) dt.loadModel() video_path = dt.detectObjectsFromVideo( input_file_path=os.path.join(execution_path, "autostrade_video.mp4"), output_file_path=os.path.join(execution_path, "traffic1"), frames_per_second=20, log_progress=True) print(video_path)