int loadParameters(cv::String filepath) override
{
cv::FileStorage fs;
//if user specified a pathfile, try to use it.
if (!filepath.empty())
{
fs.open(filepath, cv::FileStorage::READ);
}
// If the file opened, read the parameters.
if (fs.isOpened())
{
fs["borderX"] >> Param.borderX;
fs["borderY"] >> Param.borderY;
fs["corrWinSizeX"] >> Param.corrWinSizeX;
fs["corrWinSizeY"] >> Param.corrWinSizeY;
fs["correlationThreshold"] >> Param.correlationThreshold;
fs["textrureThreshold"] >> Param.textrureThreshold;
fs["neighborhoodSize"] >> Param.neighborhoodSize;
fs["disparityGradient"] >> Param.disparityGradient;
fs["lkTemplateSize"] >> Param.lkTemplateSize;
fs["lkPyrLvl"] >> Param.lkPyrLvl;
fs["lkTermParam1"] >> Param.lkTermParam1;
fs["lkTermParam2"] >> Param.lkTermParam2;
fs["gftQualityThres"] >> Param.gftQualityThres;
fs["gftMinSeperationDist"] >> Param.gftMinSeperationDist;
fs["gftMaxNumFeatures"] >> Param.gftMaxNumFeatures;
fs.release();
return 1;
}
static void glob_rec(const cv::String& directory, const cv::String& wildchart, std::vector<cv::String>& result, bool recursive)
{
DIR *dir;
struct dirent *ent;
if ((dir = opendir (directory.c_str())) != 0)
{
/* find all the files and directories within directory */
try
{
while ((ent = readdir (dir)) != 0)
{
const char* name = ent->d_name;
if((name[0] == 0) || (name[0] == '.' && name[1] == 0) || (name[0] == '.' && name[1] == '.' && name[2] == 0))
continue;
cv::String path = directory + native_separator + name;
if (isDir(path, dir))
{
if (recursive)
glob_rec(path, wildchart, result, recursive);
}
else
{
if (wildchart.empty() || wildcmp(name, wildchart.c_str()))
result.push_back(path);
}
}
}
catch (...)
{
closedir(dir);
throw;
}
closedir(dir);
}
else CV_Error(CV_StsObjectNotFound, cv::format("could not open directory: %s", directory.c_str()));
}
cv::String CameraWrapperConnector::getPathLibFolder()
{
if (!pathLibFolder.empty())
return pathLibFolder;
Dl_info dl_info;
if(0 != dladdr((void *)nextFrame, &dl_info))
{
LOGD("Library name: %s", dl_info.dli_fname);
LOGD("Library base address: %p", dl_info.dli_fbase);
const char* libName=dl_info.dli_fname;
while( ((*libName)=='/') || ((*libName)=='.') )
libName++;
char lineBuf[2048];
FILE* file = fopen("/proc/self/smaps", "rt");
if(file)
{
while (fgets(lineBuf, sizeof lineBuf, file) != NULL)
{
//verify that line ends with library name
int lineLength = strlen(lineBuf);
int libNameLength = strlen(libName);
//trim end
for(int i = lineLength - 1; i >= 0 && isspace(lineBuf[i]); --i)
{
lineBuf[i] = 0;
--lineLength;
}
if (0 != strncmp(lineBuf + lineLength - libNameLength, libName, libNameLength))
{
//the line does not contain the library name
continue;
}
//extract path from smaps line
char* pathBegin = strchr(lineBuf, '/');
if (0 == pathBegin)
{
LOGE("Strange error: could not find path beginning in lin \"%s\"", lineBuf);
continue;
}
char* pathEnd = strrchr(pathBegin, '/');
pathEnd[1] = 0;
LOGD("Libraries folder found: %s", pathBegin);
fclose(file);
return pathBegin;
}
fclose(file);
LOGE("Could not find library path");
}
else
{
LOGE("Could not read /proc/self/smaps");
}
}
else
{
LOGE("Could not get library name and base address");
}
return cv::String();
}
// Detect faces in a photo
std::vector<FaceRect> detectFaces(cv::String inputName, cv::String cascadeName, double scale, bool infer = false) {
cv::CascadeClassifier cascade;
if (!cascade.load(cascadeName)) {
std::cout << "error;Could not load classifier cascade. Filename: \"" << cascadeName << "\"" << std::endl;
}
if (inputName.empty()) {
std::cout << "error;You must specify the file to process." << std::endl;
}
cv::Mat img = cv::imread(inputName, 1);
if (img.empty()) {
std::cout << "error;Could not load the file to process. Filename: \"" << inputName << "\"" << std::endl;
}
std::vector<cv::Rect> faces;
cv::Size smallImgSize;
static bool disableDnn;
#ifdef HAS_OPENCV_DNN
disableDnn = faceDetectNet.empty();
#else
disableDnn = true;
#endif
if (disableDnn) {
// Classical face detection
cv::Mat gray;
cvtColor(img, gray, CV_BGR2GRAY);
cv::Mat smallImg(cvRound(img.rows / scale), cvRound(img.cols / scale), CV_8UC1);
smallImgSize = smallImg.size();
cv::resize(gray, smallImg, smallImgSize, 0, 0, cv::INTER_LINEAR);
cv::equalizeHist(smallImg, smallImg);
cascade.detectMultiScale(smallImg, faces, 1.1, 2, CV_HAAR_SCALE_IMAGE, cv::Size(30, 30));
} else {
#ifdef HAS_OPENCV_DNN
// DNN based face detection
faces = detectFacesMat(img);
smallImgSize = img.size(); // Not using the small image here
#endif
}
std::vector<FaceRect> scaled;
for (std::vector<cv::Rect>::const_iterator r = faces.begin(); r != faces.end(); r++) {
FaceRect i;
i.x = (float) r->x / smallImgSize.width;
i.y = (float) r->y / smallImgSize.height;
i.width = (float) r->width / smallImgSize.width;
i.height = (float) r->height / smallImgSize.height;
#ifdef HAS_OPENCV_DNN
if (infer && !faceRecogNet.empty()) {
// Get colour image for vector generation
cv::Mat colourImg;
cv::resize(img, colourImg, smallImgSize, 0, 0, cv::INTER_LINEAR);
i.vec = faceToVecMat(colourImg(*r)); // Run vector conversion on the face
} else {
i.vec.assign(128, 0);
}
#else
i.vec.assign(128, 0);
#endif
scaled.push_back(i);
}
return scaled;
}