Распознавание лиц

/home/mihail/diploma/aberdeen_shortened/3/alister3.jpg

48.490402

2

3

/home/mihail/diploma/aberdeen_shortened/2/alison1.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister1.jpg

48.67815

1

3

/home/mihail/diploma/aberdeen_shortened/1/adrian4.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister3.jpg

49.0149

2

3

/home/mihail/diploma/aberdeen_shortened/2/alison4.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister3.jpg

50.16235

2

3

/home/mihail/diploma/aberdeen_shortened/2/alison2.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister1.jpg

51.45775

1

3

/home/mihail/diploma/aberdeen_shortened/1/adrian4.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister1.jpg

51.60845

2

3

/home/mihail/diploma/aberdeen_shortened/2/alison2.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister4.jpg

51.834396

2

3

/home/mihail/diploma/aberdeen_shortened/2/alison4.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister1.jpg

55.97485

2

3

/home/mihail/diploma/aberdeen_shortened/2/alison3.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister1.jpg

56.7955

2

3

/home/mihail/diploma/aberdeen_shortened/2/alison4.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister2.jpg

61.69295

2

3

/home/mihail/diploma/aberdeen_shortened/2/alison1.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister2.jpg

63.181152

2

3

/home/mihail/diploma/aberdeen_shortened/2/alison2.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister2.jpg

70.920105

2

3

/home/mihail/diploma/aberdeen_shortened/2/alison3.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister2.jpg

73.107

1

3

/home/mihail/diploma/aberdeen_shortened/1/adrian4.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister2.jpg

75.7419

1

3

/home/mihail/diploma/aberdeen_shortened/1/adrian1.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister2.jpg

90.403595

1

3

/home/mihail/diploma/aberdeen_shortened/1/adrian2.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister2.jpg

93.04085

1

3

/home/mihail/diploma/aberdeen_shortened/1/adrian3.jpg

/home/mihail/diploma/aberdeen_shortened/3/alister2.jpg

102.02286

Приложение В

Листинг

face_recognizer.cpp

#include "opencv2/core/core.hpp"

#include "opencv2/contrib/contrib.hpp"

#include "opencv2/opencv.hpp"

#include <cctype>

#include <iostream>

#include <iterator>

#include <stdio.h>

#include <dirent.h>

#include <unistd.h>

#include <fstream>

#include <cerrno>

#include <sstream>

#include <math.h>

#include <algorithm> // std::sort

using namespace cv;

using namespace std;

string cascadeName = "/usr/share/opencv/haarcascades/haarcascade_frontalface_alt.xml";

Rect detectAndCut(Mat &img, CascadeClassifier& cascade, bool normalize = true)

{

vector<Rect> faces;

if (normalize) {

cvtColor(img, img, COLOR_BGR2GRAY);

resize(img, img, img.size(), 0, 0, INTER_LINEAR);

equalizeHist(img, img);

}

cascade.detectMultiScale(img, faces,

1.1, 2, 0

|CASCADE_FIND_BIGGEST_OBJECT

//|CASCADE_DO_ROUGH_SEARCH

|CASCADE_SCALE_IMAGE

,

Size(30, 30));

for(vector<Rect>::const_iterator r = faces.begin(); r != faces.end(); r++)

{

return *r;

}

throw "No faces were found";

}

static void fill_vectors(Mat& etalon_image, Mat& candidate_image, vector<Mat>& images, vector<int>& labels) {

images.push_back(etalon_image);

labels.push_back(0);

images.push_back(candidate_image);

labels.push_back(0);

}

struct Sort {

bool operator() (Rect i, Rect j) {

return (i.height > j.height);

}

} mySort;

vector<Rect> getTheBiggestEyes(vector<Rect> eyes) {

if (eyes.size() <= 2) {

return eyes;

}

vector<Rect> realEyes;

sort(eyes.begin(), eyes.end(), mySort);

for (int i = 0; i < 2; i++) {

realEyes.push_back(eyes.at(i));

}

return realEyes;

}

