【SeetaFace】人脸识别

void TEST(FaceRecognizerTest, CropFace) {
	FaceIdentification face_recognizer(".\\model\\seeta_fr_v1.0.bin");
	/* data initialize */
	std::ifstream ifs;
	std::string img_name;
	FacialLandmark pt5[5];
	ifs.open(".\\data\\test_file_list.txt", std::ifstream::in);
	clock_t start, count = 0;
	int img_num = 0;

	for (int i = 1; i <= 50; i++){
		char ptr[100];
		sprintf_s(ptr, ".\\data\\images\\crop\\NF_2000%02d.jpg", i);
		cv::Mat src_img = imread(ptr, CV_LOAD_IMAGE_GRAYSCALE);
		cv::imshow("Crop Face src", src_img);
		cv::waitKey(0);
		cv::destroyWindow("Crop Face src");
		
		EXPECT_NE(src_img.data, nullptr) << "Load image error!";

		// ImageData store data of an image without memory alignment.
		ImageData src_img_data(src_img.cols, src_img.rows, src_img.channels());
		src_img_data.data = src_img.data;

		// 5 located landmark points (left eye, right eye, nose, left and right 
		// corner of mouse).
		for (int i = 0; i < 5; ++i) {
			ifs >> pt5[i].x >> pt5[i].y;
		}

		// Create a image to store crop face.
		cv::Mat dst_img(face_recognizer.crop_height(),
			face_recognizer.crop_width(),
			CV_8UC(face_recognizer.crop_channels()));
		ImageData dst_img_data(dst_img.cols, dst_img.rows, dst_img.channels());
		dst_img_data.data = dst_img.data;
		/* Crop Face */
		start = clock();
		face_recognizer.CropFace(src_img_data, pt5, dst_img_data);
		count += clock() - start;
		cv::imshow("Crop Face dst", dst_img);
		cv::waitKey(0);
		cv::destroyWindow("Crop Face dst");
		
	}

	std::cout << "Test successful! \nAverage crop face time: "
  		<< 1000.0 * count / CLOCKS_PER_SEC / img_num << "ms" << std::endl;
}

// SeetaFacesTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include <iostream>  
#include <cstdint>
#include <fstream>
#include <string>
#include  <opencv2/opencv.hpp>
#include "face_identification.h"
#include "face_detection.h"

#include <ctime>

//#pragma comment(lib, "SeetaTest.lib")

using namespace cv;
using namespace std;
using namespace seeta;

#define TEST(major, minor) major##_##minor##_Tester()
#define EXPECT_NE(a, b) if ((a) == (b)) std::cout << "ERROR: "
#define EXPECT_EQ(a, b) if ((a) != (b)) std::cout << "ERROR: "


void TEST(FaceRecognizerTest, CropFace) {
	FaceIdentification face_recognizer(".\\model\\seeta_fr_v1.0.bin");
	std::string test_dir = ".\\data\\";
	/* data initialize */
	std::ifstream ifs;
	std::string img_name;
	FacialLandmark pt5[5];
	ifs.open(".\\data\\test_file_list.txt", std::ifstream::in);
	clock_t start, count = 0;
	int img_num = 0;
	while (ifs >> img_name) {
		img_num++;
		// read image
		std::string imgpath = test_dir + img_name;
		cv::Mat src_img = cv::imread(imgpath, 1);
		EXPECT_NE(src_img.data, nullptr) << "Load image error!";

		// ImageData store data of an image without memory alignment.
		ImageData src_img_data(src_img.cols, src_img.rows, src_img.channels());
		src_img_data.data = src_img.data;

		// 5 located landmark points (left eye, right eye, nose, left and right 
		// corner of mouse).
		for (int i = 0; i < 5; ++i) {
			ifs >> pt5[i].x >> pt5[i].y;
		}

		// Create a image to store crop face.
		cv::Mat dst_img(face_recognizer.crop_height(), face_recognizer.crop_width(), CV_8UC(face_recognizer.crop_channels()));
		ImageData dst_img_data(dst_img.cols, dst_img.rows, dst_img.channels());
		dst_img_data.data = dst_img.data;
		/* Crop Face */
		start = clock();
	
		uint8_t rst_cropface = face_recognizer.CropFace(src_img_data, pt5, dst_img_data);
		cout << "CropFace : " << rst_cropface << endl;
		count += clock() - start;
		// Show crop face
		/*cv::imshow("Crop Face", dst_img);
		cv::waitKey(0);
		cv::destroyWindow("Crop Face");*/
	}
	ifs.close();
	std::cout << "Test successful! \nAverage crop face time: "
  		<< 1000.0 * count / CLOCKS_PER_SEC / img_num << "ms" << std::endl;
}

