dev(narugo): 2 more

app2.py

@@ -2,7 +2,7 @@ import os
 
 import gradio as gr
 
-from detection import EyesDetection
+from detection import EyesDetection, FaceDetection, HeadDetection
 
 _GLOBAL_CSS = """
 .limit-height {
@@ -13,6 +13,10 @@ _GLOBAL_CSS = """
 if __name__ == '__main__':
     with gr.Blocks(css=_GLOBAL_CSS) as demo:
         with gr.Tabs():
+            with gr.Tab('Face Detection'):
+                FaceDetection().make_ui()
+            with gr.Tab('Head Detection'):
+                HeadDetection().make_ui()
             with gr.Tab('Eyes Detection'):
                 EyesDetection().make_ui()
 

detection/__init__.py

@@ -1,2 +1,4 @@
 from .base import ObjectDetection, DeepGHSObjectDetection
-from .eyes import EyesDetection
+from .eyes import EyesDetection
+from .face import FaceDetection
+from .head import HeadDetection

detection/face.py

@@ -0,0 +1,33 @@
+import re
+from typing import List, Tuple
+
+from imgutils.data import ImageTyping
+from imgutils.detect.face import detect_faces
+
+from .base import DeepGHSObjectDetection
+
+
+def _parse_model_name(model_name: str):
+    matching = re.fullmatch(r'^face_detect_(?P<version>[\s\S]+?)_(?P<level>[\s\S]+?)$', model_name)
+    return matching.group('version'), matching.group('level')
+
+
+class FaceDetection(DeepGHSObjectDetection):
+    def __init__(self):
+        DeepGHSObjectDetection.__init__(self, 'deepghs/anime_face_detection')
+
+    def _get_default_model(self) -> str:
+        return 'face_detect_v1.4_s'
+
+    def _get_default_iou_and_score(self, model_name: str) -> Tuple[float, float]:
+        return 0.7, 0.25
+
+    def _get_labels(self, model_name: str) -> List[str]:
+        return ['face']
+
+    def detect(self, image: ImageTyping, model_name: str,
+               iou_threshold: float = 0.7, score_threshold: float = 0.25) -> \
+            List[Tuple[Tuple[float, float, float, float], str, float]]:
+        version, level = _parse_model_name(model_name)
+        return detect_faces(image, level=level, version=version,
+                            conf_threshold=score_threshold, iou_threshold=iou_threshold)

detection/head.py

@@ -0,0 +1,47 @@
+import os.path
+import re
+from typing import List, Tuple
+
+from hfutils.operate import get_hf_fs
+from hfutils.utils import hf_fs_path, parse_hf_fs_path
+from imgutils.data import ImageTyping
+from imgutils.detect import detect_heads
+
+from .base import ObjectDetection
+
+
+def _parse_model_name(model_name: str):
+    matching = re.fullmatch(r'^head_detect_best_(?P<level>[\s\S]+?)$', model_name)
+    return matching.group('level')
+
+
+class HeadDetection(ObjectDetection):
+    def __init__(self):
+        self.repo_id = 'deepghs/imgutils-models'
+
+    def _get_default_model(self) -> str:
+        return 'head_detect_best_s'
+
+    def _list_models(self) -> List[str]:
+        hf_fs = get_hf_fs()
+        return [
+            os.path.splitext(os.path.basename(parse_hf_fs_path(path).filename))[0]
+            for path in hf_fs.glob(hf_fs_path(
+                repo_id=self.repo_id,
+                repo_type='model',
+                filename='head_detect/*.onnx',
+            ))
+        ]
+
+    def _get_default_iou_and_score(self, model_name: str) -> Tuple[float, float]:
+        return 0.7, 0.3
+
+    def _get_labels(self, model_name: str) -> List[str]:
+        return ['head']
+
+    def detect(self, image: ImageTyping, model_name: str,
+               iou_threshold: float = 0.7, score_threshold: float = 0.25) -> \
+            List[Tuple[Tuple[float, float, float, float], str, float]]:
+        level = _parse_model_name(model_name)
+        return detect_heads(image=image, level=level,
+                            iou_threshold=iou_threshold, conf_threshold=score_threshold)