-
Notifications
You must be signed in to change notification settings - Fork 0
/
vehicledetector.cpp
172 lines (149 loc) · 6.5 KB
/
vehicledetector.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
#include "vehicledetector.h"
using namespace cv;
using namespace dnn;
using namespace std;
VehicleDetector::VehicleDetector(QObject *parent) : QObject(parent)
{
// Initialize the parameters
confThreshold = 0.3; // Confidence threshold
nmsThreshold = 0.3; // Non-maximum suppression threshold
inpWidth = 416; // Width of network's input image
inpHeight = 416; // Height of network's input image
}
void VehicleDetector::initNetwork()
{
string classesFile = "/home/hp/Mascir_LPR/data2/PL.names";//"/home/hp/Yolo/data3/LP.names";///home/hp/Yolo/data/obj.names
ifstream ifs(classesFile.c_str());
string line;
while (getline(ifs, line)) classes.push_back(line);
// Give the configuration and weight files for the model
String modelConfiguration = "/home/hp/Mascir_LPR/data2/PL.cfg";//"/home/hp/Yolo/data3/LP.cfg";///home/hp/Yolo/data/yolo-LP.cfg
String modelWeights = "/home/hp/Mascir_LPR/data2/PL_26000.weights";//"/home/hp/Yolo/data3/LP.weights";///home/hp/Yolo/data/yolo-LP_2000.weights
// Load the network
net = readNetFromDarknet(modelConfiguration, modelWeights);
net.setPreferableBackend(DNN_BACKEND_OPENCV);
net.setPreferableTarget(DNN_TARGET_CPU);
}
plate VehicleDetector::detect(Mat& frame)
{
Mat blob,frame1;
vector<Rect> New_boxes;
plate result;
cv::resize(frame,frame1,cv::Size(416,416));
// Create a 4D blob from a frame.
blobFromImage(frame1, blob, 1/255.0, cvSize(inpWidth, inpHeight), Scalar(0,0,0), true, false);
//Sets the input to the network
net.setInput(blob);
// Runs the forward pass to get output of the output layers
vector<Mat> outs;
net.forward(outs, getOutputsNames(net));
// Remove the bounding boxes with low confidence
result = postprocess(frame, outs);
// Put efficiency information. The function getPerfProfile returns the overall time for inference(t) and the timings for each of the layers(in layersTimes)
vector<double> layersTimes;
double freq = getTickFrequency() / 1000;
double t = net.getPerfProfile(layersTimes) / freq;
string label = format("Inference time for a frame : %.2f ms", t);
//string out= format("size = %d",outs.size());
putText(frame, label, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.75, Scalar(0, 0, 255));
return result;
}
plate VehicleDetector::postprocess(Mat& frame, const vector<Mat>& outs)
{
vector<int> classIds;
vector<float> confidences;
vector<Rect> boxes;
for (size_t i = 0; i < outs.size(); ++i)
{
// Scan through all the bounding boxes output from the network and keep only the
// ones with high confidence scores. Assign the box's class label as the class
// with the highest score for the box.
float* data = (float*)outs[i].data;
for (int j = 0; j < outs[i].rows; ++j, data += outs[i].cols)
{
Mat scores = outs[i].row(j).colRange(5, outs[i].cols);
Point classIdPoint;
double confidence;
// Get the value and location of the maximum score
minMaxLoc(scores, 0, &confidence, 0, &classIdPoint);
if (confidence > confThreshold)
{
int centerX = (int)(data[0] * frame.cols);
int centerY = (int)(data[1] * frame.rows);
int width = (int)(data[2] * frame.cols);
int height = (int)(data[3] * frame.rows);
int left = centerX - width / 2;
int top = centerY - height / 2;
classIds.push_back(classIdPoint.x);
confidences.push_back((float)confidence);
if (0 <= left && 0 <= width && left + width <= frame.cols && 0 <= top && 0 <= height && top + height <= frame.rows) {
boxes.push_back(Rect(left, top, width, height));
}
// if (left>0 && width>0 && left+width<frame.cols && top+height<frame.rows){
// }
}
}
}
plate results;// ={null,null,null,null};
// Perform non maximum suppression to eliminate redundant overlapping boxes with
// lower confidences
if (!boxes.empty()) {
vector<int> indices;
NMSBoxes(boxes, confidences, confThreshold, nmsThreshold, indices);
// Mat img;
for (size_t i = 0; i < indices.size(); ++i)
{
int idx = indices[i];
Rect box = boxes[idx];
// drawPred(classIds[idx], confidences[idx], box.x, box.y,
// box.x + box.width, box.y + box.height, frame);
// cout<<box.x<<endl;
// cout<<box.y<<endl;
}
//imshow("frame",frame);
/*for (size_t i = 0; i < outs.size(); ++i){
cv::resize(outs[i],outs[i],cv::Size(100,30));
imshow("output",outs[i]);
}*/
//cv::resize(outs[0],outs[0],cv::Size(100,30));
//imshow("output",img);
results = {classIds,boxes,indices,confidences};
}
return results;
}
void VehicleDetector::drawPred(int classId, float conf, int left, int top, int right, int bottom, Mat& frame)
{
//Draw a rectangle displaying the bounding box
rectangle(frame, Point(left, top), Point(right, bottom), Scalar(0, 0, 255), 3);
//Get the label for the class name and its confidence
string label = format("%.2f", conf);
if (!classes.empty())
{
CV_Assert(classId < (int)classes.size());
label = classes[classId] + ":" + label;
// cout<<"label : ";
// cout<<label<<endl;//show in console
}
//Display the label at the top of the bounding box
int baseLine;
Size labelSize = getTextSize(label, FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
top = max(top, labelSize.height);
rectangle(frame, Point(left, top - round(1.5*labelSize.height)), Point(left + round(1.5*labelSize.width), top + baseLine), Scalar(255, 255, 255), FILLED);
putText(frame, label, Point(left, top), FONT_HERSHEY_SIMPLEX, 0.75, Scalar(0,0,0),1);
}
vector<String> VehicleDetector::getOutputsNames(const Net& net)
{
static vector<String> names;
if (names.empty())
{
//Get the indices of the output layers, i.e. the layers with unconnected outputs
vector<int> outLayers = net.getUnconnectedOutLayers();
//get the names of all the layers in the network
vector<String> layersNames = net.getLayerNames();
// Get the names of the output layers in names
names.resize(outLayers.size());
for (size_t i = 0; i < outLayers.size(); ++i)
names[i] = layersNames[outLayers[i] - 1];
}
return names;
}