def main_wflwe70():
args = parse_args()
logger, final_output_dir, tb_log_dir = \
utils.create_logger(config, args.cfg, 'test')
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.determinstic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
model = models.get_face_alignment_net(config)
dataset_type = get_dataset(config)
dataset = dataset_type(config, is_train=True)
for i in range(len(dataset)):
# ipdb.set_trace()
img, fname, meta = dataset[i]
filename = osp.join('data/wflwe70/xximages', fname)
if not osp.exists(osp.dirname(filename)):
os.makedirs(osp.dirname(filename))
scale = meta['scale']
center = meta['center']
tpts = meta['tpts']
for spt in tpts:
img = cv2.circle(img, (4 * spt[0], 4 * spt[1]),
1 + center[0] // 400, (255, 0, 0))
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
cv2.imwrite(filename, img)
def get_model_by_name(model_name,
root_models_path='hrnetv2_models',
prefix='HR18-',
model_type='landmarks',
device='cuda'):
checkpoint_path = f'{root_models_path}/{prefix}{model_name}.pth'
config_path = f'{root_models_path}/{prefix}{model_name}.yaml'
merge_configs(config, config_path)
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
if model_type == 'landmarks':
model = get_face_alignment_net(config)
else:
model = get_cls_net(config_imagenet)
model.load_state_dict(torch.load(checkpoint_path))
model.eval()
model.to(device)
return model
def main_cofw():
args = parse_args()
logger, final_output_dir, tb_log_dir = \
utils.create_logger(config, args.cfg, 'test')
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.determinstic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
model = models.get_face_alignment_net(config)
ipdb.set_trace()
dataset_type = get_dataset(config)
dataset = dataset_type(config, is_train=True)
fp = open('data/cofw/test.csv', 'w')
for i in range(len(dataset)):
# ipdb.set_trace()
img, image_path, meta = dataset[i]
fname = osp.join('data/cofw/test', osp.basename(image_path))
fp.write('%s,1,128,128' % fname)
tpts = meta['tpts']
for j in range(tpts.shape[0]):
fp.write(',%d,%d' % (tpts[j, 0], tpts[j, 1]))
fp.write('\n')
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
cv2.imwrite(fname, img)
fp.close()
def main():
args = parse_args()
logger, final_output_dir, tb_log_dir = \
utils.create_logger(config, args.cfg, 'test')
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.determinstic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
model = models.get_face_alignment_net(config)
gpus = list(config.GPUS)
model = nn.DataParallel(model, device_ids=gpus).cuda()
# load model
state_dict = torch.load(args.model_file)
if 'state_dict' in state_dict.keys():
state_dict = state_dict['state_dict']
model.load_state_dict(state_dict)
else:
model.module.load_state_dict(state_dict)
dataset_type = get_dataset(config)
test_loader = DataLoader(dataset=dataset_type(config, is_train=False),
batch_size=config.TEST.BATCH_SIZE_PER_GPU *
len(gpus),
shuffle=False,
num_workers=config.WORKERS,
pin_memory=config.PIN_MEMORY)
nme, predictions = function.inference(config, test_loader, model)
with open('../data/crabs/crabs_data_test.csv', 'r') as f:
data = np.loadtxt(f, str, delimiter=",", skiprows=1)
paths = data[:, 0]
for index, path in enumerate(paths):
img = cv2.imread("../data/crabs/images/{}".format(path))
a = predictions[index]
b = a.numpy()
for index, px in enumerate(b):
# print(tuple(px))
cv2.circle(img, tuple(px), 1, (0, 0, 255), 3, 8, 0)
# cv2.imwrite("/home/njtech/Jiannan/crabs/dataset/result_new/{}".format(path.split('/')[-1]), img)
cv2.imshow("img", img)
cv2.waitKey(1000) & 0xFF
torch.save(predictions, os.path.join(final_output_dir, 'predictions.pth'))
def main():
args = parse_args()
logger, final_output_dir, tb_log_dir = \
utils.create_logger(config, args.cfg, 'test')
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.determinstic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
model = models.get_face_alignment_net(config)
if args.onnx_export:
torch_out = torch.onnx._export(model,
torch.rand(1, 3, config.IMAGE_SIZE),
osp.join(final_output_dir,
args.onnx_export),
export_params=True)
return
gpus = list(config.GPUS)
if gpus[0] > -1:
model = nn.DataParallel(model, device_ids=gpus).cuda()
# load model
if gpus[0] > -1:
state_dict = torch.load(args.model_file)
else:
state_dict = torch.load(args.model_file, map_location='cpu')
if 'state_dict' in state_dict.keys():
state_dict = state_dict['state_dict']
model.load_state_dict(state_dict)
else:
if gpus[0] > -1:
model.module.load_state_dict(state_dict)
else:
model.load_state_dict(state_dict)
dataset_type = get_dataset(config)
dataset = dataset_type(config, is_train=False)
test_loader = DataLoader(dataset=dataset,
batch_size=config.TEST.BATCH_SIZE_PER_GPU *
len(gpus),
shuffle=False,
num_workers=config.WORKERS,
pin_memory=config.PIN_MEMORY)
ipdb.set_trace()
nme, predictions = function.inference(config, test_loader, model)
torch.save(predictions, os.path.join(final_output_dir, 'predictions.pth'))
def main():
args = parse_args()
logger, final_output_dir, tb_log_dir = \
utils.create_logger(config, args.cfg, 'test')
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.determinstic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
# model = models.get_face_alignment_net(config)
model = eval('models.' + config.MODEL.NAME + '.get_face_alignment_net')(
config, is_train=True)
gpus = list(config.GPUS)
model = nn.DataParallel(model, device_ids=gpus).cuda()
# load model
# state_dict = torch.load(args.model_file)
# if 'state_dict' in state_dict.keys():
# state_dict = state_dict['state_dict']
# model.load_state_dict(state_dict)
# else:
# model.module.load_state_dict(state_dict)
if args.model_file:
logger.info('=> loading model from {}'.format(args.model_file))
# model.load_state_dict(torch.load(args.model_file), strict=False)
model_state = torch.load(args.model_file)
model.module.load_state_dict(model_state.state_dict())
else:
model_state_file = os.path.join(final_output_dir, 'final_state.pth')
logger.info('=> loading model from {}'.format(model_state_file))
model_state = torch.load(model_state_file)
model.module.load_state_dict(model_state)
dataset_type = get_dataset(config)
test_loader = DataLoader(dataset=dataset_type(config, is_train=False),
batch_size=config.TEST.BATCH_SIZE_PER_GPU *
len(gpus),
shuffle=False,
num_workers=config.WORKERS,
pin_memory=config.PIN_MEMORY)
nme, predictions = function.inference(config, test_loader, model)
torch.save(predictions, os.path.join(final_output_dir, 'predictions.pth'))
def main():
args = parse_args()
logger, final_output_dir, tb_log_dir = \
utils.create_logger(config, args.cfg, 'test')
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.determinstic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
model = models.get_face_alignment_net(config)
gpus = list(config.GPUS)
model = nn.DataParallel(model, device_ids=gpus).cuda()
# load model
#state_dict = torch.load(args.model_file)
#if 'state_dict' in state_dict.keys():
# state_dict = state_dict['state_dict']
# model.load_state_dict(state_dict)
#else:
# model.module.load_state_dict(state_dict)
model = torch.load(args.model_file)
model.eval()
model = nn.DataParallel(model, device_ids=gpus).cuda()
dataset_type = get_dataset(config)
test_loader = DataLoader(dataset=dataset_type(config, is_train=False),
batch_size=config.TEST.BATCH_SIZE_PER_GPU *
len(gpus),
shuffle=False,
num_workers=config.WORKERS,
pin_memory=config.PIN_MEMORY)
nme, predictions = function.inference(config, test_loader, model)
import cv2
img = cv2.imread('data/wflw/images/my3.jpg')
print(predictions, predictions.shape)
for item in predictions[0]:
cv2.circle(img, (item[0], item[1]), 3, (0, 0, 255), -1)
cv2.imwrite('out.png', img)
torch.save(predictions, os.path.join(final_output_dir, 'predictions.pth'))
def main():
args = parse_args()
logger, final_output_dir, tb_log_dir = \
utils.create_logger(config, args.cfg, 'test')
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.determinstic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
model = models.get_face_alignment_net(config)
gpus = list(config.GPUS)
if torch.cuda.is_available():
model = nn.DataParallel(model, device_ids=gpus).cuda()
# load model
state_dict = torch.load(args.model_file)
else:
# model = nn.DataParallel(model)
state_dict = torch.load(args.model_file,
map_location=lambda storage, loc: storage)
if 'state_dict' in state_dict.keys():
state_dict = state_dict['state_dict']
model.load_state_dict(state_dict)
else:
try:
model.module.load_state_dict(state_dict.state_dict())
except AttributeError:
state_dict ## remove first seven
model.load_state_dict(state_dict)
dataset_type = get_dataset(config)
test_loader = DataLoader(dataset=dataset_type(config, is_train=False),
batch_size=config.TEST.BATCH_SIZE_PER_GPU *
len(gpus),
shuffle=False,
num_workers=config.WORKERS,
pin_memory=config.PIN_MEMORY)
#nme, predictions = function.inference(config, test_loader, model, args.model_file) #### testing
function.test(config, test_loader, model, args.model_file) #### testing
def main():
args = parse_args()
logger, final_output_dir, tb_log_dir = \
utils.create_logger(config, args.cfg, 'test')
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.determinstic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
model = torchvision.models.resnet101(pretrained=config.MODEL.PRETRAINED,
progress=True)
num_ftrs = model.fc.in_features
model.fc = torch.nn.Linear(num_ftrs, config.MODEL.OUTPUT_SIZE[0])
gpus = list(config.GPUS)
model = nn.DataParallel(model, device_ids=gpus).cuda()
# load model
state_dict = torch.load(args.model_file)
if 'state_dict' in state_dict.keys():
state_dict = state_dict['state_dict']
model.load_state_dict(state_dict)
else:
model.module.load_state_dict(state_dict)
dataset_type = get_dataset(config)
test_loader = DataLoader(dataset=dataset_type(config, is_train=False),
batch_size=config.TEST.BATCH_SIZE_PER_GPU *
len(gpus),
shuffle=False,
num_workers=config.WORKERS,
pin_memory=config.PIN_MEMORY)
predictions = function.inference(config, test_loader, model)
torch.save(predictions, os.path.join(final_output_dir, 'predictions.pth'))
def main_300w():
args = parse_args()
logger, final_output_dir, tb_log_dir = \
utils.create_logger(config, args.cfg, 'test')
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.determinstic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
model = models.get_face_alignment_net(config)
dataset_type = get_dataset(config)
dataset = dataset_type(config, is_train=False)
fp = open('data/300w/face_landmarks70_300w_test.csv', 'w')
for i in range(len(dataset)):
# ipdb.set_trace()
img, fname, meta = dataset[i]
filename = osp.join('data/300w/xximages', fname)
if not osp.exists(osp.dirname(filename)):
os.makedirs(osp.dirname(filename))
scale = meta['scale']
center = meta['center']
tpts = meta['tpts']
selpts = []
for j in range(0, 68):
selpts.append(tpts[j])
selpts.append(tpts[36:42].mean(0))
selpts.append(tpts[42:48].mean(0))
fp.write('%s,%.2f,%.1f,%.1f' % (fname, scale, center[0], center[1]))
for spt in selpts:
img = cv2.circle(img, (spt[0], spt[1]), 1 + center[0] // 400,
(255, 0, 0))
fp.write(',%f,%f' % (spt[0], spt[1]))
fp.write('\n')
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
cv2.imwrite(filename, img)
fp.close()
def __init__(self, config=config):
config.defrost()
config.merge_from_file(
"ext/HRNet-Facial-Landmark-Detection/experiments/wflw/face_alignment_wflw_hrnet_w18.yaml"
)
config.freeze()
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.determinstic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
self.model = models.get_face_alignment_net(config)
state_dict = torch.load(
"ext/HRNet-Facial-Landmark-Detection/hrnetv2_pretrained/HR18-WFLW.pth"
)
self.model.load_state_dict(state_dict, strict=False)
gpus = list(config.GPUS)
self.model = nn.DataParallel(self.model, device_ids=gpus).cuda()
def main():
# Step 1: load model
args = parse_args()
logger, final_output_dir, tb_log_dir = \
utils.create_logger(config, args.cfg, 'test')
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.determinstic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
model = models.get_face_alignment_net(config)
gpus = list(config.GPUS)
model = nn.DataParallel(model, device_ids=gpus).cuda()
# load model
state_dict = torch.load(args.model_file)
if 'state_dict' in state_dict.keys():
state_dict = state_dict['state_dict']
model.load_state_dict(state_dict)
else:
model.module.load_state_dict(state_dict)
# Step 2: detect face and predict landmark
transform = transforms.Compose([transforms.ToTensor()])
cap = cv2.VideoCapture(0)
while True:
ret, img = cap.read()
if not ret: break
height, width = img.shape[:2]
bounding_boxes, landmarks = detect_faces(img)
dataset = get_preprocess(config)
# print('--------bboxes: ', bounding_boxes)
for box in bounding_boxes:
# x1, y1, x2, y2, _ = list(map(int, box))
score = box[4]
x1, y1, x2, y2 = (box[:4] + 0.5).astype(np.int32)
w = x2 - x1 + 1
h = y2 - y1 + 1
size = int(max([w, h]) * 1.3)
cx = x1 + w // 2
cy = y1 + h // 2
x1 = cx - size // 2
x2 = x1 + size
y1 = cy - size // 2
y2 = y1 + size
dx = max(0, -x1)
dy = max(0, -y1)
x1 = max(0, x1)
y1 = max(0, y1)
edx = max(0, x2 - width)
edy = max(0, y2 - height)
x2 = min(width, x2)
y2 = min(height, y2)
cropped = img[y1:y2, x1:x2]
if (dx > 0 or dy > 0 or edx > 0 or edy > 0):
cropped = cv2.copyMakeBorder(cropped, dy, edy, dx, edx,
cv2.BORDER_CONSTANT, 0)
# center_w = (x1+x2)/2
# center_h = (y1+y2)/2
# center = torch.Tensor([center_w, center_h])
# input = img[y1:y2, x1:x2, :]
# input = dataset._preprocessing(dataset, img=img, center=center, scale=1.0)
landmarks = get_lmks_by_img(model, cropped)
img = cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
for (x, y) in landmarks.astype(np.int32):
cv2.circle(img, (x1 + x, y1 + y), 2, (255, 255, 255))
cv2.imshow('0', img)
if cv2.waitKey(10) == 27:
break
def main():
#
args = parse_args()
#
logger, final_output_dir, tb_log_dir = \
utils.create_logger(config, args.cfg, 'test')
#
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
#
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.determinstic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
#
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
model = models.get_face_alignment_net(config)
#
gpus = list(config.GPUS)
#
# # load model
state_dict = torch.load(args.model_file)
if 'state_dict' in state_dict.keys():
state_dict = state_dict['state_dict']
model.load_state_dict(state_dict)
else:
model.module.load_state_dict(state_dict)
model = nn.DataParallel(model, device_ids=gpus).cuda()
#
dataset_type = get_dataset(config)
test_loader = DataLoader(dataset=dataset_type(config, is_train=False),
batch_size=config.TEST.BATCH_SIZE_PER_GPU *
len(gpus),
shuffle=False,
num_workers=config.WORKERS,
pin_memory=config.PIN_MEMORY)
nme, predictions = function.inference(config, test_loader, model)
torch.save(predictions, os.path.join(final_output_dir, 'predictions.pth'))
target = test_loader.dataset.load_all_pts()
pred = 16 * predictions
l = len(pred)
res = 0.0
res_tmp = [0.0 for i in range(config.MODEL.NUM_JOINTS)]
res_tmp = np.array(res_tmp)
res_temp_x = target - pred
res_temp_x = res_temp_x[:, :, 0]
res_temp_y = target - pred
res_temp_y = res_temp_y[:, :, 1]
# csv_file_test_x = pd.DataFrame(np.transpose(np.array(pred[:, :, 0])), columns=test_loader.dataset.annotation_files)
# csv_file_test_y = pd.DataFrame(np.transpose(np.array(pred[:, :, 1])), columns=test_loader.dataset.annotation_files)
# csv_file_target_x = pd.DataFrame(np.transpose(np.array(target[:, :, 0])), columns=test_loader.dataset.annotation_files)
# csv_file_target_y = pd.DataFrame(np.transpose(np.array(target[:, :, 1])), columns=test_loader.dataset.annotation_files)
for i in range(l):
trans = np.sqrt(
pow(target[i][0][0] - target[i][1][0], 2) +
pow(target[i][0][1] - target[i][1][1], 2)) / 30.0
res_temp_x[i] = res_temp_x[i] / trans
res_temp_y[i] = res_temp_y[i] / trans
for j in range(len(target[i])):
dist = np.sqrt(
np.power((target[i][j][0] - pred[i][j][0]), 2) +
np.power((target[i][j][1] - pred[i][j][1]), 2)) / trans
res += dist
res_tmp[j] += dist
res_t = np.sqrt(res_temp_x * res_temp_x + res_temp_y * res_temp_y)
# pd.DataFrame(data=res_temp_x.data.value).to_csv('res_x')
# pd.DataFrame(data=res_temp_y.data.value).to_csv('res_y')
# pd.DataFrame(data=res_t.data.value).to_csv('res_t')
res_tmp /= np.float(len(pred))
print(res_tmp)
print(np.mean(res_tmp))
res /= (len(pred) * len(pred[0]))
print(res)
def main():
args = parse_args()
logger, final_output_dir, tb_log_dir = \
utils.create_logger(config, args.cfg, 'test')
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
# cudnn.benchmark = config.CUDNN.BENCHMARK
# cudnn.determinstic = config.CUDNN.DETERMINISTIC
# cudnn.enabled = config.CUDNN.ENABLED
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
model = models.get_face_alignment_net(config)
gpus = list(config.GPUS)
# model = nn.DataParallel(model, device_ids=gpus).cuda()
model.to("cuda")
# print(model)
# load model
# state_dict = torch.load(args.model_file)
# print(state_dict)
# model = torch.load(args.model_file)
with open(args.model_file, "rb") as fp:
state_dict = torch.load(fp)
model.load_state_dict(state_dict)
# model.load_state_dict(state_dict['state_dict'])
# if 'state_dict' in state_dict.keys():
# state_dict = state_dict['state_dict']
# # print(state_dict)
# model.load_state_dict(state_dict)
# else:
# model.module.load_state_dict(state_dict)
dataset_type = get_dataset(config)
test_loader = DataLoader(
dataset=dataset_type(config,
is_train=False),
batch_size=config.TEST.BATCH_SIZE_PER_GPU*len(gpus),
shuffle=False,
num_workers=config.WORKERS,
pin_memory=config.PIN_MEMORY
)
predictions = function.inference(config, test_loader, model)
# print("len(predictions)", len(predictions))
# print(predictions[0])
df_predictions = []
for pred in predictions:
row = dict()
row['file_name'] = pred[0]
for id_point in range(194):
row[f'Point_M{id_point}_X'] = int(pred[1][id_point])
row[f'Point_M{id_point}_Y'] = int(pred[2][id_point])
df_predictions.append(row)
df_predictions = pd.DataFrame(df_predictions)
# print(predictions_meta[0])
df_predictions.to_csv('pred_test.csv', index=False)
def main_wflw():
args = parse_args()
logger, final_output_dir, tb_log_dir = \
utils.create_logger(config, args.cfg, 'test')
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.determinstic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
config.defrost()
config.MODEL.INIT_WEIGHTS = False
config.freeze()
model = models.get_face_alignment_net(config)
dataset_type = get_dataset(config)
dataset = dataset_type(config, is_train=True)
fp = open('data/wflw/face_landmarks70_wflw_train.csv', 'w')
for i in range(len(dataset)):
img, image_path, meta = dataset[i]
fold, name = image_path.split('/')[-2], image_path.split('/')[-1]
folder = osp.join('data/wflw/xximages', fold)
if not osp.exists(folder):
os.makedirs(folder)
fname = osp.join(folder, name)
scale = meta['scale']
center = meta['center']
tpts = meta['tpts']
selpts = []
for j in range(0, 33, 2):
selpts.append(tpts[j])
# eyebow
selpts.append(tpts[33])
selpts.append((tpts[34] + tpts[41]) / 2)
selpts.append((tpts[35] + tpts[40]) / 2)
selpts.append((tpts[36] + tpts[39]) / 2)
selpts.append((tpts[37] + tpts[38]) / 2)
selpts.append((tpts[42] + tpts[50]) / 2)
selpts.append((tpts[43] + tpts[49]) / 2)
selpts.append((tpts[44] + tpts[48]) / 2)
selpts.append((tpts[45] + tpts[47]) / 2)
selpts.append(tpts[46])
# nose
for j in range(51, 60):
selpts.append(tpts[j])
# eye
selpts.append(tpts[60])
selpts.append((tpts[61] + tpts[62]) / 2)
selpts.append(tpts[63])
selpts.append(tpts[64])
selpts.append(tpts[65])
selpts.append((tpts[66] + tpts[67]) / 2)
selpts.append(tpts[68])
selpts.append(tpts[69])
selpts.append((tpts[70] + tpts[71]) / 2)
selpts.append(tpts[72])
selpts.append((tpts[73] + tpts[74]) / 2)
selpts.append(tpts[75])
for j in range(76, 98):
selpts.append(tpts[j])
fp.write('%s,%.2f,%.1f,%.1f' %
(osp.join(fold, name), scale, center[0], center[1]))
for spt in selpts:
cv2.circle(img, (spt[0], spt[1]), 1, (0, 0, 255))
fp.write(',%f,%f' % (spt[0], spt[1]))
fp.write('\n')
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
cv2.imwrite(fname, img)
fp.close()