add files

.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

app.py

@@ -0,0 +1,439 @@
+import spaces
+import gradio as gr
+import subprocess
+from PIL import Image,ImageOps,ImageDraw,ImageFilter
+import json
+import os
+import time
+
+from mp_utils import get_pixel_cordinate_list,extract_landmark,get_pixel_cordinate
+from glibvision.draw_utils import points_to_box,box_to_xy,plus_point
+import mp_constants
+import mp_box
+import io
+import numpy as np
+from glibvision.pil_utils import fill_points,create_color_image,draw_points,draw_box
+
+from gradio_utils import save_image,save_buffer,clear_old_files ,read_file
+import opencvinpaint
+
+'''
+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)
+
+'''
+
+def picker_color_to_rgba(picker_color):
+   
+    color_value = picker_color.strip("rgba()").split(",")
+    color_value[0] = int(float(color_value[0]))
+    color_value[1] = int(float(color_value[1]))
+    color_value[2] = int(float(color_value[2]))
+    color_value[3] = int(float(color_value[3])*255)
+    print(f"picker_color = {picker_color} color_value={color_value}")
+    return color_value
+
+#@spaces.GPU(duration=120)
+'''
+
+    innner_eyes_blur - inner eyes blur
+    iris_mask_blur - final iris edge blur
+'''
+def process_images(image,eyes_slide_x_ratio,eyes_slide_y_ratio,innner_eyes_blur_ratio=0.1,iris_mask_blur_ratio=0.1,pupil_offset_ratio=0.08,draw_eye_pupil_ratio=1.1,iris_color_value="rgba(20,20,20,255)",eyes_white_erode_ratio=0.2,eyes_ball_mask_ratio=0.9,
+                   output_important_only=True,progress=gr.Progress(track_tqdm=True)):
+    clear_old_files()
+    if image == None:
+        raise gr.Error("Need Image")
+    
+    
+
+    iris_color =  tuple(picker_color_to_rgba(iris_color_value))
+    #print(iris_color)
+    #return None,None
+    
+    
+
+
+    # TODO resize max 2048
+
+    white_image = create_color_image(image.width,image.height,(255,255,255))
+    ## Mediapipe landmark
+    progress(0, desc="Start Making Animation")
+    mp_image,face_landmarker_result = extract_landmark(image)
+    larndmarks=face_landmarker_result.face_landmarks
+
+
+    ## eyes cordinates
+    left_iris_points = get_pixel_cordinate_list(larndmarks,mp_constants.LINE_LEFT_IRIS,image.width,image.height)
+    right_iris_points = get_pixel_cordinate_list(larndmarks,mp_constants.LINE_RIGHT_IRIS,image.width,image.height)
+
+    left_box = points_to_box(left_iris_points)
+    right_box = points_to_box(right_iris_points)
+    left_eye_radius = (left_box[2] if left_box[2]>left_box[3] else left_box[3])/2
+    right_eye_radius = (right_box[2] if right_box[2]>right_box[3] else right_box[3])/2
+
+
+    innner_eyes_blur = int(left_eye_radius*innner_eyes_blur_ratio)
+    iris_mask_blur = int(left_eye_radius*iris_mask_blur_ratio)
+    
+
+    eyes_slide_x = int(left_eye_radius*2 * eyes_slide_x_ratio)
+    eyes_slide_y = int(left_eye_radius*2 * eyes_slide_y_ratio)
+    
+    
+    pupil_offset_y = right_eye_radius * pupil_offset_ratio
+
+    point_right_pupil = get_pixel_cordinate(larndmarks,mp_constants.POINT_RIGHT_PUPIL,image.width,image.height)
+    point_right_pupil = plus_point(point_right_pupil,[0,pupil_offset_y])
+
+    point_left_pupil = get_pixel_cordinate(larndmarks,mp_constants.POINT_LEFT_PUPIL,image.width,image.height)
+    point_left_pupil = plus_point(point_left_pupil,[0,pupil_offset_y])
+
+
+
+    left_inner_eyes = get_pixel_cordinate_list(larndmarks,mp_constants.LINE_RIGHT_UPPER_INNER_EYE+mp_constants.LINE_RIGHT_LOWER_INNER_EYE,image.width,image.height)
+    right_inner_eyes = get_pixel_cordinate_list(larndmarks,mp_constants.LINE_LEFT_UPPER_INNER_EYE+mp_constants.LINE_LEFT_LOWER_INNER_EYE ,image.width,image.height)
+    
+    left_white_eyes = get_pixel_cordinate_list(larndmarks,mp_constants.LINE_LEFT_EYES_WHITE,image.width,image.height)
+    fill_points(white_image,left_white_eyes,(0,0,0))
+
+    right_white_eyes = get_pixel_cordinate_list(larndmarks,mp_constants.LINE_RIGHT_EYES_WHITE ,image.width,image.height)
+    fill_points(white_image,right_white_eyes,(0,0,0))
+
+    left_eyes_box = points_to_box(left_white_eyes)
+    right_eyes_box = points_to_box(right_white_eyes)
+
+    black_image = create_color_image(image.width,image.height,(0,0,0))
+    draw_box(black_image,left_eyes_box,fill=(255,255,255))
+    draw_box(black_image,right_eyes_box,fill=(255,255,255))
+
+
+    eyes_mask_area_image = black_image.convert("L")
+    eyes_mask_image = white_image.convert("L") #eyes-white-area-hole painted black
+
+    galleries = []
+    def add_webp(add_image,label,important=False):
+        if important ==False and output_important_only == True:
+            return
+        
+        file_path = save_image(add_image,"webp")
+        galleries.append((file_path,label))
+    
+    # Create EYE LINE IMAGE
+    eyes_line_image = image.copy()
+    draw_points(eyes_line_image,left_inner_eyes,outline=(200,200,255),fill=None,width=3)
+    draw_points(eyes_line_image,right_inner_eyes,outline=(200,200,255),fill=None,width=3)
+
+    draw_points(eyes_line_image,left_white_eyes,outline=(255,0,0),fill=None,width=4)
+    draw_points(eyes_line_image,right_white_eyes,outline=(255,0,0),fill=None,width=4)
+    draw_points(eyes_line_image,left_iris_points,outline=(0,255,0),fill=None,width=4)
+    draw_points(eyes_line_image,right_iris_points,outline=(0,255,0),fill=None,width=4)
+    add_webp(eyes_line_image,"eyes-line",True)
+    
+
+    # eyes socket(face) image
+    rgba_image = image.convert("RGBA")
+    rgba_image.putalpha(eyes_mask_image)
+    eyes_socket = rgba_image
+    add_webp(eyes_socket,"eyes-socket",True)
+    eyes_socket_mask = eyes_mask_image
+
+    # Save Eyes mask and area
+    eyes_white_mask = ImageOps.invert(eyes_mask_image)
+    add_webp(eyes_white_mask,"eyes-mask")
+    add_webp(eyes_mask_area_image,"eyes-box")
+
+
+    # Remove Edge,
+    
+    erode_size = int(left_box[3]*eyes_white_erode_ratio) # eyes-height base #TODO take care right eyes
+    if erode_size%2==0:
+        erode_size+=1
+    eyes_white_mask=eyes_white_mask.filter(ImageFilter.MinFilter(erode_size))
+
+
+    # eyes_only_image inner-white-eyes - erode
+    rgba_image = image.convert("RGBA")
+    rgba_image.putalpha(eyes_white_mask)
+    eyes_only_image = rgba_image
+    add_webp(eyes_only_image,"eyes-only")
+    eyes_only_image_mask = eyes_white_mask.copy()
+
+    
+
+    draw = ImageDraw.Draw(eyes_white_mask)
+    draw.circle(point_right_pupil,left_eye_radius*draw_eye_pupil_ratio,fill=(0))
+    draw.circle(point_left_pupil,left_eye_radius*draw_eye_pupil_ratio,fill=(0))
+
+    rgba_image = image.convert("RGBA")
+    rgba_image.putalpha(eyes_white_mask)
+    add_webp(rgba_image,"white-inapint-image",True)
+
+    eyes_mask_area_image.paste(ImageOps.invert(eyes_white_mask),None,mask=eyes_white_mask)
+    add_webp(eyes_mask_area_image,"white-inapint-mask")
+
+
+    cropped_right_eye = rgba_image.crop(box_to_xy(right_eyes_box))
+    add_webp(cropped_right_eye,"right-eye")
+    cropped_right_eye_mask = eyes_mask_area_image.crop(box_to_xy(right_eyes_box))
+    add_webp(cropped_right_eye_mask,"right-eye-mask")
+
+
+    cropped_left_eye = rgba_image.crop(box_to_xy(left_eyes_box))
+    add_webp(cropped_left_eye,"left-eye")
+    cropped_left_eye_mask = eyes_mask_area_image.crop(box_to_xy(left_eyes_box))
+    add_webp(cropped_left_eye_mask,"left-eye-mask")
+
+
+    inpaint_radius  = 20
+    blur_radius = 15
+    edge_expand = 4
+
+    inpaint_mode = "Telea"
+    inner_eyes_image = create_color_image(image.width,image.height,color=(0,0,0,0))
+    inpaint_right,tmp_mask=opencvinpaint.process_cvinpaint(cropped_right_eye,cropped_right_eye_mask.convert("RGB"),inpaint_radius,blur_radius,edge_expand,inpaint_mode)
+    add_webp(inpaint_right,"right-eye")
+    inpaint_left,tmp_mask=opencvinpaint.process_cvinpaint(cropped_left_eye,cropped_left_eye_mask.convert("RGB"),inpaint_radius,blur_radius,edge_expand,inpaint_mode)
+    add_webp(inpaint_left,"left-eye")
+    
+    inner_eyes_image.paste(inpaint_right,box_to_xy(right_eyes_box))
+    inner_eyes_image.paste(inpaint_left,box_to_xy(left_eyes_box))
+    add_webp(inner_eyes_image,"inpainted-eyes",True)
+    eyes_blank = inner_eyes_image.copy()
+    eyes_blank.paste(eyes_socket,eyes_socket_mask)
+    add_webp(eyes_blank,"eyes_blank",True)
+    
+    eyes_move_pt = (eyes_slide_x,eyes_slide_y)
+    draw_pupil_border=2
+    
+    draw_left_pupil_radius = int(left_eye_radius*draw_eye_pupil_ratio)
+    draw_right_pupil_radius = int(right_eye_radius*draw_eye_pupil_ratio)
+
+    eyes_ball_image = eyes_only_image.convert("RGBA")#create_color_image(image.width,image.height,color=(0,0,0,0))
+    draw = ImageDraw.Draw(eyes_ball_image)
+   
+    
+    draw.circle(point_right_pupil,draw_right_pupil_radius,outline=iris_color,width=draw_pupil_border)
+    draw.circle(point_left_pupil,draw_left_pupil_radius,outline=iris_color,width=draw_pupil_border)
+    add_webp(eyes_ball_image,"eyes-ball-inpaint-base",True)
+
+    
+    #draw mask too
+    
+
+    eyes_ball_image_mask = create_color_image(image.width,image.height,color=(0,0,0))
+    draw = ImageDraw.Draw(eyes_ball_image_mask)
+    draw.circle(point_right_pupil,draw_right_pupil_radius-draw_pupil_border,fill=(255,255,255))
+    draw.circle(point_left_pupil,draw_left_pupil_radius-draw_pupil_border,fill=(255,255,255))
+    add_webp(eyes_ball_image_mask,"eyes-ball-image-mask")
+    eyes_ball_image_mask = eyes_ball_image_mask.convert("L")
+
+    eyes_ball_image_inpaint_mask = eyes_ball_image_mask.copy()
+    eyes_ball_image_inpaint_mask.paste(ImageOps.invert(eyes_only_image_mask),mask=eyes_only_image_mask)
+    add_webp(eyes_ball_image_inpaint_mask,"eyes_ball_image_inpaint_mask")
+
+    ### create inpaint and replace
+    pupil_inpaint_radius  = 5
+    pupil_blur_radius = 2
+    pupil_edge_expand = 5
+
+    inpaint_eyes_ball_image,tmp_mask=opencvinpaint.process_cvinpaint(eyes_ball_image,eyes_ball_image_inpaint_mask.convert("RGB"),pupil_inpaint_radius,pupil_blur_radius,pupil_edge_expand,inpaint_mode)
+    inpaint_eyes_ball_image.putalpha(eyes_ball_image_mask)
+    add_webp(inpaint_eyes_ball_image,"inpaint_eyes_ball_image")
+    eyes_ball_image = inpaint_eyes_ball_image
+
+
+    eyes_and_ball_mask = eyes_only_image_mask.copy()
+    eyes_and_ball_mask.paste(eyes_ball_image_mask,mask=eyes_ball_image_mask)
+    add_webp(eyes_and_ball_mask,"eyes-ball-mask")
+
+    eyes_ball_image.paste(eyes_only_image,mask=eyes_only_image_mask)
+    add_webp(eyes_ball_image,"eyes-ball",True)
+
+
+
+    inner_eyes_image.paste(eyes_ball_image,eyes_move_pt,mask=eyes_and_ball_mask)
+    add_webp(inner_eyes_image,"inner-eyes")
+
+    inner_eyes_image.paste(eyes_socket,None,mask=eyes_socket_mask)
+
+    #ImageFilter.BLUR,"Smooth More":ImageFilter.SMOOTH_MORE,"Smooth":ImageFilter.SMOOTH
+    filtered_image = inner_eyes_image.filter(ImageFilter.GaussianBlur(radius=innner_eyes_blur))
+    add_webp(filtered_image,"bluerd_inner_face",True)
+    
+
+    #filtered_image.paste(eyes_only_image,eyes_move_pt,mask=eyes_ball_image_mask.convert("L"))
+    
+
+
+    ### create innner mask minus eyeballs
+    white_image = create_color_image(image.width,image.height,color=(255,255,255))
+    draw = ImageDraw.Draw(white_image)
+    right_eyes_xy = get_pixel_cordinate(larndmarks,mp_constants.POINT_RIGHT_PUPIL,image.width,image.height)
+    left_eyes_xy = get_pixel_cordinate(larndmarks,mp_constants.POINT_LEFT_PUPIL,image.width,image.height)
+    draw.circle(plus_point(left_eyes_xy,eyes_move_pt),left_eye_radius*eyes_ball_mask_ratio,fill=(0,0,0,255))
+    draw.circle(plus_point(right_eyes_xy,eyes_move_pt),right_eye_radius*eyes_ball_mask_ratio,fill=(0,0,0,255))
+    add_webp(white_image,"eyes_ball_mask")
+
+    eyes_socket_mask_invert = ImageOps.invert(eyes_socket_mask)
+    eyes_socket_mask_invert.paste(white_image,eyes_socket_mask_invert)
+    add_webp(eyes_socket_mask_invert,"inner_mask_without_eyesball")
+
+
+    ### final paste eyes-ball and outer-faces on blured inner
+    eyes_socket_mask_invert = eyes_socket_mask_invert.filter(ImageFilter.GaussianBlur(radius=iris_mask_blur))
+    add_webp(eyes_socket_mask_invert,"inner_mask_without_eyesball-blur",True)
+
+    filtered_image.paste(inner_eyes_image,None,mask=ImageOps.invert(eyes_socket_mask_invert))
+    filtered_image.paste(eyes_socket,None,mask=eyes_socket_mask)
+    file_path = save_image(filtered_image,"webp")
+
+    return filtered_image,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="Image")
+                    with gr.Row(elem_id="prompt-container",  equal_height=False):
+                        with gr.Row():
+                            btn = gr.Button("Slide Eyes Direction", elem_id="run_button",variant="primary")
+                    
+                    with gr.Accordion(label="Eyes Slide", open=True):
+                        with gr.Row(equal_height=False):
+                            eyes_slide_x_ratio = gr.Slider(
+                                    label="Horizontal Slide (Iris based size)",
+                                    minimum=-2,
+                                    maximum=2,
+                                    step=0.01,
+                                    value=0,info="Based iris size minus to left,plus to right")
+                            eyes_slide_y_ratio = gr.Slider(
+                                    label="Vertical Slide (Iris based size)",
+                                    minimum=-1.5,
+                                    maximum=1.5,
+                                    step=0.01,
+                                    value=0.25,info="Based iris size minus to up,plus to down")
+                        
+                    with gr.Accordion(label="Advanced Settings", open=False):
+                        
+                        with gr.Row( equal_height=True):
+                            innner_eyes_blur_ratio = gr.Slider(
+                                label="Inner Eyes Blur Ratio",
+                                minimum=0,
+                                maximum=1,
+                                step=0.01,
+                                value=0.2,info="increse valueinnser eyes make flat")
+                            iris_mask_blur_ratio = gr.Slider(
+                                label="Iris Mask Blur Ratio",
+                                minimum=0,
+                                maximum=1,
+                                step=0.01,
+                                value=0.15,info="mask edge smooth")
+                        with gr.Row( equal_height=True):
+                            pupil_offset_ratio = gr.Slider(
+                                label="Pupil center Offset Y",
+                                minimum=-0.5,
+                                maximum=0.5,
+                                step=0.01,
+                                value=-0.08,info="mediapipe detection is not middle")
+                            draw_eye_pupil_ratio = gr.Slider(
+                                label="Draw Pupil radius ratio",
+                                minimum=0.5,
+                                maximum=1.5,
+                                step=0.01,
+                                value=1.1,info="mediapipe detection is usually small")
+                            iris_color_value = gr.ColorPicker(value="rgba(20,20,20,1)",label="Iris Border Color")
+                        with gr.Row( equal_height=True):
+                            eyes_white_erode_ratio = gr.Slider(
+                                label="Eye Erode erode ratio",
+                                minimum=0,
+                                maximum=0.5,
+                                step=0.01,
+                                value=0.1,info="eyes edge is pink")
+                            eyes_ball_mask_ratio = gr.Slider(
+                                label="Eye Ball Mask ratio",
+                                minimum=0,
+                                maximum=1,
+                                step=0.01,
+                                value=0.9,info="iris blur and mask for img2img")
+                        with gr.Row( equal_height=True):
+                            output_important_only=gr.Checkbox(label="output important image only",value=True)        
+
+                                         
+                with gr.Column():
+                    animation_out = gr.Image(height=760,label="Result", elem_id="output-animation")
+                    image_out = gr.Gallery(label="Output", elem_id="output-img",preview=True)
+                    
+
+    btn.click(fn=process_images, inputs=[image,eyes_slide_x_ratio,eyes_slide_y_ratio,innner_eyes_blur_ratio,iris_mask_blur_ratio,
+                                         pupil_offset_ratio,draw_eye_pupil_ratio,iris_color_value,eyes_white_erode_ratio,eyes_ball_mask_ratio,output_important_only
+                                         ],outputs=[animation_out,image_out] ,api_name='infer')
+    gr.Examples(
+                examples =[
+                     ["examples/02316230.jpg"],
+                    ["examples/00003245_00.jpg"],
+                   ["examples/00827009.jpg"],
+                   
+                     ["examples/00002062.jpg"],
+                   
+
+                    ["examples/00824008.jpg"],
+                    ["examples/00825000.jpg"],
+                    ["examples/00826007.jpg"],
+                     ["examples/00824006.jpg"],
+                    ["examples/00828003.jpg"],
+
+                     ["examples/00002200.jpg"],
+                    ["examples/00005259.jpg"],
+                    ["examples/00018022.jpg"],
+                    ["examples/img-above.jpg"],
+                     ["examples/00100265.jpg"],
+                ],
+                #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],examples_per_page=5
+    )
+    gr.HTML(read_file("demo_footer.html"))
+
+    if __name__ == "__main__":
+        demo.launch()

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,18 @@
+<div style="text-align: center;">
+    <h1>
+        Mediapipe Change Eyes Direction
+    </h1>
+    <div  class="grid-container">
+        <img src="https://akjava.github.io/AIDiagramChatWithVoice-FaceCharacter/webp/128/00544245.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>
+            <a href="https://huggingface.co/blog/Akjava/eyes-slide-move/">[Article>]</a>Eyes Slide-Move:Classic-Inpainting fill hole and complete missing iris<br>
+            (1) Make "blank eyes" (remove irises) using classic-inpaint<br>
+            (2) complete missing iris hidden by eyelid using classic-inapaint<br>
+            (3) Move the iris to the desired (x, y) coordinates<br>
+            The result is not so bad,If face is big you can improve with belelow Flux.1 schnell img2img/inpaint<br>
+        </p>
+    </div>
+    
+</div>

