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 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 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)
def detectionModelLoad(model_path, mod="normal"):
detector = VideoObjectDetection()
detector.setModelTypeAsRetinaNet()
detector.setModelPath(model_path)
detector.loadModel(detection_speed=mod)
return detector
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 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_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 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
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 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 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 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 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)
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_of_vehicles_from_video(folder1, folder2, findex):
'''
Detects and saves the arrays containing bounding boxes of detected
vehicles from videos of a given folder
Parameters:
folder1 : path of the folder containing videos
folder2 : path of the folder in which arrays are required to be stored
findex : index number of the first video in folder1
'''
#modifying forFrame function of ImageAI to make a list
#of bounding box coordinates for vehichles detected in a
#particular frame
def forFrame(frame_number, output_array, output_count):
bboxes = []
for i in range(len(output_array)):
bboxes.append(list(output_array[i]['box_points']))
B.append(bboxes)
#reading and sorting the filenames of folder1
videos = glob.glob(folder1 + '/video*.MOV')
videos = natsort.natsorted(videos)
#set and load ResNet Model for detection of vehicles
execution_path = os.getcwd()
detector = VideoObjectDetection()
detector.setModelTypeAsRetinaNet()
#use detector.setModelTypeAsYOLOv3() to use YOLOv3 instead of RetinaNet
detector.setModelPath(
os.path.join(
execution_path,
"/home/siddhi/Desktop/RoadCrossingAssistant_FY_Project_Data/resnet50_coco_best_v2.0.1.h5"
))
#use model path of yolo.h5 if to use YOLOv3 instead of RetinaNet
detector.loadModel()
custom_objects = detector.CustomObjects(bicycle=True,
motorcycle=True,
car=True,
truck=True)
for video in videos:
print('processing' + video)
B = []
detector.detectCustomObjectsFromVideo(
save_detected_video=False,
custom_objects=custom_objects,
input_file_path=os.path.join(execution_path, video),
frames_per_second=30,
per_frame_function=forFrame,
minimum_percentage_probability=40)
B = np.array(B)
print('saving array for video' + video + '\n shape of array: ' +
str(B.shape))
np.save(folder2 + '/array' + str(findex), B)
findex = findex + 1
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_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 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 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 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))
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 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')
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)
class itemVideoSaveFile():
def __init__(self,setModelPath):
self.execution_path = os.getcwd()
self.detetor = VideoObjectDetection()
self.detetor.setModelTypeAsRetinaNet()
self.detetor.setModelPath(os.path.join(self.execution_path,setModelPath))
self.detetor.loadModel()
def items_VideoSaveFile(self, inputFile, outputFile):
video_path = self.detetor.detectCustomObjectsFromVideo(input_file_path=os.path.join(self.execution_path,inputFile),
output_file_path=os.path.join(self.execution_path, outputFile),
frames_per_second=20, log_progress=True)
print(video_path)
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 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 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 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 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)
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)
from imageai.Detection import VideoObjectDetection
import os
execution_path = os.getcwd()
detector = VideoObjectDetection()
detector.setModelTypeAsRetinaNet()
detector.setModelPath( os.path.join(execution_path , "resnet50_coco_best_v2.0.1.h5"))
detector.loadModel(detection_speed="flash")
custom_objects = detector.CustomObjects(person=True, bicycle=True, motorcycle=True)
video_path = detector.detectCustomObjectsFromVideo(custom_objects=custom_objects, input_file_path=os.path.join(execution_path, "traffic-small.mp4"),
output_file_path=os.path.join(execution_path, "traffic_small_custom_flash_detected")
, frames_per_second=20, log_progress=True)
print(video_path)