Mat alignByEyes(Mat image, Rect face) {

// preparation

Mat smallImgROI = image(face);

const char *cascade_eye = "/usr/share/opencv/haarcascades/haarcascade_eye.xml";

CascadeClassifier eyesClassifier;

vector<Rect> eyes;

if(!eyesClassifier.load(cascade_eye))

{

cerr << "ERROR: Could not load classifier cascade" << endl;

exit(-1);

}

eyesClassifier.detectMultiScale(smallImgROI, eyes,

1.2, 3, 0

//|CASCADE_FIND_BIGGEST_OBJECT

//|CASCADE_DO_ROUGH_SEARCH

//|CASCADE_SCALE_IMAGE,

Size(15, 15));

eyes = getTheBiggestEyes(eyes);

// for(vector<Rect>::const_iterator r = eyes.begin(); r != eyes.end(); r++) {

// CvPoint p1 = { face.x + r->x, face.y + r->y };

// CvPoint p2 = { face.x + r->x + r->width, face.y + r->y + r->height };

// rectangle(image, p1, p2, CV_RGB(0, 255, 0), 1, 4, 0);

// printf(" %d %d %d %d\n", face.x + r->x, face.y + r->y, r->width, r->height);

// }

if (eyes.size() == 2) {

int xHalfEye[2], yHalfEye[2];

int i = 0;

for(vector<Rect>::const_iterator r = eyes.begin(); r != eyes.end(); r++, i++) {

xHalfEye[i] = face.x + r->x + r->width / 2;

yHalfEye[i] = face.y + r->y + r->height / 2;

}

// rotation

double rotateAngle = atan((double)(yHalfEye[0] - yHalfEye[1]) / (double)(xHalfEye[0] - xHalfEye[1]))

* 180 / M_PI;

Point2f pc(image.cols/2., image.rows/2.);

Mat r = getRotationMatrix2D(pc, rotateAngle, 1.0);

warpAffine(image, image, r, image.size());

CascadeClassifier cascade;

if(!cascade.load(cascadeName)) {

cerr << "ERROR: Could not load classifier cascade" << endl;

exit(-1);

}

try {

face = detectAndCut(image, cascade, false);

} catch (char const* msg) {

cout << msg << endl;

exit(-1);

}

smallImgROI = image(face);

eyesClassifier.detectMultiScale(smallImgROI, eyes,

1.2, 3, 0

//|CASCADE_FIND_BIGGEST_OBJECT

//|CASCADE_DO_ROUGH_SEARCH

//|CASCADE_SCALE_IMAGE,

Size(15, 15));

eyes = getTheBiggestEyes(eyes);

// for(vector<Rect>::const_iterator r = eyes.begin(); r != eyes.end(); r++) {

// CvPoint p1 = { face.x + r->x, face.y + r->y };

// CvPoint p2 = { face.x + r->x + r->width, face.y + r->y + r->height };

// rectangle(image, p1, p2, CV_RGB(0, 255, 0), 1, 4, 0);

// printf(" %d %d %d %d\n", r->x, r->y, r->width, r->height);

// }

if (eyes.size() == 2) {

int xHalfEye[2], yHalfEye[2];

int i = 0;

for(vector<Rect>::const_iterator r = eyes.begin(); r != eyes.end(); r++, i++) {

xHalfEye[i] = face.x + r->x + r->width / 2;

yHalfEye[i] = face.y + r->y + r->height / 2;

}

// cropping

int currentBetweenPupilsDistance = abs(xHalfEye[0] - xHalfEye[1]);

int currentLeftEyeX = xHalfEye[0] < xHalfEye[1] ? xHalfEye[0] : xHalfEye[1];

Rect myROI;

myROI.x = currentLeftEyeX - 0.89 * currentBetweenPupilsDistance;

myROI.width = 2.78 * currentBetweenPupilsDistance;

myROI.y = yHalfEye[0] - 0.39 * myROI.width;

myROI.height = myROI.width;

image = image(myROI);

//resize(image, image, Size(200, 200));

}

}

return image;

}

