Examine the following code to have a better understanding of the PCA algorithm for face recognition, Use the following code. Create a Windows forms application called FaceRecogPCA. Place picture boxes, buttons and Labels as shown below. The square boxes below are picture boxes.
Output Format:
Implementation
Here code implemented in C#, you need to implement it using python. If you need to any help in python computer vision then hire realcode4you expert and get instant help with and affordable price.
using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
namespace FaceRecogPCA
{
/// <summary>
/// Summary description for MyImage.
/// </summary>
public class MyImage : IComparable, ICloneable
{
public int Width { get; set; }
public int Height { get; set; }
public Bitmap BmpImg { get; set; }
public string Id { get; set; } // id of image
public string FileName { get; set; } // full path name
public string FileNameShort { get; set; } // short file name for image
public double ImgMean { get; set; }
public double[] ImgVector;// linearized pixel values
public double[] ImgVectorAdjM;// linearized pixel values minus mean image
public double[] FSV;// Face space vector, projection onto reduced Dimension
ImgComparison imgCompareMode;
public ImgComparison ImgCompareMode { get; set; }
public double CorrError { get; set; }
public double EuclideanError { get; set; } // L2 Norm
public MyImage()
{
}
public MyImage(int width, int height, string id)
{
this.Id = id;
this.ImgVector = new double[width * height];
}
public MyImage(string fname, string id, int width, int height, ImgFormat imf,
ImgComparison imc)
{
FileInfo finfo = new FileInfo(fname);
string dirName = finfo.Directory.Name;
this.FileNameShort = finfo.Name;
this.Id = id;
this.FileName = fname;
imgCompareMode = imc;
ReadPic(imf, width, height); // read the picture into an 1-D array
FindImageMean();
this.ImgVectorAdjM = new double[width * height];
this.FSV = new double[width * height];
}
private void ReadPic(ImgFormat imf, int width, int height)
{
try
{
Bitmap b = new Bitmap(this.FileName);
this.BmpImg = new Bitmap(b, new Size(width, height));
ImgVector = new double[width * height];
int k = 0; int r1a, g1a, b1a, gray;
Color c1;
for (int i = 0; i < height; i++)
for (int j = 0; j < width; j++)
{
c1 = b.GetPixel(j, i);
r1a = c1.R;
g1a = c1.G;
b1a = c1.B;
if (r1a != b1a)
gray = (int)(.299 * r1a
+ .587 * g1a
+ .114 * b1a);
else
gray = b1a;
ImgVector[k++] = gray;
}
}
catch (Exception ex)
{
throw new Exception(ex.Message + "ImageArray Creation Error");
}
}
//-------------------FindImageMean---------------------------
void FindImageMean()
{
double imgSum = 0;
for (int i = 0; i < this.ImgVector.Length; i++)
imgSum = imgSum + this.ImgVector[i];
this.ImgMean = imgSum / this.ImgVector.Length;
}
//------------------------------------------------------------------
public int CompareTo(Object rhs) // for sorting
{
MyImage im = (MyImage)rhs;
if (imgCompareMode == ImgComparison.CORRELATION)
return im.CorrError.CompareTo(this.CorrError); // index 0 is best
else
return im.EuclideanError.CompareTo(this.EuclideanError);
}
public object Clone() // for in memory copy
{
MyImage clone = (MyImage)this.MemberwiseClone();
if (this.FSV != null)
clone.FSV = (double[])(this.FSV.Clone());
if (this.ImgVector != null)
clone.ImgVector = (double[])(this.ImgVector.Clone());
if (this.ImgVectorAdjM != null)
clone.ImgVectorAdjM = (double[])(this.ImgVectorAdjM.Clone());
return clone;
}
}
}
Add a class to the project called “MyEnums.cs” with the following code in it.
namespace FaceRecogPCA
{
public enum ImgFormat:int
{
EightBit,
TwentyFourBit
}
public enum ImgComparison : int
{
CORRELATION,
EUCLIDEAN
}
}
Add a class called EigenFace to the project with the following code in it.
//--------Eigenface.cs---------------
using System;
using System.Collections;
namespace FaceRecogPCA
{
public class EigenFace : ICloneable
{ // EigenFace is one of the basis vectors after
// dimensionality reduction
public double [] EF;
public int size;
public double []Xvar2;
public double EigenValue;
public EigenFace()
{
}
public EigenFace(int sz)
{
EF = new double[sz];
Xvar2=new Double[sz];
size = sz;
}
public object Clone() // for in memory copy
{
EigenFace copy = new EigenFace();
if (this.EF != null)
copy.EF = (double []) this.EF.Clone();
copy.EigenValue = this.EigenValue;
copy.size = this.size;
if (this.Xvar2 != null)
copy.Xvar2 = (double []) this.Xvar2.Clone();
return copy;
}
}
}
Add a class called EvEvec for storing the EigenValues and the EigenVectors with the following code in it.
This is done so that we can easily sort by Eigen values.
using System;
namespace FaceRecogPCA
{
public class EvEvec : IComparable, ICloneable
{
public double EigenValue; // Eigen value
public double[] EigenVec; // Eigen Vector Array
public int size; // Size of Eigen Vector array
public EvEvec()
{
}
public EvEvec(double Ev, double[] Evc, int sz)
{
EigenVec = new double[sz];
EigenValue = Ev;
size = sz;
for (int i = 0; i < sz; i++)
EigenVec[i] = Evc[i];
// EVecs are already normalized i.e., magnitude of 1
}
public int CompareTo(Object rhs) // for sorting
{
EvEvec evv = (EvEvec)rhs; // highest to lowest sorting by Eigen value
return evv.EigenValue.CompareTo(this.EigenValue);
}
public object Clone() // for making a copy of the EvEvec object
{
EvEvec clone = new EvEvec();
clone.EigenValue = this.EigenValue;
if (this.EigenVec != null)
clone.EigenVec = (double[])this.EigenVec.Clone();
clone.size = this.size;
return clone;
}
}
}
The main PCA algorithm is encapsulated in the FaceRecogByEF class with the following code in it.
//----------------FaceRecogByEF.cs-----------------
//--- contains important functions for recognizing face by the
//--- Eigen Face technique.
using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Collections;
using System.IO;
using System.Threading;
using System.Linq;
using System.Collections.Generic;
namespace FaceRecogPCA
{
public class FaceRecogByEF
{
public List<MyImage> ImageList; // list of stored images
public MyImage AvgImage = new MyImage();
public Matrix Cov = null; // Covariance Matrix
public Matrix I = null; // matrix of mean adjusted images
public double[] Evals; // Eigen Values
public double[,] Evecs; // Eigen Vectors
public List<EvEvec> EVList; // Eigen values and vectors
public List<EigenFace> EigenFaceList = new List<EigenFace>();
// list of Eigen faces
public Matrix EigenFaceMatrix;
public MyImage unkIm;
private int imageWidth;
private int imageHeight;
public int imageNumPixels;
private int NumEigenFaces; // significant number of EigenFaces
//--------------------------------------------------
public FaceRecogByEF(int imWidth, int imHeight, int imPixels, int M)
{
imageWidth = imWidth;
imageHeight = imHeight;
imageNumPixels = imPixels;
this.NumEigenFaces = M;
}
//----------------------ComputeEFs()----------------
public void ComputeEFs(ImgComparison imgComparison, string imagesFolder) //
Euclidean or Corr
{
ImageList = new List<MyImage>();
//EigenFaceList = new List<EigenFace>();
EVList = new List<EvEvec>();
// Scan Stored Image directory and add every jpg to
// ImageList
try
{
//DirectoryInfo dirInfo = new DirectoryInfo(currDir + "\\" + Sto_ImDir);
DirectoryInfo dirInfo = new DirectoryInfo(imagesFolder);
if (!dirInfo.Exists)
throw new DirectoryNotFoundException(imagesFolder +
"folder does not exist,");
foreach (FileInfo nextFile in dirInfo.GetFiles())
{
if (nextFile.Extension.ToUpper() == ".JPG")
this.ImageList.Add(new MyImage(nextFile.FullName, "II",
imageWidth, imageHeight, ImgFormat.TwentyFourBit, imgComparison)); // Euclidean or Corr
else
if (nextFile.Extension.ToUpper() == ".GIF")
this.ImageList.Add(new MyImage(nextFile.FullName, "II",
imageWidth, imageHeight, ImgFormat.EightBit, imgComparison));
}
}
catch (Exception ex)
{
throw new Exception(ex.Message + "Error creating the ImageList..");
}
AdjustAllImages(); // subtract mean image from each image
ComputeCovMatrix();
ComputeEigenValuesEigenVectors();
ComputeEigenFaces();
ComputeKnownFaceSpace(); // projection of images onto reduced dim
}
//-------------------------------------------------
//--------------------FindAvgImageAndAdjustImages()------------
void AdjustAllImages()
{ // finds average image, then subtracts average image from
// each image to obtain zero mean images
try
{
// find average image
double[] sum = new double[imageWidth * imageHeight];
for (int i = 0; i < sum.Length; i++)
sum[i] = 0;
for (int i = 0; i < sum.Length; i++)
{
foreach (MyImage img in ImageList)
{
sum[i] += img.ImgVector[i];
}
}
this.AvgImage.ImgVector = new double[sum.Length];
for (int i = 0; i < sum.Length; i++)
this.AvgImage.ImgVector[i] = sum[i] / ImageList.Count;
// subtract average image from each image
foreach (MyImage mimg in ImageList)
{
SubtractAvgImage(mimg);
}
int numImages = ImageList.Count;
I = new Matrix(imageWidth * imageHeight, numImages);
int count = 0;
// copy mean adjusted images into I matrix
foreach (MyImage mimg in ImageList)
{
for (int j = 0; j < mimg.ImgVectorAdjM.Length; j++)
I[j, count] = mimg.ImgVectorAdjM[j];
count++;
}
}
catch (Exception)
{
throw;
}
}
//-------------------------------------------------------------
//----------------SubtractAvgImage()---------------------
public void SubtractAvgImage(MyImage img1)
{
// subtract average image from given image
for (int i = 0; i < img1.ImgVector.Length; i++)
{
img1.ImgVectorAdjM[i] = img1.ImgVector[i] -
this.AvgImage.ImgVector[i];
}
}
//-------------------------------------------------
//---------------------ComputeCovMatrix--------------------
private void ComputeCovMatrix() // covariance matrix
{
Cov = (Matrix)((I.Transpose().Multiply(I)));
}
//-------------------------------------------------
private void ComputeEigenValuesEigenVectors()
{
int i, j;
int n = ImageList.Count;
Evals = new double[n];
IMatrix Evecs = new Matrix(n, n);
IEigenvalueDecomposition eigen = Cov.GetEigenvalueDecomposition();
Evecs = eigen.EigenvectorMatrix;
Evals = eigen.RealEigenvalues;
//---Copy the Eigen values and vectors in EvEvec objects
//---for easier sorting by Eigen values.
double[] evcTemp = new double[n];
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
evcTemp[j] = Evecs[j, i];
EVList.Add(new EvEvec(Evals[i], evcTemp, n));
}
EVList.Sort(); // sorts, highest Eigen value in pos. 0
}
//----------------------------------------------------------
//-----------ComputeEigenFaces()-------------------------
private void ComputeEigenFaces()
{
int numEFs = 0;
if (ImageList.Count < NumEigenFaces)
numEFs = ImageList.Count;
else
numEFs = NumEigenFaces;
EigenFaceMatrix = new Matrix(imageWidth * imageHeight, numEFs);
// copy EigenVectors into a Matrix
Matrix EV = new Matrix(ImageList.Count, NumEigenFaces);
for (int i = 0; i < NumEigenFaces; i++)
{
for (int j = 0; j < ImageList.Count; j++)
EV[j, i] = EVList[i].EigenVec[j];
}
EigenFaceMatrix = (Matrix)(I.Multiply(EV));
//normalize EigenFace(it is an eigen vector of orig.covar matrix)
for (int j = 0; j < NumEigenFaces; j++)
{
double rsum = 0;
for (int i = 0; i < imageNumPixels; i++)
{
rsum += EigenFaceMatrix[i, j] * EigenFaceMatrix[i, j];
}
for (int i = 0; i < imageNumPixels; i++)
EigenFaceMatrix[i, j] = EigenFaceMatrix[i, j] / Math.Sqrt(rsum);
}
// Copy Eigen Faces to a List for easier display later
for (int i = 0; i < NumEigenFaces; i++)
{
EigenFace ef = new EigenFace(imageWidth * imageHeight);
for (int j = 0; j < imageWidth * imageHeight; j++)
ef.EF[j] = EigenFaceMatrix[j, i];
EigenFaceList.Add(ef);
}
}
//---------------------------------------------------------
//----------ComputeKnownFaceSpace()----------------
private void ComputeKnownFaceSpace()
{
Matrix projection = (Matrix)(I.Transpose().Multiply(EigenFaceMatrix));
for (int i = 0; i < ImageList.Count; i++)
{
for (int j = 0; j < NumEigenFaces; j++)
ImageList[i].FSV[j] = projection[i, j];
}
}
//-------------------------------------------------
//----------ComputeFaceSpace()---------------------
public void ComputeFaceSpace(MyImage im)
{
int i, j;
double rsum;
for (i = 0; i < EigenFaceList.Count; i++)
{
rsum = 0.0;
for (j = 0; j < imageNumPixels; j++)
{
EigenFace ef = (EigenFace)EigenFaceList[i];
rsum = rsum + im.ImgVectorAdjM[j] * ef.EF[j];
}
im.FSV[i] = rsum;
}
}
//-------------------------------------------------
//-------------------NormalizeEigenFaces()-----------
void NormalizeEigenFaces()
{
// normalize the EigenFace to 0-255 range
foreach (EigenFace ef in EigenFaceList)
{
double max1 = (from n in ef.EF select n).Max();
double min = (from n in ef.EF select n).Min();
double diff = max1 - min;
for (int i = 0; i < ef.EF.Length; i++)
{
ef.EF[i] = ef.EF[i] - min;
ef.EF[i] = ef.EF[i] / diff * 255;
if (ef.EF[i] < 0)
ef.EF[i] = 0;
if (ef.EF[i] > 255)
ef.EF[i] = 255;
}
}
}
//---------------------------------------------------
//--------------GetReconstructedFaceSpaceImage(MyImage img)------------
public MyImage GetMatchedAndReconstructedImages(MyImage inputImg,
ref double selfReconstError, ref MatchResult[] bestMatches)
{
// assumes data is in Imagevector
MyImage recImage = new MyImage();
recImage.ImgVectorAdjM = new double[inputImg.ImgVectorAdjM.Length];
// subtract mean image from input image
SubtractAvgImage(inputImg);
//-------FSV for input image-----------------
ComputeFaceSpace(inputImg);
double[] fsvData = inputImg.FSV;
// Reconstruct the input image
double[] recData = new double[inputImg.ImgVectorAdjM.Length];
for (int j = 0; j < inputImg.ImgVectorAdjM.Length; j++)
{
recData[j] = 0;
for (int i = 0; i < NumEigenFaces; i++)
{
recData[j] += fsvData[i] * ((EigenFace)EigenFaceList[i]).EF[j];
}
}
// normalize the reconstructed image to 255 range
double max1 = (from n in recData select n).Max();
double min = (from n in recData select n).Min();
double diff = max1 - min;
for (int i = 0; i < inputImg.ImgVectorAdjM.Length; i++)
{
recData[i] = recData[i] - min;
recData[i] = (recData[i] / diff) * 255;
recData[i] = recData[i];
if (recData[i] < 0)
recData[i] = 0;
if (recData[i] > 255)
recData[i] = 255;
}
// add mean image
for (int i = 0; i < recData.Length; i++)
recImage.ImgVectorAdjM[i] = recData[i] + this.AvgImage.ImgVector[i];
// readjust the reconstructed image to 0-255 range
max1 = (from n in recImage.ImgVectorAdjM select n).Max();
min = (from n in recImage.ImgVectorAdjM select n).Min();
diff = max1 - min;
for (int i = 0; i < recImage.ImgVectorAdjM.Length; i++)
{
recImage.ImgVectorAdjM[i] = recImage.ImgVectorAdjM[i] - min;
recImage.ImgVectorAdjM[i] = (recImage.ImgVectorAdjM[i] / diff) * 255;
if (recImage.ImgVectorAdjM[i] < 0)
recImage.ImgVectorAdjM[i] = 0;
if (recImage.ImgVectorAdjM[i] > 255)
recImage.ImgVectorAdjM[i] = 255;
}
selfReconstError = 0;
for (int i = 0; i < inputImg.ImgVectorAdjM.Length; i++)
selfReconstError = selfReconstError + (inputImg.ImgVector[i] -
recImage.ImgVectorAdjM[i]) * (inputImg.ImgVector[i] -
recImage.ImgVectorAdjM[i]);
selfReconstError = Math.Sqrt(selfReconstError);
//-----------find best match----------------------------
MatchResult[] MR = new MatchResult[ImageList.Count];
for (int i = 0; i < ImageList.Count; i++)
{
MR[i] = new MatchResult(i, 0, (MyImage)((MyImage)ImageList[i]).Clone());
double dist = 0;
for (int j = 0; j < NumEigenFaces; j++)
dist += ((MR[i].mImage.FSV[j] - inputImg.FSV[j]) *
(MR[i].mImage.FSV[j] - inputImg.FSV[j]));
MR[i].EucledianDist = Math.Sqrt(dist);
}
//--------------find correlation--------------------
double[] corr = FindCorrelation(inputImg);
for (int i = 0; i < ImageList.Count; i++)
MR[i].Correlation = corr[i];
Array.Sort(MR);
bestMatches = MR;
return recImage;
}
public double[] FindCorrelation(MyImage unkIm)
{
//----------------correlation ---------------
// m |
// S(Xi-X')*(Yi-Y') |--> rtop
// i=0 |
// Correlation = --------------------
// m m |
// S(Xi-X')² * S(Yi-Y')² |--> rbot1 ^ rbot2
// i=0 i=0 |
//-------------------------------------------
int i, j, k;
double rsum = 0; double avgunk;
double[] avgi = new double[ImageList.Count];
//---------Calculates the unknown face space average---------//
//------------------ Y' ---------------------------------//
for (k = 0; k < EigenFaceList.Count; k++)
{
rsum = rsum + unkIm.FSV[k];
}
avgunk = rsum / EigenFaceList.Count;
//---------Calculates the known face space average---------//
//------------------ X' ---------------------------------//
for (i = 0; i < ImageList.Count; i++)
{
rsum = 0.0;
MyImage im = (MyImage)ImageList[i];
for (k = 0; k < EigenFaceList.Count; k++)//review
{
rsum = rsum + im.FSV[k];
}
avgi[i] = rsum / EigenFaceList.Count;
}
//----Calculate the Numerator of the Correlation Equation----//
double[] rtop = new double[ImageList.Count];
for (i = 0; i < ImageList.Count; i++)
{
rtop[i] = 0.0;
for (j = 0; j < EigenFaceList.Count; j++)
{
MyImage im = (MyImage)ImageList[i];
rtop[i] = rtop[i] + (im.FSV[j] - avgi[i]) *
(unkIm.FSV[j] - avgunk);
}
}
//---Calculate the Denominator of the Correlation Equation----//
double[] rbot1 = new Double[ImageList.Count];
double[] rbot2 = new Double[ImageList.Count];
for (i = 0; i < ImageList.Count; i++)
{
rbot1[i] = 0.0; rbot2[i] = 0.0;
for (j = 0; j < EigenFaceList.Count; j++)
{
MyImage im = (MyImage)ImageList[i];
rbot1[i] = rbot1[i] + (im.FSV[j] - avgi[i]) * (im.FSV[j] - avgi[i]);
rbot2[i] = rbot2[i] + (unkIm.FSV[j] - avgunk) * (unkIm.FSV[j] -
avgunk);
}
}
//----Calculate the final Correlation Equation----//
double[] corr = new double[ImageList.Count];
for (i = 0; i < ImageList.Count; i++)
corr[i] = rtop[i] / Math.Sqrt(rbot1[i] * rbot2[i]);
return corr;
}
//-------------------------------------------------
//-----------Finds the LSE ------------------------
public void FindLSE()
{
// ResultVec = new Double[ImageList.Count];
for (int i = 0; i < ImageList.Count; i++)
{
double rsum = 0.0;
MyImage im = (MyImage)ImageList[i];
for (int k = 0; k < EigenFaceList.Count; k++)//review
{
rsum = rsum + (im.FSV[k] - unkIm.FSV[k]) * (im.FSV[k] -
unkIm.FSV[k]);
}
}
}
}
}
Add a class called MatchResult to the project for displaying best matches to a given input image.
//-----------MatchResult.cs--------------------
using System;
namespace FaceRecogPCA
{
/// <summary>
/// Summary description for MatchResult.
/// </summary>
public class MatchResult : IComparable, ICloneable
{
public double Correlation;
public double EucledianDist;
public MyImage mImage;
public int ImageNum;
public string ImageName;
public MatchResult(int Imnum, double err, MyImage img)
{
ImageNum = Imnum;
if (img.FileNameShort.Length > 10)
ImageName = img.FileNameShort.Substring(img.FileNameShort.Length - 10,
9);
else
ImageName = img.FileNameShort;
mImage = img;
if (img.ImgCompareMode == ImgComparison.CORRELATION)
Correlation = err;
else
EucledianDist = err;
}
public int CompareTo(Object rhs) // for sorting
{
MatchResult mr = (MatchResult)rhs;
if (mImage.ImgCompareMode == ImgComparison.CORRELATION)
return mr.Correlation.CompareTo(this.Correlation); // high corr is best
else
return this.EucledianDist.CompareTo(mr.EucledianDist); // low dist is
best
}
#region ICloneable Members
public object Clone()
{
MatchResult clone = new MatchResult(0, 0, null);
clone.Correlation = this.Correlation;
clone.mImage = (MyImage)this.mImage.Clone();
return clone;
}
#endregion
}
}
The code for the different even handlers in the Form1 class appears as:
using System;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Windows.Forms;
namespace FaceRecogPCA
{
public partial class Form1 : Form
{
int NumberOfEigenFaces = 100; // 100 most significant EigenVctors
int width = 92;
int height = 112;
FaceRecogByEF ef = null;
public Form1()
{
InitializeComponent();
}
private void btnCalculateEFs_Click(object sender, EventArgs e)
{
ef = new FaceRecogByEF(width, height, width * height, NumberOfEigenFaces);
ef.ComputeEFs(ImgComparison.CORRELATION,
@"D:\Data\ATTFaceDataSet\ATTFaceDataSet\Training");
// show average image
double[] avgData = new double[ef.AvgImage.ImgVector.Length];
for (int i = 0; i < avgData.Length; i++)
avgData[i] = ef.AvgImage.ImgVector[i];
NormalizeDataAndShowFace(avgData, width, height, picAvg);
// show top five Eigen Faces
double[] eData0 = new double[((EigenFace)ef.EigenFaceList[0]).EF.Length];
for (int i = 0; i < eData0.Length; i++)
eData0[i] = ((EigenFace)ef.EigenFaceList[0]).EF[i];
NormalizeDataAndShowFace(eData0, width, height, picEF0);
double[] eData1 = new double[((EigenFace)ef.EigenFaceList[1]).EF.Length];
for (int i = 0; i < eData1.Length; i++)
eData1[i] = ((EigenFace)ef.EigenFaceList[1]).EF[i];//+
ef.AvgImg.ImgVector[i]);
NormalizeDataAndShowFace(eData1, width, height, picEF1);
double[] eData2 = new double[((EigenFace)ef.EigenFaceList[2]).EF.Length];
for (int i = 0; i < eData2.Length; i++)
eData2[i] = ((EigenFace)ef.EigenFaceList[2]).EF[i];//+
ef.AvgImg.ImgVector[i]);
NormalizeDataAndShowFace(eData2, width, height, picEF2);
double[] eData3 = new double[((EigenFace)ef.EigenFaceList[3]).EF.Length];
for (int i = 0; i < eData3.Length; i++)
eData3[i] = ((EigenFace)ef.EigenFaceList[3]).EF[i];//+
ef.AvgImg.ImgVector[i]);
NormalizeDataAndShowFace(eData3, width, height, picEF3);
double[] eData4 = new double[((EigenFace)ef.EigenFaceList[4]).EF.Length];
for (int i = 0; i < eData3.Length; i++)
eData4[i] = ((EigenFace)ef.EigenFaceList[4]).EF[i];//+
ef.AvgImg.ImgVector[i]);
NormalizeDataAndShowFace(eData4, width, height, picEF4);
}
private void btnTestImage_Click(object sender, EventArgs e)
{
OpenFileDialog ofd = new OpenFileDialog();
if (ofd.ShowDialog() == DialogResult.OK)
{
FileInfo fi = new FileInfo(ofd.FileName);
Bitmap bmp = new Bitmap(ofd.FileName);
bmp = new Bitmap(bmp, new Size(width, height));
MyImage mimg = null;
if (fi.Extension.ToUpper() == ".GIF")
mimg = new MyImage(ofd.FileName, fi.Name, width, height,
ImgFormat.EightBit, ImgComparison.CORRELATION);
if (fi.Extension.ToUpper() == ".JPG")
mimg = new MyImage(ofd.FileName, fi.Name, width, height,
ImgFormat.TwentyFourBit, ImgComparison.CORRELATION);
NormalizeDataAndShowFace(mimg.ImgVector, width, height, pic0);
lblImageToCheck.Text = mimg.FileNameShort;
ef.SubtractAvgImage(mimg); // mean adjusted image
NormalizeDataAndShowFace(mimg.ImgVectorAdjM, width, height,
picAdjustedImage);
double selfReconsError = 0;
MatchResult[] bestMatches = new MatchResult[ef.ImageList.Count]; //
MyImage reconImg = ef.GetMatchedAndReconstructedImages(mimg, ref
selfReconsError,
ref bestMatches);
NormalizeDataAndShowFace(reconImg.ImgVectorAdjM, width, height,
picRecov);
lblReconstructedError.Text = selfReconsError.ToString() + ":" +
bestMatches[0].ImageName.ToString();
if (bestMatches[0].EucledianDist < 50)
lblBestMatch0.BackColor = System.Drawing.Color.Green;
else
lblBestMatch0.BackColor = System.Drawing.Color.Red;
NormalizeDataAndShowFace(((MyImage)ef.ImageList[bestMatches[0].ImageNum]).ImgVector,
width, height, picBestMatch0);
lblBestMatch0.Text = "D=" + bestMatches[0].EucledianDist.ToString() +
"\n" +
bestMatches[0].Correlation.ToString();//.Substring(0, 5);
NormalizeDataAndShowFace(((MyImage)ef.ImageList[bestMatches[1].ImageNum]).ImgVector,
width, height, picBestMatch1);
lblBestMatch1.Text = "D=" + bestMatches[1].EucledianDist.ToString() +
"\n" +
bestMatches[1].Correlation.ToString().Substring(0, 5);
NormalizeDataAndShowFace(((MyImage)ef.ImageList[bestMatches[2].ImageNum]).ImgVector,
width, height, picBestMatch2);
lblBestMatch2.Text = "D=" + bestMatches[2].EucledianDist.ToString() +
"\n" +
bestMatches[2].Correlation.ToString().Substring(0, 5);
NormalizeDataAndShowFace(((MyImage)ef.ImageList[bestMatches[3].ImageNum]).ImgVector,
width, height, picBextMatch3);
lblBestMatch3.Text = "D=" + bestMatches[3].EucledianDist.ToString() +
"\n" +
bestMatches[3].Correlation.ToString().Substring(0, 5);
NormalizeDataAndShowFace(((MyImage)ef.ImageList[bestMatches[4].ImageNum]).ImgVector,
width, height, picBestMatch4);
lblBestMatch4.Text = "D=" + bestMatches[4].EucledianDist.ToString() +
"\n" +
bestMatches[4].Correlation.ToString().Substring(0, 5);
NormalizeDataAndShowFace(((MyImage)ef.ImageList[bestMatches[5].ImageNum]).ImgVector,
width, height, picBestMatch5);
lblBestMatch5.Text = "D=" + bestMatches[5].EucledianDist.ToString() +
"\n" +
bestMatches[5].Correlation.ToString().Substring(0, 5);
NormalizeDataAndShowFace(((MyImage)ef.ImageList[bestMatches[6].ImageNum]).ImgVector,
width, height, picBestMatch6);
lblBestMatch6.Text = "D=" + bestMatches[6].EucledianDist.ToString() +
"\n" +
bestMatches[6].Correlation.ToString().Substring(0, 5);
NormalizeDataAndShowFace(((MyImage)ef.ImageList[bestMatches[7].ImageNum]).ImgVector,
width, height, picBestMatch7);
lblBestMatch7.Text = "D=" + bestMatches[7].EucledianDist.ToString() +
"\n" +
bestMatches[7].Correlation.ToString().Substring(0, 5);
}
}
private void btnComputeAccuracy_Click(object sender, EventArgs e)
{
try
{ // loop through test images folder to see if the
// test image matches correctly to known images
string testImagesFolder =
@"D:\Data\ATTFaceDataSet\ATTFaceDataSet\Testing";
DirectoryInfo dirInfo = new DirectoryInfo(testImagesFolder);
if (!dirInfo.Exists)
throw new DirectoryNotFoundException(testImagesFolder +
" folder does not exist,");
int accuracyCount = 0;
int count = 0;
foreach (FileInfo nextFile in dirInfo.GetFiles())
{
if (nextFile.Extension.ToUpper() == ".JPG")
{
MyImage mimg = new MyImage(nextFile.FullName, nextFile.Name,
width,
height, ImgFormat.TwentyFourBit, ImgComparison.CORRELATION);
//ef.SubtractAvgImage(mimg);
MatchResult[] bestMatches = new MatchResult[ef.ImageList.Count];
double reconstError = 0;
MyImage reconImg = ef.GetMatchedAndReconstructedImages(mimg, ref
reconstError,
ref bestMatches);
if (bestMatches[0].ImageName.ToString().Substring(0, 3) ==
mimg.FileNameShort.Substring(0, 3))
accuracyCount++;
else
Console.WriteLine(mimg.FileNameShort + ":" +
bestMatches[0].ImageName);
count++;
}
}
MessageBox.Show("Accuracy = " + ((double)accuracyCount / count *
100).ToString() + "%");
}
catch (Exception ex)
{
throw new Exception(ex.Message + "Error creating the ImageList..");
}
}
Bitmap GetBitmapFromByteArray(byte[] bdata)
{
Bitmap bmp = new Bitmap(width, height);
int k = 0;
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
bmp.SetPixel(j, i, Color.FromArgb(bdata[k], bdata[k], bdata[k]));
k++;
}
}
return bmp;
}
void NormalizeDataAndShowFace(double[] imData, int width, int height,
PictureBox pb)
{
// normalize the reconstructed image to 0-255 range
double max1 = (from n in imData select n).Max();
double min = (from n in imData select n).Min();
double diff = max1 - min;
for (int i = 0; i < width * height; i++)
{
imData[i] = imData[i] - min;
imData[i] = imData[i] / diff * 255;
if (imData[i] < 0)
imData[i] = 0;
if (imData[i] > 255)
imData[i] = 255;
}
Bitmap bmp = new Bitmap(width, height);
int k = 0;
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
bmp.SetPixel(j, i, Color.FromArgb((int)imData[k], (int)imData[k],
(int)imData[k]));
k++;
}
}
pb.Image = bmp;
}
}
}
Hire Python Expert to get instant help in python computer vision project, send your requirement details at realcode4you@gmail.com and get instant help with an affordable price.