def __init__(self): self.image_sub = rospy.Subscriber("~ncs_image_rect", Image, self.img_cb, queue_size=5) self.mode_sub = rospy.Subscriber("~mode", FSMState, self.fsm_mode) self.image_pub = rospy.Publisher('image_with_box', Image, queue_size=5) self.veh_name = rospy.get_param('~veh_name') #for img_cb self.bridge = CvBridge() self.cv_image = 0 self.cv_img_crop = [] #caffe params self.model = model = 'street_en_harvest' self.device_work = False mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) self.dim = (100, 32) #counter & flag params\ self.ncs_set = 0 self.start = 0 self.time = 0 self.n = 1 self.stop_line = 0 ### 0 self.deviceCheck()
def __init__(self, graph_file, img_shape, device_t): self.img_shape = img_shape mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) print("[INFO] finding NCS devices...") devices = mvnc.EnumerateDevices() # if no devices found, exit the script if len(devices) == 0: print("[INFO] No devices found. Please plug in a NCS") quit() print("[INFO] found {} devices. device0 will be used. " "opening device0...".format(len(devices))) device = mvnc.Device(devices[0]) device.OpenDevice() # open the CNN graph file print("[INFO] loading the graph file into memory...") with open(graph_file, mode="rb") as f: graph_in_memory = f.read() # load the graph into the NCS print("[INFO] allocating the graph on the NCS...") self.graph = device.AllocateGraph(graph_in_memory)
def __init__(self): self.initiated = False self.output = None # configure the NCS mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) # Get a list of ALL the sticks that are plugged in self.devices = mvnc.EnumerateDevices() if len(self.devices) == 0: print('No devices found') quit() # Pick the first stick to run the network self.device = mvnc.Device(self.devices[0]) # Open the NCS self.device.OpenDevice() graph_filename = 'graph' # Load graph file to memory buffer self.graph_data = None with open(graph_filename, mode='rb') as f: self.graph_data = f.read() self.ssd_mobilenet_graph = self.device.AllocateGraph(self.graph_data)
def __init__(self, yolo_model='tiny-yolo-v2'): self.model = YOLO_MODELS[yolo_model] ncs_graph = os.path.join(YOLO_MODELS_DIR, yolo_model + '.graph') # configure the NCS mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 1) # Get a list of ALL the sticks that are plugged in devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') quit() # Pick the first stick to run the network self.mvncs_dev = mvnc.Device(devices[0]) # Open the NCS try: self.mvncs_dev.OpenDevice() except: print('Cannot Open NCS Device') #Load blob with open(ncs_graph, mode='rb') as f: blob = f.read() self.graph = self.mvncs_dev.AllocateGraph(blob) self.graph.SetGraphOption(mvnc.GraphOption.ITERATIONS, 1)
def __init__(self, graphfile): select = 1 self.detector = YoloDetector(select) mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No MVNC devices found') quit() self.device = mvnc.Device(devices[0]) self.device.OpenDevice() opt = self.device.GetDeviceOption(mvnc.DeviceOption.OPTIMISATION_LIST) # load blob with open(graphfile, mode='rb') as f: blob = f.read() self.graph = self.device.AllocateGraph(blob) self.graph.SetGraphOption(mvnc.GraphOption.ITERATIONS, 1) iterations = self.graph.GetGraphOption(mvnc.GraphOption.ITERATIONS) self.dim = (416, 416) self.blockwd = 12 self.wh = self.blockwd * self.blockwd self.targetBlockwd = 12 self.classes = 20 self.threshold = 0.2 self.nms = 0.4
def __init__(self): mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No device found') quit() self.device = mvnc.Device(devices[0]) self.graph = None # traffic light # read mean file self.traffic_dim = (227, 227) self.traffic_mean = (81.1, 88.5, 90.3) # read label file traffic_labelfile = 'traffic_label.txt' self.traffic_labels = numpy.loadtxt(traffic_labelfile, str, delimiter='\t') # Load graph self.traffic_light_model = 'traffic_light_graph' # object detection # read mean file self.detection_dim = (300, 300) self.detection_mean = (127.5, 127.5, 127.5) # read label file detection_labelfile = 'detection_label.txt' self.detection_labels = numpy.loadtxt(detection_labelfile, str, delimiter='\t') # Load graph self.object_detection_model = 'object_deteciton_graph'
def __init__(self, path_to_graph, categories): assert type(path_to_graph) is str, '文字列を指定してください' assert type(categories) is tuple or type(categories) is list, 'タプルかリストを指定してください' # グラフファイルまでのパスをなんとなく保存しておく self.path_to_graph = path_to_graph # カテゴリのリストを受け取る self.categories = categories # おまじない mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) # Movidiusを読み込む devices = mvnc.EnumerateDevices() if len(devices) == 0: # 1本も見つからなかったら何もしない print('No devices found') return # セットアップ self.device = mvnc.Device(devices[0]) self.device.OpenDevice() # graphファイルを読み込む with open(self.path_to_graph, mode= 'rb') as f: graphfile = f.read() # デバイスにグラフファイルをセットする. # self.graphオブジェクトを使って検出を行う self.graph = self.device.AllocateGraph(graphfile)
def initial(self): self.model = rospy.get_param("~model_name") self.ncs_pkg = rospy.get_param("~ncs_pkg") self.device_work = False mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) self.deviceCheck() self.dim = (101, 101) #(width, height)
def run(self): # configure the NCS mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) # Get a list of ALL the sticks that are plugged in devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') quit() # Pick the first stick to run the network device = mvnc.Device(devices[0]) # Open the NCS device.OpenDevice() graph_filename = 'graph' # Load graph file to memory buffer with open(graph_filename, mode='rb') as f: graph_data = f.read() # allocate the Graph instance from NCAPI by passing the memory buffer ssd_mobilenet_graph = device.AllocateGraph(graph_data) # Create Video Capture object cap = cv2.VideoCapture(0) time.sleep(1) if ((cap == None or (not cap.isOpened()))): print('Could not open video device. Make sure file exists:') #print ('file name:' + input_video_file) print('Also, if you installed python opencv via pip or pip3 you') print( 'need to uninstall it and install from source with -D WITH_V4L=ON' ) print('Use the provided script: install-opencv-from_source.sh') exit_app = True return while (not self.killSwitch): self.ret, self.display_image = cap.read() if (not self.ret): print("No image from the video device, exiting") break self.inferred_image = self.run_inference(self.display_image, ssd_mobilenet_graph) # Clean up the graph and the device print("quitting") ssd_mobilenet_graph.DeallocateGraph() device.CloseDevice() cap.release()
def initial(self): self.model = model = 'street_en_harvest' self.start = 0 self.time = 0 self.n = 1 self.camera_name = rospy.get_param('~camera_name') self.device_work = False mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) self.deviceCheck() self.dim = (100, 32) #(width, height)
def __init__(self): # configuration NCS mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) self.devices = mvnc.EnumerateDevices() if len(self.devices) == 0: # No NCS devices found print('No NCS devices found') self.device = None else: # Try connecting to the first NCS device found self.device = mvnc.Device(self.devices[0]) self.device.OpenDevice() self.opt = self.device.GetDeviceOption(mvnc.DeviceOption.OPTIMISATION_LIST)
def __init__(self, input_width, input_height, mean_proto, ncs_graph): mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No NCS devices found') exit(1) self.device = mvnc.Device(devices[0]) self.device.OpenDevice() with open(ncs_graph, mode='rb') as f: blob = f.read() self.graph = self.device.AllocateGraph(blob) super().__init__(input_width, input_height, mean_proto)
def prepare(self): self.tinyyolo_status = True tiny_yolo_graph_file = './graph/tinyyolo_graph' mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 0) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') quit() self.device = mvnc.Device(devices[0]) self.device.OpenDevice() with open(tiny_yolo_graph_file, mode='rb') as f: graph_from_disk = f.read() self.graph = self.device.AllocateGraph(graph_from_disk)
def init_movidius(): global for_close_graph, for_close_device mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') quit() for_close_device = device = mvnc.Device(devices[0]) device.OpenDevice() graph_filename = 'graph' with open(graph_filename, mode='rb') as f: graph_data = f.read() for_close_graph = device.AllocateGraph(graph_data) return for_close_graph
def initial(self): self.device_work = False mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) self.deviceCheck() shape_txt = "" shape = [] with open(self.model_Base_Dir + 'input_shape.prototxt', 'r') as file: shape_txt = file.read().replace('\n', ' ') for s in shape_txt.split(): if s.isdigit(): shape.append(int(s)) self.dim = (shape[2], shape[3])
def open_ncs_device(verbose=False): if verbose: mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) # Look for enumerated NCS device(s); quit program if none found. devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') quit() # Get a handle to the first enumerated device and open it device = mvnc.Device(devices[0]) device.OpenDevice() return device
def __init__(self): # Set logging level and initialize/open the first NCS we find mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 0) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') return 1 self.device = mvnc.Device(devices[0]) self.device.OpenDevice() #Load graph from disk and allocate graph via API with open(tiny_yolo_graph_file, mode='rb') as f: graph_from_disk = f.read() self.graph = self.device.AllocateGraph(graph_from_disk)
def init_graph(blob): mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') quit() device = mvnc.Device(devices[0]) device.OpenDevice() opt = device.GetDeviceOption(mvnc.DeviceOption.OPTIMISATION_LIST) with open(blob, mode='rb') as f: blob = f.read() graph = device.AllocateGraph(blob) graph.SetGraphOption(mvnc.GraphOption.ITERATIONS, 1) iterations = graph.GetGraphOption(mvnc.GraphOption.ITERATIONS) return graph, device
def __init__(self, device_index): mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) devices = mvnc.EnumerateDevices() if len(devices) <= 0: raise Exception('No Movidius device found.') if device_index > (len(devices) - 1): raise Exception('Movidius device %d does not exists' % device_index) self.__device_index = device_index self.__device = mvnc.Device(devices[device_index]) self.__graph = None self.__predict_queue = Queue.Queue(50) self.__predict_event = None self.__predict_thread = None self.__stop_flag = False
def main(): print('Running NCS Caffe TinyYolo example') # Set logging level and initialize/open the first NCS we find mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 0) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') return 1 device = mvnc.Device(devices[0]) device.OpenDevice() #Load graph from disk and allocate graph via API with open(tiny_yolo_graph_file, mode='rb') as f: graph_from_disk = f.read() graph = device.AllocateGraph(graph_from_disk) # Read image from file, resize it to network width and height # save a copy in display_image for display, then convert to float32, normalize (divide by 255), # and finally convert to convert to float16 to pass to LoadTensor as input for an inference input_image = cv2.imread(input_image_file) display_image = input_image input_image = cv2.resize(input_image, (NETWORK_IMAGE_WIDTH, NETWORK_IMAGE_HEIGHT), cv2.INTER_LINEAR) input_image = input_image.astype(np.float32) input_image = np.divide(input_image, 255.0) input_image = input_image[:, :, ::-1] # convert to RGB # Load tensor and get result. This executes the inference on the NCS graph.LoadTensor(input_image.astype(np.float16), 'user object') output, userobj = graph.GetResult() # filter out all the objects/boxes that don't meet thresholds filtered_objs = filter_objects( output.astype(np.float32), input_image.shape[1], input_image.shape[0]) # fc27 instead of fc12 for yolo_small print('Displaying image with objects detected in GUI') print('Click in the GUI window and hit any key to exit') #display the filtered objects/boxes in a GUI window display_objects_in_gui(display_image, filtered_objs) #Clean up graph.DeallocateGraph() device.CloseDevice() print('Finished')
def execute_graph(blob, img): mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') quit() device = mvnc.Device(devices[0]) device.OpenDevice() opt = device.GetDeviceOption(mvnc.DeviceOption.OPTIMISATION_LIST) with open(blob, mode='rb') as f: blob = f.read() graph = device.AllocateGraph(blob) graph.SetGraphOption(mvnc.GraphOption.ITERATIONS, 1) iterations = graph.GetGraphOption(mvnc.GraphOption.ITERATIONS) graph.LoadTensor(img.astype(numpy.float16), 'user object') output, userobj = graph.GetResult() graph.DeallocateGraph() device.CloseDevice() return output, userobj
def prepare(self): self.googlenet_status = True self.dim = (224, 224) labels_file = './data/synset_words.txt' self.labels = numpy.loadtxt(labels_file, str, delimiter='\t') mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') quit() self.device = mvnc.Device(devices[0]) self.device.OpenDevice() network_blob = './graph/GoogleNet_graph' with open(network_blob, mode='rb') as f: blob = f.read() self.graph = self.device.AllocateGraph(blob) self.ilsvrc_mean = numpy.load('./data/ilsvrc_2012_mean.npy').mean( 1).mean(1)
def prepare(self): self.gendernet_status = True blob = "./graph/gender_graph" self.gender_list = ['Male', 'Female'] self.ilsvrc_mean = numpy.load('./data/age_gender_mean.npy').mean( 1).mean(1) #loading the mean file mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') self.device = mvnc.Device(devices[0]) self.device.OpenDevice() opt = self.device.GetDeviceOption(mvnc.DeviceOption.OPTIMISATION_LIST) with open(blob, mode='rb') as f: blob = f.read() self.graph = self.device.AllocateGraph(blob) self.graph.SetGraphOption(mvnc.GraphOption.ITERATIONS, 1) iterations = self.graph.GetGraphOption(mvnc.GraphOption.ITERATIONS) print( '-----------------------prepare gendernet successful-----------------------' )
def init_yolo(): try: print('Running NCS Caffe TinyYolo example') # Set logging level and initialize/open the first NCS we find mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 0) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') return 1 device = mvnc.Device(devices[0]) device.OpenDevice() #Load graph from disk and allocate graph via API with open(tiny_yolo_graph_file, mode='rb') as f: graph_from_disk = f.read() graph = device.AllocateGraph(graph_from_disk) return 0,graph except: return -1,None
def prepare(self): self.agenet_status = True mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') self.device = mvnc.Device(devices[0]) self.device.OpenDevice() opt = self.device.GetDeviceOption(mvnc.DeviceOption.OPTIMISATION_LIST) blob = "./graph/age_graph" with open(blob, mode='rb') as f: blob = f.read() self.graph = self.device.AllocateGraph(blob) self.graph.SetGraphOption(mvnc.GraphOption.ITERATIONS, 1) iterations = self.graph.GetGraphOption(mvnc.GraphOption.ITERATIONS) self.age_list = [ '0-2', '4-6', '8-12', '15-20', '25-32', '38-43', '48-53', '60-100' ] self.ilsvrc_mean = numpy.load('./data/age_gender_mean.npy').mean( 1).mean(1) #loading the mean file print( '-----------------------prepare agenet successful-----------------------' )
parser.add_argument('-q-size', '--queue-size', dest='queue_size', type=int, default=5, help='Size of the queue.') args = parser.parse_args() logger = multiprocessing.log_to_stderr() logger.setLevel(multiprocessing.SUBDEBUG) input_q = Queue(maxsize=args.queue_size) output_q = Queue(maxsize=args.queue_size) # configuration NCS network_blob = 'graph' mvnc.SetGlobalOption(mvnc.GlobalOption.LOGLEVEL, 2) devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') quit() device = mvnc.Device(devices[0]) device.OpenDevice() opt = device.GetDeviceOption(mvnc.DeviceOption.OPTIMISATIONLIST) # load blob with open(network_blob, mode='rb') as f: blob = f.read() graph = device.AllocateGraph(blob) graph.SetGraphOption(mvnc.GraphOption.ITERATIONS, 1) iterations = graph.GetGraphOption(mvnc.GraphOption.ITERATIONS) # pool = Pool(args.num_workers, worker, (graph, input_q, output_q))
def main(): global resize_output, resize_output_width, resize_output_height if (not handle_args()): print_usage() return 1 # configure the NCS mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) # Get a list of ALL the sticks that are plugged in devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') quit() # Pick the first stick to run the network device = mvnc.Device(devices[0]) # Open the NCS device.OpenDevice() graph_filename = 'graph' # Load graph file to memory buffer with open(graph_filename, mode='rb') as f: graph_data = f.read() # allocate the Graph instance from NCAPI by passing the memory buffer ssd_mobilenet_graph = device.AllocateGraph(graph_data) # get list of all the .mp4 files in the image directory input_video_filename_list = os.listdir(input_video_path) input_video_filename_list = [ i for i in input_video_filename_list if i.endswith('.mp90') ] if (len(input_video_filename_list) < 1): # no images to show print('No video (.mp4) files found') return 1 cv2.namedWindow(cv_window_name) cv2.moveWindow(cv_window_name, 10, 10) exit_app = False while (True): for input_video_file in input_video_filename_list: cap = cv2.VideoCapture(input_video_path + input_video_file) actual_frame_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH) actual_frame_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT) print('actual video resolution: ' + str(actual_frame_width) + ' x ' + str(actual_frame_height)) if ((cap == None) or (not cap.isOpened())): print('Could not open video device. Make sure file exists:') print('file name:' + input_video_file) print( 'Also, if you installed python opencv via pip or pip3 you') print( 'need to uninstall it and install from source with -D WITH_V4L=ON' ) print('Use the provided script: install-opencv-from_source.sh') exit_app = True break frame_count = 0 start_time = time.time() end_time = start_time ret, img = cap.read() size = img.shape[1], img.shape[0] # save results in a video file #fourcc = cv2.VideoWriter_fourcc(*'mp4v') fourcc = cv2.VideoWriter_fourcc(*'H264') video = cv2.VideoWriter( input_video_path + input_video_file + '_output.avi', fourcc, 10, size) while (True): ret, source_image = cap.read() display_image = cropImage(source_image, 700, 350, 300, 300) if (not ret): end_time = time.time() print("No image from from video device, exiting") break # check if the window is visible, this means the user hasn't closed # the window via the X button prop_val = cv2.getWindowProperty(cv_window_name, cv2.WND_PROP_ASPECT_RATIO) if (prop_val < 0.0): end_time = time.time() exit_app = True break #display_image = rotateImage(display_image, 90) run_inference(display_image, ssd_mobilenet_graph) if (resize_output): display_image = cv2.resize( display_image, (resize_output_width, resize_output_height), cv2.INTER_LINEAR) cv2.imshow(cv_window_name, display_image) video.write(display_image) raw_key = cv2.waitKey(1) if (raw_key != -1): if (handle_keys(raw_key) == False): end_time = time.time() exit_app = True break frame_count += 1 frames_per_second = frame_count / (end_time - start_time) print('Frames per Second: ' + str(frames_per_second)) cap.release() if (exit_app): break if (exit_app): break # Clean up the graph and the device ssd_mobilenet_graph.DeallocateGraph() device.CloseDevice() video.release() cv2.destroyAllWindows()
def MultiStick(): mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 2) devices = mvnc.EnumerateDevices() if len(devices) == 0: print("No devices found") quit() print(len(devices)) devHandle = [] graphHandle = [] with open(join(graph_folder, "graph"), mode="rb") as f: graph = f.read() for devnum in range(len(devices)): devHandle.append(mvnc.Device(devices[devnum])) devHandle[devnum].OpenDevice() graphHandle.append(devHandle[devnum].AllocateGraph(graph)) graphHandle[devnum].SetGraphOption(mvnc.GraphOption.ITERATIONS, 1) iterations = graphHandle[devnum].GetGraphOption( mvnc.GraphOption.ITERATIONS) print("\nLoaded Graphs!!!") cam = cv2.VideoCapture(0) #cam = cv2.VideoCapture('/home/pi/SSD_MobileNet/xxxx.mp4') if cam.isOpened() != True: print("Camera/Movie Open Error!!!") quit() windowWidth = 1280 windowHeight = 640 cam.set(cv2.CAP_PROP_FRAME_WIDTH, windowWidth) cam.set(cv2.CAP_PROP_FRAME_HEIGHT, windowHeight) lock = Lock() frameBuffer = [] results = Queue() lastresults = None LABELS = ('background', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor') def init(): glClearColor(0.7, 0.7, 0.7, 0.7) def idle(): glutPostRedisplay() def resizeview(w, h): glViewport(0, 0, w, h) glLoadIdentity() glOrtho(-w / 1920, w / 1920, -h / 1080, h / 1080, -1.0, 1.0) def keyboard(key, x, y): key = key.decode('utf-8') if key == 'q': lock.acquire() while len(frameBuffer) > 0: frameBuffer.pop() lock.release() for devnum in range(len(devices)): graphHandle[devnum].DeallocateGraph() devHandle[devnum].CloseDevice() print("\n\nFinished\n\n") sys.exit() def camThread(): lastresults = None s, img = cam.read() if not s: print("Could not get frame") return 0 lock.acquire() if len(frameBuffer) > 10: for i in range(10): del frameBuffer[0] frameBuffer.append(img) lock.release() res = None if not results.empty(): res = results.get(False) flag, img = overlay_on_image(img, res) if flag != 0: #glutLeaveMainLoop() print(img) return img img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) h, w = img.shape[:2] glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, img) lastresults = res else: imdraw = overlay_on_image(img, lastresults) imdraw = cv2.cvtColor(imdraw, cv2.COLOR_BGR2RGB) h, w = imdraw.shape[:2] glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, imdraw) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glColor3f(1.0, 1.0, 1.0) glEnable(GL_TEXTURE_2D) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glBegin(GL_QUADS) glTexCoord2d(0.0, 1.0) glVertex3d(-1.0, -1.0, 0.0) glTexCoord2d(1.0, 1.0) glVertex3d(1.0, -1.0, 0.0) glTexCoord2d(1.0, 0.0) glVertex3d(1.0, 1.0, 0.0) glTexCoord2d(0.0, 0.0) glVertex3d(-1.0, 1.0, 0.0) glEnd() glFlush() glutSwapBuffers() def inferencer(results, lock, frameBuffer, handle): failure = 0 sleep(5) while failure < 100: lock.acquire() if len(frameBuffer) == 0: lock.release() failure += 1 continue img = frameBuffer[-1].copy() del frameBuffer[-1] failure = 0 lock.release() now = time.time() im = preprocess_image(img) handle.LoadTensor(im.astype(np.float16), None) out, userobj = handle.GetResult() results.put(out) #print("elapsedtime = ", time.time() - now) def preprocess_image(src): img = cv2.resize(src, (300, 300)) img = img - 127.5 img = img * 0.007843 return img def overlay_on_image(display_image, object_info): sumbox = [0, 0] flag = 0 if isinstance(object_info, type(None)): return display_image num_valid_boxes = int(object_info[0]) img_cp = display_image.copy() if num_valid_boxes > 0: for box_index in range(num_valid_boxes): base_index = 7 + box_index * 7 if (not np.isfinite(object_info[base_index]) or not np.isfinite(object_info[base_index + 1]) or not np.isfinite(object_info[base_index + 2]) or not np.isfinite(object_info[base_index + 3]) or not np.isfinite(object_info[base_index + 4]) or not np.isfinite(object_info[base_index + 5]) or not np.isfinite(object_info[base_index + 6])): continue x1 = max(0, int(object_info[base_index + 3] * img_cp.shape[0])) y1 = max(0, int(object_info[base_index + 4] * img_cp.shape[1])) x2 = min(img_cp.shape[0], int(object_info[base_index + 5] * img_cp.shape[0])) y2 = min(img_cp.shape[1], int(object_info[base_index + 6] * img_cp.shape[1])) x1_ = str(x1) y1_ = str(y1) x2_ = str(x2) y2_ = str(y2) if (object_info[base_index + 2]) > flag: flag = int(object_info[base_index + 2]) sumbox = [(int(x1_) + int(x2_)) // 2, (int(y1_) + int(y2_)) // 2] # print('box at index: ' + str(box_index) + ' : ClassID: ' + LABELS[int(object_info[base_index + 1])] + ' ' # 'Confidence: ' + str(object_info[base_index + 2]*100) + '% ' + # 'Top Left: (' + x1_ + ', ' + y1_ + ') Bottom Right: (' + x2_ + ', ' + y2_ + ')') object_info_overlay = object_info[base_index:base_index + 7] min_score_percent = 10 source_image_width = img_cp.shape[1] source_image_height = img_cp.shape[0] base_index = 0 class_id = object_info_overlay[base_index + 1] percentage = int(object_info_overlay[base_index + 2] * 100) if (percentage <= min_score_percent): continue label_text = LABELS[int(class_id)] + " (" + str( percentage) + "%)" box_left = int(object_info_overlay[base_index + 3] * source_image_width) box_top = int(object_info_overlay[base_index + 4] * source_image_height) box_right = int(object_info_overlay[base_index + 5] * source_image_width) box_bottom = int(object_info_overlay[base_index + 6] * source_image_height) box_color = (255, 128, 0) box_thickness = 1 cv2.rectangle(img_cp, (box_left, box_top), (box_right, box_bottom), box_color, box_thickness) label_background_color = (125, 175, 75) label_text_color = (255, 255, 255) label_size = cv2.getTextSize(label_text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)[0] label_left = box_left label_top = box_top - label_size[1] if (label_top < 1): label_top = 1 label_right = label_left + label_size[0] label_bottom = label_top + label_size[1] cv2.rectangle(img_cp, (label_left - 1, label_top - 1), (label_right + 1, label_bottom + 1), label_background_color, -1) cv2.putText(img_cp, label_text, (label_left, label_bottom), cv2.FONT_HERSHEY_SIMPLEX, 0.5, label_text_color, 1) if sumbox == [0, 0]: return 0, img_cp else: return 1, sumbox glutInitWindowPosition(0, 0) glutInitWindowSize(1280, 640) glutInit(sys.argv) glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE) glutCreateWindow("DEMO") #glutFullScreen() glutDisplayFunc(camThread) glutReshapeFunc(resizeview) glutKeyboardFunc(keyboard) init() glutIdleFunc(idle) print("press 'q' to quit!\n") threads = [] for devnum in range(len(devices)): t = Thread(target=inferencer, args=(results, lock, frameBuffer, graphHandle[devnum])) t.start() threads.append(t) glutMainLoop()
class MvDetector(): mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 1) devices = mvnc.EnumerateDevices() devNum = len(devices) if len(devices) == 0: print('No MVNC devices found') quit() devHandle = [] graphHandle = [] def __init__(self, graphfile, cfgfile=None): if cfgfile == None: cfgfile = graphfile.replace(".graph", ".cfg") if not os.path.exists(graphfile): print("Error: Could not find graph file {}".format(graphfile)) return if not os.path.exists(cfgfile): print( "Error: Could not find darknet config file {}".format(cfgfile)) return for i in range(MvDetector.devNum): MvDetector.devHandle.append(mvnc.Device(MvDetector.devices[i])) MvDetector.devHandle[i].OpenDevice() opt = MvDetector.devHandle[i].GetDeviceOption( mvnc.DeviceOption.OPTIMISATION_LIST) # load blob with open(graphfile, mode='rb') as f: blob = f.read() MvDetector.graphHandle.append( MvDetector.devHandle[i].AllocateGraph(blob)) MvDetector.graphHandle[i].SetGraphOption( mvnc.GraphOption.ITERATIONS, 1) #MvDetector.graphHandle[i].SetGraphOption(mvnc.GraphOption.DONTBLOCK, 1) iterations = MvDetector.graphHandle[i].GetGraphOption( mvnc.GraphOption.ITERATIONS) imgWidth = cfgGetVal(cfgfile, "net", "width") imgHeight = cfgGetVal(cfgfile, "net", "height") numClasses = cfgGetVal(cfgfile, "region", "classes") anchors = cfgGetVal(cfgfile, "region", "anchors") self.detector = createYoloDetector(numClasses, anchors) self.dim = (imgWidth, imgHeight) self.blockwd = BLOCK_WD self.wh = BLOCK_WD * BLOCK_WD self.targetBlockwd = TARGET_BLOCK_WD self.classes = numClasses self.nms = NMS def __del__(self): for i in range(MvDetector.devNum): MvDetector.graphHandle[i].DeallocateGraph() MvDetector.devHandle[i].CloseDevice() def PrepareImage(self, img, dim): tPrep0 = time.time() imgw = img.shape[1] imgh = img.shape[0] imgb = np.empty((dim[0], dim[1], 3)) imgb.fill(0.5) if imgh / imgw > dim[1] / dim[0]: neww = int(imgw * dim[1] / imgh) newh = dim[1] else: newh = int(imgh * dim[0] / imgw) neww = dim[0] offx = int((dim[0] - neww) / 2) offy = int((dim[1] - newh) / 2) tDiff0 = 1000. * (time.time() - tPrep0) print(" prep0 = {:.2f}".format(tDiff0)) tRes = time.time() #img01 = img.copy()/255.0 #imgb[offy:offy+newh,offx:offx+neww,:] = resize(img01,(newh,neww),1) imgNet = cv2.resize(img, (neww, newh), cv2.INTER_LINEAR) imgNet = np.divide(imgNet, 255.) imgb[offy:offy + newh, offx:offx + neww, :] = imgNet im = imgb[:, :, (2, 1, 0)] tResDiff = 1000. * (time.time() - tRes) print(" resize = {:.2f}".format(tResDiff)) return im, int(offx * imgw / neww), int( offy * imgh / newh), neww / dim[0], newh / dim[1] def _reshape(self, out): shape = out.shape out = np.transpose(out.reshape(self.wh, int(shape[0] / self.wh))) out = out.reshape(shape) return out def GetDetector(self): return self.detector def Detect(self, img, thresh): #imgw = img.shape[1] #imgh = img.shape[0] #im,offx,offy,xscale,yscale = self.PrepareImage(img, self.dim) #print('xscale = {}, yscale = {}'.format(xscale, yscale)) #print("in shape = {}".format(img.shape)) MvDetector.graphHandle[0].LoadTensor(img, 'user object') out, userobj = MvDetector.graphHandle[0].GetResult() #print("out shape = {}".format(out.shape)) out = self._reshape(out) out = out.astype(np.float32) #with open("mvout.txt", "w") as fh: # outStr = [str(x) for x in out] # fh.writelines("\n".join(outStr)) #print("out shape after reshape = {}".format(out.shape)) #out = self.detector.Detect(out, thresh) # 4ms #pyresults = [BBox(x,xscale,yscale, offx, offy) for x in internalresults] return out
# print("window closed") widget.hide() pipeline.set_state(Gst.State.NULL) Gtk.main_quit() def sigint_handler(signal, frame): Gtk.main_quit() if __name__ == "__main__": Gdk.init([]) Gtk.init([]) Gst.init([]) fx.SetGlobalOption(fx.GlobalOption.LOGLEVEL, 0) parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) sourcegroup = parser.add_mutually_exclusive_group() # VideoSource subclasses as choices for source sourcegroup.add_argument('--v4l2-src', help="v4l2 source device name, e.g. /dev/video0", default="/dev/video1") sourcegroup.add_argument( '--src', choices=[ cls.__name__ for cls in vars()['VideoSource'].__subclasses__() ],