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)
assert not cfg.MODEL.RPN_ONLY, \
'RPN models are not supported'
assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \
'Models that require precomputed proposals are not supported'
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]
for i, im_name in enumerate(im_list):
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(im_name) + '.' + args.output_ext)
)
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=args.thresh,
kp_thresh=args.kp_thresh,
ext=args.output_ext,
out_when_no_box=args.out_when_no_box
)
def main(args):
logger = logging.getLogger(__name__)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
cfg_orig = load_cfg(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(cache_urls=False)
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 get_rpn_box_proposals(im, args):
cfg.immutable(False)
merge_cfg_from_file(args.rpn_cfg)
cfg.NUM_GPUS = 1
cfg.MODEL.RPN_ONLY = True
cfg.TEST.RPN_PRE_NMS_TOP_N = 10000
cfg.TEST.RPN_POST_NMS_TOP_N = 2000
assert_and_infer_cfg(cache_urls=False)
model = model_engine.initialize_model_from_cfg(args.rpn_pkl)
with c2_utils.NamedCudaScope(0):
boxes, scores = rpn_engine.im_proposals(model, im)
return boxes, scores
def load_model(args):
model = test_engine.initialize_model_from_cfg(cfg.TEST.WEIGHTS)
blobs = mutils.get_ws_blobs()
return model, blobs
weights_file = 'weights/DensePose_ResNet50_FPN_s1x-e2e.pkl' output_dir = 'DensePoseData/infer_out/' image_ext = 'jpg' im_or_folder = '' workspace.GlobalInit(['caffe2', '--caffe2_log_level=0']) setup_logging(__name__) logger = logging.getLogger(__name__) merge_cfg_from_file(cfg_file) cfg.NUM_GPUS = 1 cfg.TEST.BBOX_AUG.ENABLED = False cfg.MODEL.MASK_ON = False cfg.MODEL.KEYPOINTS_ON = False # weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(weights_file) dummy_coco_dataset = dummy_datasets.get_coco_dataset() # Server configs PORT = 22100 app = Flask(__name__) CORS(app) socketio = SocketIO(app) # Pix2Pix server Configs PUBLIC_IP = '107.21.18.29' PIX2PIX_PORT = '23100' PIX2PIX_ROUTE = '/infer' pix2pixURL = 'http://' + PUBLIC_IP + ':' + PIX2PIX_PORT + PIX2PIX_ROUTE # Take in base64 string and return PIL image
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()
# 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 fold in os.listdir(args.im_or_folder):
_fold = os.path.join(args.im_or_folder, fold)
if os.path.isdir(_fold):
im_list = glob.iglob(_fold + '/*.' + args.image_ext)
else:
im_list = [args.im_or_folder]
output_dir = os.path.join(args.output_dir, fold)
if not os.path.exists(output_dir):
os.mkdir(output_dir)
for i, im_name in enumerate(im_list):
out_name = os.path.join(
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[:-4],
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')
import pycocotools.mask as mask_util
boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format(
cls_boxes, cls_segms, cls_keyps)
if segms is not None and len(segms) > 0:
score = boxes[:, -1]
index = [i for i, _sc in enumerate(score) if _sc > 0.7]
mask = mask_util.decode(segms)
for i in index:
cv2.imwrite(
'{}/{}_{}.jpg'.format(output_dir,
im_name.split('/')[-1][:-4], i),
mask[:, :, i] * 255.0)
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)
assert not cfg.MODEL.RPN_ONLY, \
'RPN models are not supported'
assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \
'Models that require precomputed proposals are not supported'
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]
for i, im_name in enumerate(im_list):
out_name = os.path.join(
args.output_dir,
'{}'.format(os.path.basename(im_name) + '.' + args.output_ext))
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=args.thresh,
# kp_thresh=args.kp_thresh,
# ext=args.output_ext,
# out_when_no_box=args.out_when_no_box
# )
boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format(
cls_boxes, cls_segms, cls_keyps)
print(classes)
with open(os.path.join(args.output_dir, "out.csv"), "a+",
newline='') as csv_out:
csv_writer = csv.writer(csv_out, delimiter=';', quotechar='"')
# Save one box per line
for i, box in enumerate(boxes):
if box[-1] < 0.65:
continue
if classes[i] not in [5]:
continue
row = [im_name.split(os.path.sep)[-1]]
# Format box x1, y1, x2, y2, p
for coord in box[:4]:
row.append(int(round(coord)))
row.append(classes[i])
csv_writer.writerow(row)
def inference(self, image_list):
"""Do an inference of the DensePose model with a set of image inputs.
# Arguments:
image_list: The input image list
Return the result of the inference.
"""
# Directly return image when no inference options
if not (self.show_human_index or self.show_uv or self.show_border
or self.show_grid):
return [image_list[0]]
image = image_list[0]
image = self.linear_to_srgb(image) * 255.
imcpy = image.copy()
# Initialize the model out of the configuration and weights files
if not hasattr(self, 'model'):
workspace.ResetWorkspace()
# Reset to default config
merge_cfg_from_cfg(self.default_cfg)
# Load densepose configuration file
merge_cfg_from_file(self.cfg_file)
assert_and_infer_cfg(cache_urls=False, make_immutable=False)
self.model = infer_engine.initialize_model_from_cfg(self.weights)
# Save densepose full configuration file
self.densepose_cfg = copy.deepcopy(
AttrDict(cfg)) #cfg from detectron.core.config
else:
# There is a global config file for all detectron models (Densepose, Mask RCNN..)
# Check if current global config file is correct for densepose
if not dict_equal(self.densepose_cfg, cfg):
# Free memory of previous workspace
workspace.ResetWorkspace()
# Load densepose configuration file
merge_cfg_from_cfg(self.densepose_cfg)
assert_and_infer_cfg(cache_urls=False, make_immutable=False)
self.model = infer_engine.initialize_model_from_cfg(
self.weights)
# Compute the image inference
with c2_utils.NamedCudaScope(0):
# image in BGR format for inference
cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all(
self.model, image[:, :, ::-1], None)
res = vis_utils.vis_densepose(
imcpy, # image in RGB format for visualization
cls_boxes,
cls_bodys,
show_human_index=self.show_human_index,
show_uv=self.show_uv,
show_grid=self.show_grid,
show_border=self.show_border,
border_thick=self.border_thick,
alpha=self.alpha)
res = self.srgb_to_linear(res.astype(np.float32) / 255.)
return [res]
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)
assert not cfg.MODEL.RPN_ONLY, \
'RPN models are not supported'
assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \
'Models that require precomputed proposals are not supported'
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]
"""
Add support for webcam
"""
# Set and get camera from OpenCV
cap = cv2.VideoCapture('/detectron/mypython/people-walking.mp4')
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH) + 0.5)
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT) + 0.5)
s = n(b'XVID')
fourcc = cv2.VideoWriter_fourcc(*s)
out = cv2.VideoWriter('output.avi', fourcc, 24.0, (width, height))
im_name = 'tmp_im'
count = 0
fileOut = open('people-walking.txt', 'w')
while True:
count += 1
# Fetch image from camera
_, im = 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, 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)')
box_list = [b for b in cls_boxes if len(b) > 0]
if len(box_list) > 0:
boxes = np.concatenate(box_list)
else:
boxes = None
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.
)
time.sleep(0.05)
img = cv2.imread('/detectron/mypython/tmp_im.jpg')
cv2.putText(img, 'Frame: ', (5, 30), cv2.FONT_HERSHEY_SIMPLEX, 1,
(255, 255, 255), 2)
cv2.putText(img, str(count), (130, 30), cv2.FONT_HERSHEY_SIMPLEX, 1,
(255, 255, 255), 2)
cv2.putText(img, 'Model: e2e_mask_rcnn_R-101-FPN_2x.yaml', (200, 30),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
cv2.putText(
img,
'WEIGHTS: https://s3-us-west-2.amazonaws.com/detectron/ImageNetPretrained/MSRA/R-101.pkl',
(5, 60), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
for i in range(len(boxes)):
x1 = "{:.6f}".format(boxes[i][0] / width)
y1 = "{:.6f}".format(boxes[i][1] / height)
x2 = "{:.6f}".format(boxes[i][2] / width)
y2 = "{:.6f}".format(boxes[i][3] / height)
conf = "{:.6f}".format(boxes[i][4])
fileOut.write("Frame " + str(count).zfill(5) + ":" + " " +
str(x1) + " " + str(y1) + " " + str(x2) +
" " + str(y2) + " " + str(conf) + "\n")
#cv2.putText(img, str(x1),(5, 90+30*i), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 2)
#cv2.putText(img, str(y1),(185, 90+30*i), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 2)
#cv2.putText(img, str(x2),(365, 90+30*i), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 2)
#cv2.putText(img, str(y2),(545, 90+30*i), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 2)
#cv2.putText(img, str(conf),(725, 90+30*i), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 2)
time.sleep(0.05)
out.write(img)
fileOut.close()
cap.release()
out.release()
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(cache_urls=False)
model = infer_engine.initialize_model_from_cfg(args.weights)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
frame_no = 0
# print( "capturing video")
cap = cv2.VideoCapture(args.input)
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
# pdb.set_trace()
grab = 1
if (cap.isOpened() == False):
print("Error opening video stream or file")
exit
while (cap.isOpened() and grab <= total_frames):
print("|Processing Frame {0}/{1} ".format(grab, total_frames))
grab += 1
captime = time.time()
ret_val, im = cap.read()
print('\t-Frame read in{: .3f}s'.format(time.time() - captime))
#skips intermediate frames
if grab % 2 != 0:
continue
#uncomment to resize image
im = cv2.resize(im, (int(1280 / 1), int(720 / 1)))
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all(
model, im, None, timers=timers)
print('\t | Inference time: {:.3f}s'.format(time.time() - t))
for k, v in timers.items():
print('\t | {}: {:.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)')
output_name = 'out.mp4'
ret = vis_utils.vis_one_image(
im[:, :, ::-1], # BGR -> RGB for visualization
output_name,
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
cls_bodys,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=False,
thresh=0.7,
kp_thresh=2)
if ret == True:
frame_no = frame_no + 1
cap.release()
cv2.destroyAllWindows()
subprocess.call(
'ffmpeg -framerate 20 -i {}/file%02d.png -c:v libx264 -r 30 -pix_fmt yuv420p vid/out.mp4'
.format(os.path.join(args.output_dir, 'vid')),
shell=True)
def main(args):
logger = logging.getLogger(__name__)
classfied_confidence = args.classfied_confidence
# get test image list
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]
json_dir = args.json_dir
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)
assert not cfg.MODEL.RPN_ONLY, \
'RPN models are not supported'
assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \
'Models that require precomputed proposals are not supported'
model = infer_engine.initialize_model_from_cfg(args.weights)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
# load cnn judgement result
judgement_json_path = args.judgement_json_path
judgement_dict = {}
with open(judgement_json_path, 'r') as f:
judgement_dict = json.load(f)
# do object detection
results = {}
result_list = []
for i, im_path in enumerate(im_list):
out_name = os.path.join(
#args.output_dir, '{}'.format(os.path.basename(im_path) + '.' + args.output_ext)
args.output_dir,
'{}'.format(os.path.basename(im_path)))
logger.info('Processing {} -> {}'.format(im_path, out_name))
im = cv2.imread(im_path)
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)')
image_simple_name = im_path.split('/')[-1]
restricted_confidence = judgement_dict[image_simple_name]
judgement, category_cnt, _ = judgement_function(
restricted_confidence, cls_boxes, classfied_confidence)
file_dict = {}
file_dict["filename"] = im_path.split('/')[-1]
if judgement: # restricted
file_dict_rects = []
for class_id in range(1, 6):
if len(cls_boxes[class_id]) != 0:
for class_content in cls_boxes[class_id]:
if class_content[4] >= 0.5:
one_box = {}
one_box["xmin"] = int(class_content[0])
one_box["ymin"] = int(class_content[1])
one_box["xmax"] = int(class_content[2])
one_box["ymax"] = int(class_content[3])
one_box["label"] = int(class_id) # 1,2,3,4,5
one_box["confidence"] = round(
float(class_content[4]), 2)
file_dict_rects.append(one_box)
file_dict["rects"] = file_dict_rects
result_list.append(file_dict)
vis_utils.vis_one_image(
im[:, :, ::-1], # BGR -> RGB for visualization
im_path[:-4],
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_coco_dataset,
box_alpha=1.0,
show_class=True,
thresh=args.thresh,
kp_thresh=args.kp_thresh,
ext=args.output_ext,
out_when_no_box=args.out_when_no_box)
else:
file_dict["rects"] = []
result_list.append(file_dict)
results["results"] = result_list
nowTime = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
output_json_path = json_dir + '/' + str(nowTime) + ".json"
with open(output_json_path, 'w') as file:
json.dump(results, file)
print("All_Done")
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()
# Get image name list.
if visualize:
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]
else:
with open(src_img_list_file, 'r') as f:
im_list = f.readlines()
for i, im_name in enumerate(im_list):
im_list[i] = im_name.strip()
f = open(dst_img_list_file, "w")
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))
if visualize:
im_full_name = im_name
im = cv2.imread(im_full_name, cv2.IMREAD_COLOR)
else:
# Loading picture
im_full_name = os.path.join(src_img_folder, im_name + '.jpg')
if not os.path.exists(im_full_name):
print('%s: No such file.' % im_full_name)
exit()
im = cv2.imread(im_full_name, cv2.IMREAD_COLOR)
# Loading groundtruth
cat_gt, human_gt = gt_process(src_cat_gt_folder, im_name)
# cv2.imwrite(os.path.join(dst_whole_gt_folder, im_name + '.png'),
# cat_gt)
# continue
# cat_gt_full_name = os.path.join(src_cat_gt_folder, im_name + '.png')
# if not os.path.exists(cat_gt_full_name):
# print('%s: No such file.' % cat_gt_full_name)
# exit()
# cat_gt = cv2.imread(cat_gt_full_name, cv2.IMREAD_GRAYSCALE)
# human_gt_full_name = os.path.join(src_human_gt_folder, im_name + '.png')
# if not os.path.exists(human_gt_full_name):
# print('%s: No such file.' % human_gt_full_name)
# exit()
# human_gt = cv2.imread(human_gt_full_name, cv2.IMREAD_GRAYSCALE)
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, masks, classes = 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,
visualize=visualize
)
if not visualize and boxes is not None:
get_objs(
im, cat_gt, human_gt, im_name,
boxes, masks, classes, dummy_coco_dataset, f
)
f.close()
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)
assert not cfg.MODEL.RPN_ONLY, \
'RPN models are not supported'
assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \
'Models that require precomputed proposals are not supported'
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]
# load cnn judgement result
judgement_json_path = args.judgement_json_path
judgement_dict = {}
with open(judgement_json_path, 'r') as f:
judgement_dict = json.load(f)
classfied_confidence = args.classfied_confidence
for i, im_name in enumerate(im_list):
out_name = os.path.join(
#args.output_dir, '{}'.format(os.path.basename(im_name) + '.' + args.output_ext)
args.output_dir,
'{}'.format(os.path.basename(im_name)))
logger.info('Processing {} -> {}'.format(im_name, out_name))
im = cv2.imread(im_name)
height, width, _ = im.shape
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)')
#print("********Result**************")
#masks = mask_util.decode(cls_segms)
npy_save_dir = args.npy_save_dir
im_name_ = im_name.split('/')[-1][:-4]
restricted_confidence = judgement_dict[im_name.split('/')[-1]]
#simple apply judgement
#judgement, category_cnt, _ = judgement_function(restricted_confidence, cls_boxes,classfied_confidence)
if restricted_confidence > classfied_confidence:
judgement = True
else:
judgement = False
if judgement: # restricted
if cls_segms is not None:
for class_id in range(1, 6):
class_save_path = npy_save_dir + '/' + im_name_ + '_' + str(
class_id) + '.npy'
save_numpy = np.zeros((height, width), dtype=np.uint8)
if cls_segms[class_id] == []:
np.save(class_save_path, save_numpy)
else:
for class_content in cls_segms[class_id]:
mask_ = mask_util.decode(class_content)
save_numpy = save_numpy | mask_
np.save(class_save_path, save_numpy)
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=args.thresh,
kp_thresh=args.kp_thresh,
ext=args.output_ext,
out_when_no_box=args.out_when_no_box)
else:
save_numpy = np.zeros((height, width), dtype=np.uint8)
for class_id in range(1, 6):
class_save_path = npy_save_dir + '/' + im_name_ + '_' + str(
class_id) + '.npy'
np.save(class_save_path, save_numpy)
else:
save_numpy = np.zeros((height, width), dtype=np.uint8)
for class_id in range(1, 6):
class_save_path = npy_save_dir + '/' + im_name_ + '_' + str(
class_id) + '.npy'
np.save(class_save_path, save_numpy)
def main(args):
global dot_count
dot_count = 0
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()
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]
host = '127.0.0.1'
port = 9998
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((host, port))
s.listen(5)
s.settimeout(2)
SIZE = 4096
#s.settimeout(10)
multiTracker = cv2.MultiTracker_create()
while True:
try:
sock, addr = s.accept()
receive = sock.recv(SIZE).decode()
tmp = str(receive).split("|")
path = tmp[0]
device_addr = tmp[1]
print("path: {0}, device_addr: {1}".format(path, device_addr))
im_list = []
im_list.append(path)
for i, im_name in enumerate(im_list):
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(im_name))
)
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_bodys = 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,
cls_bodys,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.8,
kp_thresh =2
)
print("len(cls_boxes[1])-1: {0}".format(len(cls_boxes[1])-1))
count_people = 0
now_boxes = []
now_center = []
try:
for i in range(len(cls_boxes[1])):
if cls_boxes[1][i][4] > 0.8:
now_boxes.append(cls_boxes[1][i][:4])
now_center.append([int((cls_boxes[1][i][0] + cls_boxes[1][i][2])//2), int((cls_boxes[1][i][1] + cls_boxes[1][i][3])//2)])
count_people = count_people + 1
except:
count_people = 0
print("now_center: {0}".format(now_center))
print("count_people: {0}".format(count_people))
ans_command = str(count_people) + " "
for i in range(int(count_people)):
ans_command = ans_command + str(now_center[i][0]) + "," + str(now_center[i][1]) + ","
ans_command = ans_command.strip(",")
print(ans_command)
sock.send(ans_command.encode())
im_name = ""
except Exception as e:
print(' ', end='\r')
error_text = "Exception: " + str(e) + ", reconnecting "
for i in range(dot_count):
error_text = error_text + "."
dot_count = dot_count + 1
if dot_count > 3:
dot_count = 0
print(error_text, end='\r')
s.close()
def main(args):
logger = logging.getLogger(__name__)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
cfg_orig = load_cfg(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, cls_bodys = None, 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(cache_urls=False)
model = model_engine.initialize_model_from_cfg(weights_file)
with c2_utils.NamedCudaScope(0):
cls_boxes_, cls_segms_, cls_keyps_ , cls_bodys_= \
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
cls_bodys = cls_bodys_ if cls_bodys_ is not None else cls_bodys
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))
import numpy as np
import pickle
f = open('test_vis.pkl', 'w')
pickle.dump(
{
'im': im,
'cls_boxes': np.array(cls_boxes),
'cls_bodys': np.array(cls_bodys)
}, f)
f.close()
vis_utils.vis_one_image(im[:, :, ::-1],
args.im_file,
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
cls_bodys,
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)
assert not cfg.MODEL.RPN_ONLY, \
'RPN models are not supported'
assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \
'Models that require precomputed proposals are not supported'
model = infer_engine.initialize_model_from_cfg(args.weights)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
if args.datatype == 'test':
img_dir = '/HICO_DET/hico_20160224_det/images/test2015'
save_father_dir = '/HICO_DET/box/Faster_RCNN_101/test'
elif args.datatype == 'train':
img_dir = '/HICO_DET/hico_20160224_det/images/train2015'
save_father_dir = '/HICO_DET/box/Faster_RCNN_101/train'
else:
assert 0, "img type must be test or train"
im_list = glob.glob(img_dir + '/*')
im_list.sort()
img_num = len(im_list)
for i, im_name in enumerate(im_list):
save_name = im_name.split('/')[-1].split('.')[0] + '.json'
im_det_sv_pth = os.path.join(save_father_dir, save_name)
if os.path.exists(im_det_sv_pth):
continue
print('Process', i + 1, ' / ', img_num, ' img name ',
save_name.split('.')[0])
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)
# select box
each_img_out = []
box_per_thre = args.box_per_thre # 0.7
box_obj_thre = args.box_obj_thre # 0.4
human_hum = 0
object_num = 0
for class_idx, each_box in enumerate(cls_boxes[1:]):
class_name = dummy_coco_dataset['classes'][class_idx + 1]
if class_name == 'person':
threthold = box_per_thre
else:
threthold = box_obj_thre
for each_ins in each_box:
if each_ins[-1] > threthold:
if class_name == 'person':
human_hum += 1
object_num += 1
each_ins = np.around(each_ins, 2)
ins = each_ins.tolist()
ins.append(class_name)
each_img_out.append(ins)
each_img_out.append({'per_num': human_hum, 'total_num': object_num})
with open(im_det_sv_pth, "w") as file:
json.dump(each_img_out, file)
file.close()
def inference(self, image_list):
"""Do an inference on the model with a set of inputs.
# Arguments:
image_list: The input image list
Return the result of the inference.
"""
image = image_list[0]
image = self.linear_to_srgb(image)*255.
imcpy = image.copy()
# Initialize the model out of the configuration and weights files
if not hasattr(self, 'model'):
workspace.ResetWorkspace()
# Reset to default config
merge_cfg_from_cfg(self.default_cfg)
# Load mask rcnn configuration file
merge_cfg_from_file(self.cfg_file)
assert_and_infer_cfg(cache_urls=False, make_immutable=False)
self.model = infer_engine.initialize_model_from_cfg(self.weights)
# Save mask rcnn full configuration file
self.mrcnn_cfg = copy.deepcopy(AttrDict(cfg)) # cfg from detectron.core.config
else:
# There is a global config file for all detectron models (Densepose, Mask RCNN..)
# Check if current global config file is correct for mask rcnn
if not dict_equal(self.mrcnn_cfg, cfg):
# Free memory of previous workspace
workspace.ResetWorkspace()
# Load mask rcnn configuration file
merge_cfg_from_cfg(self.mrcnn_cfg)
assert_and_infer_cfg(cache_urls=False, make_immutable=False)
self.model = infer_engine.initialize_model_from_cfg(self.weights)
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
self.model, image[:, :, ::-1], None
)
if self.binary_masks:
res = vis_utils.vis_one_image_binary(
imcpy,
cls_boxes,
cls_segms,
thresh=self.thresh
)
else:
res = vis_utils.vis_one_image_opencv(
imcpy,
cls_boxes,
cls_segms,
cls_keyps,
thresh=self.thresh,
show_box=self.show_box,
show_class=self.show_class,
dataset=self.dummy_coco_dataset,
alpha=self.alpha,
show_border=self.show_border,
border_thick=self.border_thick,
bbox_thick=self.bbox_thick,
font_scale=self.font_scale
)
res = self.srgb_to_linear(res.astype(np.float32) / 255.)
return [res]
def densepose(args):
# args = parse_args()
# print(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()
# if os.path.isdir(args.video) #
im_list = video2imgs(args.video)
# 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]
# vis_imgshape = vis_img.shape
# size = (vis_imgshape[1], vis_imgshape[0])
# fourcc = cv2.VideoWriter_fourcc(*'mp4v')
# size = (1600,900)
# videoWriter = cv2.VideoWriter(args.output_dir + os.path.basename(args.video), fourcc, 20, size)
# time_start = time.time()
for i, im 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)
im = im[0:480, 210:430] #裁剪坐标为[y0:y1, x0:x1]
if i % 6 == 0:
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all(
model, im, None, timers=timers)
##############################20190123
box_list = [b for b in cls_boxes if len(b) > 0]
if len(box_list) > 0:
boxes = np.concatenate(box_list)
else:
boxes = None
if cls_keyps is not None:
keyps = [k for klist in cls_keyps for k in klist]
else:
keyps = None
a = np.argmax(boxes, axis=0)
j = a[4]
kps = keyps[j]
kpss = np.expand_dims(kps, axis=0)
if i == 0:
kpsstack = kpss
else:
kpsstack = np.vstack((kpsstack, kpss))
# if i == 0:
# kpss = kps
# elif i == 1:
# kpss2 = kps - kpss
# kpss = kps
# kpsss = np.expand_dims(kpss2, axis=0)
# kpsstack = kpsss
# else:
# kpss2 = kps - kpss
# kpss = kps
# kpsss = np.expand_dims(kpss2, axis=0)
# kpsstack = np.vstack((kpsstack, kpsss))
# mat_path = '/home/server010/zhoukaiye/jianshen/jianshenshuju/test/coordinate-161441-keyps.mat'
# io.savemat(mat_path, {'name':kps})
###########
# with open("/home/server010/zhoukaiye/jianshen/jianshenshuju/test/coordinates2.txt", "w") as f:
# for kp in cls_keyps:
# f.write(str(kp))
# mat_path = '/home/server010/zhoukaiye/jianshen/jianshenshuju/test/coordinate-161441.mat'
# io.savemat(mat_path, {'name':cls_keyps})
############
# IPython.embed()
# 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)'
# )
# if i % 5 == 0:
All_Coords = vis_utils.vis_one_image(
im[:, :, ::-1], # BGR -> RGB for visualization
cls_boxes,
None, # im_name,
None, # args.output_dir,
cls_segms,
cls_keyps,
cls_bodys,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2)
if cls_keyps is None:
vis_img = visualize(im, All_Coords)
else:
# print('keypoint')
vis_img = All_Coords
if i == 0:
fourcc = cv2.VideoWriter_fourcc(*'mp4v'.encode('utf-8'))
# fourcc = cv2.VideoWriter_fourcc(*'MP4V')
#fourcc = cv2.VideoWriter_fourcc(*'XVID')
vis_imgshape = vis_img.shape
size = (vis_imgshape[1], vis_imgshape[0])
videoWriter = cv2.VideoWriter(
args.output_dir +
os.path.basename(args.video).split('.')[0] + '.mp4',
fourcc, 25, size)
# videoWriter.write(vis_img)
# IUV_list.append(vis_img)
#imgs2video
# videoWriter = cv2.VideoWriter(args.output_dir + '/zuoqianceyang5.mp4', fourcc, 20, size)
## 5 qu 1
# if i % 5 == 0:
videoWriter.write(vis_img)
# mat_path = '/home/server010/server010/FitNess/Video_capture/video_out/yingla_test2.mat'
# io.savemat(mat_path, {'name':kpsstack})
videoWriter.release()
data1 = kpsstack[:, 0:2, :]
classify_action, count_action, maxList, maxheight, start_frame = classify_count(
data1)
return classify_action, count_action, maxList, maxheight, start_frame, data1
def main(args):
logger = logging.getLogger(__name__)
merge_cfg_from_file(args.cfg)
cfg.NUM_GPUS = 8
args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE)
assert_and_infer_cfg(cache_urls=False)
assert not cfg.MODEL.RPN_ONLY, \
'RPN models are not supported'
assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \
'Models that require precomputed proposals are not supported'
model = infer_engine.initialize_model_from_cfg(args.weights)
dummy_wider_dataset = wider_datasets.get_wider_dataset()
INFER_BOX_ALPHA = 0.3
INFER_THRESH = 0.5
INFER_KP_THRESH = 2
MODEL_ITER = 60000
submit_result = []
result_file_name = 'detectron_val_result_model_fast_rcnn_anchor_{}_' \
'NMS_{}_SOFTNMS_{}_BBOX_VOTE_{}_' \
'PRE_NMS_{}_BoxAlpha_{}_' \
'Thresh_{}_BoxNumber.txt'.format(
MODEL_ITER,
cfg.TEST.NMS,
cfg.TEST.SOFT_NMS.ENABLED,
cfg.TEST.BBOX_VOTE.ENABLED,
cfg.TEST.RPN_PRE_NMS_TOP_N,
INFER_BOX_ALPHA,
INFER_THRESH)
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)')
result = vis_utils.vis_one_image_bbox_2_class(
im[:, :, ::-1], # BGR -> RGB for visualization
im_name,
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_wider_dataset,
box_alpha=INFER_BOX_ALPHA,
show_class=False,
thresh=INFER_THRESH,
kp_thresh=INFER_KP_THRESH)
if result:
submit_result.extend(result)
logger.info('Image {}.'.format(i))
# Write file
with open(result_file_name, 'wb') as result_file:
for item in submit_result:
result_file.write("%s\n" % item)
logger.info(
'The result file has been written in {}'.format(result_file_name))
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)
assert not cfg.MODEL.RPN_ONLY, \
'RPN models are not supported'
assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \
'Models that require precomputed proposals are not supported'
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]
for i, im_name in enumerate(im_list):
out_name = os.path.join(
args.output_dir, '{}_mask.jpg'.format(os.path.basename(im_name)))
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)')
# pdb.set_trace()
boxes, segms, keyps, classes = vis_utils.convert_from_cls_format(
cls_boxes, cls_segms, cls_keyps)
if boxes is None:
continue
segms = vis_utils.mask_util.decode(segms)
valid_inds = np.greater(boxes[:, 4], 0.5)
boxes = boxes[valid_inds, :]
segms = segms[:, :, valid_inds]
classes = np.array(classes)[valid_inds]
out_mat_name = os.path.join(args.output_dir,
'{}'.format(os.path.basename(im_name)))
class_names = np.asarray(
([coco_to_pascal_name(coco_classes[c - 1]) for c in classes]),
dtype='object')
sio.savemat(out_mat_name, {
'masks': segms,
'boxes': boxes,
'classes': class_names
})
def main(args):
glob_keypoints = []
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)
assert not cfg.MODEL.RPN_ONLY, \
'RPN models are not supported'
assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \
'Models that require precomputed proposals are not supported'
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 + '/*' + '.png')
else:
im_list = [args.im_or_folder]
im_list = sorted(im_list)
for i, im_name in enumerate(im_list):
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(im_name) + '.' + args.output_ext)
)
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=args.thresh,
kp_thresh=args.kp_thresh,
ext=args.output_ext,
out_when_no_box=args.out_when_no_box
)
cls_boxes_np = np.asarray(cls_boxes)
cls_boxes_prob = cls_boxes_np[1][:,4]
idx_max_prob = np.argmax(cls_boxes_prob)
cls_keyps_max_prob = cls_keyps[1][idx_max_prob]
pose_x_y_prob_after_softmax = cls_keyps_max_prob[[0,1,3]]
glob_keypoints.append(np.transpose(pose_x_y_prob_after_softmax))
dictionarry_keypoints={'S1': {'Directions 1' : np.asarray([glob_keypoints])}}
metadata = {'layout_name': 'h36m', 'num_joints': 17, 'keypoints_symmetry': [[4, 5, 6, 11, 12, 13], [1, 2, 3, 14, 15, 16]]}
#np.savez(os.path.join('/home/narvis/Dev/VideoPose3D/data', "data_2d_detections.npz"), metadata=metadata, positions_2d=dictionarry_keypoints)
np.savez(os.path.join(args.output_dir, "data_2d_detections.npz"), metadata=metadata, positions_2d=dictionarry_keypoints)
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)
assert not cfg.MODEL.RPN_ONLY, \
'RPN models are not supported'
assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \
'Models that require precomputed proposals are not supported'
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]
for i, im_name in enumerate(im_list):
im_basename = os.path.splitext(os.path.basename(im_name))[0]
out_name = os.path.join(
args.output_dir, '{}'.format(im_basename + '.' + args.output_ext)
)
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=args.thresh,
kp_thresh=args.kp_thresh,
ext=args.output_ext,
out_when_no_box=args.out_when_no_box
)
# save bounding box information to a file
box_results = os.path.join(args.output_dir,
'{}.csv'.format(im_basename))
box_fh = open(box_results, 'w')
# convert class bounding boxes, segments, keypoints
boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format(
cls_boxes, cls_segms, cls_keyps
)
if boxes is not None:
for i in range(len(boxes)):
left = int(round(boxes[i, 0]))
top = int(round(boxes[i, 1]))
right = int(round(boxes[i, 2]))
bottom = int(round(boxes[i, 3]))
score = boxes[i, -1]
if score < args.thresh:
continue
class_name = dummy_coco_dataset.classes[classes[i]]
box_fh.write('{},{:.2f},{},{},{},{}\n'.format(
class_name, score, left, top, right, bottom))
box_fh.close()
def load_model(args):
model = test_engine.initialize_model_from_cfg(cfg.TEST.WEIGHTS)
blobs = mutils.get_ws_blobs()
return model, blobs
import json
import cv2
app = Flask(__name__)
workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
setup_logging(__name__)
args = parse_args()
logger = logging.getLogger(__name__)
merge_cfg_from_file("configs/DensePose_ResNet101_FPN_s1x-e2e.yaml")
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)
@app.route('/')
def hello_world():
return 'To use openpose as a service you need to access /upload via POST. Full readme: '
@app.route('/upload', methods=['POST'])
def upload():
if request.method == 'POST':
file = request.files['file']
extension = os.path.splitext(file.filename)[1]
f_name = "demo_im.jpg"
file.save(os.path.join('DensePoseData/demo_data', f_name))
