dockerfile/openalpr-base
1
0
Fork 0
mirror of https://github.com/kerberos-io/openalpr-base.git synced 2025-10-06 07:16:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

Changed indents to be consistent

Browse Source
This commit is contained in:
Matt Hill
2015-03-18 18:32:07 -04:00
parent c04dd4104d
commit fb3c93a162
2 changed files with 143 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

246
src/openalpr/detection/detectormorph.cpp
View File

@@ -1,167 +1,155 @@
/* /*
* Copyright (c) 2014 New Designs Unlimited, LLC * Copyright (c) 2014 New Designs Unlimited, LLC
* Opensource Automated License Plate Recognition [http://www.openalpr.com] * Opensource Automated License Plate Recognition [http://www.openalpr.com]
* *
* This file is part of OpenAlpr. * This file is part of OpenAlpr.
* *
* OpenAlpr is free software: you can redistribute it and/or modify * OpenAlpr is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License * it under the terms of the GNU Affero General Public License
* version 3 as published by the Free Software Foundation * version 3 as published by the Free Software Foundation
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details. * GNU Affero General Public License for more details.
* *
* You should have received a copy of the GNU Affero General Public License * You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "detectormorph.h" #include "detectormorph.h"
using namespace cv; using namespace cv;
using namespace std; using namespace std;
namespace alpr namespace alpr {
{
DetectorMorph::DetectorMorph(Config* config) : Detector(config) {
DetectorMorph::DetectorMorph(Config* config) : Detector(config) { this->loaded = true;
}
this->loaded = true; DetectorMorph::~DetectorMorph() {
} }
vector<PlateRegion> DetectorMorph::detect(Mat frame, std::vector<cv::Rect> regionsOfInterest) {
DetectorMorph::~DetectorMorph() { Mat frame_gray;
} cvtColor(frame, frame_gray, CV_BGR2GRAY);
vector<PlateRegion> DetectorMorph::detect(Mat frame, std::vector<cv::Rect> regionsOfInterest) vector<PlateRegion> detectedRegions;
{ for (int i = 0; i < regionsOfInterest.size(); i++) {
Mat img_open, img_result;
Mat element = getStructuringElement(MORPH_RECT, Size(30, 4));
morphologyEx(frame_gray, img_open, CV_MOP_OPEN, element, cv::Point(-1, -1));
Mat frame_gray; img_result = frame_gray - img_open;
cvtColor(frame, frame_gray, CV_BGR2GRAY);
vector<PlateRegion> detectedRegions; if (config->debugDetector && config->debugShowImages) {
for (int i = 0; i < regionsOfInterest.size(); i++) imshow("Opening", img_result);
{ }
Mat img_open, img_result;
Mat element = getStructuringElement(MORPH_RECT, Size(30, 4));
morphologyEx(frame_gray, img_open, CV_MOP_OPEN, element, cv::Point(-1, -1));
img_result = frame_gray - img_open; //threshold image using otsu thresholding
Mat img_threshold, img_open2;
threshold(img_result, img_threshold, 0, 255, CV_THRESH_OTSU + CV_THRESH_BINARY);
if (config->debugDetector && config->debugShowImages) if (config->debugDetector && config->debugShowImages) {
{ imshow("Threshold Detector", img_threshold);
imshow("Opening", img_result); }
}
//threshold image using otsu thresholding
Mat img_threshold, img_open2;
threshold(img_result, img_threshold, 0, 255, CV_THRESH_OTSU + CV_THRESH_BINARY);
if (config->debugDetector && config->debugShowImages) Mat circularElement = getStructuringElement(cv::MORPH_ELLIPSE, Size(5, 5));
{ morphologyEx(img_threshold, img_open2, CV_MOP_OPEN, circularElement, cv::Point(-1, -1));
imshow("Threshold Detector", img_threshold); Mat rectElement = getStructuringElement(cv::MORPH_RECT, Size(20, 4));
} morphologyEx(img_open2, img_threshold, CV_MOP_CLOSE, rectElement, cv::Point(-1, -1));
Mat circularElement = getStructuringElement(cv::MORPH_ELLIPSE, Size(5, 5)); if (config->debugDetector && config->debugShowImages) {
morphologyEx(img_threshold, img_open2, CV_MOP_OPEN, circularElement, cv::Point(-1, -1)); imshow("Close", img_threshold);
Mat rectElement = getStructuringElement(cv::MORPH_RECT, Size(20, 4)); waitKey(0);
morphologyEx(img_open2, img_threshold, CV_MOP_CLOSE, rectElement, cv::Point(-1, -1)); }
if (config->debugDetector && config->debugShowImages) //Find contours of possibles plates
{ vector< vector< Point> > contours;
imshow("Close", img_threshold); findContours(img_threshold,
waitKey(0); contours, // a vector of contours
} CV_RETR_EXTERNAL, // retrieve the external contours
CV_CHAIN_APPROX_NONE); // all pixels of each contours
//Find contours of possibles plates
vector< vector< Point> > contours;
findContours(img_threshold,
contours, // a vector of contours
CV_RETR_EXTERNAL, // retrieve the external contours
CV_CHAIN_APPROX_NONE); // all pixels of each contours
//Start to iterate to each contour founded //Start to iterate to each contour founded
vector<vector<Point> >::iterator itc = contours.begin(); vector<vector<Point> >::iterator itc = contours.begin();
vector<RotatedRect> rects; vector<RotatedRect> rects;
//Remove patch that are no inside limits of aspect ratio and area. //Remove patch that are no inside limits of aspect ratio and area.
while (itc != contours.end()) while (itc != contours.end()) {
{ //Create bounding rect of object
//Create bounding rect of object RotatedRect mr = minAreaRect(Mat(*itc));
RotatedRect mr = minAreaRect(Mat(*itc)); if (!CheckSizes(mr))
if (!CheckSizes(mr)) itc = contours.erase(itc);
itc = contours.erase(itc); else {
else ++itc;
{ if (itc == contours.end()) continue;
++itc; rects.push_back(mr);
if (itc == contours.end()) continue; }
rects.push_back(mr); }
}
}
//Now prunning based on checking all candidate plates for a min/max number of blobs //Now prunning based on checking all candidate plates for a min/max number of blobs
Mat img_crop, img_crop_b; Mat img_crop, img_crop_b;
vector< vector< Point> > plateBlobs; vector< vector< Point> > plateBlobs;
for (int i = 0; i < rects.size(); i++) for (int i = 0; i < rects.size(); i++) {
{ RotatedRect PlateRect = rects[i];
RotatedRect PlateRect = rects[i]; Size rect_size = PlateRect.size;
Size rect_size = PlateRect.size;
//Crop area around candidate plate
getRectSubPix(frame_gray, rect_size, PlateRect.center, img_crop);
//Thresholding
threshold(img_crop, img_crop_b, 0, 255, cv::THRESH_BINARY_INV + cv::THRESH_OTSU);
findContours(img_crop_b, //Crop area around candidate plate
plateBlobs, // a vector of contours getRectSubPix(frame_gray, rect_size, PlateRect.center, img_crop);
CV_RETR_EXTERNAL, // retrieve the external contours //Thresholding
CV_CHAIN_APPROX_NONE); // all pixels of each contours threshold(img_crop, img_crop_b, 0, 255, cv::THRESH_BINARY_INV + cv::THRESH_OTSU);
int numBlobs = plateBlobs.size(); findContours(img_crop_b,
plateBlobs, // a vector of contours
CV_RETR_EXTERNAL, // retrieve the external contours
CV_CHAIN_APPROX_NONE); // all pixels of each contours
//If too much or too little might not be a true plate int numBlobs = plateBlobs.size();
if (numBlobs < 3 || numBlobs > 20) continue;
PlateRegion PlateReg; //If too much or too little might not be a true plate
if (numBlobs < 3 || numBlobs > 20) continue;
PlateReg.rect = PlateRect.boundingRect(); PlateRegion PlateReg;
detectedRegions.push_back(PlateReg); PlateReg.rect = PlateRect.boundingRect();
} detectedRegions.push_back(PlateReg);
}
return detectedRegions; }
}
bool DetectorMorph::CheckSizes(RotatedRect& mr) }
{
float error = 1.2; return detectedRegions;
}
float aspect = config->plateWidthMM / config->plateHeightMM;
//Set a min and max area. All other patchs are discarded
int min = 10 * aspect * 10; // minimum area
int max = 100 * aspect * 100; // maximum area
//Get only patchs that match to a respect ratio.
float rmin = 3.0;
float rmax = 7.0;
int area = mr.size.height * mr.size.width; bool DetectorMorph::CheckSizes(RotatedRect& mr) {
float r = (float)mr.size.width / (float)mr.size.height;
if (r<1)
r = (float)mr.size.height / (float)mr.size.width;
if ((area < min || area > max) || (r < rmin || r > rmax) || float error = 1.2;
(mr.size.width < 20 || mr.size.width > 300) )
return false; float aspect = config->plateWidthMM / config->plateHeightMM;
else //Set a min and max area. All other patchs are discarded
return true; int min = 10 * aspect * 10; // minimum area
int max = 100 * aspect * 100; // maximum area
//Get only patchs that match to a respect ratio.
float rmin = 3.0;
float rmax = 7.0;
int area = mr.size.height * mr.size.width;
float r = (float) mr.size.width / (float) mr.size.height;
if (r < 1)
r = (float) mr.size.height / (float) mr.size.width;
if ((area < min || area > max) || (r < rmin || r > rmax) ||
(mr.size.width < 20 || mr.size.width > 300))
return false;
else
return true;
}
}
} }

53
src/openalpr/detection/detectormorph.h
View File

@@ -1,21 +1,21 @@
/* /*
* Copyright (c) 2014 New Designs Unlimited, LLC * Copyright (c) 2014 New Designs Unlimited, LLC
* Opensource Automated License Plate Recognition [http://www.openalpr.com] * Opensource Automated License Plate Recognition [http://www.openalpr.com]
* *
* This file is part of OpenAlpr. * This file is part of OpenAlpr.
* *
* OpenAlpr is free software: you can redistribute it and/or modify * OpenAlpr is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License * it under the terms of the GNU Affero General Public License
* version 3 as published by the Free Software Foundation * version 3 as published by the Free Software Foundation
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details. * GNU Affero General Public License for more details.
* *
* You should have received a copy of the GNU Affero General Public License * You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef OPENALPR_DETECTORMORPH_H #ifndef OPENALPR_DETECTORMORPH_H
#define OPENALPR_DETECTORMORPH_H #define OPENALPR_DETECTORMORPH_H
@@ -31,20 +31,19 @@
#include "detector.h" #include "detector.h"
namespace alpr namespace alpr {
{
class DetectorMorph : public Detector { class DetectorMorph : public Detector {
public: public:
DetectorMorph(Config* config); DetectorMorph(Config* config);
virtual ~DetectorMorph(); virtual ~DetectorMorph();
std::vector<PlateRegion> detect(cv::Mat frame, std::vector<cv::Rect> regionsOfInterest); std::vector<PlateRegion> detect(cv::Mat frame, std::vector<cv::Rect> regionsOfInterest);
private: private:
bool CheckSizes(cv::RotatedRect& mr); bool CheckSizes(cv::RotatedRect& mr);
}; };
} }