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

app.py

@@ -0,0 +1,250 @@
+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
+'''
+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)
+
+'''
+
+dir_name ="files"
+passed_time = 60*60 
+def clear_old_files(dir,passed_time):
+    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_image_id(image,length=32):
+    buffer = io.BytesIO()
+    image.save(buffer, format='PNG')
+    hash_object = hashlib.sha256(buffer.getvalue())
+    hex_dig = hash_object.hexdigest()
+    unique_id = hex_dig[:length]
+    return unique_id
+
+def save_image(image,extension="jpg"):
+    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 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]))
+    return color_value
+
+#@spaces.GPU(duration=120)
+def process_images(image,progress=gr.Progress(track_tqdm=True)):
+    if image == None:
+        raise gr.Error("Need Image")
+
+    progress(0, desc="Start Mediapipe")
+    
+    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)
+
+    annotations = []
+    galleries = []
+
+    def append(mask,label):
+        file_path = save_image(mask)
+        galleries.append((file_path,label))
+        annotations.append((np.array(mask.convert("1")),label))
+
+    def fill_points(points,base_image=None):
+        if base_image == None:
+            base_image = landmarks68_utils.create_color_image(image.width,image.height,(0,0,0))
+        landmarks68_utils.fill_points(base_image,points)
+        return base_image
+
+    # TODO support type
+    left_eye_points = landmarks68_utils.get_landmark_points(landmark_list,landmarks68_utils.PARTS_LEFT_EYE)
+    right_eye_points = landmarks68_utils.get_landmark_points(landmark_list,landmarks68_utils.PARTS_RIGHT_EYE)
+    eyes_mask = fill_points(left_eye_points)
+    eyes_mask = fill_points(right_eye_points,eyes_mask)
+    append(eyes_mask,"eyes")
+
+    
+    upper_lip_points = landmarks68_utils.get_landmark_points(landmark_list,landmarks68_utils.PARTS_UPPER_LIP)
+    upper_lip_mask = fill_points(upper_lip_points)
+    append(upper_lip_mask,"upper-lip")
+
+    lower_lip_points = landmarks68_utils.get_landmark_points(landmark_list,landmarks68_utils.PARTS_LOWER_LIP)
+    lower_lip_mask = fill_points(lower_lip_points)
+    append(lower_lip_mask,"lower-lip")
+
+    inner_mouth_points = landmarks68_utils.get_innner_mouth_points(landmark_list)
+    inner_mouth_mask = fill_points(inner_mouth_points)
+    append(inner_mouth_mask,"inner-mouth")
+    
+    
+    # TODO support type
+    contour_points = landmarks68_utils.get_landmark_points(landmark_list,landmarks68_utils.PARTS_CONTOUR)
+    
+    contour_points=landmarks68_utils.get_face_points(landmark_list)
+
+    contour_mask = fill_points(contour_points)
+    append(contour_mask,"contour")
+
+    mixed = Image.composite(eyes_mask,upper_lip_mask,eyes_mask.convert("L"))
+    mixed = Image.composite(mixed,lower_lip_mask,mixed.convert("L"))
+    mixed = Image.composite(mixed,inner_mouth_mask,mixed.convert("L"))
+    append(mixed,"mixed")
+
+    return [image,annotations],galleries
+    
+
+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
+
+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,
+
+import hashlib
+
+def text_to_sha256(text):
+    text_bytes = text.encode('utf-8')
+    hash_object = hashlib.sha256()
+    hash_object.update(text_bytes)
+    sha256_hex = hash_object.hexdigest()
+    return sha256_hex
+
+
+def create_json_download(text):
+    file_id = f"{dir_name}/landmark_{text_to_sha256(text)[:32]}.json"
+    write_file(file_id,text)
+    # try to save
+    return file_id
+
+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 Landmark 68 Mask", elem_id="run_button",variant="primary")
+                    
+                    with gr.Accordion(label="Advanced Settings", open=False):
+                        with gr.Row( equal_height=True):
+                            draw_number = gr.Checkbox(label="draw Number")
+
+                            font_scale = gr.Slider(
+                            label="Font Scale",
+                            minimum=0.1,
+                            maximum=2,
+                            step=0.1,
+                            value=0.5)
+
+                            text_color = gr.ColorPicker(value="rgba(200,200,200,1)",label="text color")
+                            #square_shape = gr.Checkbox(label="Square shape")
+                        with gr.Row( equal_height=True):
+                        
+                            line_color = gr.ColorPicker(value="rgba(0,0,255,1)",label="line color")
+                            line_size = gr.Slider(
+                                label="Line Size",
+                                minimum=0,
+                                maximum=20,
+                                step=1,
+                                value=1)
+                        with gr.Row( equal_height=True):
+                            dot_color = gr.ColorPicker(value="rgba(255,0,0,1)",label="dot color")
+                            dot_size = gr.Slider(
+                                label="Dot Size",
+                                minimum=0,
+                                maximum=40,
+                                step=1,
+                                value=3)
+                        with gr.Row( equal_height=True):
+                            box_color = gr.ColorPicker(value="rgba(200,200,200,1)",label="box color")
+                            box_size = gr.Slider(
+                                label="Box Size",
+                                minimum=0,
+                                maximum=20,
+                                step=1,
+                                value=1)
+                        with gr.Row( equal_height=True):
+                            json_format = gr.Radio(choices=["raw","face-detection"],value="face-detection",label="json-output format")
+                    
+                with gr.Column():
+                    image_out = gr.AnnotatedImage(label="Output", elem_id="output-img")
+                    image_gallery = gr.Gallery(label="masks",preview=True)
+                    #download_button.click(fn=json_download,inputs=text_out,outputs=download_button)
+            
+
+    btn.click(fn=process_images, inputs=[image],outputs=[image_out,image_gallery] ,api_name='infer')
+    gr.Examples(
+                examples =["examples/00003245_00.jpg","examples/00004200.jpg","examples/00002200.jpg","examples/00005259.jpg","examples/00018022.jpg","examples/img-above.jpg","examples/img-below.jpg","examples/img-side.jpg"],
+                inputs=[image]
+    )
+    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,17 @@
+<div style="text-align: center;">
+    <h1>
+        Mediapipe 68-points facial landmark
+    </h1>
+    <div  class="grid-container">
+        <img src="https://akjava.github.io/AIDiagramChatWithVoice-FaceCharacter/webp/128/00191245_09_00002200.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>
+            Contour points are not point-to-point mapping,because when face rotated some point move inside.<br>
+            Most of points are always divided equal for balancing when face rotated<br>
+        </p>
+    </div>
+    
+</div>

demo_tools.html

@@ -0,0 +1,4 @@
+<div style="text-align: center;">
+    <p><a href="https://huggingface.co/spaces/Akjava/mediapipe-face-detect">Mediapipe Face detector</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/cv2_utils.py

@@ -0,0 +1,49 @@
+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)

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

landmarks68_utils.py

@@ -0,0 +1,70 @@
+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 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)

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]

mp_utils.py

@@ -0,0 +1,94 @@
+import math
+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 points_to_bbox(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 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

requirements.txt

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