int main(int argc, const char *argv[]) {

if (argc != 3) {

cout << "usage: " << argv[0] << " <etalon_path> <candidate_path>" << endl;

exit(1);

}

string etalon = string(argv[1]);

string candidate = string(argv[2]);

CascadeClassifier cascade;

if(!cascade.load(cascadeName))

{

cerr << "ERROR: Could not load classifier cascade" << endl;

return -1;

}

Mat etalon_image, candidate_image;

Rect etalonFace, candidateFace;

etalon_image = imread(etalon, 1);

try {

etalonFace = detectAndCut(etalon_image, cascade);

} catch (char const* msg) {

cout << msg << endl;

return -1;

}

etalon_image = alignByEyes(etalon_image, etalonFace);

candidate_image = imread(candidate, 1);

try {

candidateFace = detectAndCut(candidate_image, cascade);

} catch (char const* msg) {

cout << msg << endl;

return -1;

}

candidate_image = alignByEyes(candidate_image, candidateFace);

int medianBlurFilterIntensity = 3;

int gaussianBlurFilterIntensity = medianBlurFilterIntensity;

medianBlur(etalon_image, etalon_image, medianBlurFilterIntensity);

medianBlur(candidate_image, candidate_image, medianBlurFilterIntensity);

GaussianBlur(etalon_image, etalon_image, Size(gaussianBlurFilterIntensity, gaussianBlurFilterIntensity), 0);

GaussianBlur(candidate_image, candidate_image, Size(gaussianBlurFilterIntensity, gaussianBlurFilterIntensity), 0);

// namedWindow("named_window");

// imshow("named_window", etalon_image);

// waitKey();

// imshow("named_window", candidate_image);

// waitKey();

vector<Mat> images;

vector<int> labels;

fill_vectors(etalon_image, candidate_image, images, labels);

if(images.size() <= 1) {

string error_message = "This demo needs at least 2 images to work. Please add more images to your data set!";

CV_Error(CV_StsError, error_message);

}

Mat testSample = images[images.size() - 1];

images.pop_back();

labels.pop_back();

Ptr<FaceRecognizer> model = createLBPHFaceRecognizer(2, 8, 6, 6); // try call with params: 2, 8, 6, 6

model->train(images, labels);

int predictedLabel = model->predict(testSample);

double confidence = 0.0;

model->predict(testSample, predictedLabel, confidence);

cout << confidence << endl;

return 0;

}

Calculator.java

import java.util.ArrayList;

public class Calculator {

private float xAverageTheirs, standardDeviationTheirs, xAverageStrangers, standardDeviationStrangers;

private ArrayList<ArrayList<String>> source;

public Calculator(ArrayList<ArrayList<String>> source) {

this.source = source;

}

public void calculate(int group) {

float sumTheirs = 0, sumStrangers = 0;

int quantityTheirs = 0, quantityStrangers = 0;

for (ArrayList<String> row : source) {

if (row.get(0).equals(row.get(1))) {

sumTheirs += Float.parseFloat(row.get(group));

quantityTheirs++;

} else {

sumStrangers += Float.parseFloat(row.get(group));

quantityStrangers++;

}

}

xAverageTheirs = sumTheirs / quantityTheirs;

xAverageStrangers = sumStrangers / quantityStrangers;

float numeratorTheirs = 0, numeratorStrangers = 0;

for (ArrayList<String> row : source) {

if (row.get(0).equals(row.get(1))) {

float xMinusXAvg = Float.parseFloat(row.get(group)) - xAverageTheirs;

numeratorTheirs += xMinusXAvg * xMinusXAvg;

} else {

float xMinusXAvg = Float.parseFloat(row.get(group)) - xAverageStrangers;

numeratorStrangers += xMinusXAvg * xMinusXAvg;

}

}

standardDeviationTheirs = (float)Math.sqrt(numeratorTheirs / quantityTheirs);

standardDeviationStrangers = (float)Math.sqrt(numeratorStrangers / quantityStrangers);

}

public float getXAverageTheirs() {

return xAverageTheirs;

}

public float getStandardDeviationTheirs() {

return standardDeviationTheirs;

}

public float getXAverageStrangers() {

return xAverageStrangers;

}

public float getStandardDeviationStrangers() {

return standardDeviationStrangers;

}

}

Client.java

public class Client

