iniit

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.task filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+files

.gradio/cached_examples/25/log.csv

@@ -0,0 +1,2 @@
+Output,timestamp
+"[{""image"": {""path"": "".gradio\\cached_examples\\25\\Output\\41d0a13d3c5d3c05accc\\00003245_00.webp"", ""url"": ""/gradio_api/file=C:\\Users\\owner\\AppData\\Local\\Temp\\gradio\\931aec3e3a5351edb4bba6660e3848db2c5b49fd47c1f07afe9f05213b87363b\\00003245_00.webp"", ""size"": null, ""orig_name"": ""00003245_00.webp"", ""mime_type"": null, ""is_stream"": false, ""meta"": {""_type"": ""gradio.FileData""}}, ""caption"": ""animation""}]",2024-11-16 16:03:27.862651

app.py

@@ -0,0 +1,232 @@
+import spaces
+import gradio as gr
+import subprocess
+from PIL import Image
+import json
+import os
+import time
+
+import mp_box
+import draw_landmarks68
+import landmarks68_utils
+import io
+import numpy as np
+
+from glibvision.cv2_utils import pil_to_bgr_image,bgr_to_rgb
+from gradio_utils import save_image,save_buffer,clear_old_files ,read_file
+from close_eyes import process_close_eyes_image
+from open_mouth import process_open_mouth
+'''
+Face landmark detection based Face Detection.
+https://ai.google.dev/edge/mediapipe/solutions/vision/face_landmarker
+from model card
+https://storage.googleapis.com/mediapipe-assets/MediaPipe%20BlazeFace%20Model%20Card%20(Short%20Range).pdf
+Licensed Apache License, Version 2.0
+Train with google's dataset(more detail see model card)
+
+'''
+
+#@spaces.GPU(duration=120)
+def process_images(image,eyelid_thick=1,eyelid_blur=9,inpaint_radius=10,inpaint_blur=30,mask_dilate=10,dilate_blur=10,
+                   open_size_y=8,inside_layer_low_depth=False,hole_image_name="dark01",
+                   make_animation=True,eyes_duration=200,mouth_duration=40,
+                   progress=gr.Progress(track_tqdm=True)):
+    clear_old_files()
+    if image == None:
+        raise gr.Error("Need Image")
+    
+    progress(0, desc="Start Making Animation")
+    boxes,mp_image,face_landmarker_result = mp_box.mediapipe_to_box(image)
+    annotated_image,bbox,landmark_points = draw_landmarks68.draw_landmarks_on_image(image,face_landmarker_result)
+    landmark_list = draw_landmarks68.convert_to_landmark_group_json(landmark_points)
+    
+
+    
+
+    galleries = []
+    
+    progressed = 0
+    progress_step = 0.8/open_size_y
+    animations = []
+    np_image = pil_to_bgr_image(image)
+    if make_animation:
+        start_index = 0
+    else:
+        start_index = open_size_y-1
+
+    for i in range(start_index,open_size_y):
+        mouth_opened = process_open_mouth(np_image,landmark_list,0,i,True,inside_layer_low_depth,0,hole_image_name+".jpg")
+        animations.append(mouth_opened)
+        mouth_opened_path = save_image(mouth_opened)
+        galleries.append((mouth_opened_path,f"mouth-opened {i}"))
+        progressed+=progress_step
+        progress(progressed)
+   
+    if make_animation:
+        np_image = pil_to_bgr_image(animations[0])# TODO option
+
+    eyes_closed_np,mask_np = process_close_eyes_image(np_image,landmark_list,eyelid_thick,eyelid_blur,inpaint_radius,inpaint_blur,mask_dilate,dilate_blur)
+    eyes_closed = Image.fromarray(bgr_to_rgb(eyes_closed_np))
+
+    eyes_closed_path = save_image(eyes_closed)
+    galleries.append((eyes_closed_path,"eyes-closed"))
+
+    eyes_closed_mask_path = save_image(Image.fromarray(mask_np))
+    galleries.append((eyes_closed_mask_path,"eyes-closed-mask"))
+    
+
+    duractions = [mouth_duration]*len(animations)*2+[eyes_duration]
+    if make_animation:
+        animations = animations  + animations[::-1]+[eyes_closed]
+    output_buffer = io.BytesIO()
+    animations[0].save(output_buffer, 
+                   save_all=True, 
+                   append_images=animations[1:], 
+                   duration=duractions, 
+                   loop=0, 
+                   format='WebP')
+    webp_path = save_buffer(output_buffer)
+    #galleries.append((webp_path,"animation"))
+    
+    return webp_path,galleries
+    
+
+
+
+css="""
+#col-left {
+    margin: 0 auto;
+    max-width: 640px;
+}
+#col-right {
+    margin: 0 auto;
+    max-width: 640px;
+}
+.grid-container {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap:10px
+}
+
+.image {
+  width: 128px; 
+  height: 128px; 
+  object-fit: cover; 
+}
+
+.text {
+  font-size: 16px;
+}
+"""
+
+#css=css,
+
+
+
+with gr.Blocks(css=css, elem_id="demo-container") as demo:
+    with gr.Column():
+        gr.HTML(read_file("demo_header.html"))
+        gr.HTML(read_file("demo_tools.html"))
+    with gr.Row():
+                with gr.Column():
+                    image = gr.Image(height=800,sources=['upload','clipboard'],image_mode='RGB',elem_id="image_upload", type="pil", label="Upload")
+                    with gr.Row(elem_id="prompt-container",  equal_height=False):
+                        with gr.Row():
+                            btn = gr.Button("Create Closed-eye and Mouth-opened", elem_id="run_button",variant="primary")
+                    
+                    with gr.Accordion(label="Eyes-Closed Advanced Settings", open=False):
+                        with gr.Row( equal_height=True):
+                            eyelid_thick = gr.Slider(
+                                label="Eyelid thick",
+                                minimum=0,
+                                maximum=20,
+                                step=1,
+                                value=1)
+                            eyelid_blur = gr.Slider(
+                                label="Eyelid blur",
+                                minimum=0,
+                                maximum=30,
+                                step=1,
+                                value=7)
+                        with gr.Row( equal_height=True):
+                            inpaint_radius = gr.Slider(
+                                label="Inpaint Radius",
+                                minimum=1,
+                                maximum=20,
+                                step=1,
+                                value=10,info="incresing make smooth but slow")
+                            inpaint_blur = gr.Slider(
+                                label="Inpaint blur",
+                                minimum=0,
+                                maximum=30,
+                                step=1,
+                                value=20)
+                        with gr.Row( equal_height=True):
+                            mask_dilate = gr.Slider(
+                                label="Mask dilate",
+                                minimum=0,
+                                maximum=20,
+                                step=1,
+                                value=10)
+                            
+                            dilate_blur = gr.Slider(
+                                label="dilate blur",
+                                minimum=0,
+                                maximum=20,
+                                step=1,
+                                value=10)
+                        with gr.Row( equal_height=True):
+                            eyes_duration = gr.Slider(
+                                label="Eyeclosed animation duration",
+                                minimum=1,
+                                maximum=500,
+                                step=1,
+                                value=200)
+                    with gr.Accordion(label="Mouth-Opened Advanced Settings", open=False):
+                         with gr.Row( equal_height=True):
+                            make_animation = gr.Checkbox(label="animation",value=True,info="take long time if open-size is large")
+                            open_size_y = gr.Slider(
+                                    label="Open Size",
+                                    minimum=1,
+                                    maximum=40,
+                                    step=1,
+                                    value=8,info="Large size is for img2img/inpaint")
+                            inside_layer_low_depth=gr.Checkbox(label="Inner Layer Low",value=False,info="if value >20 check on better result")
+                         
+                         hole_image_name=gr.Dropdown(label="inner image name",choices=["dark01","black","mid01","mid02"],value="dark01",info="if you use img2img black is better")
+                         with gr.Row( equal_height=True):
+                            mouth_duration = gr.Slider(
+                                label="mouhtopen animation duration",info="per frame",
+                                minimum=1,
+                                maximum=500,
+                                step=1,
+                                value=40)                    
+                with gr.Column():
+                    animation_out = gr.Image(height=760,label="Animation", elem_id="output-animation")
+                    image_out = gr.Gallery(label="Output", elem_id="output-img",preview=True)
+                    
+
+    btn.click(fn=process_images, inputs=[image,eyelid_thick,eyelid_blur,inpaint_radius,inpaint_blur,mask_dilate,dilate_blur,
+                                         open_size_y,inside_layer_low_depth,hole_image_name,make_animation,
+                                         eyes_duration,mouth_duration],outputs=[animation_out,image_out] ,api_name='infer')
+    gr.Examples(
+                examples =[
+                    ["examples/00003245_00.jpg","examples/00003245_00.webp"],
+                    ["examples/00002062.jpg","examples/00002062.webp"],
+                    ["examples/00100265.jpg","examples/00100265.webp"],
+                    ["examples/00824006.jpg","examples/00824006.webp"],
+                    ["examples/00824008.jpg","examples/00824008.webp"],
+                    ["examples/00825000.jpg","examples/00825000.webp"],
+                    ["examples/00826007.jpg","examples/00826007.webp"],
+                    ["examples/00827009.jpg","examples/00827009.webp"],
+                    ["examples/00828003.jpg","examples/00828003.webp"],
+                ],
+                #examples =["examples/00003245_00.jpg","examples/00002062.jpg","examples/00100265.jpg","examples/00824006.jpg","examples/00824008.jpg",
+                #           "examples/00825000.jpg","examples/00826007.jpg","examples/00827009.jpg","examples/00828003.jpg",],
+                inputs=[image,animation_out],examples_per_page=5
+    )
+    gr.HTML(read_file("demo_footer.html"))
+
+    if __name__ == "__main__":
+        demo.launch()

close_eyes.py

@@ -0,0 +1,120 @@
+
+"""
+close_eye.py
+
+
+目を閉じた画像を作ります。
+
+目と上まつ毛の部分をポイントとしており、そこをinpaintします。
+inpaint部分をぼかして、元の画像の上にはりつけ、ぼかします。
+
+
+
+著者: Akihito Miyazaki
+作成日: 2024-04-23
+更新履歴:
+  - 2024-04-23: 最初のリリース
+  - 2024-09-24: name suffixを追加
+  - 2034-11-15: changed for huggingface
+"""
+import os
+import cv2
+import numpy as np
+
+
+from glibvision.numpy_utils import bulge_polygon
+
+from glibvision.cv2_utils import fill_points,get_image_size,gray3d_to_2d,blend_rgb_images,create_color_image
+from landmarks68_utils import get_left_upper_eyelid_points,get_right_upper_eyelid_points,get_bulged_eyes,get_close_eyelid_point
+
+
+def create_eyelid_mask(image,face_landmarks_list,thick = 1,bulge=0.2):
+    black = create_color_image(image,(0,0,0))
+    left_eyelid = get_left_upper_eyelid_points(face_landmarks_list)
+    left_eyelid = bulge_polygon(left_eyelid,bulge)
+    fill_points(black,left_eyelid)
+
+    print("right")
+    right_eyelid = get_right_upper_eyelid_points(face_landmarks_list)
+    print(right_eyelid)    
+    right_eyelid = bulge_polygon(right_eyelid,bulge)
+    fill_points(black,right_eyelid)
+
+    eyes_points = get_bulged_eyes(face_landmarks_list)
+    for points in eyes_points:
+        np_points = np.array(points,dtype=np.int32)
+        cv2.fillPoly(image, [np_points], (255,255,255))
+        if thick > 0:
+            cv2.polylines(black, [np_points], isClosed=False, color=(255,255,255), thickness=thick)
+
+    return  cv2.cvtColor(black,cv2.COLOR_BGR2GRAY)
+
+DEBUG = False
+def process_close_eyes_image(img,landmarks_list,eyelid_thick=1,eyelid_blur=9,inpaint_radius=10,inpaint_blur=30,mask_dilate=10,dilate_blur=10):
+    img_h, img_w = get_image_size(img)
+
+    eyelid_mask = create_eyelid_mask(img,landmarks_list)
+    if DEBUG:
+        cv2.imwrite("close_eye_mask.jpg",eyelid_mask)
+
+    mask = gray3d_to_2d(eyelid_mask)
+ 
+
+    img_inpainted = cv2.inpaint(img, mask,inpaint_radius, cv2.INPAINT_TELEA)
+    if DEBUG:
+        cv2.imwrite("close_eye_inpaint.jpg",img_inpainted)
+
+    ## Inpaintした画像をぼかす。
+    if inpaint_blur>0:
+        if inpaint_blur%2==0:   #if even it would error
+            inpaint_blur+=1
+        blurred_image = cv2.GaussianBlur(img_inpainted, (inpaint_blur, inpaint_blur), 0)
+        if DEBUG:
+            cv2.imwrite("close_eye_inpaint_burred.jpg",blurred_image)
+    else:
+        blurred_image=img_inpainted
+   
+
+    # まつげを描く
+    if eyelid_thick>0:
+        left,right = get_close_eyelid_point(landmarks_list)
+        for points in [left,right]:
+            print("## draw eyelid")
+            print(points)
+            cv2.polylines(blurred_image, [np.array(points)], isClosed=False, color=(0,0,0), thickness=eyelid_thick,lineType=cv2.LINE_AA)
+        if DEBUG:
+            cv2.imwrite("close_eye_inpaint_burred_eyeline.jpg",blurred_image)
+
+
+
+
+    if eyelid_thick>0 and eyelid_blur>0:
+        if eyelid_blur%2==0:
+            eyelid_blur+=1
+        # blur-eyelid-line
+        blurred_image = cv2.GaussianBlur(blurred_image, (eyelid_blur, eyelid_blur), 2)
+
+
+    print(mask_dilate,dilate_blur)
+    if mask_dilate>0:
+        # Inpaintの境界線から少し広げている
+        kernel = np.ones((mask_dilate, mask_dilate), np.uint8)
+        extend_mask = cv2.dilate(mask, kernel, iterations=1)
+
+        if dilate_blur>0:
+            if dilate_blur%2==0:
+                dilate_blur+=1
+
+            extend_burred_mask = cv2.GaussianBlur(extend_mask, (dilate_blur, dilate_blur), 1)
+        else:
+            extend_burred_mask = extend_mask
+    else:
+        extend_burred_mask=mask
+
+    
+    img_inpainted = blend_rgb_images(img,blurred_image,extend_burred_mask)
+    
+    if DEBUG:
+        cv2.imwrite("create_no_mouth_image_merged.jpg",img_inpainted)
+
+    return img_inpainted,extend_burred_mask

close_lip.py

@@ -0,0 +1,150 @@
+
+"""
+close_lip.py
+
+
+唇を閉じた画像を作ります。
+
+唇の開いている範囲をinpaintします。
+そこに、hole部分を影として戻します。
+
+
+
+著者: Akihito Miyazaki
+作成日: 2024-04-23
+更新履歴:
+  - 2024-04-23: 最初のリリース
+  - 1024-11-16:coverted to huggingface-space (but args broken)
+"""
+import os
+import cv2
+import numpy as np
+from PIL import Image
+import lip_utils
+
+
+from glibvision.cv2_utils import blend_rgb_images
+from glibvision.numpy_utils import apply_binary_mask_to_color,create_2d_image
+
+import argparse
+
+
+
+
+
+def create_top_lip_low_mask(image,face_landmarks_list,line_thick = 1):
+    black = create_2d_image(image.shape)
+    lip_utils.fill_top_lower(black,face_landmarks_list,line_thick,lip_utils.COLOR_WHITE)
+    return  black
+
+def create_lip_hole_mask(image,face_landmarks_list,line_thick = 1):
+    black = create_2d_image(image.shape)
+    lip_utils.fill_lip_hole(black,face_landmarks_list,line_thick,lip_utils.COLOR_WHITE)
+
+    return  black
+
+def process_close_lip_image(img,landmarks_list):
+    img_h, img_w = lip_utils.get_image_size(img)
+
+    hole_mask = create_lip_hole_mask(img,landmarks_list,0)
+
+    lower_lip_mask = create_top_lip_low_mask(img,landmarks_list)
+
+    #these make dirty
+    #kernel = np.ones((3, 3), np.uint8)
+    #lower_lip_mask = cv2.erode(lower_lip_mask, kernel, iterations=1)
+
+
+    if lip_utils.DEBUG:
+        cv2.imwrite("close_lip_01_mask.jpg",lower_lip_mask)
+    
+    mixed_mask = cv2.bitwise_or(hole_mask,lower_lip_mask)
+    if lip_utils.DEBUG:
+        cv2.imwrite("close_lip_01_mask_mixed.jpg",mixed_mask)
+
+    img_inpainted = cv2.inpaint(img, mixed_mask,3, cv2.INPAINT_NS)
+    if lip_utils.DEBUG:
+        cv2.imwrite("close_lip_02_inpaint.jpg",img_inpainted)
+   
+
+    copy_impainted=img_inpainted.copy()
+    apply_binary_mask_to_color(copy_impainted,(0,8,50),hole_mask)
+    #lip_utils.fill_lip_hole(img_inpainted,landmarks_list,0,(0,8,50)) # BGR
+    if lip_utils.DEBUG:
+        cv2.imwrite("close_lip_03_hole.jpg",copy_impainted)
+   
+
+    
+
+    ## Inpaintした画像をぼかす。
+    blurred_image = cv2.GaussianBlur(copy_impainted, (9, 9), 0) #場合によっては奇数じゃないとエラーが出ることがある
+    if lip_utils.DEBUG:
+        cv2.imwrite("close_lip_04_burred.jpg",blurred_image)
+
+
+     # Inpaintの境界線から少し広げている
+    kernel = np.ones((3, 3), np.uint8)
+    shrink_mask = cv2.erode(hole_mask, kernel, iterations=1)
+
+
+    shrink_burred_mask = cv2.GaussianBlur(shrink_mask, (3, 3), 0)
+    if lip_utils.DEBUG:
+        cv2.imwrite("close_lip_05_final_hole_mask.jpg",shrink_burred_mask)
+
+    img_inpainted = blend_rgb_images(img_inpainted,blurred_image,shrink_burred_mask)
+    if lip_utils.DEBUG:
+        cv2.imwrite("close_lip_05_final_hole.jpg",img_inpainted)
+    # Inpaintの境界線から少し広げている
+    kernel = np.ones((3, 3), np.uint8)
+    extend_mask = cv2.dilate(lower_lip_mask, kernel, iterations=1)
+
+
+    extend_burred_mask = cv2.GaussianBlur(extend_mask, (3, 3), 0)
+    if lip_utils.DEBUG:
+        cv2.imwrite("close_lip_05_final_lip_mask.jpg",extend_burred_mask)
+    img_inpainted = blend_rgb_images(img_inpainted,blurred_image,extend_burred_mask)
+    
+    if lip_utils.DEBUG:
+        cv2.imwrite("close_lip_05_final_lip.jpg",img_inpainted)
+
+    mixed_mask = cv2.bitwise_or(shrink_burred_mask,extend_burred_mask)
+    mixed_mask[mixed_mask>0] = 255
+    mixed_mask = cv2.dilate(mixed_mask, (1,1), iterations=1)
+    #    mixed_mask = cv2.GaussianBlur(mixed_mask, (3, 3), 0)
+
+    if lip_utils.DEBUG:
+        cv2.imwrite("close_lip_05_final_mixed_mask.jpg",mixed_mask)
+
+    return img_inpainted,mixed_mask
+
+if __name__ == "__main__":
+  parser = argparse.ArgumentParser(description='Open Mouth')
+  parser.add_argument('--input',"-i",help='変換する画像の元(必須) 口を閉じていること',required=True)
+  parser.add_argument('--output',"-o",help='画像の保存先(別途一時的なレイヤーファイルも作られる)')
+  parser.add_argument('--landmark',"-l",help='landmarkdata')
+  parser.add_argument('--scale',"-sc",help='スケール精度が上がる',default=4,type=int)
+
+  args = parser.parse_args()
+  # 画像ファイルのパス
+  img_path = args.input
+  img = cv2.imread(img_path)
+  #landmarks_list = landmark_utils.load_landmarks(img,args.scale,args.landmark)
+  landmarks_list = None
+  eye_closed_image,mask = process_close_lip_image(img,landmarks_list)
+
+  output_path = args.output
+  if output_path == None:
+    parent_path,file = os.path.split(img_path)
+    name,ext = os.path.splitext(file)
+    output_path = os.path.join(parent_path,f"{name}_lipclose{ext}")
+      
+
+  
+
+  parent_path,file = os.path.split(output_path)
+  name,ext = os.path.splitext(file)
+
+  mask_path = os.path.join(parent_path,f"{name}_mask{ext}")
+  cv2.imwrite(mask_path,mask)
+  cv2.imwrite(output_path,eye_closed_image)
+  print(f"complete image {output_path} and mask {mask_path}")

create_bottom_lip.py

