Merge branch 'develop' of https://github.com/TadasBaltrusaitis/OpenFace into feature/Windows-GUI

# Conflicts:
#	exe/FaceLandmarkImg/FaceLandmarkImg.cpp
#	exe/FeatureExtraction/FeatureExtraction.cpp
#	lib/local/FaceAnalyser/FaceAnalyser.vcxproj
#	lib/local/FaceAnalyser/include/FaceAnalyser.h
#	lib/local/FaceAnalyser/include/Face_utils.h
#	lib/local/FaceAnalyser/include/PAW.h
#	lib/local/FaceAnalyser/include/PDM.h
#	lib/local/FaceAnalyser/src/FaceAnalyser.cpp
#	lib/local/FaceAnalyser/src/FaceAnalyserParameters.cpp
#	lib/local/FaceAnalyser/src/Face_utils.cpp
#	lib/local/FaceAnalyser/src/PAW.cpp
#	lib/local/FaceAnalyser/src/PDM.cpp
#	lib/local/GazeAnalyser/include/GazeEstimation.h
#	lib/local/GazeAnalyser/src/GazeEstimation.cpp
#	lib/local/LandmarkDetector/include/LandmarkDetectorUtils.h
#	lib/local/LandmarkDetector/src/LandmarkDetectorUtils.cpp
#	matlab_runners/Action Unit Experiments/results/BP4D_valid_res_class.txt
#	matlab_runners/Action Unit Experiments/results/BP4D_valid_res_int.txt
#	matlab_runners/Action Unit Experiments/results/Bosphorus_res_class.txt
#	matlab_runners/Action Unit Experiments/results/Bosphorus_res_int.txt
#	matlab_runners/Action Unit Experiments/run_AU_prediction_BP4D.m
#	matlab_runners/Demos/feature_extraction_demo_vid.m
#	matlab_runners/Full_test_suite.m

README.md

@@ -72,7 +72,7 @@ in *Facial Expression Recognition and Analysis Challenge*,
 
 Copyright can be found in the Copyright.txt
 
-You have to respect boost, TBB, dlib, and OpenCV licenses.
+You have to respect boost, TBB, dlib, OpenBLAS, and OpenCV licenses.
 
 # Commercial license
 

exe/FaceLandmarkImg/FaceLandmarkImg.cpp

@@ -160,15 +160,16 @@ void write_out_pose_landmarks(const string& outfeatures, const cv::Mat_<double>&
 		featuresFile << "}" << endl;
 
 		// Do the pose and eye gaze if present as well
-		featuresFile << "gaze: dir_x_1, dir_y_1, dir_z_1, dir_x_2, dir_y_2, dir_z_2: " << endl;
+		featuresFile << "gaze_vec: dir_x_1, dir_y_1, dir_z_1, dir_x_2, dir_y_2, dir_z_2: " << endl;
 		featuresFile << "{" << endl;
 		featuresFile << gaze0.x << " " << gaze0.y << " " << gaze0.z << " " << gaze1.x << " " << gaze1.y << " " << gaze1.z << endl;
 		featuresFile << "}" << endl;
+
 		featuresFile.close();
 	}
 }
 
-void write_out_landmarks(const string& outfeatures, const LandmarkDetector::CLNF& clnf_model, const cv::Vec6d& pose, const cv::Point3f& gaze0, const cv::Point3f& gaze1, std::vector<std::pair<std::string, double>> au_intensities, std::vector<std::pair<std::string, double>> au_occurences)
+void write_out_landmarks(const string& outfeatures, const LandmarkDetector::CLNF& clnf_model, const cv::Vec6d& pose, const cv::Point3f& gaze0, const cv::Point3f& gaze1, const cv::Vec2d gaze_angle, std::vector<std::pair<std::string, double>> au_intensities, std::vector<std::pair<std::string, double>> au_occurences, bool output_gaze)
 {
 	create_directory_from_file(outfeatures);
 	std::ofstream featuresFile;
@@ -177,7 +178,7 @@ void write_out_landmarks(const string& outfeatures, const LandmarkDetector::CLNF
 	if (featuresFile.is_open())
 	{
 		int n = clnf_model.patch_experts.visibilities[0][0].rows;
-		featuresFile << "version: 1" << endl;
+		featuresFile << "version: 2" << endl;
 		featuresFile << "npoints: " << n << endl;
 		featuresFile << "{" << endl;
 
@@ -194,12 +195,30 @@ void write_out_landmarks(const string& outfeatures, const LandmarkDetector::CLNF
 		featuresFile << pose[3] << " " << pose[4] << " " << pose[5] << endl;
 		featuresFile << "}" << endl;
 
-		// Do the pose and eye gaze if present as well
+		if(output_gaze)
+		{
 			featuresFile << "gaze: dir_x_1, dir_y_1, dir_z_1, dir_x_2, dir_y_2, dir_z_2: " << endl;
 			featuresFile << "{" << endl;
 			featuresFile << gaze0.x << " " << gaze0.y << " " << gaze0.z << " " << gaze1.x << " " << gaze1.y << " " << gaze1.z << endl;
 			featuresFile << "}" << endl;
 
+			featuresFile << "gaze: angle_x, angle_y: " << endl;
+			featuresFile << "{" << endl;
+			featuresFile << gaze_angle[0] << " " << gaze_angle[1] << endl;
+			featuresFile << "}" << endl;
+
+			std::vector<cv::Point2d> eye_landmark_points = LandmarkDetector::CalculateAllEyeLandmarks(clnf_model);
+
+			featuresFile << "eye_lmks: " << eye_landmark_points.size() << endl;
+			featuresFile << "{" << endl;
+
+			for (int i = 0; i < eye_landmark_points.size(); ++i)
+			{
+				// Use matlab format, so + 1
+				featuresFile << (eye_landmark_points[i].x + 1) << " " << (eye_landmark_points[i].y + 1) << endl;
+			}
+			featuresFile << "}" << endl;
+		}
 		// Do the au intensities
 		featuresFile << "au intensities: " << au_intensities.size() << endl;
 		featuresFile << "{" << endl;
@@ -297,10 +316,6 @@ int main (int argc, char **argv)
 	//Convert arguments to more convenient vector form
 	vector<string> arguments = get_arguments(argc, argv);
 
-	// Search paths
-	boost::filesystem::path config_path = boost::filesystem::path(CONFIG_DIR);
-	boost::filesystem::path parent_path = boost::filesystem::path(arguments[0]).parent_path();
-
 	// Some initial parameters that can be overriden from command line
 	vector<string> files, output_images, output_landmark_locations, output_pose_locations;
 
@@ -411,12 +426,13 @@ int main (int argc, char **argv)
 				// Gaze tracking, absolute gaze direction
 				cv::Point3f gazeDirection0(0, 0, -1);
 				cv::Point3f gazeDirection1(0, 0, -1);
+				cv::Vec2d gazeAngle(0, 0);
 
 				if (success && det_parameters.track_gaze)
 				{
-					GazeAnalysis::EstimateGaze(clnf_model, gazeDirection0, fx, fy, cx, cy, true);
+					FaceAnalysis::EstimateGaze(clnf_model, gazeDirection0, fx, fy, cx, cy, true);
-					GazeAnalysis::EstimateGaze(clnf_model, gazeDirection1, fx, fy, cx, cy, false);
+					FaceAnalysis::EstimateGaze(clnf_model, gazeDirection1, fx, fy, cx, cy, false);
-
+					gazeAngle = FaceAnalysis::GetGazeAngle(gazeDirection0, gazeDirection1);
 				}
 
 				auto ActionUnits = face_analyser.PredictStaticAUs(read_image, clnf_model.detected_landmarks, false);
@@ -437,7 +453,7 @@ int main (int argc, char **argv)
 					boost::filesystem::path fname = out_feat_path.filename().replace_extension("");
 					boost::filesystem::path ext = out_feat_path.extension();
 					string outfeatures = dir.string() + preferredSlash + fname.string() + string(name) + ext.string();
-					write_out_landmarks(outfeatures, clnf_model, headPose, gazeDirection0, gazeDirection1, ActionUnits.first, ActionUnits.second);
+					write_out_landmarks(outfeatures, clnf_model, headPose, gazeDirection0, gazeDirection1, gazeAngle,  ActionUnits.first, ActionUnits.second, det_parameters.track_gaze);
 				}
 
 				if (!output_pose_locations.empty())
@@ -527,11 +543,13 @@ int main (int argc, char **argv)
 			// Gaze tracking, absolute gaze direction
 			cv::Point3f gazeDirection0(0, 0, -1);
 			cv::Point3f gazeDirection1(0, 0, -1);
+			cv::Vec2d gazeAngle(0, 0);
 
 			if (det_parameters.track_gaze)
 			{
-				GazeAnalysis::EstimateGaze(clnf_model, gazeDirection0, fx, fy, cx, cy, true);
+				FaceAnalysis::EstimateGaze(clnf_model, gazeDirection0, fx, fy, cx, cy, true);
-				GazeAnalysis::EstimateGaze(clnf_model, gazeDirection1, fx, fy, cx, cy, false);
+				FaceAnalysis::EstimateGaze(clnf_model, gazeDirection1, fx, fy, cx, cy, false);
+				gazeAngle = FaceAnalysis::GetGazeAngle(gazeDirection0, gazeDirection1);
 			}
 
 			auto ActionUnits = face_analyser.PredictStaticAUs(read_image, clnf_model.detected_landmarks, false);
@@ -540,7 +558,7 @@ int main (int argc, char **argv)
 			if(!output_landmark_locations.empty())
 			{
 				string outfeatures = output_landmark_locations.at(i);
-				write_out_landmarks(outfeatures, clnf_model, headPose, gazeDirection0, gazeDirection1, ActionUnits.first, ActionUnits.second);
+				write_out_landmarks(outfeatures, clnf_model, headPose, gazeDirection0, gazeDirection1, gazeAngle, ActionUnits.first, ActionUnits.second, det_parameters.track_gaze);
 			}
 
 			// Writing out the detected landmarks

exe/FaceLandmarkImg/FaceLandmarkImg.vcxproj

@@ -61,6 +61,7 @@
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
     <Import Project="..\..\lib\3rdParty\boost\boost_d.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb_d.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -68,6 +69,7 @@
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
     <Import Project="..\..\lib\3rdParty\boost\boost_d.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb_d.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -75,6 +77,7 @@
     <Import Project="..\..\lib\3rdParty\dlib\dlib.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb.props" />
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -82,6 +85,7 @@
     <Import Project="..\..\lib\3rdParty\dlib\dlib.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb.props" />
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

exe/FaceLandmarkVid/FaceLandmarkVid.vcxproj

@@ -61,6 +61,7 @@
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
     <Import Project="..\..\lib\3rdParty\boost\boost_d.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb_d.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -68,6 +69,7 @@
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
     <Import Project="..\..\lib\3rdParty\boost\boost_d.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb_d.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -75,6 +77,7 @@
     <Import Project="..\..\lib\3rdParty\dlib\dlib.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb.props" />
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -82,6 +85,7 @@
     <Import Project="..\..\lib\3rdParty\dlib\dlib.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb.props" />
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

exe/FaceLandmarkVidMulti/FaceLandmarkVidMulti.cpp

@@ -238,7 +238,6 @@ int main (int argc, char **argv)
 		{		
 
 			// Reading the images
-			cv::Mat_<float> depth_image;
 			cv::Mat_<uchar> grayscale_image;
 
 			cv::Mat disp_image = captured_image.clone();
@@ -398,12 +397,6 @@ int main (int argc, char **argv)
 			{
 				cv::namedWindow("tracking_result",1);
 				cv::imshow("tracking_result", disp_image);
-
-				if(!depth_image.empty())
-				{
-					// Division needed for visualisation purposes
-					imshow("depth", depth_image/2000.0);
-				}
 			}
 
 			// output the tracked video

exe/FaceLandmarkVidMulti/FaceLandmarkVidMulti.vcxproj

@@ -60,6 +60,7 @@
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
     <Import Project="..\..\lib\3rdParty\boost\boost_d.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb_d.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -67,6 +68,7 @@
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
     <Import Project="..\..\lib\3rdParty\boost\boost_d.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb_d.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -74,6 +76,7 @@
     <Import Project="..\..\lib\3rdParty\dlib\dlib.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb.props" />
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -81,6 +84,7 @@
     <Import Project="..\..\lib\3rdParty\dlib\dlib.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb.props" />
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

exe/FeatureExtraction/FeatureExtraction.cpp

@@ -132,9 +132,9 @@ void create_directory(string output_path)
 	}
 }
 
-void get_output_feature_params(vector<string> &output_similarity_aligned, vector<string> &output_hog_aligned_files, double &similarity_scale,
+void get_output_feature_params(vector<string> &output_similarity_aligned, vector<string> &output_hog_aligned_files, bool& visualize_track,
-	int &similarity_size, bool &grayscale, bool& visualize_track, bool& visualize_align, bool& visualize_hog, bool& dynamic, bool &output_2D_landmarks, bool &output_3D_landmarks,
+	bool& visualize_align, bool& visualize_hog, bool &output_2D_landmarks, bool &output_3D_landmarks, bool &output_model_params,
-	bool &output_model_params, bool &output_pose, bool &output_AUs, bool &output_gaze, vector<string> &arguments);
+	bool &output_pose, bool &output_AUs, bool &output_gaze, vector<string> &arguments);
 
 void get_image_input_output_params_feats(vector<vector<string> > &input_image_files, bool& as_video, vector<string> &arguments);
 
@@ -205,13 +205,13 @@ void visualise_tracking(cv::Mat& captured_image, const LandmarkDetector::CLNF& f
 
 void prepareOutputFile(std::ofstream* output_file, bool output_2D_landmarks, bool output_3D_landmarks,
 	bool output_model_params, bool output_pose, bool output_AUs, bool output_gaze,
-	int num_landmarks, int num_eye_lmks, int num_model_modes, vector<string> au_names_class, vector<string> au_names_reg);
+	int num_face_landmarks, int num_model_modes, int num_eye_landmarks, vector<string> au_names_class, vector<string> au_names_reg);
 
 // Output all of the information into one file in one go (quite a few parameters, but simplifies the flow)
 void outputAllFeatures(std::ofstream* output_file, bool output_2D_landmarks, bool output_3D_landmarks,
 	bool output_model_params, bool output_pose, bool output_AUs, bool output_gaze,
 	const LandmarkDetector::CLNF& face_model, int frame_count, double time_stamp, bool detection_success,
-	cv::Point3f gazeDirection0, cv::Point3f gazeDirection1, cv::Vec2d gaze_angle, const cv::Vec6d& pose_estimate, double fx, double fy, double cx, double cy,
+	cv::Point3f gazeDirection0, cv::Point3f gazeDirection1, cv::Vec2d gaze_angle, cv::Vec6d& pose_estimate, double fx, double fy, double cx, double cy,
 	const FaceAnalysis::FaceAnalyser& face_analyser);
 
 int main (int argc, char **argv)
@@ -222,15 +222,12 @@ int main (int argc, char **argv)
 	// Some initial parameters that can be overriden from command line	
 	vector<string> input_files, output_files, tracked_videos_output;
 	
-	LandmarkDetector::FaceModelParameters det_parameters(arguments);
-	// Always track gaze in feature extraction
-	det_parameters.track_gaze = true;
-
 	// Get the input output file parameters
 	
 	// Indicates that rotation should be with respect to camera or world coordinates
+	bool use_camera_coordinates = false;
 	string output_codec; //not used but should
-	LandmarkDetector::get_video_input_output_params(input_files, output_files, tracked_videos_output, output_codec, arguments);
+	LandmarkDetector::get_video_input_output_params(input_files, output_files, tracked_videos_output, use_camera_coordinates, output_codec, arguments);
 
 	bool video_input = true;
 	bool images_as_video = false;
@@ -272,14 +269,6 @@ int main (int argc, char **argv)
 	vector<string> output_similarity_align;
 	vector<string> output_hog_align_files;
 
-	double sim_scale = -1;
-	int sim_size = 112;
-	bool grayscale = false;
-	bool video_output = false;
-	bool dynamic = true; // Indicates if a dynamic AU model should be used (dynamic is useful if the video is long enough to include neutral expressions)
-	int num_hog_rows;
-	int num_hog_cols;
-
 	// By default output all parameters, but these can be turned off to get smaller files or slightly faster processing times
 	// use -no2Dfp, -no3Dfp, -noMparams, -noPose, -noAUs, -noGaze to turn them off
 	bool output_2D_landmarks = true;
@@ -292,7 +281,7 @@ int main (int argc, char **argv)
 	bool visualize_track = false;
 	bool visualize_align = false;
 	bool visualize_hog = false;
-	get_output_feature_params(output_similarity_align, output_hog_align_files, sim_scale, sim_size, grayscale, visualize_track, visualize_align, visualize_hog, dynamic,
+	get_output_feature_params(output_similarity_align, output_hog_align_files, visualize_track, visualize_align, visualize_hog,
 		output_2D_landmarks, output_3D_landmarks, output_model_params, output_pose, output_AUs, output_gaze, arguments);
 
 	// If multiple video files are tracked, use this to indicate if we are done
@@ -300,10 +289,11 @@ int main (int argc, char **argv)
 	int f_n = -1;
 	int curr_img = -1;
 
-
 	// Load the modules that are being used for tracking and face analysis
-
 	// Load face landmark detector
+	LandmarkDetector::FaceModelParameters det_parameters(arguments);
+	// Always track gaze in feature extraction
+	det_parameters.track_gaze = true;
 	LandmarkDetector::CLNF face_model(det_parameters.model_location);
 
 	// Load facial feature extractor and AU analyser
@@ -405,8 +395,9 @@ int main (int argc, char **argv)
 		if (!output_files.empty())
 		{
 			output_file.open(output_files[f_n], ios_base::out);
-			prepareOutputFile(&output_file, output_2D_landmarks, output_3D_landmarks, output_model_params, output_pose, output_AUs, output_gaze, face_model.pdm.NumberOfPoints(), 
+			int num_eye_landmarks = LandmarkDetector::CalculateAllEyeLandmarks(face_model).size();
-				LandmarkDetector::CalculateAllEyeLandmarks(face_model).size(), face_model.pdm.NumberOfModes(), face_analyser.GetAUClassNames(), face_analyser.GetAURegNames());
+		
+			prepareOutputFile(&output_file, output_2D_landmarks, output_3D_landmarks, output_model_params, output_pose, output_AUs, output_gaze, face_model.pdm.NumberOfPoints(), face_model.pdm.NumberOfModes(), num_eye_landmarks, face_analyser.GetAUClassNames(), face_analyser.GetAURegNames());
 		}
 
 		// Saving the HOG features
@@ -507,8 +498,8 @@ int main (int argc, char **argv)
 			// But only if needed in output
 			if(!output_similarity_align.empty() || hog_output_file.is_open() || output_AUs)
 			{
-
 				face_analyser.AddNextFrame(captured_image, face_model.detected_landmarks, face_model.detection_success, time_stamp, false, !det_parameters.quiet_mode && (visualize_align || visualize_hog));
+
 				face_analyser.GetLatestAlignedFace(sim_warped_img);
 
 				if(!det_parameters.quiet_mode && visualize_align)
@@ -528,6 +519,16 @@ int main (int argc, char **argv)
 				}
 			}
 
+			// Work out the pose of the head from the tracked model
+			cv::Vec6d pose_estimate;
+			if(use_camera_coordinates)
+			{
+				pose_estimate = LandmarkDetector::GetCorrectedPoseCamera(face_model, fx, fy, cx, cy);
+			}
+			else
+			{
+				pose_estimate = LandmarkDetector::GetCorrectedPoseWorld(face_model, fx, fy, cx, cy);
+			}
 
 			if (hog_output_file.is_open())
 			{
@@ -655,7 +656,7 @@ int main (int argc, char **argv)
 
 void prepareOutputFile(std::ofstream* output_file, bool output_2D_landmarks, bool output_3D_landmarks,
 	bool output_model_params, bool output_pose, bool output_AUs, bool output_gaze,
-	int num_landmarks, int num_eye_lmks, int num_model_modes, vector<string> au_names_class, vector<string> au_names_reg)
+	int num_face_landmarks, int num_model_modes, int num_eye_landmarks, vector<string> au_names_class, vector<string> au_names_reg)
 {
 
 	*output_file << "frame, timestamp, confidence, success";
@@ -664,12 +665,11 @@ void prepareOutputFile(std::ofstream* output_file, bool output_2D_landmarks, boo
 	{
 		*output_file << ", gaze_0_x, gaze_0_y, gaze_0_z, gaze_1_x, gaze_1_y, gaze_1_z, gaze_angle_x, gaze_angle_y";
 
-		// Also output eye-landmarks as they are needed for gaze visualization etc.
+		for (int i = 0; i < num_eye_landmarks; ++i)
-		for (int i = 0; i < num_eye_lmks; ++i)
 		{
 			*output_file << ", eye_lmk_x_" << i;
 		}
-		for (int i = 0; i < num_eye_lmks; ++i)
+		for (int i = 0; i < num_eye_landmarks; ++i)
 		{
 			*output_file << ", eye_lmk_y_" << i;
 		}
@@ -682,11 +682,11 @@ void prepareOutputFile(std::ofstream* output_file, bool output_2D_landmarks, boo
 
 	if (output_2D_landmarks)
 	{
-		for (int i = 0; i < num_landmarks; ++i)
+		for (int i = 0; i < num_face_landmarks; ++i)
 		{
 			*output_file << ", x_" << i;
 		}
-		for (int i = 0; i < num_landmarks; ++i)
+		for (int i = 0; i < num_face_landmarks; ++i)
 		{
 			*output_file << ", y_" << i;
 		}
@@ -694,15 +694,15 @@ void prepareOutputFile(std::ofstream* output_file, bool output_2D_landmarks, boo
 
 	if (output_3D_landmarks)
 	{
-		for (int i = 0; i < num_landmarks; ++i)
+		for (int i = 0; i < num_face_landmarks; ++i)
 		{
 			*output_file << ", X_" << i;
 		}
-		for (int i = 0; i < num_landmarks; ++i)
+		for (int i = 0; i < num_face_landmarks; ++i)
 		{
 			*output_file << ", Y_" << i;
 		}
-		for (int i = 0; i < num_landmarks; ++i)
+		for (int i = 0; i < num_face_landmarks; ++i)
 		{
 			*output_file << ", Z_" << i;
 		}
@@ -741,7 +741,7 @@ void prepareOutputFile(std::ofstream* output_file, bool output_2D_landmarks, boo
 void outputAllFeatures(std::ofstream* output_file, bool output_2D_landmarks, bool output_3D_landmarks,
 	bool output_model_params, bool output_pose, bool output_AUs, bool output_gaze,
 	const LandmarkDetector::CLNF& face_model, int frame_count, double time_stamp, bool detection_success,
-	cv::Point3f gazeDirection0, cv::Point3f gazeDirection1, cv::Vec2d gaze_angle, const cv::Vec6d& pose_estimate, double fx, double fy, double cx, double cy,
+	cv::Point3f gazeDirection0, cv::Point3f gazeDirection1, cv::Vec2d gaze_angle, cv::Vec6d& pose_estimate, double fx, double fy, double cx, double cy,
 	const FaceAnalysis::FaceAnalyser& face_analyser)
 {
 
@@ -759,32 +759,21 @@ void outputAllFeatures(std::ofstream* output_file, bool output_2D_landmarks, boo
 	if (output_gaze)
 	{
 		*output_file << ", " << gazeDirection0.x << ", " << gazeDirection0.y << ", " << gazeDirection0.z
-			<< ", " << gazeDirection1.x << ", " << gazeDirection1.y << ", " << gazeDirection1.z
+			<< ", " << gazeDirection1.x << ", " << gazeDirection1.y << ", " << gazeDirection1.z;
-			<< ", " << gaze_angle[0] << ", " << gaze_angle[1];
 
-		// Output gaze landmarks
+		// Output gaze angle (same format as head pose angle)
-		vector<cv::Point2d> eye_lmks = LandmarkDetector::CalculateAllEyeLandmarks(face_model);
+		*output_file << ", " << gaze_angle[0] << ", " << gaze_angle[1];
-		for (size_t i = 0; i < eye_lmks.size(); ++i)
+
+		// Output eye landmarks
+		std::vector<cv::Point2d> eye_landmark_points = LandmarkDetector::CalculateAllEyeLandmarks(face_model);
+
+		for (size_t i = 0; i < eye_landmark_points.size(); ++i)
 		{
-			if (face_model.tracking_initialised)
+			*output_file << ", " << eye_landmark_points[i].x;
-			{
-				*output_file << ", " << eye_lmks[i].x;
 		}
-			else
+		for (size_t i = 0; i < eye_landmark_points.size(); ++i)
 		{
-				*output_file << ", 0";
+			*output_file << ", " << eye_landmark_points[i].y;
-			}
-		}
-		for (size_t i = 0; i < eye_lmks.size(); ++i)
-		{
-			if (face_model.tracking_initialised)
-			{
-				*output_file << ", " << eye_lmks[i].y;
-			}
-			else
-			{
-				*output_file << ", 0";
-			}
 		}
 	}
 
@@ -923,10 +912,9 @@ void outputAllFeatures(std::ofstream* output_file, bool output_2D_landmarks, boo
 }
 
 
-void get_output_feature_params(vector<string> &output_similarity_aligned, vector<string> &output_hog_aligned_files, double &similarity_scale,
+void get_output_feature_params(vector<string> &output_similarity_aligned, vector<string> &output_hog_aligned_files, bool& visualize_track, 
-	int &similarity_size, bool &grayscale, bool& visualize_track, bool& visualize_align, bool& visualize_hog, bool& dynamic,
+	bool& visualize_align, bool& visualize_hog, bool &output_2D_landmarks, bool &output_3D_landmarks, bool &output_model_params, 
-	bool &output_2D_landmarks, bool &output_3D_landmarks, bool &output_model_params, bool &output_pose, bool &output_AUs, bool &output_gaze,
+	bool &output_pose, bool &output_AUs, bool &output_gaze, vector<string> &arguments)
-	vector<string> &arguments)
 {
 	output_similarity_aligned.clear();
 	output_hog_aligned_files.clear();
@@ -940,9 +928,6 @@ void get_output_feature_params(vector<string> &output_similarity_aligned, vector
 
 	string output_root = "";
 
-	// By default the model is dynamic
-	dynamic = true;
-
 	visualize_align = false;
 	visualize_hog = false;
 	visualize_track = false;

exe/FeatureExtraction/FeatureExtraction.vcxproj

@@ -60,6 +60,7 @@
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
     <Import Project="..\..\lib\3rdParty\boost\boost_d.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb_d.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -67,6 +68,7 @@
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
     <Import Project="..\..\lib\3rdParty\boost\boost_d.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb_d.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -74,6 +76,7 @@
     <Import Project="..\..\lib\3rdParty\dlib\dlib.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb.props" />
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -81,6 +84,7 @@
     <Import Project="..\..\lib\3rdParty\dlib\dlib.props" />
     <Import Project="..\..\lib\3rdParty\tbb\tbb.props" />
     <Import Project="..\..\lib\3rdParty\OpenCV3.1\openCV3.1.props" />
+    <Import Project="..\..\lib\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

lib/3rdParty/OpenBLAS/OpenBLAS.props

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(SolutionDir)lib\3rdParty\OpenBLAS\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalLibraryDirectories>$(SolutionDir)lib\3rdParty\OpenBLAS\lib\$(PlatformShortName);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>libopenblas.dll.a;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PreBuildEvent>
+      <Command>
+      </Command>
+    </PreBuildEvent>
+    <PreLinkEvent>
+      <Command>xcopy /I /E /Y /D /C "$(SolutionDir)lib\3rdParty\OpenBlas\bin\$(PlatformShortName)" "$(OutDir)"</Command>
+    </PreLinkEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup />
+</Project>

lib/3rdParty/OpenBLAS/include/cblas.h

@@ -0,0 +1,364 @@
+#ifndef CBLAS_H
+#define CBLAS_H
+
+#include <stddef.h>
+#include "openblas_config.h"
+
+#ifdef __cplusplus
+extern "C" {
+	/* Assume C declarations for C++ */
+#endif  /* __cplusplus */
+
+/*Set the number of threads on runtime.*/
+void openblas_set_num_threads(int num_threads);
+void goto_set_num_threads(int num_threads);
+
+/*Get the number of threads on runtime.*/
+int openblas_get_num_threads(void);
+
+/*Get the number of physical processors (cores).*/
+int openblas_get_num_procs(void);
+
+/*Get the build configure on runtime.*/
+char* openblas_get_config(void);
+
+/*Get the CPU corename on runtime.*/
+char* openblas_get_corename(void);
+
+/* Get the parallelization type which is used by OpenBLAS */
+int openblas_get_parallel(void);
+/* OpenBLAS is compiled for sequential use  */
+#define OPENBLAS_SEQUENTIAL  0
+/* OpenBLAS is compiled using normal threading model */
+#define OPENBLAS_THREAD  1
+/* OpenBLAS is compiled using OpenMP threading model */
+#define OPENBLAS_OPENMP 2
+
+
+/*
+ * Since all of GotoBlas was written without const,
+ * we disable it at build time.
+ */
+#ifndef OPENBLAS_CONST
+# define OPENBLAS_CONST const
+#endif
+
+
+#define CBLAS_INDEX size_t
+
+typedef enum CBLAS_ORDER     {CblasRowMajor=101, CblasColMajor=102} CBLAS_ORDER;
+typedef enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113, CblasConjNoTrans=114} CBLAS_TRANSPOSE;
+typedef enum CBLAS_UPLO      {CblasUpper=121, CblasLower=122} CBLAS_UPLO;
+typedef enum CBLAS_DIAG      {CblasNonUnit=131, CblasUnit=132} CBLAS_DIAG;
+typedef enum CBLAS_SIDE      {CblasLeft=141, CblasRight=142} CBLAS_SIDE;
+
+float  cblas_sdsdot(OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float *y, OPENBLAS_CONST blasint incy);
+double cblas_dsdot (OPENBLAS_CONST blasint n, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float *y, OPENBLAS_CONST blasint incy);
+float  cblas_sdot(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float  *y, OPENBLAS_CONST blasint incy);
+double cblas_ddot(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST double *y, OPENBLAS_CONST blasint incy);
+
+openblas_complex_float  cblas_cdotu(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float  *y, OPENBLAS_CONST blasint incy);
+openblas_complex_float  cblas_cdotc(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float  *y, OPENBLAS_CONST blasint incy);
+openblas_complex_double cblas_zdotu(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST double *y, OPENBLAS_CONST blasint incy);
+openblas_complex_double cblas_zdotc(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST double *y, OPENBLAS_CONST blasint incy);
+
+void  cblas_cdotu_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float  *y, OPENBLAS_CONST blasint incy, openblas_complex_float  *ret);
+void  cblas_cdotc_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float  *y, OPENBLAS_CONST blasint incy, openblas_complex_float  *ret);
+void  cblas_zdotu_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST double *y, OPENBLAS_CONST blasint incy, openblas_complex_double *ret);
+void  cblas_zdotc_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST double *y, OPENBLAS_CONST blasint incy, openblas_complex_double *ret);
+
+float  cblas_sasum (OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
+double cblas_dasum (OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
+float  cblas_scasum(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
+double cblas_dzasum(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
+
+float  cblas_snrm2 (OPENBLAS_CONST blasint N, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX);
+double cblas_dnrm2 (OPENBLAS_CONST blasint N, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX);
+float  cblas_scnrm2(OPENBLAS_CONST blasint N, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX);
+double cblas_dznrm2(OPENBLAS_CONST blasint N, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX);
+
+CBLAS_INDEX cblas_isamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_idamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_icamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_izamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
+
+void cblas_saxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
+void cblas_daxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
+void cblas_caxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
+void cblas_zaxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
+
+void cblas_scopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
+void cblas_dcopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
+void cblas_ccopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
+void cblas_zcopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
+
+void cblas_sswap(OPENBLAS_CONST blasint n, float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
+void cblas_dswap(OPENBLAS_CONST blasint n, double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
+void cblas_cswap(OPENBLAS_CONST blasint n, float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
+void cblas_zswap(OPENBLAS_CONST blasint n, double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
+
+void cblas_srot(OPENBLAS_CONST blasint N, float *X, OPENBLAS_CONST blasint incX, float *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST float c, OPENBLAS_CONST float s);
+void cblas_drot(OPENBLAS_CONST blasint N, double *X, OPENBLAS_CONST blasint incX, double *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST double c, OPENBLAS_CONST double  s);
+
+void cblas_srotg(float *a, float *b, float *c, float *s);
+void cblas_drotg(double *a, double *b, double *c, double *s);
+
+void cblas_srotm(OPENBLAS_CONST blasint N, float *X, OPENBLAS_CONST blasint incX, float *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST float *P);
+void cblas_drotm(OPENBLAS_CONST blasint N, double *X, OPENBLAS_CONST blasint incX, double *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST double *P);
+
+void cblas_srotmg(float *d1, float *d2, float *b1, OPENBLAS_CONST float b2, float *P);
+void cblas_drotmg(double *d1, double *d2, double *b1, OPENBLAS_CONST double b2, double *P);
+
+void cblas_sscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, float *X, OPENBLAS_CONST blasint incX);
+void cblas_dscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, double *X, OPENBLAS_CONST blasint incX);
+void cblas_cscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST float *alpha, float *X, OPENBLAS_CONST blasint incX);
+void cblas_zscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, double *X, OPENBLAS_CONST blasint incX);
+void cblas_csscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, float *X, OPENBLAS_CONST blasint incX);
+void cblas_zdscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, double *X, OPENBLAS_CONST blasint incX);
+
+void cblas_sgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
+		 OPENBLAS_CONST float alpha, OPENBLAS_CONST float  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST float beta,  float  *y, OPENBLAS_CONST blasint incy);
+void cblas_dgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
+		 OPENBLAS_CONST double alpha, OPENBLAS_CONST double  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST double  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST double beta,  double  *y, OPENBLAS_CONST blasint incy);
+void cblas_cgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
+		 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST float *beta,  float  *y, OPENBLAS_CONST blasint incy);
+void cblas_zgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
+		 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST double  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST double *beta,  double  *y, OPENBLAS_CONST blasint incy);
+
+void cblas_sger (OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float   alpha, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float  *Y, OPENBLAS_CONST blasint incY, float  *A, OPENBLAS_CONST blasint lda);
+void cblas_dger (OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double  alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A, OPENBLAS_CONST blasint lda);
+void cblas_cgeru(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float  *alpha, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float  *Y, OPENBLAS_CONST blasint incY, float  *A, OPENBLAS_CONST blasint lda);
+void cblas_cgerc(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float  *alpha, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float  *Y, OPENBLAS_CONST blasint incY, float  *A, OPENBLAS_CONST blasint lda);
+void cblas_zgeru(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A, OPENBLAS_CONST blasint lda);
+void cblas_zgerc(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A, OPENBLAS_CONST blasint lda);
+
+void cblas_strsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
+void cblas_dtrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
+void cblas_ctrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
+void cblas_ztrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
+
+void cblas_strmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
+void cblas_dtrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
+void cblas_ctrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
+void cblas_ztrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
+
+void cblas_ssyr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, float *A, OPENBLAS_CONST blasint lda);
+void cblas_dsyr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, double *A, OPENBLAS_CONST blasint lda);
+void cblas_cher(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, float *A, OPENBLAS_CONST blasint lda);
+void cblas_zher(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, double *A, OPENBLAS_CONST blasint lda);
+
+void cblas_ssyr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo,OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X,
+                OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *Y, OPENBLAS_CONST blasint incY, float *A, OPENBLAS_CONST blasint lda);
+void cblas_dsyr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X,
+                OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A, OPENBLAS_CONST blasint lda);
+void cblas_cher2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX,
+                OPENBLAS_CONST float *Y, OPENBLAS_CONST blasint incY, float *A, OPENBLAS_CONST blasint lda);
+void cblas_zher2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX,
+                OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A, OPENBLAS_CONST blasint lda);
+
+void cblas_sgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+                 OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float beta, float *Y, OPENBLAS_CONST blasint incY);
+void cblas_dgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+                 OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double beta, double *Y, OPENBLAS_CONST blasint incY);
+void cblas_cgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+                 OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *beta, float *Y, OPENBLAS_CONST blasint incY);
+void cblas_zgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+                 OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *beta, double *Y, OPENBLAS_CONST blasint incY);
+
+void cblas_ssbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A,
+                 OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float beta, float *Y, OPENBLAS_CONST blasint incY);
+void cblas_dsbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A,
+                 OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double beta, double *Y, OPENBLAS_CONST blasint incY);
+
+
+void cblas_stbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
+void cblas_dtbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
+void cblas_ctbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
+void cblas_ztbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
+
+void cblas_stbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
+void cblas_dtbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
+void cblas_ctbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
+void cblas_ztbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
+
+void cblas_stpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST float *Ap, float *X, OPENBLAS_CONST blasint incX);
+void cblas_dtpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST double *Ap, double *X, OPENBLAS_CONST blasint incX);
+void cblas_ctpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST float *Ap, float *X, OPENBLAS_CONST blasint incX);
+void cblas_ztpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST double *Ap, double *X, OPENBLAS_CONST blasint incX);
+
+void cblas_stpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST float *Ap, float *X, OPENBLAS_CONST blasint incX);
+void cblas_dtpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST double *Ap, double *X, OPENBLAS_CONST blasint incX);
+void cblas_ctpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST float *Ap, float *X, OPENBLAS_CONST blasint incX);
+void cblas_ztpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+                 OPENBLAS_CONST blasint N, OPENBLAS_CONST double *Ap, double *X, OPENBLAS_CONST blasint incX);
+
+void cblas_ssymv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A,
+                 OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float beta, float *Y, OPENBLAS_CONST blasint incY);
+void cblas_dsymv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A,
+                 OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double beta, double *Y, OPENBLAS_CONST blasint incY);
+void cblas_chemv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A,
+                 OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *beta, float *Y, OPENBLAS_CONST blasint incY);
+void cblas_zhemv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A,
+                 OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *beta, double *Y, OPENBLAS_CONST blasint incY);
+
+
+void cblas_sspmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *Ap,
+                 OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float beta, float *Y, OPENBLAS_CONST blasint incY);
+void cblas_dspmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *Ap,
+                 OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double beta, double *Y, OPENBLAS_CONST blasint incY);
+
+void cblas_sspr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, float *Ap);
+void cblas_dspr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, double *Ap);
+
+void cblas_chpr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, float *A);
+void cblas_zhpr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X,OPENBLAS_CONST blasint incX, double *A);
+
+void cblas_sspr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *Y, OPENBLAS_CONST blasint incY, float *A);
+void cblas_dspr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A);
+void cblas_chpr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *Y, OPENBLAS_CONST blasint incY, float *Ap);
+void cblas_zhpr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *Ap);
+
+void cblas_chbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+		 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *beta, float *Y, OPENBLAS_CONST blasint incY);
+void cblas_zhbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+		 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *beta, double *Y, OPENBLAS_CONST blasint incY);
+
+void cblas_chpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N,
+		 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *Ap, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *beta, float *Y, OPENBLAS_CONST blasint incY);
+void cblas_zhpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N,
+		 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *Ap, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *beta, double *Y, OPENBLAS_CONST blasint incY);
+
+void cblas_sgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+		 OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
+void cblas_dgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+		 OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
+void cblas_cgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+		 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float *beta, float *C, OPENBLAS_CONST blasint ldc);
+void cblas_cgemm3m(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+		 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float *beta, float *C, OPENBLAS_CONST blasint ldc);
+void cblas_zgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+		 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double *beta, double *C, OPENBLAS_CONST blasint ldc);
+void cblas_zgemm3m(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+		 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double *beta, double *C, OPENBLAS_CONST blasint ldc);
+
+
+void cblas_ssymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+                 OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
+void cblas_dsymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+                 OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
+void cblas_csymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+                 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float *beta, float *C, OPENBLAS_CONST blasint ldc);
+void cblas_zsymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+                 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double *beta, double *C, OPENBLAS_CONST blasint ldc);
+
+void cblas_ssyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
+void cblas_dsyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
+void cblas_csyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *beta, float *C, OPENBLAS_CONST blasint ldc);
+void cblas_zsyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *beta, double *C, OPENBLAS_CONST blasint ldc);
+
+void cblas_ssyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
+void cblas_dsyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
+void cblas_csyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float *beta, float *C, OPENBLAS_CONST blasint ldc);
+void cblas_zsyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double *beta, double *C, OPENBLAS_CONST blasint ldc);
+
+void cblas_strmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *B, OPENBLAS_CONST blasint ldb);
+void cblas_dtrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *B, OPENBLAS_CONST blasint ldb);
+void cblas_ctrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *B, OPENBLAS_CONST blasint ldb);
+void cblas_ztrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *B, OPENBLAS_CONST blasint ldb);
+
+void cblas_strsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *B, OPENBLAS_CONST blasint ldb);
+void cblas_dtrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *B, OPENBLAS_CONST blasint ldb);
+void cblas_ctrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *B, OPENBLAS_CONST blasint ldb);
+void cblas_ztrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+                 OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *B, OPENBLAS_CONST blasint ldb);
+
+void cblas_chemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+                 OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float *beta, float *C, OPENBLAS_CONST blasint ldc);
+void cblas_zhemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+                 OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double *beta, double *C, OPENBLAS_CONST blasint ldc);
+
+void cblas_cherk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+                 OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
+void cblas_zherk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+                 OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
+
+void cblas_cher2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+                  OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
+void cblas_zher2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+                  OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
+
+void cblas_xerbla(blasint p, char *rout, char *form, ...);
+
+/*** BLAS extensions ***/
+
+void cblas_saxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST float beta, float *y, OPENBLAS_CONST blasint incy);
+
+void cblas_daxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST double beta, double *y, OPENBLAS_CONST blasint incy);
+
+void cblas_caxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST float *alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST float *beta, float *y, OPENBLAS_CONST blasint incy);
+
+void cblas_zaxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *alpha, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST double *beta, double *y, OPENBLAS_CONST blasint incy);
+
+void cblas_somatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float calpha, OPENBLAS_CONST float *a, 
+		     OPENBLAS_CONST blasint clda, float *b, OPENBLAS_CONST blasint cldb); 
+void cblas_domatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double calpha, OPENBLAS_CONST double *a,
+		     OPENBLAS_CONST blasint clda, double *b, OPENBLAS_CONST blasint cldb); 
+void cblas_comatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float* calpha, OPENBLAS_CONST float* a, 
+		     OPENBLAS_CONST blasint clda, float*b, OPENBLAS_CONST blasint cldb); 
+void cblas_zomatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double* calpha, OPENBLAS_CONST double* a, 
+		     OPENBLAS_CONST blasint clda,  double *b, OPENBLAS_CONST blasint cldb); 
+
+void cblas_simatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float calpha, float *a, 
+		     OPENBLAS_CONST blasint clda, OPENBLAS_CONST blasint cldb); 
+void cblas_dimatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double calpha, double *a,
+		     OPENBLAS_CONST blasint clda, OPENBLAS_CONST blasint cldb); 
+void cblas_cimatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float* calpha, float* a, 
+		     OPENBLAS_CONST blasint clda, OPENBLAS_CONST blasint cldb); 
+void cblas_zimatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double* calpha, double* a, 
+		     OPENBLAS_CONST blasint clda, OPENBLAS_CONST blasint cldb); 
+
+void cblas_sgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float calpha, float *a, OPENBLAS_CONST blasint clda, OPENBLAS_CONST float cbeta, 
+		  float *c, OPENBLAS_CONST blasint cldc); 
+void cblas_dgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double calpha, double *a, OPENBLAS_CONST blasint clda, OPENBLAS_CONST double cbeta, 
+		  double *c, OPENBLAS_CONST blasint cldc); 
+void cblas_cgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float *calpha, float *a, OPENBLAS_CONST blasint clda, OPENBLAS_CONST float *cbeta, 
+		  float *c, OPENBLAS_CONST blasint cldc); 
+void cblas_zgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double *calpha, double *a, OPENBLAS_CONST blasint clda, OPENBLAS_CONST double *cbeta, 
+		  double *c, OPENBLAS_CONST blasint cldc); 
+
+
+#ifdef __cplusplus
+}
+#endif  /* __cplusplus */
+
+#endif