{

public static String interimStatisticsFilePath = null;

public static String folderWithPhotos = null;

public static String executableFilename = null;

public static void main (String args[])

{

interimStatisticsFilePath = args[0];

folderWithPhotos = args[1];

executableFilename = args[2];

Recognizer r = new Recognizer();

r.recognize();

// r.recognizeShuffle();

Statistics s = new Statistics();

s.gather();

}

}

IMatcher.java

public interface IMatcher

{

final static float NO_FACE_ETALON = -1;

final static float NO_FACE_CANDIDATE = -2;

final static float INTERNAL_ERROR = -3;

final static float NO_SUCH_FILE = -4;

public float compare(String etalon, String candidate) throws Exception;

}

OpenCVMatcher.java

import java.io.BufferedReader;

import java.io.InputStreamReader;

public class OpenCVMatcher implements IMatcher

{

private String etalon, candidate;

private float extractAndMatch() throws Exception {

Process p;

String command = null;

String result = null;

try {

command = Client.executableFilename + " " + etalon + " " + candidate;

p = Runtime.getRuntime().exec(command);

String line = "";

BufferedReader errors = new BufferedReader(new InputStreamReader(p.getErrorStream()));

BufferedReader output = new BufferedReader(new InputStreamReader(p.getInputStream()));

while ((line = output.readLine()) != null) {

result = line;

}

while ((errors.readLine()) != null) {}

p.waitFor();

} catch (Exception e) {

throw e;

}

try {

return Float.parseFloat(result);

} catch (NumberFormatException e) {

return -1;

}

}

public float compare(String etalon, String candidate) throws Exception

{

this.etalon = etalon;

this.candidate = candidate;

return extractAndMatch();

}

}

Parser.java

import java.io.BufferedReader;

import java.io.FileInputStream;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.nio.charset.Charset;

import java.util.ArrayList;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class Parser {

public static ArrayList<ArrayList<String>> parse(String filepath, int[] groups) throws Exception {

String line;

try (

InputStream fis = new FileInputStream(filepath);

InputStreamReader isr = new InputStreamReader(fis, Charset.forName("UTF-8"));

BufferedReader br = new BufferedReader(isr);

) {

ArrayList<ArrayList<String>> results = new ArrayList<ArrayList<String>>();

Pattern pattern = Pattern.compile("^(.+);(.+);(.+);(.+);(.+)$", Pattern.MULTILINE);

while ((line = br.readLine()) != null) {

Matcher m = null;

m = pattern.matcher(line);

m.find();

ArrayList<String> temp = new ArrayList<String>();

for(int group : groups) {

temp.add(m.group(group));

}

results.add(temp);

}

return results;

}

}

}

Percentager.java

public class Percentager

{

public static void main (String args[])

{

String etalonFilename = "/home/mihail/diploma/aberdeen_face_database/amellanby15.jpg";

String candidateFilename = "/home/mihail/diploma/aberdeen_face_database/andrew7.jpg";

Client.executableFilename = "/home/mihail/workspace/binary/face_recognizer";

IMatcher opencvMatcher = new OpenCVMatcher();

float resultOpenCV = 0, resultOpenCV1 = 0, resultOpenCV2 = 0;

try {

resultOpenCV1 = opencvMatcher.compare(etalonFilename, candidateFilename);

resultOpenCV2 = opencvMatcher.compare(candidateFilename, etalonFilename);

resultOpenCV = (resultOpenCV1 + resultOpenCV2) / 2;

} catch (Exception e) {

// TODO Auto-generated catch block

System.out.println(e.getMessage());

}

//System.out.println("Confidence: " + getPercentFromDistance(resultOpenCV) + "%");

System.out.println("These people are identical: " + getAnswerFromDistance(resultOpenCV));

}

private static String getAnswerFromDistance(float resultOpenCV) {

if (resultOpenCV < 20)

return "true";

else if (resultOpenCV >= 26)

return "false";

else

return "not sure";

}

private static int getPercentFromDistance(float resultOpenCV) {

//distance thresholds

int absolutelyTrueThreshold = 13;

int trueThreshold = 46;

int notSureThreshold = 177;

int falseThreshold = 501;

//percent thresholds

int absolutelyTruePercent = 99;

int truePercent = 70;

int notSurePercent = 30;

int falsePercent = 0;

//steps

double absolutelyTrueStep = 1d / absolutelyTrueThreshold;

double trueStep = 29d / (trueThreshold - absolutelyTrueThreshold);

double notSureStep = 40d / (notSureThreshold - trueThreshold);

double falseStep = 30d / (falseThreshold - notSureThreshold);

//logic

double confidencePercent = 0;

if (resultOpenCV > notSureThreshold) {

confidencePercent = falsePercent + ((falseThreshold - resultOpenCV) * falseStep);

} else if (resultOpenCV > trueThreshold) {

confidencePercent = notSurePercent + ((notSureThreshold - resultOpenCV) * notSureStep);

} else if (resultOpenCV > absolutelyTrueThreshold) {

confidencePercent = truePercent + ((trueThreshold - resultOpenCV) * trueStep);

} else {

confidencePercent = absolutelyTruePercent + ((absolutelyTrueThreshold - resultOpenCV) * absolutelyTrueStep);

}

return (int)confidencePercent;

}

}