@@ -0,0 +1,212 @@
+"""
+bottom_lip.py
+
+open_mouthの一部 下唇レイヤーの生成
+単独ではまだ動かない。
+
+
+著者: Akihito Miyazaki
+作成日: 2024-04-23
+更新履歴:
+  - 2024-04-23: 最初のリリース
+
+"""
+
+import cv2
+import numpy as np
+from PIL import Image
+from lip_utils import *
+import lip_utils
+from scipy.ndimage import binary_dilation, gaussian_filter
+
+def process_lip_image(img,landmarks_list, crop_image_margin, open_size_y, open_size_x):
+    """
+    唇画像を処理する関数
+
+    open_size_x  最終画像で端をカットしている
+    side_tipsに値をコピーしている。side_tips
+    """
+    # 画像の読み込み
+    
+    side_tips = 0 # remove cropped pixel
+    edge_x =0 # remove side pixel from final image
+ 
+    
+    # 口の開きに応じて、中心を下げようとしたが、真ん中が下がるのは極めて不自然なのでやめた。
+    # そのうち、５分割の中心を変形するのに使いたい
+    mid_lip_move_ratio = open_size_y/80.0 if open_size_y>0 else 0
+    mid_lip_move_ratio = 0
+
+    if open_size_x>0:# ここ謎コード? そのうち検証したい
+       print("only support shorten use minus open")
+       side_tips = open_size_x
+       edge_x = int(open_size_x*1.5) #som magic number
+       #edge_x = 0
+       open_size_x = 0 # TODO move (some transform broken)
+
+    # 不自然にはみ出す、サイドのカット用だが、いまいち機能しないので使用停止
+    # TOP と　HOLEが未対応なのでOFF
+    side_tips = 0 # remove cropped pixel
+    edge_x =0 # remove side pixel from final image
+
+
+    img_h, img_w = lip_utils.get_image_size(img)
+    
+    # 唇領域の抽出と処理 (マージンが追加される。透明化処理が怪しい)
+    gaus = 4
+    box = lip_utils.get_points_box(landmarks_list, lip_utils.POINTS_BOTTOM_LIP, crop_image_margin)
+    align_points = lip_utils.get_bottom_lip_align_points(landmarks_list)
+    alpha_image, rec = get_alpha_image(img, landmarks_list, lip_utils.POINTS_BOTTOM_LIP, crop_image_margin, crop_image_margin, gaus)
+
+    
+    # 最後に返す画像の元を作成
+    h, w = lip_utils.get_image_size(alpha_image)
+    if lip_utils.DEBUG:
+      cv2.imwrite("debug/bottom_lip_alpha.png",alpha_image)
+    print(f"bottom-lip cropped w = {w} h = {h}")
+    bottom_lip_final_image=lip_utils.create_rgba(w,h+open_size_y+1)# some how transform image expand TODO まだ必要か確認
+    bottom_lip_final_image_h,bottom_lip_final_image_w = lip_utils.get_image_size(bottom_lip_final_image)
+    print(f"bottom_lip_final_image:w = {bottom_lip_final_image_w} h = {bottom_lip_final_image_h}")
+
+
+    #local_align_points = lip_utils.offset_points(align_points,box[0])
+    #print(align_points)
+
+
+    # 唇の位置、いまだ検討中 https://github.com/akjava/lip_recognition_tools/issues/2
+    mid_left = int(w/5*2)
+    mid_left = int(w/3)
+
+    mid_right = bottom_lip_final_image_w - mid_left
+    print(f"image width = {bottom_lip_final_image_w} mid_left = {mid_left} mid_right ={mid_right}")
+
+    mid_center = int((mid_right+mid_left)/2) # 過去に真ん中下げに使っていたが必要ないと思っている。
+    mid_move_y_divided = 5 # 0 means no move
+
+    # 真ん中左の唇の変形 中心さげのに、無駄に２分割している。 https://github.com/akjava/lip_recognition_tools/issues/3
+
+    mid_image_left = lip_utils.crop_image(alpha_image,mid_left,0,mid_center,h)
+    mid_image_left_h,mid_image_left_w = lip_utils.get_image_size(mid_image_left)
+    max_w = mid_image_left_w
+    max_h = mid_image_left_h
+    opend_mid_lip_left = lip_utils.create_moved_image(mid_image_left, 
+                    [(0,0),(max_w,0),
+                    (0,max_h),(max_w,max_h)],
+
+                    [(-0,-0),(max_w,int(max_h*mid_lip_move_ratio)),#int(max_h/2)
+                    (0,max_h),(max_w,max_h)]
+                    )
+    # 予定外にサイズが伸びると、エラーになるので避けたいが、もう少し検証が必要
+    #opend_mid_lip_left = cv2.resize(opend_mid_lip_left, (max_w, max_h), interpolation=cv2.INTER_AREA)
+    lip_utils.print_width_height(mid_image_left,"mid-left")
+    lip_utils.print_width_height(opend_mid_lip_left,"moved-mid-left")
+    
+
+    # 真ん中右の唇の変形 
+    mid_image_right = lip_utils.crop_image(alpha_image,mid_center,0,mid_right,h)
+    mid_image_right_h,mid_image_right_w = lip_utils.get_image_size(mid_image_right)
+    max_w = mid_image_right_w
+    max_h = mid_image_right_h
+    
+    opend_mid_lip_right = lip_utils.create_moved_image(mid_image_right, 
+                    [(0,0),(max_w,0),
+                    (0,max_h),(max_w,max_h)],
+
+                    [(-0,int(max_h*mid_lip_move_ratio)),(max_w,0),#int(max_h/2)
+                    (0,max_h),(max_w,max_h)]
+                    )
+    
+    #opend_mid_lip_right = cv2.resize(opend_mid_lip_right, (max_w, max_h), interpolation=cv2.INTER_AREA)
+    lip_utils.print_width_height(mid_image_right,"mid-right")
+    lip_utils.print_width_height(opend_mid_lip_right,"moved-mid-right")
+
+
+    #no remove side-tip area
+    left_image = lip_utils.crop_image(alpha_image,side_tips,0,mid_left,h)
+    right_image = lip_utils.crop_image(alpha_image,mid_right,0,w-side_tips,h)
+
+    # 左の唇を下げる 左側は固定
+    left_lip_image_h,left_lip_image_w = lip_utils.get_image_size(left_image)
+    print(f"left-image:w = {left_lip_image_w} h = {left_lip_image_h}")
+
+    max_w = left_lip_image_w
+    max_h = left_lip_image_h
+    opend_lip_left = lip_utils.create_moved_image(left_image, 
+                    [(0,0),(max_w,0),
+                    (0,max_h),(max_w,max_h)],
+
+                    [(0,-0),(max_w+open_size_x,open_size_y),
+                    (0,max_h-0),(max_w+open_size_x,max_h+open_size_y)]
+                    )
+    left_lip_image_h,left_lip_image_w = lip_utils.get_image_size(opend_lip_left)
+    max_w = left_lip_image_w
+    max_h = left_lip_image_h
+
+    new_h,new_w = lip_utils.get_image_size(opend_lip_left)
+    print(f"left-image moved:w = {new_w} h = {new_h}")
+    if lip_utils.DEBUG:
+      cv2.imwrite("open_botto_lip_left.png",opend_lip_left)
+
+
+    # 右の唇を下げる 右側は固定
+    right_lip_image_h,right_lip_image_w = lip_utils.get_image_size(right_image)
+    max_w = right_lip_image_w
+    max_h = right_lip_image_h
+    opend_lip_right = lip_utils.create_moved_image(right_image, 
+                    [(0,0),(max_w,0),
+                    (0,max_h),(max_w,max_h)],
+
+                    [(0,open_size_y),(max_w+open_size_x,-0),
+                    (0,max_h+open_size_y),(0+max_w+open_size_x,max_h-0)]
+                    )
+    new_h,new_w = lip_utils.get_image_size(opend_lip_right)
+    print(f"right-image moved :w = {new_w} h = {new_h}")
+    if lip_utils.DEBUG:
+      cv2.imwrite("open_botto_lip_right.png",opend_lip_right)
+
+
+
+
+    # 変形後の各画像を描く alpha含めた全コピーなので注意(元画像のAlphaは無視)
+    #is this ok?
+    #lip_utils.copy_image(bottom_lip_final_image,mid_image,mid_left-1,open_size_y)
+    #lip_utils.copy_image(bottom_lip_final_image,mid_image,mid_left,open_size_y)
+    ## 中央部分
+    lip_utils.copy_image(bottom_lip_final_image,opend_mid_lip_left,mid_left,open_size_y)
+    lip_utils.copy_image(bottom_lip_final_image,opend_mid_lip_right,mid_center,open_size_y)
+
+
+    print(lip_utils.get_image_size(opend_lip_left))
+    print(lip_utils.get_image_size(bottom_lip_final_image))
+   
+    ## 左右の端 side_tips
+    lip_utils.copy_image(bottom_lip_final_image,opend_lip_left,open_size_x+side_tips,0) 
+    lip_utils.copy_image(bottom_lip_final_image,opend_lip_right,mid_right,0)
+
+
+    #edge_x=22 #for40 #テスト中
+
+    # 両端の処理 https://github.com/akjava/lip_recognition_tools/issues/6
+    lip_utils.fade_in_x(bottom_lip_final_image,edge_x*2)
+    lip_utils.fade_out_x(bottom_lip_final_image,edge_x*2)
+
+    # 最終的な画像の作成と保存
+    if lip_utils.DEBUG:
+      cv2.imwrite("bottom_lip_opend.png", bottom_lip_final_image)
+    face_size_image = lip_utils.create_rgba(img_w, img_h)
+    lip_utils.copy_image(face_size_image, bottom_lip_final_image, box[0][0], box[0][1])
+    if lip_utils.DEBUG:
+      cv2.imwrite("bottom_lip_layer.png", face_size_image)
+    return face_size_image
+
+
+if __name__ == "__main__":
+  # 画像ファイルのパス
+  img_path = "straight.jpg"
+  # パラメータ
+  crop_image_margin = 16
+  open_size_y = 10
+  open_size_x = -10
+
+  # 関数の呼び出し
+  process_lip_image(img_path, crop_image_margin, open_size_y, open_size_x)

create_chin_image.py

@@ -0,0 +1,86 @@
+"""
+create_chin_image.py
+
+open_mouth.pyの一部
+
+口のオープンに合わせて、あご画像を縦に拡大しているだけ、
+
+輪郭はもう少し綺麗に取りたい
+https://github.com/akjava/lip_recognition_tools/issues/7
+
+著者: Akihito Miyazaki
+作成日: 2024-04-23
+更新履歴:
+  - 2024-04-23: 最初のリリース
+
+"""
+
+import cv2
+import numpy as np
+from PIL import Image
+import lip_utils
+
+def process_chin_image(img,landmarks_list, margin, open_size_y, open_size_x):
+    img_h, img_w = lip_utils.get_image_size(img)
+
+
+    open_size_x = 0 #stop support this
+    if open_size_x > 0:
+        print("currently stop support open-sizex")
+
+    jaw_points = lip_utils.get_jaw_points(landmarks_list)
+    print("### JAW POINT")
+    print(jaw_points)
+
+    box = lip_utils.points_to_box(jaw_points)
+    print(box)
+
+    cropped = lip_utils.crop_image_by_box(img,box)
+    cropped_img_h, cropped_img_w = lip_utils.get_image_size(cropped)
+    if lip_utils.DEBUG_CHIN:
+      cv2.imwrite("chin_cropped.jpg",cropped)
+    cropped_jaw_points = lip_utils.offset_points(jaw_points,box[0])
+    #what hell is this?
+    #points = np.array(jaw_points,dtype=np.float32)
+    # 回転矩形を取得
+    #rect = cv2.minAreaRect(points)
+    #print(rect)
+
+    mask = lip_utils.create_mask_from_points(cropped,cropped_jaw_points,4,2)
+    if lip_utils.DEBUG_CHIN:
+       cv2.imwrite("chin_mask.jpg",mask)
+
+    #lip_utils.print_numpy(mask)
+    chin_image = lip_utils.apply_mask(cropped,mask)
+    chin_image_resized = cv2.resize(chin_image, (cropped_img_w, cropped_img_h+open_size_y), interpolation=cv2.INTER_LANCZOS4)
+    #chin_mask_image_resized = cv2.resize(mask, (cropped_img_w, cropped_img_h+open_size_y), interpolation=cv2.INTER_LANCZOS4)
+
+    #lip_utils.print_numpy(chin_image)
+    if lip_utils.DEBUG_CHIN:
+       cv2.imwrite("chin_resized.png",chin_image_resized) #alpha image must be save png 
+
+    full_rgba=lip_utils.create_rgba(img_w,img_h)
+    lip_utils.copy_image(full_rgba,chin_image_resized,box[0][0],box[0][1])
+    if lip_utils.DEBUG_CHIN:
+       cv2.imwrite("chin_full.png",full_rgba)
+
+    #mask_gray=lip_utils.create_gray(img_w,img_h)
+    #lip_utils.copy_image(mask_gray,chin_mask_image_resized,box[0][0],box[0][1])
+    # chin mask is useless
+    
+    return full_rgba
+
+if __name__ == "__main__":
+  # 画像ファイルのパス
+  img_path = "straight.jpg"
+  img = cv2.imread(img_path)
+  img_h, img_w = lip_utils.get_image_size(img)
+  landmarks_list = lip_utils.image_to_landmarks_list(img)
+
+  # パラメータ
+  margin = 4
+  open_size_y = 20
+  open_size_x = 0
+
+  # 関数の呼び出し
+  process_chin_image(img,landmarks_list, margin, open_size_y, open_size_x)

create_hole_image.py