void TEST(FaceRecognizerTest, ExtractFeature) {
	FaceIdentification face_recognizer(".\\model\\seeta_fr_v1.0.bin");
	std::string test_dir = ".\\data\\";
	int feat_size = face_recognizer.feature_size();
	EXPECT_EQ(feat_size, 2048);

	FILE* feat_file = NULL;

	// Load features extract from caffe
	fopen_s(&feat_file, ".\\data\\feats.dat", "rb");
	int n, c, h, w;
	EXPECT_EQ(fread(&n, sizeof(int), 1, feat_file), (unsigned int)1);
	EXPECT_EQ(fread(&c, sizeof(int), 1, feat_file), (unsigned int)1);
	EXPECT_EQ(fread(&h, sizeof(int), 1, feat_file), (unsigned int)1);
	EXPECT_EQ(fread(&w, sizeof(int), 1, feat_file), (unsigned int)1);
	float* feat_caffe = new float[n * c * h * w];
	float* feat_sdk = new float[n * c * h * w];
	EXPECT_EQ(fread(feat_caffe, sizeof(float), n * c * h * w, feat_file), n * c * h * w);
	EXPECT_EQ(feat_size, c * h * w);

	int cnt = 0;

	/* Data initialize */
	std::ifstream ifs(".\\data\\crop_file_list.txt");
	std::string img_name;

	clock_t start, count = 0;
	int img_num = 0, lb;
	double average_sim = 0.0;

	while (ifs >> img_name >> lb) {
		// read image
		std::string imgpath = test_dir + img_name;
		cv::Mat src_img = cv::imread(imgpath, 1);
		
		EXPECT_NE(src_img.data, nullptr) << "Load image error!";
		
		cv::resize(src_img, src_img, cv::Size(face_recognizer.crop_height(), face_recognizer.crop_width()));
		
		// ImageData store data of an image without memory alignment.
		ImageData src_img_data(src_img.cols, src_img.rows, src_img.channels());
		src_img_data.data = src_img.data;

		/* Extract feature */
		start = clock();
		face_recognizer.ExtractFeature(src_img_data, feat_sdk + img_num * feat_size);
		count += clock() - start;

		/* Caculate similarity*/
		float* feat1 = feat_caffe + img_num * feat_size;
		float* feat2 = feat_sdk + img_num * feat_size;
		float sim = face_recognizer.CalcSimilarity(feat1, feat2);
		std::cout << "CalcSimilarity : " << sim << endl;
		average_sim += sim;
		img_num++;
	}

	ifs.close();
	average_sim /= img_num;
	if (1.0 - average_sim >  0.01) {
		std::cout << "average similarity: " << average_sim << std::endl;
	}
	else {
		std::cout << "Test successful!\nAverage extract feature time: "
			<< 1000.0 * count / CLOCKS_PER_SEC / img_num << "ms" << std::endl;
	}
	delete[]feat_caffe;
	delete[]feat_sdk;
}

