1
from ghunt.objects.apis import Parser
2

3
from typing import *
4

5

6
class VisionPosition(Parser):
7
    def __init__(self):
8
        self.x: int = None
9
        self.y: int = None
10
        self.z: int = None
11
    
12
    def _scrape(self, position_data: Dict[str, int]):
13
        self.x = position_data.get("x")
14
        self.y = position_data.get("y")
15
        self.z = position_data.get("z")
16

17
class VisionLandmark(Parser):
18
    def __init__(self):
19
        self.type: str = ""
20
        self.position: VisionPosition = VisionPosition()
21

22
    def _scrape(self, landmark_data: Dict[str, any]):
23
        self.type = landmark_data["type"]
24
        self.position._scrape(landmark_data["position"])
25

26
class VisionVertice(Parser):
27
    def __init__(self):
28
        self.x: int = None
29
        self.y: int = None
30

31
    def _scrape(self, vertice_data: Dict[str, int]):
32
        self.x = vertice_data.get("x")
33
        self.y = vertice_data.get("y")
34

35
class VisionVertices(Parser):
36
    def __init__(self):
37
        self.vertices: List[VisionVertice] = []
38

39
    def _scrape(self, vertices_data: List[Dict[str, int]]):
40
        for vertice_data in vertices_data:
41
            vertice = VisionVertice()
42
            vertice._scrape(vertice_data)
43
            self.vertices.append(vertice)
44

45
class VisionFaceAnnotation(Parser):
46
    def __init__(self):
47
        self.bounding_poly: VisionVertices = VisionVertices()
48
        self.fd_bounding_poly: VisionVertices = VisionVertices()
49
        self.landmarks: List[VisionLandmark] = []
50
        self.roll_angle: int = 0,
51
        self.pan_angle: int = 0,
52
        self.tilt_angle: int = 0,
53
        self.detection_confidence: int = 0,
54
        self.landmarking_confidence: int = 0,
55
        self.joy_likelihood: str = "",
56
        self.sorrow_likelihood: str = "",
57
        self.anger_likelihood: str = "",
58
        self.surprise_likelihood: str = "",
59
        self.under_exposed_likelihood: str = "",
60
        self.blurred_likelihood: str = "",
61
        self.headwear_likelihood: str = ""
62

63
    def _scrape(self, face_data: Dict[str, any]):
64
        if (vertices_data := face_data.get("boundingPoly", {}).get("vertices")):
65
            self.bounding_poly._scrape(vertices_data)
66
        if (vertices_data := face_data.get("fdBoundingPoly", {}).get("vertices")):
67
            self.fd_bounding_poly._scrape(vertices_data)
68
        if (landmarks_data := face_data.get("landmarks")):
69
            for landmark_data in landmarks_data:
70
                landmark = VisionLandmark()
71
                landmark._scrape(landmark_data)
72
                self.landmarks.append(landmark)
73
        self.roll_angle = face_data.get("rollAngle")
74
        self.pan_angle = face_data.get("panAngle")
75
        self.tilt_angle = face_data.get("tiltAngle")
76
        self.detection_confidence = face_data.get("detectionConfidence")
77
        self.landmarking_confidence = face_data.get("landmarkingConfidence")
78
        self.joy_likelihood = face_data.get("joyLikelihood")
79
        self.sorrow_likelihood = face_data.get("sorrowLikelihood")
80
        self.anger_likelihood = face_data.get("angerLikelihood")
81
        self.surprise_likelihood = face_data.get("surpriseLikelihood")
82
        self.under_exposed_likelihood = face_data.get("underExposedLikelihood")
83
        self.blurred_likelihood = face_data.get("blurredLikelihood")
84
        self.headwear_likelihood = face_data.get("headwearLikelihood")
85

86
class VisionFaceDetection(Parser):
87
    def __init__(self):
88
        self.face_annotations: List[VisionFaceAnnotation] = []
89

90
    def _scrape(self, vision_data: Dict[str, any]):
91
        for face_data in vision_data["faceAnnotations"]:
92
            face_annotation = VisionFaceAnnotation()
93
            face_annotation._scrape(face_data)
94
            self.face_annotations.append(face_annotation)
95