@@ -0,0 +1,149 @@
+
+"""
+create_hole_image.py
+
+open_mouth.pyの一部
+
+
+著者: Akihito Miyazaki
+作成日: 2024-04-23
+更新履歴:
+  - 2024-04-23: 最初のリリース
+  - 2024-09-15:slide_amountを追加
+"""
+
+import cv2
+import numpy as np
+from PIL import Image
+import lip_utils
+
+
+
+def vertical_slide(image, slide_amount):
+    height, width = image.shape[:2]
+
+    # スライド量が画像の高さより大きい場合、画像の高さに制限する
+    slide_amount = min(slide_amount, height)
+    slide_amount = max(slide_amount, -height)
+
+    slide_image = np.zeros_like(image)  # 入力画像と同じサイズと型の画像を作成
+
+    if slide_amount > 0:  # 下にスライド
+        slide_image[slide_amount:, :] = image[:height - slide_amount, :]
+    elif slide_amount < 0:  # 上にスライド
+        slide_image[:height + slide_amount, :] = image[-slide_amount:, :]
+    else:
+        slide_image = image.copy()
+
+    return slide_image
+
+
+def file_name_check(path):
+    max_name_limit = 50
+    check = True
+    if path.find("..")!=-1:
+        check = False
+    if path.find("/")!=-1:
+        check = False
+    if path.find("\\")!=-1:
+        check = False
+    if path.find(":")!=-1:
+        check = False
+    if len(path)>max_name_limit:
+        print(f"name is limited {max_name_limit}")
+        check = False
+    if not check:
+        ValueError(f"Invalid Name {path}")
+        
+
+
+def process_create_hole_image(img,landmarks_list,open_size_y = 0,open_size_x=0,hole_offset=0,hole_image_name="dark01.jpg"):
+    file_name_check(hole_image_name)
+    img_h, img_w = lip_utils.get_image_size(img)
+
+    # 画像を複製して、アラインポイントを描画する。アラインは、傾きも考慮した唇の範囲
+    img_lined = np.copy(img)
+    
+    points = lip_utils.get_top_lip_align_points(landmarks_list)
+    img_lined1 = np.copy(img)
+    print(points)
+    cv2.polylines(img_lined1, [np.array(points)], isClosed=True, color=(0,255,0), thickness=1)
+    if lip_utils.DEBUG:
+        cv2.imwrite("create_hole_top_lip_align_line.jpg",img_lined1)
+
+
+    print(f"align point = {points}")
+    diff_align_x = points[0][0]-points[2][0]
+    print(f"diff_align_x = {diff_align_x}")
+    np_points = np.array(points)
+    
+    diff_left = np_points[2] - np_points[0] #left-bottom ,left-up
+    diff_right = np_points[3] - np_points[1] #right-bottom,right-up
+    print(f"diff left-y = {diff_left},diff right-y ={diff_right}")
+
+    top_lip_thicks = lip_utils.get_top_lip_thicks(landmarks_list) # this ignore rotation
+    top_lip_thicks2 = lip_utils.get_top_lip_thicks(landmarks_list,True) # this ignore rotation
+
+    lip_thick = np.mean(top_lip_thicks)
+    lip_thick2 = np.mean(top_lip_thicks2)
+
+    base_mouth_size = lip_thick2*1.5
+    
+    mouth_angle=lip_utils.calculate_clockwise_angle(points[2],points[3])
+    angled_point=lip_utils.calculate_new_point((0,0),base_mouth_size,mouth_angle+90)
+    angled_mouth_size = angled_point[1] + open_size_y
+    #print(f"lip_thick2={lip_thick2}")
+
+    print(f"lip thick2 ={lip_thick2} base_mouth_size={base_mouth_size} mouth_angle={mouth_angle} angled_mouth_size={angled_mouth_size}")
+    #上唇の範囲を元に、口全体を定義するため、根拠ないけど1.x倍にしている。 https://github.com/akjava/lip_recognition_tools/issues/8
+    diff_left[1] = angled_mouth_size
+    diff_right[1] = angled_mouth_size
+    diff_left[0] *=0
+    diff_right[0] *=0
+    expand_left =  np_points[2] + diff_left
+    expand_right =  np_points[3] + diff_right
+
+    # X座標も拡大するが、基本使わないので無視してもいい。
+    expand_points = np.array([np_points[0],np_points[1],expand_left,expand_right])  
+    print(f"expand_points = {[np_points[0],np_points[1],expand_left,expand_right]}")
+    cv2.polylines(img_lined, [expand_points], isClosed=True, color=(0,255,0), thickness=1)
+    if lip_utils.DEBUG:
+        cv2.imwrite("create_hole_image_top-align_line.jpg",img_lined)
+
+
+    # これまた、hole用の画像をなんとなく、サイズに合わせている。
+    # そのため、画像の位置調整が非常に微妙になる
+    # TODO 画像の指定引数 https://github.com/akjava/lip_recognition_tools/issues/9
+    # https://github.com/akjava/lip_recognition_tools/issues/10
+    #hole_image = cv2.imread("hole_images/hole_01_light_dark.jpg")
+    hole_image = cv2.imread(f"hole_images/{hole_image_name}")
+    hole_image = vertical_slide(hole_image,hole_offset)
+    if lip_utils.DEBUG:
+        cv2.imwrite("create_hole_image-slided_hole_image.jpg",hole_image)
+    #exit(0)
+
+    hole_image_h,hole_image_w = lip_utils.get_image_size(hole_image)
+    max_w = hole_image_w
+    max_h = hole_image_h
+    expand_list = expand_points.tolist()
+    aligned_hole_image = lip_utils.create_moved_image(hole_image, [(0,0),(max_w,0),
+                    (0,max_h),(max_w,max_h)],
+                    expand_list
+                    
+                    )
+    if lip_utils.DEBUG:
+        cv2.imwrite("create_hole_image_top-align_image.jpg",aligned_hole_image)
+
+    img_face = np.copy(img)
+    lip_utils.copy_image(img_face,aligned_hole_image,expand_list[0][0] - diff_align_x,(expand_list[0][1]+expand_list[1][1])//2)
+    if lip_utils.DEBUG:
+        cv2.imwrite("create_hole_image_top-align_face.jpg",img_face)
+    return img_face
+
+
+if __name__ == "__main__":
+  # 画像ファイルのパス
+  img_path = "00012245.jpg" #"straight.jpg"
+  img = cv2.imread(img_path)
+  landmarks_list = lip_utils.image_to_landmarks_list(img)
+  process_create_hole_image(img,landmarks_list)

create_no_mouth.py

@@ -0,0 +1,97 @@
+
+"""
+create_no_mouth.py
+
+open_mouth.pyの一部
+
+口のない画像を作ります。
+
+口の部分のをlandpointを取って、その部分を消して、inpaintします。
+inpaint部分をぼかして、元の画像の上にはりつけ、ぼかします。
+
+
+
+著者: Akihito Miyazaki
+作成日: 2024-04-23
+更新履歴:
+  - 2024-04-23: 最初のリリース
+
+"""
+
+import cv2
+import numpy as np
+from PIL import Image
+import lip_utils
+
+from glibvision.cv2_utils import blend_rgb_images
+from glibvision.numpy_utils import apply_binary_mask_to_image
+
+def process_create_no_mouth_image(img,landmarks_list):
+    img_h, img_w = lip_utils.get_image_size(img)
+
+    ## 口の範囲をInpaintで消す。
+    (bottom_width,bottom_height)=lip_utils.get_bottom_lip_width_height(landmarks_list)
+    lip_points = lip_utils.get_lip_mask_points(landmarks_list)
+    
+    #　選択範囲を丸めてみたけど、それほどメリットが感じなかった。
+    #lip_points = lip_utils.bulge_polygon(lip_points,0.1)
+
+    # 唇のマスク範囲を検証
+    if lip_utils.DEBUG:
+        img_lined = np.copy(img)
+        cv2.polylines(img_lined, [np.array(lip_points)], isClosed=True, color=(0,255,0), thickness=1)
+        cv2.imwrite("create_no_mouth_image_polyline.jpg",img_lined)
+    
+    # 唇のエッジ部分は、影やら、ピンクなどあるので、それを削るのに、下唇の高さを元にしている。0.5は根拠ない。
+    dilation_size = int(bottom_height*0.5)
+    lip_mask = lip_utils.create_mask_from_points(img,lip_points,dilation_size,0) # inpaintで使うので、ぼかしは不要
+    if lip_utils.DEBUG:
+        lip_utils.print_numpy(lip_mask,"lip mask")
+
+    if lip_utils.DEBUG:
+        cv2.imwrite("create_no_mouth_image_mask.jpg",lip_mask)
+
+    img_inpainted = cv2.inpaint(img, lip_mask,3, cv2.INPAINT_TELEA)
+    if lip_utils.DEBUG:
+        cv2.imwrite("create_no_mouth_image_inpaint.jpg",img_inpainted)
+
+    ## Inpaintした部分をぼかしている。
+    blurred_image = cv2.GaussianBlur(img_inpainted, (29, 29), 0) #場合によっては奇数じゃないとエラーが出ることがある
+    if lip_utils.DEBUG:
+        cv2.imwrite("create_no_mouth_image_blurred.jpg",blurred_image)
+    
+    apply_binary_mask_to_image(img_inpainted,blurred_image,lip_mask)
+    if lip_utils.DEBUG:
+        cv2.imwrite("create_no_mouth_image_blurred1_applied.jpg",blurred_image)
+
+
+    # 全体を少しぼかす
+    blurred_image2 = cv2.GaussianBlur(img_inpainted, (9, 9), 0)
+    if lip_utils.DEBUG:
+        cv2.imwrite("create_no_mouth_image_blurred2.jpg",blurred_image2)
+
+    # Inpaintの境界線から少し広げている
+    kernel = np.ones((8, 8), np.uint8)
+    lip_mask = cv2.dilate(lip_mask, kernel, iterations=1)
+
+     # 全体を少しぼかす
+    blurred_mask = cv2.GaussianBlur(lip_mask, (19, 19), 0)
+    if lip_utils.DEBUG:
+        cv2.imwrite("create_no_mouth_image_blurred_mask.jpg",blurred_mask)
+
+    # https://github.com/akjava/lip_recognition_tools/issues/12
+    #cv2_utils.apply_binary_mask_to_image(img_inpainted,blurred_image2,lip_mask)
+    
+    img_inpainted = blend_rgb_images(img_inpainted,blurred_image2,lip_mask)
+    
+    if lip_utils.DEBUG:
+        cv2.imwrite("create_no_mouth_image_merged.jpg",img_inpainted)
+
+    return img_inpainted
+
+if __name__ == "__main__":
+  # 画像ファイルのパス
+  img_path = "straight.jpg"
+  img = cv2.imread(img_path)
+  landmarks_list = lip_utils.image_to_landmarks_list(img)
+  process_create_no_mouth_image(img,landmarks_list)

create_top_lip.py

@@ -0,0 +1,284 @@
+import cv2
+import numpy as np
+from PIL import Image
+import lip_utils
+
+def process_lip_image(img,landmarks_list, margin, open_size_y, open_size_x):
+    print(open_size_x)
+    """
+    唇画像を処理する関数
+    """
+    img_h, img_w = lip_utils.get_image_size(img)
+
+
+    open_size_x = 0 #stop support this
+    print("currently stop support open-sizex")
+
+    #for 40 # TODO recheck later issues/91
+    side_tips = 0 # TODO depent on size or point
+    #side_tips = 0
+    side_tips = open_size_x
+    edge_x = int(open_size_x*1.4) #som magic number
+
+    mid_lip_move_artio = open_size_y/80.0 if open_size_y>0 else 0
+    mid_lip_shrink_artio = open_size_x/4 if open_size_x>0 else 0
+
+    # 上唇の抽出と処理
+    top_lip_rgba, cropped_box = lip_utils.get_alpha_image(img, landmarks_list, lip_utils.POINTS_TOP_LIP, margin, margin, 4)
+    if lip_utils.DEBUG:
+        cv2.imwrite("top_lip_rgba.png",top_lip_rgba)
+    new_h,new_w = lip_utils.get_image_size(top_lip_rgba)
+    w = new_w
+    h = new_h
+    print(f"top-lip-alpha-margined-size:w = {new_w} h = {new_h} margin = {margin}")
+    align_points = lip_utils.get_top_lip_align_points(landmarks_list)
+
+    box = cropped_box
+    top_points=lip_utils.get_landmark_points(landmarks_list,lip_utils.POINTS_TOP_LIP)
+    cropped_lip_points = [(point[0] - box[0][0], point[1] - box[0][1]) for point in top_points]
+    lip_points = [(point[0] - box[0][0], point[1] - box[0][1]) for point in align_points]
+    middle_lip = ((lip_points[0][0] + lip_points[1][0]) / 2, (lip_points[0][1] + lip_points[1][1]) / 2)
+    print(f"middle:{middle_lip}")
+
+
+    #DEV
+    print(f"box {cropped_box[0][0]},{cropped_box[0][1]}")
+    face_size_image=lip_utils.create_rgba(img_w,img_h)
+    lip_utils.copy_image(face_size_image,top_lip_rgba,cropped_box[0][0]-margin,cropped_box[0][1]-margin)
+    if lip_utils.DEBUG:
+        cv2.imwrite("top_lip_layer.png",face_size_image)
+
+
+
+
+   
+
+    #intではないとエラー
+    middle_y = max(1,int(middle_lip[1]-5)) # force move up
+
+
+    # ３分割
+    mid_x1=int(w/3) # LEFT
+    mid_x2 = w -mid_x1 # RIGHT
+    print(f"image width = {new_w} mid_left = {mid_x1} mid_right ={mid_x2}")
+
+    cx, cy, cx2, cy2 = 0, middle_y,mid_x1, h
+
+    print("###",w,",",middle_y)
+    crop_top = lip_utils.crop_image(top_lip_rgba,0,0,w,middle_y)#full top
+
+    #if use mid only left right change control of up
+    #crop_top = lip_utils.crop_image(top_lip_rgba,mid_x1,0,mid_x2,middle_y)
+    if lip_utils.DEBUG:
+        cv2.imwrite("crop_top.png",crop_top)
+    #cv2.imwrite("top_lip_mid.png",crop_mid)
+
+    below_top_lip_image = lip_utils.crop_image(top_lip_rgba,0,middle_y,w,h)
+    below_top_lip_image_h,below_top_lip_image_w = lip_utils.get_image_size(below_top_lip_image)
+    if lip_utils.DEBUG:
+        cv2.imwrite("below_top_lip_image.png",below_top_lip_image)
+    print(f"below_top_lip_image w = {below_top_lip_image_w}, h= {below_top_lip_image_h}")
+
+    #中央部分を切り抜く
+
+    mid_x1_x2_half = int((mid_x2+mid_x1)/2)
+    print(mid_x1_x2_half)
+    crop_mid_left = lip_utils.crop_image(below_top_lip_image,mid_x1,0,mid_x1_x2_half,below_top_lip_image_h)
+    lip_utils.print_width_height(crop_mid_left,"crop_mid_left")
+    crop_mid_h,crop_mid_w = lip_utils.get_image_size(crop_mid_left)
+    max_w = crop_mid_w
+    max_h = crop_mid_h
+    moveup_lip_mid = lip_utils.create_moved_image(crop_mid_left, [(0,0),(max_w,0),
+                    (0,max_h),(max_w,max_h)],
+
+                    [(0,0),(crop_mid_w,0),
+                    (0,int(max_h)),(max_w,int(crop_mid_h*(1.0 - mid_lip_move_artio)))]# TODO ratio
+                    )
+    lip_utils.print_width_height(moveup_lip_mid,"crop_mid_left-moved")
+   
+    if lip_utils.DEBUG:
+        cv2.imwrite("moveup_lip_mid_left.png",moveup_lip_mid)
+
+    crop_mid_right = lip_utils.crop_image(below_top_lip_image,mid_x1_x2_half,0,mid_x2,below_top_lip_image_h)
+    crop_mid_h,crop_mid_w = lip_utils.get_image_size(crop_mid_right)
+    max_w = crop_mid_w
+    max_h = crop_mid_h
+    lip_utils.print_width_height(crop_mid_right,"crop_mid_right")
+    moveup_lip_mid_right = lip_utils.create_moved_image(crop_mid_right, [(0,0),(max_w,0),
+                    (0,max_h),(max_w,max_h)],
+
+                    [(0,0),(max_w,0),
+                    (0,int(max_h*(1.0-mid_lip_move_artio))),(max_w,int(max_h))]
+                    )
+    lip_utils.print_width_height(moveup_lip_mid_right,"crop_mid_right-moved")
+    if lip_utils.DEBUG:
+        cv2.imwrite("moveup_lip_mid_right.png",moveup_lip_mid_right)
+
+
+
+
+    # 最終画像　サイズは、最初の 切り抜きに 口を開く + open_size_y
+    top_lip_final_image=lip_utils.create_rgba(w,h+open_size_y+1)#some how transform image expand
+    final_image_h,final_image_w = lip_utils.get_image_size(top_lip_final_image)
+    print(f"final-image-size:w = {final_image_w} h = {final_image_h}")
+
+
+    # left block
+    left_lip_image = lip_utils.crop_image(below_top_lip_image,side_tips,0,mid_x1,below_top_lip_image_h)
+    left_lip_image_h,left_lip_image_w = lip_utils.get_image_size(left_lip_image)
+    print(f"left-image-cropped:w = {left_lip_image_w} h = {left_lip_image_h}")
+    # this left transofom is very important change result (dont feel strange +open_size_x)
+    max_w = left_lip_image_w
+    max_h = left_lip_image_h
+
+    opend_lip_left = lip_utils.create_moved_image(left_lip_image, 
+                    [(0,0),(max_w,0),
+                    (0,max_h),(max_w,max_h)],
+
+                    [(0,0+open_size_y),(max_w+open_size_x,0),
+                    (0,max_h+open_size_y),(max_w+open_size_x,max_h)]
+                    )
+  
+
+    new_h,new_w = lip_utils.get_image_size(opend_lip_left)
+    print(f"left-image-moved:w = {new_w} h = {new_h}")
+    if lip_utils.DEBUG:
+        cv2.imwrite("top_lip_opend_left.png",opend_lip_left)
+
+    right_lip_image = lip_utils.crop_image(below_top_lip_image,mid_x2,0,below_top_lip_image_w-side_tips,below_top_lip_image_h)
+    right_lip_image_h,right_lip_image_w = lip_utils.get_image_size(right_lip_image)
+    print(f"right-image-cropped:w = {right_lip_image_w} h = {right_lip_image_h}")
+    max_w = right_lip_image_w
+    #cv2.imwrite("top_lip_opend_left.png",opend_lip_left)
+    # right block
+    #right-image-cropped:w = 39 h = 32
+    opend_lip_right = lip_utils.create_moved_image(right_lip_image, 
+                    [(0,0),(right_lip_image_w-1,0),
+                    (0,right_lip_image_h-1),(right_lip_image_w-1,right_lip_image_h-1)],
+
+                    [(-0,0),(right_lip_image_w-1+open_size_x,open_size_y), # remove corner shrink it broke image
+                    (0,int(crop_mid_h-1)),(right_lip_image_w+open_size_x-1,right_lip_image_h-1+open_size_y)]
+                    #,(39+open_size_x,right_lip_image_h+open_size_y) #TOD
+                    )
+
+
+    new_h,new_w = lip_utils.get_image_size(opend_lip_right)
+    right_image_w_changed = new_w-right_lip_image_w
+
+    print(f"right-image-moved:w = {new_w} h = {new_h}")
+    if lip_utils.DEBUG:
+        cv2.imwrite("top_lip_opend_right.png",opend_lip_right)
+
+
+    move_x = open_size_x +(open_size_x-right_image_w_changed)
+    print(f"right_image_w_changed ={right_image_w_changed} open_size_x ={open_size_x} move_x ={move_x}")
+
+    lip_utils.copy_image(top_lip_final_image,crop_top,0,0) # full version
+    #lip_utils.copy_image(top_lip_final_image,crop_top,mid_x1,0)
+    print(f"open size x = {open_size_x}")
+    lip_utils.copy_image(top_lip_final_image,opend_lip_left,side_tips,middle_y)# open_size_x must slided and minus value
+
+    #mid 
+    lip_utils.copy_image(top_lip_final_image,moveup_lip_mid,mid_x1,middle_y)
+    lip_utils.copy_image(top_lip_final_image,moveup_lip_mid_right,mid_x1_x2_half,middle_y)
+    
+    lip_utils.copy_image(top_lip_final_image,opend_lip_right,mid_x2,middle_y)
+
+
+    if lip_utils.DEBUG:
+        cv2.imwrite("top_lip_opend.png",top_lip_final_image)
+    face_size_image=lip_utils.create_rgba(img_w,img_h)
+    lip_utils.copy_image(face_size_image,top_lip_final_image,box[0][0],box[0][1])
+    if lip_utils.DEBUG:
+        cv2.imwrite("top_lip_layer.png",face_size_image)
+    
+
+    # possible bug inverted
+    points = lip_utils.get_lip_hole_points(landmarks_list)
+    #points = lip_utils.get_lip_hole_top_points(landmarks_list)
+
+    statics=[1,2,3]
+    half =[0,4,5,9]
+
+    #not effect now  open-sizex set 0 at begging
+    m = 1
+   
+
+    ## TOP Lip Move Up basically upper thick is 1.5 x lower lip toher are teeth
+    (bottom_width,bottom_height)=lip_utils.get_bottom_lip_width_height(landmarks_list)
+    left_thick,mid_thick,right_thick = lip_utils.get_top_lip_thicks(landmarks_list)
+    bottom_base =  bottom_height/1.5
+    
+    diff_left = max(0,int(left_thick - bottom_base))
+    diff_right = max(0,int(right_thick - bottom_base))
+    diff_mid = max(0,int((diff_right+diff_left)*0.4))
+    print(f"bottom base = {bottom_base} left thick ={left_thick} diff ={diff_left}")
+    print(f"bottom base = {bottom_base} left thick ={left_thick} mid ={diff_mid}")
+
+
+    (bottom_width,bottom_height)=lip_utils.get_bottom_lip_width_height(landmarks_list)
+
+    mid_lip_drop_size = lip_utils.get_bottom_mid_drop_size(open_size_y,bottom_height)
+    print(f"mid_lip_drop_size = {mid_lip_drop_size}")
+    moved_points = []
+    for idx,point in enumerate(points):
+        if idx not in statics:
+            if idx in half:
+                plus_x = 0
+                if idx  == 5 :#or idx ==0
+                    plus_x =  open_size_x*m
+                elif  idx == 9:#idx == 4 or
+                    plus_x = -open_size_x*m
+                elif idx == 0:
+                    plus_x = open_size_x*m
+                elif idx == 4:
+                    plus_x =-open_size_x*m
+                print(f"idx ={idx} plus {plus_x}")
+                
+                moved_points.append((point[0]+plus_x,point[1]+open_size_y/2))
+            else:
+                #bottom
+                moved_points.append((point[0],point[1]+int(open_size_y*2)+mid_lip_drop_size))
+        else:
+            print(f"static ? {idx}")
+            #static top
+            #moved_points.append((point[0],point[1]-crop_mid_h/4)) #for open 40
+            #moved_points.append((point[0],point[1]))
+            if idx == 3:
+                 moved_points.append((point[0],point[1]-diff_left))
+                 print(f"left top lip move up {diff_left}")
+            elif idx == 2:
+                moved_points.append((point[0],point[1]-diff_mid))
+            elif idx == 1:
+                moved_points.append((point[0],point[1]-diff_right))
+                print(f"right top lip move up {diff_right}")
+                
+
+    
+
+
+    # force moved
+    #moved_points[1][1] = moved_points[1][1] -4
+
+    tmp = lip_utils.create_mask_from_points(img,points,int(open_size_y/2),0)
+    if lip_utils.DEBUG:
+        cv2.imwrite("lip_hole_mask_base.jpg",tmp)
+
+    gaus = 2 # ADD OPTION
+    mask = lip_utils.create_mask_from_points(img,moved_points,int(open_size_y/2),gaus)
+    if lip_utils.DEBUG:
+        cv2.imwrite("lip_hole_mask.jpg",mask)
+
+
+    return face_size_image,mask
+
+if __name__ == "__main__":
+  # 画像ファイルのパス
+  img_path = "straight.jpg"
+  # パラメータ
+  margin = 4
+  open_size_y = 20
+  open_size_x = 0
+
+  # 関数の呼び出し
+  process_lip_image(img_path, margin, open_size_y, open_size_x)

demo_footer.html

@@ -0,0 +1,3 @@
+<div>
+    <P> Images are generated with <a href="https://huggingface.co/black-forest-labs/FLUX.1-schnell">FLUX.1-schnell</a> and licensed under <a href="http://www.apache.org/licenses/LICENSE-2.0">the Apache 2.0 License</a>
+</div>

demo_header.html

@@ -0,0 +1,16 @@
+<div style="text-align: center;">
+    <h1>
+        Mediapipe 68-points Eyes-Closed and Mouth-Opened
+    </h1>
+    <div  class="grid-container">
+        <img src="https://akjava.github.io/AIDiagramChatWithVoice-FaceCharacter/webp/128/00538245.webp" alt="Mediapipe Face Detection" class="image">
+       
+        <p class="text">
+            This Space use <a href="http://www.apache.org/licenses/LICENSE-2.0">the Apache 2.0</a> Licensed <a href="https://ai.google.dev/edge/mediapipe/solutions/vision/face_landmarker">Mediapipe FaceLandmarker</a> <br>
+            One of json format is from MIT licensed <a href="https://github.com/ageitgey/face_recognition">face_recognition</a><br>
+            I should clarify because it is confusing: I'm not using dlib's non-MIT licensed 68-point model at all.<br>
+            This is 10-year-old technology. However, most amazing talk-head models,.<br> while often having their core code under MIT/Apache licenses, rely on datasets or NVIDIA libraries with more restrictive licenses.
+        </p>
+    </div>
+    
+</div>

demo_tools.html

@@ -0,0 +1,10 @@
+<div style="text-align: center;">
+    <p>
+        <a href="https://huggingface.co/spaces/Akjava/flux1-schnell-img2img">Flux1-Img2Img(GPU)</a>  | 
+        <a href="https://huggingface.co/spaces/Akjava/flux1-schnell-mask-inpaint">Flux1-Inpaint(GPU)</a>  | 
+        <a href="https://huggingface.co/spaces/Akjava/mediapipe-68-points-facial-mask">Create 68 points Parts Mask</a> | 
+        <a href="https://huggingface.co/spaces/Akjava/histgram-color-matching">Histgram Color Matching</a> | 
+        <a href="https://huggingface.co/spaces/Akjava/WebPTalkHead">WebP anime with 3 images</a>
+    </p>
+    <p></p> 
+</div>

draw_landmarks68.py

@@ -0,0 +1,516 @@
+
+import mediapipe as mp
+from mediapipe.tasks import python
+from mediapipe.tasks.python import vision
+from mediapipe.framework.formats import landmark_pb2
+from mediapipe import solutions
+import numpy as np
+import time
+import cv2
+import argparse
+import os
+import math
+
+# modified in gradio
+
+from mp_constants import *
+from mp_utils import divide_line_to_points,points_to_bbox,expand_bbox
+
+import logging
+
+# for share lib,TODO make module
+#import sys
+#sys.path.append("C:\\Users\\owner\\Documents\\pythons\\glibvision")
+from glibvision.glandmark_utils import bbox_to_glandmarks,convert_to_landmark_group_json
+from glibvision.cv2_utils import draw_bbox,plot_points,set_plot_text
+
+def parse_arguments():
+  """
+  引数
+  
+  """
+  parser = argparse.ArgumentParser(
+          description="draw 68 points"
+      )
+  parser.add_argument(
+          "--input_file","-i",required=True,help="Input file"
+      )
+  parser.add_argument(
+          "--model_path","-m",default="face_landmarker.task",help="model path"
+      )
+  parser.add_argument(
+          "--save_glandmark","-g",action="store_true",help="save godot-landmark json"
+      )
+  parser.add_argument(
+          "--save_group_landmark","-landmark",action="store_true",help="save group-landmark json"
+      )
+  return parser.parse_args()
+
+
+
+
+
+def draw_landmarks_on_image(rgb_image, detection_result,draw_number=True,font_scale=0.5,text_color=(200,200,200),dot_size=3,dot_color=(255,0,0),line_size=1,line_color=(0,0,355),box_size=1,box_color=(200,200,200)):
+  #print(f"dot_size={dot_size},dot_color={dot_color},line_size={line_size},line_color={line_color}")
+  image_width,iamge_height = rgb_image.size
+  face_landmarks_list = detection_result.face_landmarks
+  annotated_image = np.copy(rgb_image)
+
+  def get_cordinate(index):
+    x=face_landmarks_list[0][index].x
+    y=face_landmarks_list[0][index].y
+    return x,y
+    
+  def get_distance(x1,y1,x2,y2):
+    return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
+  
+  def get_centers():
+    center_indices =[
+    #(POINT_LEFT_HEAD_OUTER,POINT_RIGHT_HEAD_OUTER,POINT_FOREHEAD_TOP),
+    #(POINT_LEFT_HEAD_OUTER,POINT_RIGHT_HEAD_OUTER,POINT_CHIN_BOTTOM),
+    [POINT_NOSE_CENTER_MIDDLE],
+    #[POINT_LOWER_LIP_CENTER_BOTTOM]
+    #(POINT_UPPER_LIP_CENTER_BOTTOM,POINT_LOWER_LIP_CENTER_TOP)
+    ]
+    centers = []
+    for indices in center_indices:
+      total_x = 0
+      total_y = 0
+      for index in indices:
+        x,y = get_cordinate(index)
+        total_x+=x
+        total_y+=y
+      centers.append ((total_x/len(indices),total_y/len(indices)))
+    return centers
+  
+  centers = get_centers()
+  for center in centers:
+    center_x,center_y = center
+
+    pt = int(center_x*image_width),int(center_y*iamge_height)
+    
+    #cv2.circle(annotated_image,pt,20,(0,0,255),-1)
+
+  def get_closed_center(x,y):
+    closed = None
+    closed_distance = 0
+    for center in centers:
+      distance = get_distance(center[0],center[1],x,y)
+      if closed == None:
+        closed = center
+        closed_distance = distance
+      else:
+        if distance<closed_distance:
+          closed_distance = distance
+          closed = center
+    return closed
+  
+
+  #landmark is [index-upper,index-lower]
+  def get_mean_point(landmark,width=image_width,height=iamge_height):
+    xs=[]
+    ys=[]
+    for index in landmark:
+      x,y = get_cordinate(index) #inner cordinate
+      xs.append(x)
+      ys.append(y)
+
+    return int(np.mean(xs)*width),int(np.mean(ys)*height)
+    
+  def get_cordinate_point(landmark,width=image_width,height=iamge_height):
+      point = get_cordinate(landmark)
+
+      return int(point[0]*width),int(point[1]*height)
+  # TODO rename and explain this is for contour choose most outer point
+  def get_point(landmark,width=image_width,height=iamge_height):
+    xs=[]
+    ys=[]
+    
+
+    def get_outer_point(indexes):
+      outer_point = None
+      max_distance = None
+      if len(indexes) == 0:
+        return None
+      
+      ratio = 0.5
+      x,y = get_cordinate(indexes[-1]) #on contour 3 lines outer,center,inner cordinate
+
+      #x,y = get_cordinate(indexes[0])
+      center_x,center_y = get_closed_center(x,y)
+      x-=(center_x-x)*ratio
+      y-=(center_y-y)*ratio
+
+      outer_x = x
+      outer_y = y
+
+      for index in indexes:
+        x,y = get_cordinate(index)
+        
+        distance = get_distance(outer_x,outer_y,x,y)
+        #print(f"{distance} index={index} x={x},y={y}")
+        if outer_point == None:
+          outer_point = (x,y)
+          max_distance = distance
+        else:
+          if distance<max_distance:
+            outer_point = (x,y)
+      return outer_point
+
+
+
+    for group in landmark:
+      outer_point = get_outer_point(group)
+      xs.append(outer_point[0])
+      ys.append(outer_point[1])
+      
+
+    return int(np.mean(xs)*width),int(np.mean(ys)*height)
+
+  # Loop through the detected faces to visualize.
+  for idx in range(len(face_landmarks_list)):
+    face_landmarks = face_landmarks_list[idx]
+
+    # Draw the face landmarks. #something change format
+    face_landmarks_proto = landmark_pb2.NormalizedLandmarkList()
+    face_landmarks_proto.landmark.extend([
+      landmark_pb2.NormalizedLandmark(x=landmark.x, y=landmark.y, z=landmark.z) for landmark in face_landmarks
+    ])
+
+
+    def draw_sets(draw_set,color=(0,255,0)):
+        solutions.drawing_utils.draw_landmarks(
+        image=annotated_image,
+        landmark_list=face_landmarks_proto,
+        connections=draw_set,
+        landmark_drawing_spec=None,
+        connection_drawing_spec=mp.solutions.drawing_styles.DrawingSpec(color=color, thickness=1 ))
+    def draw_triangle(index1,index2,index3):
+       draw_sets({(index1,index2),(index2,index3),(index3,index1)})
+
+    def draw_lines(array,color=(0,0,128)):
+      my_set = set()
+      for i in range(len(array)-1):
+         v = (array[i],array[i+1])
+         my_set.add(v)
+      draw_sets(my_set,color)
+
+    def convert_to_box(face_landmarks_list,indices,w=1024,h=1024):
+      x1=0
+      y1=0
+      x2=w
+      y2=h
+      for index in indices:
+        x=min(w,max(0,(face_landmarks_list[0][index].x*w)))
+        y=min(h,max(0,(face_landmarks_list[0][index].y*h)))
+        if x>x1:
+          x1=x
+        if y>y1:
+          y1=y
+        
+        if x<x2:
+          x2=x
+        if y<y2:
+          y2=y
+
+      return [x1,y1,x2-x1,y2-y1]
+          
+       
+    my_set ={(362,382),(382,398),(398,362)}
+    my_set = mp.solutions.face_mesh.FACEMESH_RIGHT_EYE
+
+    #mediapipe to 5point
+    """
+    draw_triangle(362,382,398)
+    draw_triangle(173,133,155)
+    draw_triangle(33,246,7)
+    draw_triangle(249,263,466)
+
+    draw_triangle(94,2,164)
+
+    draw_triangle(61,76,61)
+    draw_triangle(291,306,291)
+   
+    draw_lines([17,18,200,199,175,152])
+
+    draw_lines([127,234,93,132,58,172,136,150,149,176,148,152],(255,0,0))
+    #draw_lines([127,234,132,172,150,176,152],(0,0,255))
+    """
+
+    #
+    #draw_lines([9,107])
+    """
+    draw_lines([148,171,208])
+    draw_lines([176,140])
+    draw_lines([149,170,211])
+    draw_lines([150,169,])
+   
+    draw_lines([150,169])
+    draw_lines([136,135,214])
+    draw_lines([172,138,192])
+    draw_lines([58,215])
+    draw_lines([132,177,147])
+    draw_lines([58,215,213])
+    draw_lines([93,137,123])
+    #draw_lines([234,227])
+    #draw_lines([127,34,143])
+
+    """
+    #draw_lines([378,288,356,251,151,21,127,58,150,152])
+    #draw_lines(LINE_RIGHT_CONTOUR_OUTER_EYE_TO_CHIN)
+    #draw_lines(LINE_RIGHT_CONTOUR_EYE_TO_CHIN)
+    #draw_lines(LINE_RIGHT_CONTOUR_INNER_EYE_TO_CHIN,(0,255,0))
+    """
+    draw_lines(LINE_RIGHT_CONTOUR_0)
+    draw_lines(LINE_RIGHT_CONTOUR_1)
+    draw_lines(LINE_RIGHT_CONTOUR_2)
+    draw_lines(LINE_RIGHT_CONTOUR_3)
+    draw_lines(LINE_RIGHT_CONTOUR_4)
+    draw_lines(LINE_RIGHT_CONTOUR_5)
+    draw_lines(LINE_RIGHT_CONTOUR_6)
+    draw_lines(LINE_RIGHT_CONTOUR_7)
+    draw_lines(LINE_RIGHT_CONTOUR_8)
+    draw_lines(LINE_RIGHT_CONTOUR_9)
+    draw_lines(LINE_RIGHT_CONTOUR_10)
+    draw_lines(LINE_RIGHT_CONTOUR_11)
+
+    
+    draw_lines(LINE_LEFT_CONTOUR_1)
+    draw_lines(LINE_LEFT_CONTOUR_2)
+    draw_lines(LINE_LEFT_CONTOUR_3)
+    draw_lines(LINE_LEFT_CONTOUR_4)
+    draw_lines(LINE_LEFT_CONTOUR_5)
+    draw_lines(LINE_LEFT_CONTOUR_6)
+    draw_lines(LINE_LEFT_CONTOUR_7)
+    draw_lines(LINE_LEFT_CONTOUR_8)
+    draw_lines(LINE_LEFT_CONTOUR_9)
+    draw_lines(LINE_LEFT_CONTOUR_10)
+    draw_lines(LINE_LEFT_CONTOUR_11)
+    #draw_lines(LINE_LEFT_CONTOUR_12)
+    """
+
+    #draw_lines(LINE_RIGHT_CONTOUR_6,(255,0,0))
+    
+    def get_eye_brow_points(landmarks):
+      result_points= []
+      for landmark in landmarks:
+        point=get_mean_point(landmark)
+        result_points.append(point)
+
+      return result_points
+    
+    def get_mean_points(landmarks):
+      result_points= []
+      for landmark in landmarks:
+        point=get_mean_point(landmark)
+        result_points.append(point)
+
+      return result_points
+    
+    def get_divided_points(landmarks,divided=3):
+      result_points= []
+      landmark_points = []
+      for landmark in landmarks:
+        if isinstance(landmark, int):
+          pt=get_cordinate_point(landmark)
+        else:
+          pt =get_mean_point(landmark)
+        landmark_points.append(pt)
+
+      divided_points = divide_line_to_points(landmark_points,divided)
+
+      #print(centers[0][0]*1024,",",centers[0][1]*1024)
+      return divided_points
+    
+    
+    def get_half_contour(landmarks):
+      result_points= []
+      landmark_points = []
+      for landmark in landmarks:
+        pt =get_point(landmark)
+        landmark_points.append(pt)
+
+      divided_points = divide_line_to_points(landmark_points,8)#9
+      #for pt in divided_points:
+      #  cv2.circle(annotated_image,pt,3,(255,0,0),-1)
+      #  result_points.append((pt[0],pt[1]))
+
+      #print(centers[0][0]*1024,",",centers[0][1]*1024)
+      return divided_points
+    
+    right_landmarks =[
+      #[LANDMARK_68_CONTOUR_5]
+      [LANDMARK_68_CONTOUR_1],[LANDMARK_68_CONTOUR_2_PART1,LANDMARK_68_CONTOUR_2_PART2],[LANDMARK_68_CONTOUR_3],[LANDMARK_68_CONTOUR_4],[LANDMARK_68_CONTOUR_5],[LANDMARK_68_CONTOUR_6_PART1,LANDMARK_68_CONTOUR_6_PART2],[LANDMARK_68_CONTOUR_7],[LANDMARK_68_CONTOUR_8_PART1,LANDMARK_68_CONTOUR_8_PART2],[LANDMARK_68_CONTOUR_9],
+     
+    ]
+    contour_right_points=get_half_contour(right_landmarks)
+
+    left_landmarks =[
+     [LANDMARK_68_CONTOUR_9], [LINE_LEFT_CONTOUR_1], [LINE_LEFT_CONTOUR_2], [LINE_LEFT_CONTOUR_3], [LINE_LEFT_CONTOUR_4],[LINE_LEFT_CONTOUR_5],[LINE_LEFT_CONTOUR_6],[LINE_LEFT_CONTOUR_7],[LINE_LEFT_CONTOUR_8],[LINE_LEFT_CONTOUR_9],[LINE_LEFT_CONTOUR_10],[LINE_LEFT_CONTOUR_11]
+    ]
+    contour_left_points=get_half_contour(left_landmarks)
+
+    set_plot_text(draw_number,font_scale,text_color) # for reset
+    plot_points(annotated_image,contour_right_points+contour_left_points[1:],False,dot_size,dot_color,line_size,line_color)
+
+    right_eye_brow_points=get_eye_brow_points([
+      LANDMARK_68_RIGHT_EYEBROW_18,LANDMARK_68_RIGHT_EYEBROW_19,LANDMARK_68_RIGHT_EYEBROW_20,LANDMARK_68_RIGHT_EYEBROW_21,LANDMARK_68_RIGHT_EYEBROW_22
+    ])
+    plot_points(annotated_image,right_eye_brow_points,False,dot_size,dot_color,line_size,line_color)
+    left_eye_brow_points=get_eye_brow_points([
+      LANDMARK_68_LEFT_EYEBROW_23,LANDMARK_68_LEFT_EYEBROW_24,LANDMARK_68_LEFT_EYEBROW_25,LANDMARK_68_LEFT_EYEBROW_26,LANDMARK_68_LEFT_EYEBROW_27
+    ])
+    plot_points(annotated_image,left_eye_brow_points,False,dot_size,dot_color,line_size,line_color)
+
+    vertical_nose_points = get_divided_points([LANDMARK_68_VERTICAL_NOSE_28,LANDMARK_68_VERTICAL_NOSE_29,LANDMARK_68_VERTICAL_NOSE_30,LANDMARK_68_VERTICAL_NOSE_31],3)
+    plot_points(annotated_image,vertical_nose_points,False,dot_size,dot_color,line_size,line_color)
+
+    horizontal_nose_points = get_mean_points([LANDMARK_68_HORIZONTAL_NOSE_32,LANDMARK_68_HORIZONTAL_NOSE_33,LANDMARK_68_HORIZONTAL_NOSE_34,LANDMARK_68_HORIZONTAL_NOSE_35,LANDMARK_68_HORIZONTAL_NOSE_36])
+    plot_points(annotated_image,horizontal_nose_points,False,dot_size,dot_color,line_size,line_color)
+
+    right_upper_eye_points = get_divided_points(LINE_RIGHT_UPPER_MIXED_EYE2,3)
+    right_lower_eye_points = get_divided_points(LINE_RIGHT_LOWER_MIXED_EYE,3)
+    #right_eye_points = right_upper_eye_points+right_lower_eye_points # first and last is same as above
+    right_eye_points = right_upper_eye_points+right_lower_eye_points[1:-1]
+    plot_points(annotated_image,right_eye_points,True,dot_size,dot_color,line_size,line_color)
+    
+    #draw_lines(LINE_RIGHT_LOWER_OUTER_EYE,(0,255,0))
+    #draw_lines(LINE_RIGHT_LOWER_INNER_EYE,(0,255,0))
+    #draw_lines(LINE_RIGHT_UPPER_OUTER_EYE,(0,255,0))
+    #draw_lines(LINE_RIGHT_UPPER_INNER_EYE,(0,255,0))
+
+    left_upper_eye_points = get_divided_points(LINE_LEFT_UPPER_MIXED_EYE2,3)
+    left_lower_eye_points = get_divided_points(LINE_LEFT_LOWER_MIXED_EYE,3)
+    #left_eye_points = left_upper_eye_points+left_lower_eye_points# first and last is same as above
+    left_eye_points = left_upper_eye_points+left_lower_eye_points[1:-1]
+    plot_points(annotated_image,left_eye_points,True,dot_size,dot_color,line_size,line_color)
+    # first and last is same as above
+
+    #draw_lines(LINE_LEFT_LOWER_OUTER_EYE,(0,255,0))
+    #draw_lines(LINE_LEFT_LOWER_INNER_EYE,(0,255,0))
+    #draw_lines(LINE_LEFT_UPPER_OUTER_EYE,(0,255,0))
+    #draw_lines(LINE_LEFT_UPPER_INNER_EYE,(0,255,0))
+
+    left_upper_outer_lip_points = get_divided_points(LINE_RIGHT_UPPER_OUTER_LIP,3)
+    right_upper_outer_lip_points = get_divided_points(LINE_LEFT_UPPER_OUTER_LIP,3)
+    upper_outer_lip_points = left_upper_outer_lip_points+right_upper_outer_lip_points[1:]# first and last is same as above
+    #plot_points(annotated_image,upper_outer_lip_points)
+    upper_outer_lip_points = get_mean_points([LANDMARK_68_UPPER_OUTER_LIP_49,LANDMARK_68_UPPER_OUTER_LIP_50,LANDMARK_68_UPPER_OUTER_LIP_51,LANDMARK_68_UPPER_OUTER_LIP_52,LANDMARK_68_UPPER_OUTER_LIP_53,LANDMARK_68_UPPER_OUTER_LIP_54,LANDMARK_68_UPPER_OUTER_LIP_55])
+    #plot_points(annotated_image,upper_outer_lip_points)
+
+    lower_outer_lip_points = get_mean_points([LANDMARK_68_UPPER_OUTER_LIP_55,LANDMARK_68_LOWER_OUTER_LIP_56,LANDMARK_68_LOWER_OUTER_LIP_57,LANDMARK_68_LOWER_OUTER_LIP_58,LANDMARK_68_LOWER_OUTER_LIP_59,LANDMARK_68_LOWER_OUTER_LIP_60,LANDMARK_68_UPPER_OUTER_LIP_49])
+    outer_lip_points = upper_outer_lip_points+lower_outer_lip_points[1:-1]
+    plot_points(annotated_image,outer_lip_points,True,dot_size,dot_color,line_size,line_color)
+
+    upper_inner_lip_points = get_mean_points([LANDMARK_68_UPPER_INNER_LIP_61,LANDMARK_68_UPPER_INNER_LIP_62,LANDMARK_68_UPPER_INNER_LIP_63,LANDMARK_68_UPPER_INNER_LIP_64,LANDMARK_68_UPPER_INNER_LIP_65])
+    #plot_points(annotated_image,upper_inner_lip_points)
+
+    lower_inner_lip_points = get_mean_points([LANDMARK_68_UPPER_INNER_LIP_65,LANDMARK_68_LOWER_INNER_LIP_66,LANDMARK_68_LOWER_INNER_LIP_67,LANDMARK_68_LOWER_INNER_LIP_68,LANDMARK_68_UPPER_INNER_LIP_61])
+    inner_lip_points = upper_inner_lip_points+lower_inner_lip_points[1:-1]
+    plot_points(annotated_image,inner_lip_points,True,dot_size,dot_color,line_size,line_color)
+
+    landmark_points = contour_right_points+contour_left_points[1:]
+    landmark_points += right_eye_brow_points + left_eye_brow_points
+    landmark_points += vertical_nose_points + horizontal_nose_points
+    landmark_points += right_eye_points + left_eye_points
+    landmark_points += outer_lip_points + inner_lip_points
+
+    #plot_points(annotated_image,landmark_points,20) # for debug
+    bbox = points_to_bbox(landmark_points)
+    bbox = expand_bbox(bbox,5,7,5,5)
+
+    draw_bbox(annotated_image,bbox,box_color,box_size)
+    #draw_lines([POINT_LEFT_HEAD_OUTER_EX,POINT_LEFT_EYE_OUTER_EX,POINT_LEFT_MOUTH_OUTER_EX,POINT_LEFT_CHIN_OUTER,POINT_CHIN_BOTTOM])
+    #draw_lines([LANDMARK_68_CONTOUR_1,LANDMARK_68_CONTOUR_2,LANDMARK_68_CONTOUR_3,LANDMARK_68_CONTOUR_4,LANDMARK_68_CONTOUR_5,LANDMARK_68_CONTOUR_6,LANDMARK_68_CONTOUR_7,LANDMARK_68_CONTOUR_8,LANDMARK_68_CONTOUR_9])
+    """solutions.drawing_utils.draw_landmarks(
+        image=annotated_image,
+        landmark_list=face_landmarks_proto,
+        connections=mp.solutions.face_mesh.FACEMESH_LEFT_EYE,#FACE_OVAL
+        landmark_drawing_spec=None,
+        connection_drawing_spec=mp.solutions.drawing_styles
+        .get_default_face_mesh_contours_style())"""
+
+    """solutions.drawing_utils.draw_landmarks(
+        image=annotated_image,
+        landmark_list=face_landmarks_proto,
+        connections=mp.solutions.face_mesh.FACEMESH_CONTOURS,# mix all
+        landmark_drawing_spec=None,
+        connection_drawing_spec=mp.solutions.drawing_styles
+        .get_default_face_mesh_contours_style())  
+     """
+    """solutions.drawing_utils.draw_landmarks(
+        image=annotated_image,
+        landmark_list=face_landmarks_proto,
+        connections=mp.solutions.face_mesh.FACEMESH_IRISES,
+          landmark_drawing_spec=None,
+          connection_drawing_spec=mp.solutions.drawing_styles
+          .get_default_face_mesh_iris_connections_style()) """
+
+  return annotated_image,bbox,landmark_points
+
+
+if __name__ == "__main__":
+  args = parse_arguments()
+  input_file = args.input_file
+
+#file checks
+  if not os.path.isfile(input_file):
+    print(f"input is not file '{input_file}'")
+    exit(0)
+
+  model_path = args.model_path
+
+  BaseOptions = mp.tasks.BaseOptions
+  FaceLandmarker = mp.tasks.vision.FaceLandmarker
+  FaceLandmarkerOptions = mp.tasks.vision.FaceLandmarkerOptions
+  VisionRunningMode = mp.tasks.vision.RunningMode
+
+  options = FaceLandmarkerOptions(
+      base_options=BaseOptions(model_asset_path=model_path),
+      running_mode=VisionRunningMode.IMAGE
+      ,min_face_detection_confidence=0, min_face_presence_confidence=0
+      )
+
+
+  with FaceLandmarker.create_from_options(options) as landmarker:
+      
+      start = time.time()
+      mp_image = mp.Image.create_from_file(input_file)
+      face_landmarker_result = landmarker.detect(mp_image)
+      detect_time = time.time()-start
+      print(detect_time)
+      
+      annotated_image,bbox,landmark_points = draw_landmarks_on_image(mp_image.numpy_view(), face_landmarker_result)
+      #print(annotated_image)
+      #annotated_image=cv2.resize(annotated_image, (800, 800))
+      annotated_image=cv2.cvtColor(annotated_image, cv2.COLOR_RGB2BGR)
+      cv2.imwrite(input_file.replace(".jpg","_la68.jpg"),annotated_image)
+
+      if args.save_glandmark:
+        parent_path,file = os.path.split(input_file)
+        glandmark = bbox_to_glandmarks(file,bbox,landmark_points)
+        glandmark_path = input_file.replace(".jpg",f".json")
+        if os.path.exists(glandmark_path):
+            print(f"glandmark exist skipped {glandmark_path}")
+        else:
+            import json
+            with open(glandmark_path,"w") as f:
+                json.dump(glandmark,f)
+
+      # _landmark.json always overwrite because not design for edit
+      if args.save_group_landmark:
+        result=convert_to_landmark_group_json(landmark_points)
+        total = 0
+        for key in result[0].keys():
+          total += len(result[0][key])
+
+        print(total)
+        import json
+        group_landmark_path = input_file.replace(".jpg",f"_landmark.json")
+        with open(group_landmark_path,"w") as f:
+              json.dump(result,f)
+
+    #cv2.imshow("image",)
+    #cv2.waitKey(0)
+    #cv2.destroyAllWindows()
+

face_landmarker.task

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64184e229b263107bc2b804c6625db1341ff2bb731874b0bcc2fe6544e0bc9ff
+size 3758596

face_landmarker.task.txt

@@ -0,0 +1,8 @@
+Face landmark detection
+https://ai.google.dev/edge/mediapipe/solutions/vision/face_landmarker
+
+model card page is 
+https://storage.googleapis.com/mediapipe-assets/MediaPipe%20BlazeFace%20Model%20Card%20(Short%20Range).pdf
+
+license is Apache2.0
+https://www.apache.org/licenses/LICENSE-2.0.html

glibvision/common_utils.py

@@ -0,0 +1,112 @@
+import os
+def check_exists_files(files,dirs,exit_on_error=True):
+    if files is not None:
+        if isinstance(files, str):  
+            files = [files]
+        for file in files:
+            if not os.path.isfile(file):
+                print(f"File {file} not found")
+                if exit_on_error:
+                    exit(1)
+                else:
+                    return 1
+    if dirs is not None:
+        if isinstance(dirs, str):  
+            dirs = [dirs]
+        for dir in dirs:
+            if not os.path.isdir(dir):
+                print(f"Dir {dir} not found")
+                if exit_on_error:
+                    exit(1)
+                else:
+                    return 1
+    return 0
+
+image_extensions =[".jpg"]
+
+def add_name_suffix(file_name,suffix,replace_suffix=False):
+    if not suffix.startswith("_"):#force add
+        suffix="_"+suffix
+
+    name,ext = os.path.splitext(file_name)
+    if replace_suffix:
+        index = name.rfind("_")
+        if index!=-1:
+            return f"{name[0:index]}{suffix}{ext}"
+        
+    return f"{name}{suffix}{ext}"
+
+def replace_extension(file_name,new_extension,suffix=None,replace_suffix=False):
+    if not new_extension.startswith("."):
+        new_extension="."+new_extension
+
+    name,ext = os.path.splitext(file_name)
+    new_file = f"{name}{new_extension}"
+    if suffix:
+        return add_name_suffix(name+new_extension,suffix,replace_suffix)
+    return new_file
+
+def list_digit_images(input_dir,sort=True):
+    digit_images = []
+    global image_extensions
+    files = os.listdir(input_dir)
+    for file in files:
+        if file.endswith(".jpg"):#TODO check image
+            base,ext = os.path.splitext(file)
+            if not base.isdigit():
+                continue
+            digit_images.append(file) 
+
+    if sort:
+        digit_images.sort()
+
+    return digit_images
+def list_suffix_images(input_dir,suffix,is_digit=True,sort=True):
+    digit_images = []
+    global image_extensions
+    files = os.listdir(input_dir)
+    for file in files:
+        if file.endswith(".jpg"):#TODO check image
+            base,ext = os.path.splitext(file)
+            if base.endswith(suffix):
+                if is_digit:
+                    if not base.replace(suffix,"").isdigit():
+                        continue
+                digit_images.append(file) 
+
+    if sort:
+        digit_images.sort()
+
+    return digit_images
+
+import time
+
+class ProgressTracker:
+    """
+    処理の進捗状況を追跡し、経過時間と残り時間を表示するクラス。
+    """
+
+    def __init__(self,key, total_target):
+        """
+        コンストラクタ
+
+        Args:
+            total_target (int): 処理対象の総数
+        """
+        self.key = key
+        self.total_target = total_target
+        self.complete_target = 0
+        self.start_time = time.time()
+
+    def update(self):
+        """
+        進捗を1つ進める。
+        経過時間と残り時間を表示する。
+        """
+        self.complete_target += 1
+        current_time = time.time()
+        consumed_time = current_time - self.start_time
+        remain_time = (consumed_time / self.complete_target) * (self.total_target - self.complete_target) if self.complete_target > 0 else 0 
+        print(f"stepped {self.key} {self.total_target} of {self.complete_target}, consumed {(consumed_time / 60):.1f} min, remain {(remain_time / 60):.1f} min")
+
+    

glibvision/cv2_utils.py

@@ -0,0 +1,138 @@
+import cv2
+import numpy as np
+
+
+
+def draw_bbox(image,box,color=(255,0,0),thickness=1):
+  if thickness==0:
+    return
+  
+  left = int(box[0])
+  top = int(box[1])
+  right = int(box[0]+box[2])
+  bottom = int(box[1]+box[3])
+  box_points =[(left,top),(right,top),(right,bottom),(left,bottom)]
+  
+  cv2.polylines(image, [np.array(box_points)], isClosed=True, color=color, thickness=thickness)
+
+
+def to_int_points(points):
+  int_points=[]
+  for point in points:
+    int_points.append([int(point[0]),int(point[1])])
+  return int_points
+
+def draw_text(img, text, point, font_scale=0.5, color=(200, 200, 200), thickness=1):
+  font = cv2.FONT_HERSHEY_SIMPLEX
+  cv2.putText(img, str(text), point, font, font_scale, color, thickness, cv2.LINE_AA)
+
+plot_text_color = (200, 200, 200)
+plot_text_font_scale = 0.5
+plot_index = 1
+plot_text = True
+
+def set_plot_text(is_plot,text_font_scale,text_color):
+  global plot_index,plot_text,plot_text_font_scale,plot_text_color
+  plot_text = is_plot
+  plot_index = 1
+  plot_text_font_scale = text_font_scale
+  plot_text_color = text_color
+
+def plot_points(image,points,isClosed=False,circle_size=3,circle_color=(255,0,0),line_size=1,line_color=(0,0,255)):
+    global plot_index,plot_text
+    int_points = to_int_points(points)
+    if circle_size>0:
+      for point in int_points:
+        cv2.circle(image,point,circle_size,circle_color,-1)
+        if plot_text:
+          draw_text(image,plot_index,point,plot_text_font_scale,plot_text_color)
+        plot_index+=1
+    if line_size>0:
+      cv2.polylines(image, [np.array(int_points)], isClosed=isClosed, color=line_color, thickness=line_size)
+
+def fill_points(image,points,thickness=1,line_color=(255,255,255),fill_color = (255,255,255)):
+    np_points = np.array(points,dtype=np.int32)
+    cv2.fillPoly(image, [np_points], fill_color)
+    cv2.polylines(image, [np_points], isClosed=True, color=line_color, thickness=thickness)
+
+def get_image_size(cv2_image):
+    return cv2_image.shape[:2]
+
+def get_channel(np_array):
+    return np_array.shape[2] if np_array.ndim == 3 else 1 
+
+def get_numpy_text(np_array,key=""):
+    channel = get_channel(np_array)
+    return f"{key} shape = {np_array.shape} channel = {channel} ndim = {np_array.ndim} size = {np_array.size}"
+
+
+def gray3d_to_2d(grayscale: np.ndarray) -> np.ndarray:
+    channel = get_channel(grayscale)
+    if channel!=1:
+        raise ValueError(f"color maybe rgb or rgba {get_numpy_text(grayscale)}")
+    """
+    3 次元グレースケール画像 (チャンネル数 1) を 2 次元に変換する。
+
+    Args:
+        grayscale (np.ndarray): 3 次元グレースケール画像 (チャンネル数 1)。
+
+    Returns:
+        np.ndarray: 2 次元グレースケール画像。
+    """
+
+    if grayscale.ndim == 2:
+        return grayscale
+    return np.squeeze(grayscale)
+
+def blend_rgb_images(image1: np.ndarray, image2: np.ndarray, mask: np.ndarray) -> np.ndarray:
+    """
+    2 つの RGB 画像をマスク画像を使用してブレンドする。
+
+    Args:
+        image1 (np.ndarray): 最初の画像 (RGB)。
+        image2 (np.ndarray): 2 番目の画像 (RGB)。
+        mask (np.ndarray): マスク画像 (グレースケール)。
+
+    Returns:
+        np.ndarray: ブレンドされた画像 (RGB)。
+
+    Raises:
+        ValueError: 入力画像の形状が一致しない場合。
+    """
+
+    if image1.shape != image2.shape or image1.shape[:2] != mask.shape:
+        raise ValueError("入力画像の形状が一致しません。")
+
+    # 画像を float 型に変換
+    image1 = image1.astype(float)
+    image2 = image2.astype(float)
+
+    # マスクを 3 チャンネルに変換し、0-1 の範囲にスケール
+    alpha = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR).astype(float) / 255.0
+
+    # ブレンド計算
+    blended = (1 - alpha) * image1 + alpha * image2
+
+    return blended.astype(np.uint8)
+
+def create_color_image(img,color=(255,255,255)):
+    mask = np.zeros_like(img)
+    
+    h, w = img.shape[:2]
+    cv2.rectangle(mask, (0, 0), (w, h), color, -1)
+    return mask
+
+def pil_to_bgr_image(image):
+  np_image = np.array(image, dtype=np.uint8)
+  if np_image.shape[2] == 4:
+      bgr_img = cv2.cvtColor(np_image, cv2.COLOR_RGBA2BGRA)
+  else:
+      bgr_img = cv2.cvtColor(np_image, cv2.COLOR_RGB2BGR)
+  return bgr_img
+
+def bgr_to_rgb(np_image):
+  if np_image.shape[2] == 4:
+      bgr_img = cv2.cvtColor(np_image, cv2.COLOR_RBGRA2RGBA)
+  else:
+      bgr_img = cv2.cvtColor(np_image, cv2.COLOR_BGR2RGB)
+  return bgr_img

