void ShmSystemV::Read(char *buffer, size_t size, size_t start)
{
CheckSizes(size, start, "in call to Read");
ProfilerStart("read");
std::memcpy(buffer, &m_Buffer[start], size);
ProfilerStop("read");
}
int main(int argc, char* argv[]) {
int nerror = 0;
nerror += CheckSizes();
nerror += CheckAlignment();
nerror += CheckBitfields();
return nerror;
}
void ShmSystemV::Write(const char *buffer, size_t size, size_t start)
{
CheckSizes(size, start, "in call to Write");
ProfilerStart("write");
std::memcpy(&m_Buffer[start], buffer, size);
ProfilerStop("write");
}
//=============================================================================
int Epetra_DistObject::DoTransfer(const Epetra_SrcDistObject& A,
Epetra_CombineMode CombineMode,
int NumSameIDs,
int NumPermuteIDs,
int NumRemoteIDs,
int NumExportIDs,
int* PermuteToLIDs,
int* PermuteFromLIDs,
int* RemoteLIDs,
int* ExportLIDs,
int& LenExports,
char*& Exports,
int& LenImports,
char*& Imports,
Epetra_Distributor& Distor,
bool DoReverse,
const Epetra_OffsetIndex * Indexor)
{
EPETRA_CHK_ERR(CheckSizes(A));
if (NumSameIDs + NumPermuteIDs > 0) {
EPETRA_CHK_ERR(CopyAndPermute(A, NumSameIDs, NumPermuteIDs, PermuteToLIDs, PermuteFromLIDs,Indexor, CombineMode));
}
// Once CopyAndPermute is done, switch to Add so rest works as before.
if(CombineMode == Epetra_AddLocalAlso) {
CombineMode = Add;
}
if (CombineMode==Zero)
return(0); // All done if CombineMode only involves copying and permuting
int SizeOfPacket;
bool VarSizes = false;
if( NumExportIDs > 0) {
delete [] Sizes_;
Sizes_ = new int[NumExportIDs];
}
EPETRA_CHK_ERR(PackAndPrepare(A, NumExportIDs, ExportLIDs,
LenExports, Exports, SizeOfPacket, Sizes_, VarSizes, Distor));
if ((DistributedGlobal_ && DoReverse) || (A.Map().DistributedGlobal() && !DoReverse)) {
if (DoReverse) {
// Do the exchange of remote data
if( VarSizes ) {
EPETRA_CHK_ERR(Distor.DoReverse(Exports, SizeOfPacket, Sizes_, LenImports, Imports));
}
else {
EPETRA_CHK_ERR(Distor.DoReverse(Exports, SizeOfPacket, LenImports, Imports));
}
}
else {
// Do the exchange of remote data
if( VarSizes ) {
EPETRA_CHK_ERR(Distor.Do(Exports, SizeOfPacket, Sizes_, LenImports, Imports));
}
else {
EPETRA_CHK_ERR(Distor.Do(Exports, SizeOfPacket, LenImports, Imports));
}
}
EPETRA_CHK_ERR(UnpackAndCombine(A, NumRemoteIDs, RemoteLIDs, LenImports, Imports, SizeOfPacket, Distor, CombineMode, Indexor));
}
return(0);
}
vector<PlateRegion> DetectorMorph::detect(Mat frame, std::vector<cv::Rect> regionsOfInterest) {
Mat frame_gray,frame_gray_cp;
if (frame.channels() > 2)
{
cvtColor( frame, frame_gray, CV_BGR2GRAY );
}
else
{
frame.copyTo(frame_gray);
}
frame_gray.copyTo(frame_gray_cp);
blur(frame_gray, frame_gray, Size(5, 5));
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));
img_result = frame_gray - img_open;
if (config->debugDetector && config->debugShowImages) {
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) {
imshow("Threshold Detector", img_threshold);
}
Mat diamond(5, 5, CV_8U, cv::Scalar(1));
diamond.at<uchar>(0, 0) = 0;
diamond.at<uchar>(0, 1) = 0;
diamond.at<uchar>(1, 0) = 0;
diamond.at<uchar>(4, 4) = 0;
diamond.at<uchar>(3, 4) = 0;
diamond.at<uchar>(4, 3) = 0;
diamond.at<uchar>(4, 0) = 0;
diamond.at<uchar>(4, 1) = 0;
diamond.at<uchar>(3, 0) = 0;
diamond.at<uchar>(0, 4) = 0;
diamond.at<uchar>(0, 3) = 0;
diamond.at<uchar>(1, 4) = 0;
morphologyEx(img_threshold, img_open2, CV_MOP_OPEN, diamond, cv::Point(-1, -1));
Mat rectElement = getStructuringElement(cv::MORPH_RECT, Size(13, 4));
morphologyEx(img_open2, img_threshold, CV_MOP_CLOSE, rectElement, cv::Point(-1, -1));
if (config->debugDetector && config->debugShowImages) {
imshow("Close", img_threshold);
waitKey(0);
}
//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
vector<vector<Point> >::iterator itc = contours.begin();
vector<RotatedRect> rects;
//Remove patch that are no inside limits of aspect ratio and area.
while (itc != contours.end()) {
//Create bounding rect of object
RotatedRect mr = minAreaRect(Mat(*itc));
if (mr.angle < -45.) {
mr.angle += 90.0;
swap(mr.size.width, mr.size.height);
}
if (!CheckSizes(mr))
itc = contours.erase(itc);
else {
++itc;
rects.push_back(mr);
}
}
//Now prunning based on checking all candidate plates for a min/max number of blobsc
Mat img_crop, img_crop_b, img_crop_th, img_crop_th_inv;
vector< vector< Point> > plateBlobs;
vector< vector< Point> > plateBlobsInv;
double thresholds[] = { 10, 40, 80, 120, 160, 200, 240 };
const int num_thresholds = 7;
int numValidChars = 0;
Mat rotated;
for (int i = 0; i < rects.size(); i++) {
numValidChars = 0;
RotatedRect PlateRect = rects[i];
Size rect_size = PlateRect.size;
// get the rotation matrix
Mat M = getRotationMatrix2D(PlateRect.center, PlateRect.angle, 1.0);
// perform the affine transformation
warpAffine(frame_gray_cp, rotated, M, frame_gray_cp.size(), INTER_CUBIC);
//Crop area around candidate plate
getRectSubPix(rotated, rect_size, PlateRect.center, img_crop);
if (config->debugDetector && config->debugShowImages) {
imshow("Tilt Correction", img_crop);
waitKey(0);
}
for (int z = 0; z < num_thresholds; z++) {
cv::threshold(img_crop, img_crop_th, thresholds[z], 255, cv::THRESH_BINARY);
cv::threshold(img_crop, img_crop_th_inv, thresholds[z], 255, cv::THRESH_BINARY_INV);
findContours(img_crop_th,
plateBlobs, // a vector of contours
CV_RETR_LIST, // retrieve the contour list
CV_CHAIN_APPROX_NONE); // all pixels of each contours
findContours(img_crop_th_inv,
plateBlobsInv, // a vector of contours
CV_RETR_LIST, // retrieve the contour list
CV_CHAIN_APPROX_NONE); // all pixels of each contours
int numBlobs = plateBlobs.size();
int numBlobsInv = plateBlobsInv.size();
float idealAspect = config->avgCharWidthMM / config->avgCharHeightMM;
for (int j = 0; j < numBlobs; j++) {
cv::Rect r0 = cv::boundingRect(cv::Mat(plateBlobs[j]));
if (ValidateCharAspect(r0, idealAspect))
numValidChars++;
}
for (int j = 0; j < numBlobsInv; j++) {
cv::Rect r0 = cv::boundingRect(cv::Mat(plateBlobsInv[j]));
if (ValidateCharAspect(r0, idealAspect))
numValidChars++;
}
}
//If too much or too lcittle might not be a true plate
//if (numBlobs < 3 || numBlobs > 50) continue;
if (numValidChars < 4 || numValidChars > 50) continue;
PlateRegion PlateReg;
// Ensure that the rectangle isn't < 0 or > maxWidth/Height
Rect bounding_rect = PlateRect.boundingRect();
PlateReg.rect = expandRect(bounding_rect, 0, 0, frame.cols, frame.rows);
detectedRegions.push_back(PlateReg);
}
}
return detectedRegions;
}