-
Notifications
You must be signed in to change notification settings - Fork 2
/
FaceMask.cpp
176 lines (143 loc) · 6.42 KB
/
FaceMask.cpp
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
#include <stdio.h>
#include <opencv2/opencv.hpp>
#include <opencv2/dnn.hpp>
#include <opencv2/highgui.hpp>
#include <fstream>
#include <iostream>
#include <opencv2/core/ocl.hpp>
#include "tensorflow/lite/interpreter.h"
#include "tensorflow/lite/kernels/register.h"
#include "tensorflow/lite/string_util.h"
#include "tensorflow/lite/model.h"
#include <cmath>
using namespace cv;
using namespace std;
int model_width;
int model_height;
int model_channels;
std::unique_ptr<tflite::Interpreter> interpreter;
//-----------------------------------------------------------------------------------------------------------------------
void GetImageTFLite(float* out, Mat &src)
{
int i,Len;
float f;
uint8_t *in;
static Mat image;
// copy image to input as input tensor
cv::resize(src, image, Size(model_width,model_height),INTER_NEAREST);
//model posenet_mobilenet_v1_100_257x257_multi_kpt_stripped.tflite runs from -1.0 ... +1.0
//model multi_person_mobilenet_v1_075_float.tflite runs from 0.0 ... +1.0
in=image.data;
Len=image.rows*image.cols*image.channels();
for(i=0;i<Len;i++){
f =in[i];
out[i]=(f - 127.5f) / 127.5f;
}
}
//-----------------------------------------------------------------------------------------------------------------------
void detect_from_video(Mat &src)
{
Mat image;
int cam_width =src.cols;
int cam_height=src.rows;
// copy image to input as input tensor
GetImageTFLite(interpreter->typed_tensor<float>(interpreter->inputs()[0]), src);
interpreter->AllocateTensors();
interpreter->SetAllowFp16PrecisionForFp32(true);
interpreter->SetNumThreads(4); //quad core
interpreter->Invoke(); // run your model
const float* detection_locations = interpreter->tensor(interpreter->outputs()[0])->data.f;
const float* detection_classes=interpreter->tensor(interpreter->outputs()[1])->data.f;
const float* detection_scores = interpreter->tensor(interpreter->outputs()[2])->data.f;
const int num_detections = *interpreter->tensor(interpreter->outputs()[3])->data.f;
//there are ALWAYS 10 detections no matter how many objects are detectable
//cout << "number of detections: " << num_detections << "\n";
const float confidence_threshold = 0.5;
for(int i = 0; i < num_detections; i++){
if(detection_scores[i] > confidence_threshold){
int det_index = (int)detection_classes[i];
float y1=detection_locations[4*i ]*cam_height;
float x1=detection_locations[4*i+1]*cam_width;
float y2=detection_locations[4*i+2]*cam_height;
float x2=detection_locations[4*i+3]*cam_width;
Rect rec((int)x1, (int)y1, (int)(x2 - x1), (int)(y2 - y1));
if(det_index==0){
rectangle(src,rec, Scalar(0, 255, 0), 2, 8, 0);
putText(src,"mask", Point(x1, y1-5) ,FONT_HERSHEY_SIMPLEX,0.7, Scalar(0, 255, 0), 1, 8, 0);
}
if(det_index==1){
rectangle(src,rec, Scalar(0, 0, 255), 2, 8, 0);
putText(src,"no mask", Point(x1, y1-5) ,FONT_HERSHEY_SIMPLEX,0.7, Scalar(0, 0, 255), 1, 8, 0);
}
if(det_index==2){
rectangle(src,rec, Scalar(0, 127, 255), 2, 8, 0);
putText(src,"wear incorrect", Point(x1, y1-5) ,FONT_HERSHEY_SIMPLEX,0.7, Scalar(0, 127, 255), 1, 8, 0);
}
}
}
}
//-----------------------------------------------------------------------------------------------------------------------
int main(int argc,char ** argv)
{
float f;
float FPS[16];
int i;
int Fcnt=0;
Mat frame;
chrono::steady_clock::time_point Tbegin, Tend;
for(i=0;i<16;i++) FPS[i]=0.0;
// Load model
std::unique_ptr<tflite::FlatBufferModel> model = tflite::FlatBufferModel::BuildFromFile("ssd_mobilenet_v2_fpnlite.tflite");
// std::unique_ptr<tflite::FlatBufferModel> model = tflite::FlatBufferModel::BuildFromFile("ssdlite_mobilenet_v2.tflite");
// Build the interpreter
tflite::ops::builtin::BuiltinOpResolver resolver;
tflite::InterpreterBuilder(*model.get(), resolver)(&interpreter);
interpreter->AllocateTensors();
// Get input dimension from the input tensor metadata
// Assuming one input only
int In = interpreter->inputs()[0];
model_height = interpreter->tensor(In)->dims->data[1];
model_width = interpreter->tensor(In)->dims->data[2];
model_channels = interpreter->tensor(In)->dims->data[3];
cout << "height : "<< model_height << endl;
cout << "width : "<< model_width << endl;
cout << "channels : "<< model_channels << endl;
cout << "tensors size: " << interpreter->tensors_size() << "\n";
cout << "nodes size: " << interpreter->nodes_size() << "\n";
cout << "inputs: " << interpreter->inputs().size() << "\n";
cout << "input(0) name: " << interpreter->GetInputName(0) << "\n";
cout << "outputs: " << interpreter->outputs().size() << "\n";
VideoCapture cap("Face_Mask_Video.mp4");//Norton_M3.mp4");
if (!cap.isOpened()) {
cerr << "ERROR: Unable to open the camera" << endl;
return 0;
}
cout << "Start grabbing, press ESC on Live window to terminate" << endl;
while(1){
// frame=imread("Kapje_2.jpg"); //need to refresh frame before dnn class detection
cap >> frame;
if (frame.empty()) {
cerr << "End of movie" << endl;
break;
}
detect_from_video(frame);
Tend = chrono::steady_clock::now();
//calculate frame rate
f = chrono::duration_cast <chrono::milliseconds> (Tend - Tbegin).count();
Tbegin = chrono::steady_clock::now();
FPS[((Fcnt++)&0x0F)]=1000.0/f;
for(f=0.0, i=0;i<16;i++){ f+=FPS[i]; }
putText(frame, format("FPS %0.2f",f/16),Point(10,20),FONT_HERSHEY_SIMPLEX,0.6, Scalar(0, 0, 255));
//show output
imshow("RPi 4 - 2.0 GHz - 2 Mb RAM", frame);
char esc = waitKey(5);
if(esc == 27) break;
}
cout << "Closing the camera" << endl;
// When everything done, release the video capture and write object
cap.release();
destroyAllWindows();
cout << "Bye!" << endl;
return 0;
}
//-----------------------------------------------------------------------------------------------------------------------