glibvision/glandmark_utils.py

@@ -0,0 +1,48 @@
+
+import os
+
+#simple single version
+def bbox_to_glandmarks(file_name,bbox,points = None):
+     base,ext = os.path.splitext(file_name)
+     glandmark = {"image":{
+            "boxes":[{
+                "left":int(bbox[0]),"top":int(bbox[1]),"width":int(bbox[2]),"height":int(bbox[3])
+            }],
+            "file":file_name,
+            "id":int(base) 
+            # width,height ignore here
+            }}
+     if points is not None:
+          parts=[
+          ]
+          for point in points:
+               parts.append({"x":int(point[0]),"y":int(point[1])})
+          glandmark["image"]["boxes"][0]["parts"] = parts
+     return glandmark
+
+#technically this is not g-landmark/dlib ,
+def convert_to_landmark_group_json(points):
+     if len(points)!=68:
+          print(f"points must be 68 but {len(points)}")
+          return None
+     new_points=list(points)
+     
+     result = [ # possible multi person ,just possible any func support multi person
+         
+          {    # index start 0 but index-number start 1
+               "chin":new_points[0:17],
+               "left_eyebrow":new_points[17:22],
+               "right_eyebrow":new_points[22:27],
+               "nose_bridge":new_points[27:31],
+               "nose_tip":new_points[31:36],
+               "left_eye":new_points[36:42],
+               "right_eye":new_points[42:48],
+               
+               # lip points customized structure  
+               # MIT licensed face_recognition
+               # https://github.com/ageitgey/face_recognition
+               "top_lip":new_points[48:55]+[new_points[64]]+[new_points[63]]+[new_points[62]]+[new_points[61]]+[new_points[60]],
+               "bottom_lip":new_points[54:60]+[new_points[48]]+[new_points[60]]+[new_points[67]]+[new_points[66]]+[new_points[65]]+[new_points[64]],
+          }
+     ]
+     return result