PhotosContainer.java

public class PhotosContainer

{

private int label;

private String filename;

public PhotosContainer(int label, String filename)

{

this.label = label;

this.filename = filename;

}

public int getLabel()

{

return label;

}

public String getFilename()

{

return filename;

}

}

Recognizer.java

import java.io.File;

import java.io.PrintWriter;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Random;

public class Recognizer {

List<PhotosContainer> photoNames = new ArrayList<PhotosContainer>();

public void listFilesForFolder(final File folder) {

for (final File fileEntry : folder.listFiles()) {

if (fileEntry.isDirectory()) {

listFilesForFolder(fileEntry);

} else {

photoNames.add(new PhotosContainer(Integer.parseInt(folder.getName()),

Client.folderWithPhotos + '/' + folder.getName() + '/' + fileEntry.getName()));

}

}

}

public void recognizeShuffle() {

final File folder = new File(Client.folderWithPhotos);

try {

compare(folder);

} catch (Exception e) {

e.getMessage();

}

}

private void compare(File folder) throws Exception {

File[] pathsList = folder.listFiles();

Random rand = new Random();

for (int i = 0; i < 5; i++) {

File randFolder = pathsList[rand.nextInt(pathsList.length)];

File[] fileList = randFolder.listFiles();

File randEtalonFile = fileList[rand.nextInt(fileList.length)];

File randCandidateFile = fileList[rand.nextInt(fileList.length)];

while (randEtalonFile.getName().equals(randCandidateFile.getName())) {

randCandidateFile = fileList[rand.nextInt(fileList.length)];

}

IMatcher opencvMatcher = new OpenCVMatcher();

float resultOpenCV1 = opencvMatcher.compare(randEtalonFile.getAbsolutePath(), randCandidateFile.getAbsolutePath());

float resultOpenCV2 = opencvMatcher.compare(randCandidateFile.getAbsolutePath(), randEtalonFile.getAbsolutePath());

float resultOpenCV = (resultOpenCV1 + resultOpenCV2) / 2;

System.out.println(randEtalonFile.getAbsolutePath() + " and " + randCandidateFile.getAbsolutePath()

+ " are identical: " + getAnswerFromDistance(resultOpenCV) + " (distance = " + resultOpenCV + ")");

}

for (int i = 0; i < 5; i++) {

File randEtalonFolder = pathsList[rand.nextInt(pathsList.length)];

File[] fileList = randEtalonFolder.listFiles();

File randEtalonFile = fileList[rand.nextInt(fileList.length)];

File randCandidateFolder = pathsList[rand.nextInt(pathsList.length)];

fileList = randCandidateFolder.listFiles();

File randCandidateFile = fileList[rand.nextInt(fileList.length)];

while (randEtalonFile.getName().equals(randCandidateFile.getName())) {

randCandidateFile = fileList[rand.nextInt(fileList.length)];

}

IMatcher opencvMatcher = new OpenCVMatcher();

float resultOpenCV1 = opencvMatcher.compare(randEtalonFile.getAbsolutePath(), randCandidateFile.getAbsolutePath());

float resultOpenCV2 = opencvMatcher.compare(randCandidateFile.getAbsolutePath(), randEtalonFile.getAbsolutePath());

float resultOpenCV = (resultOpenCV1 + resultOpenCV2) / 2;

System.out.println(randEtalonFile.getAbsolutePath() + " and " + randCandidateFile.getAbsolutePath()

+ " are identical: " + getAnswerFromDistance(resultOpenCV) + " (distance = " + resultOpenCV + ")");

}

}

private static String getAnswerFromDistance(float resultOpenCV) {

if (resultOpenCV == -1) {

return "no faces were found";

} else if (resultOpenCV < 28)

return "true";

else if (resultOpenCV >= 28)

return "false";

else

return "not sure";

}

public void recognize() {

try (PrintWriter writer = new PrintWriter(Client.interimStatisticsFilePath, "UTF-8")) {

final File folder = new File(Client.folderWithPhotos);

listFilesForFolder(folder);

int count = (photoNames.size() * photoNames.size() - photoNames.size()) / 2;

int i = 0;

for (Iterator<PhotosContainer> iterator = photoNames.iterator(); iterator.hasNext();) {

PhotosContainer etalon = iterator.next();

for (PhotosContainer candidate : photoNames) {

if (!etalon.getFilename().equals(candidate.getFilename())) {

// System.out.println(etalon.getLabel() + ";" + candidate.getLabel() + ";" + etalon.getFilename() +

// ";" + candidate.getFilename());

IMatcher opencvMatcher = new OpenCVMatcher();

float resultOpenCV1 = opencvMatcher.compare(etalon.getFilename(), candidate.getFilename());

float resultOpenCV2 = opencvMatcher.compare(candidate.getFilename(), etalon.getFilename());

float resultOpenCV = (resultOpenCV1 + resultOpenCV2) / 2;

// IMatcher openbrMatcher = new OpenBRMatcher();

// float resultOpenBR = openbrMatcher.compare(etalon.getFilename(), candidate.getFilename());

// System.out.println(etalon.getLabel() + ";" + candidate.getLabel() + ";" + etalon.getFilename() +

// ";" + candidate.getFilename() + ";" + resultOpenCV);

writer.println(etalon.getLabel() + ";" + candidate.getLabel() + ";" + etalon.getFilename() +

";" + candidate.getFilename() + ";" + resultOpenCV);

i++; System.out.println(((float)i/count*100) + "%");

}

}

iterator.remove();

}

/* Exceptions processing */

} catch (Exception e) {

//some exception message

e.printStackTrace();

}

}

}

