FaceDetectionLBPWithOpenCVClassifiers/LBPFeature.py at master · MatveyMelnikov/FaceDetectionLBPWithOpenCVClassifiers · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
import IntegralImage as IntegralImage

from Rectangle import Rectangle


def create_lbp_rect_line_with_offset(rects, top_left_rect, y_offset):
    rects.append(
        create_lbp_rect_with_offset(
            top_left_rect,
            (0, y_offset)
        )
    )
    for i in range(1, 3):
        rects.append(
            create_lbp_rect_with_offset(
                top_left_rect, (top_left_rect.size[0] * i, y_offset)
            )
        )


def create_lbp_rect_with_offset(base_rect, pos_offset):
    return Rectangle(
        (base_rect.pos[0] + pos_offset[0], base_rect.pos[1] + pos_offset[1]),
        base_rect.size
    )


def apply_scale(rect, scale):
    return Rectangle(
        (int(rect.pos[0] * scale),
         int(rect.pos[1] * scale)),
        (int(rect.size[0] * scale),
         int(rect.size[1] * scale))
    )


def apply_offset(rect, offset):
    return Rectangle(
        (rect.pos[0] + offset[0], rect.pos[1] + offset[1]),
        rect.size
    )


class LBPFeature:
    # 1. rectangle from XML, 2. subset of masks, 3. float, 4. float
    def __init__(self, top_left_rect, masks, left_value, right_value):
        # self.rect = rect
        self.rects = None
        self.scaled_features = None
        self.masks = masks
        self.left_value = left_value
        self.right_value = right_value

        self.generate_lbp_rects(top_left_rect)

    def calculate_scaled_features(self, scales):
        self.scaled_features = []

        for scale in scales:
            scaled_rects = []

            for rect in self.rects:
                scaled_rects.append(apply_scale(rect, scale))

            self.scaled_features.append(scaled_rects)

    def generate_lbp_rects(self, top_left_rect):
        #  0  1  2  3
        #  4  5  6  7
        #  8  9 10 11
        # 12 13 14 15

        # Bits in LBP
        # *-*-*-*
        # |7|6|5|
        # *-*-*-*
        # |0| |4|
        # *-*-*-*
        # |1|2|3|
        # *-*-*-*

        self.rects = []

        for i in range(0, 3):
            create_lbp_rect_line_with_offset(self.rects, top_left_rect, top_left_rect.size[1] * i)

    def get_score(self, integral_image, offset, scale_index):
        score = 0

        current_scale_rects = self.scaled_features[scale_index]

        center_value = IntegralImage.sum_region(
            integral_image,
            apply_offset(current_scale_rects[4], offset)
        )

        if IntegralImage.sum_region(
                integral_image,
                apply_offset(current_scale_rects[0], offset)
        ) >= center_value:
            score |= 128
        if IntegralImage.sum_region(
                integral_image,
                apply_offset(current_scale_rects[1], offset)
        ) >= center_value:
            score |= 64
        if IntegralImage.sum_region(
                integral_image,
                apply_offset(current_scale_rects[2], offset)
        ) >= center_value:
            score |= 32
        if IntegralImage.sum_region(
                integral_image,
                apply_offset(current_scale_rects[3], offset)
        ) >= center_value:
            score |= 1
        if IntegralImage.sum_region(
                integral_image,
                apply_offset(current_scale_rects[5], offset)
        ) >= center_value:
            score |= 16
        if IntegralImage.sum_region(
                integral_image,
                apply_offset(current_scale_rects[6], offset)
        ) >= center_value:
            score |= 2
        if IntegralImage.sum_region(
                integral_image,
                apply_offset(current_scale_rects[7], offset)
        ) >= center_value:
            score |= 4
        if IntegralImage.sum_region(
                integral_image,
                apply_offset(current_scale_rects[8], offset)
        ) >= center_value:
            score |= 8

        return score

    def get_vote(self, integral_image, offset, scale_index):
        score = self.get_score(integral_image, offset, scale_index)

        return self.right_value if self.masks[score >> 5] & (1 << (score & 31)) else self.left_value