glibvision/numpy_utils.py

@@ -0,0 +1,110 @@
+import numpy as np
+
+
+def apply_binary_mask_to_color(base_image,color,mask):
+    """
+    二値マスクを使用して、画像の一部を別の画像にコピーする。
+
+    Args:
+        base_image (np.ndarray): コピー先の画像。
+        paste_image (np.ndarray): コピー元の画像。
+        mask (np.ndarray): 二値マスク画像。
+
+    Returns:
+        np.ndarray: マスクを適用した画像。
+
+    """
+    # TODO check all shape
+    #print_numpy(base_image)
+    #print_numpy(paste_image)
+    #print_numpy(mask)
+    if mask.ndim == 2:
+        condition = mask == 255
+    else:
+        condition = mask[:,:,0] == 255
+    
+    base_image[condition] = color
+    return base_image
+
+def apply_binary_mask_to_image(base_image,paste_image,mask):
+    """
+    二値マスクを使用して、画像の一部を別の画像にコピーする。
+
+    Args:
+        base_image (np.ndarray): コピー先の画像。
+        paste_image (np.ndarray): コピー元の画像。
+        mask (np.ndarray): 二値マスク画像。
+
+    Returns:
+        np.ndarray: マスクを適用した画像。
+
+    """
+    # TODO check all shape
+    #print_numpy(base_image)
+    #print_numpy(paste_image)
+    #print_numpy(mask)
+    if mask.ndim == 2:
+        condition = mask == 255
+    else:
+        condition = mask[:,:,0] == 255
+    
+    base_image[condition] = paste_image[condition]
+    return base_image
+
+def pil_to_numpy(image):
+    return np.array(image, dtype=np.uint8)
+
+def extruce_points(points,index,ratio=1.5):
+    """
+    indexのポイントをratio倍だけ、点群の中心から、外側に膨らます。
+    """
+    center_point = np.mean(points, axis=0)
+    if index < 0 or index > len(points):
+        raise ValueError(f"index must be range(0,{len(points)} but value = {index})")
+    point1 =points[index]
+    print(f"center = {center_point}")
+    vec_to_center = point1 - center_point
+    return vec_to_center*ratio + center_point
+
+
+def bulge_polygon(points, bulge_factor=0.1,isClosed=True):
+    """
+    ポリゴンの辺の中間に点を追加し、外側に膨らませる
+    ndarrayを返すので注意
+    """
+    # 入力 points を NumPy 配列に変換
+    points = np.array(points)
+
+    # ポリゴン全体の重心を求める
+    center_point = np.mean(points, axis=0)
+    #print(f"center = {center_point}")
+    new_points = []
+    num_points = len(points)
+    for i in range(num_points):
+        if i == num_points -1 and not isClosed:
+            break
+        p1 = points[i]
+        #print(f"p{i} = {p1}")
+        # 重心から頂点へのベクトル
+        #vec_to_center = p1 - center_point
+        
+        # 辺のベクトルを求める
+        mid_diff = points[(i + 1) % num_points] - p1
+        mid = p1+(mid_diff/2)
+
+        #print(f"mid = {mid}")
+        out_vec = mid - center_point
+
+        # 重心からのベクトルに bulge_vec を加算
+        new_point = mid + out_vec * bulge_factor
+        
+        new_points.append(p1)
+        new_points.append(new_point.astype(np.int32))
+
+    return np.array(new_points)
+
+
+# image.shape rgb are (1024,1024,3) use 1024,1024 as 2-dimensional
+def create_2d_image(shape):
+    grayscale_image = np.zeros(shape[:2], dtype=np.uint8)
+    return grayscale_image

glibvision/pil_utils.py

@@ -0,0 +1,14 @@
+from PIL import Image,ImageDraw
+
+def create_color_image(width, height, color=(255,255,255)):
+    img = Image.new('RGB', (width, height), color)
+    return img
+
+def fill_points(image,points,color=(255,255,255)):
+    draw = ImageDraw.Draw(image)
+    int_points = [(int(x), int(y)) for x, y in points]
+    draw.polygon(int_points, fill=color)
+    return image
+
+def from_numpy(numpy_array):
+    return Image.fromarray(numpy_array)

gradio_utils.py

