def _main(args, model): logger = logging.getLogger(__name__) if args.video_file is not None: gen = get_frames(args.video_file) else: gen = get_infos(args.info) frame_poses = [] for frame_num, im in gen: logger.info('Processing frame num: {}'.format(frame_num)) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if cls_keyps is not None: poses = [ convert_pose_data(pose) for box, pose in zip(cls_boxes[1], cls_keyps[1]) if box[-1] > BOX_THRESH ] else: poses = [] frame_poses.append(poses) if args.video_file is not None: write_frame_poses(args, frame_poses) else: calc_error(args, frame_poses)
def post(self): if 'image' not in self.request.files: raise tornado.web.HTTPError(400, "missing field 'image'") image = self.request.files['image'][0] if not image['content_type'].startswith('image/'): raise tornado.web.HTTPError( 400, "wrong content-type '{}'. Expecting 'image/*'".format( image['content_type'])) nparr = np.fromstring(image['body'], np.uint8) im = cv2.imdecode(nparr, cv2.IMREAD_COLOR) timers = defaultdict(Timer) try: with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( self.application.model, im, None, timers=timers) except Exception as e: print(e) raise tornado.web.HTTPError(500) output = vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization 'output', '/tmp/', cls_boxes, cls_segms, cls_keyps, dataset=self.application.dummy_coco_dataset, show_class=True, thresh=0.7, kp_thresh=2, ext='png') with open('/tmp/output.png', 'rb') as fd: self.write(fd.read()) self.finish()
def main(): args = parser.parse_args() logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg() dummy_coco_dataset = dummy_datasets.get_coco_dataset() ''' if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] ''' #for i, im_name in enumerate(im_list): #out_name = os.path.join( # args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf') #) #logger.info('Processing {} -> {}'.format(im_name, out_name)) #im = cv2.imread(im_name) hintDataURL = bottle.request.forms.get("hint") hintDataURL = re.sub('^data:image/.+;base64,', '', hintDataURL) hintDataURL = base64.urlsafe_b64decode(hintDataURL.encode("ascii")) hintDataURL = np.fromstring(hintDataURL, dtype=np.uint8) hintDataURL = cv2.imdecode(hintDataURL, -1) hstr = str(np.random.randint(100, 999)) cv2.imwrite('record/' + hstr + '.hint.png', hintDataURL) im = cv2.imread('record/' + hstr + '.hint.png') timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) return 'ok'
def main(args): merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() cap = cv2.VideoCapture(0) while True: ret, frame = cap.read() timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, frame, None, timers=timers) image = vis_utils.vis_one_image_opencv(np.array(frame), cls_boxes, cls_segms, cls_keyps, thresh=0.7, kp_thresh=2, show_box=True, show_class=True) cv2.imshow('camera', image) if cv2.waitKey(1) & 0xFF == ord('q'): break print("Time:", time.time() - t) cap.release() cv2.destroyAllWindows()
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg() dummy_dataset = dummy_datasets.get_cifar100_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): logger.info('Processing {}'.format(im_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_scores, _, _ = infer_engine.im_detect_all(model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) cl = np.argmax(cls_scores) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) logger.info(' | Class is: {}'.format(dummy_dataset.classes[cl])) logger.info(' | Class Confidance is: {:.2f}%'.format( cls_scores[cl] * 100)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)')
def main(args): merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 # get the weight path args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) #dummy_coco_dataset = dummy_datasets.get_coco_dataset() det_dir = os.path.join(args.input_dir, 'det') if not os.path.exists(det_dir): os.makedirs(det_dir) txt_file = os.path.join(det_dir, "det.txt") fid = open(txt_file, 'w') img_dir = os.path.join(args.input_dir, "img1") img_list = os.listdir(img_dir) img_list = sorted(img_list) for i in range(len(img_list)): print("processing: %d/%d" % (i + 1, len(img_list))) img_name = img_list[i][:-4] img_idx = int(img_name) img_path = os.path.join(img_dir, img_list[i]) frame = cv2.imread(img_path) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, frame, None, None) vis_utils.write_txt(fid, img_idx, cls_boxes) fid.close()
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg() #jasonj #dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf')) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): #jasonj cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, "infer_res.jpg", None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)')
def pipeline_mask(im): if im is None: print("im is null!") timers = defaultdict(Timer) #t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) #logger.info('Inference time: {:.3f}s'.format(time.time() - t)) #for k, v in timers.items(): # logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) #print('===========================boxs_list:') boxs_list = vis_utils.get_boxes_image(cls_boxes, cls_segms, cls_keyps, thresh=0.7, dataset=dummy_coco_dataset) #print(boxs_list) #for i in range(len(boxs_list)): # box = boxs_list[i] #drawBoxOnImg(im,box[1],box[2],box[3],box[4],0,0,frame) #frame+=1 return boxs_list
def run_model_cfg(args, im, check_blobs): workspace.ResetWorkspace() model, _ = load_model(args) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = test_engine.im_detect_all( model, im, None, None, ) boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format( cls_boxes, cls_segms, cls_keyps) # sort the results based on score for comparision boxes, segms, keypoints, classes = _sort_results( boxes, segms, keypoints, classes) # write final results back to workspace def _ornone(res): return np.array(res) if res is not None else np.array([], dtype=np.float32) with c2_utils.NamedCudaScope(0): workspace.FeedBlob(core.ScopedName('result_boxes'), _ornone(boxes)) workspace.FeedBlob(core.ScopedName('result_segms'), _ornone(segms)) workspace.FeedBlob(core.ScopedName('result_keypoints'), _ornone(keypoints)) workspace.FeedBlob(core.ScopedName('result_classids'), _ornone(classes)) # get result blobs with c2_utils.NamedCudaScope(0): ret = _get_result_blobs(check_blobs) return ret
def extract_segments(self, im_path, im): """ Use Detectron to extract all the segments in the image, their corresponding classes, and their binary masks""" timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( self.model, im, None, timers=timers) self.logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): self.logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) # TODO #srishti error/bug here if no relevant segments found l:125 segmented_images, classes, scores, segmented_binary_masks = vis_utils.segmented_images_in_original_image_size( im, im_path, self.conf['io']['output_dir'], cls_boxes, cls_segms, cls_keyps, dataset=self.dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) return segmented_images, classes, scores, segmented_binary_masks
def detect(self, im, id): timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(id): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( self.model, im, None, timers=timers) self.logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): self.logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) imsw = vis_utils.vis_one_image_opencv(im, cls_boxes, cls_segms, cls_keyps, self.confidence, 2, show_box=True, dataset=self.dummy_coco_dataset, show_class=True) boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format( cls_boxes, cls_segms, cls_keyps) bboxes = BBoxDetArray() bboxes.header = std_msgs.msg.Header() if boxes is not None: for i in range(len(boxes)): box = boxes[i][0:4] score = boxes[i][4] cls = self.dummy_coco_dataset.classes[classes[i]] if (score >= self.confidence): bbox = BBox(box[0], box[1], box[2], box[3]) bbox_det = BBoxDet(bbox, score, cls) bboxes.bboxes.append(bbox_det) return imsw, bboxes
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg() dummy_coco_dataset = dummy_datasets.get_coco_dataset() video_frame_length = video_frame(args) #Yunhan Yang pass in a list to save all the frames print ("The video has length " + str(video_frame_length) + " frames") f_image_path = args.im_or_folder+ "frame%d.jpg" % 0 fr = cv2.imread(f_image_path, 0) origin_width, origin_height = fr.shape[:2] for x in range(0,video_frame_length): im_list = [args.im_or_folder+"frame" + str(x) + ".jpg"] #Yunhan Yang have to save frame in real folder and then read in #maybe need need double for loop for list of frames for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf') ) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)' ) #Yunhan Yang edit if not os.path.exists(args.im_or_folder+ "/video"): os.makedirs(args.im_or_folder+ "/video") #Yunhan Yang edit Detectron/lib/utils/vis.py add make result as jpg than pdf vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2 )
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg() dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf')) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') t1 = time.time() im = vis_utils.vis_one_image_opencv(im, cls_boxes, segms=cls_segms, keypoints=cls_keyps, thresh=0.7, kp_thresh=2, show_box=True, dataset=dummy_coco_dataset, show_class=True) # vis_utils.vis_one_image( # im[:, :, ::-1], # BGR -> RGB for visualization # im_name, # args.output_dir, # cls_boxes, # cls_segms, # cls_keyps, # dataset=dummy_coco_dataset, # box_alpha=0.3, # show_class=True, # thresh=0.7, # kp_thresh=2 # ) t2 = time.time() - t1 print("vis time %f ms" % (t2 * 1000)) cv2.imwrite( args.output_dir + '/' + im_name.split('/')[-1].split('.')[0] + '.jpg', im)
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 cfg.TRAIN.IMS_PER_BATCH = 1 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg() dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf')) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, \ cls_refined_segms, cls_refined_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, os.path.join(args.output_dir, 'vis_local'), cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, os.path.join(args.output_dir, 'vis_refined'), cls_boxes, cls_refined_segms, cls_refined_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2)
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg() dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] # for i, im_name in enumerate(im_list): # out_name = os.path.join( # args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf') # ) # logger.info('Processing {} -> {}'.format(im_name, out_name)) #set webcam cam = cv2.VideoCapture(0) while True: #Fetch image from camera ret_val, im = cam.read() #uncomment to resize image #im = cv2.resize(im, (1200,1024)) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)' ) vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization "dummy_name", args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2 ) cv2.destroyAllWindows()
def predict(self,im): #class_str_list = [] data_list = [] with c2_utils.NamedCudaScope(self.gpu_id): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(self.model, im, None, None ) #get box classes if isinstance(cls_boxes, list): boxes, segms, keypoints, classes = self.convert_from_cls_format(cls_boxes, cls_segms, cls_keyps) if boxes is None or boxes.shape[0] == 0 or max(boxes[:, 4]) < self.score_thresh: return data_list #get score areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1]) sorted_inds = np.argsort(-areas) #nms between classes #im2 = cv2.cvtColor(im,cv2.COLOR_RGB2BGR) #result2= im2.copy() if (len(sorted_inds) > 0): nmsIndex = self.nms_between_classes(boxes, self.class_nms_thresh) #阈值为0.9,阈值越大,过滤的越少 for i in xrange(len(nmsIndex)): bbox = boxes[nmsIndex[i], :4] score = boxes[nmsIndex[i], -1] if score < self.score_thresh: continue #get class-str class_str = self.get_class_string(classes[nmsIndex[i]], score, self.dummy_coco_dataset) #score thresd per class if self.per_class_thresh: if 'autotruck' == class_str and score < self.autotruck_score_thresh: continue if 'forklift' == class_str and score < self.forklift_score_thresh: continue if 'digger' == class_str and score < self.digger_score_thresh: continue if 'car' == class_str and score < self.car_score_thresh: continue if 'bus' == class_str and score < self.bus_score_thresh: continue if 'tanker' == class_str and score < self.tanker_score_thresh: continue if 'person' == class_str and score < self.person_score_thresh: continue if 'minitruck' == class_str and score < self.minitruck_score_thresh: continue if 'minibus' == class_str and score < self.minibus_score_thresh: continue single_data = {"cls":class_str,"score":float('%.2f' % score),"bbox":{"xmin":int(bbox[0]),"ymin":int(bbox[1]),"xmax":int(bbox[2]),"ymax":int(bbox[3])}} data_list.append(single_data) #construcrion - data_list return data_list
def __call__(self, img): timers = defaultdict(Timer) im = cv2.resize(img, (540, 400)) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( MODEL, im, None, timers=timers) # print cls_boxes, cls_segms, cls_keyps return cls_boxes, cls_segms, cls_keyps
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 logger.info('about to assert') assert_and_infer_cfg() logger.info('About to initialise model') model = infer_engine.initialize_model_from_cfg() logger.info("Done initialising") dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.png')) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') segmented_images, classes, scores, segmented_binary_masks = vis_utils.segmented_images_in_original_image_size( im, im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) found = False for index, value in enumerate(segmented_images): if classes[index] == args.class_label and not found: logger.info('Writing output file to: {}'.format(str(i))) bin_mask = vis_utils.vis_binary_mask( im, segmented_binary_masks[index]) cv2.imwrite(out_name, value) cv2.imwrite(out_name.rstrip(".png") + "bin.png", bin_mask) found = True
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg() dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] """ Add support for webcam """ # Set and get camera from OpenCV cam = cv2.VideoCapture(0) im_name = 'tmp_im' while True: # Fetch image from camera _, im = cam.read() timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2, ext='jpg' # default is PDF, but we want JPG. ) cv2.destroyAllWindows()
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): # im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) im_list = search(args.im_or_folder, args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): #for i, im_name in im_list: #out_name = os.path.join( # args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf') #) out_name = im_name.replace(args.im_or_folder, args.output_dir) par_path = os.path.dirname(out_name) if not os.path.exists(par_path): os.makedirs(par_path) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)' ) vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, par_path, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2, ext='png' )
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = ( dummy_datasets.get_vg3k_dataset() if args.use_vg3k else dummy_datasets.get_coco_dataset()) if os.path.isdir(args.im_or_folder): im_list = sorted(glob.iglob(args.im_or_folder + '/*.' + args.image_ext)) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.npz') ) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) if im is None: logger.info('Unable to read image, skipping.') continue timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)' ) boxes, segms, classes = convert(cls_boxes, cls_segms) classes = np.array(classes, dtype=np.uint16) resolution = segms[0]['size'] segms = np.array([x['counts'] for x in segms]) # Run-length encoding valid = boxes[:, 4] >= args.thresh if args.filter_classes: valid &= np.isin(classes, all_classes) boxes = boxes[valid].copy() classes = classes[valid].copy() segms = segms[valid].copy() output_name = os.path.basename(im_name) np.savez(args.output_dir + '/' + output_name, boxes=boxes, segments=segms, classes=classes, resolution=resolution)
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg() dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] test_ids = [] rles = [] for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf')) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') new_test_ids, new_rles = vis_utils.make_submission(im[:, :, ::-1], im_name, cls_boxes, cls_segms, cls_keyps, thresh=0.7) test_ids.extend(new_test_ids) rles.extend(new_rles) import pandas as pd sub = pd.DataFrame() sub['ImageId'] = test_ids sub['EncodedPixels'] = pd.Series(rles).apply( lambda x: ' '.join(str(y) for y in x)) sub.to_csv(args.output_dir + '/e2e_mask_rcnn_R-50-FPN_1x-lr3e-3-nuclei-6-new.csv', index=False)
def main(args): logger = logging.getLogger(__name__) dummy_coco_dataset = dummy_datasets.get_coco_dataset() cfg_orig = yaml.load(yaml.dump(cfg)) im = cv2.imread(args.im_file) if args.rpn_pkl is not None: proposal_boxes, _proposal_scores = get_rpn_box_proposals(im, args) workspace.ResetWorkspace() else: proposal_boxes = None cls_boxes, cls_segms, cls_keyps = None, None, None for i in range(0, len(args.models_to_run), 2): pkl = args.models_to_run[i] yml = args.models_to_run[i + 1] cfg.immutable(False) merge_cfg_from_cfg(cfg_orig) merge_cfg_from_file(yml) if len(pkl) > 0: weights_file = pkl else: weights_file = cfg.TEST.WEIGHTS cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = model_engine.initialize_model_from_cfg(weights_file) with c2_utils.NamedCudaScope(0): cls_boxes_, cls_segms_, cls_keyps_ = \ model_engine.im_detect_all(model, im, proposal_boxes) cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps workspace.ResetWorkspace() out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(args.im_file) + '.pdf') ) logger.info('Processing {} -> {}'.format(args.im_file, out_name)) vis_utils.vis_one_image( im[:, :, ::-1], args.im_file, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2 )
def main(args): logger = logging.getLogger(__name__) args.cfg = '/detectron/configs/12_2017_baselines/e2e_mask_rcnn_R-101-FPN_2x.yaml' args.weights = '/data/workspace/fbdet/models/mask_rcnn_R_101_FPN_2x/model_final.pkl' merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] im_list = [] im_list.append('/data/workspace/fbdet/test_pic/11.jpg') video = cv2.VideoCapture('/data/pic/valid_video_00.avi') frame = 0 while (True): if frame > 0: break # ret, im = video.read() # if im is None or ret is None: # print("video.read() fail || video.read() is end!") # break im = cv2.imread(im_list[0]) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) print('-----------------------------', frame) boxs_list = vis_utils.get_boxes_image(cls_boxes, cls_segms, cls_keyps, thresh=0.7, dataset=dummy_coco_dataset) print(boxs_list) print('-----------------------------') for i in range(len(boxs_list)): box = boxs_list[i] drawBoxOnImg(im, box[1], box[2], box[3], box[4], 0, 0, frame) frame += 1
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() for root_dir_path_1, sub_dir_path_list_1, sub_file_path_list_1 in os.walk( args.im_or_folder): sub_dir_path_list_1 = sorted(sub_dir_path_list_1) for i, sub_dir_path_1 in enumerate(sub_dir_path_list_1): for root_dir_path_2, sub_dir_path_list_2, sub_file_path_list_2 in os.walk( os.path.join(root_dir_path_1, sub_dir_path_1)): sub_file_path_list_2 = sorted(sub_file_path_list_2) out_file = open( os.path.join(args.output_dir, sub_dir_path_1 + "_Det_ffasta.txt"), "wb") for img_idx, sub_file_path_2 in enumerate( sub_file_path_list_2): im = cv2.imread( os.path.join(root_dir_path_2, sub_file_path_2)) timers = defaultdict(Timer) t = time.time() if (img_idx + 1) % 1000 == 0: sys.stdout.write( "\rFinish {} images\n".format(img_idx + 1)) sys.stdout.flush() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) if isinstance(cls_boxes, list): cls_boxes, cls_segms, cls_keyps, classes = vis_utils.convert_from_cls_format( cls_boxes, cls_segms, cls_keyps) if cls_boxes is None or cls_boxes.shape[0] == 0: continue obj_idx = 0 for cls_box, cls in zip(cls_boxes, classes): if int(cls) != 3 and int(cls) != 6: continue out_file.write("{},{},{},{},{},{},{}\n".format( img_idx + 1, obj_idx + 1, cls_box[0], cls_box[1], cls_box[2] - cls_box[0], cls_box[3] - cls_box[1], cls_box[4])) obj_idx += 1 out_file.close() print("Finish {} / {} of video sequences".format( i + 1, len(sub_dir_path_list_1))) break
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg() dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf') ) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)' ) vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2 )
def execute(self, frame: FrameType) -> Tuple[bytes, bytes, bytes]: logger = logging.getLogger(__name__) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( self.graph, frame, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) return ( pickle.dumps(cls_boxes), pickle.dumps(cls_segms), pickle.dumps(cls_keyps))
def main(): logger = logging.getLogger(__name__) merge_cfg_from_file('/detectron/e2e_mask_rcnn_R-101-FPN_2x.yaml') cfg.NUM_GPUS = 4 assert_and_infer_cfg() model = infer_engine.initialize_model_from_cfg('/detectron/models/model_final.pkl') dummy_coco_dataset = dummy_datasets.get_coco_dataset() # cam = cv2.VideoCapture("rtsp://192.168.128.12:554/mpeg4cif") # cam = cv2.VideoCapture("rtsp://192.168.128.11:554/av0_1") # cam = cv2.VideoCapture("http://192.168.128.14/video.cgi") n = 0 tmp_file_name = '/tmp/tmp.jpg' im0 = 0 im1 = 0 while True: # ret_val, im = cam.read() # cv2.imwrite(tmp_file_name, im) im = cv2.imread('/detectron/k2m30/img/' + str(n) + '.jpg') timers = defaultdict(Timer) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) data = vis_utils.vis_one_image_opencv( im, # BGR -> RGB for visualization cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, # box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2, # ext='png' ) # time.sleep(0.1) # if data == None: # logger.info(cls_boxes) # # else: n += 1 n = n % 1000 file_name = '/tmp/' + str(n) + '.jpg' cv2.imwrite(file_name, data) logger.info(str(n) + ' saved') logger.info(os.path.getsize(file_name))
def predict(cfg_path, weights_path): logger = logging.getLogger(__name__) merge_cfg_from_file(cfg_path) cfg.NUM_GPUS = 1 gpu_id = 0 #指定GPU weights_path = cache_url(weights_path, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(weights_path, gpu_id) dummy_coco_dataset = dummy_datasets.get_coco_dataset() #dummy_coco_dataset = dummy_datasets.get_illbuild_class11_dataset() print("model is ok") if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.jpg')) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(gpu_id): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2)
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = (dummy_datasets.get_vg3k_dataset() if args.use_vg3k else dummy_datasets.get_coco_dataset()) if args.im_or_folder == 'train0': #im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) im_list = cPickle.load(open('train_list.pkl')) pre_folder = '/mnt/storage/jialinwu/detectron/detectron/datasets/data/coco/coco_train2014' im_list = im_list[:40000] elif args.im_or_folder == 'train1': im_list = cPickle.load(open('train_list.pkl')) pre_folder = '/mnt/storage/jialinwu/detectron/detectron/datasets/data/coco/coco_train2014' im_list = im_list[40000:] elif args.im_or_folder == 'val': im_list = cPickle.load(open('val_list.pkl')) pre_folder = '/mnt/storage/jialinwu/detectron/detectron/datasets/data/coco/coco_val2014' elif args.im_or_folder == 'test0': im_list = cPickle.load(open('test_list.pkl')) im_list = im_list[:40000] pre_folder = '../ARNet/image_captioning/data/images/test2015' elif args.im_or_folder == 'test1': im_list = cPickle.load(open('test_list.pkl')) im_list = im_list[40000:] pre_folder = '../ARNet/image_captioning/data/images/test2015' for i in tqdm(range(len(im_list))): im_name = pre_folder + '/' + im_list[i] if im_name[-4:] != '.jpg': continue im = cv2.imread(im_name) timers = defaultdict(Timer) imgid = int(im_list[i][:-4].split('_')[-1]) if args.im_or_folder == 'val': save_name = '/mnt/storage/jialinwu/seg_every_thing/npz_features/coco_val2014/%d.npz' % imgid else: save_name = '/mnt/storage/jialinwu/seg_every_thing/npz_features/coco_train2014/%d.npz' % imgid with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, save_name, timers=timers) '''
def main(args): dummy_coco_dataset = dummy_datasets.get_coco_dataset() cfg_orig = yaml.load(yaml.dump(cfg)) im = cv2.imread(args.im_file) if args.rpn_pkl is not None: proposal_boxes, _proposal_scores = get_rpn_box_proposals(im, args) workspace.ResetWorkspace() else: proposal_boxes = None cls_boxes, cls_segms, cls_keyps = None, None, None for i in range(0, len(args.models_to_run), 2): pkl = args.models_to_run[i] yml = args.models_to_run[i + 1] merge_cfg_from_cfg(cfg_orig) merge_cfg_from_file(yml) if len(pkl) > 0: cfg.TEST.WEIGHTS = pkl cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = model_engine.initialize_model_from_cfg() with c2_utils.NamedCudaScope(0): cls_boxes_, cls_segms_, cls_keyps_ = \ model_engine.im_detect_all(model, im, proposal_boxes) cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps workspace.ResetWorkspace() vis_utils.vis_one_image( im[:, :, ::-1], args.im_file, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2 )
def main(args): dummy_coco_dataset = dummy_datasets.get_coco_dataset() cfg_orig = yaml.safe_load(yaml.dump(cfg)) im = cv2.imread(args.im_file) if args.rpn_pkl is not None: proposal_boxes, _proposal_scores = get_rpn_box_proposals(im, args) workspace.ResetWorkspace() else: proposal_boxes = None cls_boxes, cls_segms, cls_keyps = None, None, None for i in range(0, len(args.models_to_run), 2): pkl = args.models_to_run[i] yml = args.models_to_run[i + 1] merge_cfg_from_cfg(cfg_orig) merge_cfg_from_file(yml) if len(pkl) > 0: cfg.TEST.WEIGHTS = pkl cfg.NUM_GPUS = 1 assert_and_infer_cfg() model = model_engine.initialize_model_from_cfg() with c2_utils.NamedCudaScope(0): cls_boxes_, cls_segms_, cls_keyps_ = \ model_engine.im_detect_all(model, im, proposal_boxes) cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps workspace.ResetWorkspace() vis_utils.vis_one_image(im[:, :, ::-1], args.im_file, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2)