def detect(pred, args, im_queue, rst_queue): while True: im_item = im_queue.get() if not im_item: print('detect finish...') rst_queue.put(None) break im, data_batch, data_names, im_scale = im_item t0 = time.clock() scores, boxes, data_dict = im_detect(pred, data_batch, data_names, im_scale) all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack( (cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[] ] + [all_boxes[j] for j in range(1, len(CLASSES))] print('detect:', time.clock() - t0) rst_queue.put([data_dict['data'.asnumpy], boxes_this_image, im_scale]) print('Hello2')
def demo_net(predictor, image_name): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :return: None """ assert os.path.exists(image_name), image_name + ' not found' im = cv2.imread(image_name) data_batch, data_names, im_scale = generate_batch(im) scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets, NMS_THRESH) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))] vis_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale)
def demo_net(predictor, image_name, vis=False, save_dir='./', save_name='tmp.jpg', threshold=0.7): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ assert os.path.exists(image_name), image_name + ' not found' result_lst = list() try: im = cv2.imread(image_name) data_batch, data_names, im_scale = generate_batch(im) scores, boxes, data_dict = im_detect( predictor, data_batch, data_names, im_scale) all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= threshold)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))] except: print('detection error') return None # print results print('class ---- [[x1, x2, y1, y2, confidence]]') for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: print('---------', CLASSES[ind], '---------') print(boxes) for box in boxes: tmp_box = box.tolist()[:4] tmp_box.append(str(CLASSES[ind])) result_lst.append(tmp_box) if vis: vis_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) else: # result_dir = os.path.dirname(image_name) # result_file = save_dir + os.path.basename(image_name) result_file = save_dir + save_name print('results saved to %s' % result_file) im = draw_all_detection( data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) if not os.path.exists(os.path.dirname(result_file)): os.system('mkdir -p '+os.path.dirname(result_file)) cv2.imwrite(result_file, im) return result_lst
def demo_net(predictor, image_name, args): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ assert os.path.exists(image_name), image_name + ' not found' im = cv2.imread(image_name) data_batch, data_names, im_scale = generate_batch(im) #for i in range(10): # scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) t0 = time.clock() for i in range(1): scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) print(time.clock() - t0) all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))] # print results print('class ---- [[x1, x2, y1, y2, confidence]]') for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: print('---------', CLASSES[ind], '---------') print(boxes) if args.vis: vis_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) else: #print(os.path.join(args.out_dir, os.path.split(image_name.replace('.jpg', '_result.jpg'))[1])) result_file = os.path.join( args.out_dir, os.path.split(image_name.replace('.jpg', '_result.jpg'))[1]) print('results saved to %s' % result_file) im = draw_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) cv2.imwrite(result_file, im)
def demo_net(predictor, image_name, args): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ global detect_num global tp, fp, fn global gp, gr, gf1 #assert os.path.exists(image_name), image_name + ' not found' #im = cv2.imread(image_name) #im = cv2.flip(im, 1) data_batch, data_names, im_scale = generate_batch(image_name) #for i in range(10): # scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) t0 = time.clock() for i in range(1): scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) print(time.clock() - t0) all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))] #print(boxes_this_image) # print results rst = {} lfn, lfp, ltp = 0, 0, 0 print('class ---- [[x1, x2, y1, y2, confidence]]') for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: print('---------', CLASSES[ind], '---------') print(boxes) rst[CLASSES[ind]] = [box for box in boxes] #detect_num[CLASSES[ind]] += len(boxes) detect_num[CLASSES[ind]] += 1 #len(boxes) """if args.image == '' and args.with_label:
def demo_net(predictor, image_name, result_txt, vis=False): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ assert os.path.exists(image_name), image_name + ' not found' print image_name im = cv2.imread(image_name) data_batch, data_names, im_scale = generate_batch(im) scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) result_txt.write( image_name.split('/')[-2] + '/' + image_name.split('/')[-1] + '\n') all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))] # print results #logger.info('---class---') #logger.info('[[x1, x2, y1, y2, confidence]]') for ind, boxes in enumerate(boxes_this_image): #print ind if len(boxes) > 0: logger.info('---%s---' % CLASSES[ind]) logger.info('%s' % boxes) #print len(boxes) for iii in range(0, len(boxes)): result_txt.write( str(boxes[iii][0]) + ' ' + str(boxes[iii][1]) + ' ' + str(boxes[iii][2]) + ' ' + str(boxes[iii][3]) + ' ' + str(boxes[iii][4]) + ' ') result_txt.write('\n')
def demo_net(predictor, image_name, vis=False): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ assert os.path.exists(image_name), image_name + ' not found' im = cv2.imread(image_name) data_batch, data_names, im_scale = generate_batch(im) scores, boxes, head_boxes, joints, data_dict = im_detect( predictor, data_batch, data_names, im_scale) print 'im_scale = {}'.format(im_scale) all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep1 = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep1, :] keep2 = nms(dets) all_boxes[cls_ind] = dets[keep2, :] if cls == 'person': head_boxes = head_boxes[keep1[keep2], :] joints = joints[keep1[keep2], :] boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))] # print results print 'class ---- [[x1, x2, y1, y2, confidence]]' for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: print '---------', CLASSES[ind], '---------' print boxes if vis: vis_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale, head_boxes, joints) else: result_file = image_name.replace('.', '_result.') print 'results saved to %s' % result_file im = draw_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) cv2.imwrite(result_file, im)
def demo_net(predictor, image_name, vis=True): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ BOOL = 0 assert os.path.exists(image_name), image_name + ' not found' im = cv2.imread(image_name) data_batch, data_names, im_scale = generate_batch(im) scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) all_boxes = [[] for _ in Global.CLASSES] for cls in Global.CLASSES: cls_ind = Global.CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= Global.conf_thresh_value)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = py_nms_wrapper(Global.nms_thresh_value)(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[]] + [ all_boxes[j] for j in range(1, len(Global.CLASSES)) ] for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: BOOL = 1 logger.info('---%s---' % Global.CLASSES[ind]) logger.info('%s' % boxes) result_file = image_name.replace(str(Global.open_img_dir), str(Global.save_path)) print result_file logger.info('results saved to %s' % result_file) im, CLASS, SCORE = draw_all_detection(data_dict['data'].asnumpy(), boxes_this_image, Global.CLASSES, im_scale) cv2.imwrite(result_file, im) Global.PICTURE_INFO[0].append(result_file) Global.PICTURE_INFO[1].append(CLASS) Global.PICTURE_INFO[2].append(SCORE) return CLASS, SCORE, BOOL
def demo_net(predictor, image_name, vis=False): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ assert os.path.exists(image_name), image_name + ' not found' im = cv2.imread(image_name) data_batch, data_names, im_scale = generate_batch(im) scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] print(cls_scores.shape) keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))] # print results logger.info('---class---') logger.info('[[x1, x2, y1, y2, confidence]]') for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: logger.info('---%s---' % CLASSES[ind]) logger.info('%s' % boxes) if vis: vis_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) else: idx = [i for i, v in enumerate(image_name) if v == '/'][-1] result_file = "data/VOCdevkit/results/test/" + image_name[idx+1:] result_file = result_file.replace('.', '_result.') logger.info('results saved to %s' % result_file) im = draw_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) cv2.imwrite(result_file, im)
def predict(imagePath, predictor): if imagePath.startswith('http://') or imagePath.startswith( 'https://') or imagePath.startswith('ftp://'): req = urllib.urlopen(imagePath) arr = np.asarray(bytearray(req.read()), dtype=np.uint8) im = cv2.imdecode(arr, -1) else: if not os.path.exists(imagePath): raise Exception('Input image file does not exist') im = cv2.imread(imagePath) data_batch, data_names, im_scale = generate_batch(im) scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))] result = [] # print results for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: result.append({ "object_name": CLASSES[ind], "confidence": boxes[0][4], "bounding_box": { "x1": boxes[0][0], "x2": boxes[0][1], "y1": boxes[0][2], "y2": boxes[0][3] } }) result = jsonpickle.encode(result, unpicklable=False) return json.loads(result)
def net_inference(model, args): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :return: None """ predictor = model['predictor'] classes = model['classes'] threshold = model['threshold'] rets = [] try: for data in args: im, im_info, err = _load_image(data['data']) if err is not None: rets.append(err) continue data_batch, data_names, im_scale = generate_batch(im) scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) det_ret = [] for cls_ind, cls_name in enumerate(classes[1:], start=1): cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= threshold)[0] dets = np.hstack( (cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) det_ret.extend( _build_result(det, cls_name, cls_ind, im_info) for det in dets[keep, :]) rets.append( dict(code=0, message='', result=dict(detections=det_ret))) except Exception as _e: logger.info("inference error:%s", traceback.format_exc(), extra={"reqid": ""}) return [], 599, {"code": 599, "message": str(_e)} return rets, 0, None
def demo_net(predictor, image_name, cat, vis=False): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ assert os.path.exists(image_name), image_name + ' not found' im = cv2.imread(image_name) data_batch, data_names, im_scale = generate_batch(im) scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) CLASSES = ['__background__', cat] all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] if dets.shape[0] > 1: keep = [np.argmax(dets[:, 4])] all_boxes[cls_ind] = dets[keep, :] else: all_boxes[cls_ind] = dets boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))] # print results """ #logger.info('---class---') #logger.info('[[x1, x2, y1, y2, confidence]]') for ind, boxes in enumerate(boxes_this_image): #if len(boxes) > 0: # logger.info('---%s---' % CLASSES[ind]) logger.info('%s' % boxes) """ if vis: vis_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) return boxes_this_image[1][0]
def demo_net(predictor, image_name, vis=False): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ assert os.path.exists(image_name), image_name + ' not found' im = cv2.imread(image_name) data_batch, data_names, im_scale = generate_batch(im) scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))] # print results logger.info('---class---') logger.info('[[x1, x2, y1, y2, confidence]]') for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: logger.info('---%s---' % CLASSES[ind]) logger.info('%s' % boxes) if vis: vis_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) else: result_file = image_name.replace('.', '_result.') logger.info('results saved to %s' % result_file) im = draw_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) cv2.imwrite(result_file, im)
def detect(self, im, vis=False, verbose=False): """ generate data_batch -> im_detect -> post process :param vis: will save as a new image if not visualized :return: None """ data_batch, data_names, im_scale = self.generate_batch(im) scores, boxes, data_dict = im_detect(self.predictor, data_batch, data_names, im_scale) all_boxes = [[] for _ in CLASSES] for cls in CLASSES: #if cls == 'person': cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack( (cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[] ] + [all_boxes[j] for j in range(1, len(CLASSES))] detections = [] for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: for box in boxes: x1 = int(round(box[0])) y1 = int(round(box[1])) x2 = int(round(box[2])) y2 = int(round(box[3])) score = int(round(box[4])) new_det = Detection(x1, y1, x2 - x1, y2 - y1, score) detections.append(new_det) if verbose: format_str = ('%d,%d,%d,%d,%.3f') print(format_str % (x1, y1, x2 - x1, y2 - y1, score)) return detections
def demo_net(predictor, data, image_names, im_scales): data = [[mx.nd.array(data[i][name]) for name in DATA_NAMES] for i in xrange(len(data))] # warm up for i in xrange(2): data_batch = mx.io.DataBatch(data=[data[0]], label=[], pad=0, index=0, provide_data=[[(k, v.shape) for k, v in zip(DATA_NAMES, data[0])]], provide_label=[None]) scales = [data_batch.data[i][1].asnumpy()[0, 2] for i in xrange(len(data_batch.data))] _, _, _, _, _= im_detect(predictor, data_batch, DATA_NAMES, scales) # test for idx, im_name in enumerate(image_names): data_batch = mx.io.DataBatch(data=[data[idx]], label=[], pad=0, index=idx, provide_data=[[(k, v.shape) for k, v in zip(DATA_NAMES, data[idx])]], provide_label=[None]) scales = [data_batch.data[i][1].asnumpy()[0, 2] for i in xrange(len(data_batch.data))] tic() scores, boxes, boxes2, masks, data_dict = im_detect(predictor, data_batch, DATA_NAMES, scales) im_shapes = [data_batch.data[i][0].shape[2:4] for i in xrange(len(data_batch.data))] # mask output if not config.TEST.USE_MASK_MERGE: all_boxes = [[] for _ in xrange(config.NUM_CLASSES)] all_masks = [[] for _ in xrange(config.NUM_CLASSES)] nms = py_nms_wrapper(config.TEST.NMS) for j in range(1, config.NUM_CLASSES): indexes = np.where(scores[0][:, j] > 0.7)[0] cls_scores = scores[0][indexes, j, np.newaxis] cls_masks = masks[0][indexes, 1, :, :] try: if config.CLASS_AGNOSTIC: cls_boxes = boxes[0][indexes, :] else: raise Exception() except: cls_boxes = boxes[0][indexes, j * 4:(j + 1) * 4] cls_dets = np.hstack((cls_boxes, cls_scores)) keep = nms(cls_dets) all_boxes[j] = cls_dets[keep, :] all_masks[j] = cls_masks[keep, :] dets = [all_boxes[j] for j in range(1, config.NUM_CLASSES)] masks = [all_masks[j] for j in range(1, config.NUM_CLASSES)] else: masks = masks[0][:, 1:, :, :] im_height = np.round(im_shapes[0][0] / scales[0]).astype('int') im_width = np.round(im_shapes[0][1] / scales[0]).astype('int') print (im_height, im_width) boxes_ = clip_boxes(boxes[0], (im_height, im_width)) result_masks, result_dets = gpu_mask_voting(masks, boxes_, scores[0], config.NUM_CLASSES, 100, im_width, im_height, config.TEST.NMS, config.TEST.MASK_MERGE_THRESH, config.BINARY_THRESH, 0) dets = [result_dets[j] for j in range(1, config.NUM_CLASSES)] masks = [result_masks[j][:, 0, :, :] for j in range(1, config.NUM_CLASSES)] print 'testing {} {:.4f}s'.format(im_name, toc()) # visualize for i in xrange(len(dets)): keep = np.where(dets[i][:,-1]>0.7) dets[i] = dets[i][keep] masks[i] = masks[i][keep] im = cv2.imread('../data/demo/' + im_name) im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB) show_masks(im, dets, masks, CLASSES) # debug ''' for ii in range(scores[0].shape[0]): for jj in range(1, scores[0].shape[1]): if scores[0][ii][jj]>0.7: print ii, jj, scores[0][ii][jj] ''' # bounding box output all_boxes = [[] for _ in CLASSES] nms = py_nms_wrapper(NMS_THRESH) for cls in CLASSES: cls_ind = CLASSES.index(cls)+1 cls_boxes = boxes2[0][:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[0][:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] #print cls, keep dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind-1] = dets[keep, :] boxes_this_image = [all_boxes[j] for j in range(len(CLASSES))] vis_all_detection(data_dict[0]['data'].asnumpy(), boxes_this_image, CLASSES, im_scales[idx]) print 'done'
def demo_net(predictor, dataset, image_set, root_path, dataset_path, vis=False, vis_image_dir=None, use_box_voting=False): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ image_set_index_file = os.path.join(dataset_path, 'DET', 'ImageSets', 'DET', image_set + '.txt') assert os.path.exists( image_set_index_file), image_set_index_file + ' not found' with open(image_set_index_file) as f: image_set_index = [x.strip().split(' ')[0] for x in f.readlines()] num_images = len(image_set_index) num_classes = len(CLASSES) all_boxes = [[[] for _ in xrange(num_images)] for _ in xrange(num_classes)] i = 0 for index in image_set_index: image_file = image_path_from_index(index, dataset_path, image_set) print("processing {}/{} image:{}".format(i, num_images, image_file)) im = cv2.imread(image_file) data_batch, data_names, im_scale = generate_batch(im) scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] cls_dets = np.hstack( (cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(cls_dets) # apply box voting after nms if use_box_voting: nms_cls_dets = cls_dets[keep, :] all_boxes[cls_ind][i] = box_voting(nms_cls_dets, cls_dets) else: all_boxes[cls_ind][i] = cls_dets[keep, :] boxes_this_image = [[]] + [ all_boxes[j][i] for j in xrange(1, len(CLASSES)) ] # print results """ print('class ---- [[x1, x2, y1, y2, confidence]]') for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: print('---------', CLASSES[ind], '---------') print(boxes) """ i += 1 if vis: #vis_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) if not os.path.exists(vis_image_dir): os.mkdir(vis_image_dir) result_file = os.path.join( vis_image_dir, index.strip().split('/')[-1] + '_result' + '.JPEG') print('results saved to %s' % result_file) im = draw_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB) cv2.imwrite(result_file, im) print("num of images: detection:{}, gt:{}".format(len(all_boxes[0]), num_images)) # assert len(all_boxes) == num_images, 'calculations not complete' # save results cache_folder = os.path.join(root_path, 'cache') if not os.path.exists(cache_folder): os.mkdir(cache_folder) cache_file = os.path.join(cache_folder, dataset + '_' + image_set + '_detections.pkl') print("save to {}".format(cache_file)) with open(cache_file, 'wb') as f: cPickle.dump(all_boxes, f, cPickle.HIGHEST_PROTOCOL)
def demo_net(predictor, image_name, args): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ global detect_num global tp, fp, fn global gp, gr, gf1 assert os.path.exists(image_name), image_name + ' not found' im = cv2.imread(image_name) #im = cv2.flip(im, 0) #im = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) #im.reshape((im.shape[0],im.shape[1],1)) data_batch, data_names, im_scale = generate_batch(im) print(im.shape) print(im_scale) #for i in range(10): # scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) t0 = time.clock() for i in range(1): scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) print(time.clock() - t0) all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))] #print(boxes_this_image) # print results rst = {} lfn, lfp, ltp = 0, 0, 0 print('class ---- [[x1, x2, y1, y2, confidence]]') for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: #print('---------', CLASSES[ind], '---------') #print(boxes) rst[CLASSES[ind]] = [box for box in boxes] #detect_num[CLASSES[ind]] += len(boxes) detect_num[CLASSES[ind]] += 1 #len(boxes) bcs = [(list(box), cls) for (cls, boxes) in rst.items() for box in boxes if is_valid(box, im, im_scale)] bcs = sorted(bcs, key=lambda x: -x[0][-1]) print('bcs:', bcs) #print('rst:', rst) rst_bcs = [] for bc in bcs: ignore = False for rbc in rst_bcs: print('bc', bc) print('rbc', rbc) iarea = intersect(bc[0], rbc[0]) area1 = area(bc[0]) area2 = area(rbc[0]) print(iarea, area1, area2) if (iarea / area1 > 0.8) or (iarea / area2 > 0.8): ignore = True print( 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' ) print('area', iarea, area1, area2) break if not ignore: rst_bcs.append(bc) tmp_rst = {} for bc in rst_bcs: tmp_rst.setdefault(bc[1], []) tmp_rst[bc[1]].append(np.array(bc[0])) rst = tmp_rst boxes_this_image = [ copy.deepcopy(rst[CLASSES[idx]]) if CLASSES[idx] in rst else [] for idx in range(len(boxes_this_image)) ] #for boxes in boxes_this_image: # if len(boxes): # boxes.append(pre_box(im, im_scale)) # break #else: # boxes_this_image[-1].append(pre_box(im, im_scale)) boxes_this_image[-1].append(get_pre_box(im, im_scale)) print('in, rst', rst) print(boxes_this_image) if args.image == '' and args.with_label: label_file = os.path.join( args.label_dir, os.path.split(image_name.replace('.jpg', '.txt'))[1]) with open(label_file) as fd: for line in fd: cls, poss = line.split(':') x1, y1, x2, y2 = [float(item) for item in poss.split(',')] if not is_valid([x1, y1, x2, y2], im, im_scale): continue if cls not in rst: lfn += 1 continue iou_thd = 0.5 now_iou = 0 now_idx = 0 for ind, box in enumerate(rst[cls]): #print('box = ', box, type(box)) #print('box = {}, true = {}'.format(box, (x1, y1, x2, y2))) if (box[0] >= x2) or (box[2] <= x1) or (box[1] >= y2) or ( box[3] <= y1): continue else: #print('###############################################') i = (min(x2, box[2]) - max(x1, box[0])) * ( min(y2, box[3]) - max(y1, box[1])) assert (i > 0) u = (x2 - x1) * (y2 - y1) + (box[0] - box[2]) * ( box[1] - box[3]) - i if i / u > now_iou: now_iou = i / u now_idx = ind if now_iou > iou_thd: ltp += 1 rst[cls].pop(now_idx) if len(rst[cls]) == 0: rst.pop(cls) else: lfn += 1 print('after rst:', rst) for vs in rst.values(): lfp += len([v for v in vs if is_valid(v, im, im_scale)]) p, r, f1 = 0, 0, 0 if ltp != 0: p = 100.0 * ltp / (ltp + lfp) r = 100.0 * ltp / (ltp + lfn) f1 = 2 * p * r / (p + r) print('precision = {}%, recall = {}%, f1 score = {}%'.format(p, r, f1)) print(boxes_this_image) tp += ltp fp += lfp fn += lfn gp += p gr += r gf1 += f1 if args.vis: vis_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) else: #print(os.path.join(args.out_dir, os.path.split(image_name.replace('.jpg', '_result.jpg'))[1])) result_file = os.path.join( args.out_dir, os.path.split(image_name.replace('.jpg', '_result.jpg'))[1]) print('results saved to %s' % result_file) im = draw_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) cv2.imwrite(result_file, im)
def demo_net(predictor, image_name, vis=False): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ for image_name in listfile: ll = [] ll.append(image_name.split('/')[-1] + ',') assert os.path.exists(image_name), image_name + ' not found' im = cv2.imread(image_name) width, height, _ = im.shape data_batch, data_names, im_scale = generate_batch(im) scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack( (cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[] ] + [all_boxes[j] for j in range(1, len(CLASSES))] if len(CLASSES) == 0: ll.extend([2, 0, 183, 272, 517]) # print results logger.info('---class---') logger.info('[[x1, x2, y1, y2, confidence]]') for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: logger.info('---%s---' % CLASSES[ind]) logger.info('%s' % boxes) print(boxes) item = boxes[0] xmin = int(round(item[0])) ymin = int(round(item[1])) xmax = int(round(item[2])) ymax = int(round(item[3])) if xmin < 0: xmin = 0 if ymin < 0: ymin = 0 if xmax > width: xmax = width if ymax > height: ymax = height ll.extend([bq[CLASSES[ind]], xmin, ymin, xmax, ymax]) gl = [ str(i) for i in [ image_name.split('/')[-1], bq[CLASSES[ind]], item[4], xmin, ymin, xmax, ymax ] ] file2 = 'fasterrcnnrh.txt' with open(file2, 'a+') as f1: f1.write(','.join(gl)) f1.write('\n') print(ll) ll = [str(i) for i in ll] file = 'fasterrcnn.txt' with open(file, 'a+') as f: f.write(' '.join(ll)) f.write('\n')
def demo_net(predictor, image_name, image, with_label, vis, out_dir, label_dir): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ global detect_num global tp, fp, fn global gp, gr, gf1 if (type(image_name)==str): assert os.path.exists(image_name), image_name + ' not found' im = cv2.imread(image_name) else: im = image # im = cv2.flip(im, 1) data_batch, data_names, im_scale = generate_batch(im) # for i in range(10): # scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) for i in range(1): scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) xn = [] yn = [] wn = [] hn = [] all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))] # print(boxes_this_image) # print results rst = {}; lfn, lfp, ltp = 0, 0, 0 #print('class ---- [[x1, x2, y1, y2, confidence]]') for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: #print('---------', CLASSES[ind], '---------') #print(boxes) for i in range(0, len(boxes)): xn.append(int(boxes[i][0] + 0)) yn.append(int(boxes[i][1] + 0)) wn.append(int(boxes[i][2] - boxes[i][0])) hn.append(int(boxes[i][3] - boxes[i][1])) #rst[CLASSES[ind]] = [box for box in boxes] # detect_num[CLASSES[ind]] += len(boxes) #detect_num[CLASSES[ind]] += 1 # len(boxes) """if image == '' and with_label: label_file = os.path.join(label_dir, os.path.split(image_name.replace('.jpg', '.txt'))[1]) with open(label_file) as fd: for line in fd: cls, poss = line.split(':') x1, y1, x2, y2 = [float(item) for item in poss.split(',')] if cls not in rst: lfn += 1 continue iou_thd = 0.5 now_iou = 0 now_idx = 0 for ind, box in enumerate(rst[cls]): # print('box = ', box, type(box)) # print('box = {}, true = {}'.format(box, (x1, y1, x2, y2))) if (box[0] >= x2) or (box[2] <= x1) or (box[1] >= y2) or (box[3] <= y1): continue else: # print('###############################################') i = (min(x2, box[2]) - max(x1, box[0])) * (min(y2, box[3]) - max(y1, box[1])) assert (i > 0) u = (x2 - x1) * (y2 - y1) + (box[0] - box[2]) * (box[1] - box[3]) - i if i / u > now_iou: now_iou = i / u now_idx = ind if now_iou > iou_thd: ltp += 1 rst[cls].pop(now_idx) if len(rst[cls]) == 0: rst.pop(cls) else: lfn += 1 for vs in rst.values(): lfp += len(vs) p, r, f1 = 0, 0, 0 if ltp != 0: p = 100.0 * ltp / (ltp + lfp) r = 100.0 * ltp / (ltp + lfn) f1 = 2 * p * r / (p + r) print('precision = {}%, recall = {}%, f1 score = {}%'.format(p, r, f1)) tp += ltp fp += lfp fn += lfn gp += p gr += r gf1 += f1""" """if vis: vis_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) else: # print(os.path.join(args.out_dir, os.path.split(image_name.replace('.jpg', '_result.jpg'))[1])) # result_file = os.path.join(out_dir, os.path.split(image_name.replace('.jpg', '_result.jpg'))[1]) result_file = os.path.join(out_dir, os.path.split('_result.jpg')[1]) print('results saved to %s' % result_file) im = draw_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) cv2.imwrite(result_file, im)""" # print(type(xn)) return xn, yn, wn, hn
def demo_net(predictor, image_name, vis=False): """ generate data_batch -> im_detect -> post process :param predictor: Predictor :param image_name: image name :param vis: will save as a new image if not visualized :return: None """ # warm up: twice for i in range(1, 2): im = cv2.imread(image_name) data_batch, data_names, im_scale = generate_batch(im) scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) print "begin test ================================\n" test_list = '/home/junchao/hexiangteng/mxnet/mx-rcnn-master/data/VOCdevkit2007/VOC2007/test.list' f_test = open(test_list, 'r') f_object = f_test.read() rows = f_object.split('\n') starttime1 = time.time() totaltime = 0 for i in range(0, 999): image_name = rows[i] if os.path.exists(image_name) != True: break im = cv2.imread(image_name) data_batch, data_names, im_scale = generate_batch(im) starttime = time.time() scores, boxes, data_dict = im_detect(predictor, data_batch, data_names, im_scale) endtime = time.time() totaltime = (endtime - starttime) + totaltime print image_name, '\t', i, '\t', 'per:', ( endtime - starttime ), '\s\ttotal:', totaltime / (i + 1), 's-------------------' print '--------time for all image:', totaltime, 'ms-------------------' print '--------time for all image with all processes:', ( time.time() - starttime1), 's-------------------' all_boxes = [[] for _ in CLASSES] for cls in CLASSES: cls_ind = CLASSES.index(cls) cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)] cls_scores = scores[:, cls_ind, np.newaxis] keep = np.where(cls_scores >= CONF_THRESH)[0] dets = np.hstack((cls_boxes, cls_scores)).astype(np.float32)[keep, :] keep = nms(dets) all_boxes[cls_ind] = dets[keep, :] boxes_this_image = [[]] + [all_boxes[j] for j in range(1, len(CLASSES))] # print results print 'class ---- [[x1, x2, y1, y2, confidence]]' for ind, boxes in enumerate(boxes_this_image): if len(boxes) > 0: print '---------', CLASSES[ind], '---------' print boxes if vis: vis_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) else: result_file = image_name.replace('.', '_result.') print 'results saved to %s' % result_file im = draw_all_detection(data_dict['data'].asnumpy(), boxes_this_image, CLASSES, im_scale) cv2.imwrite(result_file, im)