@@ -0,0 +1,60 @@
+
+
+import os
+import time
+import io
+import hashlib
+
+def clear_old_files(dir="files",passed_time=60*60):
+    try:
+        files = os.listdir(dir)
+        current_time = time.time()
+        for file in files:
+            file_path = os.path.join(dir,file)
+            
+            ctime = os.stat(file_path).st_ctime
+            diff = current_time - ctime
+            #print(f"ctime={ctime},current_time={current_time},passed_time={passed_time},diff={diff}")
+            if diff > passed_time:
+                os.remove(file_path)
+    except:
+            print("maybe still gallery using error")
+
+def get_buffer_id(buffer):
+    hash_object = hashlib.sha256(buffer.getvalue())
+    hex_dig = hash_object.hexdigest()
+    unique_id = hex_dig[:32]
+    return unique_id
+
+def get_image_id(image):
+    buffer = io.BytesIO()
+    image.save(buffer, format='PNG')
+    return get_buffer_id(buffer)
+
+def save_image(image,extension="jpg",dir_name="files"):
+    id = get_image_id(image)
+    os.makedirs(dir_name,exist_ok=True)
+    file_path = f"{dir_name}/{id}.{extension}"
+    
+    image.save(file_path)
+    return file_path
+
+def save_buffer(buffer,extension="webp",dir_name="files"):
+    id = get_buffer_id(buffer)
+    os.makedirs(dir_name,exist_ok=True)
+    file_path = f"{dir_name}/{id}.{extension}"
+    
+    with open(file_path,"wb") as f:
+         f.write(buffer.getvalue())
+    return file_path
+
+def write_file(file_path,text):
+    with open(file_path, 'w', encoding='utf-8') as f:
+        f.write(text)
+
+def read_file(file_path):
+    """read the text of target file
+    """
+    with open(file_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+    return content

landmarks68_utils.py

@@ -0,0 +1,147 @@
+import numpy as np
+from PIL import Image,ImageDraw
+from glibvision.numpy_utils import extruce_points,bulge_polygon
+
+
+def minus_point(pt1,pt2):
+    return [pt1[0]-pt2[0],pt1[1]-pt2[1]]
+
+def lerp_point(pt1,pt2,pt2_ratio):
+    return [int(pt1[0]*(1.0-pt2_ratio)+pt2[0]*pt2_ratio),pt1[1]*(1.0-pt2_ratio)+pt2[1]*pt2_ratio]
+
+def mean_point(points):
+    xs = 0
+    ys = 0
+    for pt in points:
+        xs +=pt[0]
+        ys +=pt[1]
+    return [int(xs/len(points)),int(ys/len(points))]
+
+def get_face_points(face_landmarks_list):
+    contour_points=get_landmark_points(face_landmarks_list,PARTS_CONTOUR)
+    left_eyebrow_points=get_landmark_points(face_landmarks_list,PARTS_LEFT_EYEBROW)
+
+    right_eyebrow_points=get_landmark_points(face_landmarks_list,PARTS_RIGHT_EYEBROW)
+
+    nose_points=get_landmark_points(face_landmarks_list,PARTS_NOSE_BRIDGE)
+    
+    diff_right = minus_point(contour_points[1],contour_points[0])
+    right_minus_corner = minus_point(contour_points[0] , diff_right)
+    right_contour = lerp_point(right_minus_corner,left_eyebrow_points[0],0.3)
+
+    diff_left = minus_point(contour_points[15],contour_points[16])
+    left_minus_corner = minus_point(contour_points[16] , diff_left)
+    left_contour = lerp_point(left_minus_corner,right_eyebrow_points[-1],0.3)
+
+    middle_face = mean_point([nose_points[0],right_eyebrow_points[0],left_eyebrow_points[-1]])
+    return [right_contour]+list(contour_points)+[left_contour,middle_face]
+
+
+def get_innner_mouth_points(face_landmarks_list):
+    top_points=get_landmark_points(face_landmarks_list,PARTS_UPPER_LIP)
+    bottom_points=get_landmark_points(face_landmarks_list,PARTS_LOWER_LIP)
+    return top_points[7:]+bottom_points[7:]#[::-1]
+
+
+PARTS_UPPER_LIP = "top_lip"
+PARTS_LOWER_LIP = "bottom_lip"
+PARTS_CONTOUR ="chin"
+PARTS_LEFT_EYEBROW ="left_eyebrow"
+PARTS_RIGHT_EYEBROW ="right_eyebrow"
+PARTS_LEFT_EYE ="left_eye"
+PARTS_RIGHT_EYE ="right_eye"
+PARTS_NOSE_TIP ="nose_tip"
+PARTS_NOSE_BRIDGE ="nose_bridge"
+
+def get_landmark_points(face_landmarks_list,key):
+    matching_landmark_points = []
+    for face_landmarks in face_landmarks_list:
+      for landmark_name, landmark_points in face_landmarks.items():
+        matching_landmark_points = landmark_points.copy()
+        if landmark_name ==key:
+            return tuple(matching_landmark_points)
+        
+def get_left_upper_eyelid_points(face_landmarks_list,bulge_factor = 0.2):
+    eye_points=get_landmark_points(face_landmarks_list,PARTS_LEFT_EYE)
+    extruded_points=[]
+   
+    need_extrude =[0,1,2]
+    for index in range(len(eye_points)):
+        if index in need_extrude:
+            ratio = 1.3
+        else:
+            ratio = 1.1
+        ex_point=extruce_points(eye_points,index,ratio)
+        extruded_points.append(ex_point)
+    return extruded_points
+
+def get_right_upper_eyelid_points(face_landmarks_list,bulge_factor = 0.2):
+    eye_points=get_landmark_points(face_landmarks_list,PARTS_RIGHT_EYE)
+    extruded_points=[]
+   
+    need_extrude =[1,2,3]
+    for index in range(len(eye_points)):
+        if index in need_extrude:
+            ratio = 1.3
+        else:
+            ratio = 1.1
+        ex_point=extruce_points(eye_points,index,ratio)
+        extruded_points.append(ex_point)
+    #return list(eye_points[0:4])+extruded_points
+    return extruded_points
+
+def get_bulged_eyes(face_landmarks_list,bulge_factor=0.2):
+    points1=get_landmark_points(face_landmarks_list,PARTS_LEFT_EYE)
+    points2=get_landmark_points(face_landmarks_list,PARTS_RIGHT_EYE)
+    
+    return bulge_polygon(points1, bulge_factor=bulge_factor),bulge_polygon(points2, bulge_factor=bulge_factor)
+
+
+def get_lerp(point1,point2,ratio1=0.5):
+    x = point1[0]*ratio1 + point2[0]*(1.0-ratio1)
+    y = point1[1]*ratio1 + point2[1]*(1.0-ratio1)
+    return [int(x),int(y)]
+
+def get_close_eyelid_point(landmarks_list,bulge = 0.01):
+    left = get_landmark_points(landmarks_list,PARTS_LEFT_EYE)
+    left_points = [get_lerp(left[3],left[4],0.6)]+list(left[4:6])+[left[0]]
+    right = get_landmark_points(landmarks_list,PARTS_RIGHT_EYE)
+    right_points = [get_lerp(right[0],right[5],0.6)]+list(right[3:6][::-1])
+
+    #print("right points")
+    #print(right_points) 
+    last2 = right_points[-2:]
+    #print(last2[0])
+    #print(last2[1])
+    extra_dvidied = 10
+    diff = ((last2[0][0]-last2[1][0])/extra_dvidied,(last2[0][1]-last2[1][1])/extra_dvidied)
+    extra = [int(last2[1][0] - diff[0]),int(last2[1][1] - diff[1])]
+
+    height = abs(right_points[0][1]-right_points[-1][1])
+    print(f"height = {height}")
+    move_down = int(height/5)
+    print("diff")
+    print(diff)
+    print(right_points[-1])
+    print(extra)
+    right_points.append(extra)
+    for pt in right_points:
+        pt[1]+=move_down
+
+    last2 = left_points[-2:]
+    diff = ((last2[0][0]-last2[1][0])/extra_dvidied,(last2[0][1]-last2[1][1])/extra_dvidied)
+    extra = [int(last2[1][0] - diff[0]),int(last2[1][1] - diff[1])]
+    left_points.append(extra)
+    for pt in left_points:
+        pt[1]+=move_down
+
+    print(right_points)
+    if bulge:
+        left_points = bulge_polygon(left_points,0.1,False).tolist()
+        right_points = bulge_polygon(right_points,0.1,False).tolist()
+     ###LEFT
+    print("####RIGHT")
+    # last 2 points
+   
+   
+    return left_points,right_points

lip_utils.py

@@ -0,0 +1,781 @@
+import face_recognition
+import os
+import json
+#from glibvision.cv2_utils import get_numpy_text
+from glibvision.numpy_utils import bulge_polygon
+import numpy as np
+import math
+USE_CACHE = True
+
+# face structures are same
+# MIT LICENSED
+# https://github.com/ageitgey/face_recognition
+
+TOP_LIP = "top_lip"
+BOTTOM_LIP = "bottom_lip"
+PARTS_CHIN ="chin"
+PARTS_LEFT_EYEBROW ="left_eyebrow"
+PARTS_RIGHT_EYEBROW ="right_eyebrow"
+PARTS_LEFT_EYE ="left_eye"
+PARTS_RIGHT_EYE ="right_eye"
+
+POINTS_TOP_LIP = "top_lip"
+POINTS_BOTTOM_LIP = "bottom_lip"
+POINTS_CHIN = "chin"
+
+COLOR_WHITE=(255,255,255)
+COLOR_BLACK=(0,0,0)
+COLOR_ALPHA=(0,0,0,0)
+
+DEBUG = False
+DEBUG_CHIN = False
+def load_image_file(path):
+    image = face_recognition.load_image_file(path)
+    data_path=path+".json"
+    if USE_CACHE and os.path.exists(data_path):
+        with open(data_path, "r") as f:
+            face_landmarks_list = json.loads(f.read())
+    else:
+        face_landmarks_list = image_to_landmarks_list(image)
+        if USE_CACHE:
+            json_data = json.dumps(face_landmarks_list)
+            with open(data_path, "w") as f:
+                f.write(json_data)
+
+    return image,face_landmarks_list
+
+def save_landmarks(face_landmarks,out_path):
+     json_data = json.dumps(face_landmarks)
+     with open(out_path, "w") as f:
+        f.write(json_data)
+
+def load_landmarks(input_path):
+    with open(input_path, "r") as f:
+        face_landmarks_list = json.loads(f.read())
+    return face_landmarks_list
+
+
+
+def image_to_landmarks_list(image):
+    face_landmarks_list = face_recognition.face_landmarks(image)
+    return face_landmarks_list
+
+def fill_polygon(image,face_landmarks_list,key,thickness=1,line_color=(255,255,255),fill_color = (255,255,255)):
+    points=get_landmark_points(face_landmarks_list,key)
+    np_points = np.array(points,dtype=np.int32)
+    cv2.fillPoly(image, [np_points], fill_color)
+    cv2.polylines(image, [np_points], isClosed=True, color=line_color, thickness=thickness)
+
+def fill_lip(image,face_landmarks_list,thickness=1,line_color=(255,255,255),fill_color = (255,255,255)):
+    points1=get_landmark_points(face_landmarks_list,TOP_LIP)[0:7]
+    points2=get_landmark_points(face_landmarks_list,BOTTOM_LIP)[0:7]
+    
+    np_points = np.array(points1+points2[::-1],dtype=np.int32)
+    
+    
+    cv2.fillPoly(image, [np_points], fill_color)
+    if thickness > 0:
+        cv2.polylines(image, [np_points], isClosed=False, color=line_color, thickness=thickness)
+
+def fill_top(image,face_landmarks_list,thickness=1,line_color=(255,255,255),fill_color = (255,255,255)):
+    points1=get_landmark_points(face_landmarks_list,TOP_LIP)[0:7]
+    
+    np_points = np.array(points1,dtype=np.int32)
+    
+    
+    cv2.fillPoly(image, [np_points], fill_color)
+    if thickness > 0:
+        cv2.polylines(image, [np_points], isClosed=False, color=line_color, thickness=thickness)
+
+def fill_top_lower(image,face_landmarks_list,thickness=1,line_color=(255,255,255),fill_color = (255,255,255)):
+    top_lip_points=get_landmark_points(face_landmarks_list,TOP_LIP) # 5 to 7 ,1 t- 11
+    points1 = [lerp_points(top_lip_points[5],top_lip_points[7],0.7)]+ \
+        [mid_points(top_lip_points[7],top_lip_points[8])]+ \
+        list(top_lip_points[8:11]) +\
+         [mid_points(top_lip_points[10],top_lip_points[11])]+ \
+        [lerp_points(top_lip_points[1],top_lip_points[11],0.7)]+\
+        [mid_points(top_lip_points[2],top_lip_points[10])]+\
+        [mid_points(top_lip_points[3],top_lip_points[9])]+\
+        [mid_points(top_lip_points[4],top_lip_points[8])]
+    
+    np_points = np.array(points1,dtype=np.int32)
+    
+    
+    cv2.fillPoly(image, [np_points], fill_color)
+    if thickness > 0:
+        cv2.polylines(image, [np_points], isClosed=False, color=line_color, thickness=thickness)
+
+def get_lip_mask_points(face_landmarks_list):
+    points1=get_landmark_points(face_landmarks_list,TOP_LIP)[0:7]
+    points2=get_landmark_points(face_landmarks_list,BOTTOM_LIP)[0:7]
+    return points1+points2
+
+
+
+from scipy.special import comb
+
+def bernstein_poly(i, n, t):
+    """
+    n 次ベジェ曲線の i 番目の Bernstein 基底関数を計算する
+    """
+    return comb(n, i) * (t**(n-i)) * (1 - t)**i
+
+def bezier_curve(points, num_points=100):
+    """
+    与えられた点からベジェ曲線を計算する
+    """
+    nPoints = len(points)
+    xPoints = np.array([p[0] for p in points])
+    yPoints = np.array([p[1] for p in points])
+
+    t = np.linspace(0.0, 1.0, num_points)
+
+    polynomial_array = np.array([bernstein_poly(i, nPoints-1, t) for i in range(0, nPoints)])
+
+    xvals = np.dot(xPoints, polynomial_array)
+    yvals = np.dot(yPoints, polynomial_array)
+
+    return np.array(list(zip(xvals, yvals)))
+import cv2
+import numpy as np
+
+
+    
+
+
+
+def fill_eyes(image,face_landmarks_list,thickness=1,line_color=(255,255,255),fill_color = (255,255,255)):
+    points1=get_landmark_points(face_landmarks_list,PARTS_LEFT_EYE)
+    points2=get_landmark_points(face_landmarks_list,PARTS_RIGHT_EYE)
+    
+    for points in [points1,points2]:
+        #points = bezier_curve(points, num_points=10)
+        #print(points)
+        points = bulge_polygon(points, bulge_factor=0.2)
+        #print(points)
+        np_points = np.array(points,dtype=np.int32)
+        
+        cv2.fillPoly(image, [np_points], fill_color)
+        if thickness > 0:
+            cv2.polylines(image, [np_points], isClosed=False, color=line_color, thickness=thickness)
+
+
+
+
+
+def fill_face(image,face_landmarks_list,thickness=1,line_color=(255,255,255),fill_color = (255,255,255)):
+    points1=get_landmark_points(face_landmarks_list,PARTS_LEFT_EYEBROW)
+    points2=get_landmark_points(face_landmarks_list,PARTS_RIGHT_EYEBROW)
+    points3=get_landmark_points(face_landmarks_list,PARTS_CHIN)
+    
+    np_points = np.array(points1+points2+points3[::-1],dtype=np.int32)
+    
+    
+    cv2.fillPoly(image, [np_points], fill_color)
+    cv2.polylines(image, [np_points], isClosed=False, color=line_color, thickness=thickness) 
+
+def fill_face_inside(image,face_landmarks_list,thickness=1,line_color=(255,255,255),fill_color = (255,255,255)):
+    print("not support yet")
+    return None
+    points1=get_landmark_points(face_landmarks_list,PARTS_LEFT_EYEBROW)
+    points2=get_landmark_points(face_landmarks_list,PARTS_RIGHT_EYEBROW)
+    points3=get_landmark_points(face_landmarks_list,PARTS_CHIN)
+    points3=get_landmark_points(face_landmarks_list,PARTS_CHIN)
+    points3=get_landmark_points(face_landmarks_list,PARTS_CHIN)
+    
+    np_points = np.array(points1+points2+points3[::-1],dtype=np.int32)
+    
+    
+    cv2.fillPoly(image, [np_points], fill_color)
+    cv2.polylines(image, [np_points], isClosed=False, color=line_color, thickness=thickness)   
+
+def half_pt(point1,point2):
+    return [sum(x) / 2 for x in zip(point1, point2)]
+
+
+def line_lip(image,face_landmarks_list,key,thickness=1,line_color=(255,255,255)):
+    points=get_landmark_points(face_landmarks_list,key)
+    print(len(points))
+    #st=[(points[0]+points[11])/2]
+    st = [sum(x) / 2 for x in zip(points[0], points[11])]
+
+    #et=[(points[6]+points[7])/2]
+    et = [sum(x) / 2 for x in zip(points[6], points[7])]
+    print(et)
+    print(points)
+    np_points = np.array([st]+points[1:6]+[et],dtype=np.int32)
+    #if key == TOP_LIP:
+    cv2.polylines(image, [np_points], isClosed=False, color=line_color, thickness=thickness)
+
+def get_lip_hole_points(face_landmarks_list):
+    top_points=get_landmark_points(face_landmarks_list,TOP_LIP)
+    bottom_points=get_landmark_points(face_landmarks_list,BOTTOM_LIP)
+    return top_points[7:]+bottom_points[7:]#[::-1]
+    #np_points = np.array(top_points[7:]+bottom_points[7:][::-1],dtype=np.int32)
+
+def get_lip_hole_top_points(face_landmarks_list):
+    top_points=get_landmark_points(face_landmarks_list,TOP_LIP)
+    #bottom_points=get_landmark_points(face_landmarks_list,BOTTOM_LIP)
+    return top_points[7:]
+
+def get_lip_hole_bottom_points(face_landmarks_list):
+    #top_points=get_landmark_points(face_landmarks_list,TOP_LIP)
+    bottom_points=get_landmark_points(face_landmarks_list,BOTTOM_LIP)
+    #inverted for connect top
+    return bottom_points[7:][::-1]
+
+#for hide too long tooth
+def get_lip_hole_bottom_half_points(face_landmarks_list):
+    #top_points=get_landmark_points(face_landmarks_list,TOP_LIP)
+    bottom_points=get_landmark_points(face_landmarks_list,BOTTOM_LIP)
+    #inverted for connect top
+    st = [sum(x) / 2 for x in zip(bottom_points[7], bottom_points[8])]
+    et = [sum(x) / 2 for x in zip(bottom_points[10], bottom_points[11])]
+    points = [st]+bottom_points[8:11]+[et]
+    #print(points)
+    return points[::-1]
+
+def fill_points(points,image,thickness=1,line_color=(255,255,255),fill_color = (255,255,255)):
+    np_points = np.array(points,dtype=np.int32)
+    
+    
+
+    cv2.fillPoly(image, [np_points], fill_color)
+    if thickness>0:
+        cv2.polylines(image, [np_points], isClosed=False, color=line_color, thickness=thickness) 
+
+def fill_lip_hole_top(image,face_landmarks_list,thickness=1,line_color=(255,255,255),fill_color = (255,255,255)):
+    np_points = np.array(get_lip_hole_top_points(face_landmarks_list),dtype=np.int32)
+    
+    cv2.fillPoly(image, [np_points], fill_color)
+    cv2.polylines(image, [np_points], isClosed=False, color=line_color, thickness=thickness) 
+
+
+
+def fill_lip_hole(image,face_landmarks_list,thickness=1,line_color=(255,255,255),fill_color = (255,255,255)):
+    np_points = np.array(get_lip_hole_points(face_landmarks_list),dtype=np.int32)
+    #print(np_points)
+    cv2.fillPoly(image, [np_points], fill_color)
+    cv2.polylines(image, [np_points], isClosed=False, color=line_color, thickness=thickness) 
+
+
+
+def get_landmark_points(face_landmarks_list,key):
+    matching_landmark_points = []
+    for face_landmarks in face_landmarks_list:
+      for landmark_name, landmark_points in face_landmarks.items():
+        #matching_landmark_points = landmark_points.copy()
+        if landmark_name ==key:
+            for value in landmark_points:
+                matching_landmark_points.append([value[0],value[1]])
+            return tuple(matching_landmark_points)
+
+def get_image_size(cv2_image):
+    return cv2_image.shape[:2]
+
+def get_top_lip_box(face_landmarks_list,margin = 0):
+    print(f"get_top_lip_box margin = {margin}")
+    points = get_landmark_points(face_landmarks_list,TOP_LIP)
+    box= points_to_box(points)
+    if margin>0:
+        return ((box[0][0] - margin,box[0][1] - margin),(box[1][0] + margin, box[1][1] + margin))
+    else:
+        return box
+
+def get_points_box(face_landmarks_list,key,margin = 0):
+    print(f"margin = {margin}")
+    points = get_landmark_points(face_landmarks_list,key)
+    box= points_to_box(points)
+    if margin>0:
+        return ((box[0][0] - margin,box[0][1] - margin),(box[1][0] + margin, box[1][1] + margin))
+    else:
+        return box
+
+#for size up 
+
+def create_moved_image(image,src_points,dst_points,force_size=None):
+    # keep top of lip stable but affing must be 4 point
+    #print(f"src = {src_points}")
+    #print(f"dst = {dst_points}")
+    src_pts=np.array([src_points],dtype=np.float32)
+    dst_pts=np.array([dst_points],dtype=np.float32)
+    #BORDER_REPLICATE
+    return warp_with_auto_resize(image, src_pts, dst_pts,cv2.BORDER_REPLICATE,force_size)
+
+# lip-index
+"""
+ 1 2 3 4 5
+0           6
+ 11 10 9 8 7
+"""
+def get_top_lip_align_points(face_landmarks_list):
+    landmark=get_landmark_points(face_landmarks_list,TOP_LIP)
+    index_center = 3
+    index_right= 0 #mirror
+    #index_ritht_top= 2 #mirror
+    #index_left_top= 4 #mirror
+    index_left = 6
+    #if landmark_name ==key:
+    # 0 is right edge
+    x1 = landmark[index_right][0]
+    y1 = landmark[index_right][1]
+    # 6 is left edge
+    x2 = landmark[index_left][0]
+    y2 = landmark[index_left][1]
+
+    #left_top = landmark[index_left_top][1]
+    #right_top = landmark[index_ritht_top][1]
+    #top = left_top if left_top<right_top else right_top
+
+    # bottom center position
+    cx = (x1+x2)/2
+    cy = (y1+y2)/2
+
+   
+    diffx=(landmark[index_center][0]-cx)
+    diffy=(landmark[index_center][1]-cy)
+
+    #print(f"x1={x1} y1={y1} x2={x2} y2={y2} cx={cx} cy={cy} diffx={diffx} diffy={diffy}")
+
+    #plt.scatter(cx,cy, c='r', s=10)
+    return ((int(x1+diffx),int(y1+diffy)),(int(x2+diffx),int(y2+diffy)),(x1,y1),(x2,y2))
+
+
+def calculate_new_point(start_point, distance, angle):
+    x1, y1 = start_point
+    angle_rad = math.radians(angle)
+    
+    # 新しい点の座標を計算
+    new_x = x1 + distance * math.cos(angle_rad)
+    new_y = y1 + distance * math.sin(angle_rad)
+    
+    return (new_x, new_y)
+
+def calculate_clockwise_angle(point1, point2):
+    x1, y1 = point1
+    x2, y2 = point2
+    
+    # atan2を使用して角度を計算
+    angle_rad = math.atan2(y2 - y1, x2 - x1)
+    
+    # 反時計回りから時計回りに変換
+    if angle_rad < 0:
+        angle_rad += 2 * math.pi
+    
+    # ラジアンから度に変換
+    angle_deg = math.degrees(angle_rad)
+    
+    return angle_deg
+
+def get_bottom_lip_align_points(landmarks_list):
+    points =  get_landmark_points(landmarks_list,POINTS_BOTTOM_LIP)
+    return (points[0],points[3],points[6],points[9])
+
+def get_bottom_lip_width_height(landmarks_list):
+    points =  get_landmark_points(landmarks_list,POINTS_BOTTOM_LIP)
+    return (points[0][0] -points[6][0],points[3][1] -points[9][1])
+
+
+def crop_image(image,x1,y1,x2,y2):
+    return image[y1:y2, x1:x2]
+
+def crop_cv2_image_by_box(image,box):
+    return crop_image_by_box(image,box)
+
+def crop_image_by_box(image,box):
+    print(f"crop_cv2_image_by_box yy2 xx2 {box[0][1]}:{box[1][1]},{box[0][0]}:{box[1][0]}")
+    return image[box[0][1]:box[1][1], box[0][0]:box[1][0]]
+
+def get_top_lip_datas(img,margin=4):
+      landmarks_list=image_to_landmarks_list(img)
+      box = get_top_lip_box(landmarks_list,margin)
+      cropped_img = crop_cv2_image_by_box(img,box)
+      points = get_top_lip_points(landmarks_list) #its rectangle but not square
+      return landmarks_list,cropped_img,points,box
+
+def get_bottom_lip_datas(img,margin=4):
+      landmarks_list=image_to_landmarks_list(img)
+      box = get_points_box(landmarks_list,POINTS_BOTTOM_LIP,margin)
+      cropped_img = crop_cv2_image_by_box(img,box)
+      points = get_bottom_lip_align_points(landmarks_list) #its rectangle but not square
+      return landmarks_list,cropped_img,points,box
+
+def offset_points(points,offset):
+    new_points = []
+    for point in points:
+        new_points.append((point[0]-offset[0],point[1]-offset[1]))
+    return new_points
+
+
+def points_to_box(points):
+   min_x = 0
+   min_y = 0
+   min_x  = float('inf')
+   min_y  = float('inf')
+   max_x= 0
+   max_y= 0
+   for point in points:
+      if point[0]>max_x:
+            max_x=int(point[0])
+      if point[1]>max_y:
+            max_y=int(point[1])
+      if point[0]<min_x:
+            min_x=int(point[0])
+      if point[1]<min_y:
+            min_y=int(point[1])
+   return ((min_x,min_y),(max_x,max_y))
+
+
+
+import cv2
+import numpy as np
+
+def warp_with_auto_resize(img, src_pts, dst_pts, borderMode=cv2.BORDER_TRANSPARENT, force_size=None):
+  """
+  画像を WRAP 変換し、はみ出した場合は自動的にサイズを調整します。
+
+  Args:
+      img: 変換対象の画像 (numpy array)
+      src_pts: 変換元の四角形の頂点 (numpy array)
+      dst_pts: 変換先の四角形の頂点 (numpy array)
+
+  Returns:
+      変換後の画像 (numpy array)
+  """
+  # 変換行列を計算
+  mat = cv2.getPerspectiveTransform(src_pts, dst_pts)
+
+  # 変換後の画像サイズを計算
+  h, w = img.shape[:2]
+  corners = np.float32([[0, 0], [w, 0], [w, h], [0, h]])
+  warped_corners = cv2.perspectiveTransform(corners.reshape(-1, 1, 2), mat).reshape(-1, 2)
+
+  # 変換後の画像の最小矩形を計算 (元の画像の四隅も含めて計算)
+  min_x = np.min(warped_corners[:, 0])
+  min_y = np.min(warped_corners[:, 1])
+  max_x = np.max(warped_corners[:, 0])
+  max_y = np.max(warped_corners[:, 1])
+  new_w, new_h = int(max_x - min_x), int(max_y - min_y)
+
+  # 変換行列を更新 (平行移動成分を追加)
+  mat[0, 2] += -min_x
+  mat[1, 2] += -min_y
+
+  if force_size:
+    new_w = force_size[0]
+    new_h = force_size[1]
+
+  warped_img = cv2.warpPerspective(img, mat, (new_w, new_h), flags=cv2.INTER_LANCZOS4, borderMode=borderMode)
+
+  return warped_img
+
+def warp_with_auto_resize1(img, src_pts, dst_pts,borderMode= cv2.BORDER_TRANSPARENT,force_size=None):
+  """
+  画像を WRAP 変換し、はみ出した場合は自動的にサイズを調整します。
+
+  Args:
+      img: 変換対象の画像 (numpy array)
+      src_pts: 変換元の四角形の頂点 (numpy array)
+      dst_pts: 変換先の四角形の頂点 (numpy array)
+
+  Returns:
+      変換後の画像 (numpy array)
+  """
+  # 変換行列を計算
+  mat = cv2.getPerspectiveTransform(src_pts, dst_pts)
+
+  # 変換後の画像サイズを計算
+  h, w = img.shape[:2]
+  #print(f"img w{w} h{h}")
+  corners = np.float32([[0, 0], [w, 0], [w, h], [0, h]])
+  warped_corners = cv2.perspectiveTransform(corners.reshape(-1, 1, 2), mat).reshape(-1, 2)
+
+  # 変換後の画像の最小矩形を計算
+  min_x, min_y = np.min(warped_corners, axis=0)
+ 
+  max_x, max_y = np.max(warped_corners, axis=0)
+  new_w, new_h = int(max_x - min_x), int(max_y - min_y)
+  #print(f"min x {min_x} min y {min_y}")
+  #print(f"max x {max_x} max y {max_y}")
+  # 変換行列を更新 (平行移動成分を追加)
+  mat[0, 2] += -min_x
+  mat[1, 2] += -min_y
+
+  #print(f"audo w{new_w} h{new_h}")
+
+  if force_size:
+    new_w = force_size[0]
+    new_h = force_size[1]
+
+  warped_img = cv2.warpPerspective(img, mat, (new_w, new_h),flags=cv2.INTER_LANCZOS4, borderMode=borderMode)
+
+  return warped_img
+
+def get_channel(np_array):
+    return np_array.shape[2] if np_array.ndim == 3 else 1 
+
+def print_numpy(np_array,key=""):
+    channel = get_channel(np_array)
+    print(f"{key} shape = {np_array.shape} channel = {channel} ndim = {np_array.ndim} size = {np_array.size}")
+
+def create_color_image(img,color=(255,255,255)):
+    mask = np.zeros_like(img)
+    h, w = img.shape[:2]
+    cv2.rectangle(mask, (0, 0), (w, h), color, -1)
+    return mask
+
+def create_mask(img,color=(255,255,255)):
+    mask = np.zeros_like(img)
+    h, w = img.shape[:2]
+    cv2.rectangle(mask, (0, 0), (w, h), color, -1)
+    return mask
+
+def create_rgba(width,height):
+    return np.zeros((height, width, 4), dtype=np.uint8)
+
+def create_rgb(width,height):
+    return np.zeros((height, width, 3), dtype=np.uint8)
+
+def create_gray(width,height):
+    return np.zeros((height, width), dtype=np.uint8)
+
+def copy_image(img1,img2,x,y):
+    img1[y:y+img2.shape[0], x:x+img2.shape[1]] = img2
+
+def copy_color(img1,x,y,x2,y2,color):
+    color_img = np.full((y2-y, x2-x, 4), color, dtype=np.uint8)
+    img1[y:y2, x:x2] = color_img
+
+
+
+def multiply_point(point,multiply):
+    return int(point[0]*multiply),int(point[1]*multiply)
+
+def get_resized_top_pos(points,multiply=0.5):
+      diff_left = multiply_point((points[0][0]-points[2][0],points[0][1]-points[2][1]),multiply)
+      diff_right = multiply_point((points[1][0]-points[3][0],points[1][1]-points[3][1]),multiply)
+      return (diff_right,diff_left)
+
+
+def get_alpha_image(base_image,landmarks_list,key,margin = 0,dilation_size = 2,gaussian_size = 2):
+    box = get_points_box(landmarks_list,key,margin)
+    # box expand margin
+    cropped_img = crop_cv2_image_by_box(base_image,box)
+    # convert RGBA
+    if cropped_img.shape[2] == 3: # Check if the image has 3 channels (RGB)
+        image_rgba = cv2.cvtColor(cropped_img, cv2.COLOR_BGR2BGRA)
+        mask = np.zeros(cropped_img.shape[:2], dtype="uint8")
+    else:
+        print("already alpha skipped")
+        image_rgba = cropped_img
+        mask = np.zeros(cropped_img.shape[:2], dtype="uint8")
+        #mask = cropped_img[:, :, 3].copy() # if you use this .some how block
+    
+    global_points = get_landmark_points(landmarks_list,key)
+    
+    local_points =  offset_points(global_points,box[0]) 
+    print(local_points)
+    # create Lip Mask
+    np_points = np.array(local_points,dtype=np.int32)
+    
+    cv2.fillPoly(mask, [np_points], 255)
+
+    kernel = np.ones((dilation_size, dilation_size), np.uint8)
+
+    dilated_mask = cv2.dilate(mask, kernel, iterations=1)
+    #dilated_mask = cv2.erode(mask, kernel, iterations=1) # TODO support dilation_size
+
+    # Gaussian Blur
+    if gaussian_size > 0:
+        smooth_mask = cv2.GaussianBlur(dilated_mask, (0,0 ), sigmaX=gaussian_size, sigmaY=gaussian_size)
+        expanded_mask = np.expand_dims(smooth_mask, axis=-1)
+    else:
+        expanded_mask = np.expand_dims(dilated_mask, axis=-1)
+
+    #lip_utils.print_numpy(image_rgba,"rgba")
+    #lip_utils.print_numpy(smooth_mask,"smooth")
+    #lip_utils.print_numpy(expanded_mask,"expanded_mask")
+
+    image_rgba[..., 3] = expanded_mask[..., 0]
+
+
+    return image_rgba,box
+
+def apply_mask(image,mask):
+    if len(mask.shape) == 3:
+        expanded_mask = mask
+    else:
+        expanded_mask = np.expand_dims(mask, axis=-1)
+
+    if len(mask.shape)!=3:
+        error = f"image must be shape 3 {image.shape}"
+        raise ValueError(error)
+
+    if get_channel(image)!=4:
+        image_rgba = cv2.cvtColor(image, cv2.COLOR_BGR2BGRA) #why rgb to gray?
+    else:
+        image_rgba = image
+    image_rgba[..., 3] = expanded_mask[..., 0]
+    return image_rgba
+
+def apply_mask_alpha(image,mask,invert=False):
+    if len(mask.shape) == 3:
+        expanded_mask = mask
+    else:
+        expanded_mask = np.expand_dims(mask, axis=-1)
+
+    image_rgba = cv2.cvtColor(image, cv2.COLOR_BGR2BGRA)
+    if invert:
+        image_rgba[..., 3] = expanded_mask[..., 0]
+    else:
+        image_rgba[..., 3] = 255 - expanded_mask[..., 0]
+    return image_rgba
+
+def print_width_height(image,label):
+    new_h,new_w = get_image_size(image)
+    print(f"{label}:width = {new_w} height = {new_h}")
+
+
+def create_mask_from_points(img,points,dilation_size=4,gaussian_size=4):
+    np_points = np.array(points,dtype=np.int32)
+    mask = np.zeros(img.shape[:2], dtype="uint8")
+    cv2.fillPoly(mask, [np_points], 255)
+
+    kernel = np.ones((abs(dilation_size),abs(dilation_size) ), np.uint8)
+    if dilation_size > 0:
+        dilated_mask = cv2.dilate(mask, kernel, iterations=1)
+    else:
+        dilated_mask = cv2.erode(mask, kernel, iterations=1) # TODO support dilation_size
+    # Gaussian Blur
+    if gaussian_size > 0:
+        smooth_mask = cv2.GaussianBlur(dilated_mask, (0,0 ), sigmaX=gaussian_size, sigmaY=gaussian_size)
+        expanded_mask = np.expand_dims(smooth_mask, axis=-1)
+    else:
+        expanded_mask = np.expand_dims(dilated_mask, axis=-1)
+    return expanded_mask
+    #lip_utils.print_numpy(image_rgba,"rgba")
+    #lip_utils.print_numpy(smooth_mask,"smooth")
+    #lip_utils.print_numpy(expanded_mask,"expanded_mask")
+
+def mid_points(point1,point2):
+    return [sum(x) / 2 for x in zip(point1,point2)]
+
+def lerp_points(point1, point2, lerp):
+    return [(1.0 - lerp) * p1 + lerp * p2 for p1, p2 in zip(point1, point2)]
+
+def get_jaw_points(face_landmarks_list):
+    chin_points = get_landmark_points(face_landmarks_list,POINTS_CHIN)
+    bottom_lip_points = get_landmark_points(face_landmarks_list,POINTS_BOTTOM_LIP)
+
+    points =[]
+    
+    points.extend(chin_points[4:13])
+    points.append(mid_points(chin_points[12],bottom_lip_points[0]))
+    points.append(mid_points(chin_points[8],bottom_lip_points[3]))
+    points.append(mid_points(chin_points[4],bottom_lip_points[6]))
+
+    return points
+
+def get_bottom_mid_drop_size(open_size_y,lip_height):
+    # when full open case open_size_y 40 lip become half
+    mid_lip_move_ratio = open_size_y/80.0 if open_size_y>0 else 0
+    return mid_lip_move_ratio*lip_height
+
+
+def fade_in_x(img,size):
+    if size==0:
+        return
+    per_pixel = 1.0/size
+    for y in range(img.shape[0]):
+        for x in range(img.shape[1]):
+
+            if x <size:
+                alpha_base = per_pixel * x
+                # アルファ値を変更し、ピクセルに設定
+                #print(f"before x ={x} = {img[y,x,3]} after = {img[y,x,3] * alpha_base}")
+                img[y, x, 3] =  img[y,x,3] * alpha_base
+def fade_out_x(img,size):
+    if size==0:
+        return
+    per_pixel = 1.0/size
+    w = img.shape[1]
+
+    for y in range(img.shape[0]):
+        for x in range(img.shape[1]):
+
+            if x >w:
+                diff = x - w
+                alpha_base = 1.0 - (per_pixel * x)
+                # アルファ値を変更し、ピクセルに設定
+                #print(f"before x ={x} = {img[y,x,3]} after = {img[y,x,3] * alpha_base}")
+                img[y, x, 3] =  img[y,x,3] * alpha_base
+
+
+def alpha_blend_with_image2_alpha(image1, image2):
+    return cv2.addWeighted(image1, 1, image2, 1, 0)
+def numpy_alpha_blend_with_image2_alpha(image1, image2,invert=False):
+    """
+    image1をimage2のアルファチャンネルを使用してアルファブレンディングします。
+    """
+    # 画像のサイズを確認し、必要に応じてリサイズします。
+    if image1.shape[:2] != image2.shape[:2]:
+        image1 = cv2.resize(image1, (image2.shape[1], image2.shape[0]))
+    
+    src1 = np.array(image1)
+    src2 = np.array(image2)
+    mask1 = np.array(image2[:, :, 3])
+    mask1 = mask1 / 255
+    mask1 = np.expand_dims(mask1, axis=-1)
+    if invert:
+        dst = src1 * (1-mask1) + src2 * mask1
+    else:
+        dst = src1 * mask1 + src2 * (1 - mask1)
+    # アルファブレンディングを行います。
+    #blended = cv2.cvtColor(dst, cv2.COLOR_BGRA2BGRA)
+    dst = dst.astype(np.uint8)
+    return dst
+
+def distance_2d(point1, point2):
+    return math.sqrt((point2[0] - point1[0])**2 + (point2[1] - point1[1])**2)
+
+# points[index][x=0 y=1] index is see landmark image by plot2.py
+def get_top_lip_thicks(landmarks_list,is_distance_base=False):
+    points =  get_landmark_points(landmarks_list,POINTS_TOP_LIP)
+    if is_distance_base:
+        return (distance_2d(points[10],points[2]),distance_2d(points[9],points[3]),distance_2d(points[8],points[4]))
+    return (points[10][1] -points[2][1],points[9][1] -points[3][1],points[8][1] -points[4][1])
+
+
+def scale_down_values(data, scale_factor=0.25):
+    """
+    Scales down the values in a list of dictionaries by a given scale factor.
+    
+    Parameters:
+    - data: A list of dictionaries where each dictionary represents facial landmarks.
+    - scale_factor: The factor by which to scale down the values. Default is 0.25 (1/4).
+    
+    Returns:
+    - A new list of dictionaries with scaled down values.
+    """
+    scaled_data = []
+    for item in data:
+        scaled_item = {}
+        for key, values in item.items():
+            scaled_values = [(int(x * scale_factor), int(y * scale_factor)) for x, y in values]
+            scaled_item[key] = scaled_values
+        scaled_data.append(scaled_item)
+    return scaled_data
+
+def save_landmarks(face_landmarks,out_path):
+     json_data = json.dumps(face_landmarks)
+     with open(out_path, "w") as f:
+        f.write(json_data)
+
+def load_landmarks(input_path):
+    with open(input_path, "r") as f:
+        face_landmarks_list = json.loads(f.read())
+    return face_landmarks_list
+
+
+
+

mp_box.py

@@ -0,0 +1,133 @@
+import mediapipe as mp
+from mediapipe.tasks import python
+from mediapipe.tasks.python import vision
+from mediapipe.framework.formats import landmark_pb2
+from mediapipe import solutions
+import numpy as np
+
+# for X,Y,W,H to x1,y1,x2,y2(Left-top,right-bottom style)
+def xywh_to_xyxy(box):
+  return [box[0],box[1],box[0]+box[2],box[1]+box[3]]
+
+def convert_to_box(face_landmarks_list,indices,w=1024,h=1024):
+  x1=w
+  y1=h
+  x2=0
+  y2=0
+  for index in indices:
+    x=min(w,max(0,(face_landmarks_list[0][index].x*w)))
+    y=min(h,max(0,(face_landmarks_list[0][index].y*h)))
+    if x<x1:
+      x1=x
+
+    if y<y1:
+      y1=y
+    
+    if x>x2:
+      x2=x
+    if y>y2:
+      y2=y
+   
+        
+  return [int(x1),int(y1),int(x2-x1),int(y2-y1)]
+       
+  
+def box_to_square(bbox):
+  box=list(bbox)
+  if box[2]>box[3]:
+    diff = box[2]-box[3]
+    box[3]+=diff
+    box[1]-=diff/2
+  elif box[3]>box[2]:
+    diff = box[3]-box[2]
+    box[2]+=diff
+    box[0]-=diff/2
+  return box
+
+
+def face_landmark_result_to_box(face_landmarker_result,width=1024,height=1024):
+  face_landmarks_list = face_landmarker_result.face_landmarks
+
+
+  full_indices  = list(range(456))
+
+  MIDDLE_FOREHEAD = 151
+  BOTTOM_CHIN_EX = 152
+  BOTTOM_CHIN = 175
+  CHIN_TO_MIDDLE_FOREHEAD = [200,14,1,6,18,9]
+  MOUTH_BOTTOM = [202,200,422]
+  EYEBROW_CHEEK_LEFT_RIGHT = [46,226,50,1,280,446,276]
+
+  LEFT_HEAD_OUTER_EX = 251  #on side face almost same as full
+  LEFT_HEAD_OUTER = 301
+  LEFT_EYE_OUTER_EX = 356
+  LEFT_EYE_OUTER = 264
+  LEFT_MOUTH_OUTER_EX = 288
+  LEFT_MOUTH_OUTER = 288
+  LEFT_CHIN_OUTER = 435
+  RIGHT_HEAD_OUTER_EX = 21
+  RIGHT_HEAD_OUTER = 71
+  RIGHT_EYE_OUTER_EX = 127
+  RIGHT_EYE_OUTER = 34
+  RIGHT_MOUTH_OUTER_EX = 58
+  RIGHT_MOUTH_OUTER = 215
+  RIGHT_CHIN_OUTER = 150
+
+  # TODO naming line
+  min_indices=CHIN_TO_MIDDLE_FOREHEAD+EYEBROW_CHEEK_LEFT_RIGHT+MOUTH_BOTTOM
+
+  chin_to_brow_indices = [LEFT_CHIN_OUTER,LEFT_MOUTH_OUTER,LEFT_EYE_OUTER,LEFT_HEAD_OUTER,MIDDLE_FOREHEAD,RIGHT_HEAD_OUTER,RIGHT_EYE_OUTER,RIGHT_MOUTH_OUTER,RIGHT_CHIN_OUTER,BOTTOM_CHIN]+min_indices
+  
+  box1 = convert_to_box(face_landmarks_list,min_indices,width,height)
+  box2 = convert_to_box(face_landmarks_list,chin_to_brow_indices,width,height)
+  box3 = convert_to_box(face_landmarks_list,full_indices,width,height)
+  #print(box)
+
+  return [box1,box2,box3,box_to_square(box1),box_to_square(box2),box_to_square(box3)]
+
+
+def draw_landmarks_on_image(detection_result,rgb_image):
+  face_landmarks_list = detection_result.face_landmarks
+  annotated_image = np.copy(rgb_image)
+
+  # Loop through the detected faces to visualize.
+  for idx in range(len(face_landmarks_list)):
+    face_landmarks = face_landmarks_list[idx]
+
+    # Draw the face landmarks.
+    face_landmarks_proto = landmark_pb2.NormalizedLandmarkList()
+    face_landmarks_proto.landmark.extend([
+      landmark_pb2.NormalizedLandmark(x=landmark.x, y=landmark.y, z=landmark.z) for landmark in face_landmarks
+    ])
+
+    solutions.drawing_utils.draw_landmarks(
+        image=annotated_image,
+        landmark_list=face_landmarks_proto,
+        connections=mp.solutions.face_mesh.FACEMESH_TESSELATION,
+        landmark_drawing_spec=None,
+        connection_drawing_spec=mp.solutions.drawing_styles
+        .get_default_face_mesh_tesselation_style())
+    
+  return annotated_image
+
+def mediapipe_to_box(image_data,model_path="face_landmarker.task"):
+  BaseOptions = mp.tasks.BaseOptions
+  FaceLandmarker = mp.tasks.vision.FaceLandmarker
+  FaceLandmarkerOptions = mp.tasks.vision.FaceLandmarkerOptions
+  VisionRunningMode = mp.tasks.vision.RunningMode
+
+  options = FaceLandmarkerOptions(
+      base_options=BaseOptions(model_asset_path=model_path),
+      running_mode=VisionRunningMode.IMAGE
+      ,min_face_detection_confidence=0, min_face_presence_confidence=0
+      )
+
+
+  with FaceLandmarker.create_from_options(options) as landmarker:
+    if isinstance(image_data,str):
+        mp_image = mp.Image.create_from_file(image_data)
+    else:
+        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=np.asarray(image_data))
+    face_landmarker_result = landmarker.detect(mp_image)
+    boxes = face_landmark_result_to_box(face_landmarker_result,mp_image.width,mp_image.height)
+    return boxes,mp_image,face_landmarker_result