Statistics.java

import java.util.ArrayList;

public class Statistics {

public void gather() {

int []groupsToResult = {1, 2, 5};

ArrayList<ArrayList<String>> results = null;

try {

results = Parser.parse(Client.interimStatisticsFilePath, groupsToResult);

} catch (Exception e) {

System.out.println("Parser fucked up");

}

Calculator calculator = new Calculator(results);

calculator.calculate(2);

System.out.println(calculator.getXAverageTheirs() + " - " + calculator.getXAverageStrangers() + "; "

+ calculator.getStandardDeviationTheirs() + " - " + calculator.getStandardDeviationStrangers());

// calculator.calculate(3);

// System.out.println(calculator.getXAverageTheirs() + " - " + calculator.getXAverageStrangers() + "; "

// + calculator.getStandardDeviationTheirs() + " - " + calculator.getStandardDeviationStrangers());

// calculator.calculate(4);

// System.out.println(calculator.getXAverageTheirs() + " - " + calculator.getXAverageStrangers() + "; "

// + calculator.getStandardDeviationTheirs() + " - " + calculator.getStandardDeviationStrangers());

}

}

Time.java

public class Time {

final static long SECOND = 1000;

final static long MINUTE = 60 * Time.SECOND;

final static long HOUR = 60 * Time.MINUTE;

}

VisionLabsMatcher.java

import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class VisionLabsMatcher implements IMatcher