void TEST(FaceRecognizerTest, ExtractFeatureWithCrop) {
	FaceIdentification face_recognizer(".\\Model\\seeta_fr_v1.0.bin");
	std::string test_dir = ".\\data\\";
	int feat_size = face_recognizer.feature_size();
	EXPECT_EQ(feat_size, 2048);

	FILE* feat_file = NULL;

	// Load features extract from caffe
	fopen_s(&feat_file, ".\\data\\feats.dat", "rb");
	int n, c, h, w;
	EXPECT_EQ(fread(&n, sizeof(int), 1, feat_file), (unsigned int)1);
	EXPECT_EQ(fread(&c, sizeof(int), 1, feat_file), (unsigned int)1);
	EXPECT_EQ(fread(&h, sizeof(int), 1, feat_file), (unsigned int)1);
	EXPECT_EQ(fread(&w, sizeof(int), 1, feat_file), (unsigned int)1);
	float* feat_caffe = new float[n * c * h * w];
	float* feat_sdk = new float[n * c * h * w];
	EXPECT_EQ(fread(feat_caffe, sizeof(float), n * c * h * w, feat_file),
		n * c * h * w);
	EXPECT_EQ(feat_size, c * h * w);

	int cnt = 0;

	/* Data initialize */
	std::ifstream ifs(".\\data\\test_file_list.txt");
	std::string img_name;
	FacialLandmark pt5[5];

	clock_t start, count = 0;
	int img_num = 0;
	double average_sim = 0.0;
	while (ifs >> img_name) {
		// read image
		std::string imgpath = test_dir + img_name;
		cv::Mat src_img = cv::imread(imgpath, 1);
		EXPECT_NE(src_img.data, nullptr) << "Load image error!";

		// ImageData store data of an image without memory alignment.
		ImageData src_img_data(src_img.cols, src_img.rows, src_img.channels());
		src_img_data.data = src_img.data;

		// 5 located landmark points (left eye, right eye, nose, left and right 
		// corner of mouse).
		for (int i = 0; i < 5; ++i) {
			ifs >> pt5[i].x >> pt5[i].y;
		}

		/* Extract feature: ExtractFeatureWithCrop */
		start = clock();
		face_recognizer.ExtractFeatureWithCrop(src_img_data, pt5,
			feat_sdk + img_num * feat_size);
		count += clock() - start;

		/* Caculate similarity*/
		float* feat1 = feat_caffe + img_num * feat_size;
		float* feat2 = feat_sdk + img_num * feat_size;
		float sim = face_recognizer.CalcSimilarity(feat1, feat2);
		average_sim += sim;
		std::cout << "CalcSimilarity : " << sim << std::endl;
		img_num++;
	}
	ifs.close();
	average_sim /= img_num;
	if (1.0 - average_sim >  0.02) {
		std::cout << "average similarity: " << average_sim << std::endl;
	}
	else {
		std::cout << "Test successful!\nAverage extract feature time: "
			<< 1000.0 * count / CLOCKS_PER_SEC / img_num << "ms" << std::endl;
	}
	delete[]feat_caffe;
	delete[]feat_sdk;
}


int main()
{
	//TEST(FaceRecognizerTest, CropFace);
	//TEST(FaceRecognizerTest, ExtractFeature);
	//TEST(FaceRecognizerTest, ExtractFeatureWithCrop);

	/*
	const char* img_path = "12.jpg";
	//seeta::FaceDetection detector(".\\Model\\seeta_fd_frontal_v1.0.bin");
	seeta::FaceDetection detector(".\\Model\\seeta_fd_frontal_v1.0.bin");

	detector.SetMinFaceSize(100);
	detector.SetScoreThresh(2.f);
	detector.SetImagePyramidScaleFactor(1.0f);
	detector.SetWindowStep(4, 4);

	cv::Mat img = cv::imread(img_path, cv::IMREAD_UNCHANGED);
	cv::Mat img_gray;

	if (img.channels() != 1)
		cv::cvtColor(img, img_gray, cv::COLOR_BGR2GRAY);
	else
		img_gray = img;

	seeta::ImageData img_data;
	img_data.data = img_gray.data;
	img_data.width = img_gray.cols;
	img_data.height = img_gray.rows;
	img_data.num_channels = 1;

	long t0 = cv::getTickCount();
	std::vector<seeta::FaceInfo> faces = detector.Detect(img_data);
	long t1 = cv::getTickCount();
	double secs = (t1 - t0) / cv::getTickFrequency();


	cv::Rect face_rect;
	int32_t num_face = static_cast<int32_t>(faces.size());

	for (int32_t i = 0; i < num_face; i++) {
		face_rect.x = faces[i].bbox.x;
		face_rect.y = faces[i].bbox.y;
		face_rect.width = faces[i].bbox.width;
		face_rect.height = faces[i].bbox.height;

		cv::rectangle(img, face_rect, CV_RGB(0, 0, 255), 10, 8, 0);
	}
	cout << "renlian number:" << num_face << endl;

	Size size(img_data.width/5 , img_data.height/5 );
	Mat dst;
    cv:resize(img, dst, size);
	cv::namedWindow("Test", cv::WINDOW_AUTOSIZE);
	cv::imshow("Test", dst);
	cv::waitKey(0);
	cv::destroyAllWindows();*/
	return 0;
}