mp_constants.py

@@ -0,0 +1,320 @@
+  
+# contour
+POINT_LEFT_HEAD_OUTER_EX = 251  #on side face almost same as full
+POINT_LEFT_HEAD_OUTER = 301
+POINT_LEFT_EYE_OUTER_EX = 356
+POINT_LEFT_EYE_OUTER = 264
+POINT_LEFT_MOUTH_OUTER_EX = 288
+POINT_LEFT_MOUTH_OUTER = 435
+POINT_LEFT_CHIN_OUTER =  379
+POINT_RIGHT_HEAD_OUTER_EX = 21
+POINT_RIGHT_HEAD_OUTER = 71
+POINT_RIGHT_EYE_OUTER_EX = 127
+POINT_RIGHT_EYE_OUTER = 34
+POINT_RIGHT_MOUTH_OUTER_EX = 58
+POINT_RIGHT_MOUTH_OUTER = 215
+POINT_RIGHT_CHIN_OUTER = 150
+POINT_CHIN_BOTTOM = 152
+
+POINT_FOREHEAD_TOP = 10
+
+POINT_UPPER_LIP_CENTER_BOTTOM=13
+POINT_LOWER_LIP_CENTER_TOP=14
+POINT_LOWER_LIP_CENTER_BOTTOM=17
+POINT_NOSE_CENTER_MIDDLE=5
+
+LINE_RIGHT_CONTOUR_OUTER_EYE_TO_CHIN =[127,234,93,132,58,172,136,150,149,176,148,152]
+LINE_RIGHT_CONTOUR_EYE_TO_CHIN =      [34,227,137,177,215,138,135,169,170,140,171,175]
+LINE_RIGHT_CONTOUR_INNER_EYE_TO_CHIN =[143,116,123,147,213,192,214,210,211,32,208,199]
+
+
+LINE_RIGHT_CONTOUR_0 = [152,175,199]
+LINE_RIGHT_CONTOUR_1 = [148,171,208]
+LINE_RIGHT_CONTOUR_2 = [176,140,32]
+LINE_RIGHT_CONTOUR_3 = [149,170,211]
+LINE_RIGHT_CONTOUR_4 = [150,169,210]
+LINE_RIGHT_CONTOUR_5 = [136,135,214]
+LINE_RIGHT_CONTOUR_6 = [172,138,192]
+LINE_RIGHT_CONTOUR_7 = [58,215,213]
+LINE_RIGHT_CONTOUR_8 = [132,177,147]
+LINE_RIGHT_CONTOUR_9 = [93,137,123]
+LINE_RIGHT_CONTOUR_10 = [234,227,116]
+LINE_RIGHT_CONTOUR_11 = [127,34,143]
+
+LANDMARK_68_CONTOUR_1 = LINE_RIGHT_CONTOUR_11
+LANDMARK_68_CONTOUR_2_PART1 = LINE_RIGHT_CONTOUR_10
+LANDMARK_68_CONTOUR_2_PART2 = LINE_RIGHT_CONTOUR_9
+LANDMARK_68_CONTOUR_3 = LINE_RIGHT_CONTOUR_8
+LANDMARK_68_CONTOUR_4 = LINE_RIGHT_CONTOUR_7
+LANDMARK_68_CONTOUR_5 = LINE_RIGHT_CONTOUR_6
+LANDMARK_68_CONTOUR_6_PART1 = LINE_RIGHT_CONTOUR_5
+LANDMARK_68_CONTOUR_6_PART2 = LINE_RIGHT_CONTOUR_4
+
+LANDMARK_68_CONTOUR_7 = LINE_RIGHT_CONTOUR_3
+LANDMARK_68_CONTOUR_8_PART1 = LINE_RIGHT_CONTOUR_2
+LANDMARK_68_CONTOUR_8_PART2 = LINE_RIGHT_CONTOUR_1
+LANDMARK_68_CONTOUR_9 = LINE_RIGHT_CONTOUR_0
+
+
+LINE_LEFT_CONTOUR_1 = [377,396,428]
+LINE_LEFT_CONTOUR_2 = [400,369,262]
+LINE_LEFT_CONTOUR_3 = [378,395,431]
+LINE_LEFT_CONTOUR_4 = [379,394,430]
+LINE_LEFT_CONTOUR_5 = [365,364,434]
+LINE_LEFT_CONTOUR_6 = [397,367,416]
+LINE_LEFT_CONTOUR_7 = [288,435,433]
+LINE_LEFT_CONTOUR_8 = [361,401,376]
+LINE_LEFT_CONTOUR_9 = [323,366,352]
+LINE_LEFT_CONTOUR_10 = [454,447,345]
+LINE_LEFT_CONTOUR_11 = [356,264,372]
+LINE_LEFT_CONTOUR_12 = [389,368,383]
+
+LANDMARK_68_CONTOUR_10 = LINE_LEFT_CONTOUR_1
+LANDMARK_68_CONTOUR_11_PART1 = LINE_LEFT_CONTOUR_2
+LANDMARK_68_CONTOUR_11_PART2 = LINE_LEFT_CONTOUR_3
+LANDMARK_68_CONTOUR_12 = LINE_LEFT_CONTOUR_4
+LANDMARK_68_CONTOUR_13 = LINE_LEFT_CONTOUR_5
+LANDMARK_68_CONTOUR_14 = LINE_LEFT_CONTOUR_6
+LANDMARK_68_CONTOUR_15_PART1 = LINE_LEFT_CONTOUR_7
+LANDMARK_68_CONTOUR_15_PART2 = LINE_LEFT_CONTOUR_8
+
+LANDMARK_68_CONTOUR_16 = LINE_LEFT_CONTOUR_9
+LANDMARK_68_CONTOUR_17_PART1 = LINE_LEFT_CONTOUR_10
+LANDMARK_68_CONTOUR_17_PART2 = LINE_LEFT_CONTOUR_11
+
+LANDMARK_68_RIGHT_EYEBROW_18 = [70,46] #upper,lower
+LANDMARK_68_RIGHT_EYEBROW_19 = [63,53]
+LANDMARK_68_RIGHT_EYEBROW_20 = [105,52]
+LANDMARK_68_RIGHT_EYEBROW_21 = [66,65]
+LANDMARK_68_RIGHT_EYEBROW_22 = [107,55]
+
+LANDMARK_68_LEFT_EYEBROW_23 = [336,285] #upper,lower
+LANDMARK_68_LEFT_EYEBROW_24 = [296,295]
+LANDMARK_68_LEFT_EYEBROW_25 = [334,282]
+LANDMARK_68_LEFT_EYEBROW_26 = [293,283]
+LANDMARK_68_LEFT_EYEBROW_27 = [300,276]
+
+POINT_NOSE_0 = 8
+POINT_NOSE_1 = 168
+POINT_NOSE_2 = 6
+POINT_NOSE_3 = 197
+POINT_NOSE_4 = 195
+POINT_NOSE_5 = 5
+POINT_NOSE_6 = 4
+POINT_NOSE_7 = 19
+POINT_NOSE_8 = 94
+POINT_NOSE_9 = 2
+
+#side
+POINT_NOSE_10 = 98
+POINT_NOSE_11 = 97
+POINT_NOSE_12 = 326
+POINT_NOSE_13 = 327
+
+LANDMARK_68_VERTICAL_NOSE_28 =[8,168]
+LANDMARK_68_VERTICAL_NOSE_29 = [6]
+LANDMARK_68_VERTICAL_NOSE_30=[197,195]
+LANDMARK_68_VERTICAL_NOSE_31=[5,4]
+
+LANDMARK_68_HORIZONTAL_NOSE_32 =[POINT_NOSE_10]
+LANDMARK_68_HORIZONTAL_NOSE_33 = [POINT_NOSE_11]
+LANDMARK_68_HORIZONTAL_NOSE_34=[POINT_NOSE_9]
+LANDMARK_68_HORIZONTAL_NOSE_35=[POINT_NOSE_12]
+LANDMARK_68_HORIZONTAL_NOSE_36=[POINT_NOSE_13]
+
+
+LINE_VERTICAL_NOSE = [POINT_NOSE_0,POINT_NOSE_1,POINT_NOSE_2,POINT_NOSE_3,POINT_NOSE_4,POINT_NOSE_5,POINT_NOSE_6,POINT_NOSE_7,POINT_NOSE_8,POINT_NOSE_9]
+LINE_HORIZONTAL_NOSE =[POINT_NOSE_10,POINT_NOSE_11,POINT_NOSE_9,POINT_NOSE_12,POINT_NOSE_13]
+
+### EYES
+POINT_RIGHT_UPPER_INNER_EYE_1 = 33
+POINT_RIGHT_UPPER_INNER_EYE_2 = 246
+POINT_RIGHT_UPPER_INNER_EYE_3 = 161
+POINT_RIGHT_UPPER_INNER_EYE_4 = 160
+POINT_RIGHT_UPPER_INNER_EYE_5 = 159
+POINT_RIGHT_UPPER_INNER_EYE_6 = 158
+POINT_RIGHT_UPPER_INNER_EYE_7 = 157
+POINT_RIGHT_UPPER_INNER_EYE_8 = 173
+POINT_RIGHT_UPPER_INNER_EYE_9 = 133
+
+LINE_RIGHT_UPPER_INNER_EYE=[POINT_RIGHT_UPPER_INNER_EYE_1,POINT_RIGHT_UPPER_INNER_EYE_2,POINT_RIGHT_UPPER_INNER_EYE_3,POINT_RIGHT_UPPER_INNER_EYE_4,POINT_RIGHT_UPPER_INNER_EYE_5,POINT_RIGHT_UPPER_INNER_EYE_6,POINT_RIGHT_UPPER_INNER_EYE_7,POINT_RIGHT_UPPER_INNER_EYE_8,POINT_RIGHT_UPPER_INNER_EYE_9]
+
+POINT_RIGHT_LOWER_INNER_EYE_1 = 155
+POINT_RIGHT_LOWER_INNER_EYE_2 = 154
+POINT_RIGHT_LOWER_INNER_EYE_3 = 153
+POINT_RIGHT_LOWER_INNER_EYE_4 = 145
+POINT_RIGHT_LOWER_INNER_EYE_5 = 144
+POINT_RIGHT_LOWER_INNER_EYE_6 = 163
+POINT_RIGHT_LOWER_INNER_EYE_7 = 7
+
+LINE_RIGHT_LOWER_INNER_EYE=[POINT_RIGHT_UPPER_INNER_EYE_9,POINT_RIGHT_LOWER_INNER_EYE_1,POINT_RIGHT_LOWER_INNER_EYE_2,POINT_RIGHT_LOWER_INNER_EYE_3,POINT_RIGHT_LOWER_INNER_EYE_4,POINT_RIGHT_LOWER_INNER_EYE_5,POINT_RIGHT_LOWER_INNER_EYE_6,POINT_RIGHT_LOWER_INNER_EYE_7,POINT_RIGHT_UPPER_INNER_EYE_1]
+
+
+POINT_RIGHT_UPPER_OUTER_EYE_1 = 130
+POINT_RIGHT_UPPER_OUTER_EYE_2 = 247
+POINT_RIGHT_UPPER_OUTER_EYE_3 = 30
+POINT_RIGHT_UPPER_OUTER_EYE_4 = 29
+POINT_RIGHT_UPPER_OUTER_EYE_5 = 27
+POINT_RIGHT_UPPER_OUTER_EYE_6 = 28
+POINT_RIGHT_UPPER_OUTER_EYE_7 = 56
+POINT_RIGHT_UPPER_OUTER_EYE_8 = 190
+POINT_RIGHT_UPPER_OUTER_EYE_9 = 243
+
+LINE_RIGHT_UPPER_OUTER_EYE=[POINT_RIGHT_UPPER_OUTER_EYE_1,POINT_RIGHT_UPPER_OUTER_EYE_2,POINT_RIGHT_UPPER_OUTER_EYE_3,POINT_RIGHT_UPPER_OUTER_EYE_4,POINT_RIGHT_UPPER_OUTER_EYE_5,POINT_RIGHT_UPPER_OUTER_EYE_6,POINT_RIGHT_UPPER_OUTER_EYE_7,POINT_RIGHT_UPPER_OUTER_EYE_8,POINT_RIGHT_UPPER_OUTER_EYE_9]
+
+LINE_RIGHT_UPPER_MIXED_EYE =[#firs eye1 and eye2 is intesionaly for moveup
+    [POINT_RIGHT_UPPER_INNER_EYE_1,POINT_RIGHT_UPPER_OUTER_EYE_2], [POINT_RIGHT_UPPER_INNER_EYE_2,POINT_RIGHT_UPPER_OUTER_EYE_2], [POINT_RIGHT_UPPER_INNER_EYE_3,POINT_RIGHT_UPPER_OUTER_EYE_3], [POINT_RIGHT_UPPER_INNER_EYE_4,POINT_RIGHT_UPPER_OUTER_EYE_4], [POINT_RIGHT_UPPER_INNER_EYE_5,POINT_RIGHT_UPPER_OUTER_EYE_5], [POINT_RIGHT_UPPER_INNER_EYE_6,POINT_RIGHT_UPPER_OUTER_EYE_6]
+    ,[POINT_RIGHT_UPPER_INNER_EYE_8],[POINT_RIGHT_UPPER_INNER_EYE_8,POINT_RIGHT_UPPER_INNER_EYE_9] #I'm not sure need this one or not POINT_RIGHT_LOWER_INNER_EYE_1
+]
+
+LINE_RIGHT_UPPER_MIXED_EYE2 =[#firs eye1 and eye2 is intesionaly for moveup
+    [POINT_RIGHT_UPPER_INNER_EYE_1,POINT_RIGHT_UPPER_INNER_EYE_1,POINT_RIGHT_UPPER_OUTER_EYE_2],
+    [POINT_RIGHT_UPPER_INNER_EYE_2,POINT_RIGHT_UPPER_INNER_EYE_2,POINT_RIGHT_UPPER_OUTER_EYE_2], 
+    [POINT_RIGHT_UPPER_INNER_EYE_3,POINT_RIGHT_UPPER_INNER_EYE_3,POINT_RIGHT_UPPER_OUTER_EYE_3], 
+    [POINT_RIGHT_UPPER_INNER_EYE_4,POINT_RIGHT_UPPER_INNER_EYE_4,POINT_RIGHT_UPPER_OUTER_EYE_4], 
+    [POINT_RIGHT_UPPER_INNER_EYE_5,POINT_RIGHT_UPPER_INNER_EYE_5,POINT_RIGHT_UPPER_OUTER_EYE_5], 
+    [POINT_RIGHT_UPPER_INNER_EYE_6,POINT_RIGHT_UPPER_INNER_EYE_6,POINT_RIGHT_UPPER_OUTER_EYE_6]
+    ,[POINT_RIGHT_UPPER_INNER_EYE_8],
+    [POINT_RIGHT_UPPER_INNER_EYE_8,POINT_RIGHT_UPPER_INNER_EYE_9] #I'm not sure need this one or not POINT_RIGHT_LOWER_INNER_EYE_1
+]
+
+POINT_RIGHT_LOWER_OUTER_EYE_1 = 112
+POINT_RIGHT_LOWER_OUTER_EYE_2 = 26
+POINT_RIGHT_LOWER_OUTER_EYE_3 = 22
+POINT_RIGHT_LOWER_OUTER_EYE_4 = 23
+POINT_RIGHT_LOWER_OUTER_EYE_5 = 24
+POINT_RIGHT_LOWER_OUTER_EYE_6 = 110
+POINT_RIGHT_LOWER_OUTER_EYE_7 = 25
+
+LINE_RIGHT_LOWER_OUTER_EYE=[POINT_RIGHT_UPPER_OUTER_EYE_9,POINT_RIGHT_LOWER_OUTER_EYE_1,POINT_RIGHT_LOWER_OUTER_EYE_2,POINT_RIGHT_LOWER_OUTER_EYE_3,POINT_RIGHT_LOWER_OUTER_EYE_4,POINT_RIGHT_LOWER_OUTER_EYE_5,POINT_RIGHT_LOWER_OUTER_EYE_6,POINT_RIGHT_LOWER_OUTER_EYE_7,POINT_RIGHT_UPPER_OUTER_EYE_1]
+
+LINE_RIGHT_LOWER_MIXED_EYE =[
+    [POINT_RIGHT_UPPER_INNER_EYE_8,POINT_RIGHT_UPPER_INNER_EYE_9,POINT_RIGHT_LOWER_INNER_EYE_1]
+    ,[POINT_RIGHT_LOWER_INNER_EYE_2]
+    ,POINT_RIGHT_LOWER_INNER_EYE_3,POINT_RIGHT_LOWER_INNER_EYE_4,POINT_RIGHT_LOWER_INNER_EYE_5,POINT_RIGHT_LOWER_INNER_EYE_6,POINT_RIGHT_LOWER_INNER_EYE_7
+    ,[POINT_RIGHT_UPPER_INNER_EYE_1,POINT_RIGHT_UPPER_OUTER_EYE_2]  #combine 1 and 2 for move up
+]
+
+
+POINT_LEFT_UPPER_INNER_EYE_1 = 362
+POINT_LEFT_UPPER_INNER_EYE_2 = 398
+POINT_LEFT_UPPER_INNER_EYE_3 = 384
+POINT_LEFT_UPPER_INNER_EYE_4 = 385
+POINT_LEFT_UPPER_INNER_EYE_5 = 386
+POINT_LEFT_UPPER_INNER_EYE_6 = 387
+POINT_LEFT_UPPER_INNER_EYE_7 = 388
+POINT_LEFT_UPPER_INNER_EYE_8 = 466
+POINT_LEFT_UPPER_INNER_EYE_9 = 263
+
+LINE_LEFT_UPPER_INNER_EYE=[POINT_LEFT_UPPER_INNER_EYE_1,POINT_LEFT_UPPER_INNER_EYE_2,POINT_LEFT_UPPER_INNER_EYE_3,POINT_LEFT_UPPER_INNER_EYE_4,POINT_LEFT_UPPER_INNER_EYE_5,POINT_LEFT_UPPER_INNER_EYE_6,POINT_LEFT_UPPER_INNER_EYE_7,POINT_LEFT_UPPER_INNER_EYE_8,POINT_LEFT_UPPER_INNER_EYE_9]
+LINE_LEFT_UPPER_INNER_EYE2=[POINT_LEFT_UPPER_INNER_EYE_1,POINT_LEFT_UPPER_INNER_EYE_2,POINT_LEFT_UPPER_INNER_EYE_3,POINT_LEFT_UPPER_INNER_EYE_4,POINT_LEFT_UPPER_INNER_EYE_5,POINT_LEFT_UPPER_INNER_EYE_6,POINT_LEFT_UPPER_INNER_EYE_7,POINT_LEFT_UPPER_INNER_EYE_8,POINT_LEFT_UPPER_INNER_EYE_9]
+
+
+
+POINT_LEFT_LOWER_INNER_EYE_1 = 249
+POINT_LEFT_LOWER_INNER_EYE_2 = 390
+POINT_LEFT_LOWER_INNER_EYE_3 = 373
+POINT_LEFT_LOWER_INNER_EYE_4 = 374
+POINT_LEFT_LOWER_INNER_EYE_5 = 380
+POINT_LEFT_LOWER_INNER_EYE_6 = 381
+POINT_LEFT_LOWER_INNER_EYE_7 = 382
+
+
+LINE_LEFT_LOWER_INNER_EYE=[POINT_LEFT_UPPER_INNER_EYE_9,POINT_LEFT_LOWER_INNER_EYE_2,POINT_LEFT_LOWER_INNER_EYE_3,POINT_LEFT_LOWER_INNER_EYE_4,POINT_LEFT_LOWER_INNER_EYE_5,POINT_LEFT_LOWER_INNER_EYE_6,POINT_LEFT_LOWER_INNER_EYE_7,POINT_LEFT_UPPER_INNER_EYE_1]
+
+#outer
+
+POINT_LEFT_UPPER_OUTER_EYE_1 = 463
+POINT_LEFT_UPPER_OUTER_EYE_2 = 414
+POINT_LEFT_UPPER_OUTER_EYE_3 = 286
+POINT_LEFT_UPPER_OUTER_EYE_4 = 258
+POINT_LEFT_UPPER_OUTER_EYE_5 = 257
+POINT_LEFT_UPPER_OUTER_EYE_6 = 259
+POINT_LEFT_UPPER_OUTER_EYE_7 = 260
+POINT_LEFT_UPPER_OUTER_EYE_8 = 467
+POINT_LEFT_UPPER_OUTER_EYE_9 = 359
+
+LINE_LEFT_UPPER_OUTER_EYE=[POINT_LEFT_UPPER_OUTER_EYE_1,POINT_LEFT_UPPER_OUTER_EYE_2,POINT_LEFT_UPPER_OUTER_EYE_3,POINT_LEFT_UPPER_OUTER_EYE_4,POINT_LEFT_UPPER_OUTER_EYE_5,POINT_LEFT_UPPER_OUTER_EYE_6,POINT_LEFT_UPPER_OUTER_EYE_7,POINT_LEFT_UPPER_OUTER_EYE_8,POINT_LEFT_UPPER_OUTER_EYE_9]
+
+
+POINT_LEFT_LOWER_OUTER_EYE_1 = 255
+POINT_LEFT_LOWER_OUTER_EYE_2 = 339
+POINT_LEFT_LOWER_OUTER_EYE_3 = 254
+POINT_LEFT_LOWER_OUTER_EYE_4 = 253
+POINT_LEFT_LOWER_OUTER_EYE_5 = 252
+POINT_LEFT_LOWER_OUTER_EYE_6 = 256
+POINT_LEFT_LOWER_OUTER_EYE_7 = 341
+
+LINE_LEFT_LOWER_OUTER_EYE=[POINT_LEFT_UPPER_OUTER_EYE_9,POINT_LEFT_LOWER_OUTER_EYE_1,POINT_LEFT_LOWER_OUTER_EYE_2,POINT_LEFT_LOWER_OUTER_EYE_3,POINT_LEFT_LOWER_OUTER_EYE_4,POINT_LEFT_LOWER_OUTER_EYE_5,POINT_LEFT_LOWER_OUTER_EYE_6,POINT_LEFT_LOWER_OUTER_EYE_7,POINT_LEFT_UPPER_OUTER_EYE_1]
+
+LINE_LEFT_UPPER_MIXED_EYE =[#firs eye1 and eye2 is intesionaly for moveup
+    [POINT_LEFT_UPPER_INNER_EYE_1,POINT_LEFT_UPPER_INNER_EYE_2,POINT_LEFT_LOWER_INNER_EYE_7],
+    [POINT_LEFT_UPPER_INNER_EYE_2,POINT_LEFT_UPPER_OUTER_EYE_2], [POINT_LEFT_UPPER_INNER_EYE_3,POINT_LEFT_UPPER_INNER_EYE_3,POINT_LEFT_UPPER_OUTER_EYE_3], [POINT_LEFT_UPPER_INNER_EYE_4,POINT_LEFT_UPPER_OUTER_EYE_4], [POINT_LEFT_UPPER_INNER_EYE_5,POINT_LEFT_UPPER_OUTER_EYE_5], [POINT_LEFT_UPPER_INNER_EYE_6,POINT_LEFT_UPPER_OUTER_EYE_6]
+    ,[POINT_LEFT_UPPER_INNER_EYE_8],[POINT_LEFT_UPPER_OUTER_EYE_8,POINT_LEFT_UPPER_INNER_EYE_9]
+]
+
+LINE_LEFT_UPPER_MIXED_EYE2 =[#firs eye1 and eye2 is intesionaly for moveup
+    [POINT_LEFT_UPPER_INNER_EYE_1,POINT_LEFT_UPPER_INNER_EYE_1,POINT_LEFT_UPPER_INNER_EYE_2,POINT_LEFT_LOWER_INNER_EYE_7],
+    [POINT_LEFT_UPPER_INNER_EYE_2,POINT_LEFT_UPPER_INNER_EYE_2,POINT_LEFT_UPPER_OUTER_EYE_2],
+    [POINT_LEFT_UPPER_INNER_EYE_3,POINT_LEFT_UPPER_INNER_EYE_3,POINT_LEFT_UPPER_INNER_EYE_3,POINT_LEFT_UPPER_OUTER_EYE_3],
+    [POINT_LEFT_UPPER_INNER_EYE_4,POINT_LEFT_UPPER_INNER_EYE_4,POINT_LEFT_UPPER_OUTER_EYE_4],
+    [POINT_LEFT_UPPER_INNER_EYE_5,POINT_LEFT_UPPER_INNER_EYE_5,POINT_LEFT_UPPER_OUTER_EYE_5],
+    [POINT_LEFT_UPPER_INNER_EYE_6,POINT_LEFT_UPPER_INNER_EYE_6,POINT_LEFT_UPPER_OUTER_EYE_6]
+    ,[POINT_LEFT_UPPER_INNER_EYE_8],
+    [POINT_LEFT_UPPER_OUTER_EYE_8,POINT_LEFT_UPPER_INNER_EYE_9]
+]
+
+LINE_LEFT_LOWER_MIXED_EYE =[
+    [POINT_LEFT_UPPER_OUTER_EYE_8,POINT_LEFT_UPPER_INNER_EYE_9]
+    ,[POINT_LEFT_LOWER_INNER_EYE_2]
+    ,POINT_LEFT_LOWER_INNER_EYE_3,POINT_LEFT_LOWER_INNER_EYE_4,POINT_LEFT_LOWER_INNER_EYE_5,POINT_LEFT_LOWER_INNER_EYE_6,POINT_LEFT_LOWER_INNER_EYE_7
+    , [POINT_LEFT_UPPER_INNER_EYE_1,POINT_LEFT_UPPER_INNER_EYE_2,POINT_LEFT_LOWER_INNER_EYE_7]  #combine 1 and 2 for move up
+]
+
+
+#LIP
+LINE_RIGHT_UPPER_OUTER_LIP=[
+      61,185,40,39,37,0
+    ]
+LINE_LEFT_UPPER_OUTER_LIP=[
+      0,267,269,270,409,291
+    ]
+
+
+LINE_LOWER_OUTER_LIP=[291,#upper
+      375,321,405,314,17,84,181,91,146
+      ,61 #upper
+    ]
+
+LINE_UPPER_INNER_LIP=[
+      61,185,40,39,37,0,267,269,270,409,291
+    ]
+
+LINE_LOWER_INNER_LIP=[291,#upper
+      375,321,405,314,17,84,181,91,146
+      ,61 #upper
+    ]
+
+LANDMARK_68_UPPER_OUTER_LIP_49 =[61]
+LANDMARK_68_UPPER_OUTER_LIP_50 =[40,39]
+LANDMARK_68_UPPER_OUTER_LIP_51 =[37]
+LANDMARK_68_UPPER_OUTER_LIP_52 =[0]
+LANDMARK_68_UPPER_OUTER_LIP_53 =[267]
+LANDMARK_68_UPPER_OUTER_LIP_54 =[270,269]
+LANDMARK_68_UPPER_OUTER_LIP_55 =[291]
+
+LANDMARK_68_LOWER_OUTER_LIP_56 =[375,321]
+LANDMARK_68_LOWER_OUTER_LIP_57 =[405,314]
+LANDMARK_68_LOWER_OUTER_LIP_58 =[17]
+LANDMARK_68_LOWER_OUTER_LIP_59 =[84,181]
+LANDMARK_68_LOWER_OUTER_LIP_60 =[146,91]
+
+LANDMARK_68_UPPER_INNER_LIP_61 =[78]
+LANDMARK_68_UPPER_INNER_LIP_62 =[81]
+LANDMARK_68_UPPER_INNER_LIP_63 =[13]
+LANDMARK_68_UPPER_INNER_LIP_64 =[311]
+LANDMARK_68_UPPER_INNER_LIP_65 =[308]
+
+LANDMARK_68_LOWER_INNER_LIP_66 =[402]
+LANDMARK_68_LOWER_INNER_LIP_67 =[14]
+LANDMARK_68_LOWER_INNER_LIP_68 =[178]