demo_tools.html

@@ -0,0 +1,11 @@
+<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> |
+        <a href="https://huggingface.co/spaces/Akjava/WebP-Resize-Convert">WebP Resize Animation</a>
+    </p>
+    <p></p> 
+</div>

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/draw_utils.py

@@ -0,0 +1,39 @@
+# DrawUtils 
+# not PIL,CV2,Numpy drawing method
+
+
+def points_to_box(points):
+  x1=float('inf')
+  x2=0
+  y1=float('inf')
+  y2=0
+  for point in points:
+    if point[0]<x1:
+      x1=point[0]
+    if point[0]>x2:
+      x2=point[0]
+    if point[1]<y1:
+      y1=point[1]
+    if point[1]>y2:
+      y2=point[1]
+  return [x1,y1,x2-x1,y2-y1]
+
+def box_to_point(box):
+  return [
+    [box[0],box[1]], 
+    [box[0]+box[2],box[1]],
+    [box[0]+box[2],box[1]+box[3]],
+    [box[0],box[1]+box[3]]
+  ]
+
+def plus_point(base_pt,add_pt):
+  return [base_pt[0]+add_pt[0],base_pt[1]+add_pt[1]]
+
+def box_to_xy(box):
+  return [box[0],box[1],box[2]+box[0],box[3]+box[1]]
+
+def to_int_points(points):
+  int_points=[]
+  for point in points:
+    int_points.append([int(point[0]),int(point[1])])
+  return int_points

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,30 @@
+from PIL import Image,ImageDraw
+from .draw_utils import box_to_xy,to_int_points,box_to_point
+#ver-2024-11-18
+def create_color_image(width, height, color=(255,255,255)):
+    if color == None:
+        color = (0,0,0)
+    
+    if len(color )== 3:
+        mode ="RGB"
+    elif len(color )== 4:
+        mode ="RGBA"
+
+    img = Image.new(mode, (width, height), color)
+    return img
+
+def fill_points(image,points,color=(255,255,255)):
+    return draw_points(image,points,fill=color)
+
+def draw_points(image,points,outline=None,fill=None,width=1):
+    draw = ImageDraw.Draw(image)
+    int_points = [(int(x), int(y)) for x, y in points]
+    draw.polygon(int_points, outline=outline,fill=fill,width=width)
+    return image
+
+def draw_box(image,box,outline=None,fill=None):
+    points = to_int_points(box_to_point(box))
+    return draw_points(image,points,outline,fill)
+
+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

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,331 @@
+#ver 2024-11-21  
+# 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
+]
+
+# LEFT AND RIGHT IS DIFF
+LINE_RIGHT_EYES_WHITE = LINE_RIGHT_UPPER_INNER_EYE[1:-1] + LINE_RIGHT_LOWER_INNER_EYE[2:-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]
+#TODO what is this?
+#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]
+
+
+
+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_1,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
+]
+
+LINE_LEFT_EYES_WHITE = LINE_LEFT_UPPER_INNER_EYE[1:-1] + LINE_LEFT_LOWER_INNER_EYE[1:-2]
+
+#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]
+
+POINT_LEFT_PUPIL = 473
+LINE_LEFT_IRIS = [474,475,476,477]
+POINT_RIGHT_PUPIL = 468
+LINE_RIGHT_IRIS = [469,470,471,472]