lib/3rdParty/OpenBLAS/include/f77blas.h

@@ -0,0 +1,772 @@
+#ifndef OPENBLAS_F77BLAS_H
+#define OPENBLAS_F77BLAS_H
+#include "openblas_config.h"
+/*********************************************************************/
+/* Copyright 2009, 2010 The University of Texas at Austin.           */
+/* All rights reserved.                                              */
+/*                                                                   */
+/* Redistribution and use in source and binary forms, with or        */
+/* without modification, are permitted provided that the following   */
+/* conditions are met:                                               */
+/*                                                                   */
+/*   1. Redistributions of source code must retain the above         */
+/*      copyright notice, this list of conditions and the following  */
+/*      disclaimer.                                                  */
+/*                                                                   */
+/*   2. Redistributions in binary form must reproduce the above      */
+/*      copyright notice, this list of conditions and the following  */
+/*      disclaimer in the documentation and/or other materials       */
+/*      provided with the distribution.                              */
+/*                                                                   */
+/*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */
+/*    AUSTIN  ``AS IS''  AND ANY  EXPRESS OR  IMPLIED WARRANTIES,    */
+/*    INCLUDING, BUT  NOT LIMITED  TO, THE IMPLIED  WARRANTIES OF    */
+/*    MERCHANTABILITY  AND FITNESS FOR  A PARTICULAR  PURPOSE ARE    */
+/*    DISCLAIMED.  IN  NO EVENT SHALL THE UNIVERSITY  OF TEXAS AT    */
+/*    AUSTIN OR CONTRIBUTORS BE  LIABLE FOR ANY DIRECT, INDIRECT,    */
+/*    INCIDENTAL,  SPECIAL, EXEMPLARY,  OR  CONSEQUENTIAL DAMAGES    */
+/*    (INCLUDING, BUT  NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE    */
+/*    GOODS  OR  SERVICES; LOSS  OF  USE,  DATA,  OR PROFITS;  OR    */
+/*    BUSINESS INTERRUPTION) HOWEVER CAUSED  AND ON ANY THEORY OF    */
+/*    LIABILITY, WHETHER  IN CONTRACT, STRICT  LIABILITY, OR TORT    */
+/*    (INCLUDING NEGLIGENCE OR OTHERWISE)  ARISING IN ANY WAY OUT    */
+/*    OF  THE  USE OF  THIS  SOFTWARE,  EVEN  IF ADVISED  OF  THE    */
+/*    POSSIBILITY OF SUCH DAMAGE.                                    */
+/*                                                                   */
+/* The views and conclusions contained in the software and           */
+/* documentation are those of the authors and should not be          */
+/* interpreted as representing official policies, either expressed   */
+/* or implied, of The University of Texas at Austin.                 */
+/*********************************************************************/
+
+#ifndef ASSEMBLER
+
+#ifdef __cplusplus
+extern "C" {
+	/* Assume C declarations for C++ */
+#endif  /* __cplusplus */
+
+int    BLASFUNC(xerbla)(char *, blasint *info, blasint);
+
+void    openblas_set_num_threads_(int *);
+
+FLOATRET  BLASFUNC(sdot)  (blasint *, float  *, blasint *, float  *, blasint *);
+FLOATRET  BLASFUNC(sdsdot)(blasint *, float  *,        float  *, blasint *, float  *, blasint *);
+
+double BLASFUNC(dsdot) (blasint *, float  *, blasint *, float  *, blasint *);
+double BLASFUNC(ddot)  (blasint *, double *, blasint *, double *, blasint *);
+xdouble BLASFUNC(qdot)  (blasint *, xdouble *, blasint *, xdouble *, blasint *);
+
+
+#ifdef RETURN_BY_STRUCT
+typedef struct {
+  float r, i;
+} myccomplex_t;
+
+typedef struct {
+  double r, i;
+} myzcomplex_t;
+
+typedef struct {
+  xdouble r, i;
+} myxcomplex_t;
+
+myccomplex_t    BLASFUNC(cdotu)  (blasint *, float  *, blasint *, float  *, blasint *);
+myccomplex_t    BLASFUNC(cdotc)  (blasint *, float  *, blasint *, float  *, blasint *);
+myzcomplex_t    BLASFUNC(zdotu)  (blasint *, double  *, blasint *, double  *, blasint *);
+myzcomplex_t    BLASFUNC(zdotc)  (blasint *, double  *, blasint *, double  *, blasint *);
+myxcomplex_t    BLASFUNC(xdotu)  (blasint *, xdouble  *, blasint *, xdouble  *, blasint *);
+myxcomplex_t    BLASFUNC(xdotc)  (blasint *, xdouble  *, blasint *, xdouble  *, blasint *);
+
+#elif defined RETURN_BY_STACK
+void  BLASFUNC(cdotu)  (openblas_complex_float   *,  blasint *, float  * , blasint *, float  *,  blasint *);
+void  BLASFUNC(cdotc)  (openblas_complex_float   *,  blasint *, float  *,  blasint *, float  *,  blasint *);
+void  BLASFUNC(zdotu)  (openblas_complex_double  *, blasint *, double  *, blasint *, double  *, blasint *);
+void  BLASFUNC(zdotc)  (openblas_complex_double  *, blasint *, double  *, blasint *, double  *, blasint *);
+void  BLASFUNC(xdotu)  (openblas_complex_xdouble *, blasint *, xdouble  *, blasint *, xdouble  *, blasint *);
+void  BLASFUNC(xdotc)  (openblas_complex_xdouble *, blasint *, xdouble  *, blasint *, xdouble  *, blasint *);
+#else
+openblas_complex_float   BLASFUNC(cdotu)  (blasint *, float  *, blasint *, float  *, blasint *);
+openblas_complex_float   BLASFUNC(cdotc)  (blasint *, float  *, blasint *, float  *, blasint *);
+openblas_complex_double  BLASFUNC(zdotu)  (blasint *, double  *, blasint *, double  *, blasint *);
+openblas_complex_double  BLASFUNC(zdotc)  (blasint *, double  *, blasint *, double  *, blasint *);
+openblas_complex_xdouble BLASFUNC(xdotu)  (blasint *, xdouble  *, blasint *, xdouble  *, blasint *);
+openblas_complex_xdouble BLASFUNC(xdotc)  (blasint *, xdouble  *, blasint *, xdouble  *, blasint *);
+#endif
+
+void    BLASFUNC(saxpy) (blasint *, float  *, float  *, blasint *, float  *, blasint *);
+void    BLASFUNC(daxpy) (blasint *, double *, double *, blasint *, double *, blasint *);
+void    BLASFUNC(qaxpy) (blasint *, xdouble *, xdouble *, blasint *, xdouble *, blasint *);
+void    BLASFUNC(caxpy) (blasint *, float  *, float  *, blasint *, float  *, blasint *);
+void    BLASFUNC(zaxpy) (blasint *, double *, double *, blasint *, double *, blasint *);
+void    BLASFUNC(xaxpy) (blasint *, xdouble *, xdouble *, blasint *, xdouble *, blasint *);
+void    BLASFUNC(caxpyc)(blasint *, float  *, float  *, blasint *, float  *, blasint *);
+void    BLASFUNC(zaxpyc)(blasint *, double *, double *, blasint *, double *, blasint *);
+void    BLASFUNC(xaxpyc)(blasint *, xdouble *, xdouble *, blasint *, xdouble *, blasint *);
+
+void    BLASFUNC(scopy) (blasint *, float  *, blasint *, float  *, blasint *);
+void    BLASFUNC(dcopy) (blasint *, double *, blasint *, double *, blasint *);
+void    BLASFUNC(qcopy) (blasint *, xdouble *, blasint *, xdouble *, blasint *);
+void    BLASFUNC(ccopy) (blasint *, float  *, blasint *, float  *, blasint *);
+void    BLASFUNC(zcopy) (blasint *, double *, blasint *, double *, blasint *);
+void    BLASFUNC(xcopy) (blasint *, xdouble *, blasint *, xdouble *, blasint *);
+
+void    BLASFUNC(sswap) (blasint *, float  *, blasint *, float  *, blasint *);
+void    BLASFUNC(dswap) (blasint *, double *, blasint *, double *, blasint *);
+void    BLASFUNC(qswap) (blasint *, xdouble *, blasint *, xdouble *, blasint *);
+void    BLASFUNC(cswap) (blasint *, float  *, blasint *, float  *, blasint *);
+void    BLASFUNC(zswap) (blasint *, double *, blasint *, double *, blasint *);
+void    BLASFUNC(xswap) (blasint *, xdouble *, blasint *, xdouble *, blasint *);
+
+FLOATRET  BLASFUNC(sasum) (blasint *, float  *, blasint *);
+FLOATRET  BLASFUNC(scasum)(blasint *, float  *, blasint *);
+double BLASFUNC(dasum) (blasint *, double *, blasint *);
+xdouble BLASFUNC(qasum) (blasint *, xdouble *, blasint *);
+double BLASFUNC(dzasum)(blasint *, double *, blasint *);
+xdouble BLASFUNC(qxasum)(blasint *, xdouble *, blasint *);
+
+blasint    BLASFUNC(isamax)(blasint *, float  *, blasint *);
+blasint    BLASFUNC(idamax)(blasint *, double *, blasint *);
+blasint    BLASFUNC(iqamax)(blasint *, xdouble *, blasint *);
+blasint    BLASFUNC(icamax)(blasint *, float  *, blasint *);
+blasint    BLASFUNC(izamax)(blasint *, double *, blasint *);
+blasint    BLASFUNC(ixamax)(blasint *, xdouble *, blasint *);
+
+blasint    BLASFUNC(ismax) (blasint *, float  *, blasint *);
+blasint    BLASFUNC(idmax) (blasint *, double *, blasint *);
+blasint    BLASFUNC(iqmax) (blasint *, xdouble *, blasint *);
+blasint    BLASFUNC(icmax) (blasint *, float  *, blasint *);
+blasint    BLASFUNC(izmax) (blasint *, double *, blasint *);
+blasint    BLASFUNC(ixmax) (blasint *, xdouble *, blasint *);
+
+blasint    BLASFUNC(isamin)(blasint *, float  *, blasint *);
+blasint    BLASFUNC(idamin)(blasint *, double *, blasint *);
+blasint    BLASFUNC(iqamin)(blasint *, xdouble *, blasint *);
+blasint    BLASFUNC(icamin)(blasint *, float  *, blasint *);
+blasint    BLASFUNC(izamin)(blasint *, double *, blasint *);
+blasint    BLASFUNC(ixamin)(blasint *, xdouble *, blasint *);
+
+blasint    BLASFUNC(ismin)(blasint *, float  *, blasint *);
+blasint    BLASFUNC(idmin)(blasint *, double *, blasint *);
+blasint    BLASFUNC(iqmin)(blasint *, xdouble *, blasint *);
+blasint    BLASFUNC(icmin)(blasint *, float  *, blasint *);
+blasint    BLASFUNC(izmin)(blasint *, double *, blasint *);
+blasint    BLASFUNC(ixmin)(blasint *, xdouble *, blasint *);
+
+FLOATRET  BLASFUNC(samax) (blasint *, float  *, blasint *);
+double BLASFUNC(damax) (blasint *, double *, blasint *);
+xdouble BLASFUNC(qamax) (blasint *, xdouble *, blasint *);
+FLOATRET  BLASFUNC(scamax)(blasint *, float  *, blasint *);
+double BLASFUNC(dzamax)(blasint *, double *, blasint *);
+xdouble BLASFUNC(qxamax)(blasint *, xdouble *, blasint *);
+
+FLOATRET  BLASFUNC(samin) (blasint *, float  *, blasint *);
+double BLASFUNC(damin) (blasint *, double *, blasint *);
+xdouble BLASFUNC(qamin) (blasint *, xdouble *, blasint *);
+FLOATRET  BLASFUNC(scamin)(blasint *, float  *, blasint *);
+double BLASFUNC(dzamin)(blasint *, double *, blasint *);
+xdouble BLASFUNC(qxamin)(blasint *, xdouble *, blasint *);
+
+FLOATRET  BLASFUNC(smax)  (blasint *, float  *, blasint *);
+double BLASFUNC(dmax)  (blasint *, double *, blasint *);
+xdouble BLASFUNC(qmax)  (blasint *, xdouble *, blasint *);
+FLOATRET  BLASFUNC(scmax) (blasint *, float  *, blasint *);
+double BLASFUNC(dzmax) (blasint *, double *, blasint *);
+xdouble BLASFUNC(qxmax) (blasint *, xdouble *, blasint *);
+
+FLOATRET  BLASFUNC(smin)  (blasint *, float  *, blasint *);
+double BLASFUNC(dmin)  (blasint *, double *, blasint *);
+xdouble BLASFUNC(qmin)  (blasint *, xdouble *, blasint *);
+FLOATRET  BLASFUNC(scmin) (blasint *, float  *, blasint *);
+double BLASFUNC(dzmin) (blasint *, double *, blasint *);
+xdouble BLASFUNC(qxmin) (blasint *, xdouble *, blasint *);
+
+void    BLASFUNC(sscal) (blasint *,  float  *, float  *, blasint *);
+void    BLASFUNC(dscal) (blasint *,  double *, double *, blasint *);
+void    BLASFUNC(qscal) (blasint *,  xdouble *, xdouble *, blasint *);
+void    BLASFUNC(cscal) (blasint *,  float  *, float  *, blasint *);
+void    BLASFUNC(zscal) (blasint *,  double *, double *, blasint *);
+void    BLASFUNC(xscal) (blasint *,  xdouble *, xdouble *, blasint *);
+void    BLASFUNC(csscal)(blasint *,  float  *, float  *, blasint *);
+void    BLASFUNC(zdscal)(blasint *,  double *, double *, blasint *);
+void    BLASFUNC(xqscal)(blasint *,  xdouble *, xdouble *, blasint *);
+
+FLOATRET  BLASFUNC(snrm2) (blasint *, float  *, blasint *);
+FLOATRET  BLASFUNC(scnrm2)(blasint *, float  *, blasint *);
+
+double BLASFUNC(dnrm2) (blasint *, double *, blasint *);
+xdouble BLASFUNC(qnrm2) (blasint *, xdouble *, blasint *);
+double BLASFUNC(dznrm2)(blasint *, double *, blasint *);
+xdouble BLASFUNC(qxnrm2)(blasint *, xdouble *, blasint *);
+
+void  BLASFUNC(srot)  (blasint *, float  *, blasint *, float  *, blasint *, float  *, float  *);
+void  BLASFUNC(drot)  (blasint *, double *, blasint *, double *, blasint *, double *, double *);
+void  BLASFUNC(qrot)  (blasint *, xdouble *, blasint *, xdouble *, blasint *, xdouble *, xdouble *);
+void  BLASFUNC(csrot) (blasint *, float  *, blasint *, float  *, blasint *, float  *, float  *);
+void  BLASFUNC(zdrot) (blasint *, double *, blasint *, double *, blasint *, double *, double *);
+void  BLASFUNC(xqrot) (blasint *, xdouble *, blasint *, xdouble *, blasint *, xdouble *, xdouble *);
+
+void  BLASFUNC(srotg) (float  *, float  *, float  *, float  *);
+void  BLASFUNC(drotg) (double *, double *, double *, double *);
+void  BLASFUNC(qrotg) (xdouble *, xdouble *, xdouble *, xdouble *);
+void  BLASFUNC(crotg) (float  *, float  *, float  *, float  *);
+void  BLASFUNC(zrotg) (double *, double *, double *, double *);
+void  BLASFUNC(xrotg) (xdouble *, xdouble *, xdouble *, xdouble *);
+
+void  BLASFUNC(srotmg)(float  *, float  *, float  *, float  *, float  *);
+void  BLASFUNC(drotmg)(double *, double *, double *, double *, double *);
+
+void  BLASFUNC(srotm) (blasint *, float  *, blasint *, float  *, blasint *, float  *);
+void  BLASFUNC(drotm) (blasint *, double *, blasint *, double *, blasint *, double *);
+void  BLASFUNC(qrotm) (blasint *, xdouble *, blasint *, xdouble *, blasint *, xdouble *);
+
+/* Level 2 routines */
+
+void BLASFUNC(sger)(blasint *,    blasint *, float *,  float *, blasint *,
+		   float *,  blasint *, float *,  blasint *);
+void BLASFUNC(dger)(blasint *,    blasint *, double *, double *, blasint *,
+		   double *, blasint *, double *, blasint *);
+void BLASFUNC(qger)(blasint *,    blasint *, xdouble *, xdouble *, blasint *,
+		   xdouble *, blasint *, xdouble *, blasint *);
+void BLASFUNC(cgeru)(blasint *,    blasint *, float *,  float *, blasint *,
+		    float *,  blasint *, float *,  blasint *);
+void BLASFUNC(cgerc)(blasint *,    blasint *, float *,  float *, blasint *,
+		    float *,  blasint *, float *,  blasint *);
+void BLASFUNC(zgeru)(blasint *,    blasint *, double *, double *, blasint *,
+		    double *, blasint *, double *, blasint *);
+void BLASFUNC(zgerc)(blasint *,    blasint *, double *, double *, blasint *,
+		    double *, blasint *, double *, blasint *);
+void BLASFUNC(xgeru)(blasint *,    blasint *, xdouble *, xdouble *, blasint *,
+		    xdouble *, blasint *, xdouble *, blasint *);
+void BLASFUNC(xgerc)(blasint *,    blasint *, xdouble *, xdouble *, blasint *,
+		    xdouble *, blasint *, xdouble *, blasint *);
+
+void BLASFUNC(sgemv)(char *, blasint *, blasint *, float  *, float  *, blasint *,
+		    float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(dgemv)(char *, blasint *, blasint *, double *, double *, blasint *,
+		    double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(qgemv)(char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+		    xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+void BLASFUNC(cgemv)(char *, blasint *, blasint *, float  *, float  *, blasint *,
+		    float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(zgemv)(char *, blasint *, blasint *, double *, double *, blasint *,
+		    double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xgemv)(char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+		    xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(strsv) (char *, char *, char *, blasint *, float  *, blasint *,
+		     float  *, blasint *);
+void BLASFUNC(dtrsv) (char *, char *, char *, blasint *, double *, blasint *,
+		     double *, blasint *);
+void BLASFUNC(qtrsv) (char *, char *, char *, blasint *, xdouble *, blasint *,
+		     xdouble *, blasint *);
+void BLASFUNC(ctrsv) (char *, char *, char *, blasint *, float  *, blasint *,
+		     float  *, blasint *);
+void BLASFUNC(ztrsv) (char *, char *, char *, blasint *, double *, blasint *,
+		     double *, blasint *);
+void BLASFUNC(xtrsv) (char *, char *, char *, blasint *, xdouble *, blasint *,
+		     xdouble *, blasint *);
+
+void BLASFUNC(strmv) (char *, char *, char *, blasint *, float  *, blasint *,
+		     float  *, blasint *);
+void BLASFUNC(dtrmv) (char *, char *, char *, blasint *, double *, blasint *,
+		     double *, blasint *);
+void BLASFUNC(qtrmv) (char *, char *, char *, blasint *, xdouble *, blasint *,
+		     xdouble *, blasint *);
+void BLASFUNC(ctrmv) (char *, char *, char *, blasint *, float  *, blasint *,
+		     float  *, blasint *);
+void BLASFUNC(ztrmv) (char *, char *, char *, blasint *, double *, blasint *,
+		     double *, blasint *);
+void BLASFUNC(xtrmv) (char *, char *, char *, blasint *, xdouble *, blasint *,
+		     xdouble *, blasint *);
+
+void BLASFUNC(stpsv) (char *, char *, char *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(dtpsv) (char *, char *, char *, blasint *, double *, double *, blasint *);
+void BLASFUNC(qtpsv) (char *, char *, char *, blasint *, xdouble *, xdouble *, blasint *);
+void BLASFUNC(ctpsv) (char *, char *, char *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(ztpsv) (char *, char *, char *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xtpsv) (char *, char *, char *, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(stpmv) (char *, char *, char *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(dtpmv) (char *, char *, char *, blasint *, double *, double *, blasint *);
+void BLASFUNC(qtpmv) (char *, char *, char *, blasint *, xdouble *, xdouble *, blasint *);
+void BLASFUNC(ctpmv) (char *, char *, char *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(ztpmv) (char *, char *, char *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xtpmv) (char *, char *, char *, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(stbmv) (char *, char *, char *, blasint *, blasint *, float  *, blasint *, float  *, blasint *);
+void BLASFUNC(dtbmv) (char *, char *, char *, blasint *, blasint *, double *, blasint *, double *, blasint *);
+void BLASFUNC(qtbmv) (char *, char *, char *, blasint *, blasint *, xdouble *, blasint *, xdouble *, blasint *);
+void BLASFUNC(ctbmv) (char *, char *, char *, blasint *, blasint *, float  *, blasint *, float  *, blasint *);
+void BLASFUNC(ztbmv) (char *, char *, char *, blasint *, blasint *, double *, blasint *, double *, blasint *);
+void BLASFUNC(xtbmv) (char *, char *, char *, blasint *, blasint *, xdouble *, blasint *, xdouble *, blasint *);
+
+void BLASFUNC(stbsv) (char *, char *, char *, blasint *, blasint *, float  *, blasint *, float  *, blasint *);
+void BLASFUNC(dtbsv) (char *, char *, char *, blasint *, blasint *, double *, blasint *, double *, blasint *);
+void BLASFUNC(qtbsv) (char *, char *, char *, blasint *, blasint *, xdouble *, blasint *, xdouble *, blasint *);
+void BLASFUNC(ctbsv) (char *, char *, char *, blasint *, blasint *, float  *, blasint *, float  *, blasint *);
+void BLASFUNC(ztbsv) (char *, char *, char *, blasint *, blasint *, double *, blasint *, double *, blasint *);
+void BLASFUNC(xtbsv) (char *, char *, char *, blasint *, blasint *, xdouble *, blasint *, xdouble *, blasint *);
+
+void BLASFUNC(ssymv) (char *, blasint *, float  *, float *, blasint *,
+		     float  *, blasint *, float *, float *, blasint *);
+void BLASFUNC(dsymv) (char *, blasint *, double  *, double *, blasint *,
+		     double  *, blasint *, double *, double *, blasint *);
+void BLASFUNC(qsymv) (char *, blasint *, xdouble  *, xdouble *, blasint *,
+		     xdouble  *, blasint *, xdouble *, xdouble *, blasint *);
+void BLASFUNC(csymv) (char *, blasint *, float  *, float *, blasint *,
+		     float  *, blasint *, float *, float *, blasint *);
+void BLASFUNC(zsymv) (char *, blasint *, double  *, double *, blasint *,
+		     double  *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xsymv) (char *, blasint *, xdouble  *, xdouble *, blasint *,
+		     xdouble  *, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(sspmv) (char *, blasint *, float  *, float *,
+		     float  *, blasint *, float *, float *, blasint *);
+void BLASFUNC(dspmv) (char *, blasint *, double  *, double *,
+		     double  *, blasint *, double *, double *, blasint *);
+void BLASFUNC(qspmv) (char *, blasint *, xdouble  *, xdouble *,
+		     xdouble  *, blasint *, xdouble *, xdouble *, blasint *);
+void BLASFUNC(cspmv) (char *, blasint *, float  *, float *,
+		     float  *, blasint *, float *, float *, blasint *);
+void BLASFUNC(zspmv) (char *, blasint *, double  *, double *,
+		     double  *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xspmv) (char *, blasint *, xdouble  *, xdouble *,
+		     xdouble  *, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(ssyr) (char *, blasint *, float   *, float  *, blasint *,
+		    float  *, blasint *);
+void BLASFUNC(dsyr) (char *, blasint *, double  *, double *, blasint *,
+		    double *, blasint *);
+void BLASFUNC(qsyr) (char *, blasint *, xdouble  *, xdouble *, blasint *,
+		    xdouble *, blasint *);
+void BLASFUNC(csyr) (char *, blasint *, float   *, float  *, blasint *,
+		    float  *, blasint *);
+void BLASFUNC(zsyr) (char *, blasint *, double  *, double *, blasint *,
+		    double *, blasint *);
+void BLASFUNC(xsyr) (char *, blasint *, xdouble  *, xdouble *, blasint *,
+		    xdouble *, blasint *);
+
+void BLASFUNC(ssyr2) (char *, blasint *, float   *,
+		     float  *, blasint *, float  *, blasint *, float  *, blasint *);
+void BLASFUNC(dsyr2) (char *, blasint *, double  *,
+		     double *, blasint *, double *, blasint *, double *, blasint *);
+void BLASFUNC(qsyr2) (char *, blasint *, xdouble  *,
+		     xdouble *, blasint *, xdouble *, blasint *, xdouble *, blasint *);
+void BLASFUNC(csyr2) (char *, blasint *, float   *,
+		     float  *, blasint *, float  *, blasint *, float  *, blasint *);
+void BLASFUNC(zsyr2) (char *, blasint *, double  *,
+		     double *, blasint *, double *, blasint *, double *, blasint *);
+void BLASFUNC(xsyr2) (char *, blasint *, xdouble  *,
+		     xdouble *, blasint *, xdouble *, blasint *, xdouble *, blasint *);
+
+void BLASFUNC(sspr) (char *, blasint *, float   *, float  *, blasint *,
+		    float  *);
+void BLASFUNC(dspr) (char *, blasint *, double  *, double *, blasint *,
+		    double *);
+void BLASFUNC(qspr) (char *, blasint *, xdouble  *, xdouble *, blasint *,
+		    xdouble *);
+void BLASFUNC(cspr) (char *, blasint *, float   *, float  *, blasint *,
+		    float  *);
+void BLASFUNC(zspr) (char *, blasint *, double  *, double *, blasint *,
+		    double *);
+void BLASFUNC(xspr) (char *, blasint *, xdouble  *, xdouble *, blasint *,
+		    xdouble *);
+
+void BLASFUNC(sspr2) (char *, blasint *, float   *,
+		     float  *, blasint *, float  *, blasint *, float  *);
+void BLASFUNC(dspr2) (char *, blasint *, double  *,
+		     double *, blasint *, double *, blasint *, double *);
+void BLASFUNC(qspr2) (char *, blasint *, xdouble  *,
+		     xdouble *, blasint *, xdouble *, blasint *, xdouble *);
+void BLASFUNC(cspr2) (char *, blasint *, float   *,
+		     float  *, blasint *, float  *, blasint *, float  *);
+void BLASFUNC(zspr2) (char *, blasint *, double  *,
+		     double *, blasint *, double *, blasint *, double *);
+void BLASFUNC(xspr2) (char *, blasint *, xdouble  *,
+		     xdouble *, blasint *, xdouble *, blasint *, xdouble *);
+
+void BLASFUNC(cher) (char *, blasint *, float   *, float  *, blasint *,
+		    float  *, blasint *);
+void BLASFUNC(zher) (char *, blasint *, double  *, double *, blasint *,
+		    double *, blasint *);
+void BLASFUNC(xher) (char *, blasint *, xdouble  *, xdouble *, blasint *,
+		    xdouble *, blasint *);
+
+void BLASFUNC(chpr) (char *, blasint *, float   *, float  *, blasint *, float  *);
+void BLASFUNC(zhpr) (char *, blasint *, double  *, double *, blasint *, double *);
+void BLASFUNC(xhpr) (char *, blasint *, xdouble  *, xdouble *, blasint *, xdouble *);
+
+void BLASFUNC(cher2) (char *, blasint *, float   *,
+		     float  *, blasint *, float  *, blasint *, float  *, blasint *);
+void BLASFUNC(zher2) (char *, blasint *, double  *,
+		     double *, blasint *, double *, blasint *, double *, blasint *);
+void BLASFUNC(xher2) (char *, blasint *, xdouble  *,
+		     xdouble *, blasint *, xdouble *, blasint *, xdouble *, blasint *);
+
+void BLASFUNC(chpr2) (char *, blasint *, float   *,
+		     float  *, blasint *, float  *, blasint *, float  *);
+void BLASFUNC(zhpr2) (char *, blasint *, double  *,
+		     double *, blasint *, double *, blasint *, double *);
+void BLASFUNC(xhpr2) (char *, blasint *, xdouble  *,
+		     xdouble *, blasint *, xdouble *, blasint *, xdouble *);
+
+void BLASFUNC(chemv) (char *, blasint *, float  *, float *, blasint *,
+		     float  *, blasint *, float *, float *, blasint *);
+void BLASFUNC(zhemv) (char *, blasint *, double  *, double *, blasint *,
+		     double  *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xhemv) (char *, blasint *, xdouble  *, xdouble *, blasint *,
+		     xdouble  *, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(chpmv) (char *, blasint *, float  *, float *,
+		     float  *, blasint *, float *, float *, blasint *);
+void BLASFUNC(zhpmv) (char *, blasint *, double  *, double *,
+		     double  *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xhpmv) (char *, blasint *, xdouble  *, xdouble *,
+		     xdouble  *, blasint *, xdouble *, xdouble *, blasint *);
+
+int BLASFUNC(snorm)(char *, blasint *, blasint *, float  *, blasint *);
+int BLASFUNC(dnorm)(char *, blasint *, blasint *, double *, blasint *);
+int BLASFUNC(cnorm)(char *, blasint *, blasint *, float  *, blasint *);
+int BLASFUNC(znorm)(char *, blasint *, blasint *, double *, blasint *);
+
+void BLASFUNC(sgbmv)(char *, blasint *, blasint *, blasint *, blasint *, float  *, float  *, blasint *,
+		    float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(dgbmv)(char *, blasint *, blasint *, blasint *, blasint *, double *, double *, blasint *,
+		    double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(qgbmv)(char *, blasint *, blasint *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+		    xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+void BLASFUNC(cgbmv)(char *, blasint *, blasint *, blasint *, blasint *, float  *, float  *, blasint *,
+		    float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(zgbmv)(char *, blasint *, blasint *, blasint *, blasint *, double *, double *, blasint *,
+		    double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xgbmv)(char *, blasint *, blasint *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+		    xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(ssbmv)(char *, blasint *, blasint *, float  *, float  *, blasint *,
+		    float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(dsbmv)(char *, blasint *, blasint *, double *, double *, blasint *,
+		    double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(qsbmv)(char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+		    xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+void BLASFUNC(csbmv)(char *, blasint *, blasint *, float  *, float  *, blasint *,
+		    float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(zsbmv)(char *, blasint *, blasint *, double *, double *, blasint *,
+		    double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xsbmv)(char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+		    xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(chbmv)(char *, blasint *, blasint *, float  *, float  *, blasint *,
+		    float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(zhbmv)(char *, blasint *, blasint *, double *, double *, blasint *,
+		    double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xhbmv)(char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+		    xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+
+/* Level 3 routines */
+
+void BLASFUNC(sgemm)(char *, char *, blasint *, blasint *, blasint *, float *,
+	   float  *, blasint *, float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(dgemm)(char *, char *, blasint *, blasint *, blasint *, double *,
+	   double *, blasint *, double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(qgemm)(char *, char *, blasint *, blasint *, blasint *, xdouble *,
+	   xdouble *, blasint *, xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+void BLASFUNC(cgemm)(char *, char *, blasint *, blasint *, blasint *, float *,
+	   float  *, blasint *, float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(zgemm)(char *, char *, blasint *, blasint *, blasint *, double *,
+	   double *, blasint *, double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xgemm)(char *, char *, blasint *, blasint *, blasint *, xdouble *,
+	   xdouble *, blasint *, xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(cgemm3m)(char *, char *, blasint *, blasint *, blasint *, float *,
+	   float  *, blasint *, float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(zgemm3m)(char *, char *, blasint *, blasint *, blasint *, double *,
+	   double *, blasint *, double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xgemm3m)(char *, char *, blasint *, blasint *, blasint *, xdouble *,
+	   xdouble *, blasint *, xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+
+int BLASFUNC(sge2mm)(char *, char *, char *, blasint *, blasint *,
+		     float *, float  *, blasint *, float  *, blasint *,
+		     float *, float  *, blasint *);
+int BLASFUNC(dge2mm)(char *, char *, char *, blasint *, blasint *,
+		     double *, double  *, blasint *, double  *, blasint *,
+		     double *, double  *, blasint *);
+int BLASFUNC(cge2mm)(char *, char *, char *, blasint *, blasint *,
+		     float *, float  *, blasint *, float  *, blasint *,
+		     float *, float  *, blasint *);
+int BLASFUNC(zge2mm)(char *, char *, char *, blasint *, blasint *,
+		     double *, double  *, blasint *, double  *, blasint *,
+		     double *, double  *, blasint *);
+
+void BLASFUNC(strsm)(char *, char *, char *, char *, blasint *, blasint *,
+	   float *,  float *, blasint *, float *, blasint *);
+void BLASFUNC(dtrsm)(char *, char *, char *, char *, blasint *, blasint *,
+	   double *,  double *, blasint *, double *, blasint *);
+void BLASFUNC(qtrsm)(char *, char *, char *, char *, blasint *, blasint *,
+	   xdouble *,  xdouble *, blasint *, xdouble *, blasint *);
+void BLASFUNC(ctrsm)(char *, char *, char *, char *, blasint *, blasint *,
+	   float *,  float *, blasint *, float *, blasint *);
+void BLASFUNC(ztrsm)(char *, char *, char *, char *, blasint *, blasint *,
+	   double *,  double *, blasint *, double *, blasint *);
+void BLASFUNC(xtrsm)(char *, char *, char *, char *, blasint *, blasint *,
+	   xdouble *,  xdouble *, blasint *, xdouble *, blasint *);
+
+void BLASFUNC(strmm)(char *, char *, char *, char *, blasint *, blasint *,
+	   float *,  float *, blasint *, float *, blasint *);
+void BLASFUNC(dtrmm)(char *, char *, char *, char *, blasint *, blasint *,
+	   double *,  double *, blasint *, double *, blasint *);
+void BLASFUNC(qtrmm)(char *, char *, char *, char *, blasint *, blasint *,
+	   xdouble *,  xdouble *, blasint *, xdouble *, blasint *);
+void BLASFUNC(ctrmm)(char *, char *, char *, char *, blasint *, blasint *,
+	   float *,  float *, blasint *, float *, blasint *);
+void BLASFUNC(ztrmm)(char *, char *, char *, char *, blasint *, blasint *,
+	   double *,  double *, blasint *, double *, blasint *);
+void BLASFUNC(xtrmm)(char *, char *, char *, char *, blasint *, blasint *,
+	   xdouble *,  xdouble *, blasint *, xdouble *, blasint *);
+
+void BLASFUNC(ssymm)(char *, char *, blasint *, blasint *, float  *, float  *, blasint *,
+	   float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(dsymm)(char *, char *, blasint *, blasint *, double *, double *, blasint *,
+	   double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(qsymm)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+	   xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+void BLASFUNC(csymm)(char *, char *, blasint *, blasint *, float  *, float  *, blasint *,
+	   float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(zsymm)(char *, char *, blasint *, blasint *, double *, double *, blasint *,
+	   double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xsymm)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+	   xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(csymm3m)(char *, char *, blasint *, blasint *, float  *, float  *, blasint *,
+	   float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(zsymm3m)(char *, char *, blasint *, blasint *, double *, double *, blasint *,
+	   double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xsymm3m)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+	   xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(ssyrk)(char *, char *, blasint *, blasint *, float  *, float  *, blasint *,
+	   float  *, float  *, blasint *);
+void BLASFUNC(dsyrk)(char *, char *, blasint *, blasint *, double *, double *, blasint *,
+	   double *, double *, blasint *);
+void BLASFUNC(qsyrk)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+	   xdouble *, xdouble *, blasint *);
+void BLASFUNC(csyrk)(char *, char *, blasint *, blasint *, float  *, float  *, blasint *,
+	   float  *, float  *, blasint *);
+void BLASFUNC(zsyrk)(char *, char *, blasint *, blasint *, double *, double *, blasint *,
+	   double *, double *, blasint *);
+void BLASFUNC(xsyrk)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+	   xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(ssyr2k)(char *, char *, blasint *, blasint *, float  *, float  *, blasint *,
+	   float *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(dsyr2k)(char *, char *, blasint *, blasint *, double *, double *, blasint *,
+	   double*, blasint *, double *, double *, blasint *);
+void BLASFUNC(qsyr2k)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+	   xdouble*, blasint *, xdouble *, xdouble *, blasint *);
+void BLASFUNC(csyr2k)(char *, char *, blasint *, blasint *, float  *, float  *, blasint *,
+	   float *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(zsyr2k)(char *, char *, blasint *, blasint *, double *, double *, blasint *,
+	   double*, blasint *, double *, double *, blasint *);
+void BLASFUNC(xsyr2k)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+	   xdouble*, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(chemm)(char *, char *, blasint *, blasint *, float  *, float  *, blasint *,
+	   float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(zhemm)(char *, char *, blasint *, blasint *, double *, double *, blasint *,
+	   double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xhemm)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+	   xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(chemm3m)(char *, char *, blasint *, blasint *, float  *, float  *, blasint *,
+	   float  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(zhemm3m)(char *, char *, blasint *, blasint *, double *, double *, blasint *,
+	   double *, blasint *, double *, double *, blasint *);
+void BLASFUNC(xhemm3m)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+	   xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(cherk)(char *, char *, blasint *, blasint *, float  *, float  *, blasint *,
+	   float  *, float  *, blasint *);
+void BLASFUNC(zherk)(char *, char *, blasint *, blasint *, double *, double *, blasint *,
+	   double *, double *, blasint *);
+void BLASFUNC(xherk)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+	   xdouble *, xdouble *, blasint *);
+
+void BLASFUNC(cher2k)(char *, char *, blasint *, blasint *, float  *, float  *, blasint *,
+	   float *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(zher2k)(char *, char *, blasint *, blasint *, double *, double *, blasint *,
+	   double*, blasint *, double *, double *, blasint *);
+void BLASFUNC(xher2k)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+	   xdouble*, blasint *, xdouble *, xdouble *, blasint *);
+
+int BLASFUNC(cher2m)(char *, char *, char *, blasint *, blasint *, float  *, float  *, blasint *,
+	   float *, blasint *, float  *, float  *, blasint *);
+int BLASFUNC(zher2m)(char *, char *, char *, blasint *, blasint *, double *, double *, blasint *,
+	   double*, blasint *, double *, double *, blasint *);
+int BLASFUNC(xher2m)(char *, char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *,
+	   xdouble*, blasint *, xdouble *, xdouble *, blasint *);
+
+int BLASFUNC(sgemt)(char *, blasint *, blasint *, float  *, float  *, blasint *,
+		    float  *, blasint *);
+int BLASFUNC(dgemt)(char *, blasint *, blasint *, double *, double *, blasint *,
+		    double *, blasint *);
+int BLASFUNC(cgemt)(char *, blasint *, blasint *, float  *, float  *, blasint *,
+		    float  *, blasint *);
+int BLASFUNC(zgemt)(char *, blasint *, blasint *, double *, double *, blasint *,
+		    double *, blasint *);
+
+int BLASFUNC(sgema)(char *, char *, blasint *, blasint *, float  *,
+		    float  *, blasint *, float *, float  *, blasint *, float *, blasint *);
+int BLASFUNC(dgema)(char *, char *, blasint *, blasint *, double *,
+		    double *, blasint *, double*, double *, blasint *, double*, blasint *);
+int BLASFUNC(cgema)(char *, char *, blasint *, blasint *, float  *,
+		    float  *, blasint *, float *, float  *, blasint *, float *, blasint *);
+int BLASFUNC(zgema)(char *, char *, blasint *, blasint *, double *,
+		    double *, blasint *, double*, double *, blasint *, double*, blasint *);
+
+int BLASFUNC(sgems)(char *, char *, blasint *, blasint *, float  *,
+		    float  *, blasint *, float *, float  *, blasint *, float *, blasint *);
+int BLASFUNC(dgems)(char *, char *, blasint *, blasint *, double *,
+		    double *, blasint *, double*, double *, blasint *, double*, blasint *);
+int BLASFUNC(cgems)(char *, char *, blasint *, blasint *, float  *,
+		    float  *, blasint *, float *, float  *, blasint *, float *, blasint *);
+int BLASFUNC(zgems)(char *, char *, blasint *, blasint *, double *,
+		    double *, blasint *, double*, double *, blasint *, double*, blasint *);
+
+int BLASFUNC(sgemc)(char *, char *, blasint *, blasint *, blasint *, float *,
+	   float  *, blasint *, float  *, blasint *, float  *, blasint *, float  *, float  *, blasint *);
+int BLASFUNC(dgemc)(char *, char *, blasint *, blasint *, blasint *, double *,
+	   double *, blasint *, double *, blasint *, double *, blasint *, double *, double *, blasint *);
+int BLASFUNC(qgemc)(char *, char *, blasint *, blasint *, blasint *, xdouble *,
+	   xdouble *, blasint *, xdouble *, blasint *, xdouble *, blasint *,  xdouble *, xdouble *, blasint *);
+int BLASFUNC(cgemc)(char *, char *, blasint *, blasint *, blasint *, float *,
+	   float  *, blasint *, float  *, blasint *, float  *, blasint *, float  *, float  *, blasint *);
+int BLASFUNC(zgemc)(char *, char *, blasint *, blasint *, blasint *, double *,
+	   double *, blasint *, double *, blasint *, double *, blasint *, double *, double *, blasint *);
+int BLASFUNC(xgemc)(char *, char *, blasint *, blasint *, blasint *, xdouble *,
+	   xdouble *, blasint *, xdouble *, blasint *, xdouble *, blasint *, xdouble *, xdouble *, blasint *);
+
+/* Lapack routines */
+
+int BLASFUNC(sgetf2)(blasint *, blasint *, float  *, blasint *, blasint *, blasint *);
+int BLASFUNC(dgetf2)(blasint *, blasint *, double *, blasint *, blasint *, blasint *);
+int BLASFUNC(qgetf2)(blasint *, blasint *, xdouble *, blasint *, blasint *, blasint *);
+int BLASFUNC(cgetf2)(blasint *, blasint *, float  *, blasint *, blasint *, blasint *);
+int BLASFUNC(zgetf2)(blasint *, blasint *, double *, blasint *, blasint *, blasint *);
+int BLASFUNC(xgetf2)(blasint *, blasint *, xdouble *, blasint *, blasint *, blasint *);
+
+int BLASFUNC(sgetrf)(blasint *, blasint *, float  *, blasint *, blasint *, blasint *);
+int BLASFUNC(dgetrf)(blasint *, blasint *, double *, blasint *, blasint *, blasint *);
+int BLASFUNC(qgetrf)(blasint *, blasint *, xdouble *, blasint *, blasint *, blasint *);
+int BLASFUNC(cgetrf)(blasint *, blasint *, float  *, blasint *, blasint *, blasint *);
+int BLASFUNC(zgetrf)(blasint *, blasint *, double *, blasint *, blasint *, blasint *);
+int BLASFUNC(xgetrf)(blasint *, blasint *, xdouble *, blasint *, blasint *, blasint *);
+
+int BLASFUNC(slaswp)(blasint *, float  *, blasint *, blasint *, blasint *, blasint *, blasint *);
+int BLASFUNC(dlaswp)(blasint *, double *, blasint *, blasint *, blasint *, blasint *, blasint *);
+int BLASFUNC(qlaswp)(blasint *, xdouble *, blasint *, blasint *, blasint *, blasint *, blasint *);
+int BLASFUNC(claswp)(blasint *, float  *, blasint *, blasint *, blasint *, blasint *, blasint *);
+int BLASFUNC(zlaswp)(blasint *, double *, blasint *, blasint *, blasint *, blasint *, blasint *);
+int BLASFUNC(xlaswp)(blasint *, xdouble *, blasint *, blasint *, blasint *, blasint *, blasint *);
+
+int BLASFUNC(sgetrs)(char *, blasint *, blasint *, float  *, blasint *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(dgetrs)(char *, blasint *, blasint *, double *, blasint *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(qgetrs)(char *, blasint *, blasint *, xdouble *, blasint *, blasint *, xdouble *, blasint *, blasint *);
+int BLASFUNC(cgetrs)(char *, blasint *, blasint *, float  *, blasint *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(zgetrs)(char *, blasint *, blasint *, double *, blasint *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(xgetrs)(char *, blasint *, blasint *, xdouble *, blasint *, blasint *, xdouble *, blasint *, blasint *);
+
+int BLASFUNC(sgesv)(blasint *, blasint *, float  *, blasint *, blasint *, float *, blasint *, blasint *);
+int BLASFUNC(dgesv)(blasint *, blasint *, double *, blasint *, blasint *, double*, blasint *, blasint *);
+int BLASFUNC(qgesv)(blasint *, blasint *, xdouble *, blasint *, blasint *, xdouble*, blasint *, blasint *);
+int BLASFUNC(cgesv)(blasint *, blasint *, float  *, blasint *, blasint *, float *, blasint *, blasint *);
+int BLASFUNC(zgesv)(blasint *, blasint *, double *, blasint *, blasint *, double*, blasint *, blasint *);
+int BLASFUNC(xgesv)(blasint *, blasint *, xdouble *, blasint *, blasint *, xdouble*, blasint *, blasint *);
+
+int BLASFUNC(spotf2)(char *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(dpotf2)(char *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(qpotf2)(char *, blasint *, xdouble *, blasint *, blasint *);
+int BLASFUNC(cpotf2)(char *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(zpotf2)(char *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(xpotf2)(char *, blasint *, xdouble *, blasint *, blasint *);
+
+int BLASFUNC(spotrf)(char *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(dpotrf)(char *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(qpotrf)(char *, blasint *, xdouble *, blasint *, blasint *);
+int BLASFUNC(cpotrf)(char *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(zpotrf)(char *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(xpotrf)(char *, blasint *, xdouble *, blasint *, blasint *);
+
+int BLASFUNC(spotrs)(char *, blasint *, blasint *, float   *, blasint *, float   *, blasint *, blasint *);
+int BLASFUNC(dpotrs)(char *, blasint *, blasint *, double  *, blasint *, double  *, blasint *, blasint *);
+int BLASFUNC(qpotrs)(char *, blasint *, blasint *, xdouble *, blasint *, xdouble *, blasint *, blasint *);
+int BLASFUNC(cpotrs)(char *, blasint *, blasint *, float   *, blasint *, float   *, blasint *, blasint *);
+int BLASFUNC(zpotrs)(char *, blasint *, blasint *, double  *, blasint *, double  *, blasint *, blasint *);
+int BLASFUNC(xpotrs)(char *, blasint *, blasint *, xdouble *, blasint *, xdouble *, blasint *, blasint *);
+
+int BLASFUNC(slauu2)(char *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(dlauu2)(char *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(qlauu2)(char *, blasint *, xdouble *, blasint *, blasint *);
+int BLASFUNC(clauu2)(char *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(zlauu2)(char *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(xlauu2)(char *, blasint *, xdouble *, blasint *, blasint *);
+
+int BLASFUNC(slauum)(char *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(dlauum)(char *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(qlauum)(char *, blasint *, xdouble *, blasint *, blasint *);
+int BLASFUNC(clauum)(char *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(zlauum)(char *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(xlauum)(char *, blasint *, xdouble *, blasint *, blasint *);
+
+int BLASFUNC(strti2)(char *, char *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(dtrti2)(char *, char *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(qtrti2)(char *, char *, blasint *, xdouble *, blasint *, blasint *);
+int BLASFUNC(ctrti2)(char *, char *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(ztrti2)(char *, char *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(xtrti2)(char *, char *, blasint *, xdouble *, blasint *, blasint *);
+
+int BLASFUNC(strtri)(char *, char *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(dtrtri)(char *, char *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(qtrtri)(char *, char *, blasint *, xdouble *, blasint *, blasint *);
+int BLASFUNC(ctrtri)(char *, char *, blasint *, float  *, blasint *, blasint *);
+int BLASFUNC(ztrtri)(char *, char *, blasint *, double *, blasint *, blasint *);
+int BLASFUNC(xtrtri)(char *, char *, blasint *, xdouble *, blasint *, blasint *);
+
+
+FLOATRET  BLASFUNC(slamch)(char *);
+double    BLASFUNC(dlamch)(char *);
+xdouble   BLASFUNC(qlamch)(char *);
+
+FLOATRET  BLASFUNC(slamc3)(float *, float *);
+double    BLASFUNC(dlamc3)(double *, double *);
+xdouble   BLASFUNC(qlamc3)(xdouble *, xdouble *);
+
+/* BLAS extensions */
+
+void    BLASFUNC(saxpby) (blasint *, float  *, float  *, blasint *, float *, float  *, blasint *);
+void    BLASFUNC(daxpby) (blasint *, double  *, double  *, blasint *, double *, double  *, blasint *);
+void    BLASFUNC(caxpby) (blasint *, float  *, float  *, blasint *, float *, float  *, blasint *);
+void    BLASFUNC(zaxpby) (blasint *, double  *, double  *, blasint *, double *, double  *, blasint *);
+
+void    BLASFUNC(somatcopy) (char *, char *, blasint *, blasint *, float  *, float  *, blasint *, float  *, blasint *);
+void    BLASFUNC(domatcopy) (char *, char *, blasint *, blasint *, double  *, double  *, blasint *, double  *, blasint *);
+void    BLASFUNC(comatcopy) (char *, char *, blasint *, blasint *, float  *, float  *, blasint *, float  *, blasint *);
+void    BLASFUNC(zomatcopy) (char *, char *, blasint *, blasint *, double  *, double  *, blasint *, double  *, blasint *);
+
+void    BLASFUNC(simatcopy) (char *, char *, blasint *, blasint *, float  *, float  *, blasint *, blasint *);
+void    BLASFUNC(dimatcopy) (char *, char *, blasint *, blasint *, double  *, double  *, blasint *, blasint *);
+void    BLASFUNC(cimatcopy) (char *, char *, blasint *, blasint *, float  *, float  *, blasint *, blasint *);
+void    BLASFUNC(zimatcopy) (char *, char *, blasint *, blasint *, double  *, double  *, blasint *, blasint *);
+
+void    BLASFUNC(sgeadd) (blasint *, blasint *, float *, float *, blasint *, float *, float *, blasint*); 
+void    BLASFUNC(dgeadd) (blasint *, blasint *, double *, double *, blasint *, double *, double *, blasint*); 
+void    BLASFUNC(cgeadd) (blasint *, blasint *, float *, float *, blasint *, float *, float *, blasint*); 
+void    BLASFUNC(zgeadd) (blasint *, blasint *, double *, double *, blasint *, double *, double *, blasint*); 
+
+
+#ifdef __cplusplus
+}
+
+#endif  /* __cplusplus */
+
+#endif
+#endif

lib/3rdParty/OpenBLAS/include/lapacke_config.h

@@ -0,0 +1,126 @@
+/*****************************************************************************
+  Copyright (c) 2010, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+******************************************************************************
+* Contents: Native C interface to LAPACK
+* Author: Intel Corporation
+* Generated May, 2011
+*****************************************************************************/
+
+#ifndef _LAPACKE_CONFIG_H_
+#define _LAPACKE_CONFIG_H_
+
+// For Android prior to API 21 (no <complex> include)
+#if defined(__ANDROID__)
+#if __ANDROID_API__ < 21
+#define LAPACK_COMPLEX_STRUCTURE
+#endif
+#endif
+
+#ifdef __cplusplus
+#if defined(LAPACK_COMPLEX_CPP)
+#include <complex>
+#endif
+extern "C" {
+#endif /* __cplusplus */
+
+#include <stdlib.h>
+
+#ifndef lapack_int
+#if defined(LAPACK_ILP64)
+#define lapack_int              long
+#else
+#define lapack_int              int
+#endif
+#endif
+
+#ifndef lapack_logical
+#define lapack_logical          lapack_int
+#endif
+
+#ifndef LAPACK_COMPLEX_CUSTOM
+
+#if defined(LAPACK_COMPLEX_STRUCTURE)
+
+typedef struct { float real, imag; } _lapack_complex_float;
+typedef struct { double real, imag; } _lapack_complex_double;
+#define lapack_complex_float  _lapack_complex_float
+#define lapack_complex_double _lapack_complex_double
+#define lapack_complex_float_real(z)  ((z).real)
+#define lapack_complex_float_imag(z)  ((z).imag)
+#define lapack_complex_double_real(z)  ((z).real)
+#define lapack_complex_double_imag(z)  ((z).imag)
+
+#elif defined(LAPACK_COMPLEX_C99)
+
+#include <complex.h>
+#define lapack_complex_float    float _Complex
+#define lapack_complex_double   double _Complex
+#define lapack_complex_float_real(z)       (creal(z))
+#define lapack_complex_float_imag(z)       (cimag(z))
+#define lapack_complex_double_real(z)       (creal(z))
+#define lapack_complex_double_imag(z)       (cimag(z))
+
+#elif defined(LAPACK_COMPLEX_CPP)
+
+#define lapack_complex_float std::complex<float>
+#define lapack_complex_double std::complex<double>
+#define lapack_complex_float_real(z)       ((z).real())
+#define lapack_complex_float_imag(z)       ((z).imag())
+#define lapack_complex_double_real(z)       ((z).real())
+#define lapack_complex_double_imag(z)       ((z).imag())
+
+#else
+
+#include <complex.h>
+#define lapack_complex_float    float _Complex
+#define lapack_complex_double   double _Complex
+#define lapack_complex_float_real(z)       (creal(z))
+#define lapack_complex_float_imag(z)       (cimag(z))
+#define lapack_complex_double_real(z)       (creal(z))
+#define lapack_complex_double_imag(z)       (cimag(z))
+
+#endif
+
+lapack_complex_float lapack_make_complex_float( float re, float im );
+lapack_complex_double lapack_make_complex_double( double re, double im );
+
+#endif
+
+#ifndef LAPACK_malloc
+#define LAPACK_malloc( size )   malloc( size )
+#endif
+
+#ifndef LAPACK_free
+#define LAPACK_free( p )        free( p )
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _LAPACKE_CONFIG_H_ */

lib/3rdParty/OpenBLAS/include/lapacke_mangling.h

@@ -0,0 +1,17 @@
+#ifndef LAPACK_HEADER_INCLUDED
+#define LAPACK_HEADER_INCLUDED
+
+#ifndef LAPACK_GLOBAL
+#if defined(LAPACK_GLOBAL_PATTERN_LC) || defined(ADD_)
+#define LAPACK_GLOBAL(lcname,UCNAME)  lcname##_
+#elif defined(LAPACK_GLOBAL_PATTERN_UC) || defined(UPPER)
+#define LAPACK_GLOBAL(lcname,UCNAME)  UCNAME
+#elif defined(LAPACK_GLOBAL_PATTERN_MC) || defined(NOCHANGE)
+#define LAPACK_GLOBAL(lcname,UCNAME)  lcname
+#else
+#define LAPACK_GLOBAL(lcname,UCNAME)  lcname##_
+#endif
+#endif
+
+#endif
+

lib/3rdParty/OpenBLAS/include/lapacke_utils.h

@@ -0,0 +1,579 @@
+/*****************************************************************************
+  Copyright (c) 2014, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+******************************************************************************
+* Contents: Native C interface to LAPACK utility functions
+* Author: Intel Corporation
+* Created in January, 2010
+*****************************************************************************/
+
+#ifndef _LAPACKE_UTILS_H_
+#define _LAPACKE_UTILS_H_
+
+#include "lapacke.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#ifndef ABS
+#define ABS(x) (((x) < 0) ? -(x) : (x))
+#endif
+#ifndef MAX
+#define MAX(x,y) (((x) > (y)) ? (x) : (y))
+#endif
+#ifndef MIN
+#define MIN(x,y) (((x) < (y)) ? (x) : (y))
+#endif
+#ifndef MAX3
+#define MAX3(x,y,z) (((x) > MAX(y,z)) ? (x) : MAX(y,z))
+#endif
+#ifndef MIN3
+#define MIN3(x,y,z) (((x) < MIN(y,z)) ? (x) : MIN(y,z))
+#endif
+
+#define IS_S_NONZERO(x) ( (x) < 0 || (x) > 0 )
+#define IS_D_NONZERO(x) ( (x) < 0 || (x) > 0 )
+#define IS_C_NONZERO(x) ( IS_S_NONZERO(*((float*)&x)) ||  \
+                          IS_S_NONZERO(*(((float*)&x)+1)) )
+#define IS_Z_NONZERO(x) ( IS_D_NONZERO(*((double*)&x)) || \
+                          IS_D_NONZERO(*(((double*)&x)+1)) )
+
+/* Error handler */
+void LAPACKE_xerbla( const char *name, lapack_int info );
+
+/* Compare two chars (case-insensitive) */
+lapack_logical LAPACKE_lsame( char ca,  char cb );
+
+/* Functions to convert column-major to row-major 2d arrays and vice versa. */
+void LAPACKE_cgb_trans( int matrix_layout, lapack_int m, lapack_int n,
+                        lapack_int kl, lapack_int ku,
+                        const lapack_complex_float *in, lapack_int ldin,
+                        lapack_complex_float *out, lapack_int ldout );
+void LAPACKE_cge_trans( int matrix_layout, lapack_int m, lapack_int n,
+                        const lapack_complex_float* in, lapack_int ldin,
+                        lapack_complex_float* out, lapack_int ldout );
+void LAPACKE_cgg_trans( int matrix_layout, lapack_int m, lapack_int n,
+                        const lapack_complex_float* in, lapack_int ldin,
+                        lapack_complex_float* out, lapack_int ldout );
+void LAPACKE_chb_trans( int matrix_layout, char uplo, lapack_int n,
+                        lapack_int kd,
+                        const lapack_complex_float *in, lapack_int ldin,
+                        lapack_complex_float *out, lapack_int ldout );
+void LAPACKE_che_trans( int matrix_layout, char uplo, lapack_int n,
+                        const lapack_complex_float *in, lapack_int ldin,
+                        lapack_complex_float *out, lapack_int ldout );
+void LAPACKE_chp_trans( int matrix_layout, char uplo, lapack_int n,
+                        const lapack_complex_float *in,
+                        lapack_complex_float *out );
+void LAPACKE_chs_trans( int matrix_layout, lapack_int n,
+                        const lapack_complex_float *in, lapack_int ldin,
+                        lapack_complex_float *out, lapack_int ldout );
+void LAPACKE_cpb_trans( int matrix_layout, char uplo, lapack_int n,
+                        lapack_int kd,
+                        const lapack_complex_float *in, lapack_int ldin,
+                        lapack_complex_float *out, lapack_int ldout );
+void LAPACKE_cpf_trans( int matrix_layout, char transr, char uplo,
+                        lapack_int n, const lapack_complex_float *in,
+                        lapack_complex_float *out );
+void LAPACKE_cpo_trans( int matrix_layout, char uplo, lapack_int n,
+                        const lapack_complex_float *in, lapack_int ldin,
+                        lapack_complex_float *out, lapack_int ldout );
+void LAPACKE_cpp_trans( int matrix_layout, char uplo, lapack_int n,
+                        const lapack_complex_float *in,
+                        lapack_complex_float *out );
+void LAPACKE_csp_trans( int matrix_layout, char uplo, lapack_int n,
+                        const lapack_complex_float *in,
+                        lapack_complex_float *out );
+void LAPACKE_csy_trans( int matrix_layout, char uplo, lapack_int n,
+                        const lapack_complex_float *in, lapack_int ldin,
+                        lapack_complex_float *out, lapack_int ldout );
+void LAPACKE_ctb_trans( int matrix_layout, char uplo, char diag,
+                        lapack_int n, lapack_int kd,
+                        const lapack_complex_float *in, lapack_int ldin,
+                        lapack_complex_float *out, lapack_int ldout );
+void LAPACKE_ctf_trans( int matrix_layout, char transr, char uplo, char diag,
+                        lapack_int n, const lapack_complex_float *in,
+                        lapack_complex_float *out );
+void LAPACKE_ctp_trans( int matrix_layout, char uplo, char diag,
+                        lapack_int n, const lapack_complex_float *in,
+                        lapack_complex_float *out );
+void LAPACKE_ctr_trans( int matrix_layout, char uplo, char diag, lapack_int n,
+                        const lapack_complex_float *in, lapack_int ldin,
+                        lapack_complex_float *out, lapack_int ldout );
+
+void LAPACKE_dgb_trans( int matrix_layout, lapack_int m, lapack_int n,
+                        lapack_int kl, lapack_int ku,
+                        const double *in, lapack_int ldin,
+                        double *out, lapack_int ldout );
+void LAPACKE_dge_trans( int matrix_layout, lapack_int m, lapack_int n,
+                        const double* in, lapack_int ldin,
+                        double* out, lapack_int ldout );
+void LAPACKE_dgg_trans( int matrix_layout, lapack_int m, lapack_int n,
+                        const double* in, lapack_int ldin,
+                        double* out, lapack_int ldout );
+void LAPACKE_dhs_trans( int matrix_layout, lapack_int n,
+                        const double *in, lapack_int ldin,
+                        double *out, lapack_int ldout );
+void LAPACKE_dpb_trans( int matrix_layout, char uplo, lapack_int n,
+                        lapack_int kd,
+                        const double *in, lapack_int ldin,
+                        double *out, lapack_int ldout );
+void LAPACKE_dpf_trans( int matrix_layout, char transr, char uplo,
+                        lapack_int n, const double *in,
+                        double *out );
+void LAPACKE_dpo_trans( int matrix_layout, char uplo, lapack_int n,
+                        const double *in, lapack_int ldin,
+                        double *out, lapack_int ldout );
+void LAPACKE_dpp_trans( int matrix_layout, char uplo, lapack_int n,
+                        const double *in,
+                        double *out );
+void LAPACKE_dsb_trans( int matrix_layout, char uplo, lapack_int n,
+                        lapack_int kd,
+                        const double *in, lapack_int ldin,
+                        double *out, lapack_int ldout );
+void LAPACKE_dsp_trans( int matrix_layout, char uplo, lapack_int n,
+                        const double *in,
+                        double *out );
+void LAPACKE_dsy_trans( int matrix_layout, char uplo, lapack_int n,
+                        const double *in, lapack_int ldin,
+                        double *out, lapack_int ldout );
+void LAPACKE_dtb_trans( int matrix_layout, char uplo, char diag,
+                        lapack_int n, lapack_int kd,
+                        const double *in, lapack_int ldin,
+                        double *out, lapack_int ldout );
+void LAPACKE_dtf_trans( int matrix_layout, char transr, char uplo, char diag,
+                        lapack_int n, const double *in,
+                        double *out );
+void LAPACKE_dtp_trans( int matrix_layout, char uplo, char diag,
+                        lapack_int n, const double *in,
+                        double *out );
+void LAPACKE_dtr_trans( int matrix_layout, char uplo, char diag, lapack_int n,
+                        const double *in, lapack_int ldin,
+                        double *out, lapack_int ldout );
+
+void LAPACKE_sgb_trans( int matrix_layout, lapack_int m, lapack_int n,
+                        lapack_int kl, lapack_int ku,
+                        const float *in, lapack_int ldin,
+                        float *out, lapack_int ldout );
+void LAPACKE_sge_trans( int matrix_layout, lapack_int m, lapack_int n,
+                        const float* in, lapack_int ldin,
+                        float* out, lapack_int ldout );
+void LAPACKE_sgg_trans( int matrix_layout, lapack_int m, lapack_int n,
+                        const float* in, lapack_int ldin,
+                        float* out, lapack_int ldout );
+void LAPACKE_shs_trans( int matrix_layout, lapack_int n,
+                        const float *in, lapack_int ldin,
+                        float *out, lapack_int ldout );
+void LAPACKE_spb_trans( int matrix_layout, char uplo, lapack_int n,
+                        lapack_int kd,
+                        const float *in, lapack_int ldin,
+                        float *out, lapack_int ldout );
+void LAPACKE_spf_trans( int matrix_layout, char transr, char uplo,
+                        lapack_int n, const float *in,
+                        float *out );
+void LAPACKE_spo_trans( int matrix_layout, char uplo, lapack_int n,
+                        const float *in, lapack_int ldin,
+                        float *out, lapack_int ldout );
+void LAPACKE_spp_trans( int matrix_layout, char uplo, lapack_int n,
+                        const float *in,
+                        float *out );
+void LAPACKE_ssb_trans( int matrix_layout, char uplo, lapack_int n,
+                        lapack_int kd,
+                        const float *in, lapack_int ldin,
+                        float *out, lapack_int ldout );
+void LAPACKE_ssp_trans( int matrix_layout, char uplo, lapack_int n,
+                        const float *in,
+                        float *out );
+void LAPACKE_ssy_trans( int matrix_layout, char uplo, lapack_int n,
+                        const float *in, lapack_int ldin,
+                        float *out, lapack_int ldout );
+void LAPACKE_stb_trans( int matrix_layout, char uplo, char diag,
+                        lapack_int n, lapack_int kd,
+                        const float *in, lapack_int ldin,
+                        float *out, lapack_int ldout );
+void LAPACKE_stf_trans( int matrix_layout, char transr, char uplo, char diag,
+                        lapack_int n, const float *in,
+                        float *out );
+void LAPACKE_stp_trans( int matrix_layout, char uplo, char diag,
+                        lapack_int n, const float *in,
+                        float *out );
+void LAPACKE_str_trans( int matrix_layout, char uplo, char diag, lapack_int n,
+                        const float *in, lapack_int ldin,
+                        float *out, lapack_int ldout );
+
+void LAPACKE_zgb_trans( int matrix_layout, lapack_int m, lapack_int n,
+                        lapack_int kl, lapack_int ku,
+                        const lapack_complex_double *in, lapack_int ldin,
+                        lapack_complex_double *out, lapack_int ldout );
+void LAPACKE_zge_trans( int matrix_layout, lapack_int m, lapack_int n,
+                        const lapack_complex_double* in, lapack_int ldin,
+                        lapack_complex_double* out, lapack_int ldout );
+void LAPACKE_zgg_trans( int matrix_layout, lapack_int m, lapack_int n,
+                        const lapack_complex_double* in, lapack_int ldin,
+                        lapack_complex_double* out, lapack_int ldout );
+void LAPACKE_zhb_trans( int matrix_layout, char uplo, lapack_int n,
+                        lapack_int kd,
+                        const lapack_complex_double *in, lapack_int ldin,
+                        lapack_complex_double *out, lapack_int ldout );
+void LAPACKE_zhe_trans( int matrix_layout, char uplo, lapack_int n,
+                        const lapack_complex_double *in, lapack_int ldin,
+                        lapack_complex_double *out, lapack_int ldout );
+void LAPACKE_zhp_trans( int matrix_layout, char uplo, lapack_int n,
+                        const lapack_complex_double *in,
+                        lapack_complex_double *out );
+void LAPACKE_zhs_trans( int matrix_layout, lapack_int n,
+                        const lapack_complex_double *in, lapack_int ldin,
+                        lapack_complex_double *out, lapack_int ldout );
+void LAPACKE_zpb_trans( int matrix_layout, char uplo, lapack_int n,
+                        lapack_int kd,
+                        const lapack_complex_double *in, lapack_int ldin,
+                        lapack_complex_double *out, lapack_int ldout );
+void LAPACKE_zpf_trans( int matrix_layout, char transr, char uplo,
+                        lapack_int n, const lapack_complex_double *in,
+                        lapack_complex_double *out );
+void LAPACKE_zpo_trans( int matrix_layout, char uplo, lapack_int n,
+                        const lapack_complex_double *in, lapack_int ldin,
+                        lapack_complex_double *out, lapack_int ldout );
+void LAPACKE_zpp_trans( int matrix_layout, char uplo, lapack_int n,
+                        const lapack_complex_double *in,
+                        lapack_complex_double *out );
+void LAPACKE_zsp_trans( int matrix_layout, char uplo, lapack_int n,
+                        const lapack_complex_double *in,
+                        lapack_complex_double *out );
+void LAPACKE_zsy_trans( int matrix_layout, char uplo, lapack_int n,
+                        const lapack_complex_double *in, lapack_int ldin,
+                        lapack_complex_double *out, lapack_int ldout );
+void LAPACKE_ztb_trans( int matrix_layout, char uplo, char diag,
+                        lapack_int n, lapack_int kd,
+                        const lapack_complex_double *in, lapack_int ldin,
+                        lapack_complex_double *out, lapack_int ldout );
+void LAPACKE_ztf_trans( int matrix_layout, char transr, char uplo, char diag,
+                        lapack_int n, const lapack_complex_double *in,
+                        lapack_complex_double *out );
+void LAPACKE_ztp_trans( int matrix_layout, char uplo, char diag,
+                        lapack_int n, const lapack_complex_double *in,
+                        lapack_complex_double *out );
+void LAPACKE_ztr_trans( int matrix_layout, char uplo, char diag, lapack_int n,
+                        const lapack_complex_double *in, lapack_int ldin,
+                        lapack_complex_double *out, lapack_int ldout );
+
+/* NaN checkers */
+#define LAPACK_SISNAN( x ) ( x != x )
+#define LAPACK_DISNAN( x ) ( x != x )
+#define LAPACK_CISNAN( x ) ( LAPACK_SISNAN(*((float*) &x)) || \
+                              LAPACK_SISNAN(*(((float*) &x)+1)) )
+#define LAPACK_ZISNAN( x ) ( LAPACK_DISNAN(*((double*)&x)) || \
+                              LAPACK_DISNAN(*(((double*)&x)+1)) )
+
+/* NaN checkers for vectors */
+lapack_logical LAPACKE_c_nancheck( lapack_int n,
+                                    const lapack_complex_float *x,
+                                    lapack_int incx );
+lapack_logical LAPACKE_d_nancheck( lapack_int n,
+                                    const double *x,
+                                    lapack_int incx );
+lapack_logical LAPACKE_s_nancheck( lapack_int n,
+                                    const float *x,
+                                    lapack_int incx );
+lapack_logical LAPACKE_z_nancheck( lapack_int n,
+                                    const lapack_complex_double *x,
+                                    lapack_int incx );
+/* NaN checkers for matrices */
+lapack_logical LAPACKE_cgb_nancheck( int matrix_layout, lapack_int m,
+                                      lapack_int n, lapack_int kl,
+                                      lapack_int ku,
+                                      const lapack_complex_float *ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_cge_nancheck( int matrix_layout, lapack_int m,
+                                      lapack_int n,
+                                      const lapack_complex_float *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_cgg_nancheck( int matrix_layout, lapack_int m,
+                                      lapack_int n,
+                                      const lapack_complex_float *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_cgt_nancheck( lapack_int n,
+                                      const lapack_complex_float *dl,
+                                      const lapack_complex_float *d,
+                                      const lapack_complex_float *du );
+lapack_logical LAPACKE_chb_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n, lapack_int kd,
+                                      const lapack_complex_float* ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_che_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n,
+                                      const lapack_complex_float *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_chp_nancheck( lapack_int n,
+                                      const lapack_complex_float *ap );
+lapack_logical LAPACKE_chs_nancheck( int matrix_layout, lapack_int n,
+                                      const lapack_complex_float *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_cpb_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n, lapack_int kd,
+                                      const lapack_complex_float* ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_cpf_nancheck( lapack_int n,
+                                      const lapack_complex_float *a );
+lapack_logical LAPACKE_cpo_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n,
+                                      const lapack_complex_float *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_cpp_nancheck( lapack_int n,
+                                      const lapack_complex_float *ap );
+lapack_logical LAPACKE_cpt_nancheck( lapack_int n,
+                                      const float *d,
+                                      const lapack_complex_float *e );
+lapack_logical LAPACKE_csp_nancheck( lapack_int n,
+                                      const lapack_complex_float *ap );
+lapack_logical LAPACKE_cst_nancheck( lapack_int n,
+                                      const lapack_complex_float *d,
+                                      const lapack_complex_float *e );
+lapack_logical LAPACKE_csy_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n,
+                                      const lapack_complex_float *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_ctb_nancheck( int matrix_layout, char uplo, char diag,
+                                      lapack_int n, lapack_int kd,
+                                      const lapack_complex_float* ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_ctf_nancheck( int matrix_layout, char transr,
+                                      char uplo, char diag,
+                                      lapack_int n,
+                                      const lapack_complex_float *a );
+lapack_logical LAPACKE_ctp_nancheck( int matrix_layout, char uplo, char diag,
+                                      lapack_int n,
+                                      const lapack_complex_float *ap );
+lapack_logical LAPACKE_ctr_nancheck( int matrix_layout, char uplo, char diag,
+                                      lapack_int n,
+                                      const lapack_complex_float *a,
+                                      lapack_int lda );
+
+lapack_logical LAPACKE_dgb_nancheck( int matrix_layout, lapack_int m,
+                                      lapack_int n, lapack_int kl,
+                                      lapack_int ku,
+                                      const double *ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_dge_nancheck( int matrix_layout, lapack_int m,
+                                      lapack_int n,
+                                      const double *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_dgg_nancheck( int matrix_layout, lapack_int m,
+                                      lapack_int n,
+                                      const double *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_dgt_nancheck( lapack_int n,
+                                      const double *dl,
+                                      const double *d,
+                                      const double *du );
+lapack_logical LAPACKE_dhs_nancheck( int matrix_layout, lapack_int n,
+                                      const double *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_dpb_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n, lapack_int kd,
+                                      const double* ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_dpf_nancheck( lapack_int n,
+                                      const double *a );
+lapack_logical LAPACKE_dpo_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n,
+                                      const double *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_dpp_nancheck( lapack_int n,
+                                      const double *ap );
+lapack_logical LAPACKE_dpt_nancheck( lapack_int n,
+                                      const double *d,
+                                      const double *e );
+lapack_logical LAPACKE_dsb_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n, lapack_int kd,
+                                      const double* ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_dsp_nancheck( lapack_int n,
+                                      const double *ap );
+lapack_logical LAPACKE_dst_nancheck( lapack_int n,
+                                      const double *d,
+                                      const double *e );
+lapack_logical LAPACKE_dsy_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n,
+                                      const double *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_dtb_nancheck( int matrix_layout, char uplo, char diag,
+                                      lapack_int n, lapack_int kd,
+                                      const double* ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_dtf_nancheck( int matrix_layout, char transr,
+                                      char uplo, char diag,
+                                      lapack_int n,
+                                      const double *a );
+lapack_logical LAPACKE_dtp_nancheck( int matrix_layout, char uplo, char diag,
+                                      lapack_int n,
+                                      const double *ap );
+lapack_logical LAPACKE_dtr_nancheck( int matrix_layout, char uplo, char diag,
+                                      lapack_int n,
+                                      const double *a,
+                                      lapack_int lda );
+
+lapack_logical LAPACKE_sgb_nancheck( int matrix_layout, lapack_int m,
+                                      lapack_int n, lapack_int kl,
+                                      lapack_int ku,
+                                      const float *ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_sge_nancheck( int matrix_layout, lapack_int m,
+                                      lapack_int n,
+                                      const float *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_sgg_nancheck( int matrix_layout, lapack_int m,
+                                      lapack_int n,
+                                      const float *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_sgt_nancheck( lapack_int n,
+                                      const float *dl,
+                                      const float *d,
+                                      const float *du );
+lapack_logical LAPACKE_shs_nancheck( int matrix_layout, lapack_int n,
+                                      const float *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_spb_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n, lapack_int kd,
+                                      const float* ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_spf_nancheck( lapack_int n,
+                                      const float *a );
+lapack_logical LAPACKE_spo_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n,
+                                      const float *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_spp_nancheck( lapack_int n,
+                                      const float *ap );
+lapack_logical LAPACKE_spt_nancheck( lapack_int n,
+                                      const float *d,
+                                      const float *e );
+lapack_logical LAPACKE_ssb_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n, lapack_int kd,
+                                      const float* ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_ssp_nancheck( lapack_int n,
+                                      const float *ap );
+lapack_logical LAPACKE_sst_nancheck( lapack_int n,
+                                      const float *d,
+                                      const float *e );
+lapack_logical LAPACKE_ssy_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n,
+                                      const float *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_stb_nancheck( int matrix_layout, char uplo, char diag,
+                                      lapack_int n, lapack_int kd,
+                                      const float* ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_stf_nancheck( int matrix_layout, char transr,
+                                      char uplo, char diag,
+                                      lapack_int n,
+                                      const float *a );
+lapack_logical LAPACKE_stp_nancheck( int matrix_layout, char uplo, char diag,
+                                      lapack_int n,
+                                      const float *ap );
+lapack_logical LAPACKE_str_nancheck( int matrix_layout, char uplo, char diag,
+                                      lapack_int n,
+                                      const float *a,
+                                      lapack_int lda );
+
+lapack_logical LAPACKE_zgb_nancheck( int matrix_layout, lapack_int m,
+                                      lapack_int n, lapack_int kl,
+                                      lapack_int ku,
+                                      const lapack_complex_double *ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_zge_nancheck( int matrix_layout, lapack_int m,
+                                      lapack_int n,
+                                      const lapack_complex_double *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_zgg_nancheck( int matrix_layout, lapack_int m,
+                                      lapack_int n,
+                                      const lapack_complex_double *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_zgt_nancheck( lapack_int n,
+                                      const lapack_complex_double *dl,
+                                      const lapack_complex_double *d,
+                                      const lapack_complex_double *du );
+lapack_logical LAPACKE_zhb_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n, lapack_int kd,
+                                      const lapack_complex_double* ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_zhe_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n,
+                                      const lapack_complex_double *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_zhp_nancheck( lapack_int n,
+                                      const lapack_complex_double *ap );
+lapack_logical LAPACKE_zhs_nancheck( int matrix_layout, lapack_int n,
+                                      const lapack_complex_double *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_zpb_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n, lapack_int kd,
+                                      const lapack_complex_double* ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_zpf_nancheck( lapack_int n,
+                                      const lapack_complex_double *a );
+lapack_logical LAPACKE_zpo_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n,
+                                      const lapack_complex_double *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_zpp_nancheck( lapack_int n,
+                                      const lapack_complex_double *ap );
+lapack_logical LAPACKE_zpt_nancheck( lapack_int n,
+                                      const double *d,
+                                      const lapack_complex_double *e );
+lapack_logical LAPACKE_zsp_nancheck( lapack_int n,
+                                      const lapack_complex_double *ap );
+lapack_logical LAPACKE_zst_nancheck( lapack_int n,
+                                      const lapack_complex_double *d,
+                                      const lapack_complex_double *e );
+lapack_logical LAPACKE_zsy_nancheck( int matrix_layout, char uplo,
+                                      lapack_int n,
+                                      const lapack_complex_double *a,
+                                      lapack_int lda );
+lapack_logical LAPACKE_ztb_nancheck( int matrix_layout, char uplo, char diag,
+                                      lapack_int n, lapack_int kd,
+                                      const lapack_complex_double* ab,
+                                      lapack_int ldab );
+lapack_logical LAPACKE_ztf_nancheck( int matrix_layout, char transr,
+                                      char uplo, char diag,
+                                      lapack_int n,
+                                      const lapack_complex_double *a );
+lapack_logical LAPACKE_ztp_nancheck( int matrix_layout, char uplo, char diag,
+                                      lapack_int n,
+                                      const lapack_complex_double *ap );
+lapack_logical LAPACKE_ztr_nancheck( int matrix_layout, char uplo, char diag,
+                                      lapack_int n,
+                                      const lapack_complex_double *a,
+                                      lapack_int lda );
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif  /* _LAPACKE_UTILS_H_ */

lib/3rdParty/OpenBLAS/include/openblas_config.h

@@ -0,0 +1,126 @@
+#ifndef OPENBLAS_CONFIG_H
+#define OPENBLAS_CONFIG_H
+#define OPENBLAS_OS_WINNT 1
+#define OPENBLAS_ARCH_X86_64 1
+#define OPENBLAS_C_GCC 1
+#define OPENBLAS___64BIT__ 1
+#define OPENBLAS_PTHREAD_CREATE_FUNC pthread_create
+#define OPENBLAS_BUNDERSCORE _
+#define OPENBLAS_NEEDBUNDERSCORE 1
+#define OPENBLAS_NEHALEM 
+#define OPENBLAS_L1_DATA_SIZE 32768
+#define OPENBLAS_L1_DATA_LINESIZE 64
+#define OPENBLAS_L2_SIZE 262144
+#define OPENBLAS_L2_LINESIZE 64
+#define OPENBLAS_DTB_DEFAULT_ENTRIES 64
+#define OPENBLAS_DTB_SIZE 4096
+#define OPENBLAS_HAVE_CMOV 
+#define OPENBLAS_HAVE_MMX 
+#define OPENBLAS_HAVE_SSE 
+#define OPENBLAS_HAVE_SSE2 
+#define OPENBLAS_HAVE_SSE3 
+#define OPENBLAS_HAVE_SSSE3 
+#define OPENBLAS_HAVE_SSE4_1 
+#define OPENBLAS_HAVE_SSE4_2 
+#define OPENBLAS_CORE_NEHALEM 
+#define OPENBLAS_CHAR_CORENAME "NEHALEM"
+#define OPENBLAS_SLOCAL_BUFFER_SIZE 65536
+#define OPENBLAS_DLOCAL_BUFFER_SIZE 32768
+#define OPENBLAS_CLOCAL_BUFFER_SIZE 65536
+#define OPENBLAS_ZLOCAL_BUFFER_SIZE 32768
+#define OPENBLAS_GEMM_MULTITHREAD_THRESHOLD 4
+#define OPENBLAS_VERSION " OpenBLAS 0.2.19 "
+/*This is only for "make install" target.*/
+
+#if defined(OPENBLAS_OS_WINNT) || defined(OPENBLAS_OS_CYGWIN_NT) || defined(OPENBLAS_OS_INTERIX)
+#define OPENBLAS_WINDOWS_ABI
+#define OPENBLAS_OS_WINDOWS
+
+#ifdef DOUBLE
+#define DOUBLE_DEFINED DOUBLE
+#undef  DOUBLE
+#endif
+#endif
+
+#ifdef OPENBLAS_NEEDBUNDERSCORE
+#define BLASFUNC(FUNC) FUNC##_
+#else
+#define BLASFUNC(FUNC) FUNC
+#endif
+
+#ifdef OPENBLAS_QUAD_PRECISION
+typedef struct {
+  unsigned long x[2];
+}  xdouble;
+#elif defined OPENBLAS_EXPRECISION
+#define xdouble long double
+#else
+#define xdouble double
+#endif
+
+#if defined(OPENBLAS_OS_WINDOWS) && defined(OPENBLAS___64BIT__)
+typedef long long BLASLONG;
+typedef unsigned long long BLASULONG;
+#else
+typedef long BLASLONG;
+typedef unsigned long BLASULONG;
+#endif
+
+#ifdef OPENBLAS_USE64BITINT
+typedef BLASLONG blasint;
+#else
+typedef int blasint;
+#endif
+
+#if defined(XDOUBLE) || defined(DOUBLE)
+#define FLOATRET	FLOAT
+#else
+#ifdef NEED_F2CCONV
+#define FLOATRET	double
+#else
+#define FLOATRET	float
+#endif
+#endif
+
+/* Inclusion of a standard header file is needed for definition of __STDC_*
+   predefined macros with some compilers (e.g. GCC 4.7 on Linux).  This occurs
+   as a side effect of including either <features.h> or <stdc-predef.h>. */
+#include <stdio.h>
+
+/* C99 supports complex floating numbers natively, which GCC also offers as an
+   extension since version 3.0.  If neither are available, use a compatible
+   structure as fallback (see Clause 6.2.5.13 of the C99 standard). */
+#if ((defined(__STDC_IEC_559_COMPLEX__) || __STDC_VERSION__ >= 199901L || \
+      (__GNUC__ >= 3 && !defined(__cplusplus))) && !(defined(FORCE_OPENBLAS_COMPLEX_STRUCT)))
+  #define OPENBLAS_COMPLEX_C99
+#ifndef __cplusplus
+  #include <complex.h>
+#endif
+  typedef float _Complex openblas_complex_float;
+  typedef double _Complex openblas_complex_double;
+  typedef xdouble _Complex openblas_complex_xdouble;
+  #define openblas_make_complex_float(real, imag)    ((real) + ((imag) * _Complex_I))
+  #define openblas_make_complex_double(real, imag)   ((real) + ((imag) * _Complex_I))
+  #define openblas_make_complex_xdouble(real, imag)  ((real) + ((imag) * _Complex_I))
+  #define openblas_complex_float_real(z)             (creal(z))
+  #define openblas_complex_float_imag(z)             (cimag(z))
+  #define openblas_complex_double_real(z)            (creal(z))
+  #define openblas_complex_double_imag(z)            (cimag(z))
+  #define openblas_complex_xdouble_real(z)           (creal(z))
+  #define openblas_complex_xdouble_imag(z)           (cimag(z))
+#else
+  #define OPENBLAS_COMPLEX_STRUCT
+  typedef struct { float real, imag; } openblas_complex_float;
+  typedef struct { double real, imag; } openblas_complex_double;
+  typedef struct { xdouble real, imag; } openblas_complex_xdouble;
+  #define openblas_make_complex_float(real, imag)    {(real), (imag)}
+  #define openblas_make_complex_double(real, imag)   {(real), (imag)}
+  #define openblas_make_complex_xdouble(real, imag)  {(real), (imag)}
+  #define openblas_complex_float_real(z)             ((z).real)
+  #define openblas_complex_float_imag(z)             ((z).imag)
+  #define openblas_complex_double_real(z)            ((z).real)
+  #define openblas_complex_double_imag(z)            ((z).imag)
+  #define openblas_complex_xdouble_real(z)           ((z).real)
+  #define openblas_complex_xdouble_imag(z)           ((z).imag)
+#endif
+#endif /* OPENBLAS_CONFIG_H */

lib/3rdParty/OpenBLAS/readme.txt

@@ -0,0 +1,33 @@
+make QUIET_MAKE=1 TARGET=NEHALEM DYNAMIC_ARCH=1 HOSTCC=gcc NUM_THREADS=64 BINARY=64 CC=x86_64-w64-mingw32-gcc FC=x86_64-w64-mingw32-gfortran
+[INFO] : TIMER value: INT_ETIME (given by make.inc)
+[INFO] : TIMER value: INT_ETIME (given by make.inc)
+touch libopenblasp-r0.2.19.a
+make -s -j 16 -C test all
+make -s -j 16 -C utest all
+make -s -j 16 -C ctest all
+
+ OpenBLAS build complete. (BLAS CBLAS LAPACK LAPACKE)
+
+  OS               ... WINNT             
+  Architecture     ... x86_64               
+  BINARY           ... 64bit                 
+  C compiler       ... GCC  (command line : x86_64-w64-mingw32-gcc)
+  Fortran compiler ... GFORTRAN  (command line : x86_64-w64-mingw32-gfortran)
+  Library Name     ... libopenblasp-r0.2.19.a (Multi threaded; Max num-threads is 64)
+
+To install the library, you can run "make PREFIX=/path/to/your/installation install".
+
+├── bin
+│   └── libopenblas.dll       The shared library for Visual Studio and GCC.
+├── include
+│   ├── cblas.h
+│   ├── f77blas.h
+│   ├── lapacke_config.h
+│   ├── lapacke.h
+│   ├── lapacke_mangling.h
+│   ├── lapacke_utils.h
+│   └── openblas_config.h
+├── lib
+│   ├── libopenblas.a         The static library. Only work with GCC.
+│   └── libopenblas.dll.a     The import library for Visual Studio.
+└── readme.txt

lib/3rdParty/OpenBLAS/readme_2.txt

@@ -0,0 +1,14 @@
+Using the following OpenBLAS implementation - https://github.com/xianyi/OpenBLAS
+
+The pre-compiled library was acquired from (64 bit version):
+https://sourceforge.net/projects/openblas/files/v0.2.19/ 
+File - OpenBLAS-v0.2.19-Win64-int32.zip
+
+The pre-compiled library was acquired from (32 bit version):
+https://sourceforge.net/projects/openblas/files/v0.2.15/ 
+OpenBLAS-v0.2.15-Win32.zip
+
+Extra .dll dependencies from:
+https://sourceforge.net/projects/openblas/files/v0.2.14/
+
+Download the appropriate mingw zip files

lib/local/FaceAnalyser/FaceAnalyser.vcxproj

@@ -59,6 +59,7 @@
     <Import Project="..\..\3rdParty\OpenCV3.1\openCV3.1.props" />
     <Import Project="..\..\3rdParty\boost\boost_d.props" />
     <Import Project="..\..\3rdParty\tbb\tbb_d.props" />
+    <Import Project="..\..\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -66,6 +67,7 @@
     <Import Project="..\..\3rdParty\OpenCV3.1\openCV3.1.props" />
     <Import Project="..\..\3rdParty\boost\boost_d.props" />
     <Import Project="..\..\3rdParty\tbb\tbb_d.props" />
+    <Import Project="..\..\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -73,6 +75,7 @@
     <Import Project="..\..\3rdParty\tbb\tbb.props" />
     <Import Project="..\..\3rdParty\boost\boost.props" />
     <Import Project="..\..\3rdParty\OpenCV3.1\openCV3.1.props" />
+    <Import Project="..\..\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -80,6 +83,7 @@
     <Import Project="..\..\3rdParty\tbb\tbb.props" />
     <Import Project="..\..\3rdParty\boost\boost.props" />
     <Import Project="..\..\3rdParty\OpenCV3.1\openCV3.1.props" />
+    <Import Project="..\..\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

lib/local/FaceAnalyser/FaceAnalyser.vcxproj.filters

@@ -42,6 +42,15 @@
     <ClInclude Include="include\FaceAnalyserParameters.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="include\FaceAnalyserParameters.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="include\PAW.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="include\PDM.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="src\Face_utils.cpp">
@@ -71,5 +80,14 @@
     <ClCompile Include="src\FaceAnalyserParameters.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\FaceAnalyserParameters.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\PAW.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\PDM.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

lib/local/FaceAnalyser/include/FaceAnalyser.h

@@ -64,7 +64,7 @@ public:
 	// Constructor for FaceAnalyser using the parameters structure
 	FaceAnalyser(const FaceAnalysis::FaceAnalyserParameters& face_analyser_params);
 
-	void AddNextFrame(const cv::Mat& frame, const cv::Mat_<double>& detected_landmarks, bool success, double timestamp_seconds, bool online = false, bool visualise = true);
+	void AddNextFrame(const cv::Mat& frame, const cv::Mat_<float>& detected_landmarks, bool success, double timestamp_seconds, bool online = false, bool visualise = true);
 
 	cv::Mat GetLatestHOGDescriptorVisualisation();
 
@@ -77,7 +77,7 @@ public:
 
 	// A standalone call for predicting AUs from a static image, the first element in the pair represents occurence the second intensity
 	// This call is useful for detecting action units in images
-	std::pair<std::vector<std::pair<std::string, double>>, std::vector<std::pair<std::string, double>>> PredictStaticAUs(const cv::Mat& frame, const cv::Mat_<double>& detected_landmarks, bool visualise = true);
+	std::pair<std::vector<std::pair<std::string, double>>, std::vector<std::pair<std::string, double>>> PredictStaticAUs(const cv::Mat& frame, const cv::Mat_<float>& detected_landmarks, bool visualise = true);
 
 	void Reset();
 
@@ -105,7 +105,7 @@ public:
 		std::vector<double>& confidences, std::vector<bool>& successes, std::vector<double>& timestamps, bool dynamic);
 
 	// Helper function for post-processing AU output files
-	void FaceAnalyser::PostprocessOutputFile(std::string output_file);
+	void PostprocessOutputFile(std::string output_file);
 
 private:
 

lib/local/FaceAnalyser/include/Face_utils.h

@@ -46,8 +46,8 @@ namespace FaceAnalysis
 	// Defining a set of useful utility functions to be used within FaceAnalyser
 
 	// Aligning a face to a common reference frame
-	void AlignFace(cv::Mat& aligned_face, const cv::Mat& frame, const cv::Mat_<double>& detected_landmarks, cv::Vec6d params_global, const PDM& pdm, bool rigid = true, double scale = 0.6, int width = 96, int height = 96);
+	void AlignFace(cv::Mat& aligned_face, const cv::Mat& frame, const cv::Mat_<float>& detected_landmarks, cv::Vec6f params_global, const PDM& pdm, bool rigid = true, float scale = 0.6, int width = 96, int height = 96);
-	void AlignFaceMask(cv::Mat& aligned_face, const cv::Mat& frame, const cv::Mat_<double>& detected_landmarks, cv::Vec6d params_global, const PDM& pdm, const cv::Mat_<int>& triangulation, bool rigid = true, double scale = 0.6, int width = 96, int height = 96);
+	void AlignFaceMask(cv::Mat& aligned_face, const cv::Mat& frame, const cv::Mat_<float>& detected_landmarks, cv::Vec6f params_global, const PDM& pdm, const cv::Mat_<int>& triangulation, bool rigid = true, float scale = 0.6, int width = 96, int height = 96);
 
 	void Extract_FHOG_descriptor(cv::Mat_<double>& descriptor, const cv::Mat& image, int& num_rows, int& num_cols, int cell_size = 8);
 
@@ -62,32 +62,32 @@ namespace FaceAnalysis
 	//===========================================================================
 	// Using Kabsch's algorithm for aligning shapes
 	//This assumes that align_from and align_to are already mean normalised
-	cv::Matx22d AlignShapesKabsch2D(const cv::Mat_<double>& align_from, const cv::Mat_<double>& align_to);
+	cv::Matx22f AlignShapesKabsch2D(const cv::Mat_<float>& align_from, const cv::Mat_<float>& align_to);
 
 	//=============================================================================
 	// Basically Kabsch's algorithm but also allows the collection of points to be different in scale from each other
-	cv::Matx22d AlignShapesWithScale(cv::Mat_<double>& src, cv::Mat_<double> dst);
+	cv::Matx22f AlignShapesWithScale(cv::Mat_<float>& src, cv::Mat_<float> dst);
 
 	//===========================================================================
 	// Visualisation functions
 	//===========================================================================
-	void Project(cv::Mat_<double>& dest, const cv::Mat_<double>& mesh, double fx, double fy, double cx, double cy);
+	void Project(cv::Mat_<float>& dest, const cv::Mat_<float>& mesh, float fx, float fy, float cx, float cy);
 
 	//===========================================================================
 	// Angle representation conversion helpers
 	//===========================================================================
-	cv::Matx33d Euler2RotationMatrix(const cv::Vec3d& eulerAngles);
+	cv::Matx33f Euler2RotationMatrix(const cv::Vec3f& eulerAngles);
 	
 	// Using the XYZ convention R = Rx * Ry * Rz, left-handed positive sign
-	cv::Vec3d RotationMatrix2Euler(const cv::Matx33d& rotation_matrix);
+	cv::Vec3f RotationMatrix2Euler(const cv::Matx33f& rotation_matrix);
 
-	cv::Vec3d Euler2AxisAngle(const cv::Vec3d& euler);
+	cv::Vec3f Euler2AxisAngle(const cv::Vec3f& euler);
 
-	cv::Vec3d AxisAngle2Euler(const cv::Vec3d& axis_angle);
+	cv::Vec3f AxisAngle2Euler(const cv::Vec3f& axis_angle);
 
-	cv::Matx33d AxisAngle2RotationMatrix(const cv::Vec3d& axis_angle);
+	cv::Matx33f AxisAngle2RotationMatrix(const cv::Vec3f& axis_angle);
 
-	cv::Vec3d RotationMatrix2AxisAngle(const cv::Matx33d& rotation_matrix);
+	cv::Vec3f RotationMatrix2AxisAngle(const cv::Matx33f& rotation_matrix);
 
 	//============================================================================
 	// Matrix reading functionality

lib/local/FaceAnalyser/include/PAW.h

@@ -56,16 +56,16 @@ public:
     int     number_of_pixels; 
 
 	// Minimum x coordinate in destination
-    double  min_x;
+    float  min_x;
 
 	// minimum y coordinate in destination
-    double  min_y;
+	float  min_y;
 
 	// Destination points (landmarks to be warped to)
-	cv::Mat_<double> destination_landmarks;
+	cv::Mat_<float> destination_landmarks;
 
 	// Destination points (landmarks to be warped from)
-	cv::Mat_<double> source_landmarks;
+	cv::Mat_<float> source_landmarks;
 
 	// Triangulation, each triangle is warped using an affine transform
 	cv::Mat_<int> triangulation;
@@ -81,13 +81,13 @@ public:
 	// affine coefficients for all triangles (see Matthews and Baker 2004)
 	// 6 coefficients for each triangle (are computed from alpha and beta)
 	// This is computed during each warp based on source landmarks
-	cv::Mat_<double> coefficients;
+	cv::Mat_<float> coefficients;
 
 	// matrix of (c,x,y) coeffs for alpha
-	cv::Mat_<double> alpha;
+	cv::Mat_<float> alpha;
 
 	// matrix of (c,x,y) coeffs for alpha
-	cv::Mat_<double> beta;
+	cv::Mat_<float> beta;
 
 	// x-source of warped points
 	cv::Mat_<float> map_x;
@@ -99,10 +99,10 @@ public:
     PAW(){;}
 
 	// Construct a warp from a destination shape and triangulation
-	PAW(const cv::Mat_<double>& destination_shape, const cv::Mat_<int>& triangulation);
+	PAW(const cv::Mat_<float>& destination_shape, const cv::Mat_<int>& triangulation);
 
 	// The final optional argument allows for optimisation if the triangle indices from previous frame are known (for tracking in video)
-	PAW(const cv::Mat_<double>& destination_shape, const cv::Mat_<int>& triangulation, double in_min_x, double in_min_y, double in_max_x, double in_max_y);
+	PAW(const cv::Mat_<float>& destination_shape, const cv::Mat_<int>& triangulation, float in_min_x, float in_min_y, float in_max_x, float in_max_y);
 
 	// Copy constructor
 	PAW(const PAW& other);
@@ -110,7 +110,7 @@ public:
 	void Read(std::ifstream &s);
 
 	// The actual warping
-    void Warp(const cv::Mat& image_to_warp, cv::Mat& destination_image, const cv::Mat_<double>& landmarks_to_warp);
+    void Warp(const cv::Mat& image_to_warp, cv::Mat& destination_image, const cv::Mat_<float>& landmarks_to_warp);
 	
 	// Compute coefficients needed for warping
     void CalcCoeff();
@@ -128,9 +128,9 @@ public:
 private:
 
 	// Helper functions for dealing with triangles
-	static bool sameSide(double x0, double y0, double x1, double y1, double x2, double y2, double x3, double y3);
+	static bool sameSide(float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3);
-	static bool pointInTriangle(double x0, double y0, double x1, double y1, double x2, double y2, double x3, double y3);
+	static bool pointInTriangle(float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3);
-	static int findTriangle(const cv::Point_<double>& point, const std::vector<std::vector<double>>& control_points, int guess = -1);
+	static int findTriangle(const cv::Point_<float>& point, const std::vector<std::vector<float>>& control_points, int guess = -1);
 
   };
   //===========================================================================

lib/local/FaceAnalyser/include/PDM.h

@@ -53,13 +53,13 @@ class PDM{
 	public:    
     
 		// The 3D mean shape vector of the PDM [x1,..,xn,y1,...yn,z1,...,zn]
-		cv::Mat_<double> mean_shape;	
+		cv::Mat_<float> mean_shape;	
   
 		// Principal components or variation bases of the model, 
-		cv::Mat_<double> princ_comp;	
+		cv::Mat_<float> princ_comp;
 
 		// Eigenvalues (variances) corresponding to the bases
-		cv::Mat_<double> eigen_values;	
+		cv::Mat_<float> eigen_values;
 
 		PDM(){;}
 		
@@ -75,30 +75,30 @@ class PDM{
 		inline int NumberOfModes() const {return princ_comp.cols;}
 
 		// Compute shape in object space (3D)
-		void CalcShape3D(cv::Mat_<double>& out_shape, const cv::Mat_<double>& params_local) const;
+		void CalcShape3D(cv::Mat_<float>& out_shape, const cv::Mat_<float>& params_local) const;
 
 		// Compute shape in image space (2D)
-		void CalcShape2D(cv::Mat_<double>& out_shape, const cv::Mat_<double>& params_local, const cv::Vec6d& params_global) const;
+		void CalcShape2D(cv::Mat_<float>& out_shape, const cv::Mat_<float>& params_local, const cv::Vec6f& params_global) const;
     
 		// provided the bounding box of a face and the local parameters (with optional rotation), generates the global parameters that can generate the face with the provided bounding box
-		void CalcParams(cv::Vec6d& out_params_global, const cv::Rect_<double>& bounding_box, const cv::Mat_<double>& params_local, const cv::Vec3d rotation = cv::Vec3d(0.0)) const;
+		void CalcParams(cv::Vec6f& out_params_global, const cv::Rect_<float>& bounding_box, const cv::Mat_<float>& params_local, const cv::Vec3f rotation = cv::Vec3f(0.0f)) const;
 
 		// Provided the landmark location compute global and local parameters best fitting it (can provide optional rotation for potentially better results)
-		void CalcParams(cv::Vec6d& out_params_global, cv::Mat_<double>& out_params_local, const cv::Mat_<double>& landmark_locations, const cv::Vec3d rotation = cv::Vec3d(0.0)) const;
+		void CalcParams(cv::Vec6f& out_params_global, cv::Mat_<float>& out_params_local, const cv::Mat_<float>& landmark_locations, const cv::Vec3f rotation = cv::Vec3f(0.0f)) const;
 
 		// provided the model parameters, compute the bounding box of a face
-		void CalcBoundingBox(cv::Rect& out_bounding_box, const cv::Vec6d& params_global, const cv::Mat_<double>& params_local) const;
+		void CalcBoundingBox(cv::Rect_<float>& out_bounding_box, const cv::Vec6f& params_global, const cv::Mat_<float>& params_local) const;
 
 		// Helpers for computing Jacobians, and Jacobians with the weight matrix
-		void ComputeRigidJacobian(const cv::Mat_<float>& params_local, const cv::Vec6d& params_global, cv::Mat_<float> &Jacob, const cv::Mat_<float> W, cv::Mat_<float> &Jacob_t_w) const;
+		void ComputeRigidJacobian(const cv::Mat_<float>& params_local, const cv::Vec6f& params_global, cv::Mat_<float> &Jacob, const cv::Mat_<float> W, cv::Mat_<float> &Jacob_t_w) const;
-		void ComputeJacobian(const cv::Mat_<float>& params_local, const cv::Vec6d& params_global, cv::Mat_<float> &Jacobian, const cv::Mat_<float> W, cv::Mat_<float> &Jacob_t_w) const;
+		void ComputeJacobian(const cv::Mat_<float>& params_local, const cv::Vec6f& params_global, cv::Mat_<float> &Jacobian, const cv::Mat_<float> W, cv::Mat_<float> &Jacob_t_w) const;
 
 		// Given the current parameters, and the computed delta_p compute the updated parameters
-		void UpdateModelParameters(const cv::Mat_<float>& delta_p, cv::Mat_<float>& params_local, cv::Vec6d& params_global) const;
+		void UpdateModelParameters(const cv::Mat_<float>& delta_p, cv::Mat_<float>& params_local, cv::Vec6f& params_global) const;
 
 		// Helper utilities
 	private:
-		static void Orthonormalise(cv::Matx33d &R);
+		static void Orthonormalise(cv::Matx33f &R);
   };
   //===========================================================================
 }

lib/local/FaceAnalyser/src/FaceAnalyser.cpp

@@ -248,12 +248,12 @@ int GetViewId(const vector<cv::Vec3d> orientations_all, const cv::Vec3d& orienta
 	
 }
 
-std::pair<std::vector<std::pair<string, double>>, std::vector<std::pair<string, double>>> FaceAnalyser::PredictStaticAUs(const cv::Mat& frame, const cv::Mat_<double>& detected_landmarks, bool visualise)
+std::pair<std::vector<std::pair<string, double>>, std::vector<std::pair<string, double>>> FaceAnalyser::PredictStaticAUs(const cv::Mat& frame, const cv::Mat_<float>& detected_landmarks, bool visualise)
 {
 	
 	// Extract shape parameters from the detected landmarks
-	cv::Vec6d params_global;
+	cv::Vec6f params_global;
-	cv::Mat_<double> params_local;
+	cv::Mat_<float> params_local;
 	pdm.CalcParams(params_global, params_local, detected_landmarks);
 
 	// First align the face
@@ -269,11 +269,15 @@ std::pair<std::vector<std::pair<string, double>>, std::vector<std::pair<string,
 	cv::Vec3d curr_orient(params_global[1], params_global[2], params_global[3]);
 	int orientation_to_use = GetViewId(this->head_orientations, curr_orient);
 	
-	// Geom descriptor and its median
+	// Geom descriptor and its median, TODO these should be floats?
-	geom_descriptor_frame = params_local.t();
+	params_local = params_local.t();
+	params_local.convertTo(geom_descriptor_frame, CV_64F);
+	
+	cv::Mat_<double> princ_comp_d;
+	pdm.princ_comp.convertTo(princ_comp_d, CV_64F);
 
 	// Stack with the actual feature point locations (without mean)
-	cv::Mat_<double> locs = pdm.princ_comp * geom_descriptor_frame.t();
+	cv::Mat_<double> locs = princ_comp_d * geom_descriptor_frame.t();
 
 	cv::hconcat(locs.t(), geom_descriptor_frame.clone(), geom_descriptor_frame);
 	
@@ -306,14 +310,14 @@ std::pair<std::vector<std::pair<string, double>>, std::vector<std::pair<string,
 
 }
 
-void FaceAnalyser::AddNextFrame(const cv::Mat& frame, const cv::Mat_<double>& detected_landmarks, bool success, double timestamp_seconds, bool online, bool visualise)
+void FaceAnalyser::AddNextFrame(const cv::Mat& frame, const cv::Mat_<float>& detected_landmarks, bool success, double timestamp_seconds, bool online, bool visualise)
 {
 
 	frames_tracking++;
 
 	// Extract shape parameters from the detected landmarks
-	cv::Vec6d params_global;
+	cv::Vec6f params_global;
-	cv::Mat_<double> params_local;
+	cv::Mat_<float> params_local;
 	pdm.CalcParams(params_global, params_local, detected_landmarks);
 
 	// First align the face if tracking was successfull
@@ -398,7 +402,8 @@ void FaceAnalyser::AddNextFrame(const cv::Mat& frame, const cv::Mat_<double>& de
 	}	
 
 	// Geom descriptor and its median
-	geom_descriptor_frame = params_local.t();
+	params_local = params_local.t();
+	params_local.convertTo(geom_descriptor_frame, CV_64F);
 
 	if(!success)
 	{
@@ -406,7 +411,10 @@ void FaceAnalyser::AddNextFrame(const cv::Mat& frame, const cv::Mat_<double>& de
 	}
 
 	// Stack with the actual feature point locations (without mean)
-	cv::Mat_<double> locs = pdm.princ_comp * geom_descriptor_frame.t();
+	// TODO rem double
+	cv::Mat_<double> princ_comp_d;
+	pdm.princ_comp.convertTo(princ_comp_d, CV_64F);
+	cv::Mat_<double> locs = princ_comp_d * geom_descriptor_frame.t();
 	
 	cv::hconcat(locs.t(), geom_descriptor_frame.clone(), geom_descriptor_frame);
 	
@@ -1044,7 +1052,7 @@ void FaceAnalyser::Read(std::string model_loc)
 		else if (module.compare("PDM") == 0)
 		{
 			cout << "Reading the PDM from: " << location;
-			pdm = PDM::PDM();
+			pdm = PDM();
 			pdm.Read(location);
 			cout << "... Done" << endl;
 		}

lib/local/FaceAnalyser/src/FaceAnalyserParameters.cpp

@@ -61,12 +61,13 @@ FaceAnalyserParameters::FaceAnalyserParameters(string root_dir)
 }
 FaceAnalyserParameters::FaceAnalyserParameters(vector<string> &arguments):root()
 {
-	// initialise the default values
-	init();
 
 	// First element is reserved for the executable location (useful for finding relative model locs)
 	this->root = boost::filesystem::path(arguments[0]).parent_path();
 
+	// initialise the default values
+	init();
+
 	bool* valid = new bool[arguments.size()];
 	valid[0] = true;
 

lib/local/FaceAnalyser/src/Face_utils.cpp

@@ -50,12 +50,12 @@ namespace FaceAnalysis
 {
 
 	// Pick only the more stable/rigid points under changes of expression
-	void extract_rigid_points(cv::Mat_<double>& source_points, cv::Mat_<double>& destination_points)
+	void extract_rigid_points(cv::Mat_<float>& source_points, cv::Mat_<float>& destination_points)
 	{
 		if(source_points.rows == 68)
 		{
-			cv::Mat_<double> tmp_source = source_points.clone();
+			cv::Mat_<float> tmp_source = source_points.clone();
-			source_points = cv::Mat_<double>();
+			source_points = cv::Mat_<float>();
 
 			// Push back the rigid points (some face outline, eyes, and nose)
 			source_points.push_back(tmp_source.row(1));
@@ -83,8 +83,8 @@ namespace FaceAnalysis
 			source_points.push_back(tmp_source.row(46));
 			source_points.push_back(tmp_source.row(47));
 
-			cv::Mat_<double> tmp_dest = destination_points.clone();
+			cv::Mat_<float> tmp_dest = destination_points.clone();
-			destination_points = cv::Mat_<double>();
+			destination_points = cv::Mat_<float>();
 
 			// Push back the rigid points
 			destination_points.push_back(tmp_dest.row(1));
@@ -115,16 +115,16 @@ namespace FaceAnalysis
 	}
 
 	// Aligning a face to a common reference frame
-	void AlignFace(cv::Mat& aligned_face, const cv::Mat& frame, const cv::Mat_<double>& detected_landmarks, cv::Vec6d params_global, const PDM& pdm, bool rigid, double sim_scale, int out_width, int out_height)
+	void AlignFace(cv::Mat& aligned_face, const cv::Mat& frame, const cv::Mat_<float>& detected_landmarks, cv::Vec6d params_global, const PDM& pdm, bool rigid, float sim_scale, int out_width, int out_height)
 	{
 		// Will warp to scaled mean shape
-		cv::Mat_<double> similarity_normalised_shape = pdm.mean_shape * sim_scale;
+		cv::Mat_<float> similarity_normalised_shape = pdm.mean_shape * sim_scale;
 	
 		// Discard the z component
 		similarity_normalised_shape = similarity_normalised_shape(cv::Rect(0, 0, 1, 2*similarity_normalised_shape.rows/3)).clone();
 
-		cv::Mat_<double> source_landmarks = detected_landmarks.reshape(1, 2).t();
+		cv::Mat_<float> source_landmarks = detected_landmarks.reshape(1, 2).t();
-		cv::Mat_<double> destination_landmarks = similarity_normalised_shape.reshape(1, 2).t();
+		cv::Mat_<float> destination_landmarks = similarity_normalised_shape.reshape(1, 2).t();
 
 		// Aligning only the more rigid points
 		if(rigid)
@@ -132,6 +132,7 @@ namespace FaceAnalysis
 			extract_rigid_points(source_landmarks, destination_landmarks);
 		}
 
+		// TODO rem the doubles here
 		cv::Matx22d scale_rot_matrix = AlignShapesWithScale(source_landmarks, destination_landmarks);
 		cv::Matx23d warp_matrix;
 
@@ -154,16 +155,16 @@ namespace FaceAnalysis
 	}
 
 	// Aligning a face to a common reference frame
-	void AlignFaceMask(cv::Mat& aligned_face, const cv::Mat& frame, const cv::Mat_<double>& detected_landmarks, cv::Vec6d params_global, const PDM& pdm, const cv::Mat_<int>& triangulation, bool rigid, double sim_scale, int out_width, int out_height)
+	void AlignFaceMask(cv::Mat& aligned_face, const cv::Mat& frame, const cv::Mat_<float>& detected_landmarks, cv::Vec6f params_global, const PDM& pdm, const cv::Mat_<int>& triangulation, bool rigid, float sim_scale, int out_width, int out_height)
 	{
 		// Will warp to scaled mean shape
-		cv::Mat_<double> similarity_normalised_shape = pdm.mean_shape * sim_scale;
+		cv::Mat_<float> similarity_normalised_shape = pdm.mean_shape * sim_scale;
 	
 		// Discard the z component
 		similarity_normalised_shape = similarity_normalised_shape(cv::Rect(0, 0, 1, 2*similarity_normalised_shape.rows/3)).clone();
 
-		cv::Mat_<double> source_landmarks = detected_landmarks.reshape(1, 2).t();
+		cv::Mat_<float> source_landmarks = detected_landmarks.reshape(1, 2).t();
-		cv::Mat_<double> destination_landmarks = similarity_normalised_shape.reshape(1, 2).t();
+		cv::Mat_<float> destination_landmarks = similarity_normalised_shape.reshape(1, 2).t();
 
 		// Aligning only the more rigid points
 		if(rigid)
@@ -171,18 +172,18 @@ namespace FaceAnalysis
 			extract_rigid_points(source_landmarks, destination_landmarks);
 		}
 
-		cv::Matx22d scale_rot_matrix = AlignShapesWithScale(source_landmarks, destination_landmarks);
+		cv::Matx22f scale_rot_matrix = AlignShapesWithScale(source_landmarks, destination_landmarks);
-		cv::Matx23d warp_matrix;
+		cv::Matx23f warp_matrix;
 
 		warp_matrix(0,0) = scale_rot_matrix(0,0);
 		warp_matrix(0,1) = scale_rot_matrix(0,1);
 		warp_matrix(1,0) = scale_rot_matrix(1,0);
 		warp_matrix(1,1) = scale_rot_matrix(1,1);
 
-		double tx = params_global[4];
+		float tx = params_global[4];
-		double ty = params_global[5];
+		float ty = params_global[5];
 
-		cv::Vec2d T(tx, ty);
+		cv::Vec2f T(tx, ty);
 		T = scale_rot_matrix * T;
 
 		// Make sure centering is correct
@@ -192,7 +193,7 @@ namespace FaceAnalysis
 		cv::warpAffine(frame, aligned_face, warp_matrix, cv::Size(out_width, out_height), cv::INTER_LINEAR);
 
 		// Move the destination landmarks there as well
-		cv::Matx22d warp_matrix_2d(warp_matrix(0,0), warp_matrix(0,1), warp_matrix(1,0), warp_matrix(1,1));
+		cv::Matx22f warp_matrix_2d(warp_matrix(0,0), warp_matrix(0,1), warp_matrix(1,0), warp_matrix(1,1));
 		
 		destination_landmarks = cv::Mat(detected_landmarks.reshape(1, 2).t()) * cv::Mat(warp_matrix_2d).t();
 
@@ -200,19 +201,19 @@ namespace FaceAnalysis
 		destination_landmarks.col(1) = destination_landmarks.col(1) + warp_matrix(1,2);
 		
 		// Move the eyebrows up to include more of upper face
-		destination_landmarks.at<double>(0,1) -= (30/0.7)*sim_scale; 
+		destination_landmarks.at<float>(0,1) -= (30/0.7)*sim_scale;
-		destination_landmarks.at<double>(16,1) -= (30 / 0.7)*sim_scale;
+		destination_landmarks.at<float>(16,1) -= (30 / 0.7)*sim_scale;
 
-		destination_landmarks.at<double>(17,1) -= (30 / 0.7)*sim_scale;
+		destination_landmarks.at<float>(17,1) -= (30 / 0.7)*sim_scale;
-		destination_landmarks.at<double>(18,1) -= (30 / 0.7)*sim_scale;
+		destination_landmarks.at<float>(18,1) -= (30 / 0.7)*sim_scale;
-		destination_landmarks.at<double>(19,1) -= (30 / 0.7)*sim_scale;
+		destination_landmarks.at<float>(19,1) -= (30 / 0.7)*sim_scale;
-		destination_landmarks.at<double>(20,1) -= (30 / 0.7)*sim_scale;
+		destination_landmarks.at<float>(20,1) -= (30 / 0.7)*sim_scale;
-		destination_landmarks.at<double>(21,1) -= (30 / 0.7)*sim_scale;
+		destination_landmarks.at<float>(21,1) -= (30 / 0.7)*sim_scale;
-		destination_landmarks.at<double>(22,1) -= (30 / 0.7)*sim_scale;
+		destination_landmarks.at<float>(22,1) -= (30 / 0.7)*sim_scale;
-		destination_landmarks.at<double>(23,1) -= (30 / 0.7)*sim_scale;
+		destination_landmarks.at<float>(23,1) -= (30 / 0.7)*sim_scale;
-		destination_landmarks.at<double>(24,1) -= (30 / 0.7)*sim_scale;
+		destination_landmarks.at<float>(24,1) -= (30 / 0.7)*sim_scale;
-		destination_landmarks.at<double>(25,1) -= (30 / 0.7)*sim_scale;
+		destination_landmarks.at<float>(25,1) -= (30 / 0.7)*sim_scale;
-		destination_landmarks.at<double>(26,1) -= (30 / 0.7)*sim_scale;
+		destination_landmarks.at<float>(26,1) -= (30 / 0.7)*sim_scale;
 
 		destination_landmarks = cv::Mat(destination_landmarks.t()).reshape(1, 1).t();
 
@@ -363,16 +364,16 @@ namespace FaceAnalysis
 	//===========================================================================
 	// Using Kabsch's algorithm for aligning shapes
 	//This assumes that align_from and align_to are already mean normalised
-	cv::Matx22d AlignShapesKabsch2D(const cv::Mat_<double>& align_from, const cv::Mat_<double>& align_to)
+	cv::Matx22f AlignShapesKabsch2D(const cv::Mat_<float>& align_from, const cv::Mat_<float>& align_to)
 	{
 
 		cv::SVD svd(align_from.t() * align_to);
 
 		// make sure no reflection is there
 		// corr ensures that we do only rotaitons and not reflections
-		double d = cv::determinant(svd.vt.t() * svd.u.t());
+		float d = cv::determinant(svd.vt.t() * svd.u.t());
 
-		cv::Matx22d corr = cv::Matx22d::eye();
+		cv::Matx22f corr = cv::Matx22f::eye();
 		if (d > 0)
 		{
 			corr(1, 1) = 1;
@@ -382,7 +383,7 @@ namespace FaceAnalysis
 			corr(1, 1) = -1;
 		}
 
-		cv::Matx22d R;
+		cv::Matx22f R;
 		cv::Mat(svd.vt.t()*cv::Mat(corr)*svd.u.t()).copyTo(R);
 
 		return R;
@@ -390,22 +391,22 @@ namespace FaceAnalysis
 
 	//=============================================================================
 	// Basically Kabsch's algorithm but also allows the collection of points to be different in scale from each other
-	cv::Matx22d AlignShapesWithScale(cv::Mat_<double>& src, cv::Mat_<double> dst)
+	cv::Matx22f AlignShapesWithScale(cv::Mat_<float>& src, cv::Mat_<float> dst)
 	{
 		int n = src.rows;
 
 		// First we mean normalise both src and dst
-		double mean_src_x = cv::mean(src.col(0))[0];
+		float mean_src_x = cv::mean(src.col(0))[0];
-		double mean_src_y = cv::mean(src.col(1))[0];
+		float mean_src_y = cv::mean(src.col(1))[0];
 
-		double mean_dst_x = cv::mean(dst.col(0))[0];
+		float mean_dst_x = cv::mean(dst.col(0))[0];
-		double mean_dst_y = cv::mean(dst.col(1))[0];
+		float mean_dst_y = cv::mean(dst.col(1))[0];
 
-		cv::Mat_<double> src_mean_normed = src.clone();
+		cv::Mat_<float> src_mean_normed = src.clone();
 		src_mean_normed.col(0) = src_mean_normed.col(0) - mean_src_x;
 		src_mean_normed.col(1) = src_mean_normed.col(1) - mean_src_y;
 
-		cv::Mat_<double> dst_mean_normed = dst.clone();
+		cv::Mat_<float> dst_mean_normed = dst.clone();
 		dst_mean_normed.col(0) = dst_mean_normed.col(0) - mean_dst_x;
 		dst_mean_normed.col(1) = dst_mean_normed.col(1) - mean_dst_y;
 
@@ -416,25 +417,25 @@ namespace FaceAnalysis
 		cv::Mat dst_sq;
 		cv::pow(dst_mean_normed, 2, dst_sq);
 
-		double s_src = sqrt(cv::sum(src_sq)[0] / n);
+		float s_src = sqrt(cv::sum(src_sq)[0] / n);
-		double s_dst = sqrt(cv::sum(dst_sq)[0] / n);
+		float s_dst = sqrt(cv::sum(dst_sq)[0] / n);
 
 		src_mean_normed = src_mean_normed / s_src;
 		dst_mean_normed = dst_mean_normed / s_dst;
 
-		double s = s_dst / s_src;
+		float s = s_dst / s_src;
 
 		// Get the rotation
-		cv::Matx22d R = AlignShapesKabsch2D(src_mean_normed, dst_mean_normed);
+		cv::Matx22f R = AlignShapesKabsch2D(src_mean_normed, dst_mean_normed);
 
-		cv::Matx22d	A;
+		cv::Matx22f	A;
 		cv::Mat(s * R).copyTo(A);
 
-		cv::Mat_<double> aligned = (cv::Mat(cv::Mat(A) * src.t())).t();
+		cv::Mat_<float> aligned = (cv::Mat(cv::Mat(A) * src.t())).t();
-		cv::Mat_<double> offset = dst - aligned;
+		cv::Mat_<float> offset = dst - aligned;
 
-		double t_x = cv::mean(offset.col(0))[0];
+		float t_x = cv::mean(offset.col(0))[0];
-		double t_y = cv::mean(offset.col(1))[0];
+		float t_y = cv::mean(offset.col(1))[0];
 
 		return A;
 
@@ -444,17 +445,17 @@ namespace FaceAnalysis
 	//===========================================================================
 	// Visualisation functions
 	//===========================================================================
-	void Project(cv::Mat_<double>& dest, const cv::Mat_<double>& mesh, double fx, double fy, double cx, double cy)
+	void Project(cv::Mat_<float>& dest, const cv::Mat_<float>& mesh, float fx, float fy, float cx, float cy)
 	{
-		dest = cv::Mat_<double>(mesh.rows, 2, 0.0);
+		dest = cv::Mat_<float>(mesh.rows, 2, 0.0);
 
 		int num_points = mesh.rows;
 
-		double X, Y, Z;
+		float X, Y, Z;
 
 
-		cv::Mat_<double>::const_iterator mData = mesh.begin();
+		cv::Mat_<float>::const_iterator mData = mesh.begin();
-		cv::Mat_<double>::iterator projected = dest.begin();
+		cv::Mat_<float>::iterator projected = dest.begin();
 
 		for (int i = 0; i < num_points; i++)
 		{
@@ -463,8 +464,8 @@ namespace FaceAnalysis
 			Y = *(mData++);
 			Z = *(mData++);
 
-			double x;
+			float x;
-			double y;
+			float y;
 
 			// if depth is 0 the projection is different
 			if (Z != 0)
@@ -484,22 +485,23 @@ namespace FaceAnalysis
 		}
 
 	}
+
 	//===========================================================================
 	// Angle representation conversion helpers
 	//===========================================================================
 
 	// Using the XYZ convention R = Rx * Ry * Rz, left-handed positive sign
-	cv::Matx33d Euler2RotationMatrix(const cv::Vec3d& eulerAngles)
+	cv::Matx33f Euler2RotationMatrix(const cv::Vec3f& eulerAngles)
 	{
-		cv::Matx33d rotation_matrix;
+		cv::Matx33f rotation_matrix;
 
-		double s1 = sin(eulerAngles[0]);
+		float s1 = sin(eulerAngles[0]);
-		double s2 = sin(eulerAngles[1]);
+		float s2 = sin(eulerAngles[1]);
-		double s3 = sin(eulerAngles[2]);
+		float s3 = sin(eulerAngles[2]);
 
-		double c1 = cos(eulerAngles[0]);
+		float c1 = cos(eulerAngles[0]);
-		double c2 = cos(eulerAngles[1]);
+		float c2 = cos(eulerAngles[1]);
-		double c3 = cos(eulerAngles[2]);
+		float c3 = cos(eulerAngles[2]);
 
 		rotation_matrix(0, 0) = c2 * c3;
 		rotation_matrix(0, 1) = -c2 *s3;
@@ -515,52 +517,51 @@ namespace FaceAnalysis
 	}
 	
 	// Using the XYZ convention R = Rx * Ry * Rz, left-handed positive sign
-	cv::Vec3d RotationMatrix2Euler(const cv::Matx33d& rotation_matrix)
+	cv::Vec3f RotationMatrix2Euler(const cv::Matx33f& rotation_matrix)
 	{
-		double q0 = sqrt(1 + rotation_matrix(0, 0) + rotation_matrix(1, 1) + rotation_matrix(2, 2)) / 2.0;
+		float q0 = sqrt(1 + rotation_matrix(0, 0) + rotation_matrix(1, 1) + rotation_matrix(2, 2)) / 2.0f;
-		double q1 = (rotation_matrix(2, 1) - rotation_matrix(1, 2)) / (4.0*q0);
+		float q1 = (rotation_matrix(2, 1) - rotation_matrix(1, 2)) / (4.0f*q0);
-		double q2 = (rotation_matrix(0, 2) - rotation_matrix(2, 0)) / (4.0*q0);
+		float q2 = (rotation_matrix(0, 2) - rotation_matrix(2, 0)) / (4.0f*q0);
-		double q3 = (rotation_matrix(1, 0) - rotation_matrix(0, 1)) / (4.0*q0);
+		float q3 = (rotation_matrix(1, 0) - rotation_matrix(0, 1)) / (4.0f*q0);
 
-		double t1 = 2.0 * (q0*q2 + q1*q3);
+		float t1 = 2.0f * (q0*q2 + q1*q3);
 
-		double yaw = asin(2.0 * (q0*q2 + q1*q3));
+		float yaw = asin(2.0 * (q0*q2 + q1*q3));
-		double pitch = atan2(2.0 * (q0*q1 - q2*q3), q0*q0 - q1*q1 - q2*q2 + q3*q3);
+		float pitch = atan2(2.0 * (q0*q1 - q2*q3), q0*q0 - q1*q1 - q2*q2 + q3*q3);
-		double roll = atan2(2.0 * (q0*q3 - q1*q2), q0*q0 + q1*q1 - q2*q2 - q3*q3);
+		float roll = atan2(2.0 * (q0*q3 - q1*q2), q0*q0 + q1*q1 - q2*q2 - q3*q3);
 
-		return cv::Vec3d(pitch, yaw, roll);
+		return cv::Vec3f(pitch, yaw, roll);
 	}
 
-	cv::Vec3d Euler2AxisAngle(const cv::Vec3d& euler)
+	cv::Vec3f Euler2AxisAngle(const cv::Vec3f& euler)
 	{
-		cv::Matx33d rotMatrix = Euler2RotationMatrix(euler);
+		cv::Matx33f rotMatrix = Euler2RotationMatrix(euler);
-		cv::Vec3d axis_angle;
+		cv::Vec3f axis_angle;
 		cv::Rodrigues(rotMatrix, axis_angle);
 		return axis_angle;
 	}
 
-	cv::Vec3d AxisAngle2Euler(const cv::Vec3d& axis_angle)
+	cv::Vec3f AxisAngle2Euler(const cv::Vec3f& axis_angle)
 	{
-		cv::Matx33d rotation_matrix;
+		cv::Matx33f rotation_matrix;
 		cv::Rodrigues(axis_angle, rotation_matrix);
 		return RotationMatrix2Euler(rotation_matrix);
 	}
 
-	cv::Matx33d AxisAngle2RotationMatrix(const cv::Vec3d& axis_angle)
+	cv::Matx33f AxisAngle2RotationMatrix(const cv::Vec3f& axis_angle)
 	{
-		cv::Matx33d rotation_matrix;
+		cv::Matx33f rotation_matrix;
 		cv::Rodrigues(axis_angle, rotation_matrix);
 		return rotation_matrix;
 	}
 
-	cv::Vec3d RotationMatrix2AxisAngle(const cv::Matx33d& rotation_matrix)
+	cv::Vec3f RotationMatrix2AxisAngle(const cv::Matx33f& rotation_matrix)
 	{
-		cv::Vec3d axis_angle;
+		cv::Vec3f axis_angle;
 		cv::Rodrigues(rotation_matrix, axis_angle);
 		return axis_angle;
 	}
 
-
 	//============================================================================
 	// Matrix reading functionality
 	//============================================================================

lib/local/FaceAnalyser/src/PAW.cpp

@@ -53,7 +53,7 @@ triangle_id(other.triangle_id.clone()), pixel_mask(other.pixel_mask.clone()), co
 }
 
 // A constructor from destination shape and triangulation
-PAW::PAW(const cv::Mat_<double>& destination_shape, const cv::Mat_<int>& triangulation)
+PAW::PAW(const cv::Mat_<float>& destination_shape, const cv::Mat_<int>& triangulation)
 {
 	// Initialise some variables directly
 	this->destination_landmarks = destination_shape;
@@ -64,14 +64,14 @@ PAW::PAW(const cv::Mat_<double>& destination_shape, const cv::Mat_<int>& triangu
 	int num_tris = triangulation.rows;
 	
 	// Pre-compute the rest
-    alpha = cv::Mat_<double>(num_tris, 3);
+    alpha = cv::Mat_<float>(num_tris, 3);
-    beta = cv::Mat_<double>(num_tris, 3);
+    beta = cv::Mat_<float>(num_tris, 3);
     
-	cv::Mat_<double> xs = destination_shape(cv::Rect(0, 0, 1, num_points));
+	cv::Mat_<float> xs = destination_shape(cv::Rect(0, 0, 1, num_points));
-	cv::Mat_<double> ys = destination_shape(cv::Rect(0, num_points, 1, num_points));
+	cv::Mat_<float> ys = destination_shape(cv::Rect(0, num_points, 1, num_points));
     
 	// Create a vector representation of the control points
-	std::vector<std::vector<double>> destination_points;
+	std::vector<std::vector<float>> destination_points;
 
 	for (int tri = 0; tri < num_tris; ++tri)
 	{	
@@ -79,43 +79,43 @@ PAW::PAW(const cv::Mat_<double>& destination_shape, const cv::Mat_<int>& triangu
 		int k = triangulation.at<int>(tri, 1);
 		int l = triangulation.at<int>(tri, 2);
 
-        double c1 = ys.at<double>(l) - ys.at<double>(j);
+		float c1 = ys.at<float>(l) - ys.at<float>(j);
-        double c2 = xs.at<double>(l) - xs.at<double>(j);
+		float c2 = xs.at<float>(l) - xs.at<float>(j);
-        double c4 = ys.at<double>(k) - ys.at<double>(j);
+		float c4 = ys.at<float>(k) - ys.at<float>(j);
-        double c3 = xs.at<double>(k) - xs.at<double>(j);
+		float c3 = xs.at<float>(k) - xs.at<float>(j);
         		
-        double c5 = c3*c1 - c2*c4;
+		float c5 = c3*c1 - c2*c4;
 
-        alpha.at<double>(tri, 0) = (ys.at<double>(j) * c2 - xs.at<double>(j) * c1) / c5;
+        alpha.at<float>(tri, 0) = (ys.at<float>(j) * c2 - xs.at<float>(j) * c1) / c5;
-        alpha.at<double>(tri, 1) = c1/c5;
+        alpha.at<float>(tri, 1) = c1/c5;
-        alpha.at<double>(tri, 2) = -c2/c5;
+        alpha.at<float>(tri, 2) = -c2/c5;
 
-        beta.at<double>(tri, 0) = (xs.at<double>(j) * c4 - ys.at<double>(j) * c3)/c5;
+        beta.at<float>(tri, 0) = (xs.at<float>(j) * c4 - ys.at<float>(j) * c3)/c5;
-        beta.at<double>(tri, 1) = -c4/c5;
+        beta.at<float>(tri, 1) = -c4/c5;
-        beta.at<double>(tri, 2) = c3/c5;
+        beta.at<float>(tri, 2) = c3/c5;
 
 		// Add points corresponding to triangles as optimisation
-		std::vector<double> triangle_points(10);
+		std::vector<float> triangle_points(10);
 
-		triangle_points[0] = xs.at<double>(j);
+		triangle_points[0] = xs.at<float>(j);
-		triangle_points[1] = ys.at<double>(j);
+		triangle_points[1] = ys.at<float>(j);
-		triangle_points[2] = xs.at<double>(k);
+		triangle_points[2] = xs.at<float>(k);
-		triangle_points[3] = ys.at<double>(k);
+		triangle_points[3] = ys.at<float>(k);
-		triangle_points[4] = xs.at<double>(l);
+		triangle_points[4] = xs.at<float>(l);
-		triangle_points[5] = ys.at<double>(l);
+		triangle_points[5] = ys.at<float>(l);
 		
-		cv::Vec3d xs_three(triangle_points[0], triangle_points[2], triangle_points[4]);
+		cv::Vec3f xs_three(triangle_points[0], triangle_points[2], triangle_points[4]);
-		cv::Vec3d ys_three(triangle_points[1], triangle_points[3], triangle_points[5]);
+		cv::Vec3f ys_three(triangle_points[1], triangle_points[3], triangle_points[5]);
 
 		double min_x, max_x, min_y, max_y;
 		cv::minMaxIdx(xs_three, &min_x, &max_x);
 		cv::minMaxIdx(ys_three, &min_y, &max_y);
 
-		triangle_points[6] = max_x;
+		triangle_points[6] = (float) max_x;
-		triangle_points[7] = max_y;
+		triangle_points[7] = (float) max_y;
 
-		triangle_points[8] = min_x;
+		triangle_points[8] = (float) min_x;
-		triangle_points[9] = min_y;
+		triangle_points[9] = (float) min_y;
 
 		destination_points.push_back(triangle_points);
 
@@ -123,9 +123,14 @@ PAW::PAW(const cv::Mat_<double>& destination_shape, const cv::Mat_<int>& triangu
 
 	double max_x;
 	double max_y;
+	double min_x_d;
+	double min_y_d;
 
-	minMaxLoc(xs, &min_x, &max_x);
+	minMaxLoc(xs, &min_x_d, &max_x);
-	minMaxLoc(ys, &min_y, &max_y);
+	minMaxLoc(ys, &min_y_d, &max_y);
+
+	min_x = min_x_d;
+	min_y = min_y_d;
 
 	int w = (int)(max_x - min_x + 1.5);
     int h = (int)(max_y - min_y + 1.5);
@@ -141,7 +146,7 @@ PAW::PAW(const cv::Mat_<double>& destination_shape, const cv::Mat_<int>& triangu
 	{
 		for(int x = 0; x < pixel_mask.cols; x++)
 		{
-			curr_tri = findTriangle(cv::Point_<double>(x + min_x, y + min_y), destination_points, curr_tri);
+			curr_tri = findTriangle(cv::Point_<float>(x + min_x, y + min_y), destination_points, curr_tri);
 			// If there is a triangle at this location
             if(curr_tri != -1)
 			{
@@ -160,7 +165,7 @@ PAW::PAW(const cv::Mat_<double>& destination_shape, const cv::Mat_<int>& triangu
 }
 
 // Manually define min and max values
-PAW::PAW(const cv::Mat_<double>& destination_shape, const cv::Mat_<int>& triangulation, double in_min_x, double in_min_y, double in_max_x, double in_max_y)
+PAW::PAW(const cv::Mat_<float>& destination_shape, const cv::Mat_<int>& triangulation, float in_min_x, float in_min_y, float in_max_x, float in_max_y)
 {
 	// Initialise some variables directly
 	this->destination_landmarks = destination_shape;
@@ -171,14 +176,14 @@ PAW::PAW(const cv::Mat_<double>& destination_shape, const cv::Mat_<int>& triangu
 	int num_tris = triangulation.rows;
 	
 	// Pre-compute the rest
-    alpha = cv::Mat_<double>(num_tris, 3);
+    alpha = cv::Mat_<float>(num_tris, 3);
-    beta = cv::Mat_<double>(num_tris, 3);
+    beta = cv::Mat_<float>(num_tris, 3);
     
-	cv::Mat_<double> xs = destination_shape(cv::Rect(0, 0, 1, num_points));
+	cv::Mat_<float> xs = destination_shape(cv::Rect(0, 0, 1, num_points));
-	cv::Mat_<double> ys = destination_shape(cv::Rect(0, num_points, 1, num_points));
+	cv::Mat_<float> ys = destination_shape(cv::Rect(0, num_points, 1, num_points));
 
 	// Create a vector representation of the control points
-	std::vector<std::vector<double>> destination_points;
+	std::vector<std::vector<float>> destination_points;
     
 	for (int tri = 0; tri < num_tris; ++tri)
 	{	
@@ -186,50 +191,50 @@ PAW::PAW(const cv::Mat_<double>& destination_shape, const cv::Mat_<int>& triangu
 		int k = triangulation.at<int>(tri, 1);
 		int l = triangulation.at<int>(tri, 2);
 
-        double c1 = ys.at<double>(l) - ys.at<double>(j);
+		float c1 = ys.at<float>(l) - ys.at<float>(j);
-        double c2 = xs.at<double>(l) - xs.at<double>(j);
+		float c2 = xs.at<float>(l) - xs.at<float>(j);
-        double c4 = ys.at<double>(k) - ys.at<double>(j);
+		float c4 = ys.at<float>(k) - ys.at<float>(j);
-        double c3 = xs.at<double>(k) - xs.at<double>(j);
+		float c3 = xs.at<float>(k) - xs.at<float>(j);
         		
-        double c5 = c3*c1 - c2*c4;
+		float c5 = c3*c1 - c2*c4;
 
-        alpha.at<double>(tri, 0) = (ys.at<double>(j) * c2 - xs.at<double>(j) * c1) / c5;
+        alpha.at<float>(tri, 0) = (ys.at<float>(j) * c2 - xs.at<float>(j) * c1) / c5;
-        alpha.at<double>(tri, 1) = c1/c5;
+        alpha.at<float>(tri, 1) = c1/c5;
-        alpha.at<double>(tri, 2) = -c2/c5;
+        alpha.at<float>(tri, 2) = -c2/c5;
 
-        beta.at<double>(tri, 0) = (xs.at<double>(j) * c4 - ys.at<double>(j) * c3)/c5;
+        beta.at<float>(tri, 0) = (xs.at<float>(j) * c4 - ys.at<float>(j) * c3)/c5;
-        beta.at<double>(tri, 1) = -c4/c5;
+        beta.at<float>(tri, 1) = -c4/c5;
-        beta.at<double>(tri, 2) = c3/c5;
+        beta.at<float>(tri, 2) = c3/c5;
 
 		// Add points corresponding to triangles as optimisation
-		std::vector<double> triangle_points(10);
+		std::vector<float> triangle_points(10);
 
-		triangle_points[0] = xs.at<double>(j);
+		triangle_points[0] = xs.at<float>(j);
-		triangle_points[1] = ys.at<double>(j);
+		triangle_points[1] = ys.at<float>(j);
-		triangle_points[2] = xs.at<double>(k);
+		triangle_points[2] = xs.at<float>(k);
-		triangle_points[3] = ys.at<double>(k);
+		triangle_points[3] = ys.at<float>(k);
-		triangle_points[4] = xs.at<double>(l);
+		triangle_points[4] = xs.at<float>(l);
-		triangle_points[5] = ys.at<double>(l);
+		triangle_points[5] = ys.at<float>(l);
 		
-		cv::Vec3d xs_three(triangle_points[0], triangle_points[2], triangle_points[4]);
+		cv::Vec3f xs_three(triangle_points[0], triangle_points[2], triangle_points[4]);
-		cv::Vec3d ys_three(triangle_points[1], triangle_points[3], triangle_points[5]);
+		cv::Vec3f ys_three(triangle_points[1], triangle_points[3], triangle_points[5]);
 
 		double min_x, max_x, min_y, max_y;
 		cv::minMaxIdx(xs_three, &min_x, &max_x);
 		cv::minMaxIdx(ys_three, &min_y, &max_y);
 
-		triangle_points[6] = max_x;
+		triangle_points[6] = (float)max_x;
-		triangle_points[7] = max_y;
+		triangle_points[7] = (float)max_y;
 
-		triangle_points[8] = min_x;
+		triangle_points[8] = (float)min_x;
-		triangle_points[9] = min_y;
+		triangle_points[9] = (float)min_y;
 
 		destination_points.push_back(triangle_points);
 		
 	}
 
-	double max_x;
+	float max_x;
-	double max_y;
+	float max_y;
 
 	min_x = in_min_x;
 	min_y = in_min_y;
@@ -251,7 +256,7 @@ PAW::PAW(const cv::Mat_<double>& destination_shape, const cv::Mat_<int>& triangu
 	{
 		for(int x = 0; x < pixel_mask.cols; x++)
 		{
-			curr_tri = findTriangle(cv::Point_<double>(x + min_x, y + min_y), destination_points, curr_tri);
+			curr_tri = findTriangle(cv::Point_<float>(x + min_x, y + min_y), destination_points, curr_tri);
 			// If there is a triangle at this location
             if(curr_tri != -1)
 			{
@@ -273,10 +278,15 @@ void PAW::Read(std::ifstream& stream)
 {
 
 	stream.read ((char*)&number_of_pixels, 4);
-	stream.read ((char*)&min_x, 8);
+	double min_x_d, min_y_d;
-	stream.read ((char*)&min_y, 8);
+	stream.read ((char*)&min_x_d, 8);
+	stream.read ((char*)&min_y_d, 8);
+	min_x = (float)min_x_d;
+	min_y = (float)min_y_d;
 
-	ReadMatBin(stream, destination_landmarks);
+	cv::Mat_<double> destination_landmarks_d;
+	ReadMatBin(stream, destination_landmarks_d);
+	destination_landmarks_d.convertTo(destination_landmarks, CV_32F);
 
 	ReadMatBin(stream, triangulation);
 
@@ -286,9 +296,13 @@ void PAW::Read(std::ifstream& stream)
 	ReadMatBin(stream, tmpMask);	
 	tmpMask.convertTo(pixel_mask, CV_8U);	
 	
-	ReadMatBin(stream, alpha);
+	cv::Mat_<double> alpha_d;
+	ReadMatBin(stream, alpha_d);
+	alpha_d.convertTo(alpha, CV_32F);
 
-	ReadMatBin(stream, beta);
+	cv::Mat_<double> beta_d;
+	ReadMatBin(stream, beta_d);
+	beta_d.convertTo(beta, CV_32F);
 
 	map_x.create(pixel_mask.rows,pixel_mask.cols);
 	map_y.create(pixel_mask.rows,pixel_mask.cols);
@@ -300,7 +314,7 @@ void PAW::Read(std::ifstream& stream)
 
 //=============================================================================
 // cropping from the source image to the destination image using the shape in s, used to determine if shape fitting converged successfully
-void PAW::Warp(const cv::Mat& image_to_warp, cv::Mat& destination_image, const cv::Mat_<double>& landmarks_to_warp)
+void PAW::Warp(const cv::Mat& image_to_warp, cv::Mat& destination_image, const cv::Mat_<float>& landmarks_to_warp)
 {
   
 	// set the current shape
@@ -331,19 +345,19 @@ void PAW::CalcCoeff()
 		int j = triangulation.at<int>(l,1);
 		int k = triangulation.at<int>(l,2);
 
-		double c1 = source_landmarks.at<double>(i    , 0);
+		float c1 = source_landmarks.at<float>(i    , 0);
-		double c2 = source_landmarks.at<double>(j    , 0) - c1;
+		float c2 = source_landmarks.at<float>(j    , 0) - c1;
-		double c3 = source_landmarks.at<double>(k    , 0) - c1;
+		float c3 = source_landmarks.at<float>(k    , 0) - c1;
-		double c4 = source_landmarks.at<double>(i + p, 0);
+		float c4 = source_landmarks.at<float>(i + p, 0);
-		double c5 = source_landmarks.at<double>(j + p, 0) - c4;
+		float c5 = source_landmarks.at<float>(j + p, 0) - c4;
-		double c6 = source_landmarks.at<double>(k + p, 0) - c4;
+		float c6 = source_landmarks.at<float>(k + p, 0) - c4;
 
 		// Get a pointer to the coefficient we will be precomputing
-		double *coeff = coefficients.ptr<double>(l);
+		float *coeff = coefficients.ptr<float>(l);
 
 		// Extract the relevant alphas and betas
-		double *c_alpha = alpha.ptr<double>(l);
+		float *c_alpha = alpha.ptr<float>(l);
-		double *c_beta  = beta.ptr<double>(l);
+		float *c_beta  = beta.ptr<float>(l);
 
 		coeff[0] = c1 + c2 * c_alpha[0] + c3 * c_beta[0];
 		coeff[1] =      c2 * c_alpha[1] + c3 * c_beta[1];
@@ -365,18 +379,18 @@ void PAW::WarpRegion(cv::Mat_<float>& mapx, cv::Mat_<float>& mapy)
 	cv::MatIterator_<int>   tp = triangle_id.begin();
 	
 	// The coefficients corresponding to the current triangle
-	double * a;
+	float * a;
 
 	// Current triangle being processed	
 	int k=-1;
 
 	for(int y = 0; y < pixel_mask.rows; y++)
 	{
-		double yi = double(y) + min_y;
+		float yi = float(y) + min_y;
 	
 		for(int x = 0; x < pixel_mask.cols; x++)
 		{
-			double xi = double(x) + min_x;
+			float xi = float(x) + min_x;
 
 			if(*mp == 0)
 			{
@@ -393,22 +407,22 @@ void PAW::WarpRegion(cv::Mat_<float>& mapx, cv::Mat_<float>& mapy)
 				if(j != k)
 				{
 					// Update the coefficient pointer if a new triangle is being processed
-					a = coefficients.ptr<double>(j);			
+					a = coefficients.ptr<float>(j);
 					k = j;
 				}  	
 
 				//ap is now the pointer to the coefficients
-				double *ap = a;							
+				float *ap = a;
 
 				//look at the first coefficient (and increment). first coefficient is an x offset
-				double xo = *ap++;						
+				float xo = *ap++;
 				//second coefficient is an x scale as a function of x
 				xo += *ap++ * xi;						
 				//third coefficient ap(2) is an x scale as a function of y
 				*xp = float(xo + *ap++ * yi);			
 
 				//then fourth coefficient ap(3) is a y offset
-				double yo = *ap++;						
+				float yo = *ap++;
 				//fifth coeff adds coeff[4]*x to y
 				yo += *ap++ * xi;						
 				//final coeff adds coeff[5]*y to y
@@ -425,18 +439,18 @@ void PAW::WarpRegion(cv::Mat_<float>& mapx, cv::Mat_<float>& mapy)
 // ============================================================
 
 // Is the point (x0,y0) on same side as a half-plane defined by (x1,y1), (x2, y2), and (x3, y3)
-bool PAW::sameSide(double x0, double y0, double x1, double y1, double x2, double y2, double x3, double y3)
+bool PAW::sameSide(float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3)
 {
     
-    double x = (x3-x2)*(y0-y2) - (x0-x2)*(y3-y2);
+	float x = (x3-x2)*(y0-y2) - (x0-x2)*(y3-y2);
-    double y = (x3-x2)*(y1-y2) - (x1-x2)*(y3-y2);
+	float y = (x3-x2)*(y1-y2) - (x1-x2)*(y3-y2);
 
     return x*y >= 0;
 
 }
 
 // if point (x0, y0) is on same side for all three half-planes it is in a triangle
-bool PAW::pointInTriangle(double x0, double y0, double x1, double y1, double x2, double y2, double x3, double y3)
+bool PAW::pointInTriangle(float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3)
 {
 	bool same_1 = sameSide(x0, y0, x1, y1, x2, y2, x3, y3);
 	bool same_2 = sameSide(x0, y0, x2, y2, x1, y1, x3, y3);
@@ -447,15 +461,15 @@ bool PAW::pointInTriangle(double x0, double y0, double x1, double y1, double x2,
 }
 
 // Find if a given point lies in the triangles
-int PAW::findTriangle(const cv::Point_<double>& point, const std::vector<std::vector<double>>& control_points, int guess)
+int PAW::findTriangle(const cv::Point_<float>& point, const std::vector<std::vector<float>>& control_points, int guess) 
 {
     
 	int num_tris = control_points.size();
 	
 	int tri = -1;
     
-	double x0 = point.x;
+	float x0 = point.x;
-	double y0 = point.y;
+	float y0 = point.y;
 
 	// Allow a guess for speed (so as not to go through all triangles)
 	if(guess != -1)
@@ -472,11 +486,11 @@ int PAW::findTriangle(const cv::Point_<double>& point, const std::vector<std::ve
     for (int i = 0; i < num_tris; ++i)
 	{
 
-		double max_x = control_points[i][6];
+		float max_x = control_points[i][6];
-		double max_y = control_points[i][7];
+		float max_y = control_points[i][7];
 
-		double min_x = control_points[i][8];
+		float min_x = control_points[i][8];
-		double min_y = control_points[i][9];
+		float min_y = control_points[i][9];
 
 		// Skip the check if the point is outside the bounding box of the triangle
 

lib/local/FaceAnalyser/src/PDM.cpp

@@ -49,23 +49,27 @@
 
 #include <Face_utils.h>
 
+// OpenBLAS
+#include <cblas.h>
+#include <f77blas.h>
+
 using namespace FaceAnalysis;
 //===========================================================================
 
 //=============================================================================
 // Orthonormalising the 3x3 rotation matrix
-void PDM::Orthonormalise(cv::Matx33d &R)
+void PDM::Orthonormalise(cv::Matx33f &R)
 {
 
 	cv::SVD svd(R,cv::SVD::MODIFY_A);
   
 	// get the orthogonal matrix from the initial rotation matrix
-	cv::Mat_<double> X = svd.u*svd.vt;
+	cv::Mat_<float> X = svd.u*svd.vt;
   
 	// This makes sure that the handedness is preserved and no reflection happened
 	// by making sure the determinant is 1 and not -1
-	cv::Mat_<double> W = cv::Mat_<double>::eye(3,3);
+	cv::Mat_<float> W = cv::Mat_<float>::eye(3,3);
-	double d = determinant(X);
+	float d = determinant(X);
 	W(2,2) = determinant(X);
 	cv::Mat Rt = svd.u*W*svd.vt;
 
@@ -84,59 +88,59 @@ PDM::PDM(const PDM& other) {
 
 //===========================================================================
 // Compute the 3D representation of shape (in object space) using the local parameters
-void PDM::CalcShape3D(cv::Mat_<double>& out_shape, const cv::Mat_<double>& p_local) const
+void PDM::CalcShape3D(cv::Mat_<float>& out_shape, const cv::Mat_<float>& p_local) const
 {
 	out_shape.create(mean_shape.rows, mean_shape.cols);
-	out_shape = mean_shape + princ_comp*p_local;
+	out_shape = mean_shape + princ_comp * p_local;
 }
 
 //===========================================================================
 // Get the 2D shape (in image space) from global and local parameters
-void PDM::CalcShape2D(cv::Mat_<double>& out_shape, const cv::Mat_<double>& params_local, const cv::Vec6d& params_global) const
+void PDM::CalcShape2D(cv::Mat_<float>& out_shape, const cv::Mat_<float>& params_local, const cv::Vec6f& params_global) const
 {
 
 	int n = this->NumberOfPoints();
 
-	double s = params_global[0]; // scaling factor
+	float s = params_global[0]; // scaling factor
-	double tx = params_global[4]; // x offset
+	float tx = params_global[4]; // x offset
-	double ty = params_global[5]; // y offset
+	float ty = params_global[5]; // y offset
 
 								 // get the rotation matrix from the euler angles
-	cv::Vec3d euler(params_global[1], params_global[2], params_global[3]);
+	cv::Vec3f euler(params_global[1], params_global[2], params_global[3]);
-	cv::Matx33d currRot = Euler2RotationMatrix(euler);
+	cv::Matx33f currRot = Euler2RotationMatrix(euler);
 
 	// get the 3D shape of the object
-	cv::Mat_<double> Shape_3D = mean_shape + princ_comp * params_local;
+	cv::Mat_<float> Shape_3D = mean_shape + princ_comp * params_local;
 
 	// create the 2D shape matrix (if it has not been defined yet)
-	if((out_shape.rows != mean_shape.rows) || (out_shape.cols != 1))
+	if ((out_shape.rows != mean_shape.rows) || (out_shape.cols != 1))
 	{
-		out_shape.create(2*n,1);
+		out_shape.create(2 * n, 1);
 	}
 	// for every vertex
-	for(int i = 0; i < n; i++)
+	for (int i = 0; i < n; i++)
 	{
 		// Transform this using the weak-perspective mapping to 2D from 3D
-		out_shape.at<double>(i  ,0) = s * ( currRot(0,0) * Shape_3D.at<double>(i, 0) + currRot(0,1) * Shape_3D.at<double>(i+n  ,0) + currRot(0,2) * Shape_3D.at<double>(i+n*2,0) ) + tx;
+		out_shape.at<float>(i, 0) = s * (currRot(0, 0) * Shape_3D.at<float>(i, 0) + currRot(0, 1) * Shape_3D.at<float>(i + n, 0) + currRot(0, 2) * Shape_3D.at<float>(i + n * 2, 0)) + tx;
-		out_shape.at<double>(i+n,0) = s * ( currRot(1,0) * Shape_3D.at<double>(i, 0) + currRot(1,1) * Shape_3D.at<double>(i+n  ,0) + currRot(1,2) * Shape_3D.at<double>(i+n*2,0) ) + ty;
+		out_shape.at<float>(i + n, 0) = s * (currRot(1, 0) * Shape_3D.at<float>(i, 0) + currRot(1, 1) * Shape_3D.at<float>(i + n, 0) + currRot(1, 2) * Shape_3D.at<float>(i + n * 2, 0)) + ty;
 	}
 }
 
 //===========================================================================
 // provided the bounding box of a face and the local parameters (with optional rotation), generates the global parameters that can generate the face with the provided bounding box
 // This all assumes that the bounding box describes face from left outline to right outline of the face and chin to eyebrows
-void PDM::CalcParams(cv::Vec6d& out_params_global, const cv::Rect_<double>& bounding_box, const cv::Mat_<double>& params_local, const cv::Vec3d rotation) const
+void PDM::CalcParams(cv::Vec6f& out_params_global, const cv::Rect_<float>& bounding_box, const cv::Mat_<float>& params_local, const cv::Vec3f rotation) const
 {
 
 	// get the shape instance based on local params
-	cv::Mat_<double> current_shape(mean_shape.size());
+	cv::Mat_<float> current_shape(mean_shape.size());
 
 	CalcShape3D(current_shape, params_local);
 
 	// rotate the shape
-	cv::Matx33d rotation_matrix = Euler2RotationMatrix(rotation);
+	cv::Matx33f rotation_matrix = Euler2RotationMatrix(rotation);
 
-	cv::Mat_<double> reshaped = current_shape.reshape(1, 3);
+	cv::Mat_<float> reshaped = current_shape.reshape(1, 3);
 
 	cv::Mat rotated_shape = (cv::Mat(rotation_matrix) * reshaped);
 
@@ -149,30 +153,30 @@ void PDM::CalcParams(cv::Vec6d& out_params_global, const cv::Rect_<double>& boun
 	double max_y;
 	cv::minMaxLoc(rotated_shape.row(1), &min_y, &max_y);
 
-	double width = abs(min_x - max_x);
+	float width = (float)abs(min_x - max_x);
-	double height = abs(min_y - max_y);
+	float height = (float)abs(min_y - max_y);
 
-	double scaling = ((bounding_box.width / width) + (bounding_box.height / height)) / 2;
+	float scaling = ((bounding_box.width / width) + (bounding_box.height / height)) / 2.0f;
 
 	// The estimate of face center also needs some correction
-	double tx = bounding_box.x + bounding_box.width / 2;
+	float tx = bounding_box.x + bounding_box.width / 2;
-	double ty = bounding_box.y + bounding_box.height / 2;
+	float ty = bounding_box.y + bounding_box.height / 2;
 
 	// Correct it so that the bounding box is just around the minimum and maximum point in the initialised face	
-	tx = tx - scaling * (min_x + max_x)/2;
+	tx = tx - scaling * (min_x + max_x) / 2.0f;
-    ty = ty - scaling * (min_y + max_y)/2;
+	ty = ty - scaling * (min_y + max_y) / 2.0f;
 
-	out_params_global = cv::Vec6d(scaling, rotation[0], rotation[1], rotation[2], tx, ty);
+	out_params_global = cv::Vec6f(scaling, rotation[0], rotation[1], rotation[2], tx, ty);
 }
 
 //===========================================================================
 // provided the model parameters, compute the bounding box of a face
 // The bounding box describes face from left outline to right outline of the face and chin to eyebrows
-void PDM::CalcBoundingBox(cv::Rect& out_bounding_box, const cv::Vec6d& params_global, const cv::Mat_<double>& params_local) const
+void PDM::CalcBoundingBox(cv::Rect_<float>& out_bounding_box, const cv::Vec6f& params_global, const cv::Mat_<float>& params_local) const
 {
 
 	// get the shape instance based on local params
-	cv::Mat_<double> current_shape;
+	cv::Mat_<float> current_shape;
 	CalcShape2D(current_shape, params_local, params_global);
 
 	// Get the width of expected shape
@@ -184,15 +188,15 @@ void PDM::CalcBoundingBox(cv::Rect& out_bounding_box, const cv::Vec6d& params_gl
 	double max_y;
 	cv::minMaxLoc(current_shape(cv::Rect(0, this->NumberOfPoints(), 1, this->NumberOfPoints())), &min_y, &max_y);
 
-	double width = abs(min_x - max_x);
+	float width = (float)abs(min_x - max_x);
-	double height = abs(min_y - max_y);
+	float height = (float)abs(min_y - max_y);
 
-	out_bounding_box = cv::Rect((int)min_x, (int)min_y, (int)width, (int)height);
+	out_bounding_box = cv::Rect_<float>(min_x, min_y, width, height);
 }
 
 //===========================================================================
 // Calculate the PDM's Jacobian over rigid parameters (rotation, translation and scaling), the additional input W represents trust for each of the landmarks and is part of Non-Uniform RLMS 
-void PDM::ComputeRigidJacobian(const cv::Mat_<float>& p_local, const cv::Vec6d& params_global, cv::Mat_<float> &Jacob, const cv::Mat_<float> W, cv::Mat_<float> &Jacob_t_w) const
+void PDM::ComputeRigidJacobian(const cv::Mat_<float>& p_local, const cv::Vec6f& params_global, cv::Mat_<float> &Jacob, const cv::Mat_<float> W, cv::Mat_<float> &Jacob_t_w) const
 {
 
 	// number of verts
@@ -200,41 +204,36 @@ void PDM::ComputeRigidJacobian(const cv::Mat_<float>& p_local, const cv::Vec6d&
 
 	Jacob.create(n * 2, 6);
 
-	float X,Y,Z;
+	float X, Y, Z;
 
-	float s = (float)params_global[0];
+	float s = params_global[0];
-  	
-	cv::Mat_<double> shape_3D_d;
-	cv::Mat_<double> p_local_d;
-	p_local.convertTo(p_local_d, CV_64F);
-	this->CalcShape3D(shape_3D_d, p_local_d);
 
 	cv::Mat_<float> shape_3D;
-	shape_3D_d.convertTo(shape_3D, CV_32F);
+	this->CalcShape3D(shape_3D, p_local);
 
 	// Get the rotation matrix
-	cv::Vec3d euler(params_global[1], params_global[2], params_global[3]);
+	cv::Vec3f euler(params_global[1], params_global[2], params_global[3]);
-	cv::Matx33d currRot = Euler2RotationMatrix(euler);
+	cv::Matx33f currRot = Euler2RotationMatrix(euler);
 
-	float r11 = (float) currRot(0,0);
+	float r11 = currRot(0, 0);
-	float r12 = (float) currRot(0,1);
+	float r12 = currRot(0, 1);
-	float r13 = (float) currRot(0,2);
+	float r13 = currRot(0, 2);
-	float r21 = (float) currRot(1,0);
+	float r21 = currRot(1, 0);
-	float r22 = (float) currRot(1,1);
+	float r22 = currRot(1, 1);
-	float r23 = (float) currRot(1,2);
+	float r23 = currRot(1, 2);
-	float r31 = (float) currRot(2,0);
+	float r31 = currRot(2, 0);
-	float r32 = (float) currRot(2,1);
+	float r32 = currRot(2, 1);
-	float r33 = (float) currRot(2,2);
+	float r33 = currRot(2, 2);
 
 	cv::MatIterator_<float> Jx = Jacob.begin();
 	cv::MatIterator_<float> Jy = Jx + n * 6;
 
-	for(int i = 0; i < n; i++)
+	for (int i = 0; i < n; i++)
 	{
 
-		X = shape_3D.at<float>(i,0);
+		X = shape_3D.at<float>(i, 0);
-		Y = shape_3D.at<float>(i+n,0);
+		Y = shape_3D.at<float>(i + n, 0);
-		Z = shape_3D.at<float>(i+n*2,0);    
+		Z = shape_3D.at<float>(i + n * 2, 0);
 
 		// The rigid jacobian from the axis angle rotation matrix approximation using small angle assumption (R * R')
 		// where R' = [1, -wz, wy
@@ -247,12 +246,12 @@ void PDM::ComputeRigidJacobian(const cv::Mat_<float>& p_local, const cv::Vec6d&
 		*Jy++ = (X  * r21 + Y * r22 + Z * r23);
 
 		// rotation terms
-		*Jx++ = (s * (Y * r13 - Z * r12) );
+		*Jx++ = (s * (Y * r13 - Z * r12));
-		*Jy++ = (s * (Y * r23 - Z * r22) );
+		*Jy++ = (s * (Y * r23 - Z * r22));
 		*Jx++ = (-s * (X * r13 - Z * r11));
 		*Jy++ = (-s * (X * r23 - Z * r21));
-		*Jx++ = (s * (X * r12 - Y * r11) );
+		*Jx++ = (s * (X * r12 - Y * r11));
-		*Jy++ = (s * (X * r22 - Y * r21) );
+		*Jy++ = (s * (X * r22 - Y * r21));
 
 		// translation terms
 		*Jx++ = 1.0f;
@@ -265,18 +264,18 @@ void PDM::ComputeRigidJacobian(const cv::Mat_<float>& p_local, const cv::Vec6d&
 	cv::Mat Jacob_w = cv::Mat::zeros(Jacob.rows, Jacob.cols, Jacob.type());
 
 	Jx = Jacob.begin();
-	Jy =  Jx + n*6;
+	Jy = Jx + n * 6;
 
 	cv::MatIterator_<float> Jx_w = Jacob_w.begin<float>();
-	cv::MatIterator_<float> Jy_w =  Jx_w + n*6;
+	cv::MatIterator_<float> Jy_w = Jx_w + n * 6;
 
 	// Iterate over all Jacobian values and multiply them by the weight in diagonal of W
-	for(int i = 0; i < n; i++)
+	for (int i = 0; i < n; i++)
 	{
 		float w_x = W.at<float>(i, i);
-		float w_y = W.at<float>(i+n, i+n);
+		float w_y = W.at<float>(i + n, i + n);
 
-		for(int j = 0; j < Jacob.cols; ++j)
+		for (int j = 0; j < Jacob.cols; ++j)
 		{
 			*Jx_w++ = *Jx++ * w_x;
 			*Jy_w++ = *Jy++ * w_y;
@@ -288,7 +287,7 @@ void PDM::ComputeRigidJacobian(const cv::Mat_<float>& p_local, const cv::Vec6d&
 
 //===========================================================================
 // Calculate the PDM's Jacobian over all parameters (rigid and non-rigid), the additional input W represents trust for each of the landmarks and is part of Non-Uniform RLMS
-void PDM::ComputeJacobian(const cv::Mat_<float>& params_local, const cv::Vec6d& params_global, cv::Mat_<float> &Jacobian, const cv::Mat_<float> W, cv::Mat_<float> &Jacob_t_w) const
+void PDM::ComputeJacobian(const cv::Mat_<float>& params_local, const cv::Vec6f& params_global, cv::Mat_<float> &Jacobian, const cv::Mat_<float> W, cv::Mat_<float> &Jacob_t_w) const
 {
 
 	// number of vertices
@@ -299,43 +298,38 @@ void PDM::ComputeJacobian(const cv::Mat_<float>& params_local, const cv::Vec6d&
 
 	Jacobian.create(n * 2, 6 + m);
 
-	float X,Y,Z;
+	float X, Y, Z;
 
-	float s = (float) params_global[0];
+	float s = params_global[0];
-  	
-	cv::Mat_<double> shape_3D_d;
-	cv::Mat_<double> p_local_d;
-	params_local.convertTo(p_local_d, CV_64F);
-	this->CalcShape3D(shape_3D_d, p_local_d);
 
 	cv::Mat_<float> shape_3D;
-	shape_3D_d.convertTo(shape_3D, CV_32F);
+	this->CalcShape3D(shape_3D, params_local);
 
-	cv::Vec3d euler(params_global[1], params_global[2], params_global[3]);
+	cv::Vec3f euler(params_global[1], params_global[2], params_global[3]);
-	cv::Matx33d currRot = Euler2RotationMatrix(euler);
+	cv::Matx33f currRot = Euler2RotationMatrix(euler);
 
-	float r11 = (float) currRot(0,0);
+	float r11 = currRot(0, 0);
-	float r12 = (float) currRot(0,1);
+	float r12 = currRot(0, 1);
-	float r13 = (float) currRot(0,2);
+	float r13 = currRot(0, 2);
-	float r21 = (float) currRot(1,0);
+	float r21 = currRot(1, 0);
-	float r22 = (float) currRot(1,1);
+	float r22 = currRot(1, 1);
-	float r23 = (float) currRot(1,2);
+	float r23 = currRot(1, 2);
-	float r31 = (float) currRot(2,0);
+	float r31 = currRot(2, 0);
-	float r32 = (float) currRot(2,1);
+	float r32 = currRot(2, 1);
-	float r33 = (float) currRot(2,2);
+	float r33 = currRot(2, 2);
 
 	cv::MatIterator_<float> Jx = Jacobian.begin();
 	cv::MatIterator_<float> Jy = Jx + n * (6 + m);
-	cv::MatConstIterator_<double> Vx =  this->princ_comp.begin();
+	cv::MatConstIterator_<float> Vx = this->princ_comp.begin();
-	cv::MatConstIterator_<double> Vy =  Vx + n*m;
+	cv::MatConstIterator_<float> Vy = Vx + n*m;
-	cv::MatConstIterator_<double> Vz =  Vy + n*m;
+	cv::MatConstIterator_<float> Vz = Vy + n*m;
 
-	for(int i = 0; i < n; i++)
+	for (int i = 0; i < n; i++)
 	{
 
-		X = shape_3D.at<float>(i,0);
+		X = shape_3D.at<float>(i, 0);
-		Y = shape_3D.at<float>(i+n,0);
+		Y = shape_3D.at<float>(i + n, 0);
-		Z = shape_3D.at<float>(i+n*2,0);    
+		Z = shape_3D.at<float>(i + n * 2, 0);
 
 		// The rigid jacobian from the axis angle rotation matrix approximation using small angle assumption (R * R')
 		// where R' = [1, -wz, wy
@@ -348,12 +342,12 @@ void PDM::ComputeJacobian(const cv::Mat_<float>& params_local, const cv::Vec6d&
 		*Jy++ = (X  * r21 + Y * r22 + Z * r23);
 
 		// rotation terms
-		*Jx++ = (s * (Y * r13 - Z * r12) );
+		*Jx++ = (s * (Y * r13 - Z * r12));
-		*Jy++ = (s * (Y * r23 - Z * r22) );
+		*Jy++ = (s * (Y * r23 - Z * r22));
 		*Jx++ = (-s * (X * r13 - Z * r11));
 		*Jy++ = (-s * (X * r23 - Z * r21));
-		*Jx++ = (s * (X * r12 - Y * r11) );
+		*Jx++ = (s * (X * r12 - Y * r11));
-		*Jy++ = (s * (X * r22 - Y * r21) );
+		*Jy++ = (s * (X * r22 - Y * r21));
 
 		// translation terms
 		*Jx++ = 1.0f;
@@ -361,32 +355,32 @@ void PDM::ComputeJacobian(const cv::Mat_<float>& params_local, const cv::Vec6d&
 		*Jx++ = 0.0f;
 		*Jy++ = 1.0f;
 
-		for(int j = 0; j < m; j++,++Vx,++Vy,++Vz)
+		for (int j = 0; j < m; j++, ++Vx, ++Vy, ++Vz)
 		{
 			// How much the change of the non-rigid parameters (when object is rotated) affect 2D motion
-			*Jx++ = (float) ( s*(r11*(*Vx) + r12*(*Vy) + r13*(*Vz)) );
+			*Jx++ = (s*(r11*(*Vx) + r12*(*Vy) + r13*(*Vz)));
-			*Jy++ = (float) ( s*(r21*(*Vx) + r22*(*Vy) + r23*(*Vz)) );
+			*Jy++ = (s*(r21*(*Vx) + r22*(*Vy) + r23*(*Vz)));
 		}
 	}
 
 	// Adding the weights here
 	cv::Mat Jacob_w = Jacobian.clone();
 
-	if(cv::trace(W)[0] != W.rows) 
+	if (cv::trace(W)[0] != W.rows)
 	{
 		Jx = Jacobian.begin();
-		Jy =  Jx + n*(6+m);
+		Jy = Jx + n*(6 + m);
 
 		cv::MatIterator_<float> Jx_w = Jacob_w.begin<float>();
-		cv::MatIterator_<float> Jy_w =  Jx_w + n*(6+m);
+		cv::MatIterator_<float> Jy_w = Jx_w + n*(6 + m);
 
 		// Iterate over all Jacobian values and multiply them by the weight in diagonal of W
-		for(int i = 0; i < n; i++)
+		for (int i = 0; i < n; i++)
 		{
 			float w_x = W.at<float>(i, i);
-			float w_y = W.at<float>(i+n, i+n);
+			float w_y = W.at<float>(i + n, i + n);
 
-			for(int j = 0; j < Jacobian.cols; ++j)
+			for (int j = 0; j < Jacobian.cols; ++j)
 			{
 				*Jx_w++ = *Jx++ * w_x;
 				*Jy_w++ = *Jy++ * w_y;
@@ -397,52 +391,53 @@ void PDM::ComputeJacobian(const cv::Mat_<float>& params_local, const cv::Vec6d&
 
 }
 
+
 //===========================================================================
 // Updating the parameters (more details in my thesis)
-void PDM::UpdateModelParameters(const cv::Mat_<float>& delta_p, cv::Mat_<float>& params_local, cv::Vec6d& params_global) const
+void PDM::UpdateModelParameters(const cv::Mat_<float>& delta_p, cv::Mat_<float>& params_local, cv::Vec6f& params_global) const
 {
 
 	// The scaling and translation parameters can be just added
-	params_global[0] += (double)delta_p.at<float>(0,0);
+	params_global[0] += delta_p.at<float>(0, 0);
-	params_global[4] += (double)delta_p.at<float>(4,0);
+	params_global[4] += delta_p.at<float>(4, 0);
-	params_global[5] += (double)delta_p.at<float>(5,0);
+	params_global[5] += delta_p.at<float>(5, 0);
 
 	// get the original rotation matrix	
-	cv::Vec3d eulerGlobal(params_global[1], params_global[2], params_global[3]);
+	cv::Vec3f eulerGlobal(params_global[1], params_global[2], params_global[3]);
-	cv::Matx33d R1 = Euler2RotationMatrix(eulerGlobal);
+	cv::Matx33f R1 = Euler2RotationMatrix(eulerGlobal);
 
 	// construct R' = [1, -wz, wy
 	//               wz, 1, -wx
 	//               -wy, wx, 1]
-	cv::Matx33d R2 = cv::Matx33d::eye();
+	cv::Matx33f R2 = cv::Matx33f::eye();
 
-	R2(1,2) = -1.0*(R2(2,1) = (double)delta_p.at<float>(1,0));
+	R2(1, 2) = -1.0*(R2(2, 1) = delta_p.at<float>(1, 0));
-	R2(2,0) = -1.0*(R2(0,2) = (double)delta_p.at<float>(2,0));
+	R2(2, 0) = -1.0*(R2(0, 2) = delta_p.at<float>(2, 0));
-	R2(0,1) = -1.0*(R2(1,0) = (double)delta_p.at<float>(3,0));
+	R2(0, 1) = -1.0*(R2(1, 0) = delta_p.at<float>(3, 0));
 
 	// Make sure it's orthonormal
 	Orthonormalise(R2);
 
 	// Combine rotations
-	cv::Matx33d R3 = R1 *R2;
+	cv::Matx33f R3 = R1 *R2;
 
 	// Extract euler angle (through axis angle first to make sure it's legal)
-	cv::Vec3d axis_angle = RotationMatrix2AxisAngle(R3);
+	cv::Vec3f axis_angle = RotationMatrix2AxisAngle(R3);
-	cv::Vec3d euler = AxisAngle2Euler(axis_angle);
+	cv::Vec3f euler = AxisAngle2Euler(axis_angle);
 
 	params_global[1] = euler[0];
 	params_global[2] = euler[1];
 	params_global[3] = euler[2];
 
 	// Local parameter update, just simple addition
-	if(delta_p.rows > 6)
+	if (delta_p.rows > 6)
 	{
-		params_local = params_local + delta_p(cv::Rect(0,6,1, this->NumberOfModes()));
+		params_local = params_local + delta_p(cv::Rect(0, 6, 1, this->NumberOfModes()));
 	}
 
 }
-
+// void CalcParams(cv::Vec6d& out_params_global, cv::Mat_<double>& out_params_local, const cv::Mat_<double>& landmark_locations, const cv::Vec3d rotation = cv::Vec3d(0.0)) const;
-void PDM::CalcParams(cv::Vec6d& out_params_global, cv::Mat_<double>& out_params_local, const cv::Mat_<double>& landmark_locations, const cv::Vec3d rotation) const
+void PDM::CalcParams(cv::Vec6f& out_params_global, cv::Mat_<float>& out_params_local, const cv::Mat_<float>& landmark_locations, const cv::Vec3f rotation) const
 {
 		
 	int m = this->NumberOfModes();
@@ -460,48 +455,45 @@ void PDM::CalcParams(cv::Vec6d& out_params_global, cv::Mat_<double>& out_params_
 	double max_y;
 	cv::minMaxLoc(landmark_locations(cv::Rect(0, this->NumberOfPoints(), 1, this->NumberOfPoints())), &min_y, &max_y);
 
-	double width = abs(min_x - max_x);
+	float width = (float)abs(min_x - max_x);
-	double height = abs(min_y - max_y);
+	float height = (float)abs(min_y - max_y);
 
-	cv::Rect model_bbox;
+	cv::Rect_<float> model_bbox;
 	CalcBoundingBox(model_bbox, cv::Vec6d(1.0, 0.0, 0.0, 0.0, 0.0, 0.0), cv::Mat_<double>(this->NumberOfModes(), 1, 0.0));
 
 	cv::Rect bbox((int)min_x, (int)min_y, (int)width, (int)height);
 
-	double scaling = ((width / model_bbox.width) + (height / model_bbox.height)) / 2;
+	float scaling = ((width / model_bbox.width) + (height / model_bbox.height)) / 2;
         
-	cv::Vec3d rotation_init = rotation;
+	cv::Vec3f rotation_init(rotation[0], rotation[1], rotation[2]);
-	cv::Matx33d R = Euler2RotationMatrix(rotation_init);
+	cv::Matx33f R = Euler2RotationMatrix(rotation_init);
-	cv::Vec2d translation((min_x + max_x) / 2.0, (min_y + max_y) / 2.0);
+	cv::Vec2f translation((min_x + max_x) / 2.0, (min_y + max_y) / 2.0);
     
 	cv::Mat_<float> loc_params(this->NumberOfModes(),1, 0.0);
-	cv::Vec6d glob_params(scaling, rotation_init[0], rotation_init[1], rotation_init[2], translation[0], translation[1]);
+	cv::Vec6f glob_params(scaling, rotation_init[0], rotation_init[1], rotation_init[2], translation[0], translation[1]);
 
 	// get the 3D shape of the object
-	cv::Mat_<double> loc_params_d;
+	cv::Mat_<float> shape_3D = mean_shape + princ_comp * loc_params;
-	loc_params.convertTo(loc_params_d, CV_64F);
-	cv::Mat_<double> shape_3D = mean_shape + princ_comp * loc_params_d;
 
-	cv::Mat_<double> curr_shape(2*n, 1);
+	cv::Mat_<float> curr_shape(2*n, 1);
 	
 	// for every vertex
 	for(int i = 0; i < n; i++)
 	{
 		// Transform this using the weak-perspective mapping to 2D from 3D
-		curr_shape.at<double>(i  ,0) = scaling * ( R(0,0) * shape_3D.at<double>(i, 0) + R(0,1) * shape_3D.at<double>(i+n  ,0) + R(0,2) * shape_3D.at<double>(i+n*2,0) ) + translation[0];
+		curr_shape.at<float>(i  ,0) = scaling * ( R(0,0) * shape_3D.at<float>(i, 0) + R(0,1) * shape_3D.at<float>(i+n  ,0) + R(0,2) * shape_3D.at<float>(i+n*2,0) ) + translation[0];
-		curr_shape.at<double>(i+n,0) = scaling * ( R(1,0) * shape_3D.at<double>(i, 0) + R(1,1) * shape_3D.at<double>(i+n  ,0) + R(1,2) * shape_3D.at<double>(i+n*2,0) ) + translation[1];
+		curr_shape.at<float>(i+n,0) = scaling * ( R(1,0) * shape_3D.at<float>(i, 0) + R(1,1) * shape_3D.at<float>(i+n  ,0) + R(1,2) * shape_3D.at<float>(i+n*2,0) ) + translation[1];
 	}
 		    
-    double currError = cv::norm(curr_shape - landmark_locations);
+    float currError = cv::norm(curr_shape - landmark_locations);
 
-	cv::Mat_<float> regularisations = cv::Mat_<double>::zeros(1, 6 + m);
+	cv::Mat_<float> regularisations = cv::Mat_<float>::zeros(1, 6 + m);
 
-	double reg_factor = 1;
+	float reg_factor = 1;
 
 	// Setting the regularisation to the inverse of eigenvalues
 	cv::Mat(reg_factor / this->eigen_values).copyTo(regularisations(cv::Rect(6, 0, m, 1)));
-	cv::Mat_<double> regTerm_d = cv::Mat::diag(regularisations.t());
+	regularisations = cv::Mat::diag(regularisations.t());
-	regTerm_d.convertTo(regularisations, CV_32F);    
     
 	cv::Mat_<float> WeightMatrix = cv::Mat_<float>::eye(n*2, n*2);
 
@@ -510,15 +502,13 @@ void PDM::CalcParams(cv::Vec6d& out_params_global, cv::Mat_<double>& out_params_
     for (size_t i = 0; i < 1000; ++i)
 	{
 		// get the 3D shape of the object
-		cv::Mat_<double> loc_params_d;
+		shape_3D = mean_shape + princ_comp * loc_params;
-		loc_params.convertTo(loc_params_d, CV_64F);
-		shape_3D = mean_shape + princ_comp * loc_params_d;
 
 		shape_3D = shape_3D.reshape(1, 3);
 
-		cv::Matx23d R_2D(R(0,0), R(0,1), R(0,2), R(1,0), R(1,1), R(1,2));
+		cv::Matx23f R_2D(R(0,0), R(0,1), R(0,2), R(1,0), R(1,1), R(1,2));
 
-		cv::Mat_<double> curr_shape_2D = scaling * shape_3D.t() * cv::Mat(R_2D).t();
+		cv::Mat_<float> curr_shape_2D = scaling * shape_3D.t() * cv::Mat(R_2D).t();
         curr_shape_2D.col(0) = curr_shape_2D.col(0) + translation(0);
 		curr_shape_2D.col(1) = curr_shape_2D.col(1) + translation(1);
 
@@ -536,17 +526,22 @@ void PDM::CalcParams(cv::Vec6d& out_params_global, cv::Mat_<double>& out_params_
 		// Add the regularisation term
 		J_w_t_m(cv::Rect(0,6,1, m)) = J_w_t_m(cv::Rect(0,6,1, m)) - regularisations(cv::Rect(6,6, m, m)) * loc_params;
 
-		cv::Mat_<float> Hessian = J_w_t * J;
+		cv::Mat_<float> Hessian = regularisations.clone();
 
-		// Add the Tikhonov regularisation
+		// Perform matrix multiplication in OpenBLAS (fortran call)
-		Hessian = Hessian + regularisations;
+		float alpha1 = 1.0;
+		float beta1 = 1.0;
+		sgemm_("N", "N", &J.cols, &J_w_t.rows, &J_w_t.cols, &alpha1, (float*)J.data, &J.cols, (float*)J_w_t.data, &J_w_t.cols, &beta1, (float*)Hessian.data, &J.cols);
+
+		// Above is a fast (but ugly) version of 
+		// cv::Mat_<float> Hessian2 = J_w_t * J + regularisations;
 
 		// Solve for the parameter update (from Baltrusaitis 2013 based on eq (36) Saragih 2011)
 		cv::Mat_<float> param_update;
 		cv::solve(Hessian, J_w_t_m, param_update, CV_CHOLESKY);
 
 		// To not overshoot, have the gradient decent rate a bit smaller
-		param_update = 0.5 * param_update;
+		param_update = 0.75 * param_update;
 
 		UpdateModelParameters(param_update, loc_params, glob_params);		
         
@@ -569,12 +564,12 @@ void PDM::CalcParams(cv::Vec6d& out_params_global, cv::Mat_<double>& out_params_
 
 		curr_shape_2D = cv::Mat(curr_shape_2D.t()).reshape(1, n * 2);
         
-        double error = cv::norm(curr_shape_2D - landmark_locations);
+        float error = cv::norm(curr_shape_2D - landmark_locations);
         
         if(0.999 * currError < error)
 		{
 			not_improved_in++;
-			if (not_improved_in == 5)
+			if (not_improved_in == 3)
 			{				
 	            break;
 			}
@@ -585,8 +580,7 @@ void PDM::CalcParams(cv::Vec6d& out_params_global, cv::Mat_<double>& out_params_
 	}
 
 	out_params_global = glob_params;
-	loc_params.convertTo(out_params_local, CV_64F);
+	out_params_local = loc_params;
-    	
 
 }
 
@@ -598,16 +592,22 @@ void PDM::Read(std::string location)
 	SkipComments(pdmLoc);
 
 	// Reading mean values
-	ReadMat(pdmLoc,mean_shape);
+	cv::Mat_<double> mean_shape_d;
+	ReadMat(pdmLoc, mean_shape_d);
+	mean_shape_d.convertTo(mean_shape, CV_32F); // Moving things to floats for speed
 	
 	SkipComments(pdmLoc);
 
 	// Reading principal components
-	ReadMat(pdmLoc,princ_comp);
+	cv::Mat_<double> princ_comp_d;
+	ReadMat(pdmLoc, princ_comp_d);
+	princ_comp_d.convertTo(princ_comp, CV_32F);
 	
 	SkipComments(pdmLoc);
 	
 	// Reading eigenvalues	
-	ReadMat(pdmLoc,eigen_values);
+	cv::Mat_<double> eigen_values_d;
+	ReadMat(pdmLoc, eigen_values_d);
+	eigen_values_d.convertTo(eigen_values, CV_32F);
 
 }

lib/local/GazeAnalyser/src/GazeEstimation.cpp

@@ -92,6 +92,7 @@ cv::Point3f GazeAnalysis::GetPupilPosition(cv::Mat_<double> eyeLdmks3d){
 void GazeAnalysis::EstimateGaze(const LandmarkDetector::CLNF& clnf_model, cv::Point3f& gaze_absolute, float fx, float fy, float cx, float cy, bool left_eye)
 {
 	cv::Vec6d headPose = LandmarkDetector::GetPose(clnf_model, fx, fy, cx, cy);
+
 	cv::Vec3d eulerAngles(headPose(3), headPose(4), headPose(5));
 	cv::Matx33d rotMat = LandmarkDetector::Euler2RotationMatrix(eulerAngles);
 
@@ -120,7 +121,9 @@ void GazeAnalysis::EstimateGaze(const LandmarkDetector::CLNF& clnf_model, cv::Po
 
 	cv::Mat faceLdmks3d = clnf_model.GetShape(fx, fy, cx, cy);
 	faceLdmks3d = faceLdmks3d.t();
+
 	cv::Mat offset = (cv::Mat_<double>(3, 1) << 0, -3.5, 7.0);
+
 	int eyeIdx = 1;
 	if (left_eye)
 	{

lib/local/LandmarkDetector/LandmarkDetector.vcxproj

@@ -56,6 +56,7 @@
     <Import Project="..\..\3rdParty\dlib\dlib.props" />
     <Import Project="..\..\3rdParty\tbb\tbb.props" />
     <Import Project="..\..\3rdParty\OpenCV3.1\openCV3.1.props" />
+    <Import Project="..\..\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -63,6 +64,7 @@
     <Import Project="..\..\3rdParty\dlib\dlib.props" />
     <Import Project="..\..\3rdParty\tbb\tbb.props" />
     <Import Project="..\..\3rdParty\OpenCV3.1\openCV3.1.props" />
+    <Import Project="..\..\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -70,6 +72,7 @@
     <Import Project="..\..\3rdParty\OpenCV3.1\openCV3.1.props" />
     <Import Project="..\..\3rdParty\boost\boost_d.props" />
     <Import Project="..\..\3rdParty\tbb\tbb_d.props" />
+    <Import Project="..\..\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -77,6 +80,7 @@
     <Import Project="..\..\3rdParty\OpenCV3.1\openCV3.1.props" />
     <Import Project="..\..\3rdParty\boost\boost_d.props" />
     <Import Project="..\..\3rdParty\tbb\tbb_d.props" />
+    <Import Project="..\..\3rdParty\OpenBLAS\OpenBLAS.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup>

lib/local/LandmarkDetector/include/CCNF_patch_expert.h

@@ -51,7 +51,7 @@ class CCNF_neuron{
 
 public:
 
-	// Type of patch (0=raw,1=grad,3=depth, other types besides raw are not actually used now)
+	// Type of patch (0=raw,1=grad other types besides raw are not actually used now)
 	int     neuron_type; 
 
 	// scaling of weights (needed as the energy of neuron might not be 1) 
@@ -112,7 +112,7 @@ public:
 
 	void Read(std::ifstream &stream, std::vector<int> window_sizes, std::vector<std::vector<cv::Mat_<float> > > sigma_components);
 
-	// actual work (can pass in an image and a potential depth image, if the CCNF is trained with depth)
+	// actual work (can pass in an image)
 	void Response(cv::Mat_<float> &area_of_interest, cv::Mat_<float> &response);
 
 	// Helper function to compute relevant sigmas

lib/local/LandmarkDetector/include/LandmarkDetectorUtils.h

@@ -53,7 +53,7 @@ namespace LandmarkDetector
 	// Helper functions for parsing the inputs
 	//=============================================================================================
 	void get_video_input_output_params(vector<string> &input_video_file, vector<string> &output_files,
-		vector<string> &output_video_files, string &output_codec, vector<string> &arguments);
+		vector<string> &output_video_files, bool& camera_coordinates_pose, string &output_codec, vector<string> &arguments);
 
 	void get_camera_params(int &device, float &fx, float &fy, float &cx, float &cy, vector<string> &arguments);
 

lib/local/LandmarkDetector/include/SVR_patch_expert.h

@@ -78,9 +78,8 @@ class SVR_patch_expert{
 		// Reading in the patch expert
 		void Read(std::ifstream &stream);
 
-		// The actual response computation from intensity or depth (for CLM-Z)
+		// The actual response computation from intensity
 		void Response(const cv::Mat_<float> &area_of_interest, cv::Mat_<float> &response);
-		void ResponseDepth(const cv::Mat_<float> &area_of_interest, cv::Mat_<float> &response);
 
 };
 //===========================================================================
@@ -105,9 +104,8 @@ class Multi_SVR_patch_expert{
 
 		void Read(std::ifstream &stream);
 
-		// actual response computation from intensity of depth (for CLM-Z)
+		// actual response computation from intensity
 		void Response(const cv::Mat_<float> &area_of_interest, cv::Mat_<float> &response);
-		void ResponseDepth(const cv::Mat_<float> &area_of_interest, cv::Mat_<float> &response);
 
 };
 }

lib/local/LandmarkDetector/src/LandmarkDetectorUtils.cpp

@@ -97,7 +97,7 @@ void create_directories(string output_path)
 
 // Extracting the following command line arguments -f, -op, -of, -ov (and possible ordered repetitions)
 void get_video_input_output_params(vector<string> &input_video_files, vector<string> &output_files,
-	vector<string> &output_video_files, string& output_codec, vector<string> &arguments)
+	vector<string> &output_video_files, bool& camera_coordinates_pose, string& output_codec, vector<string> &arguments)
 {
 	bool* valid = new bool[arguments.size()];
 
@@ -106,6 +106,9 @@ void get_video_input_output_params(vector<string> &input_video_files, vector<str
 		valid[i] = true;
 	}
 
+	// By default use world coordinate system
+	camera_coordinates_pose = false;
+
     // By default use DIVX codec
 	output_codec = "DIVX";
 
@@ -162,6 +165,10 @@ void get_video_input_output_params(vector<string> &input_video_files, vector<str
 			valid[i+1] = false;
 			i++;
 		}		
+		else if (arguments[i].compare("-camera_coord") == 0)
+		{
+			camera_coordinates_pose = true;
+		}
 		else if (arguments[i].compare("-oc") == 0)
 		{
 			if(arguments[i + 1].length() == 4)
@@ -966,14 +973,14 @@ void DrawBox(vector<pair<cv::Point, cv::Point>> lines, cv::Mat image, cv::Scalar
 // Computing landmarks (to be drawn later possibly)
 vector<cv::Point2d> CalculateVisibleLandmarks(const cv::Mat_<double>& shape2D, const cv::Mat_<int>& visibilities)
 {
-	int n = shape2D.rows/2;
+	int n = shape2D.rows / 2;
 	vector<cv::Point2d> landmarks;
 
-	for( int i = 0; i < n; ++i)
+	for (int i = 0; i < n; ++i)
 	{
-		if(visibilities.at<int>(i))
+		if (visibilities.at<int>(i))
 		{
-			cv::Point2d featurePoint(shape2D.at<double>(i), shape2D.at<double>(i +n));
+			cv::Point2d featurePoint(shape2D.at<double>(i), shape2D.at<double>(i + n));
 
 			landmarks.push_back(featurePoint);
 		}
@@ -989,21 +996,21 @@ vector<cv::Point2d> CalculateAllLandmarks(const cv::Mat_<double>& shape2D)
 	int n;
 	vector<cv::Point2d> landmarks;
 
-	if(shape2D.cols == 2)
+	if (shape2D.cols == 2)
 	{
 		n = shape2D.rows;
 	}
-	else if(shape2D.cols == 1)
+	else if (shape2D.cols == 1)
 	{
-		n = shape2D.rows/2;
+		n = shape2D.rows / 2;
 	}
 
-	for( int i = 0; i < n; ++i)
+	for (int i = 0; i < n; ++i)
 	{
 		cv::Point2d featurePoint;
-		if(shape2D.cols == 1)
+		if (shape2D.cols == 1)
 		{
-			featurePoint = cv::Point2d(shape2D.at<double>(i), shape2D.at<double>(i +n));
+			featurePoint = cv::Point2d(shape2D.at<double>(i), shape2D.at<double>(i + n));
 		}
 		else
 		{
@@ -1026,7 +1033,7 @@ vector<cv::Point2d> CalculateAllLandmarks(const CLNF& clnf_model)
 vector<cv::Point2d> CalculateVisibleLandmarks(const CLNF& clnf_model)
 {
 	// If the detection was not successful no landmarks are visible
-	if(clnf_model.detection_success)
+	if (clnf_model.detection_success)
 	{
 		int idx = clnf_model.patch_experts.GetViewIdx(clnf_model.params_global, 0);
 		// Because we only draw visible points, need to find which points patch experts consider visible at a certain orientation
@@ -1061,6 +1068,7 @@ vector<cv::Point2d> CalculateVisibleEyeLandmarks(const CLNF& clnf_model)
 	return to_return;
 }
 
+
 // Computing eye landmarks (to be drawn later or in different interfaces)
 vector<cv::Point2d> CalculateAllEyeLandmarks(const CLNF& clnf_model)
 {
@@ -1084,6 +1092,7 @@ vector<cv::Point2d> CalculateAllEyeLandmarks(const CLNF& clnf_model)
 	return to_return;
 }
 
+
 // Drawing landmarks on a face image
 void Draw(cv::Mat img, const cv::Mat_<double>& shape2D, const cv::Mat_<int>& visibilities)
 {

lib/local/LandmarkDetector/src/SVR_patch_expert.cpp

@@ -195,72 +195,6 @@ void SVR_patch_expert::Response(const cv::Mat_<float>& area_of_interest, cv::Mat
 
 }
 
-void SVR_patch_expert::ResponseDepth(const cv::Mat_<float>& area_of_interest, cv::Mat_<float> &response)
-{
-
-	// How big the response map will be
-	int response_height = area_of_interest.rows - weights.rows + 1;
-	int response_width = area_of_interest.cols - weights.cols + 1;
-	
-	// the patch area on which we will calculate reponses
-	cv::Mat_<float> normalised_area_of_interest;
-  
-	if(response.rows != response_height || response.cols != response_width)
-	{
-		response.create(response_height, response_width);
-	}
-
-	if(type == 0)
-	{
-		// Perform normalisation across whole patch
-		cv::Scalar mean;
-		cv::Scalar std;
-		
-		// ignore missing values
-		cv::Mat_<uchar> mask = area_of_interest > 0;
-		cv::meanStdDev(area_of_interest, mean, std, mask);
-
-		// if all values the same don't divide by 0
-		if(std[0] == 0)
-		{
-			std[0] = 1;
-		}
-
-		normalised_area_of_interest = (area_of_interest - mean[0]) / std[0];
-
-		// Set the invalid pixels to 0
-		normalised_area_of_interest.setTo(0, mask == 0);
-	}
-	else
-	{
-		printf("ERROR(%s,%d): Unsupported patch type %d!\n", __FILE__,__LINE__,type);
-		abort();
-	}
-  
-	cv::Mat_<float> svr_response;
-		
-	// The empty matrix as we don't pass precomputed dft's of image
-	cv::Mat_<double> empty_matrix_0(0,0,0.0);
-	cv::Mat_<float> empty_matrix_1(0,0,0.0);
-	cv::Mat_<float> empty_matrix_2(0,0,0.0);
-
-	// Efficient calc of patch expert response across the area of interest
-
-	matchTemplate_m(normalised_area_of_interest, empty_matrix_0, empty_matrix_1, empty_matrix_2, weights, weights_dfts, svr_response, CV_TM_CCOEFF); 
-	
-	response.create(svr_response.size());
-	cv::MatIterator_<float> p = response.begin();
-
-	cv::MatIterator_<float> q1 = svr_response.begin(); // respone for each pixel
-	cv::MatIterator_<float> q2 = svr_response.end();
-
-	while(q1 != q2)
-	{
-		// the SVR response passed through a logistic regressor
-		*p++ = 1.0/(1.0 + exp( -(*q1++ * scaling + bias )));
-	}	
-}
-
 // Copy constructor				
 Multi_SVR_patch_expert::Multi_SVR_patch_expert(const Multi_SVR_patch_expert& other) : svr_patch_experts(other.svr_patch_experts)
 {
@@ -321,17 +255,3 @@ void Multi_SVR_patch_expert::Response(const cv::Mat_<float> &area_of_interest, c
 
 }
 
-void Multi_SVR_patch_expert::ResponseDepth(const cv::Mat_<float>& area_of_interest, cv::Mat_<float>& response)
-{
-	int response_height = area_of_interest.rows - height + 1;
-	int response_width = area_of_interest.cols - width + 1;
-
-	if(response.rows != response_height || response.cols != response_width)
-	{
-		response.create(response_height, response_width);
-	}
-	
-	// With depth patch experts only do raw data modality
-	svr_patch_experts[0].ResponseDepth(area_of_interest, response);
-}
-//===========================================================================

matlab_runners/Action Unit Experiments/helpers/find_Bosphorus.m

@@ -1,5 +1,7 @@
 if(exist('D:/Datasets/Bosphorus/', 'file'))
     Bosphorus_dir = 'D:\Datasets\Bosphorus/';   
+elseif(exist('E:/Datasets/Bosphorus/', 'file'))
+    Bosphorus_dir = 'E:\Datasets\Bosphorus/';   
 else    
     fprintf('Bosphorus dataset location not found (or not defined)\n'); 
 end

matlab_runners/Action Unit Experiments/results/BP4D_valid_res_class.txt

@@ -1,11 +1,11 @@
-AU1 class, Precision - 0.503, Recall - 0.518, F1 - 0.511
+AU1 class, Precision - 0.555, Recall - 0.533, F1 - 0.544
-AU2 class, Precision - 0.377, Recall - 0.445, F1 - 0.408
+AU2 class, Precision - 0.403, Recall - 0.440, F1 - 0.420
-AU4 class, Precision - 0.456, Recall - 0.514, F1 - 0.484
+AU4 class, Precision - 0.491, Recall - 0.513, F1 - 0.502
-AU6 class, Precision - 0.735, Recall - 0.780, F1 - 0.757
+AU6 class, Precision - 0.741, Recall - 0.776, F1 - 0.758
-AU7 class, Precision - 0.762, Recall - 0.731, F1 - 0.746
+AU7 class, Precision - 0.764, Recall - 0.727, F1 - 0.745
-AU10 class, Precision - 0.846, Recall - 0.842, F1 - 0.844
+AU10 class, Precision - 0.849, Recall - 0.840, F1 - 0.845
-AU12 class, Precision - 0.887, Recall - 0.816, F1 - 0.850
+AU12 class, Precision - 0.887, Recall - 0.820, F1 - 0.852
-AU14 class, Precision - 0.544, Recall - 0.809, F1 - 0.650
+AU14 class, Precision - 0.542, Recall - 0.807, F1 - 0.649
-AU15 class, Precision - 0.400, Recall - 0.418, F1 - 0.409
+AU15 class, Precision - 0.402, Recall - 0.417, F1 - 0.409
-AU17 class, Precision - 0.627, Recall - 0.595, F1 - 0.611
+AU17 class, Precision - 0.631, Recall - 0.596, F1 - 0.613
-AU23 class, Precision - 0.332, Recall - 0.604, F1 - 0.428
+AU23 class, Precision - 0.335, Recall - 0.598, F1 - 0.429

matlab_runners/Action Unit Experiments/results/BP4D_valid_res_int.txt

@@ -1,5 +1,5 @@
-AU6 results - rms 0.866, corr 0.779, ccc - 0.732
+AU6 results - rms 0.858, corr 0.786, ccc - 0.737
 AU10 results - rms 1.044, corr 0.736, ccc - 0.678
-AU12 results - rms 0.828, corr 0.867, ccc - 0.827
+AU12 results - rms 0.828, corr 0.865, ccc - 0.827
-AU14 results - rms 1.103, corr 0.534, ccc - 0.487
+AU14 results - rms 1.104, corr 0.532, ccc - 0.485
-AU17 results - rms 0.835, corr 0.591, ccc - 0.486
+AU17 results - rms 0.833, corr 0.591, ccc - 0.490

matlab_runners/Action Unit Experiments/results/Bosphorus_res_class.txt

@@ -1,17 +1,17 @@
 AU1 class, Precision - 0.393, Recall - 0.727, F1 - 0.510
 AU2 class, Precision - 0.266, Recall - 0.850, F1 - 0.405
-AU4 class, Precision - 0.512, Recall - 0.874, F1 - 0.646
+AU4 class, Precision - 0.511, Recall - 0.874, F1 - 0.645
-AU5 class, Precision - 0.294, Recall - 0.968, F1 - 0.450
+AU5 class, Precision - 0.294, Recall - 0.968, F1 - 0.451
 AU6 class, Precision - 0.346, Recall - 0.833, F1 - 0.489
 AU7 class, Precision - 0.793, Recall - 0.750, F1 - 0.771
-AU9 class, Precision - 0.315, Recall - 0.960, F1 - 0.474
+AU9 class, Precision - 0.316, Recall - 0.960, F1 - 0.475
 AU10 class, Precision - 0.349, Recall - 0.773, F1 - 0.481
 AU12 class, Precision - 0.674, Recall - 0.864, F1 - 0.757
 AU14 class, Precision - 0.183, Recall - 0.863, F1 - 0.302
 AU15 class, Precision - 0.183, Recall - 0.851, F1 - 0.302
 AU17 class, Precision - 0.293, Recall - 0.889, F1 - 0.441
 AU20 class, Precision - 0.114, Recall - 0.930, F1 - 0.203
-AU23 class, Precision - 0.107, Recall - 0.889, F1 - 0.190
+AU23 class, Precision - 0.107, Recall - 0.889, F1 - 0.191
 AU25 class, Precision - 0.860, Recall - 0.873, F1 - 0.866
-AU26 class, Precision - 0.359, Recall - 0.811, F1 - 0.497
+AU26 class, Precision - 0.359, Recall - 0.811, F1 - 0.498
 AU45 class, Precision - 0.318, Recall - 0.771, F1 - 0.450

matlab_runners/Action Unit Experiments/results/Bosphorus_res_int.txt

@@ -1,7 +1,7 @@
 AU1 intensity, Corr - 0.717, RMS - 0.892, CCC - 0.668
 AU2 intensity, Corr - 0.696, RMS - 0.774, CCC - 0.625
-AU4 intensity, Corr - 0.802, RMS - 0.602, CCC - 0.776
+AU4 intensity, Corr - 0.802, RMS - 0.603, CCC - 0.776
-AU5 intensity, Corr - 0.747, RMS - 0.831, CCC - 0.640
+AU5 intensity, Corr - 0.747, RMS - 0.832, CCC - 0.640
 AU6 intensity, Corr - 0.556, RMS - 0.735, CCC - 0.533
 AU7 intensity, Corr - 0.831, RMS - 0.757, CCC - 0.804
 AU9 intensity, Corr - 0.779, RMS - 0.551, CCC - 0.738
@@ -14,4 +14,4 @@ AU20 intensity, Corr - 0.413, RMS - 0.880, CCC - 0.285
 AU23 intensity, Corr - 0.354, RMS - 0.753, CCC - 0.268
 AU25 intensity, Corr - 0.847, RMS - 0.818, CCC - 0.811
 AU26 intensity, Corr - 0.514, RMS - 0.955, CCC - 0.465
-AU45 intensity, Corr - 0.867, RMS - 0.550, CCC - 0.848
+AU45 intensity, Corr - 0.868, RMS - 0.550, CCC - 0.848

matlab_runners/Action Unit Experiments/results/DISFA_valid_res.txt

@@ -1,12 +1,12 @@
-AU1 results - corr 0.827, rms 0.412, ccc - 0.804
+AU1 results - corr 0.826, rms 0.412, ccc - 0.803
-AU2 results - corr 0.762, rms 0.446, ccc - 0.656
+AU2 results - corr 0.763, rms 0.445, ccc - 0.656
 AU4 results - corr 0.874, rms 0.565, ccc - 0.848
-AU5 results - corr 0.744, rms 0.181, ccc - 0.714
+AU5 results - corr 0.745, rms 0.181, ccc - 0.711
-AU6 results - corr 0.702, rms 0.604, ccc - 0.657
+AU6 results - corr 0.706, rms 0.592, ccc - 0.665
-AU9 results - corr 0.741, rms 0.384, ccc - 0.688
+AU9 results - corr 0.740, rms 0.385, ccc - 0.687
-AU12 results - corr 0.864, rms 0.510, ccc - 0.850
+AU12 results - corr 0.869, rms 0.494, ccc - 0.856
 AU15 results - corr 0.745, rms 0.269, ccc - 0.712
-AU17 results - corr 0.640, rms 0.521, ccc - 0.571
+AU17 results - corr 0.642, rms 0.517, ccc - 0.574
-AU20 results - corr 0.618, rms 0.311, ccc - 0.580
+AU20 results - corr 0.619, rms 0.311, ccc - 0.581
 AU25 results - corr 0.926, rms 0.500, ccc - 0.920
-AU26 results - corr 0.803, rms 0.449, ccc - 0.763
+AU26 results - corr 0.803, rms 0.449, ccc - 0.762

matlab_runners/Action Unit Experiments/results/FERA2011_res_class.txt

@@ -1,11 +1,11 @@
-AU1 class, Precision - 0.590, Recall - 0.714, F1 - 0.646
+AU1 class, Precision - 0.587, Recall - 0.720, F1 - 0.647
-AU2 class, Precision - 0.474, Recall - 0.750, F1 - 0.581
+AU2 class, Precision - 0.470, Recall - 0.797, F1 - 0.591
-AU4 class, Precision - 0.509, Recall - 0.745, F1 - 0.605
+AU4 class, Precision - 0.499, Recall - 0.753, F1 - 0.600
-AU6 class, Precision - 0.835, Recall - 0.667, F1 - 0.741
+AU6 class, Precision - 0.836, Recall - 0.674, F1 - 0.746
-AU7 class, Precision - 0.686, Recall - 0.792, F1 - 0.735
+AU7 class, Precision - 0.683, Recall - 0.791, F1 - 0.733
-AU10 class, Precision - 0.522, Recall - 0.738, F1 - 0.612
+AU10 class, Precision - 0.524, Recall - 0.748, F1 - 0.616
-AU12 class, Precision - 0.919, Recall - 0.658, F1 - 0.767
+AU12 class, Precision - 0.919, Recall - 0.659, F1 - 0.768
-AU15 class, Precision - 0.361, Recall - 0.638, F1 - 0.461
+AU15 class, Precision - 0.358, Recall - 0.639, F1 - 0.459
-AU17 class, Precision - 0.231, Recall - 0.280, F1 - 0.253
+AU17 class, Precision - 0.229, Recall - 0.287, F1 - 0.255
-AU25 class, Precision - 0.205, Recall - 0.871, F1 - 0.332
+AU25 class, Precision - 0.205, Recall - 0.869, F1 - 0.332
-AU26 class, Precision - 0.122, Recall - 0.974, F1 - 0.217
+AU26 class, Precision - 0.122, Recall - 0.972, F1 - 0.216

matlab_runners/Action Unit Experiments/results/SEMAINE_valid_res.txt

@@ -1,6 +1,6 @@
-AU2 class, Precision - 0.360, Recall - 0.742, F1 - 0.485
+AU2 class, Precision - 0.361, Recall - 0.746, F1 - 0.487
-AU12 class, Precision - 0.427, Recall - 0.781, F1 - 0.552
+AU12 class, Precision - 0.424, Recall - 0.781, F1 - 0.550
-AU17 class, Precision - 0.111, Recall - 0.813, F1 - 0.195
+AU17 class, Precision - 0.110, Recall - 0.812, F1 - 0.194
-AU25 class, Precision - 0.337, Recall - 0.523, F1 - 0.410
+AU25 class, Precision - 0.338, Recall - 0.525, F1 - 0.411
-AU28 class, Precision - 0.430, Recall - 0.471, F1 - 0.450
+AU28 class, Precision - 0.432, Recall - 0.475, F1 - 0.453
 AU45 class, Precision - 0.295, Recall - 0.615, F1 - 0.399

matlab_runners/Action Unit Experiments/run_AU_prediction_BP4D.m

@@ -1,7 +1,7 @@
 clear
 
-bp4d_loc = 'D:/Datasets/FERA_2015/BP4D/BP4D-training/';
+find_BP4D;
-
+BP4D_dir = [BP4D_dir, '../BP4D-training/'];
 out_loc = './out_bp4d/';
 
 if(~exist(out_loc, 'dir'))
@@ -21,9 +21,9 @@ new_bp4d_dirs = {};
 
 % This might take some time
 for i = 1:numel(bp4d_dirs)
-    dirs = dir([bp4d_loc, '/', bp4d_dirs{i}, '/T*']);
+    dirs = dir([BP4D_dir, '/', bp4d_dirs{i}, '/T*']);
 
-    tmp_dir = [bp4d_loc, '/../tmp/', bp4d_dirs{i}, '/'];
+    tmp_dir = [BP4D_dir, '/../tmp/', bp4d_dirs{i}, '/'];
     new_bp4d_dirs = cat(1, new_bp4d_dirs, tmp_dir);
 
     if(~exist(tmp_dir, 'file'))
@@ -32,11 +32,11 @@ for i = 1:numel(bp4d_dirs)
         % Move all images and resize them
         for d=1:numel(dirs)
 
-            in_files = dir([bp4d_loc, '/', bp4d_dirs{i}, '/', dirs(d).name, '/*.jpg']);
+            in_files = dir([BP4D_dir, '/', bp4d_dirs{i}, '/', dirs(d).name, '/*.jpg']);
 
             for img_ind=1:numel(in_files)
 
-                img_file = [bp4d_loc, '/', bp4d_dirs{i}, '/', dirs(d).name, '/', in_files(img_ind).name];
+                img_file = [BP4D_dir, '/', bp4d_dirs{i}, '/', dirs(d).name, '/', in_files(img_ind).name];
                 img = imread(img_file);
                 img = imresize(img, 0.5);
                 img_out = [tmp_dir, dirs(d).name, '_', in_files(img_ind).name];

matlab_runners/Action Unit Experiments/run_AU_prediction_Bosphorus.m

@@ -48,6 +48,7 @@ end_ind = -1;
 aus_det = [];
 aus_det_id = [];
 
+%%
 while ischar(data)
     if(~isempty(findstr(data, 'au occurences:')))
         num_occurences = str2num(data(numel('au occurences:')+1:end));

matlab_runners/Demos/feature_extraction_demo_vid.m

@@ -93,6 +93,7 @@ for j = 1:size(xs,1)
     hold on;
     plot(xs_eye(j,:), -ys_eye(j,:), '.');
     hold off;
+
     xlim([min(xs(1,:)) * 0.5, max(xs(2,:))*1.4]);
     ylim([min(-ys(1,:)) * 1.4, max(-ys(2,:))*0.5]);
     xlabel('x (px)');
@@ -148,21 +149,16 @@ title('Pose (rotation and translation)');
 xlabel('Time (s)');
 
 %% Demo gaze
-gaze_inds = cellfun(@(x) ~isempty(x) && x==1, strfind(column_names, 'gaze_'));
+gaze_inds = cellfun(@(x) ~isempty(x) && x==1, strfind(column_names, 'gaze_angle'));
 
 % Read gaze (x,y,z) for one eye and (x,y,z) for another
 gaze = all_params(valid_frames, gaze_inds);
 
-% only picking left, right and up down views for visualisation
-gaze = (gaze(:,[1,2]) + gaze(:,[4,5]))/2;
-gaze(:,1) = smooth(gaze(:,1));
-gaze(:,2) = smooth(gaze(:,2));
-
 plot(time, gaze(:,1), 'DisplayName', 'Left - right');
 hold on;
 plot(time, gaze(:,2), 'DisplayName', 'Up - down');
 xlabel('Time(s)') % x-axis label
-ylabel('Gaze vector size') % y-axis label
+ylabel('Angle radians') % y-axis label
 legend('show');
 hold off;
 

matlab_runners/Full_test_suite.m

@@ -5,7 +5,7 @@ tic
 %% Head pose
 cd('Head Pose Experiments');
 run_head_pose_tests_OpenFace;
-assert(median(all_errors_biwi_OF(:)) < 2.7);
+assert(median(all_errors_biwi_OF(:)) < 2.8);
 assert(median(all_errors_bu_OF(:)) < 2.2);
 assert(median(all_errors_ict_OF(:)) < 2.1);
 cd('../');
@@ -29,9 +29,6 @@ run_AU_prediction_BP4D
 assert(mean(ints_cccs) > 0.6);
 assert(mean(f1s_class) > 0.6);
 
-run_AU_prediction_UNBC
-assert(mean(ints_cccs) > 0.38);
-
 run_AU_prediction_DISFA
 assert(mean(au_res) > 0.7);
 

matlab_runners/Head Pose Experiments/results/Pose_OF.txt

@@ -1,4 +1,4 @@
 Dataset and model,        pitch,  yaw,  roll,  mean,  median
-biwi error:  7.092,   5.170, 4.657,  5.640,  2.607
+biwi error:  7.779,   6.302, 4.440,  6.174,  2.779
-bu error:    2.769,   4.105, 2.569,  3.147,  2.118
+bu error:    2.739,   3.348, 2.458,  2.848,  1.975
-ict error:   3.489,   3.632, 3.538,  3.553,  2.029
+ict error:   3.501,   3.988, 3.298,  3.596,  1.968

matlab_runners/Head Pose Experiments/run_biwi_experiment.m

@@ -1,4 +1,4 @@
-function [output_dir] = run_biwi_experiment(rootDir, biwiDir, verbose, depth, varargin)
+function [output_dir] = run_biwi_experiment(rootDir, biwiDir, verbose, varargin)
 % Biwi dataset experiment
 
 if(isunix)
@@ -11,10 +11,6 @@ output_dir = 'experiments/biwi_out';
 
 dbSeqDir = dir([rootDir biwiDir]);
    
-if(depth)
-    output_dir = cat(2, output_dir, '_depth');
-end
-
 output_dir = cat(2, output_dir, '/');
 
 offset = 0;
@@ -43,17 +39,12 @@ for i=3 + offset:numTogether:numel(dbSeqDir)
 
         command = cat(2, command, [' -f "' inputFile '" -of "' outputFile  '"']);
 
-        if(depth)
-            dDir = [biwiDir dbSeqDir(i+n).name '/depthAligned/'];
-            command = cat(2, command, [' -fd "' dDir '"']);    
-        end
-
         if(verbose)
             outputVideo = [output_dir dbSeqDir(i).name '.avi'];
             command = cat(2, command, [' -ov "' outputVideo '"']);    
         end
     end    
-    command = cat(2, command, [' -fx 505 -fy 505 -cx 320 -cy 240 -no2Dfp -no3Dfp -noMparams -noAUs -noGaze -vis-track']);
+    command = cat(2, command, [' -fx 505 -fy 505 -cx 320 -cy 240 -no2Dfp -no3Dfp -noMparams -noAUs -noGaze -vis-track ']);
         
     if(any(strcmp('model', varargin)))
         command = cat(2, command, [' -mloc "', varargin{find(strcmp('model', varargin))+1}, '"']);

matlab_runners/Head Pose Experiments/run_head_pose_tests_OpenFace.m

@@ -27,7 +27,7 @@ buDir = [database_root, '/bu/uniform-light/'];
 % Run the Biwi test
 biwi_dir = '/biwi pose/';
 
-[res_folder_biwi_OF] = run_biwi_experiment(database_root, biwi_dir, false, false, 'model', 'model/main_clnf_general.txt');
+[res_folder_biwi_OF] = run_biwi_experiment(database_root, biwi_dir, false, 'model', 'model/main_clnf_general.txt');
 % Calculate the resulting errors
 [biwi_error_OF, pred_hp_biwi, gt_hp_biwi, ~, all_errors_biwi_OF, rels_biwi] = calcBiwiError(res_folder_biwi_OF, [database_root biwi_dir]);
 
@@ -35,7 +35,7 @@ biwi_dir = '/biwi pose/';
 ict_dir = ['/ict/'];
 
 % Intensity
-[res_folder_ict_OF] = run_ict_experiment(database_root, ict_dir, false, false, 'model', 'model/main_clnf_general.txt');
+[res_folder_ict_OF] = run_ict_experiment(database_root, ict_dir, false, 'model', 'model/main_clnf_general.txt');
 % Calculate the resulting errors
 [ict_error_OF, pred_hp_ict, gt_hp_ict, ~, all_errors_ict_OF, rel_ict] = calcIctError(res_folder_ict_OF, [database_root ict_dir]);
 

matlab_runners/Head Pose Experiments/run_ict_experiment.m

@@ -1,4 +1,4 @@
-function [output_dir] = run_ict_experiment(rootDir, ictDir, verbose, depth, varargin)
+function [output_dir] = run_ict_experiment(rootDir, ictDir, verbose, varargin)
 %EVALUATEICTDATABASE Summary of this function goes here
 %   Detailed explanation goes here
 
@@ -12,10 +12,6 @@ output_dir = 'experiments/ict_out';
 
 dbSeqDir = dir([rootDir ictDir]);
    
-if(depth)
-    output_dir = cat(2, output_dir, '_depth');
-end
-
 output_dir = cat(2, output_dir, '/');
 
 numTogether = 10;
@@ -38,11 +34,6 @@ for i=3:numTogether:numel(dbSeqDir)
         
         command = cat(2, command,  [' -f "' inputFile '" -of "' outputFile  '" ']);
                 
-        if(depth)
-            dDir = [ictDir dbSeqDir(i+n).name '/depthAligned/'];
-            command = cat(2, command, [' -fd "' dDir '"']);
-        end
-        
         if(verbose)
             outputVideo = [output_dir dbSeqDir(i+n).name '.avi'];
             command = cat(2, command, [' -ov "' outputVideo '"']);

matlab_version/face_detection/mtcnn/setup.m

@@ -0,0 +1,23 @@
+function setup(varargin)
+
+addpath C:\matconvnet\matconvnet-1.0-beta25\examples;
+
+opts.useGpu = false ;
+opts.verbose = false ;
+opts = vl_argparse(opts, varargin) ;
+
+try
+  vl_nnconv(single(1),single(1),[]) ;
+catch
+  warning('VL_NNCONV() does not seem to be compiled. Trying to compile it now.') ;
+  vl_compilenn('enableGpu', opts.useGpu, 'verbose', opts.verbose) ;
+end
+
+if opts.useGpu
+  try
+    vl_nnconv(gpuArray(single(1)),gpuArray(single(1)),[]) ;
+  catch
+    vl_compilenn('enableGpu', opts.useGpu, 'verbose', opts.verbose) ;
+    warning('GPU support does not seem to be compiled in MatConvNet. Trying to compile it now') ;
+  end
+end