def __call__(self, image):
image = F.resize(image, 256)
gray = np.array(F.to_grayscale(image))
detections = self.bounding_boxes(gray)
if not detections:
return self.no_glasses_image
face_rect = detections[0].rect
aligned_face = self.aligner.align(opencv2matplotlib(np.array(image)),
gray, face_rect)
return opencv2matplotlib(aligned_face)
def show_labels(labeled_img, labels_im, masked):
fig, axes = plt.subplots(1, 3, figsize=(18, 10))
axes = axes.reshape(-1, )
axes[0].imshow(imutils.opencv2matplotlib(labeled_img))
axes[0].set_title("hue ordered labels")
cm, axes[1], cmap = discrete_matshow(labels_im, axes[1])
_ = fig.colorbar(cm,
ticks=np.arange(np.min(labels_im),
np.max(labels_im) + 1),
ax=axes[1])
axes[2].imshow(imutils.opencv2matplotlib(masked))
axes[2].set_axis_off()
axes[2].set_title("Masked")
plt.show()
def auto_canny(img_path):
img = cv2.imread(img_path, 0)
img_canny = imutils.auto_canny(img)
img_skeleton = imutils.skeletonize(img, size=(3, 3))
plt.subplot(131)
plt.imshow(imutils.opencv2matplotlib(img_canny))
plt.axis('off')
plt.subplot(132)
plt.imshow(imutils.opencv2matplotlib(img))
plt.axis('off')
plt.subplot(133)
plt.imshow(imutils.opencv2matplotlib(img_skeleton))
plt.axis('off')
plt.show()
def main():
client = get_mqtt_client()
# if MQTT_USER != "" and MQTT_PWD != "":
client.username_pw_set(MQTT_USER, MQTT_PWD)
client.connect(MQTT_BROKER, port=MQTT_PORT)
time.sleep(4) # Wait for connection setup to complete
client.loop_start()
# Open camera
camera = WebcamVideoStream(src=VIDEO_SOURCE).start()
# time.sleep(2) # Webcam light should come on if using one
while True:
frame = camera.read()
font = cv2.FONT_HERSHEY_SIMPLEX
datet = datetime.datetime.now().strftime("%d.%m.%Y, %H:%M:%S")
frame = cv2.putText(frame, datet, (10, 20), font, 0.7, (255, 255, 255),
1, cv2.LINE_AA)
# cv2.imshow('frame', frame)
np_array_RGB = opencv2matplotlib(frame) # Convert to RGB
image = Image.fromarray(np_array_RGB) # PIL image
byte_array = pil_image_to_byte_array(image)
client.publish(MQTT_TOPIC_CAMERA, byte_array, qos=MQTT_QOS)
now = get_now_string()
print(f"published frame on topic: {MQTT_TOPIC_CAMERA} at {now}")
def hue_map(ax):
# creating hue map
map_hsv = np.tile(np.arange(180), 200).reshape(-1, 180)
hmap = imshow_components(map_hsv)
ax.imshow(imutils.opencv2matplotlib(hmap))
ax.set_title("Hue Map")
return ax
def show_img(x, ax=None, figsize=(12, 13)):
gray = True if len(x.shape) == 2 else False
if ax is None: _, ax = plt.subplots(figsize=figsize)
if gray: ax.imshow(x, 'gray')
else: ax.imshow(imutils.opencv2matplotlib(x))
ax.set_axis_off()
return ax
def display_random_set(data, labels):
for i in range(10):
random_val = np.random.randint(low=0, high=len(data))
plt.subplot(2, 5, (i + 1))
plt.imshow(imutils.opencv2matplotlib(data[random_val]))
plt.title(labels[random_val])
plt.axis(False)
plt.show()
def work_thread(cam=0, pData=0, nDataSize=0):
stFrameInfo = MV_FRAME_OUT_INFO_EX()
memset(byref(stFrameInfo), 0, sizeof(stFrameInfo))
while True:
ret = cam.MV_CC_GetOneFrameTimeout(byref(data_buf), nPayloadSize,
stDeviceList, 1000)
if ret == 0:
print("get one frame: Width[%d], Height[%d], nFrameNum[%d]" %
(stDeviceList.nWidth, stDeviceList.nHeight,
stDeviceList.nFrameNum))
nRGBSize = stDeviceList.nWidth * stDeviceList.nHeight * 3
stConvertParam = MV_CC_PIXEL_CONVERT_PARAM()
memset(byref(stConvertParam), 0, sizeof(stConvertParam))
stConvertParam.nWidth = stDeviceList.nWidth
stConvertParam.nHeight = stDeviceList.nHeight
stConvertParam.pSrcData = data_buf
stConvertParam.nSrcDataLen = stDeviceList.nFrameLen
stConvertParam.enSrcPixelType = stDeviceList.enPixelType
stConvertParam.enDstPixelType = PixelType_Gvsp_RGB8_Packed
stConvertParam.pDstBuffer = (c_ubyte * nRGBSize)()
stConvertParam.nDstBufferSize = nRGBSize
ret = cam.MV_CC_ConvertPixelType(stConvertParam)
if ret != 0:
print("convert pixel fail! ret[0x%x]" % ret)
del data_buf
sys.exit()
# file_path = "AfterConvert_RGB.raw"
# file_open = open(file_path.encode('ascii'), 'wb+')
try:
img_buff = (c_ubyte * stConvertParam.nDstLen)()
cdll.msvcrt.memcpy(byref(img_buff), stConvertParam.pDstBuffer,
stConvertParam.nDstLen)
aa = np.frombuffer(img_buff,
dtype=np.uint8,
count=-1,
offset=0)
b = np.max(aa)
c = np.min(aa)
resized = aa.reshape(
(stConvertParam.nHeight, stConvertParam.nWidth, 3))
# resized = imutils.resize(aa, width=1280)
# img = imutils.resize(aa,width=stConvertParam.nWidth )
cv2.imwrite("2222.png", resized)
cv2.imshow('', imutils.opencv2matplotlib(resized))
cv2.waitKey()
# file_open.write(img_buff)
except:
raise Exception("save file executed failed:%s" % e.message)
# finally:
# file_open.close()
else:
print("get one frame fail, ret[0x%x]" % ret)
print("convert pixeltype succeed!")
def read_a_pic_reconstruct_slim(pic_path, imageheight, imagewidth):
img = cv2.imread(pic_path)
img = image_preprocess.preprocess_for_test(img, imageheight, imagewidth)
img = imutils.opencv2matplotlib(img)
img_list = []
img = list(img)
img_list.append(img)
# pic_base = os.path.basename(pic_path)
return img_list
def plot_images(images, names, figsize=[15, 10], rows=1, cols=None):
plt.figure(figsize=figsize)
for i, (name, img) in enumerate(zip(names, images)):
if len(img.shape) == 3:
img = imutils.opencv2matplotlib(img)
if cols is None:
cols = len(images) // rows
plt.subplot(rows, cols, i + 1)
plt.imshow(img, cmap='gray')
plt.title(name)
plt.show()
def plot3DHist(image):
''' Draw a histogram for the 3 channels'''
hist = cv2.calcHist([image], [0, 1, 2],
None, [8, 8, 8], [0, 256, 0, 256, 0, 256])
print("3D histogram shape: {}, with {} values".format(
hist.shape, hist.flatten().shape[0]))
''' display the original input image '''
plt.figure()
plt.axis("off")
plt.imshow(imutils.opencv2matplotlib(image))
plt.show()
def getSoftmax(image_filepath):
import cv2
import numpy as np
image = imutils.opencv2matplotlib(cv2.imread(image_filepath))
image = image_preprocessing_fn(image, 224, 224)
image = image.eval(session=sess)
result_feature = sess.run('resnet_v1_50/predictions/Softmax:0',
feed_dict={'input:0': [image]})
return np.ravel(result_feature)
def getFeature(image_filepath):
img = cv2.imread(image_filepath)
if img is not None:
image = imutils.opencv2matplotlib(img)
image = sess.run(image_preprocessing, feed_dict={'img:0': image})
result_feature = sess.run("resnet_v1_50/pool5:0",
feed_dict={'input:0': [image]})
return np.ravel(result_feature)
else:
return None
def orb_similarities(
file1,
file2,
show_matches=False
): # return similarity (matching rate) between iPenvmg1 and img2
method = 'ORB' # 'SIFT'
lowe_ratio = 0.89
img1 = cv2.imread(os.path.join(file1), cv2.IMREAD_GRAYSCALE)
img2 = cv2.imread(os.path.join(file2), cv2.IMREAD_GRAYSCALE)
size = (img1.shape[1], img1.shape[0])
img2 = cv2.resize(img2, size, interpolation=cv2.INTER_AREA)
# -- Traitement ---
# Find keypoints with ORB
finder = cv2.ORB_create()
kp1, des1 = finder.detectAndCompute(img1, None)
kp2, des2 = finder.detectAndCompute(img2, None)
# create BFMatcher object
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
# Match descriptors.
matches = bf.match(des1, des2)
# Sort them in the order of their distance.
matches = sorted(matches, key=lambda x: x.distance)
result_img = imu.opencv2matplotlib(
cv2.drawMatches(img1, kp1, img2, kp2, matches, None, flags=2))
# Compute matching rate
mr = 1 / (1 + np.mean(list(m.distance for m in matches)))
if (show_matches):
fig, ax = plt.subplots(ncols=1)
ax.imshow(result_img)
ax.set_title('Query_img vs. database_img')
plt.show()
'''
fig, ax = plt.subplots()
im=ax.imshow(result_img)
tit=ax.set_title ('Query_img vs. database_img')
'''
return mr
#EndRegion
def read_a_pic_reconstruct_slim(pic_path, dim):
img = cv2.imread(pic_path)
train_image_size = utils.global_var._RESIZE_SIDE_MIN
img = data_preprocessing.image_preprocess.preprocess_for_test(
img, train_image_size, train_image_size)
img = imutils.opencv2matplotlib(img)
img_list = []
img = list(img)
img_list.append(img)
pic_base = os.path.basename(pic_path)
items = pic_base.split('_')
if len(items) > 2:
label = utils.data_helper.num2label(int(items[1]), dim)
labels = []
labels.append(label)
else:
labels = np.zeros([1, dim], dtype=np.float32)
return img_list, labels
def detect_demo():
""" 图像检测器 """
yolov5_detector = YOLOv5Detector(weights='weights/yolov5s.pt', conf_thres=0.25)
window_name = 'YOLOv5 detector'
while True:
im = ImageGrab.grab(bbox=(0, 0, 600, 800))
frame = np.array(im)
image_result, bbox_container = yolov5_detector(frame)
for info in bbox_container:
print(info)
print('---')
""" 显示图像 """
cv2.imshow(window_name, imutils.opencv2matplotlib(image_result))
cv2.waitKey(1)
""" 点 x 退出 """
if cv2.getWindowProperty(window_name, cv2.WND_PROP_AUTOSIZE) < 1:
break
cv2.destroyAllWindows()
def main():
model = GlassesClassifier()
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
model.load_state_dict(torch.load('checkpoint.pt', map_location=device))
model.train(False)
align = FaceAlignTransform(
detector_model='mmod_human_face_detector.dat',
shape_predictor='shape_predictor_5_face_landmarks.dat')
tensorize = ToTensor()
winname = 'Am I wearing eyeglasses?'
cv2.namedWindow(winname)
vc = cv2.VideoCapture(0)
vc.set(cv2.CAP_PROP_FPS, 60)
rval, frame = vc.read()
while True:
if frame is not None:
frame = cv2.resize(frame, (320, 180))
image = opencv2matplotlib(frame)
bboxes = align.bounding_boxes(
cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY))
image = Image.fromarray(image)
image = tensorize(align(image))
image = image.unsqueeze(0)
pred = model.forward(image)
_, labels = torch.max(pred.data, 1)
if labels.item() == 1:
put_text(frame, BOTTOM_LEFT_CORNER, 'Yes!')
else:
put_text(frame, BOTTOM_LEFT_CORNER, 'No...')
for bbox in bboxes:
(x, y, w, h) = face_utils.rect_to_bb(bbox.rect)
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
cv2.imshow(winname, frame)
rval, frame = vc.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
def main():
client = get_mqtt_client()
client.connect(MQTT_BROKER, port=MQTT_PORT)
time.sleep(4) # Wait for connection setup to complete
client.loop_start()
# Open camera
camera = WebcamVideoStream(src=VIDEO_SOURCE).start()
time.sleep(2) # Webcam light should come on if using one
while True:
frame = camera.read()
np_array_RGB = opencv2matplotlib(frame) # Convert to RGB
image = Image.fromarray(np_array_RGB) # PIL image
byte_array = pil_image_to_byte_array(image)
client.publish(MQTT_TOPIC_CAMERA, byte_array, qos=MQTT_QOS)
now = get_now_string()
print(f"published frame on topic: {MQTT_TOPIC_CAMERA} at {now}")
time.sleep(1 / FPS)
def main():
classes = ['mask_weared_incorrect', 'with_mask', 'without_mask']
model = load_model('./mask_status.h5')
cascade_classifier = cv2.CascadeClassifier('./cascade_classifier/haarcascade_frontalface_alt2.xml')
for img in os.listdir('./Test/'):
img_path = './Test/' + img
img = cv2.imread(img_path)
face_coords = get_faces_coords(img=img, classifier=cascade_classifier)
for face in face_coords:
x, y, w, h = face
roi = img[y:y+h, x:x+w] / 255
prediction = get_prediction(face=roi, model=model)
prediction = classes[np.argmax(prediction)]
if prediction == 'with_mask':
color = (0, 255, 0)
else:
color = (0, 0, 255)
cv2.rectangle(img, pt1=(x, y), pt2=(x+w, y+h), color=color, thickness=2)
cv2.putText(img=img, text=prediction, org=(x, y), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=1, color=color, thickness=2)
plt.imshow(imutils.opencv2matplotlib(img))
plt.show()
def change_format(image_path):
global image_sum, now_number, last_time, last_number
nature_image_path = image_path
image_path = image_path.replace(base_path, save_path)
image_path = image_path.replace(na_format, af_format)
if os.path.exists(image_path) is False:
file_tools.check_fold(file_tools.getFloderOfFileJustPath(image_path))
img = cv2.imread(nature_image_path)
if img is not None:
img = Image.fromarray(
imutils.opencv2matplotlib(cv2.resize(img, (1024, 1024))))
img.save(image_path)
else:
if os.path.exists(nature_image_path) is False:
print '无法读取webp文件(文件不存在)...%s' % nature_image_path
else:
print '无法读取webp文件...%s' % nature_image_path
now_number += 1
if now_number % 100 == 0:
print '正在进行转换...%d/%d(%.2f/sec)' % (now_number, image_sum,
(float(now_number - last_number) /
(time.time() - last_time)))
last_number = now_number
last_time = time.time()
def save_results(image_name, image, image_horizon, image_sun, horizon_flag,
sun_flag, daytime):
# fill result pdf file
content = []
output_file_name = image_name[:-4] + '.pdf'
output_file = PdfPages(output_file_name)
# adjust spacing
plt.subplots_adjust(left=None,
bottom=None,
right=None,
top=1,
wspace=1,
hspace=None)
# build content for result pdf
# [image, image_title, image_text]
# main page
text = 'Image \"' + image_name + '\" processing'
content.append([image, None, text])
# conditions page
text = 'Conditions: ' + daytime
content.append([image, text, None])
# horizon page
text = 'horizon detected' if horizon_flag else 'horizon line is unclear'
content.append([image_horizon, text, None])
# sun page
if daytime != 'nighttime':
text = 'sun located' if sun_flag else 'no sun spot located'
content.append([image_sun, text, None])
# save result into pdf format
for item in content:
fig = plt.figure()
ax = fig.add_subplot(111)
# if title present
if item[2]:
fig.suptitle(item[2], fontsize=12, fontweight='bold')
# if text present
if item[1]:
ax.text(image.shape[1] * 2.5,
image.shape[0],
item[1],
style='italic',
bbox={
'facecolor': 'orange',
'alpha': 0.5,
'pad': 5
})
plt.imshow(imutils.opencv2matplotlib(item[0]))
fig.tight_layout()
plt.axis('off')
output_file.savefig()
output_file.close()
# save result into image format
png_filename = image_name[:-4] + '_processed.png'
res_img = image
for item in content:
# if text present
if item[1]:
image_add = put_text(item[0], item[1])
res_img = np.concatenate((res_img, image_add), axis=0)
# plt.imshow(imutils.opencv2matplotlib(res_img))
cv2.imwrite(png_filename, res_img)
print 'check', output_file_name, 'or', png_filename, 'for results'
def plt_imshow_bgr(image):
plt.imshow(imutils.opencv2matplotlib(image))
plt.show()
def dataSynchronization(self, result, img_list, model, alarm_type, Zone,
Channel, device_id, pub, Polygon_list):
cls_dict = get_cls_dict(model.split('_')[-1])
vis = BBoxVisualization(cls_dict)
for i in range(len(result)):
boxes, confs, clss = result[i][0], result[i][1], result[i][2]
img, txt = vis.draw_bboxes(img_list[0][i], boxes, confs, clss)
alarm = str(txt).split(' ')[0]
print(alarm)
if alarm in COCO_CLASSES_LIST:
if alarm == 'fire':
np_array_RGB = opencv2matplotlib(img) # Convert to RGB
image = Image.fromarray(np_array_RGB) # PIL image
byte_array = pil_image_to_byte_array(image)
baseData = im_pb2.BaseData()
baseData.img = byte_array
baseData.app_id = Zone
baseData.channel_id = 'channel' + str(Channel)
baseData.fps = 20
baseData.timestamp = time.time()
self.last_fire_alarm_time = time.time()
baseData.alarm_type = 'Firesmoke'
self.last_fire_alarm_type = baseData.alarm_type
current_status = start_end_status(True,
self.fire_history_data,
baseData.timestamp, 15)
if current_status == 'start':
baseData.frame_id = time.strftime(
'%H%M%S', time.localtime(time.time()))
detectionCommonData = im_pb2.DetectionCommonData(
base_data=baseData)
detectionCommonDataDict = {}
detectionCommonDataDict[Zone] = detectionCommonData
result_data = im_pb2.GeneralDetectionMapData(
general_map_data=detectionCommonDataDict)
self.last_fire_topic_time = baseData.frame_id
print('topic_start')
pub.send_msg(topic='zs/' + Zone + '/' + 'channel' +
str(Channel) + '/' + 'Firesmoke' + '/out',
msg=result_data.SerializeToString(),
Zone=Zone,
device_id=device_id)
else:
slide_history(1, self.fire_history_data)
if alarm == 'person':
np_array_RGB = opencv2matplotlib(img) # Convert to RGB
image = Image.fromarray(np_array_RGB) # PIL image
byte_array = pil_image_to_byte_array(image)
baseData = im_pb2.BaseData()
baseData.img = byte_array
baseData.app_id = Zone
baseData.channel_id = 'channel' + str(Channel)
baseData.fps = 20
baseData.timestamp = time.time()
self.last_person_alarm_time = time.time()
baseData.alarm_type = 'Personnelfall'
self.last_person_alarm_type = baseData.alarm_type
current_status = start_end_status(True,
self.person_history_data,
baseData.timestamp, 15)
if current_status == 'start':
baseData.frame_id = time.strftime(
'%H%M%S', time.localtime(time.time()))
detectionCommonData = im_pb2.DetectionCommonData(
base_data=baseData)
detectionCommonDataDict = {}
detectionCommonDataDict[Zone] = detectionCommonData
result_data = im_pb2.GeneralDetectionMapData(
general_map_data=detectionCommonDataDict)
self.last_person_topic_time = baseData.frame_id
print('topic_start')
print(baseData.frame_id)
topic = 'zs/' + Zone + '/' + 'channel' + str(
Channel) + '/' + 'Personnelfall' + '/out'
print(topic)
pub.send_msg(topic='zs/' + Zone + '/' + 'channel' +
str(Channel) + '/' + 'Personnelfall' +
'/out',
msg=result_data.SerializeToString(),
Zone=Zone,
device_id=device_id)
else:
slide_history(1, self.person_history_data)
else:
slide_history(0, self.fire_history_data)
slide_history(0, self.person_history_data)
if self.last_person_alarm_time is not None:
current_status = start_end_status(
False, self.person_history_data,
self.last_person_alarm_time, 15)
if current_status == 'end':
self.last_person_alarm_time = None
end_topic(self.last_person_topic_time,
self.last_person_alarm_type, Zone, Channel,
device_id, pub)
if self.last_fire_alarm_time is not None:
current_status = start_end_status(
False, self.fire_history_data,
self.last_fire_alarm_time, 15)
if current_status == 'end':
self.last_fire_alarm_time = None
end_topic(self.last_fire_topic_time,
self.last_fire_alarm_type, Zone, Channel,
device_id, pub)
def show_matr(ax, matr):
ax.imshow(imutils.opencv2matplotlib(matr))
ax.set_axis_off()
ax.set_title("croped")
return ax
# skeletonize the image using a 3x3 kernel
cv2.imshow("Original", logo)
gray = cv2.cvtColor(logo, cv2.COLOR_BGR2GRAY)
skeleton = imutils.skeletonize(gray, size=(3, 3))
cv2.imshow("Skeleton", skeleton)
cv2.waitKey(0)
cv2.destroyAllWindows()
# 5. MATPLOTLIB
# INCORRECT: show the image without converting color spaces
plt.figure("Incorrect")
plt.imshow(cactus)
# CORRECT: convert color spaces before using plt.imshow
plt.figure("Correct")
plt.imshow(imutils.opencv2matplotlib(cactus))
plt.show()
# 6. URL TO IMAGE
# load an image from a URL, convert it to OpenCV, format, and
# display it
url = "http://pyimagesearch.com/static/pyimagesearch_logo_github.png"
logo = imutils.url_to_image(url)
cv2.imshow("URL to Image", logo)
cv2.waitKey(0)
cv2.destroyAllWindows()
# 7. AUTO CANNY
# convert the logo to grayscale and automatically detect edges
gray = cv2.cvtColor(logo, cv2.COLOR_BGR2GRAY)
edgeMap = imutils.auto_canny(gray)
def show(title, image):
plt.figure(title)
plt.imshow(opencv2matplotlib(image))
plt.show()
def show(title, image):
plt.figure(title)
plt.imshow(opencv2matplotlib(image))
plt.show()
def validate_input(img_in):
img = cv2.imread(img_in)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
resized = imutils.resize(gray, width=28)
plt.imshow(imutils.opencv2matplotlib(resized))
plt.show()
from PIL import Image
import cv2
import io
from imutils import opencv2matplotlib
image_path = '/home/mengjun/project/0.jpg'
def pil_image_to_byte_array(image):
imgByteArr = io.BytesIO()
image.save(imgByteArr, "PNG")
return imgByteArr.getvalue()
image = cv2.imread(image_path)
np_array_RGB = opencv2matplotlib(image) # Convert to RGB
image = Image.fromarray(np_array_RGB) # PIL image
byte_array = pil_image_to_byte_array(image)
#idx = 0 # 往paho/temperature 一直发送内容
while True:
print("send success")
publish.single(
"paho/temperature",
payload=byte_array,
hostname="localhost",
client_id="lora1",
# qos = 0,
# tls=tls,
port=1883,
protocol=mqtt.MQTTv311)
ax = fig.add_subplot(132)
hist = cv2.calcHist([chans[1], chans[2]], [0, 1], None, [32, 32],
[0, 256, 0, 256])
p = ax.imshow(hist, interpolation='nearest')
ax.set_title('2D Color Histogram for G and R')
plt.colorbar(p)
# plot 2D color histogram for blue and red
ax = fig.add_subplot(133)
hist = cv2.calcHist([chans[0], chans[2]], [0, 1], None, [32, 32],
[0, 256, 0, 256])
p = ax.imshow(hist, interpolation='nearest')
ax.set_title('2D Color Histogram for B and R')
plt.colorbar(p)
plt.show()
# examine the dimension of the 2D histogram
print('2D histogram shape: {}, with {} value'.format(hist.shape,
hist.flatten().shape[0]))
# 3D histogram
hist = cv2.calcHist([image], [0, 1, 2], None, [8, 8, 8],
[0, 256, 0, 256, 0, 256])
# display the original image with matplotlib
plt.figure()
plt.axis('off')
plt.imshow(imutils.opencv2matplotlib(image))
plt.show()
def process(self):
# Face shape related
face_alignment.extract_face_triangles(self)
face_alignment.warp_example(self)
face_alignment.make_masks(self)
# Makeup
makeup_utils.layer_decomposition(self)
makeup_utils.color_transfer(self)
makeup_utils.skin_detail_transfer(self)
makeup_utils.highlight_shading_transfer(self)
makeup_utils.lip_makeup(self)
self.subject_makeup_mask_lab = np.zeros_like(self.subject_image)
self.makeup_mask = self.entire_face_mask - self.eyes_mask - self.inner_mouth_mask
self.subject_makeup_mask_lab[:, :,
0] = self.face_structure_resultant + self.skin_detail_resultant
self.subject_makeup_mask_lab[:, :, 1:] = np.where(
cv.merge([self.lip_mask, self.lip_mask]) == 255,
self.subject_lip_makeup[:, :, 1:], cv.merge([self.rc_a,
self.rc_b]))
self.subject_makeup_mask_lab = cv.bitwise_and(
self.subject_makeup_mask_lab,
self.subject_makeup_mask_lab,
mask=self.makeup_mask)
self.subject_makeup_mask_bgr = cv.cvtColor(
self.subject_makeup_mask_lab, cv.COLOR_LAB2BGR)
self.subject_makeup = np.where(
cv.merge([self.makeup_mask, self.makeup_mask,
self.makeup_mask]) == 255, self.subject_makeup_mask_bgr,
self.subject_image)
# Blur boundaries
eroded_mask = cv.erode(self.entire_face_mask,
np.ones((1, 1), np.uint8),
iterations=2)
contours, _ = cv.findContours(eroded_mask, cv.RETR_TREE,
cv.CHAIN_APPROX_SIMPLE)
self.blurred_face_contour = np.zeros_like(eroded_mask)
cv.drawContours(self.blurred_face_contour, contours, -1, 255, 4)
subject_makeup_blurred = cv.GaussianBlur(self.subject_image, (9, 9), 0)
blurred_face_contour_boolean = (self.blurred_face_contour == 255)
self.subject_makeup[
blurred_face_contour_boolean] = subject_makeup_blurred[
blurred_face_contour_boolean]
# self.subject_makeup = cv.seamlessClone(self.subject_makeup_mask_bgr, self.subject_image, self.makeup_mask, (self.subject_image.shape[1]//2, self.subject_image.shape[0]//2), cv.MIXED_CLONE)
self.xdog_makeup_lab = cv.cvtColor(
cv.cvtColor(self.xdog, cv.COLOR_GRAY2BGR), cv.COLOR_BGR2LAB)
self.xdog_makeup_lab[:, :, 1:] = np.where(
cv.merge([self.makeup_mask, self.makeup_mask]) == 255,
self.subject_makeup_mask_lab[:, :, 1:], self.xdog_makeup_lab[:, :,
1:])
self.xdog_makeup_lab[:, :, 0] = np.where(
self.skin_mask == 255, 0.25 * self.face_structure_resultant +
0.75 * self.xdog_makeup_lab[:, :, 0], self.xdog_makeup_lab[:, :,
0])
self.xdog_makeup_lab[:, :, 0] = np.where(
self.lip_mask == 255, 0.75 * self.face_structure_resultant +
0.25 * self.xdog_makeup_lab[:, :, 0], self.xdog_makeup_lab[:, :,
0])
# self.xdog_makeup_lab[:,:,1:] = self.gamma*self.xdog_makeup_lab[:,:,1:]
self.xdog_makeup = cv.cvtColor(self.xdog_makeup_lab, cv.COLOR_LAB2BGR)
# Showcase
plt.subplot(2, 3, 1)
plt.imshow(opencv2matplotlib(self.subject_image))
plt.subplot(2, 3, 2)
plt.imshow(opencv2matplotlib(self.xdog_makeup))
plt.subplot(2, 3, 3)
plt.imshow(opencv2matplotlib(self.subject_makeup))
plt.subplot(2, 3, 5)
plt.imshow(opencv2matplotlib(self.example_image))
plt.show()