mp_utils.py

@@ -0,0 +1,125 @@
+import math
+
+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
+
+
+def calculate_distance(p1, p2):
+  """
+
+  """
+  return math.sqrt((p2[0] - p1[0])**2 + (p2[1] - p1[1])**2)
+def to_int_points(points):
+    ints=[]
+    for pt in points:
+        #print(pt)
+        value = [int(pt[0]),int(pt[1])]
+        #print(value)
+        ints.append(value)
+    return ints
+
+debug = False
+def divide_line_to_points(points,divided): # return divided + 1
+    total_length = 0
+    line_length_list = []
+    for i in range(len(points)-1):
+        pt_length = calculate_distance(points[i],points[i+1])
+        total_length += pt_length
+        line_length_list.append(pt_length)
+     
+    splited_length = total_length/divided
+
+    def get_new_point(index,lerp):
+        pt1 = points[index]
+        pt2 = points[index+1]
+        diff = [pt2[0] - pt1[0], pt2[1]-pt1[1]]
+        new_point = [pt1[0]+diff[0]*lerp,pt1[1]+diff[1]*lerp]
+        if debug:
+          print(f"pt1 ={pt1}  pt2 ={pt2} diff={diff} new_point={new_point}")
+
+        return new_point
+
+    if debug:
+      print(f"{total_length} splitted = {splited_length} line-length-list = {len(line_length_list)}")
+    splited_points=[points[0]]
+    for i in range(1,divided):
+        need_length = splited_length*i
+        if debug:
+          print(f"{i} need length = {need_length}")
+        current_length = 0
+        for j in range(len(line_length_list)):
+            line_length = line_length_list[j]
+            current_length+=line_length
+            if current_length>need_length:
+                if debug:
+                  print(f"over need length index = {j} current={current_length}")
+                diff = current_length - need_length
+            
+                lerp_point = 1.0 - (diff/line_length)
+                if debug:
+                  print(f"over = {diff} lerp ={lerp_point}")
+                new_point = get_new_point(j,lerp_point)
+                
+                splited_points.append(new_point)
+                break
+        
+    splited_points.append(points[-1]) # last one
+    splited_points=to_int_points(splited_points)    
+         
+    if debug:
+      print(f"sp={len(splited_points)}")
+    return splited_points
+
+
+
+def expand_bbox(bbox,left=5,top=5,right=5,bottom=5):
+   left_pixel = bbox[2]*(float(left)/100)
+   top_pixel = bbox[3]*(float(top)/100)
+   right_pixel = bbox[2]*(float(right)/100)
+   bottom_pixel = bbox[3]*(float(bottom)/100)
+   new_box = list(bbox)
+   new_box[0] -=left_pixel
+   new_box[1] -=top_pixel
+   new_box[2] +=left_pixel+right_pixel
+   new_box[3] +=top_pixel+bottom_pixel
+   return new_box
+
+#normalized value index see mp_constants
+def get_normalized_cordinate(face_landmarks_list,index):
+    x=face_landmarks_list[0][index].x
+    y=face_landmarks_list[0][index].y
+    return x,y
+
+def get_pixel_cordinate(face_landmarks_list,landmark,width,height):
+    point = get_normalized_cordinate(face_landmarks_list,landmark)
+    return int(point[0]*width),int(point[1]*height)
+
+def get_pixel_cordinate_list(face_landmarks_list,indices,width,height):
+   cordinates = []
+   for index in indices:
+      cordinates.append(get_pixel_cordinate(face_landmarks_list,index,width,height))
+   return cordinates
+
+def extract_landmark(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)
+    return mp_image,face_landmarker_result

