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 # lilinwei modify code start tiny_yolo_graph_file = os.path.join(os.path.dirname(__file__), 'graph') # lilinwei modify code end 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_file_ = 'data/images/photo.jpg' input_image_file = os.path.join(os.path.dirname(__file__), input_image_file_) input_image = cv2.imread(input_image_file) display_image = input_image NETWORK_IMAGE_WIDTH = 448 NETWORK_IMAGE_HEIGHT = 448 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 = caffe_objecet_direction.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 # lilinwei modify code start # for filtered_obj in filtered_objs: # print(filtered_obj) graph.DeallocateGraph() device.CloseDevice() return filtered_objs # lilinwei modify code end # display_objects_in_gui(display_image, filtered_objs) # Clean up # graph.DeallocateGraph() # device.CloseDevice() print('Finished')
green_LED = LED(12) # Physical pin 32 yellow_LED = LED(16) # Physical pin 36 red_LED = LED(21) # Physical pin 40 #-------------------------------------------------------------------- #----------------------------NCS Setup------------------------------- #-------------------------------------------------------------------- # Check if NCS is connected devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No NCS devices found') quit() # Pick the first stick to run the network device = mvnc.Device(devices[0]) # Open the NCS device.OpenDevice() # The graph file that was created with the ncsdk compiler graph_file_name = GRAPH_FILENAME # read in the graph file to memory buffer with open(graph_file_name, mode='rb') as f: graph_in_memory = f.read() # create the NCAPI graph instance from the memory buffer containing the graph file. graph = device.AllocateGraph(graph_in_memory) del graph_in_memory del f
gNetworkMean = numpy.load( EXAMPLES_BASE_DIR + 'data/ilsvrc12/ilsvrc_2012_mean.npy').mean(1).mean( 1) #loading the mean file gNetworkStd = numpy.load(EXAMPLES_BASE_DIR + 'data/ilsvrc12/ilsvrc_2012_mean.npy').std(1) # Load categories from categories.txt gNetworkCategories = [] labels_file = EXAMPLES_BASE_DIR + 'data/ilsvrc12/synset_words.txt' gNetworkCategories = numpy.loadtxt(labels_file, str, delimiter='\t') fx.SetGlobalOption(fx.GlobalOption.LOG_LEVEL, 2) # For this program we will always use the first MVNC device. ncs_names = fx.EnumerateDevices() if (len(ncs_names) < 1): print( "Error - No NCS devices detected. Make sure your device is connected." ) quit() # Initialize the MVNC device dev = fx.Device(ncs_names[0]) dev.OpenDevice() gGraph = dev.AllocateGraph(get_graph_from_disk()) # Initialize input and output threads to pass images to the # MVNC device and to read results from the inferences made on thos images. start_thread()
# Entry point if __name__ == "__main__": # Set the logging level for the NC API fx.global_set_option(fx.GlobalOption.RW_LOG_LEVEL, 0) # Get a list of names for all the devices plugged into the system devices = fx.enumerate_devices() if (len(devices) < 1): print( "ERROR: No NCS devices detected, verify an NCS device is connected." ) quit() # Get the first NCS device by its name # For this program we will always open the first NCS device dev = fx.Device(devices[0]) # Try to open the device # This will throw an exception if someone else has it open already try: dev.open() except: print("ERROR: Could not open NCS device.") quit() print("INFO: Hello world, NCS! Device opened normally.") try: dev.close() except: print("ERROR: could not close NCS device.") quit()
def main(): print('Running NCS Caffe TinyYolo example') # Set logging level to only log errors mvnc.global_set_option(mvnc.GlobalOption.RW_LOG_LEVEL, 3) devices = mvnc.enumerate_devices() if len(devices) == 0: print('No devices found') return 1 device = mvnc.Device(devices[0]) device.open() #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 = mvnc.Graph("Tiny Yolo Graph") fifo_in, fifo_out = graph.allocate_with_fifos(device, graph_from_disk) #------------------------------ # capture #------------------------------ cap = cv2.VideoCapture("cars.mp4") #------------------------------ # pygame init #------------------------------ pygame.init() screen = pygame.display.set_mode((640, 360)) pygame.display.set_caption("TinyYolo VR") background = pygame.image.load("aquarium.jpg") player = pygame.image.load("jellyfish.png").convert_alpha() x_ratio = float(screen.get_width()) / NETWORK_IMAGE_WIDTH y_ratio = float(screen.get_height()) / NETWORK_IMAGE_HEIGHT while True: ret, frame = cap.read() if ret == False: break # Wait key key = cv2.waitKey(1) if key != -1: break # 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) input_image = frame 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.queue_inference_with_fifo_elem(fifo_in, fifo_out, input_image.astype(np.float32), None) output, userobj = fifo_out.read_elem() # 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]) 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) # Display cv2.imshow("window", display_image) #------------------------------ # pygame draw #------------------------------ #draw background screen.blit(background, (0, 0)) #draw player for obj_index in range(len(filtered_objs)): center_x = int(filtered_objs[obj_index][1] * x_ratio) center_y = int(filtered_objs[obj_index][2] * y_ratio) screen.blit(player, (center_x - player.get_width() / 2, center_y - player.get_height() / 2)) #update display pygame.display.flip() fifo_in.destroy() fifo_out.destroy() graph.destroy() device.close() device.destroy() print('Finished') # Clean up capture cap.release() cv2.destroyAllWindows()
def infer(imgname): # *************************************************************** # get labels # *************************************************************** labels_file = EXAMPLES_BASE_DIR + 'data/ilsvrc12/synset_words.txt' labels = numpy.loadtxt(labels_file, str, delimiter='\t') # *************************************************************** # 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() filefolder = os.path.dirname(os.path.realpath(__file__)) network_blob = filefolder + '/graph' system('(cd ' + filefolder + ';test -f graph || make compile)') #Load blob with open(network_blob, mode='rb') as f: blob = f.read() graph = device.AllocateGraph(blob) # *************************************************************** # Load the image # *************************************************************** ilsvrc_mean = numpy.load( EXAMPLES_BASE_DIR + 'data/ilsvrc12/ilsvrc_2012_mean.npy').mean(1).mean( 1) #loading the mean file img = cv2.imread(imgname) img = cv2.resize(img, dim) img = img.astype(numpy.float32) img[:, :, 0] = (img[:, :, 0] - ilsvrc_mean[0]) img[:, :, 1] = (img[:, :, 1] - ilsvrc_mean[1]) img[:, :, 2] = (img[:, :, 2] - ilsvrc_mean[2]) # *************************************************************** # Send the image to the NCS # *************************************************************** graph.LoadTensor(img.astype(numpy.float16), 'user object') # *************************************************************** # Get the result from the NCS # *************************************************************** output, userobj = graph.GetResult() # *************************************************************** # Print the results of the inference form the NCS # *************************************************************** order = output.argsort()[::-1][:6] print('\n------- predictions --------') result = "" for i in range(0, 5): #print ('prediction ' + str(i) + ' (probability ' + str(output[order[i]]*100) + '%) is ' + labels[order[i]] + ' label index is: ' + str(order[i]) ) label = re.search("n[0-9]+\s([^,]+)", labels[order[i]]).groups(1)[0] result = result + "\n%20s %0.2f %%" % (label, output[order[i]] * 100) # *************************************************************** # Clean up the graph and the device # *************************************************************** graph.DeallocateGraph() device.CloseDevice() return result, imgname
def main(): print("Loading system...") mvnc.global_set_option(mvnc.GlobalOption.RW_LOG_LEVEL, 2) # enumerate all devices devices = mvnc.enumerate_devices() if len(devices) == 0: print("No devices found") quit() # use the first device found device = mvnc.Device(devices[0]) # open the device device.open() # load the model from the disk with open(GRAPH_PATH, mode="rb") as f: graph_in_memory = f.read() graph = mvnc.Graph(GRAPH_PATH) # create the input and output fifos fifo_in, fifo_out = graph.allocate_with_fifos(device, graph_in_memory) cap = cv2.VideoCapture(0) print("Starting capture...") try: while True: global start_time start_time = time.time() # read an image in bgr format ret, img = cap.read() original_img = img # bgr input scaling img = np.divide(img, 255.0) resized_img = cv2.resize(img, (416, 416), cv2.INTER_LINEAR) # transpose the image to rgb resized_img = resized_img[:, :, ::-1] resized_img = resized_img.astype(np.float32) # make an inference graph.queue_inference_with_fifo_elem(fifo_in, fifo_out, resized_img, "user object") # get the result output, userobj = fifo_out.read_elem() # Tiny Yolo V2 requires post processing to filter out duplicate objects and low score objects # After post processing, the app will display the image and any detected objects post_processing(output, original_img) except KeyboardInterrupt: print("Closing, please wait...") pass # clean up cv2.destroyAllWindows() cv2.VideoCapture(0).release() fifo_in.destroy() fifo_out.destroy() graph.destroy() device.close() device.destroy() print("All done!")
def main(): while True: vs=VideoStream(usePiCamera=True).start() time.sleep(1) print('Running NCS Caffe TinyYolo example') # Set logging level to only log errors mvnc.global_set_option(mvnc.GlobalOption.RW_LOG_LEVEL, 3) ########################################################################### devices = mvnc.enumerate_devices() if len(devices) == 0: print('No devices found') return 1 ########################################################################### device = mvnc.Device(devices[0]) device.open() #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 = mvnc.Graph("Tiny Yolo Graph") ############################################################################ fifo_in, fifo_out = graph.allocate_with_fifos(device, graph_from_disk) #may need another line here from cheat sheet # fifo_in, fifo_out = graph.allocate_with_fifos(device, graph_from_disk, # fifo_in_type=mvnc.FifoType.HOST_WO, fifo_in_data_type=mvnc.FifoDataType.FP32, # fifo_in_num_elem=2, # fifo_out_type=mvnc.FifoType.HOST_RO, fifo_out_data_type=mvnc.FifoDataType.FP32, # fifo_out_num_elem=2) # 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 while True: frame=vs.read()# Get a frame from a video stream. input_image=frame.copy()# copy frame to an input image. display_image = cv2.resize(input_image, (NETWORK_IMAGE_WIDTH, NETWORK_IMAGE_HEIGHT), cv2.INTER_LINEAR) input_image = cv2.resize(input_image, (NETWORK_IMAGE_WIDTH, NETWORK_IMAGE_HEIGHT), cv2.INTER_LINEAR) input_image = input_image.astype(np.float32) ############################################################################## input_image = (255.0/input_image.max()) #could also be this # input_image = input_image/255 # input_image[:] = ((input_image[:] )*(1.0/255.0)) input_image = input_image[:, :, ::-1] # convert to RGB #TODO: Use the queue_inference_with_fifo_elem to load the image and get the result from the NCS. This should be one line of code. graph.queue_inference_with_fifo_elem(fifo_in, fifo_out, input_image,'userobj') output, userobj = fifo_out.read_elem() # 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]) ############################################################## save_box(filtered_objs,display_image) 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) fifo_in.destroy() fifo_out.destroy() graph.destroy() device.close() device.destroy() time.sleep(.5) print('Finished')
def main(): global gn_mean, gn_labels, actual_frame_height, actual_frame_width, TY_BOX_PROBABILITY_THRESHOLD, TY_MAX_IOU print_info() # Set logging level and initialize/open the first NCS we find mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 0) devices = mvnc.EnumerateDevices() if len(devices) < 2: print('This application requires two NCS devices.') print('Insert two devices and try again!') return 1 ty_device = mvnc.Device(devices[0]) ty_device.OpenDevice() gn_device = mvnc.Device(devices[1]) gn_device.OpenDevice() #Load tiny yolo graph from disk and allocate graph via API try: with open(tiny_yolo_graph_file, mode='rb') as ty_file: ty_graph_from_disk = ty_file.read() ty_graph = ty_device.AllocateGraph(ty_graph_from_disk) except: print('Error - could not load tiny yolo graph file') ty_device.CloseDevice() gn_device.CloseDevice() return 1 #Load googlenet graph from disk and allocate graph via API try: with open(googlenet_graph_file, mode='rb') as gn_file: gn_graph_from_disk = gn_file.read() gn_graph = gn_device.AllocateGraph(gn_graph_from_disk) except: print('Error - could not load googlenet graph file') ty_device.CloseDevice() gn_device.CloseDevice() return 1 # GoogLenet initialization EXAMPLES_BASE_DIR = '../../' gn_mean = np.load(EXAMPLES_BASE_DIR + 'data/ilsvrc12/ilsvrc_2012_mean.npy').mean(1).mean( 1) # loading the mean file gn_labels_file = EXAMPLES_BASE_DIR + 'data/ilsvrc12/synset_words.txt' gn_labels = np.loadtxt(gn_labels_file, str, delimiter='\t') for label_index in range(0, len(gn_labels)): temp = gn_labels[label_index].split(',')[0].split(' ', 1)[1] gn_labels[label_index] = temp # get list of all the .jpg 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('.mp4') ] if (len(input_video_filename_list) < 1): # no images to show print('No .mp4 files found') return 1 exit_app = False print('Starting GUI, press Q to quit') cv2.namedWindow(cv_window_name) cv2.waitKey(1) TY_MAX_IOU = 0.15 TY_BOX_PROBABILITY_THRESHOLD = 0.13 while (True): for input_video_file in input_video_filename_list: video_device = cv2.VideoCapture("./" + input_video_file) actual_frame_width = video_device.get(cv2.CAP_PROP_FRAME_WIDTH) actual_frame_height = video_device.get(cv2.CAP_PROP_FRAME_HEIGHT) print('actual video resolution: ' + str(actual_frame_width) + ' x ' + str(actual_frame_height)) if ((video_device == None) or (not video_device.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') frame_count = 0 start_time = time.time() while True: # Read image from video device, ret_val, input_image = video_device.read() if (not ret_val): end_time = time.time() print("No image from from video device, exiting") break # resize image to network width and height # then convert to float32, normalize (divide by 255), # and finally convert to float16 to pass to LoadTensor as input # for an inference input_image = cv2.resize( input_image, (TY_NETWORK_IMAGE_WIDTH, TY_NETWORK_IMAGE_HEIGHT), cv2.INTER_LINEAR) # save a display image as read from video device. display_image = input_image.copy() # modify input_image for TinyYolo input input_image = input_image[:, :, ::-1] # convert to RGB input_image = input_image.astype(np.float32) input_image = np.divide(input_image, 255.0) # Load tensor and get result. This executes the inference on the NCS ty_graph.LoadTensor(input_image.astype(np.float16), 'user object') output, userobj = ty_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]) get_googlenet_classifications(gn_graph, display_image, filtered_objs) # 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 overlay_on_image(display_image, filtered_objs) # resize back to original size so image doesn't look squashed # It might be better to resize the boxes to match video dimensions # and overlay them directly on the video image returned from video device. display_image = cv2.resize( display_image, (int(actual_frame_width), int(actual_frame_height)), cv2.INTER_LINEAR) # update the GUI window with new image cv2.imshow(cv_window_name, 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 = frame_count + 1 frames_per_second = frame_count / (end_time - start_time) print('File: ' + input_video_file) print('Frames per Second: ' + str(frames_per_second)) # close video device video_device.release() if (exit_app): break if (exit_app): break # clean up tiny yolo ty_graph.DeallocateGraph() ty_device.CloseDevice() # Clean up googlenet gn_graph.DeallocateGraph() gn_device.CloseDevice() print('Finished')
def main(): cv_window_name = "SSD MobileNet - hit any key to exit" devices = mvnc.enumerate_devices() if len(devices) == 0: print('No devices found') quit() device = mvnc.Device(devices[0]) device.open() graph_file_name = 'test.graph' with open(graph_file_name, mode='rb') as f: graph_in_memory = f.read() graph = mvnc.Graph(graph_file_name) fifoIn, fifoOut = graph.allocate_with_fifos(device, graph_in_memory) # read the image to run an inference on from the disk while True: f_list = [] for i, j, filename_list in os.walk(jpath): f_list = filename_list si1 = len(f_list) time.sleep(1.2) f9_list = [] for i, j, filename99_list in os.walk(jpath): f9_list = filename99_list si2 = len(f9_list) if si1 == si2: for f in f_list: temjpg = jpath + f ncsjpg = tmpth + f if os.path.isfile(temjpg): mymovefile(temjpg, ncsjpg) infer_image = cv2.imread(ncsjpg) nn_list = f.split('.') nf = nn_list[0] try: run_inference(infer_image, graph, fifoIn, fifoOut, nf) except: os.remove(ncsjpg) continue else: f1_list = [] for e, r, filename2_list in os.walk(tmpth): f1_list = filename2_list if len(f1_list) > 1: for ff in f1_list: srcfile = tmpth + ff dstfile = goal_path + ff mymovefile(srcfile, dstfile) else: os.remove(ncsjpg) else: continue else: continue # display the results and wait for user to hit a key #cv2.imshow(cv_window_name, infer_image) #cv2.imwrite("./0833/") #cv2.waitKey(0) # Clean up the graph and the device graph.destroy() fifoIn.destroy() fifoOut.destroy() device.close()
def main(): global resize_output, resize_output_width, resize_output_height if (not handle_args()): print_usage() return 1 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() graph_filename = 'graph' with open(graph_filename, mode='rb') as f: graph_data = f.read() graphnet = device.AllocateGraph(graph_data) # template = cv2.imread('template.png',0) # template = cv2.resize(template, (NETWORK_IMAGE_WIDTH, NETWORK_IMAGE_HEIGHT)) # orb = cv2.ORB_create() # kp1, des1 = orb.detectAndCompute(template,None) cv2.namedWindow(cv_window_name) cv2.moveWindow(cv_window_name, 10, 10) exit_app = False cap = cv2.VideoCapture(0) 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. ') exit_app = True frame_count = 0 start_time = time.time() end_time = start_time bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) ## Calibration Matrix: ##[[ 516.14758188 0. 314.02546443] ## [ 0. 515.76615942 250.15817809] ## [ 0. 0. 1. ]] ##Disortion: [[ 2.48041485e-01 -6.31759025e-01 4.36060601e-04 -1.48720850e-03 ## 5.17810257e-01]] ##total error: 0.021112667972552 mtx = numpy.matrix([[516.14758188, 0, 314.02546443], [0, 515.76615942, 250.15817809], [0, 0, 1]]) disto = numpy.matrix([[ 2.48041485e-01, -6.31759025e-01, 4.36060601e-04, -1.48720850e-03, 5.17810257e-01 ]]) nrows = 7 ncols = 7 dimension = 9 choice = input( 'Enter Y to run camera calibration, press enter to continue:') if choice.upper() == 'Y': ret, mtx, disto, rvecs, tvecs = run_camera_calibration( cap, nrows, ncols, dimension) if not ret: print('failed to calibrate') exit_app = True print('mtx', mtx) print('disto', disto) ret, img = cap.read() h, w = img.shape[:-1] newcameramtx, roi = cv2.getOptimalNewCameraMatrix(mtx, disto, (w, h), 1, (w, h)) #mapx, mapy = cv2.initUndistortRectifyMap(mtx, disto, None, newcameramtx, (w, h), 5) while (True): if (exit_app): break ret, image = cap.read() if (not ret): end_time = time.time() print("No image from from video device, exiting") break display_imagec = cv2.undistort(image, mtx, disto, None, newcameramtx) x, y, w, h = roi display_imagec = display_imagec[y:y + h, x:x + w] # check if user hasn't closed the window 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 = cv2.cvtColor(display_imagec, cv2.COLOR_BGR2GRAY) #corners = cv2.goodFeaturesToTrack(display_image,81, 0.1, 10) ret, corners = cv2.findChessboardCorners(display_image, (ncols, nrows), None) if ret != True: print('No much found') continue try: corners = sorted(numpy.int0(corners).tolist(), key=lambda x: x) except: continue xp = int(actual_frame_width / 2) yp = int(actual_frame_height / 2) cv2.circle(display_image, (xp, yp), 10, [150, 0, 0], -1) ii = 0 print('######################################') sstart = True udx = 0 for corner in corners: [x, y] = corner[0] if sstart: corner[0].append(0) xp = x yp = y sstart = False continue udx += (x - xp) corner[0].append(x - xp) xp = x yp = y print('###################################### udx : ', udx, cnt, len(corners)) udx /= len(corners) print('###################################### udx : ', udx) ii = 0 jj = 0 sstart = True cpx = [[[]]] for corner in corners: if sstart: sstart = False continue if corner[0][2] < udx: cpx[ii].append(corner[0]) [x, y, dx] = corner[0] print(ii, ',', x, ',', y, ',', dx) else: ii += 1 cpx.append([corner[0]]) [x, y, dx] = corner[0] print(ii, ',', x, ',', y, ',', dx) cv2.circle(display_image, (x, y), 3, 2000, -1) print('######################################') ################################################################################################### # kp2, des2 = orb.detectAndCompute(display_imagec,None) # matches = bf.match(des1,des2) # matches = sorted(matches, key = lambda x:x.distance) # display_image = cv2.drawMatches(template,kp1,display_imagec,kp2,matches[:36],None, flags=4) #################################################################################################### #run_inference(display_image, graphnet) #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) 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() # Clean up the graph and the device graphnet.DeallocateGraph() device.CloseDevice() cv2.destroyAllWindows()
def inferencer(results, frameBuffer, ssd_detection_mode, face_detection_mode, devnum, mp_active_stick_number, mp_stick_temperature): graphs = [] graph_buffers = [] graphHandles = [] graphHandle0 = None graphHandle1 = None mvnc.global_set_option(mvnc.GlobalOption.RW_LOG_LEVEL, 4) devices = mvnc.enumerate_devices() if len(devices) == 0: print("No NCS devices found") sys.exit(1) print(len(devices)) # 1:= Enabled MobileNet-SSD Model if ssd_detection_mode == 1: with open(join(graph_folder, "graph"), mode="rb") as f: graph_buffers.append(f.read()) graphs.append(mvnc.Graph('MobileNet-SSD')) # 1:= Enabled Fullweight FaceDetection Model if face_detection_mode == 1: with open(join(graph_folder, "graph.fullfacedetection"), mode="rb") as f: graph_buffers.append(f.read()) graphs.append(mvnc.Graph('FullFaceDetection')) # 2:= Enabled Lightweight FaceDetection Model if face_detection_mode == 2: with open(join(graph_folder, "graph.shortfacedetection"), mode="rb") as f: graph_buffers.append(f.read()) graphs.append(mvnc.Graph('ShortFaceDetection')) devopen = False for device in devices: try: device = mvnc.Device(device) device.open() for (graph, graph_buffer) in zip(graphs, graph_buffers): graphHandles.append(graph.allocate_with_fifos(device, graph_buffer)) devopen = True break except: continue if devopen == False: print("NCS Devices open Error!!!") sys.exit(1) print("Loaded Graphs!!! ") THERMAL_STATS = mvnc.DeviceOption.RO_THERMAL_STATS temperature = device.get_option while True: # 0:= Inactive stick, 1:= Active stick if mp_active_stick_number[devnum] == 0: continue # Measure the temperature inside the stick mp_stick_temperature[devnum] = temperature(THERMAL_STATS)[0] try: if frameBuffer.empty(): continue color_image = frameBuffer.get() prepimg = preprocess_image(color_image) res = None for (graph, graphHandle) in zip(graphs, graphHandles): graphHandle0 = graphHandle[0] graphHandle1 = graphHandle[1] graph.queue_inference_with_fifo_elem(graphHandle0, graphHandle1, prepimg.astype(np.float32), None) out, _ = graphHandle1.read_elem() num_valid_boxes = int(out[0]) if num_valid_boxes > 0: if isinstance(res, type(None)): res = [out] else: res = np.append(res, [out], axis=0) results.put(res) except: import traceback traceback.print_exc()
def main(): # 設定程式參數 arg_parser = argparse.ArgumentParser(description='使用 Movidius 進行預測') arg_parser.add_argument( '--graph-file', required=True, help='Movidius 模型檔', ) arg_parser.add_argument( '--video-type', choices=['file', 'camera'], default='camera', help='影片類型', ) arg_parser.add_argument( '--source', default='/dev/video0', help='影片來源檔', ) arg_parser.add_argument( '--input-width', type=int, default=48, help='模型輸入影像寬度', ) arg_parser.add_argument( '--input-height', type=int, default=48, help='模型輸入影像高度', ) arg_parser.add_argument( '--gui', action='store_true', help='啓用圖像界面', ) # 解讀程式參數 args = arg_parser.parse_args() assert args.input_width > 0 and args.input_height > 0 # 設置 Movidius 裝置 mvnc.global_set_option(mvnc.GlobalOption.RW_LOG_LEVEL, 2) mvnc_devices = mvnc.enumerate_devices() if not mvnc_devices: print('找不到 Movidius 裝置') exit(1) mvnc_dev = mvnc.Device(mvnc_devices[0]) mvnc_dev.open() # 載入模型檔 try: with open(args.graph_file, mode='rb') as file_graph: graph_buffer = file_graph.read() except (FileNotFoundError, IOError): print('無法載入模型檔') exit(1) graph = mvnc.Graph('graph') fifo_in, fifo_out = graph.allocate_with_fifos(mvnc_dev, graph_buffer) # 開啓影片來源 if args.video_type == 'file': # 檔案 video_dev = cv2.VideoCapture(args.source) video_width = video_dev.get(cv2.CAP_PROP_FRAME_WIDTH) video_height = video_dev.get(cv2.CAP_PROP_FRAME_HEIGHT) elif args.video_type == 'camera': # 攝影機 video_dev = cv2.VideoCapture(0) # 主迴圈 try: prev_timestamp = time.time() while True: ret, orig_image = video_dev.read() curr_time = time.localtime() # 檢查串流是否結束 if ret is None or orig_image is None: break # 縮放爲模型輸入的維度、調整數字範圍爲 0~1 之間的數值 resized_image = cv2.resize( orig_image, (args.input_width, args.input_height), ).astype(np.float32) normalized_image = resized_image / 255.0 # 執行預測 graph.queue_inference_with_fifo_elem( fifo_in, fifo_out, normalized_image, None, ) result_onehot, _ = fifo_out.read_elem() left_score, right_score, stop_score, other_score = result_onehot class_id = np.argmax(result_onehot) if class_id == 0: class_str = 'left' elif class_id == 1: class_str = 'right' elif class_id == 2: class_str = 'stop' elif class_id == 3: class_str = 'other' # 計算執行時間 recent_timestamp = time.time() period = recent_timestamp - prev_timestamp prev_timestamp = recent_timestamp print('時間:%02d:%02d:%02d ' % (curr_time.tm_hour, curr_time.tm_min, curr_time.tm_sec)) print('輸出:%.2f %.2f %.2f %.2f' % (left_score, right_score, stop_score, other_score)) print('類別:%s' % class_str) print('費時:%f' % period) print() # 顯示圖片 if args.gui: cv2.imshow('', orig_image) cv2.waitKey(1) except KeyboardInterrupt: print('使用者中斷') # 終止影像裝置 video_dev.release() # 終止 Movidius 裝置 fifo_in.destroy() fifo_out.destroy() graph.destroy() mvnc_dev.close() mvnc_dev.destroy()
def main(): print('test start') func() return print('Running NCS Caffe TinyYolo example') # Set logging level to only log errors mvnc.global_set_option(mvnc.GlobalOption.RW_LOG_LEVEL, 3) devices = mvnc.enumerate_devices() if len(devices) == 0: print('No devices found') return 1 device = mvnc.Device(devices[0]) device.open() #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 = mvnc.Graph("Tiny Yolo Graph") fifo_in, fifo_out = graph.allocate_with_fifos(device, 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 cv_window_name='123' while (True): video_device = cv2.VideoCapture("./" + input_image_file) actual_frame_width = video_device.get(cv2.CAP_PROP_FRAME_WIDTH) actual_frame_height = video_device.get(cv2.CAP_PROP_FRAME_HEIGHT) print ('actual video resolution: ' + str(actual_frame_width) + ' x ' + str(actual_frame_height)) # if ((video_device == None) or (not video_device.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') # frame_count = 0 # start_time = time.time() #frame_count = frame_count + 1 #frames_per_second = frame_count / (end_time - start_time) while True : print ('Use the provided script: install-opencv-from_source.sh') time1 = time.time() ret_val, input_image = video_device.read() time2 = time.time() start_time = time.time() 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 time3 = time.time() # Load tensor and get result. This executes the inference on the NCS graph.queue_inference_with_fifo_elem(fifo_in, fifo_out, input_image.astype(np.float32), None) output, userobj = fifo_out.read_elem() # 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]) 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) time4 = time.time() end_time = time.time() time_used=end_time-start_time print("time used : "+ str(time_used)+"time point:"+str(time1)+" "+str(time2)+" "+str(time3)+" "+str(time4)) cv2.imshow(cv_window_name, input_image) #raw_key = cv2.waitKey(1) if (not ret_val): # end_time = time.time() print("No image from from video device, exiting") break # resize image to network width and height # then convert to float32, normalize (divide by 255), # and finally convert to float16 to pass to LoadTensor as input # for an inference # input_image = cv2.resize(input_image, (TY_NETWORK_IMAGE_WIDTH, TY_NETWORK_IMAGE_HEIGHT), cv2.INTER_LINEAR) # save a display image as read from video device. # close video device video_device.release() 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.queue_inference_with_fifo_elem(fifo_in, fifo_out, input_image.astype(np.float32), None) output, userobj = fifo_out.read_elem() # 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]) 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) fifo_in.destroy() fifo_out.destroy() graph.destroy() device.close() device.destroy() print('Finished')
def main(): """Main function for the program. Everything starts here. :return: None """ global resize_output, resize_output_width, resize_output_height, \ resize_output, resize_output_width, resize_output_height, \ device_count if (not handle_args()): print_usage() return 1 # 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('.mp4')] if (len(input_video_filename_list) < 1): # no images to show print('No video (.mp4) files found') return 1 resting_image = cv2.imread("resting_image.png") if (resting_image is None): resting_image = numpy.zeros((800, 600, 3), numpy.uint8) if (resize_output): resting_image = cv2.resize(resting_image, (resize_output_width, resize_output_height), cv2.INTER_LINEAR) # Set logging level to only log errors mvnc.global_set_option(mvnc.GlobalOption.RW_LOG_LEVEL, 3) devices = mvnc.enumerate_devices() if len(devices) < 1: print('No NCS device detected.') print('Insert device and try again!') return 1 if (device_count < 1) or (device_count > len(devices)): device_count = len(devices) # Create an object detector processor for each device that opens # and store it in our list of processors obj_detect_list = list() idle_obj_detect_list = list() device_number = 0 for one_device in devices: try: obj_detect_dev = mvnc.Device(one_device) obj_detect_dev.open() print("opened device " + str(device_number)) obj_detector_proc = Yolov2_tiny_Processor(NETWORK_GRAPH_FILENAME, obj_detect_dev, inital_box_prob_thresh=min_score_percent / 100.0, classification_mask=object_classifications_mask, name="object detector " + str(device_number)) if (device_number < device_count): obj_detect_list.append(obj_detector_proc) else: idle_obj_detect_list.append(obj_detector_proc) device_number += 1 except: print("Could not open device " + str(device_number) + ", trying next device") pass if len(obj_detect_list) < 1: print('Could not open any NCS devices.') print('Reinsert devices and try again!') return 1 print("Using " + str(len(obj_detect_list)) + " devices for object detection") print_hot_keys() cv2.namedWindow(cv_window_name) cv2.moveWindow(cv_window_name, 10, 10) cv2.waitKey(1) exit_app = False while (True): for input_video_file in input_video_filename_list : for one_obj_detect_proc in obj_detect_list: print("using object detector: " + one_obj_detect_proc.get_name()) one_obj_detect_proc.drain_queues() # video processor that will put video frames images on the object detector's input FIFO queue video_proc = VideoProcessor(input_video_path + '/' + input_video_file, network_processor_list = obj_detect_list) video_proc.start_processing() frame_count = 0 start_time = time.time() last_throttle_time = start_time end_time = start_time uptime=time.time() while(True): done = False for one_obj_detect_proc in obj_detect_list: try: (filtered_objs, display_image) = one_obj_detect_proc.get_async_inference_result() print("resive result:",time.time()-uptime) uptime=time.time() except : print("exception caught in main") raise # 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() video_proc.stop_processing() video_proc.cleanup() exit_app = True break running_fps = frame_count / (time.time() - start_time) overlay_on_image(display_image, filtered_objs, running_fps) print("show time:",time.time()-uptime) 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) raw_key = cv2.waitKey(1) if (raw_key != -1): if (handle_keys(raw_key, obj_detect_list) == False): end_time = time.time() exit_app = True done = True break frame_count += 1 #if (one_obj_detect_proc.is_input_queue_empty()): if (not video_proc.is_processing()): # asssume the video is over. end_time = time.time() done = True print('video processor not processing, assuming video is finished.') break #if (frame_count % 100) == 0: if ((time.time() - last_throttle_time) > throttle_check_seconds): #long movie, check for throttling devices # throttling = one_obj_detect_proc.get_device().get_option(mvnc.DeviceOption.RO_THERMAL_THROTTLING_LEVEL) last_throttle_time = time.time() print("movie not done, but going a long time so adjust for throttling") video_proc.pause() do_throttle_adjustment(obj_detect_list, idle_obj_detect_list) video_proc.unpause() if (done) : break frames_per_second = frame_count / (end_time - start_time) print('Frames per Second: ' + str(frames_per_second)) # check for throttling devices and save in throttling list throttling_list = list() for one_obj_detect_proc in obj_detect_list: throttling = one_obj_detect_proc.get_device().get_option(mvnc.DeviceOption.RO_THERMAL_THROTTLING_LEVEL) if (throttling > 0): print("\nDevice " + one_obj_detect_proc.get_name() + " is throttling, level is: " + str(throttling)) throttling_list.append(one_obj_detect_proc) if (not exit_app): # rest between movies, display an image while resting resting_display_image = cv2.resize(resting_image, (display_image.shape[1], display_image.shape[0]), cv2.INTER_LINEAR) cv2.imshow(cv_window_name, resting_display_image) if ((len(throttling_list) > len(idle_obj_detect_list))): # more devices throttling than we have in the idle list # so do extra rest by applying a multiplier to the rest time print("throttling devices... resting") cv2.waitKey(rest_seconds * 1000 * rest_throttling_multiplier) else: cv2.waitKey(rest_seconds * 1000) # remove the throttling devices from the main list and put them at the end so they will # be moved to the idle list with priority for one_throttling in throttling_list: obj_detect_list.remove(one_throttling) obj_detect_list.append(one_throttling) num_idle = len(idle_obj_detect_list) if (num_idle > len(obj_detect_list)): num_idle = len(obj_detect_list) if (num_idle > 0): # replace one of the devices with an idle device for idle_index in range(0, num_idle): #for one_idle_proc in idle_obj_detect_list: obj_detect_list.insert(0, idle_obj_detect_list.pop(0)) for idle_count in range(0, num_idle): idle_obj_detect_list.append(obj_detect_list.pop()) video_proc.stop_processing() video_proc.cleanup() if (exit_app): break if (exit_app): break # Clean up the graph and the device for one_obj_detect_proc in obj_detect_list: cv2.waitKey(1) one_obj_detect_proc.cleanup(True) cv2.destroyAllWindows()
def main(): global resize_output, resize_output_width, resize_output_height if (not handle_args()): print_usage() return 1 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() graph_filename = 'caffe_ssd_mobilenet_graph' with open(os.path.join(Config.model_dir, graph_filename), mode='rb') as f: graph_data = f.read() ssd_mobilenet_graph = device.AllocateGraph(graph_data) cv2.namedWindow(cv_window_name) cv2.moveWindow(cv_window_name, 10, 10) exit_app = False list_cam = Config.get_usb_cam() while (True): if list_cam is not None and list_cam[0] != "": cam_index = int(list_cam[0][-1]) cap = cv2.VideoCapture(cam_index) actual_frame_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH) actual_frame_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT) if ((cap == None) or (not cap.isOpened())): print('Could not open usb cam') exit_app = True break while (True): ret, display_image = cap.read() if (not ret): 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): exit_app = True break 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) raw_key = cv2.waitKey(1) if (raw_key != -1): if (handle_keys(raw_key) == False): exit_app = True break cap.release() if (exit_app): break if (exit_app): break ssd_mobilenet_graph.DeallocateGraph() device.CloseDevice() cv2.destroyAllWindows()
def main(): vs = VideoStream(usePiCamera=True).start() time.sleep(1) print('Running NCS Caffe TinyYolo example') # Set logging level to only log errors mvnc.global_set_option(mvnc.GlobalOption.RW_LOG_LEVEL, 3) devices = mvnc.enumerate_devices( ) # TODO use the mvnc API to querydevices. if len(devices) == 0: print('No devices found') return 1 device = mvnc.Device( devices[0] ) # TODO: use the mvnc API to assign the first device in devices to the device variable. device.open() #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 = mvnc.Graph("Tiny Yolo Graph") fifo_in, fifo_out = graph.allocate_with_fifos( device, graph_from_disk ) # TODO: Instantiate fifo_in and fifo_out using the graph file above. # 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 while True: frame = vs.read() # Get a frame from a video stream. input_image = frame.copy() # copy frame to an input image. display_image = cv2.resize(input_image, (NETWORK_IMAGE_WIDTH, NETWORK_IMAGE_HEIGHT), cv2.INTER_LINEAR) input_image = cv2.resize(input_image, (NETWORK_IMAGE_WIDTH, NETWORK_IMAGE_HEIGHT), cv2.INTER_LINEAR) input_image = input_image.astype(np.float32) input_image = (input_image * (1.0 / 255.0) ) # TODO: Scale values between 0 and 255 input_image = input_image[:, :, ::-1] # convert to RGB #TODO: Use the queue_inference_with_fifo_elem to load the image and get the result from the NCS. This should be one line of code. graph.queue_inference_with_fifo_elem(fifo_in, fifo_out, input_image.astype(np.float32), None) output, userobj = fifo_out.read_elem() # 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]) 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) fifo_in.destroy() fifo_out.destroy() graph.destroy() device.close() device.destroy() print('Finished')
def __init__(self): super(MyMnistWindow, self).__init__() self.resize(284*2, 330*2) # resize设置宽高 self.move(100, 100) # move设置位置 说明在哪个位置截图 self.setWindowIcon(QIcon('./logo.ico')) self.setWindowTitle('计算棒测试-手写数字识别') self.setWindowFlags(Qt.FramelessWindowHint) # 窗体无边框 #setMouseTracking设置为False,否则不按下鼠标时也会跟踪鼠标事件 self.setMouseTracking(False) self.pos_xy = [] #保存鼠标移动过的点 # 添加一系列控件 self.label_draw = QLabel('', self) self.label_draw.setStyleSheet("QLabel{background:rgb(255,255,255)}") self.label_draw.setGeometry(2, 2, 550, 550) # (x,y,width,height) self.label_draw.setStyleSheet("QLabel{border:1px solid black;}") self.label_draw.setAlignment(Qt.AlignCenter) self.label_result_name = QLabel('预测:', self) self.label_result_name.setGeometry(2, 570, 61, 35) self.label_result_name.setAlignment(Qt.AlignCenter) self.label_result = QLabel(' ', self) self.label_result.setGeometry(64, 570, 35, 35) self.label_result.setFont(QFont("Roman times", 8, QFont.Bold)) self.label_result.setStyleSheet("QLabel{border:1px solid black;}") self.label_result.setAlignment(Qt.AlignCenter) self.btn_recognize = QPushButton("识别", self) self.btn_recognize.setGeometry(110, 570, 50, 35) self.btn_recognize.clicked.connect(self.btn_recognize_on_clicked) self.btn_clear = QPushButton("清空", self) self.btn_clear.setGeometry(170, 570, 50, 35) self.btn_clear.clicked.connect(self.btn_clear_on_clicked) self.btn_close = QPushButton("关闭", self) self.btn_close.setGeometry(230, 570, 50, 35) self.btn_close.clicked.connect(self.btn_close_on_clicked) # 时间 self.label_time_name = QLabel('识别时间:', self) self.label_time_name.setGeometry(320, 570, 100, 35) self.label_time_name.setAlignment(Qt.AlignCenter) self.label_time = QLabel(' ', self) self.label_time.setGeometry(430, 570, 110, 35) self.label_time.setFont(QFont("Roman times", 8, QFont.Bold)) self.label_time.setStyleSheet("QLabel{border:1px solid black;}") self.label_time.setAlignment(Qt.AlignCenter) # 计算棒信息 self.label_ncs_name = QLabel('NCS状态:', self) self.label_ncs_name.setGeometry(2, 610, 100, 35) self.label_ncs_name.setAlignment(Qt.AlignCenter) self.label_ncs = QLabel(' ', self) self.label_ncs.setGeometry(110, 610, 430, 35) self.label_ncs.setFont(QFont("Roman times", 8, QFont.Bold)) self.label_ncs.setStyleSheet("QLabel{border:1px solid black;}") self.label_ncs.setAlignment(Qt.AlignCenter) # 打开计算棒的设备 mvnc.global_set_option(mvnc.GlobalOption.RW_LOG_LEVEL,2) #获取连接到主机系统的神经计算设备列表 self.devices = mvnc.enumerate_devices() if len(self.devices) == 0: print("[INFO] 未发现计算棒的任何设备!") raise("[Error] No devices found!") # quit() #调用第一个NCS设备 self.device = mvnc.Device(self.devices[0]) print("[INFO] 打开的计算棒设备id:" + str(self.devices[0])) #打开通信 self.device.open() self.ncs_info = "NCS调用成功,device ID:" + str(self.devices[0]) # 加载图 with open(GRAPH_FILE,mode='rb') as f: self.graphFileBuff = f.read() #初始化一个名为graph_name的图 self.graph = mvnc.Graph("alexnet") #创建输入和输出先进先出队列,将图加载到设备 self.input_fifo,self.output_fifo=self.graph.allocate_with_fifos(self.device,self.graphFileBuff)
def main(): global gn_mean, gn_labels, input_image_filename_list print('Running NCS birds example') # get list of all the .jpg files in the image directory input_image_filename_list = os.listdir(input_image_path) input_image_filename_list = [ input_image_path + '/' + i for i in input_image_filename_list if i.endswith('.jpg') ] if (len(input_image_filename_list) < 1): # no images to show print('No .jpg files found') return 1 # Set logging level and initialize/open the first NCS we find mvnc.SetGlobalOption(mvnc.GlobalOption.LOG_LEVEL, 0) devices = mvnc.EnumerateDevices() if len(devices) < 2: print('This application requires two NCS devices.') print('Insert two devices and try again!') return 1 ty_device = mvnc.Device(devices[0]) ty_device.OpenDevice() gn_device = mvnc.Device(devices[1]) gn_device.OpenDevice() #Load tiny yolo graph from disk and allocate graph via API with open(tiny_yolo_graph_file, mode='rb') as ty_file: ty_graph_from_disk = ty_file.read() ty_graph = ty_device.AllocateGraph(ty_graph_from_disk) #Load googlenet graph from disk and allocate graph via API with open(googlenet_graph_file, mode='rb') as gn_file: gn_graph_from_disk = gn_file.read() gn_graph = gn_device.AllocateGraph(gn_graph_from_disk) # GoogLenet initialization EXAMPLES_BASE_DIR = '../../' gn_mean = np.load(EXAMPLES_BASE_DIR + 'data/ilsvrc12/ilsvrc_2012_mean.npy').mean(1).mean( 1) # loading the mean file gn_labels_file = EXAMPLES_BASE_DIR + 'data/ilsvrc12/synset_words.txt' gn_labels = np.loadtxt(gn_labels_file, str, delimiter='\t') for label_index in range(0, len(gn_labels)): temp = gn_labels[label_index].split(',')[0].split(' ', 1)[1] gn_labels[label_index] = temp print('Q to quit, or any key to advance to next image') cv2.namedWindow(cv_window_name) for input_image_file in input_image_filename_list: # Read image from file, resize it to network width and height # save a copy in img_cv 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) # resize the image to be a standard width for all images and maintain aspect ratio STANDARD_RESIZE_WIDTH = 800 input_image_width = input_image.shape[1] input_image_height = input_image.shape[0] standard_scale = float(STANDARD_RESIZE_WIDTH) / input_image_width new_width = int( input_image_width * standard_scale) # this should be == STANDARD_RESIZE_WIDTH new_height = int(input_image_height * standard_scale) input_image = cv2.resize(input_image, (new_width, new_height), cv2.INTER_LINEAR) display_image = input_image input_image = cv2.resize( input_image, (TY_NETWORK_IMAGE_WIDTH, TY_NETWORK_IMAGE_HEIGHT), cv2.INTER_LINEAR) input_image = input_image[:, :, ::-1] # convert to RGB input_image = input_image.astype(np.float32) input_image = np.divide(input_image, 255.0) # Load tensor and get result. This executes the inference on the NCS ty_graph.LoadTensor(input_image.astype(np.float16), 'user object') output, userobj = ty_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 get_googlenet_classifications(gn_graph, display_image, filtered_objs) # check if the window has been closed. all properties will return -1.0 # for windows that are closed. If the user has closed the window via the # x on the title bar then we will break out of the loop. we are # getting property aspect ratio but it could probably be any property try: prop_asp = cv2.getWindowProperty(cv_window_name, cv2.WND_PROP_ASPECT_RATIO) except: break prop_asp = cv2.getWindowProperty(cv_window_name, cv2.WND_PROP_ASPECT_RATIO) if (prop_asp < 0.0): # the property returned was < 0 so assume window was closed by user break ret_val = display_objects_in_gui(display_image, filtered_objs) if (not ret_val): break # clean up tiny yolo ty_graph.DeallocateGraph() ty_device.CloseDevice() # Clean up googlenet gn_graph.DeallocateGraph() gn_device.CloseDevice() print('Finished')
# Do mean substraction for i in range(3): img[:, :, i] = (img[:, :, i] - mean) * std img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img = img.astype(numpy.float16) imgarr.append(img) print("Processed ", len(imgarr), " images") # ***************************************************************** # Open the device and load the graph into each of the devices # ***************************************************************** for devnum in range(len(devices)): print("***********************************************") devHandle.append(mvnc.Device(devices[devnum])) devHandle[devnum].OpenDevice() opt = devHandle[devnum].GetDeviceOption(mvnc.DeviceOption.OPTIMISATIONLIST) print("Optimisations:") print(opt) graphHandle.append(devHandle[devnum].AllocateGraph(graph)) graphHandle[devnum].SetGraphOption(mvnc.GraphOption.ITERATIONS, 1) iterations = graphHandle[devnum].GetGraphOption( mvnc.GraphOption.ITERATIONS) print("Iterations:", iterations) print("***********************************************") print("Loaded Graphs") print("***********************************************\n\n\n")
def run_detection(camera_path, graph_filename, visualize, ros_enabled): global resize_output, resize_output_width, resize_output_height # 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) pub = None sub = None if ros_enabled: from utils.ros_op import CameraSubscriber, DetectionPublisher pub = DetectionPublisher() sub = CameraSubscriber() cv2.namedWindow(cv_window_name) cv2.moveWindow(cv_window_name, 10, 10) exit_app = False while (True): if ros_enabled: cap = sub.get_frame() else: cap = WebcamVideoStream(src=camera_path).start() actual_frame_width = cap.stream.get(3) actual_frame_height = cap.stream.get(4) print('actual video resolution: ' + str(actual_frame_width) + ' x ' + str(actual_frame_height)) if ((cap == None) or (not cap.is_running())): print('Could not open camera device') print('device path:' + camera_path) exit_app = True break frame_count = 0 start_time = time.time() end_time = start_time while (cap.is_running()): ret, display_image = cap.read() 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 run_inference(display_image, ssd_mobilenet_graph, visualize, pub) 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) 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.stop() if (exit_app): break # Clean up the graph and the device ssd_mobilenet_graph.DeallocateGraph() device.CloseDevice() cv2.destroyAllWindows()
def main(): # name of the opencv window # cv_window_name = "SSD MobileNet - hit any key to exit" #start publisher rospy.init_node('SSD_node', anonymous=True) pub = rospy.Publisher('ssd_output', Float32MultiArray, queue_size=2) # Get a list of ALL the sticks that are plugged in # we need at least one devices = mvnc.enumerate_devices() 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.open() graph = mvnc.Graph('graph1') # The graph file that was created with the ncsdk compiler graph_file_name = '/home/owl/src/ncs-ros/graph' # read in the graph file to memory buffer with open(graph_file_name, mode='rb') as f: graph_in_memory = f.read() # create the NCAPI graph instance from the memory buffer containing the graph file. inputfifo, outputfifo = graph.allocate_with_fifos(device, graph_in_memory) cam = cv2.VideoCapture(0) if not cam.isOpened(): print('error: camera not opened') #below property not supported by this opencv implementation. # cam.set(cv2.CAP_PROP_BUFFERSIZE , 1) # images for testing for filename in os.listdir('./images'): image = cv2.imread('images/' + filename) print(filename) # image = cv2.imread('images/img00000.jpg') output = run_inference(image, graph, inputfifo, outputfifo) #message will be in format described above msg = Float32MultiArray() msg.data = output print(output) pub.publish(msg) cv2.imshow('mobilenet', image) cv2.waitKey(0) # img_counter = 0 # while not rospy.is_shutdown(): # ret, image = cam.read() # print(img_counter) # img_counter += 1 # #run network # output = run_inference(image, graph, inputfifo, outputfifo) # #message will be in format described above # msg = Float32MultiArray() # msg.data = output # print(output) # pub.publish(msg) # cv2.imwrite('out_imgs/'+str(img_counter)+'.jpg', image) # # display the results # cv2.imshow('mobilenet', image) # cv2.waitKey(1) # Clean up the graph and the device graph.destroy() inputfifo.destroy() outputfifo.destroy() device.close() device.destroy()
def main(): """Main function for the program. Everything starts here. :return: None """ global resize_output, resize_output_width, resize_output_height, \ obj_detector_proc, resize_output, resize_output_width, resize_output_height, video_proc, \ last_num_persons, asyncImWriter if (not handle_args()): print_usage() return 1 # Set logging level to only log errors mvnc.global_set_option(mvnc.GlobalOption.RW_LOG_LEVEL, 3) devices = mvnc.enumerate_devices() if len(devices) < 1: print('No NCS device detected.') print('Insert device and try again!') return 1 # Pick the first stick to run the network # use the first NCS device that opens for the object detection. dev_count = 0 for one_device in devices: try: obj_detect_dev = mvnc.Device(one_device) obj_detect_dev.open() print("opened device " + str(dev_count)) break except: print("Could not open device " + str(dev_count) + ", trying next device") pass dev_count += 1 cv2.namedWindow(cv_window_name) cv2.moveWindow(cv_window_name, 10, 10) cv2.waitKey(1) obj_detector_proc = SsdMobileNetProcessor( NETWORK_GRAPH_FILENAME, obj_detect_dev, inital_box_prob_thresh=min_score_percent / 100.0, classification_mask=object_classifications_mask) exit_app = False while (True): # video processor that will put video frames images on the object detector's input FIFO queue video_proc = CameraProcessor(CAMERA_INDEX, 1920, 1080, network_processor=obj_detector_proc) video_proc.start_processing() frame_count = 0 start_time = time.time() end_time = start_time while (True): try: (filtered_objs, display_image ) = obj_detector_proc.get_async_inference_result() except: print("exception caught in main") raise # 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() video_proc.stop_processing() exit_app = True break agg_results = overlay_on_image(display_image, filtered_objs) num_persons = len(agg_results) if (show_output): 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) raw_key = cv2.waitKey(1) if (raw_key != -1): if (handle_keys(raw_key, obj_detector_proc) == False): end_time = time.time() exit_app = True video_proc.stop_processing() break frame_count += 1 # if (obj_detector_proc.is_input_queue_empty()): # end_time = time.time() # print('Neural Network Processor has nothing to process, assuming video is finished.') # break frames_per_second = frame_count / (end_time - start_time) print('Frames per Second: ' + str(frames_per_second)) throttling = obj_detect_dev.get_option( mvnc.DeviceOption.RO_THERMAL_THROTTLING_LEVEL) if (throttling > 0): print("\nDevice is throttling, level is: " + str(throttling)) print("Sleeping for a few seconds....") cv2.waitKey(2000) #video_proc.stop_processing() cv2.waitKey(1) if (exit_app): video_proc.cleanup() break # Clean up the graph and the device obj_detector_proc.cleanup() obj_detect_dev.close() obj_detect_dev.destroy() cv2.destroyAllWindows()
def main(): url_cam = 'rr+tcp://192.168.43.141:2355?service=Webcam' url_drive = 'rr+tcp://192.168.43.141:2356?service=Drive' # Connect to camera and start streaming on global current_frame variable # p,cam = connect_camera(url_cam) cam = connect_camera2(url_cam) # Connect to motors to drive car = connect_drive(url_drive) ## Check Mividius Device devices = mvnc.EnumerateDevices() if len(devices) == 0: print('No devices found') quit() device = mvnc.Device(devices[0]) device.OpenDevice() # Load Deep Neural Network graph with open('./graph', mode='rb') as f: graphfile = f.read() # Send graph to the device graph = device.AllocateGraph(graphfile) # Image parameters image_size = np.array([120, 160]) top_cutoff = 40 is_view = False if is_view: cv2.namedWindow("Image") # Debug try: prev_time = time.time() iteration_times = [] predict_times = [] prep_times = [] while True: #Just loop resetting the frame #This is not ideal but good enough for demonstration. current_frame = WebcamImageToMat(cam.CaptureFrame()) if not current_frame is None: # Use image from now on to prevent unknown updates on current frame. frame = current_frame # print("Get-image: "+str(time.time() - prev_time)) # Resize image hei_original, wid_original = frame.shape[0:2] if image_size[0] != hei_original or image_size[ 1] != wid_original: frame = cv2.resize(frame, (image_size[1], image_size[0]), interpolation=cv2.INTER_NEAREST) # Crop image frame = frame[top_cutoff:, :, :] # print("Preprocess0: "+str(time.time() - prev_time)) # Convert color due to openCV defaults BGR to RGB img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # print("Preprocess1: "+str(time.time() - prev_time)) # Convert image to float16 and normalize so that device can process img = img.astype(np.float16) / 255.0 #print("Preprocess: "+str(time.time() - prev_time)) prep_times.append(time.time() - prev_time) # Send image to the device, and Calculate d and phi graph.LoadTensor(img, 'user object') output, userobj = graph.GetResult() output = output.astype(np.float32) # Extract d and phi d = output[0] phi = output[1] print('Output(d,phi): ' + str(output)) # If d or phi could not be find, stop the car. if d is None or phi is None: # car.setWheelsSpeed(0,0) prev_time = time.time() continue # Calculate w(omega) and v from d and phi v, w = lane_controller(d, phi) #print(v,w) # Calculate inverse kinematics to find each wheel speed vel_right, vel_left = inverse_kinematics(v, w) # print("vel_left: " + str(vel_left) + ", vel_right: " + str(vel_right)) # print("Predict: "+str(time.time() - prev_time)) predict_times.append(time.time() - prev_time) # Drive the car car.setWheelsSpeed(vel_left, vel_right) # car.setWheelsSpeed(0,0) # Calculate passed time rate duration_rate = (time.time() - prev_time) iteration_times.append(duration_rate) prev_time = time.time() # Print the fps print("Rate: " + str(1.0 / duration_rate)) # View for Debug if is_view: frame = cv2.resize(frame, (640, 320)) cv2.imshow("Image-with-lines", frame) if cv2.waitKey(1) != -1: break except KeyboardInterrupt: print('Interrupted!') # Convert fps values to numpy array iteration_times = np.array(iteration_times) avr_times = np.mean(iteration_times) prep_times = np.array(prep_times) avr_prep_times = np.mean(prep_times) predict_times = np.array(predict_times) avr_predict_times = np.mean(predict_times) # Print average fps print("Avr. (get image + preprocess) time: " + str(avr_prep_times * 1000) + ' ms') print("Avr. (prediction + motor speed control) time: " + str((avr_predict_times - avr_prep_times) * 1000) + ' ms') print("Avr. (set wheels speed) time: " + str((avr_times - avr_predict_times) * 1000) + ' ms') print("Avr. loop rate: " + str(1.0 / avr_times) + ' FPS') print('Shutting Down..') car.setWheelsSpeed(0, 0) # disconnect_camera(p,cam) # Clear and Disconnect Movidius device graph.DeallocateGraph() device.CloseDevice() print('Finished')
camera.vflip = True camera.hflip = True camera.resolution = (720, 720) camera.shutter_speed = 5000 camera.iso = 800 time.sleep(2) print('Initialized...') talk('init.wav') ncs_names = ncs.EnumerateDevices() if (len(ncs_names) < 1): print("Error - no NCS devices detected.") sys.exit(1) dev = ncs.Device(ncs_names[0]) dev.OpenDevice() with open('inception_v3.graph', 'rb') as f: graph = dev.AllocateGraph(f.read()) while True: start = time.time() print("start_time:", start) with tempfile.TemporaryDirectory() as temp_path: filepath = os.path.join(temp_path, 'image.jpg') snapshot(camera, filepath) elapsed_time_snapshot = time.time() - start
def main111(): # name of the opencv window cv_window_name = "SSD MobileNet - hit key 'q' to exit" # Get a list of ALL the sticks that are plugged in # we need at least one 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() # The graph file that was created with the ncsdk compiler # graph_file_name = 'new_graph' # read in the graph file to memory buffer with open(graph_file_name, mode='rb') as f: graph_in_memory = f.read() # create the NCAPI graph instance from the memory buffer containing the graph file. graph = device.AllocateGraph(graph_in_memory) # read the image to run an inference on from the disk ##################################################### # Create a VideoCapture object and read from input file # If the input is the camera, pass 0 instead of the video file name #cap = cv2.VideoCapture('/data/darknet/video/192.168.10.66_01_20160923193103251.mp4') cap = cv2.VideoCapture(video_file) # Check if camera opened successfully if (cap.isOpened() == False): print("Error opening video stream or file") # Read until video is completed while (cap.isOpened()): loop_start = time.time() # Capture frame-by-frame ret, frame = cap.read() if ret == True: # Display the resulting frame # cv2.imshow('Frame',frame) # run a single inference on the image and overwrite the # boxes and labels time_start = time.time() run_inference(frame, graph) fps = 1 / (time.time() - time_start) print("FPS=" + str(fps)) #cv2.HoughLinesP #cv2.namedWindow("SSD-Mobilenet",0); #cv2.resizeWindow("SSD-Mobilenet", 640, 480); #cv2.imshow(cv_window_name, frame) # display the results and wait for user to hit a key #cv2.waitKey(0) # Press Q on keyboard to exit if cv2.waitKey(25) & 0xFF == ord('q'): break loop_time = time.time() - loop_start print("loop_fps=" + str(1 / loop_time)) # When everything done, release the video capture object cap.release() # Closes all the frames cv2.destroyAllWindows() ##################################################### # Clean up the graph and the device graph.DeallocateGraph() device.CloseDevice()
def main(): skip_classifier = True frame_interval = 1 # Number of frames after which to run face detection fps_display_interval = 10 # seconds frame_rate = 0 frame_count = 0 start_time = time.time() parser = get_parser() args = parser.parse_args() use_classifier = bool(args.classifier) devices = mvnc.enumerate_devices() if len(devices) == 0: print('No devices found') quit() device = mvnc.Device(devices[0]) device.open() print('Load PNET') pnets = [] for r in parse_resolutions(args.resolutions): p = PNetHandler(device, r[0], r[1]) pnets.append(p) print('Load RNET') with open('movidius/rnet.graph', mode='rb') as f: rgraphFileBuff = f.read() rnetGraph = mvnc.Graph("RNet Graph") rnetIn, rnetOut = rnetGraph.allocate_with_fifos(device, rgraphFileBuff) print('Load ONET') with open('movidius/onet.graph', mode='rb') as f: ographFileBuff = f.read() onetGraph = mvnc.Graph("ONet Graph") onetIn, onetOut = onetGraph.allocate_with_fifos(device, ographFileBuff) if use_classifier: print('Load FACENET') with open(args.graph, mode='rb') as f: fgraphFileBuff = f.read() fGraph = mvnc.Graph("Face Graph") fifoIn, fifoOut = fGraph.allocate_with_fifos(device, fgraphFileBuff) # Load classifier with open(args.classifier, 'rb') as f: opts = {'file': f} if six.PY3: opts['encoding'] = 'latin1' (model, class_names) = pickle.load(**opts) threshold = [0.6, 0.6, 0.7] # three steps's threshold bounding_boxes = [] labels = [] with tf.Session() as sess: pnets_proxy = [] for p in pnets: pnets_proxy.append(p.proxy()) def _rnet_proxy(img): rnetGraph.queue_inference_with_fifo_elem(rnetIn, rnetOut, img, 'rnet') output, userobj = rnetOut.read_elem() return output def _onet_proxy(img): onetGraph.queue_inference_with_fifo_elem(onetIn, onetOut, img, 'onet') output, userobj = onetOut.read_elem() return output pnets_proxy, rnet, onet = detect_face.create_movidius_mtcnn( sess, 'align', pnets_proxy, _rnet_proxy, _onet_proxy) frame_src = cv2.imread(args.image).astype(np.float32) if (frame_src.shape[1] != 640) or (frame_src.shape[0] != 480): frame_src = cv2.resize(frame_src, (640, 480), interpolation=cv2.INTER_AREA) try: while True: frame = frame_src.copy() # BGR -> RGB rgb_frame = frame[:, :, ::-1] # print("Frame {}".format(frame.shape)) if (frame_count % frame_interval) == 0: bounding_boxes, _ = detect_face.movidius_detect_face( rgb_frame, pnets_proxy, rnet, onet, threshold) detected = len(bounding_boxes) > 0 # Check our current fps end_time = time.time() if (end_time - start_time) > fps_display_interval: frame_rate = float(frame_count) / (end_time - start_time) start_time = time.time() frame_count = 0 if detected: print('Full FPS: {}'.format(frame_rate)) else: print('Pure FPS: {}'.format(frame_rate)) if use_classifier: imgs = get_images(rgb_frame, bounding_boxes) labels = [] for img_idx, img in enumerate(imgs): img = img.astype(np.float32) fGraph.queue_inference_with_fifo_elem( fifoIn, fifoOut, img, 'user object') output, userobj = fifoOut.read_elem() if not skip_classifier: try: output = output.reshape(1, model.shape_fit_[1]) predictions = model.predict_proba(output) except ValueError as e: # Can not reshape print( "ERROR: Output from graph doesn't consistent" " with classifier model: %s" % e) continue best_class_indices = np.argmax(predictions, axis=1) best_class_probabilities = predictions[ np.arange(len(best_class_indices)), best_class_indices] for i in range(len(best_class_indices)): bb = bounding_boxes[img_idx].astype(int) text = '%.1f%% %s' % ( best_class_probabilities[i] * 100, class_names[best_class_indices[i]]) labels.append({ 'label': text, 'left': bb[0], 'top': bb[1] - 5 }) add_overlays(frame, bounding_boxes, int(frame_rate), labels=labels) frame_count += 1 if args.image_out is not None: cv2.imwrite(args.image_out, frame) if cv2.waitKey(1) & 0xFF == ord('q'): break except (KeyboardInterrupt, SystemExit) as e: print('Caught %s: %s' % (e.__class__.__name__, e)) if use_classifier: fifoIn.destroy() fifoOut.destroy() fGraph.destroy() rnetIn.destroy() rnetOut.destroy() rnetGraph.destroy() onetIn.destroy() onetOut.destroy() onetGraph.destroy() for p in pnets: p.destroy() device.close() print('Finished')
pnet_graph_filename = './p2838.graph' onet_graph_filename = './o.graph' with open(pnet_graph_filename, mode='rb') as rf: pgraphfile = rf.read() with open(onet_graph_filename, mode='rb') as rf: ographfile = rf.read() #mvnc.SetGlobalOption(mvnc.GlobalOption.LOGLEVEL, 2) devices = mvnc.EnumerateDevices() if len(devices) < 2: print('No enough devices found') quit() device = mvnc.Device(devices[0]) device.OpenDevice() device1 = mvnc.Device(devices[1]) device1.OpenDevice() pgraph = device.AllocateGraph(pgraphfile) ograph = device1.AllocateGraph(ographfile) def imresample(img, sz): # @UndefinedVariable im_data = cv2.resize(img, (sz[1], sz[0]), interpolation=cv2.INTER_AREA) return im_data def detect_face(img, threshold=[0.405, 0.8473], factor=0.709):
box = Gtk.Box() box.set_spacing(5) box.set_orientation(Gtk.Orientation.VERTICAL) window.add(box) box.pack_start(viewsink, True, True, 0) output = OutputWidget() box.pack_start(output, False, True, 0) # Initialize Ncs device if verbose: print("Opening device") dev = fx.Device(args.dest) try: dev.OpenDevice() except Exception as e: print("Failed to open NCS. Is the device plugged in?") sys.exit(1) if verbose: print("Loading graph") graph = dev.AllocateGraph(network.get_graph_binary()) # Open UI after device initialization if verbose: print("Opening UI")
def main(): global time1 global time2 global time3 global time4 # name of the opencv window cv_window_name = "SSD MobileNet - hit any key to exit" # Get a list of ALL the sticks that are plugged in # we need at least one 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() # The graph file that was created with the ncsdk compiler graph_file_name = cwd + '/../../models/caffe/MobileNetSSD_deploy.graph' # read in the graph file to memory buffer with open(graph_file_name, mode='rb') as f: graph_in_memory = f.read() # create the NCAPI graph instance from the memory buffer containing the graph file. graph = device.AllocateGraph(graph_in_memory) # read the image to run an inference on from the disk avg1 = 0 avg2 = 0 avg3 = 0 for img in img_array: time1 = time.time() infer_image = cv2.imread(img) # run a single inference on the image and overwrite the # boxes and labels time2 = time.time() run_inference(infer_image, graph) # display the results and wait for user to hit a key # cv2.imshow(cv_window_name, infer_image) # cv2.waitKey(0) # cv2.imwrite("nanga.jpg",infer_image) # print("Image read: "+str(time2-time1)+"\nInference: "+str(time3-time2)+"\nVisualization: "+str(time4-time3)) avg1 += time2 - time1 avg2 += time3 - time2 avg3 += time4 - time3 avg1 /= len(img_array) avg2 /= len(img_array) avg3 /= len(img_array) print("Image read: " + str(avg1) + "\nInference: " + str(avg2) + "\nVisualization: " + str(avg3)) # Clean up the graph and the device graph.DeallocateGraph() device.CloseDevice()