{

private final String pathToEtalonTemp = "C:/temp/etalon_temp";

private final String pathToCandidateTemp = "C:/temp/candidate_temp";

private final String pathToEtalonKeys = "C:/temp/etalon_keys";

private final String pathToCandidateKeys = "C:/temp/candidate_keys";

private final String pathToReport = "C:/temp/report.csv";

private final static String HASP_FEATURE_EXPIRED = "HASP_FEATURE_EXPIRED";

private final static String NO_FACES_FOUND = "NoFacesFound";

private float extractAndMatch() throws Exception {

Process p;

String command = null;

try {

command = VisionLabsMatcher.class.getProtectionDomain().getCodeSource().getLocation().getPath()

+ "/../Extractor -S " + pathToEtalonTemp + " -D " + pathToEtalonKeys + " -Dt DPM -St CNN -Ft VGG";

p = Runtime.getRuntime().exec(command);

String line = "";

BufferedReader errors = new BufferedReader(new InputStreamReader(p.getErrorStream()));

BufferedReader output = new BufferedReader(new InputStreamReader(p.getInputStream()));

while ((output.readLine()) != null) {}

while ((line = errors.readLine()) != null) {

if (line.contains(HASP_FEATURE_EXPIRED)) {

throw new Exception(HASP_FEATURE_EXPIRED);

} else if (line.contains(NO_FACES_FOUND)) {

return NO_FACE_ETALON;

} else {

return INTERNAL_ERROR;

}

}

p.waitFor();

command = VisionLabsMatcher.class.getProtectionDomain().getCodeSource().getLocation().getPath()

+ "/../Extractor -S " + pathToCandidateTemp + " -D " + pathToCandidateKeys + " -Dt DPM -St CNN -Ft VGG";

p = Runtime.getRuntime().exec(command);

errors = new BufferedReader(new InputStreamReader(p.getErrorStream()));

output = new BufferedReader(new InputStreamReader(p.getInputStream()));

while ((output.readLine()) != null) {}

while ((line = errors.readLine()) != null) {

return NO_FACE_CANDIDATE;

}

p.waitFor();

command = VisionLabsMatcher.class.getProtectionDomain().getCodeSource().getLocation().getPath()

+ "/../Matcher2 -T " + pathToEtalonKeys + " -C " + pathToCandidateKeys + " -D " + pathToReport + " -M 1 -St CNN";

p = Runtime.getRuntime().exec(command);

errors = new BufferedReader(new InputStreamReader(p.getErrorStream()));

output = new BufferedReader(new InputStreamReader(p.getInputStream()));

while ((output.readLine()) != null) {}

while ((line = errors.readLine()) != null) {

return INTERNAL_ERROR;

}

p.waitFor();

} catch (Exception e) {

throw e;

}

return parseResult();

}

private float parseResult() {

Pattern pattern = Pattern.compile("^(.+); (.+); (.+); (.+)$",

Pattern.MULTILINE);

BufferedReader reader = null;

try {

reader = new BufferedReader(new FileReader(pathToReport));

String line = null;

Matcher m = null;

while ((line = reader.readLine()) != null) {

try {

m = pattern.matcher(line);

m.find();

} catch (Exception e) {

return INTERNAL_ERROR;

}

return Float.parseFloat(m.group(4));

}

} catch (Exception e) {

return INTERNAL_ERROR;

} finally {

try {

reader.close();

} catch (IOException e) {

}

}

return (float) -1;

}

public float compare (String etalon, String candidate) throws Exception

{

float result = NO_SUCH_FILE;

if(prepare(etalon, candidate)) {

result = extractAndMatch();

};

return result;

}

private boolean prepare(String etalon, String candidate) {

File etalonTemp = new File(pathToEtalonTemp);

etalonTemp.mkdir();

File candidateTemp = new File(pathToCandidateTemp);

candidateTemp.mkdir();

File etalonKeys = new File(pathToEtalonKeys);

etalonKeys.mkdir();

File candidateKeys = new File(pathToCandidateKeys);

candidateKeys.mkdir();

File sourceEtalon = new File(etalon);

File sourceCandidate = new File(candidate);

Path etalonTempPath = Paths.get(pathToEtalonTemp + "/etalon.jpg");

Path candidateTempPath = Paths.get(pathToCandidateTemp + "/candidate.jpg");

try {

Files.copy(sourceEtalon.toPath(), etalonTempPath, REPLACE_EXISTING);

Files.copy(sourceCandidate.toPath(), candidateTempPath, REPLACE_EXISTING);

} catch (IOException e) {

return false;

}

return true;

}

Размещено на Allbest.ru

...