opencvinpaint.py

@@ -0,0 +1,106 @@
+import os
+import sys
+
+import cv2
+import numpy as np
+from PIL import Image
+
+
+debug = False
+
+def gray3d_to_2d(grayscale: np.ndarray) -> np.ndarray:
+    channel = grayscale.shape[2] if grayscale.ndim == 3 else 1 
+    if channel!=1:
+        text = f"grayscale shape = {grayscale.shape} channel = {channel} ndim = {grayscale.ndim} size = {grayscale.size}"
+        raise ValueError(f"color maybe rgb or rgba {text}")
+
+    if grayscale.ndim == 2:
+        return grayscale
+    return np.squeeze(grayscale)
+
+def pil_to_cv(image):
+    cv_image = np.array(image, dtype=np.uint8)
+    if cv_image.shape[2] == 3:  # カラー
+        cv_image = cv2.cvtColor(cv_image, cv2.COLOR_RGB2BGR)
+    elif cv_image.shape[2] == 4: #
+        cv_image = cv2.cvtColor(cv_image, cv2.COLOR_RGBA2BGR)
+    return cv_image
+
+def blend_rgb_images(image1: np.ndarray, image2: np.ndarray, mask: np.ndarray) -> np.ndarray:
+
+    if image1.shape != image2.shape or image1.shape[:2] != mask.shape:
+        raise ValueError("not same shape")
+
+    # 画像を float 型に変換
+    image1 = image1.astype(float)
+    image2 = image2.astype(float)
+
+    # mask to 3 chan 0 -1 value
+    alpha = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR).astype(float) / 255.0
+
+    # calcurate blend
+    blended = (1 - alpha) * image1 + alpha * image2
+
+    return blended.astype(np.uint8)
+
+def process_cvinpaint(image,mask_image,inpaint_radius,blur_radius,edge_expand,inpaint_mode,dilate=0):
+    #print("process cvinpaint")
+    #print(blur_radius,",",edge_expand)
+    cv_image = pil_to_cv(image)
+
+    cv_mask = pil_to_cv(mask_image)
+
+  
+
+
+    cv_gray = cv2.cvtColor(cv_mask,cv2.COLOR_BGR2GRAY)
+    
+
+    mask = gray3d_to_2d(cv_gray)
+    if dilate>0:
+        kernel = np.ones((dilate, dilate), np.uint8)
+        mask = cv2.dilate(mask, kernel, iterations=1)
+
+    #cv2.imwrite("_mask.jpg",mask)
+    #cv2.imwrite("_image.jpg",cv_image)
+    mode = cv2.INPAINT_TELEA if inpaint_mode == "Telea" else cv2.INPAINT_NS
+    img_inpainted = cv2.inpaint(cv_image, mask,inpaint_radius, mode)
+    if debug:
+        cv2.imwrite("close_eye_inpaint.jpg",img_inpainted)
+    
+    
+    ## blur
+    if blur_radius > 0:
+        if blur_radius%2==0:
+            blur_radius += 1
+        #print(blur_radius)
+        blurred_image = cv2.GaussianBlur(img_inpainted, (blur_radius, blur_radius), 0) #should be odd
+        if debug:
+            cv2.imwrite("close_eye_inpaint_burred.jpg",blurred_image)
+    else:
+        blurred_image = img_inpainted
+
+    # expand edge and blur
+    kernel = np.ones((edge_expand, edge_expand), np.uint8)
+    extend_mask = cv2.dilate(mask, kernel, iterations=1)
+
+    if edge_expand > 0 and blur_radius > 0:
+        extend_burred_mask = cv2.GaussianBlur(extend_mask, (blur_radius, blur_radius), 0)
+    else:
+        extend_burred_mask = extend_mask
+
+    
+    img_inpainted = blend_rgb_images(img_inpainted,blurred_image,extend_burred_mask)
+
+    output_image = img_inpainted.copy()
+    
+    if output_image.shape[2] == 3:  # カラー
+        output_image = cv2.cvtColor(output_image, cv2.COLOR_BGR2RGB)
+    
+    return Image.fromarray(output_image),Image.fromarray(mask)
+
+if __name__ == "__main__":
+    image = Image.open(sys.argv[1])
+    mask  = Image.open(sys.argv[2])
+    output = process_cvinpaint(image,mask)
+    output.save(sys.argv[3])

requirements.txt

@@ -0,0 +1,5 @@
+numpy
+torch
+spaces
+mediapipe
+opencv-python