class Detector: def __init__(self, model_path, speed): self.detector = ObjectDetection() self.detector.setModelTypeAsTinyYOLOv3() self.detector.setModelPath(model_path) self.detector.loadModel(detection_speed=speed) # Run object detection and return the two tags with highest probability. # In the case of no objects detected, tag="None" def detect(self, input_path): _, detection = self.detector.detectObjectsFromImage( input_image=input_path, output_type="array", minimum_percentage_probability=30) detection = sorted(detection, key=lambda item: item["percentage_probability"], reverse=True) objects = [] for eachItem in detection: if eachItem["name"] not in objects: objects.append(eachItem["name"]) if len(objects) == 2: break while len(objects) != 2: objects.append("None") return objects
def setUpNN(model_path): detector = ObjectDetection() detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(model_path) detector.loadModel() return detector
def getYoloTiny(request): if request.method == "POST": f = request.FILES['sentFile'] # here you get the files needed execution_path = os.getcwd() detector = ObjectDetection() path = os.path.join(settings.MODELS, "yolo-tiny.h5") detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(path) detector.loadModel() detections = detector.detectObjectsFromImage(input_image=f, output_image_path='media/imagetest.jpg') item=[] object='' for eachObject in detections: item.append(eachObject["name"]) if len(item) == 0: return render(request, 'failPredictions.html') 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, 'predictions.html', context) else: return render(request, 'homepage.html')
class StartWindows(QMainWindow): def __init__(self, camera=None, parent=None): super(StartWindows, self).__init__(parent=parent) self.ui = Ui_Form() self.ui.setupUi(self) self.detections = None self.frame = None self.files = [] self.tmp = [] self.update_timer = QTimer() self.update_timer.timeout.connect(self.update) #button #camera self.camera = cv2.VideoCapture(0) self.update_timer.start(30) self.execution_path = os.getcwd() #model self.detector = ObjectDetection() self.detector.setModelTypeAsTinyYOLOv3() self.detector.setModelPath( os.path.join(self.execution_path, "yolo-tiny.h5")) self.detector.loadModel(detection_speed="fast") print("###you are use yolo_tiny model###") def update(self): ret, self.frame = self.camera.read() self.frame = cv2.flip(self.frame, 1) #detected custom = self.ui.comboBox_2.currentText() print(custom) custom_objects = self.detector.CustomObjects(bottle=True) detected_image_array, self.detections = self.detector.detectCustomObjectsFromImage( custom_objects=custom_objects, input_type="array", input_image=self.frame, output_type="array") #detected_image_array, detections = self.detector.detectCustomObjectsFromImage(custom_objects=custom_objects,output_type="array",input_type="array", input_image= frame,display_percentage_probability=True, display_object_name=True) for eachObject in self.detections: print(eachObject["name"], " : ", eachObject["percentage_probability"], " : ", eachObject["box_points"]) #resize detected_image_array = cv2.resize(detected_image_array, (851, 471)) height, width, channel = detected_image_array.shape bytesPerLine = 3 * width qImg = QImage(detected_image_array.data, width, height, bytesPerLine, QImage.Format_RGB888).rgbSwapped() pixmap01 = QPixmap.fromImage(qImg) pixmap_image = QPixmap(pixmap01) self.ui.label.setPixmap(pixmap_image) self.ui.label.show()
def tinyYoloImage(image, model, output): detector = ObjectDetection() detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(model) detector.loadModel() start_time = time.time() detections = detector.detectObjectsFromImage(input_image=image, output_image_path=output) for eachObject in detections: print(eachObject["name"], " : ", eachObject["percentage_probability"]) print("Total time: %s seconds" % (time.time() - start_time))
def ObjectDetect(self): execution_path = "C:\Tensorflow\models\Research\object_detection\Engine\customPrediction" print(execution_path) detector = ObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(execution_path, "resnet50_coco_best_v2.0.1.h5")) detector.loadModel() detections1 = detector.detectCustomObjectsFromImage( input_image=os.path.join(execution_path, "trail1.jpg"), output_image_path=os.path.join(execution_path, "example3.jpg")) detector2 = ObjectDetection() detector2.setModelTypeAsYOLOv3() detector2.setModelPath(os.path.join(execution_path, "yolo.h5")) detector2.loadModel() detections2 = detector2.detectCustomObjectsFromImage( input_image=os.path.join(execution_path, "trail1.jpg"), output_image_path=os.path.join(execution_path, "example4.jpg")) detector3 = ObjectDetection() detector3.setModelTypeAsTinyYOLOv3() detector3.setModelPath(os.path.join(execution_path, "yolo-tiny.h5")) detector3.loadModel() detections3 = detector3.detectCustomObjectsFromImage( input_image=os.path.join(execution_path, "trail1.jpg"), output_image_path=os.path.join(execution_path, "example5.jpg")) prediction = CustomImagePrediction() prediction.setModelTypeAsResNet() prediction.setModelPath( os.path.join(execution_path, "model_ex-027_acc-0.843750.h5")) prediction.setJsonPath(os.path.join(execution_path, "model_class.json")) prediction.loadModel(num_objects=2) predictions, probabilities = prediction.predictImage(os.path.join( execution_path, "trail1.jpg"), result_count=5) detections = detections1 + detections2 + detections3 List = [] for i in detections: List.append(i["name"]) for eachPrediction, eachProbability in zip(predictions, probabilities): if eachProbability > 50: List.append(eachPrediction) """for eachObject in detections: print(eachObject["name"], " : ", eachObject["percentage_probability"]) for eachPrediction, eachProbability in zip(predictions, probabilities): print(eachPrediction, " : ", eachProbability)""" return List
def load_detector(model_type, model_path, detection_speed="normal"): detector = ObjectDetection() if model_type == ModelType.YOLO: detector.setModelTypeAsYOLOv3() elif model_type == ModelType.YOLO_TINY: detector.setModelTypeAsTinyYOLOv3() elif model_type == ModelType.RES_NET: detector.setModelTypeAsRetinaNet() detector.setModelPath(model_path) detector.loadModel(detection_speed=detection_speed) return detector
def run(self): detector = ObjectDetection( ) if self.type_file == "img" else VideoObjectDetection() settings = QSettings(CONFIG_FILE_NAME, QSettings.IniFormat) model = settings.value(KEY_SAVE_MODEL, MODELS[0], type=str) if model == MODELS[0]: detector.setModelTypeAsRetinaNet() file = MODEL_RETINA_NET elif model == MODELS[1]: detector.setModelTypeAsYOLOv3() file = MODEL_YOLOv3 else: detector.setModelTypeAsTinyYOLOv3() file = MODEL_TINY_YOLOv3 detector.setModelPath(file) detector.loadModel(self.window.detection_speed) if self.type_file == "img": detections = detector.detectObjectsFromImage( input_image=self.new_file, output_image_path=self.output_file, **self.window.getFunctionArg()) self._print_table_txt({ name: len( list( filter( lambda elem: True if elem["name"] == name else False, detections))) for name in set([obj["name"] for obj in detections]) }) elif self.type_file == "video": detector.detectObjectsFromVideo( input_file_path=self.new_file, output_file_path=self.output_file, video_complete_function=self.forFull, **self.window.getFunctionArg()) else: camera = cv2.VideoCapture(self.window.index) detector.detectObjectsFromVideo( camera_input=camera, output_file_path=self.output_file, video_complete_function=self.forFull, **self.window.getFunctionArg())
def getDetModel(modelName): '''Get detector model given name.''' detector = ObjectDetection() if modelName == "retinanet": detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(pathModel, "resnet50_coco_best_v2.0.1.h5")) elif modelName == "yolo": detector.setModelTypeAsYOLOv3() detector.setModelPath(os.path.join(pathModel, "yolo.h5")) elif modelName == "yolo-tiny": detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(os.path.join(pathModel, "yolo-tiny.h5")) detector.loadModel() return detector
class Vision: def __init__(self, model="model/yolo-tiny.h5"): self.model_path = model def detectImage(self, input_path, output_path): self.detector = ObjectDetection() self.detector.setModelTypeAsTinyYOLOv3() self.detector.setModelPath(self.model_path) self.detector.loadModel() detection = self.detector.detectObjectsFromImage( input_image=input_path, output_image_path=output_path) return detection
class tinyyolo: def __init__(self): # initializing model execution_path = os.getcwd() self.detector = ObjectDetection() self.detector.setModelTypeAsTinyYOLOv3() self.detector.setModelPath( os.path.join(execution_path, "models/yolo-tiny.h5")) self.detector.loadModel() def prediction(self, img_execution_path, pred_img_execution_path, img, pred_img): # predicting from model detections = self.detector.detectObjectsFromImage( input_image=os.path.join(img_execution_path, img), output_image_path=os.path.join(pred_img_execution_path, pred_img)) return detections
def YoloV3_model(yolov3_model_path, b_tiny_version=False): ''' Method that creates a YoloV3 model, using config from ImageAi core library. :param yolov3_model_path: the path of the config file :return: the YoloV3 model used to predict and the custom objects ( only poeple) to pass to the model during prediction. ''' detector = ObjectDetection() if not b_tiny_version: detector.setModelTypeAsYOLOv3() else: detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(yolov3_model_path) custom_objects = detector.CustomObjects(person=True) detector.loadModel() return detector, custom_objects
def detect_object(image_name): detector = ObjectDetection() model_path = "/content/task/models/yolo-tiny.h5" input_path = "/content/task/ScreenShots/" + image_name output_path = "/content/task/output/new_" + image_name detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(model_path) detector.loadModel() detection = detector.detectObjectsFromImage( input_image=input_path, output_image_path=output_path, minimum_percentage_probability=20) return detection
def detect_photo(model_path="static/other/yolo-tiny.h5", input_path="static/other/ai_photo.jpg", output_path="static/other/ai_photo_after.jpg"): detector = ObjectDetection() detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(model_path) detector.loadModel() detection = detector.detectObjectsFromImage( input_image=input_path, output_image_path=output_path, minimum_percentage_probability=40) names = [d['name'] for d in detection] counts = {n: names.count(n) for n in set(names)} return counts
class Detector: def __init__(self, model_path, output_path, language, translator): self.detector = None self.detection = None self.detection_items = [] self.model_path = model_path self.output_path = output_path self.detection_text = '' self.jpg_id = 0 self.photo_id = 0 self.language = language self.translator = translator self.cam = None def initialize(self, cam_number): self.detector = ObjectDetection() self.detector.setModelTypeAsTinyYOLOv3() self.detector.setModelPath(self.model_path) self.detector.loadModel() def get_detection(self, input_path): output_image = self.output_path + str(self.jpg_id) + '.jpg' self.detection = self.detector.detectObjectsFromImage( input_image=input_path, output_image_path=output_image) self.detection_items = [] self.detection_text = '' for item in self.detection: text = self.translator.translate(item["name"], dest=self.language).text self.detection_items.append(item) self.detection_text = self.detection_text + text + '. ' self.jpg_id += 1 return self.detection_text, output_image def take_picture(self): video_capture = cv2.VideoCapture(0) if not video_capture.isOpened(): return False, None ret, frame = video_capture.read() video_capture.release() # im = Image.fromarray(crop_center(frame[:,:,::-1],350,350)) im = Image.fromarray(frame[:, :, ::-1]) picture_name = "pictures/{}.jpg".format(self.photo_id) im.save(picture_name) self.photo_id += 1 return True, picture_name
def test_object_detection_tiny_yolov3_array_io(): try: keras.backend.clear_session() except: None image_input_array = cv2.imread(image_input) detector = ObjectDetection() detector.setModelTypeAsTinyYOLOv3() detector.setModelPath( os.path.join(main_folder, "data-models", "yolo-tiny.h5")) detector.loadModel() detected_array, results = detector.detectObjectsFromImage( input_image=image_input_array, input_type="array", minimum_percentage_probability=40, output_type="array") assert isinstance(detected_array, ndarray) assert isinstance(results, list) for result in results: assert isinstance(result["name"], str) assert isinstance(result["percentage_probability"], float) assert isinstance(result["box_points"], tuple) detected_array, results2, extracted_arrays = detector.detectObjectsFromImage( input_image=image_input, output_image_path=image_output, minimum_percentage_probability=40, extract_detected_objects=True, output_type="array") assert isinstance(results2, list) assert isinstance(extracted_arrays, list) for result2 in results2: assert isinstance(result2["name"], str) assert isinstance(result2["percentage_probability"], float) assert isinstance(result2["box_points"], tuple) for extracted_array in extracted_arrays: assert isinstance(extracted_array, ndarray)
def detect_people(): # object detection detector = ObjectDetection() detector.setModelTypeAsTinyYOLOv3() detector.setModelPath('yolo-tiny.h5') detector.loadModel() detections = detector.detectObjectsFromImage( input_image="image.jpeg", output_image_path="imagenew.jpg") # sort detected objects into "persons", with probability 70%+ detected_people = [] for eachObject in detections: if eachObject["name"] == "person" and eachObject[ "percentage_probability"] > 60: detected_people.append(eachObject) # print all detected_people for dp in detected_people: print(dp) return detected_people
def test_object_detection_tiny_yolov3(): try: keras.backend.clear_session() except: None detector = ObjectDetection() detector.setModelTypeAsTinyYOLOv3() detector.setModelPath( os.path.join(main_folder, "data-models", "yolo-tiny.h5")) detector.loadModel() results = detector.detectObjectsFromImage( input_image=image_input, output_image_path=image_output, minimum_percentage_probability=40) assert isinstance(results, list) for result in results: assert isinstance(result["name"], str) assert isinstance(result["percentage_probability"], float) assert isinstance(result["box_points"], tuple) assert os.path.exists(image_output) os.remove(image_output) results2, extracted_paths = detector.detectObjectsFromImage( input_image=image_input, output_image_path=image_output, minimum_percentage_probability=40, extract_detected_objects=True) assert isinstance(results2, list) assert isinstance(extracted_paths, list) assert os.path.isdir(os.path.join(image_output + "-objects")) for result2 in results2: assert isinstance(result2["name"], str) assert isinstance(result2["percentage_probability"], float) assert isinstance(result2["box_points"], tuple) for extracted_path in extracted_paths: assert os.path.exists(extracted_path) shutil.rmtree(os.path.join(image_output + "-objects"))
def predict_path(): if request.method == 'POST': path = request.args.get('path') import os cwd = os.getcwd() print(cwd) detector = ObjectDetection() model_path = "./models/yolo-tiny.h5" input_path = path output_path = "C:/Users/bgranat/Desktop/finalhtml/final/rest-api/target/classes/static/" + path.rsplit( '/', 1)[-1] + "newimage.jpg" detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(model_path) detector.loadModel() detection = detector.detectObjectsFromImage( input_image=input_path, output_image_path=output_path) jsondata = {} rf1 = joblib.load("./models/x.pkl") rf2 = joblib.load("./models/y.pkl") i = 0 for eachItem in detection: if (eachItem["name"] == "person"): x1 = eachItem["box_points"][0] y1 = eachItem["box_points"][1] x2 = eachItem["box_points"][2] y2 = eachItem["box_points"][3] x = rf1.predict([[x1, x2]]) y = rf2.predict([[y1, y2]]) print(x, y) point = makeANewPoint(str(math.floor(x)), str(math.floor(y)), input_path) jsondata[i] = point i = i + 1 return jsonify(jsondata)
def hello(): K.clear_session() if request.method == 'POST': detector = ObjectDetection() detector.setModelTypeAsTinyYOLOv3() detector.setModelPath("yolo-tiny.h5") detector.loadModel() algo = request.form['algo'] if 'file_input' not in request.files: flash('No file part') return redirect(request.url) file = request.files['file_input'] if file.filename == '': flash('No selected file') return redirect(request.url) if file and allowed_file(file.filename): filename = secure_filename(file.filename) file_data = file.stream.read() nparr = np.fromstring(file_data, np.uint8) img = cv2.imdecode(nparr, cv2.IMREAD_COLOR) detect_img, result = detector.detectObjectsFromImage( input_image=img, input_type="array", output_type="array", minimum_percentage_probability=80) K.clear_session() detect_img = cv2.cvtColor(detect_img, cv2.COLOR_BGR2RGB) cv2.imwrite('detect_img.jpg', detect_img) img_str = cv2.imencode('.jpg', detect_img)[1].tostring() encoded = base64.b64encode(img_str).decode("utf-8") mime = "image/jpg;" out_image = f"data:{mime}base64,{encoded}" return render_template('result.html', out_image=out_image) else: return "File extension not supported" return render_template('index.html')
def __init__(self, model): execution_path = os.getcwd() detector = ObjectDetection() if model == 'yolo': detector.setModelTypeAsYOLOv3() elif model == 'yolo-tiny': detector.setModelTypeAsTinyYOLOv3() else: raise ValueError( 'Model ' + model + 'not fould. you should download the model and put it into "modules" directory.' ) detector.setModelPath( os.path.join(execution_path, '../input/models-detection/' + model + '.h5')) detector.loadModel() custom_objects = detector.CustomObjects(car=True) self.detector = detector self.custom_objects = custom_objects self.execution_path = execution_path
def objectDetect(): input_path = input_path_entry.get() input_path_entry.delete(0, tk.END) output_path = output_path_entry.get() output_path_entry.delete(0, tk.END) detector = ObjectDetection() model_path = "./models/yolo-tiny.h5" output_path = output_path + '/newimage.jpg' detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(model_path) detector.loadModel() detections = detector.detectObjectsFromImage(input_image=input_path, output_image_path=output_path) for eachObject in detections: print(eachObject["name"], " : ", eachObject["percentage_probability"], " : ", eachObject["box_points"]) print("--------------------------------")
def load_model(model='yolo'): ''' :type: model: str :rtype: detector Input model name and output the corresponding model ''' # Load object detection model execution_path = os.getcwd() detector = ObjectDetection() if model == 'yolo': detector.setModelTypeAsYOLOv3() detector.setModelPath( os.path.join(execution_path, "pretrained_model/yolo.h5")) elif model == 'resnet': detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(execution_path, "pretrained_model/resnet50_coco_best_v2.0.1.h5")) elif model == 'tinyyolo': detector.setModelTypeAsTinyYOLOv3() detector.setModelPath( os.path.join(execution_path, "pretrained_model/yolo-tiny.h5")) detector.loadModel() return detector
from imageai.Detection import ObjectDetection import cv2 """Create instance of Object Detection class""" det = ObjectDetection() """Setting paths for input image, output image and pretrained model weights of tiny yolo""" model_path = "yolo-tiny.h5" input_path = "input.jpg" output_path = "prediction_output.jpg" """Setting the model to tiny yolov3 and loading the weights from the specified path""" det.setModelTypeAsTinyYOLOv3() det.setModelPath(model_path) det.loadModel() """Detecting objects from the image and displaying the label if the prediction has minimum 0.1 probability.""" detection = det.detectObjectsFromImage(input_image=input_path, output_image_path=output_path, minimum_percentage_probability=0.1) """Result: Input and output image""" i1 = cv2.imread("input.jpg") cv2.imshow(i1) i2 = cv2.imread("prediction_output.jpg") cv2.imshow(i2) """Total objects detected""" print("Enter object name to get the box location") print("Available options are:") count = 1
class StartWindows(QMainWindow): def __init__(self,camera=None, parent=None): super(StartWindows, self).__init__(parent=parent) self.ui = Ui_Form() self.ui.setupUi(self) self.detections = None self.frame = None self.files=[] self.tmp=[] #detector #button self.ui.pushButton_3.clicked.connect(self.capture) self.ui.pushButton_2.clicked.connect(self.start) self.ui.pushButton.clicked.connect(self.stop) #camera self.camera = cv2.VideoCapture(0) #timer self.update_timer = QTimer() self.update_timer.timeout.connect(self.update) def start(self): model=self.ui.comboBox.currentText() print(model) if model == "YOLO V3": self.yolo() elif model == "YOLO TINY": self.yolo_tiny() elif model == "RESNET": self.resnet() def capture (self): d = self.detections for eachObject in d: ts = time.time() txt=str(ts) box = eachObject["box_points"]; x = box[0] y = box[1] w = box[2] h = box[3] crop_img = self.frame[y:y+h, x:x+w] txt=str(ts) cv2.imwrite(txt+'.png',crop_img) for file in os.listdir("D:/dec/Detection/guifinish/New folder"): if file.endswith(".png"): self.files.append(os.path.join(os.getcwd(), file)) self.tmp=self.files self.ui.listWidget.clear() for x in self.files: print(x) item = QListWidgetItem() item.setIcon(QIcon(x)) self.ui.listWidget.addItem(item) self.files=[] ''' for file in os.listdir("D:/dec/Detection/guifinish"): if file.endswith(".png"): self.files.append(os.path.join(os.getcwd(), file)) for x in self.files: print(x) item = QListWidgetItem() item.setIcon(QIcon(x)) self.ui.listWidget.addItems(item) ''' def yolo(self): self.update_timer.start(30) self.execution_path = os.getcwd() self.detector = ObjectDetection() self.detector.setModelTypeAsYOLOv3() self.detector.setModelPath( os.path.join(self.execution_path , "yolo.h5")) self.detector.loadModel(detection_speed="fast") print("###you are use yolo model###") def yolo_tiny(self): self.update_timer.start(30) self.execution_path = os.getcwd() self.detector = ObjectDetection() self.detector.setModelTypeAsTinyYOLOv3() self.detector.setModelPath( os.path.join(self.execution_path , "yolo-tiny.h5")) self.detector.loadModel(detection_speed="flash") print("###you are use yolo_tiny model###") def resnet(self): self.update_timer.start(30) self.execution_path = os.getcwd() self.detector = ObjectDetection() self.detector.setModelTypeAsRetinaNet() self.detector.setModelPath( os.path.join(self.execution_path , "resnet50_coco_best_v2.0.1.h5")) self.detector.loadModel(detection_speed="fast") print("###you are use resnet model###") def stop(self): self.update_timer.stop() def update(self): ret,self.frame =self.camera.read() self.frame=cv2.flip(self.frame,1) #detected custom=self.ui.comboBox_2.currentText() print(custom) if custom == "ALL": custom_objects =None elif custom == "Person": custom_objects = self.detector.CustomObjects(person=True) elif custom == "Orange": custom_objects = self.detector.CustomObjects(orange=True) elif custom == "Cell Phone": custom_objects = self.detector.CustomObjects(cell_phone=True) elif custom == "Bicycle": custom_objects = self.detector.CustomObjects(bicycle=True) elif custom == "Car": custom_objects = self.detector.CustomObjects(car=True) elif custom == "Motorcycle": custom_objects = self.detector.CustomObjects(motorcycle=True) elif custom == "Airplane": custom_objects = self.detector.CustomObjects(airplane=True) elif custom == "Bus": custom_objects = self.detector.CustomObjects(bus=True) elif custom == "Train": custom_objects = self.detector.CustomObjects(train=True) elif custom == "Truck": custom_objects = self.detector.CustomObjects(truck=True) elif custom == "Boat": custom_objects = self.detector.CustomObjects(boat=True) elif custom == "Traffic Light": custom_objects = self.detector.CustomObjects(traffic_light=True) elif custom == "Fire Hydrant": custom_objects = self.detector.CustomObjects(fire_hydrant=True) elif custom == "Stop Sign": custom_objects = self.detector.CustomObjects(stop_sign=True) elif custom == "Giraffe": custom_objects = self.detector.CustomObjects(giraffe=True) elif custom == "Backpack": custom_objects = self.detector.CustomObjects(backpack=True) elif custom == "Umbrella": custom_objects = self.detector.CustomObjects(umbrella=True) elif custom == "Handbag": custom_objects = self.detector.CustomObjects(handbag=True) elif custom == "Tie": custom_objects = self.detector.CustomObjects(tie=True) elif custom == "Suitcase": custom_objects = self.detector.CustomObjects(suitcase=True) elif custom == "Frisbee": custom_objects = self.detector.CustomObjects(frisbee=True) #end first elif custom == "Skis": custom_objects = self.detector.CustomObjects(skis=True) elif custom == "Snowboard": custom_objects = self.detector.CustomObjects(snowboard=True) elif custom == "Sports Ball": custom_objects = self.detector.CustomObjects(sports_ball=True) elif custom == "Kite": custom_objects = self.detector.CustomObjects(kite=True) elif custom == "Baseball Bat": custom_objects = self.detector.CustomObjects(baseball_bat=True) elif custom == "Baseball Glove": custom_objects = self.detector.CustomObjects(baseball_glove=True) elif custom == "Skateboard": custom_objects = self.detector.CustomObjects(skateboard=True) elif custom == "Surfboard": custom_objects = self.detector.CustomObjects(surfboard=True) elif custom == "Tennis Rack": custom_objects = self.detector.CustomObjects( tennis_racket=True) elif custom == "Bottle": custom_objects = self.detector.CustomObjects(bottle=True) elif custom == "Wine Glass": custom_objects = self.detector.CustomObjects(wine_glass=True) elif custom == "Cup": custom_objects = self.detector.CustomObjects(cup=True) elif custom == "Fork": custom_objects = self.detector.CustomObjects(fork=True) elif custom == "Knife": custom_objects = self.detector.CustomObjects(knife=True) elif custom == "Spoon": custom_objects = self.detector.CustomObjects(spoon=True) elif custom == "Bowl": custom_objects = self.detector.CustomObjects(bowl=True) elif custom == "Banana": custom_objects = self.detector.CustomObjects(banana=True) elif custom == "Apple": custom_objects = self.detector.CustomObjects(apple=True) #end seco elif custom == "Sandwich": custom_objects = self.detector.CustomObjects(sandwich=True) elif custom == "Broccoli": custom_objects = self.detector.CustomObjects(broccoli=True) elif custom == "Carrot": custom_objects = self.detector.CustomObjects(carrot=True) elif custom == "Hot Dog": custom_objects = self.detector.CustomObjects(hot_dog=True) elif custom == "Pizza": custom_objects = self.detector.CustomObjects(pizza=True) elif custom == "Cake": custom_objects = self.detector.CustomObjects(cake=True) elif custom == "Chair": custom_objects = self.detector.CustomObjects(chair=True) elif custom == "Couch": custom_objects = self.detector.CustomObjects(couch=True) elif custom == "Potted Plant": custom_objects = self.detector.CustomObjects(potted_plant=True) elif custom == "bed": custom_objects = self.detector.CustomObjects(bed=True) elif custom == "Dining Table": custom_objects = self.detector.CustomObjects(dining_table=True) elif custom == "Toilet": custom_objects = self.detector.CustomObjects(toilet=True) elif custom == "Tv": custom_objects = self.detector.CustomObjects(tv=True) elif custom == "Laptop": custom_objects = self.detector.CustomObjects(laptop=True) elif custom == "Mouse": custom_objects = self.detector.CustomObjects(mouse=True) elif custom == "Remote": custom_objects = self.detector.CustomObjects(remote=True) elif custom == "Keyboard": custom_objects = self.detector.CustomObjects(keyboard=True) elif custom == "Microwave": custom_objects = self.detector.CustomObjects(microwave=True) elif custom == "Oven": custom_objects = self.detector.CustomObjects(oven=True) elif custom == "Toaster": custom_objects = self.detector.CustomObjects(toaster=True) elif custom == "Sink": custom_objects = self.detector.CustomObjects(sink=True) #end th elif custom == "Refrigerator": custom_objects = self.detector.CustomObjects(refrigerator=True) elif custom == "Book": custom_objects = self.detector.CustomObjects(book=True) elif custom == "Clock": custom_objects = self.detector.CustomObjects(clock=True) elif custom == "Vase": custom_objects = self.detector.CustomObjects(vase=True) elif custom == "Scissors": custom_objects = self.detector.CustomObjects(scissors=True) elif custom == "Teddy Bear": custom_objects = self.detector.CustomObjects(teddy_bear=True) elif custom == "Hair Dryer": custom_objects = self.detector.CustomObjects(hair_dryer=True) elif custom == "Toothbrush": custom_objects = self.detector.CustomObjects(toothbrush=True) #end fo elif custom == "Parking Meter": custom_objects = self.detector.CustomObjects(parking_meter=True) elif custom == "Bench": custom_objects = self.detector.CustomObjects(bench=True) elif custom == "Bird": custom_objects = self.detector.CustomObjects(bird=True) elif custom == "Cat": custom_objects = self.detector.CustomObjects(cat=True) elif custom == "Dog": custom_objects = self.detector.CustomObjects(dog=True) elif custom == "Horse": custom_objects = self.detector.CustomObjects(horse=True) elif custom == "Sheep": custom_objects = self.detector.CustomObjects(sheep=True) elif custom == "Cow": custom_objects = self.detector.CustomObjects(cow=True) elif custom == "Elephant": custom_objects = self.detector.CustomObjects(elephant=True) elif custom == "Bear": custom_objects = self.detector.CustomObjects(bear=True) elif custom == "Zebra": custom_objects = self.detector.CustomObjects(zebra=True) #end all detected_image_array,self.detections = self.detector.detectCustomObjectsFromImage(custom_objects=custom_objects,input_type="array", input_image=self.frame , output_type="array") #detected_image_array, detections = self.detector.detectCustomObjectsFromImage(custom_objects=custom_objects,output_type="array",input_type="array", input_image= frame,display_percentage_probability=True, display_object_name=True) for eachObject in self.detections: print(eachObject["name"] , " : ", eachObject["percentage_probability"], " : ", eachObject["box_points"] ) #resize detected_image_array = cv2.resize(detected_image_array,(851,471)) height, width, channel = detected_image_array.shape bytesPerLine = 3 * width qImg = QImage(detected_image_array.data, width, height, bytesPerLine, QImage.Format_RGB888).rgbSwapped() pixmap01 = QPixmap.fromImage(qImg) pixmap_image = QPixmap(pixmap01) self.ui.label.setPixmap(pixmap_image) self.ui.label.show();
#In this python3 file we use a pretrained model to predict on images #Import ObjectDetection class from the ImageAI library. from imageai.Detection import ObjectDetection #Creating an instance of the image-ai detector detector = ObjectDetection() #Set up constant file paths model_path = "./models/yolo-tiny.h5" input_path = "./input/test45.jpg" output_path = "./output/newimage.jpg" #Let the computer know, that we''l be using the YOLOv3 model detector.setModelTypeAsTinyYOLOv3() #Load model detector.loadModel() #Detect detection = detector.detectObjectsFromImage(input_image=input_path, output_image_path=output_path) #Get probabilities for each category for eachItem in detection: print(eachItem["name"], " : ", eachItem["percentage_probability"])
def extractor(self, image_objects): #inizializzo la lista delle classi da chiamare per verificare le condizioni lista_classi = [] #Estraggo la lista delle differenti tipologie di condizione lista_condizioni = list(self.condition_list.keys()) if 'size' in lista_condizioni: ''' Appendo a 'lista_classi' le diverse chiamate alla classe che gestisce la condizione sulla 'size' (dimensione del file). Creo in questo modo due oggetti diversi, uno per soddisfare la dimensione minima e uno per la dimensione massima. ''' min_value = self.condition_list['size']['min'] max_value = self.condition_list['size']['max'] lista_classi.append( SizeChecker(self.condition_list, min_value, max_value)) if 'time' in lista_condizioni: #Appendo a 'lista_classi' le diverse chiamate alla classe #che gestisce la condizione sul 'time' (data di creazione del file). min_value = self.condition_list['time']['min'] max_value = self.condition_list['time']['max'] lista_classi.append( TimeChecker(self.condition_list, min_value, max_value)) if 'wordlist' in lista_condizioni: ''' Appendo a 'lista_classi' le diverse chiamate alla classe che gestisce la condizione sulla 'wordlist' (lista delle parole cercate). Creo tanti oggetti della classe 'OccurrenceChecker' quante sono le coppie parola-occorrenza cercate. ''' for parola in self.condition_list['wordlist'].keys(): lista_classi.append( OccurrenceChecker(parola, self.condition_list['wordlist'][parola])) if 'objectlist' in lista_condizioni: detector = ObjectDetection() model_path = "./models/yolo-tiny.h5" detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(model_path) detector.loadModel() #Appendo a 'lista_classi' le diverse chiamate alla classe #che gestisce la condizione sulla 'objectlist' (lista degli oggetti cercati). for obj in self.condition_list['objectlist'].keys(): #controllo se l'oggetto è tra quelli riconoscibili dall'algoritmo if obj in image_objects: lista_classi.append( ImageChecker(self.condition_list, obj, self.condition_list['objectlist'][obj], detector)) return lista_classi #Restituisco la lista contenente la chiamata alle classi per ogni specifica condizione
class ObjectDetector: model_class_labels = [ "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", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear", "hair dryer", "toothbrush" ] def __init__(self, model_name, model_path): self.model_path = model_path self.model_name = model_name if model_name == 'other': self.object_detector = DetectorAPI(path_to_ckpt=model_path) else: self.object_detector = ObjectDetection() if model_name == 'yolov3': self.object_detector.setModelTypeAsYOLOv3() elif model_name == 'tinyyolov3': self.object_detector.setModelTypeAsTinyYOLOv3() elif model_name == 'retinanet': self.object_detector.setModelTypeAsRetinaNet() self.object_detector.setModelPath(model_path) self.object_detector.loadModel() def detect(self, input_image_path, output_image_path, extract_detected_objects=True, display_percentage_probability=False, display_object_name=False, threshold=0.7): if self.model_name == 'other': detected_objects_location = [] img = cv2.imread(input_image_path) boxes, scores, classes, _ = self.object_detector.process_frame(img) detections = [] for i in range(len(boxes)): if scores[i] > threshold: detections.append( {'name': self.model_class_labels[classes[i] - 1]}) box = boxes[i] cv2.rectangle(img, (box[1], box[0]), (box[3], box[2]), (255, 0, 0), 2) cv2.imwrite(output_image_path, img) else: detections, detected_objects_location = self.object_detector.detectObjectsFromImage( input_image=input_image_path, output_image_path=output_image_path, extract_detected_objects=extract_detected_objects, display_percentage_probability=display_percentage_probability, display_object_name=display_object_name) return detections, detected_objects_location
class CountingObject(object): """ A class of counting objects """ algos = { "resnet": "resnet50_coco_best_v2.0.1.h5", "yolov3": "yolo.h5", "yolo_tiny": "yolo-tiny.h5" } def __init__(self, stream_link): self.stream_link = stream_link self.streams = streamlink.streams(stream_link) if self.streams is None: raise ValueError("cannot open the stream link %s" % stream_link) q = list(self.streams.keys())[0] self.stream = self.streams['%s' % q] self.target_img_path = os.getcwd() self.detector = ObjectDetection() if self.detector is None: raise ValueError("Detector of objects is None") def detector_init(self, algo="resnet", speed="nomal"): """ Must be invoked after instantiate for initialize a object detector. Args: algo (str): The algorithm of object detection tasks. "resnet"(default), "yolov3", "yolo_tiny". speed (str): The detection speed for object detetion tasks. "normal"(default), "fast", "faster" , "fastest" and "flash". Returns: void """ if algo == "resnet": self.detector.setModelTypeAsRetinaNet() self.detector.setModelPath( os.path.join(self.target_img_path, self.algos["resnet"])) elif algo == "yolov3": self.detector.setModelTypeAsYOLOv3() self.detector.setModelPath( os.path.join(self.target_img_path, self.algos["yolov3"])) elif algo == "yolo_tiny": self.detector.setModelTypeAsTinyYOLOv3() self.detector.setModelPath( os.path.join(self.target_img_path, self.algos["yolo_tiny"])) else: print("Given algorithm of object detection is invalid.") return self.detector.loadModel(detection_speed=speed) self.custom_objects = self.detector.CustomObjects(person=True) def put_text_to_img(self, img, text, pos=(50, 50), fontColor=(0, 0, 255), lineType=2): """ Put text to an image. Args: img : An image represented by numpy array. You can use cv2.imread(path_to_iamge) to read an image in the filesystem by giving the image path. text (str): The text what you want to put to the image. pos (tuple): x and y position relative to the origin (0,0) at the top left. fontColor (tuple): R G B channel. lineType (int): Type of line. Returns: void """ if img is None: print("Put text to a none image.") return font = cv2.FONT_HERSHEY_SIMPLEX fontScale = 1 cv2.putText(img, text, pos, font, fontScale, fontColor, lineType) def capture_frame_by_stream_wrapper(self, image_prefix="stream", mprob=30, num_im=6, time_interval=10, tz=None): """ A wrapper of the function capture_frame_by_stream. Args: image_prefix (str): Prefix of target images. The postfix is numerated by numbers. mprob (int): Minimum probability to be a person. num_im (int): How many images will be taken. time_interval (int): Time interval of taking next image, the unit is second. tz (str): Time zone from package pytz. Default is None, then apply utc time. Use function pytz.all_timezones to get the list of timezones. Returns: void """ print( "The current conuting function is based on capture frame by stream." ) dir_path = os.path.join(self.target_img_path, image_prefix) if not os.path.isdir(dir_path): os.makedirs(dir_path) frames_res = [] if num_im <= 0: try: i = 0 while True: i = i + 1 frame_res = self.capture_frame_by_stream( image_prefix, i, mprob, tz) frames.res.append(frame_res) time.sleep(time_interval) except KeyboardInterrupt: return frames_res print('Abort by key interrupt.') else: for i in range(num_im): frame_res = self.capture_frame_by_stream( image_prefix, i, mprob, tz) frames_res.append(frame_res) time.sleep(time_interval) return frames_res def capture_frame_by_stream(self, image_prefix="stream", image_index=0, mprob=30, tz=None) -> int: """ capture a frame from a online stream, namely webcam. Args: image_prefix (str): Prefix of target images. The postfix is numerated by numbers. image_index (int): The postfix of target images. By default, numerated from 0. mprob (int): Minimum probability to be a person. tz (str): Time zone from package pytz. Default is None, then apply utc time. Use function pytz.all_timezones to get the list of timezones. Returns: tuple: The name of target image, the number of persons in an image detected by the model and the current time. """ video_cap = cv2.VideoCapture(self.stream.url) dir_path = os.path.join(self.target_img_path, image_prefix) if video_cap is None: print("Open webcam [%s] failed." % self.stream.url) return None else: ret, frame = video_cap.read() if not ret: print("Captured frame is broken.") video_cap.release() return None else: print("-----------------------------------------------------") if tz is None: current_time = datetime.utcnow().strftime( "%a %Y-%m-%d %H:%M:%S") print('### time zone is None, therefore use utc time ###') else: current_time = datetime.now( timezone(tz)).strftime("%a %Y-%m-%d %H:%M:%S") print("Capturing frame %d." % image_index) target_img_name = "{}{}.png".format(image_prefix, image_index) # frame = crop_frame(frame, target_img_name) # comment to unuse the crop function. cv2.imwrite(os.path.join(dir_path, target_img_name), frame) detections = self.detector.detectCustomObjectsFromImage( custom_objects=self.custom_objects, input_image=os.path.join(dir_path, target_img_name), output_image_path=os.path.join(dir_path, target_img_name), minimum_percentage_probability=mprob) print( "The number of person in frame %d (%s):" % (image_index, target_img_name), len(detections)) print( "The current time in frame %d (%s):" % (image_index, target_img_name), current_time) img = cv2.imread(os.path.join(dir_path, target_img_name)) # put the number of persons to the image and put timestamp to the image self.put_text_to_img( img, "The number of person:%s " % str(len(detections))) img_height, img_width = img.shape[0:2] self.put_text_to_img(img, "The current time:%s " % current_time, pos=(int(img_width * 0.1), int(img_height * 0.9))) cv2.imwrite(os.path.join(dir_path, target_img_name), img) video_cap.release() return target_img_name, len(detections), current_time def capture_frame_by_screenshot_wrapper(self, image_prefix="screenshot", mprob=30, num_im=6, time_interval=10, tz=None): """ A wrapper of the function capture_frame_by_screenshot. Args: image_prefix (str): Prefix of target images. The postfix is numerated by numbers. mprob (int): Minimum probability to be a person. num_im (int): How many images will be taken. time_interval (int): Time interval of taking next image, the unit is second. tz (str): Time zone from package pytz. Default is None, then apply utc time. Use function pytz.all_timezones to get the list of timezones. Returns: void """ print( "The current conuting function is based on capture frame by screenshot." ) frames_res = [] dir_path = os.path.join(self.target_img_path, image_prefix) if not os.path.isdir(dir_path): os.makedirs(dir_path) if num_im <= 0: try: i = 0 while True: i = i + 1 frame_res = self.capture_frame_by_screenshot( image_prefix, i, mprob, tz) frames_res.append(frame_res) time.sleep(time_interval) except KeyboardInterrupt: if self.driver is not None: self.driver.quit() return frames_res print('Abort by key interrupt.') else: for i in range(num_im): frame_res = self.capture_frame_by_screenshot( image_prefix, i, mprob, tz) frames_res.append(frame_res) time.sleep(time_interval) if self.driver is not None: self.driver.quit() return frames_res def capture_frame_by_screenshot(self, image_prefix="screenshot", image_index=0, mprob=30, num_im=6, tz=None) -> int: """ capture an image by taking a screenshot on an opened website via browser. Args: image_prefix (str): Prefix of target images. The postfix is numerated by numbers. image_index (int): The postfix of target images. By default, numerated from 0. mprob (int): Minimum probability to be a person. tz (str): Time zone from package pytz. Default is None, then apply utc time. Use function pytz.all_timezones to get the list of timezones. Returns: tuple: The name of target image, the number of persons in an image detected by the model and the current time. """ dir_path = os.path.join(self.target_img_path, image_prefix) if self.driver is None: print("Web driver is none.") return None else: print("-----------------------------------------------------") if tz is None: current_time = datetime.utcnow().strftime( "%a %Y-%m-%d %H:%M:%S") print('### time zone is None, therefore use utc time###') else: current_time = datetime.now( timezone(tz)).strftime("%a %Y-%m-%d %H:%M:%S") target_img_name = "{}{}.png".format(image_prefix, image_index) print("Taking screenshot %d..." % image_index) self.driver.save_screenshot(os.path.join(dir_path, target_img_name)) detections = self.detector.detectCustomObjectsFromImage( custom_objects=self.custom_objects, input_image=os.path.join(dir_path, target_img_name), output_image_path=os.path.join(dir_path, target_img_name), minimum_percentage_probability=mprob) print( "The number of person in frame %d (%s):" % (image_index, target_img_name), len(detections)) print( "The current time in frame %d (%s):" % (image_index, target_img_name), current_time) img = cv2.imread(os.path.join(dir_path, target_img_name)) # put the number of persons to the image self.put_text_to_img( img, "The number of person is:%s" % str(len(detections))) img_height, img_width = img.shape[0:2] self.put_text_to_img(img, "The current time:%s " % current_time, pos=(int(img_width * 0.1), int(img_height * 0.9))) cv2.imwrite(os.path.join(dir_path, target_img_name), img) return target_img_name, len(detections), current_time def init_webdriver(self): """ Initialize the webdriver of Chrome by using the python lib selenium. Args: Void Returns: Void """ self.driver = webdriver.Chrome( ) # Optional argument, if not specified will search path. self.driver.get(self.stream_link) time.sleep(15) # Jump over the ads def store_info_in_df_csv( self, infos, cvs_filename="counting_person", ): """ Collect test dataset by storing the image name and the detected number of persons in a csv file. Args: infos (list): The infos of images contain the image name, the number of detected persons, current time of given time zone and the empty ground-truth. cvs_filename (str): The name of csv file. Returns: df (DataFrame): Show the image name, the detected number of persons, current time of given time zone """ df = pd.DataFrame(np.array(infos), columns=['image_name', 'detected_num', 'time']) # df["counted_num"] = "" #only for baseline df.to_csv(path_or_buf=os.path.join(self.target_img_path, "%s.csv" % cvs_filename)) return df
output_topic = 'output3' brokers = "G01-01:2181,G01-02:2181,G01-03:2181,G01-04:2181,G01-05:2181,G01-06:2181,G01-07:2181,G01-08:2181," \ "G01-09:2181,G01-10:2181,G01-11:2181,G01-12:2181,G01-13:2181,G01-14:2181,G01-15:2181,G01-16:2181" def my_decoder(s): return s kafkaStream = KafkaUtils.createStream(ssc, brokers, 'test-consumer-group-3', {input_topic: 15}, valueDecoder=my_decoder) producer = KafkaProducer(bootstrap_servers='G01-01:9092', compression_type='gzip', batch_size=163840, buffer_memory=33554432, max_request_size=20485760) detector = ObjectDetection() detector.setModelTypeAsTinyYOLOv3() # !!!tiny detector.setModelPath('/home/hduser/yolo-tiny.h5') detector.loadModel(detection_speed="flash") custom = detector.CustomObjects(person=True, bottle=True, knife=True, cell_phone=True, fork=True) graph = tf.get_default_graph() broadcast_detector = sc.broadcast(detector) broadcast_custom = sc.broadcast(custom) broadcast_graph = sc.broadcast(graph) broadcast_producer = sc.broadcast(producer) def obj_detection(ss): key = ss[0] value = ss[1]