import com.googlecode.javacpp.FloatPointer;

import com.googlecode.javacpp.Pointer;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Logger;

import static com.googlecode.javacv.cpp.opencv_highgui.cvWaitKey;

import static com.googlecode.javacv.cpp.opencv_highgui.cvShowImage;

import static com.googlecode.javacv.cpp.opencv_highgui.cvSaveImage;

import static com.googlecode.javacv.cpp.opencv_highgui.cvDestroyWindow;

import static com.googlecode.javacv.cpp.opencv_highgui.CV_LOAD_IMAGE_GRAYSCALE;

import static com.googlecode.javacv.cpp.opencv_highgui.cvLoadImage;

import com.googlecode.javacv.FrameGrabber;

import com.googlecode.javacv.FrameGrabber.Exception;

import com.googlecode.javacv.OpenCVFrameGrabber;

import com.googlecode.javacv.VideoInputFrameGrabber;

import com.googlecode.javacv.cpp.opencv_core.CvFont;

import com.googlecode.javacv.cpp.opencv_core.CvMemStorage;

import com.googlecode.javacv.cpp.opencv_core.CvPoint;

import com.googlecode.javacv.cpp.opencv_core.CvRect;

import com.googlecode.javacv.cpp.opencv_core.CvScalar;

import com.googlecode.javacv.cpp.opencv_core.CvSeq;

import com.googlecode.javacv.cpp.opencv_core.IplImage;

import static com.googlecode.javacv.cpp.opencv_legacy.*;

import static com.googlecode.javacv.cpp.opencv_objdetect.CV_HAAR_DO_CANNY_PRUNING;

import static com.googlecode.javacv.cpp.opencv_objdetect.CV_HAAR_FIND_BIGGEST_OBJECT;

import static com.googlecode.javacv.cpp.opencv_objdetect.CV_HAAR_DO_ROUGH_SEARCH;

import static com.googlecode.javacv.cpp.opencv_objdetect.cvHaarDetectObjects;

import static com.googlecode.javacv.cpp.opencv_imgproc.CV_BGR2GRAY;

import static com.googlecode.javacv.cpp.opencv_imgproc.cvEqualizeHist;

import com.googlecode.javacv.cpp.opencv_objdetect.CvHaarClassifierCascade;     

import static com.googlecode.javacv.cpp.opencv_core.CvMat;

import static com.googlecode.javacv.cpp.opencv_core.cvReleaseImage;

import static com.googlecode.javacv.cpp.opencv_core.cvLoad;

import static com.googlecode.javacv.cpp.opencv_core.CV_FONT_HERSHEY_COMPLEX_SMALL;

import static com.googlecode.javacv.cpp.opencv_core.cvGetSize;

import static com.googlecode.javacv.cpp.opencv_core.CV_32FC1;

import static com.googlecode.javacv.cpp.opencv_core.cvCreateMat;

import static com.googlecode.javacv.cpp.opencv_core.cvCloneImage;

import static com.googlecode.javacv.cpp.opencv_core.IPL_DEPTH_8U;

import static com.googlecode.javacv.cpp.opencv_core.cvCreateImage;

import static com.googlecode.javacv.cpp.opencv_core.CvSize;

import static com.googlecode.javacv.cpp.opencv_core.cvResetImageROI;

import static com.googlecode.javacv.cpp.opencv_core.cvClearMemStorage;

import static com.googlecode.javacv.cpp.opencv_core.cvSize;

import static com.googlecode.javacv.cpp.opencv_core.cvCopy;

import static com.googlecode.javacv.cpp.opencv_core.cvSetImageROI;

import static com.googlecode.javacv.cpp.opencv_core.CV_AA;

import static com.googlecode.javacv.cpp.opencv_core.cvPoint;

import static com.googlecode.javacv.cpp.opencv_core.cvInitFont;

import static com.googlecode.javacv.cpp.opencv_core.cvGetSeqElem;

import static com.googlecode.javacv.cpp.opencv_core.cvRectangle;

import static com.googlecode.javacv.cpp.opencv_core.cvPutText;

import static com.googlecode.javacv.cpp.opencv_core.CV_32SC1;

import static com.googlecode.javacv.cpp.opencv_core.CvTermCriteria;

import static com.googlecode.javacv.cpp.opencv_core.IPL_DEPTH_32F;

import static com.googlecode.javacv.cpp.opencv_core.CV_L1;

import static com.googlecode.javacv.cpp.opencv_core.CV_TERMCRIT_ITER;

import static com.googlecode.javacv.cpp.opencv_core.cvNormalize;

import static com.googlecode.javacv.cpp.opencv_core.CvFileStorage;

import static com.googlecode.javacv.cpp.opencv_core.cvWriteInt;

import static com.googlecode.javacv.cpp.opencv_core.cvTermCriteria;

import static com.googlecode.javacv.cpp.opencv_core.CV_STORAGE_WRITE;

import static com.googlecode.javacv.cpp.opencv_core.cvOpenFileStorage;

import static com.googlecode.javacv.cpp.opencv_core.cvWrite;

import static com.googlecode.javacv.cpp.opencv_core.cvWriteString;

import static com.googlecode.javacv.cpp.opencv_core.cvReleaseFileStorage;

import static com.googlecode.javacv.cpp.opencv_core.CV_STORAGE_READ;

import static com.googlecode.javacv.cpp.opencv_core.cvReadIntByName;

import static com.googlecode.javacv.cpp.opencv_core.cvReadStringByName;

import static com.googlecode.javacv.cpp.opencv_core.cvReadByName;

import static com.googlecode.javacv.cpp.opencv_core.cvRect;

import static com.googlecode.javacv.cpp.opencv_core.cvConvertScale;

import static com.googlecode.javacv.cpp.opencv_core.cvMinMaxLoc;

import static com.googlecode.javacv.cpp.opencv_imgproc.CV_INTER_LINEAR;

import static com.googlecode.javacv.cpp.opencv_imgproc.CV_INTER_AREA;

import static com.googlecode.javacv.cpp.opencv_imgproc.cvResize;

import static com.googlecode.javacv.cpp.opencv_imgproc.cvCvtColor;

 

       

import java.io.*;

 

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.FileDialog;

import org.eclipse.swt.widgets.MessageBox;

import org.eclipse.swt.widgets.Shell;

       

        public class FaceRecognizer{

       

          private static final Logger LOGGER = Logger.getLogger(FaceRecognizer.class.getName());

          private int nTrainFaces = 0;

          private int nPersons=0;

          private int nEigens = 0;

          private int countSavedFace=1;

          private CvMat personNumTruthMat;

          private  CvMat eigenValMat;

          private CvMat projectedTrainFaceMat;

          private CvMat trainPersonNumMat=null;

          final static List<String> personNames = new ArrayList<String>();

          private CvHaarClassifierCascade cascade = new CvHaarClassifierCascade(cvLoad("data\\haarcascade_frontalface_alt2.xml"));

          private static final int newWidth=50;

          private static final int newHeight=50;

         

          IplImage[] eigenVectArr;

          IplImage[] trainingFaceImgArr;

          IplImage[] testFaceImgArr;

          IplImage pAvgTrainImg;

         

         

          public static String personName;

          private static String textName="unknow";

         

          public static double g_confidence=0;  

         

         

          public FaceRecognizer() {

                  trainPersonNumMat = loadTrainingData();

          }

         

         

          private void learn(final String trainingFileName) {

            int i;

       

            // load training data

            LOGGER.info("===========================================");

            LOGGER.info("Loading the training images in " + trainingFileName);

            trainingFaceImgArr = loadFaceImgArray(trainingFileName);

            nTrainFaces = trainingFaceImgArr.length;

            LOGGER.info("Got " + nTrainFaces + " training images");

            if (nTrainFaces < 3) {

              LOGGER.severe("Need 3 or more training faces\n"

                      + "Input file contains only " + nTrainFaces);

              return;

            }

       

            // do Principal Component Analysis on the training faces

            doPCA();

       

            LOGGER.info("projecting the training images onto the PCA subspace");

            // project the training images onto the PCA subspace

            projectedTrainFaceMat = cvCreateMat(

                    nTrainFaces, // rows

                    nEigens, // cols

                    CV_32FC1); // type, 32-bit float, 1 channel

       

            // initialize the training face matrix - for ease of debugging

            for (int i1 = 0; i1 < nTrainFaces; i1++) {

              for (int j1 = 0; j1 < nEigens; j1++) {

                projectedTrainFaceMat.put(i1, j1, 0.0);

              }

            }

       

            LOGGER.info("created projectedTrainFaceMat with " + nTrainFaces + " (nTrainFaces) rows and " + nEigens + " (nEigens) columns");

            if (nTrainFaces < 5) {

              LOGGER.info("projectedTrainFaceMat contents:\n" + oneChannelCvMatToString(projectedTrainFaceMat));

            }

       

            final FloatPointer floatPointer = new FloatPointer(nEigens);

            for (i = 0; i < nTrainFaces; i++) {

              cvEigenDecomposite(

                      trainingFaceImgArr[i], // obj

                      nEigens, // nEigObjs

                      eigenVectArr, // eigInput (Pointer)

                      0, // ioFlags

                      null, // userData (Pointer)

                      pAvgTrainImg, // avg

                      floatPointer); // coeffs (FloatPointer)

       

              if (nTrainFaces < 5) {

                LOGGER.info("floatPointer: " + floatPointerToString(floatPointer));

              }

              for (int j1 = 0; j1 < nEigens; j1++) {

                projectedTrainFaceMat.put(i, j1, floatPointer.get(j1));

              }

            }

            if (nTrainFaces < 5) {

              LOGGER.info("projectedTrainFaceMat after cvEigenDecomposite:\n" + projectedTrainFaceMat);

            }

       

            // store the recognition data as an xml file

            storeTrainingData();

       

            // Save all the eigenvectors as images, so that they can be checked.

            storeEigenfaceImages();

          }

 

       

        private IplImage convertImageToGreyscale(IplImage imageSrc)

          {

                IplImage imageGrey;

                // Either convert the image to greyscale, or make a copy of the existing greyscale image.

                // This is to make sure that the user can always call cvReleaseImage() on the output, whether it was greyscale or not.

                if (imageSrc.nChannels()==3) {

                        imageGrey = cvCreateImage( cvGetSize(imageSrc), IPL_DEPTH_8U, 1 );

                        cvCvtColor( imageSrc, imageGrey, CV_BGR2GRAY );

                }

                else {

                        imageGrey = cvCloneImage(imageSrc);

                }

                return imageGrey;

          }

         

         

        private IplImage resizeImage(IplImage origImg)

          {

                IplImage outImg = null;

                int origWidth=0;

                int origHeight=0;

                if (origImg!=null) {

                        origWidth = origImg.width();

                        origHeight = origImg.height();

                }

                if (newWidth <= 0 || newHeight <= 0 || origImg == null || origWidth <= 0 || origHeight <= 0) {

                        LOGGER.info("ERROR in resizeImage: Bad desired image size of");

                        LOGGER.info(String.valueOf(newWidth)+","+String.valueOf(newHeight));

                        System.exit(1);

                }

       

                // Scale the image to the new dimensions, even if the aspect ratio will be changed.

                outImg = cvCreateImage(cvSize(newWidth, newHeight), origImg.depth(), origImg.nChannels());

                if (newWidth > origImg.width() && newHeight > origImg.height()) {

                        // Make the image larger

                        cvResetImageROI((IplImage)origImg);

                        cvResize(origImg, outImg, CV_INTER_LINEAR);     // CV_INTER_CUBIC or CV_INTER_LINEAR is good for enlarging

                }

                else {

                        // Make the image smaller

                        cvResetImageROI((IplImage)origImg);

                        cvResize(origImg, outImg, CV_INTER_AREA);       // CV_INTER_AREA is good for shrinking / decimation, but bad at enlarging.

                }

       

                return outImg;

          }

       

       

       

         private IplImage cropImage(IplImage img, CvRect region)

          {

               

                IplImage imageTmp;

                IplImage imageRGB;

       

          //    size.height()=img.height();

          //    size.width() = img.width();

               

                if (img.depth() != IPL_DEPTH_8U) {

                        LOGGER.info("ERROR in cropImage: Unknown image depth of");

                        LOGGER.info(String.valueOf(img.depth()));

                        LOGGER.info(" given in cropImage() instead of 8 bits per pixel.");

                        System.exit(1);

                }

       

                // First create a new (color or greyscale) IPL Image and copy contents of img into it.

                imageTmp = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, img.nChannels());

                cvCopy(img, imageTmp);

               

                // Create a new image of the detected region

                // Set region of interest to that surrounding the face

                cvSetImageROI(imageTmp, region);

                // Copy region of interest (i.e. face) into a new iplImage (imageRGB) and return it

                imageRGB = cvCreateImage(cvSize(region.width(),region.height()),  IPL_DEPTH_8U, img.nChannels());

                cvCopy(imageTmp, imageRGB);     // Copy just the region.

       

              cvReleaseImage(imageTmp);

              //region.setNull();

                return imageRGB;       

                }

       

           

         

         public boolean recognizeFromCam() throws Exception

          {

                        OpenCVFrameGrabber  grabber = null;

                        FileDialog fd;

                        IplImage pFrame=null;

                        int keypress = 0;

                        if(LoginShell.video_flag)//如果被选，刚用视频

                        {      

                                fd=new FileDialog(LoginShell.sShell,SWT.OPEN);  

                                fd.setFilterExtensions(new String[]{"*.avi","*.wmv","*.mp4","*.*"});

                                fd.setFilterNames(new String[]{".avi",".wmv",".mp4"});

                                String filename=fd.open();

                                grabber = OpenCVFrameGrabber.createDefault(filename);

                        }

                        else

                                grabber = OpenCVFrameGrabber.createDefault(0);

                        grabber.start();

                pFrame = grabber.grab();  

                while( pFrame!=null ){

                        detectAndCropAndPre( pFrame,cascade,CV_HAAR_DO_CANNY_PRUNING | CV_HAAR_DO_ROUGH_SEARCH);                               

                        cvShowImage("Press 'Esc' to Stop!",pFrame);

                                pFrame = grabber.grab();

                                keypress=cvWaitKey(24);

                                System.out.println(g_confidence);

                                if( keypress== 27){    

                                        grabber.release();

                                        cvDestroyWindow("Press 'Esc' to Stop!");

                                        break;

                                }

                }

                cvWaitKey(1000);

                cvReleaseImage(pFrame);

                //cvDestroyWindow("BP_FaceRecognizer_FaceLogin");

                grabber.release();

                        return false;

          }

         

         public void recongizeFormImage(String filePath){

                        IplImage signleImage=null;

                        System.out.println(filePath);

                        signleImage=cvLoadImage(filePath);

                        if(!signleImage.isNull());

                                detectAndCropFromImg(signleImage,cascade,CV_HAAR_DO_CANNY_PRUNING | CV_HAAR_DO_ROUGH_SEARCH);                          

                cvShowImage("Press 'Esc' to exit",signleImage);

                        cvWaitKey(0);

                        cvDestroyWindow("Press 'Esc' to exit");

         }

         

         

         

       

         public boolean register(String name)throws Exception

         {       

                        boolean flag=true;

                        OpenCVFrameGrabber  grabber = null;

                        FileDialog fd;

                        IplImage pFrame=null;

                        int keypress = 0;

                        int countSecond=0;

                       

                        for(int i=0;i<personNames.size();i++){

                                if(name.equals(personNames.get(i).toString()))

                                {

                                        MessageBox messageBox = new MessageBox(RegisterShell.sShell, SWT.ICON_QUESTION |SWT.YES | SWT.NO);

                                        messageBox.setMessage("此用户已经被使用！！！连续按 “否” 返回");  

                                        messageBox.open();

                                        flag=false;

                                }

                        }

                         

                        if(LoginShell.video_flag)//用视频文件进行注册

                        {

                                fd=new FileDialog(LoginShell.sShell,SWT.OPEN);  

                                fd.setFilterExtensions(new String[]{"*.avi","*.wmv","*.mp4","*.*"});

                                fd.setFilterNames(new String[]{".avi",".wmv",".mp4"});

                                String filename=fd.open();

                                grabber = OpenCVFrameGrabber.createDefault(filename);

                        }

                        else

                                grabber = OpenCVFrameGrabber.createDefault(0);

                        grabber.start();

                pFrame = grabber.grab();                                       

                while( pFrame!=null )

                {

                        countSecond++;

                        detectForRegister(pFrame,cascade,CV_HAAR_FIND_BIGGEST_OBJECT | CV_HAAR_DO_ROUGH_SEARCH,name);

                        cvShowImage("Press 'Esc' to Stop",pFrame);

                                pFrame = grabber.grab();

                                keypress=cvWaitKey(24);

                                if( keypress== 27 ||countSecond==100||countSavedFace==6)//||second==60

                                {      

                                        cvReleaseImage(pFrame);

                                        grabber.release();

                                        break;                         

                                }

                }

 

                personNames.add(name);

                writeNameToTXT(name);

                learn("data\\ForTraining.txt");

                cvDestroyWindow("Press 'Esc' to Stop");

                        return flag;

         }

         

 

         

         

         private void detectForRegister(IplImage src,CvHaarClassifierCascade cascade,int flag,String name){

 

                IplImage greyImg=null;

                IplImage faceImg=null;

                IplImage sizedImg=null;

                IplImage equalizedImg=null;

 

               

                CvRect r ;

                CvFont font = new CvFont(CV_FONT_HERSHEY_COMPLEX_SMALL, 1, 1);

                cvInitFont(font,CV_FONT_HERSHEY_COMPLEX_SMALL, 1.0, 0.8,1,1,CV_AA);

                greyImg = cvCreateImage( cvGetSize(src), IPL_DEPTH_8U, 1 );            

                greyImg=convertImageToGreyscale(src);

                CvMemStorage storage = CvMemStorage.create();

               

                CvSeq sign = cvHaarDetectObjects(

                                greyImg,

                                cascade,

                                storage,

                                1.1,

                                3,

                                flag);

                cvClearMemStorage(storage);

                if(sign.total()==1)//只会有一个脸部

                {      

                        r = new CvRect(cvGetSeqElem(sign, 0));

                        faceImg = cropImage(greyImg, r);               

                        sizedImg = resizeImage(faceImg);

                        equalizedImg = cvCreateImage(cvGetSize(sizedImg), 8, 1);       

                        cvEqualizeHist(sizedImg, equalizedImg);        

                        cvRectangle (

                                                        src,

                                                        cvPoint(r.x(), r.y()),

                                                        cvPoint(r.width() + r.x(), r.height() + r.y()),

                                                        CvScalar.WHITE,

                                                        1,

                                                        CV_AA,

                                                        0);

                        cvPutText(src, "This is your No."+String.valueOf(countSavedFace)+" photos. " ,cvPoint(r.x()-30, r.y() + r.height() + 30), font, CvScalar.RED);                         

                        cvSaveImage("img\\"+name+countSavedFace+".jpg",equalizedImg);

                        cvWaitKey(1000);

                        countSavedFace++;      

                        cvReleaseImage(greyImg);

                        cvReleaseImage(faceImg);

                        cvReleaseImage(sizedImg);

                        cvReleaseImage(equalizedImg);  

                }

               

                       

       

               

               

                                         

         

         private  void writeNameToTXT(String name){

                        String text=null;

                        int temp;

                        temp=personNames.size();

                        if(temp==0)

                                temp=temp+1;

                               

                        try {

                             File file = new File("data\\ForTraining.txt");

                             FileOutputStream fos = new FileOutputStream(file,true);

                             OutputStreamWriter osw = new OutputStreamWriter(fos);

                             BufferedWriter bw = new BufferedWriter(osw);

                            // if(personNames.size()==0)

                                 

                             for(int i=1;i<6;i++){

                                     text=temp+" "+name+" "+"img\\"+name+i+".jpg";

                                     bw.write(text);

                                     bw.newLine();

                             }

                             

                             bw.flush();

                             bw.close();

                             osw.close();

                             fos.close();

 

                        }

                        catch (FileNotFoundException e1) {

                             e1.printStackTrace();

                            } catch (IOException e2) {

                             e2.printStackTrace();

                            }

         }

         

         

         private void eigenDecomImg(IplImage src){

                //CvMat trainPersonNumMat=null;

                float confidence = 0.0f;

                int  nearest=0;

                int iNearest=0;

               

               

                LOGGER.info("=====================================Waiting For the camera .....");

          //   

                if( trainPersonNumMat==null) {

                        LOGGER.info("ERROR in recognizeFromCam(): Couldn't load the training data!\n");

                        System.exit(1);

                }

                float[] projectedTestFace = new float[nEigens];

                        cvEigenDecomposite(

                                src,

                                nEigens,

                                eigenVectArr,

                                0,

                                null,

                                pAvgTrainImg,

                                projectedTestFace);

       

            final FloatPointer pConfidence = new FloatPointer(confidence);

            iNearest = findNearestNeighbor(projectedTestFace, new FloatPointer(pConfidence));

            confidence = pConfidence.get();

            nearest = trainPersonNumMat.data_i().get(iNearest);

            personName="";

                textName=personNames.get(nearest-1);

                personName=personNames.get(nearest-1);

            g_confidence=confidence;

               

        }

                   

         

         private void detectAndCropAndPre(IplImage src,CvHaarClassifierCascade cascade,int flag)

         {

                        int nearest=0;

                        IplImage greyImg=null;

                        IplImage faceImg=null;

                        IplImage sizedImg=null;

                        IplImage equalizedImg=null;

                        boolean faceIsTrue=false;

                        CvRect r ;

                        CvFont font = new CvFont(CV_FONT_HERSHEY_COMPLEX_SMALL, 1, 1);

                        cvInitFont(font,CV_FONT_HERSHEY_COMPLEX_SMALL, 1.0, 0.8,1,1,CV_AA);

                        greyImg = cvCreateImage( cvGetSize(src), IPL_DEPTH_8U, 1 );            

                        greyImg=convertImageToGreyscale(src);

                        CvMemStorage storage = CvMemStorage.create();

                       

                        CvSeq sign = cvHaarDetectObjects(

                                        greyImg,

                                        cascade,

                                        storage,

                                        1.1,

                                        3,

                                        flag);

                        cvClearMemStorage(storage);

                        if(sign.total()>0)

                        {

                               

                                for(int i=0;i<sign.total();i++)

                                {

                                        r = new CvRect(cvGetSeqElem(sign, i));

                                        faceImg = cropImage(greyImg, r);       

                                        sizedImg = resizeImage(faceImg);

                                        if(i==0)

                                                equalizedImg = cvCreateImage(cvGetSize(sizedImg), 8, 1);       

                                        cvEqualizeHist(sizedImg, equalizedImg);                        

                                        cvRectangle (

                                                                        src,

                                                                        cvPoint(r.x(), r.y()),

                                                                        cvPoint(r.width() + r.x(), r.height() + r.y()),

                                                                        CvScalar.WHITE,

                                                                        1,

                                                                        CV_AA,

                                                                        0);

                               

                                        eigenDecomImg(equalizedImg);

                                        if(g_confidence*100>50){

                                                cvPutText(src, textName,cvPoint(r.x()-10, r.y() + r.height() + 20), font, CvScalar.WHITE);

                                                cvPutText(src, " conf="+Integer.valueOf((int) (g_confidence*100))+"%",cvPoint(r.x()-10, r.y() + r.height() + 40), font, CvScalar.GREEN);

                                                textName="unknow";

                                        }

                                        else {

                                                cvPutText(src, "unknow",cvPoint(r.x()-10, r.y() + r.height() + 20), font, CvScalar.WHITE);

                                                cvPutText(src, " conf="+Integer.valueOf((int) (g_confidence*100))+"%",cvPoint(r.x()-10, r.y() + r.height() + 40), font, CvScalar.GREEN);

                                        }

                                }

                                cvReleaseImage(greyImg);

                                cvReleaseImage(faceImg);

                                cvReleaseImage(sizedImg);

                                cvReleaseImage(equalizedImg);

                        }      

                               

       

                }

 

         private void detectAndCropFromImg(IplImage src,CvHaarClassifierCascade cascade,int flag)

         {

                        IplImage greyImg=null;

                        IplImage faceImg=null;

                        IplImage sizedImg=null;

                        IplImage equalizedImg=null;

                        CvRect r ;

                        CvFont font = new CvFont(CV_FONT_HERSHEY_COMPLEX_SMALL, 1, 1);

                        cvInitFont(font,CV_FONT_HERSHEY_COMPLEX_SMALL, 1.0, 0.8,1,1,CV_AA);

                        greyImg = cvCreateImage( cvGetSize(src), IPL_DEPTH_8U, 1 );            

                        greyImg=convertImageToGreyscale(src);

                        CvMemStorage storage = CvMemStorage.create();

                       

                        CvSeq sign = cvHaarDetectObjects(

                                        greyImg,

                                        cascade,

                                        storage,

                                        1.1,

                                        3,

                                        flag);

                        cvClearMemStorage(storage);

                        if(sign.total()>0)

                        {

                               

                                for(int i=0;i<sign.total();i++)

                                {

                                        r = new CvRect(cvGetSeqElem(sign, i));

                                        faceImg = cropImage(greyImg, r);       

                                        sizedImg = resizeImage(faceImg);

                                        if(i==0)

                                                equalizedImg = cvCreateImage(cvGetSize(sizedImg), 8, 1);       

                                        cvEqualizeHist(sizedImg, equalizedImg);                        

                                        cvRectangle (

                                                                        src,

                                                                        cvPoint(r.x(), r.y()),

                                                                        cvPoint(r.width() + r.x(), r.height() + r.y()),

                                                                        CvScalar.WHITE,

                                                                        1,

                                                                        CV_AA,

                                                                        0);

                               

                                        eigenDecomImg(equalizedImg);

                                        if(g_confidence*100>50){

                                                cvPutText(src, textName,cvPoint(r.x()-10, r.y() + r.height() + 20), font, CvScalar.WHITE);

                                                cvPutText(src, " conf="+Integer.valueOf((int) (g_confidence*100))+"%",cvPoint(r.x()-10, r.y() + r.height() + 40), font, CvScalar.GREEN);

                                                textName="unknow";

                                        }

                                        else{

                                                cvPutText(src, "Unknow",cvPoint(r.x()-10, r.y() + r.height() + 20), font, CvScalar.WHITE);

                                                cvPutText(src, " conf="+Integer.valueOf((int) (g_confidence*100))+"%",cvPoint(r.x()-10, r.y() + r.height() + 40), font, CvScalar.GREEN);

                                        }

                                }

                        }

                        else

                                cvPutText(src, "can't find any face!",cvPoint(src.width()/2, src.height()/2), font, CvScalar.GREEN);

                        //cvReleaseImage(greyImg);

                        //if(!faceImg.isNull())

                        //      cvReleaseImage(faceImg);

                        //cvReleaseImage(sizedImg);

                        //cvReleaseImage(equalizedImg);

                }      

 

                       

 

         

         private IplImage[] loadFaceImgArray(final String filename) {

            IplImage[] faceImgArr;

            BufferedReader imgListFile;

            String imgFilename;

            int iFace = 0;

            int nFaces = 0;

            int i;

            try {

              // open the input file

              imgListFile = new BufferedReader(new FileReader(filename));

       

              // count the number of faces

              while (true) {

                final String line = imgListFile.readLine();

                if (line == null || line.isEmpty()) {

                  break;

                }

                nFaces++;

              }

              LOGGER.info("nFaces: " + nFaces);

              imgListFile = new BufferedReader(new FileReader(filename));

       

              // allocate the face-image array and person number matrix

              faceImgArr = new IplImage[nFaces];

              personNumTruthMat = cvCreateMat(

                      1, // rows

                      nFaces, // cols

                      CV_32SC1); // type, 32-bit unsigned, one channel

       

              // initialize the person number matrix - for ease of debugging

              for (int j1 = 0; j1 < nFaces; j1++) {

                personNumTruthMat.put(0, j1, 0);

              }

       

              personNames.clear();        // Make sure it starts as empty.

              nPersons = 0;

       

              // store the face images in an array

              for (iFace = 0; iFace < nFaces; iFace++) {

                String personName;

                String sPersonName;

                int personNumber;

       

                // read person number (beginning with 1), their name and the image filename.

                final String line = imgListFile.readLine();

                if (line.isEmpty()) {

                  break;

                }

                final String[] tokens = line.split(" ");

                personNumber = Integer.parseInt(tokens[0]);

                personName = tokens[1];

                imgFilename = tokens[2];

                sPersonName = personName;

                LOGGER.info("Got " + iFace + " " + personNumber + " " + personName + " " + imgFilename);

       

                // Check if a new person is being loaded.

                if (personNumber > nPersons) {

                  // Allocate memory for the extra person (or possibly multiple), using this new person's name.

                  personNames.add(sPersonName);

                  nPersons = personNumber;

                  LOGGER.info("Got new person " + sPersonName + " -> nPersons = " + nPersons + " [" + personNames.size() + "]");

                }

       

                // Keep the data

                personNumTruthMat.put(

                        0, // i

                        iFace, // j

                        personNumber); // v

       

                // load the face image

                faceImgArr[iFace] = cvLoadImage(

                        imgFilename, // filename

                        CV_LOAD_IMAGE_GRAYSCALE); // isColor

       

                if (faceImgArr[iFace] == null) {

                  throw new RuntimeException("Can't load image from " + imgFilename);

                }

              }

       

              imgListFile.close();

       

            } catch (IOException ex) {

              throw new RuntimeException(ex);

            }

       

            LOGGER.info("Data loaded from '" + filename + "': (" + nFaces + " images of " + nPersons + " people).");

            final StringBuilder stringBuilder = new StringBuilder();

            stringBuilder.append("People: ");

            if (nPersons > 0) {

              stringBuilder.append("<").append(personNames.get(0)).append(">");

            }

            for (i = 1; i < nPersons && i < personNames.size(); i++) {

              stringBuilder.append(", <").append(personNames.get(i)).append(">");

            }

            LOGGER.info(stringBuilder.toString());

       

            return faceImgArr;

          }

       

         

          private void doPCA() {

            int i;

            CvTermCriteria calcLimit;

            CvSize faceImgSize = new CvSize();

       

            // set the number of eigenvalues to use

            nEigens = nTrainFaces-1 ;

       

            LOGGER.info("allocating images for principal component analysis, using " + nEigens + (nEigens == 1 ? " eigenvalue" : " eigenvalues"));

       

            // allocate the eigenvector images

            faceImgSize.width(trainingFaceImgArr[0].width());

            faceImgSize.height(trainingFaceImgArr[0].height());

            eigenVectArr = new IplImage[nEigens];

            for (i = 0; i < nEigens; i++) {

              eigenVectArr[i] = cvCreateImage(

                      faceImgSize, // size

                      IPL_DEPTH_32F, // depth

                      1); // channels

            }

       

            // allocate the eigenvalue array

            eigenValMat = cvCreateMat(

                    1, // rows

                    nEigens, // cols

                    CV_32FC1); // type, 32-bit float, 1 channel

       

            // allocate the averaged image

            pAvgTrainImg = cvCreateImage(

                    faceImgSize, // size

                    IPL_DEPTH_32F, // depth

                    1); // channels

       

            // set the PCA termination criterion

            calcLimit = cvTermCriteria(

                    CV_TERMCRIT_ITER, // type

                    nEigens, // max_iter

                    1); // epsilon

       

            LOGGER.info("computing average image, eigenvalues and eigenvectors");

            // compute average image, eigenvalues, and eigenvectors

            cvCalcEigenObjects(

                    nTrainFaces, // nObjects

                    trainingFaceImgArr, // input

                    eigenVectArr, // output

                    CV_EIGOBJ_NO_CALLBACK, // ioFlags

                    0, // ioBufSize

                    null, // userData

                    calcLimit,

                    pAvgTrainImg, // avg

                    eigenValMat.data_fl()); // eigVals

       

            LOGGER.info("normalizing the eigenvectors");

            cvNormalize(

                    eigenValMat, // src (CvArr)

                    eigenValMat, // dst (CvArr)

                    1, // a

                    0, // b

                    CV_L1, // norm_type

                    null); // mask

          }

       

         

          private void storeTrainingData() {

            CvFileStorage fileStorage;

            int i;

       

            LOGGER.info("writing data/facedata.xml");

       

            // create a file-storage interface

            fileStorage = cvOpenFileStorage(

                    "data\\facedata.xml", // filename

                    null, // memstorage

                    CV_STORAGE_WRITE, // flags

                    null); // encoding

       

            // Store the person names. Added by Shervin.

            cvWriteInt(

                    fileStorage, // fs

                    "nPersons", // name

                    nPersons); // value

       

            for (i = 0; i < nPersons; i++) {

              String varname = "personName_" + (i + 1);

              cvWriteString(

                      fileStorage, // fs

                      varname, // name

                      personNames.get(i), // string

                      0); // quote

            }

       

            // store all the data

            cvWriteInt(

                    fileStorage, // fs

                    "nEigens", // name

                    nEigens); // value

       

            cvWriteInt(

                    fileStorage, // fs

                    "nTrainFaces", // name

                    nTrainFaces); // value

       

            cvWrite(

                    fileStorage, // fs

                    "trainPersonNumMat", // name

                    personNumTruthMat); // value

       

            cvWrite(

                    fileStorage, // fs

                    "eigenValMat", // name

                    eigenValMat); // value

       

            cvWrite(

                    fileStorage, // fs

                    "projectedTrainFaceMat", // name

                    projectedTrainFaceMat);

       

            cvWrite(fileStorage, // fs

                    "avgTrainImg", // name

                    pAvgTrainImg); // value

       

            for (i = 0; i < nEigens; i++) {

              String varname = "eigenVect_" + i;

              cvWrite(

                      fileStorage, // fs

                      varname, // name

                      eigenVectArr[i]); // value

            }

       

            // release the file-storage interface

            cvReleaseFileStorage(fileStorage);

          }

       

       

          private CvMat loadTrainingData() {

            LOGGER.info("loading training data");

            CvMat pTrainPersonNumMat = null; // the person numbers during training

            CvFileStorage fileStorage;

            int i;

       

            // create a file-storage interface

            fileStorage = cvOpenFileStorage(

                    "data\\facedata.xml", // filename

                    null, // memstorage

                    CV_STORAGE_READ, // flags

                    null); // encoding

            if (fileStorage == null) {

              LOGGER.severe("Can't open training database file 'data/facedata.xml'.");

              return null;

            }

       

            // Load the person names.

            personNames.clear();        // Make sure it starts as empty.

            nPersons = cvReadIntByName(

                    fileStorage, // fs

                    null, // map

                    "nPersons", // name

                    0); // default_value

            if (nPersons == 0) {

              LOGGER.severe("No people found in the training database 'data/facedata.xml'.");

              return null;

            } else {

              LOGGER.info(nPersons + " persons read from the training database");

            }

       

            // Load each person's name.

            for (i = 0; i < nPersons; i++) {

              String sPersonName;

              String varname = "personName_" + (i + 1);

              sPersonName = cvReadStringByName(

                      fileStorage, // fs

                      null, // map

                      varname,

                      "");

              personNames.add(sPersonName);

            }

            LOGGER.info("person names: " + personNames);

       

            // Load the data

            nEigens = cvReadIntByName(

                    fileStorage, // fs

                    null, // map

                    "nEigens",

                    0); // default_value

            nTrainFaces = cvReadIntByName(

                    fileStorage,

                    null, // map

                    "nTrainFaces",

                    0); // default_value

            Pointer pointer = cvReadByName(

                    fileStorage, // fs

                    null, // map

                    "trainPersonNumMat"); // name

            pTrainPersonNumMat = new CvMat(pointer);

       

            pointer = cvReadByName(

                    fileStorage, // fs

                    null, // map

                    "eigenValMat"); // name

            eigenValMat = new CvMat(pointer);

       

            pointer = cvReadByName(

                    fileStorage, // fs

                    null, // map

                    "projectedTrainFaceMat"); // name

            projectedTrainFaceMat = new CvMat(pointer);

       

            pointer = cvReadByName(

                    fileStorage,

                    null, // map

                    "avgTrainImg");

            pAvgTrainImg = new IplImage(pointer);

       

            eigenVectArr = new IplImage[nTrainFaces];

            for (i = 0; i <= nEigens; i++) {

              String varname = "eigenVect_" + i;

              pointer = cvReadByName(

                      fileStorage,

                      null, // map

                      varname);

              eigenVectArr[i] = new IplImage(pointer);

            }

       

            // release the file-storage interface

            cvReleaseFileStorage(fileStorage);

       

            LOGGER.info("Training data loaded (" + nTrainFaces + " training images of " + nPersons + " people)");

            final StringBuilder stringBuilder = new StringBuilder();

            stringBuilder.append("People: ");

            if (nPersons > 0) {

              stringBuilder.append("<").append(personNames.get(0)).append(">");

            }

            for (i = 1; i < nPersons; i++) {

              stringBuilder.append(", <").append(personNames.get(i)).append(">");

            }

            LOGGER.info(stringBuilder.toString());

       

            return pTrainPersonNumMat;

          }

       

 

          private void storeEigenfaceImages() {

            // Store the average image to a file

            LOGGER.info("Saving the image of the average face as 'data/out_averageImage.bmp'");

            cvSaveImage("img\\out_averageImage.jpg", pAvgTrainImg);

       

            // Create a large image made of many eigenface images.

            // Must also convert each eigenface image to a normal 8-bit UCHAR image instead of a 32-bit float image.

            LOGGER.info("Saving the " + nEigens + " eigenvector images as 'data/out_eigenfaces.bmp'");

       

            if (nEigens > 0) {

              // Put all the eigenfaces next to each other.

              int COLUMNS = 8;        // Put upto 8 images on a row.

              int nCols = Math.min(nEigens, COLUMNS);

              int nRows = 1 + (nEigens / COLUMNS);        // Put the rest on new rows.

              int w = eigenVectArr[0].width();

              int h = eigenVectArr[0].height();

              CvSize size = cvSize(nCols * w, nRows * h);

              final IplImage bigImg = cvCreateImage(

                      size,

                      IPL_DEPTH_8U, // depth, 8-bit Greyscale UCHAR image

                      1);        // channels

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

                // Get the eigenface image.

                IplImage byteImg = convertFloatImageToUcharImage(eigenVectArr[i]);

                // Paste it into the correct position.

                int x = w * (i % COLUMNS);

                int y = h * (i / COLUMNS);

                CvRect ROI = cvRect(x, y, w, h);

                cvSetImageROI(

                        bigImg, // image

                        ROI); // rect

                cvCopy(

                        byteImg, // src

                        bigImg, // dst

                        null); // mask

                cvResetImageROI(bigImg);

                cvReleaseImage(byteImg);

              }

              cvSaveImage(

                      "img\\out_eigenfaces.jpg", // filename

                      bigImg); // image

              cvReleaseImage(bigImg);

            }

          }

       

       

          private IplImage convertFloatImageToUcharImage(IplImage srcImg) {

                  IplImage dstImg;

                  if ((srcImg != null) && (srcImg.width() > 0 && srcImg.height() > 0)) {

                      // Spread the 32bit floating point pixels to fit within 8bit pixel range.

                      CvPoint minloc = new CvPoint();

                      CvPoint maxloc = new CvPoint();

                      double[] minVal = new double[1];

                      double[] maxVal = new double[1];

                      cvMinMaxLoc(srcImg, minVal, maxVal, minloc, maxloc, null);

                      // Deal with NaN and extreme values, since the DFT seems to give some NaN results.

                      if (minVal[0] < -1e30) {

                        minVal[0] = -1e30;

                      }

                      if (maxVal[0] > 1e30) {

                        maxVal[0] = 1e30;

                      }

                      if (maxVal[0] - minVal[0] == 0.0f) {

                        maxVal[0] = minVal[0] + 0.001;  // remove potential divide by zero errors.

                      }                        // Convert the format

                      dstImg = cvCreateImage(cvSize(srcImg.width(), srcImg.height()), 8, 1);

                      cvConvertScale(srcImg, dstImg, 255.0 / (maxVal[0] - minVal[0]), -minVal[0] * 255.0 / (maxVal[0] - minVal[0]));

                      return dstImg;

            }

            return null;

          }

       

       

          private int findNearestNeighbor(float projectedTestFace[], FloatPointer pConfidencePointer) {

            double leastDistSq = Double.MAX_VALUE;

            int i = 0;

            int iTrain = 0;

            int iNearest = 0;

       

            LOGGER.info("................");

            LOGGER.info("find nearest neighbor from " + nTrainFaces + " training faces");

            for (iTrain = 0; iTrain < nTrainFaces; iTrain++) {

              //LOGGER.info("considering training face " + (iTrain + 1));

              double distSq = 0;

       

              for (i = 0; i < nEigens; i++) {

                //LOGGER.debug("  projected test face distance from eigenface " + (i + 1) + " is " + projectedTestFace[i]);

       

                float projectedTrainFaceDistance = (float) projectedTrainFaceMat.get(iTrain, i);

                float d_i = projectedTestFace[i] - projectedTrainFaceDistance;

                distSq += d_i * d_i; // / eigenValMat.data_fl().get(i);  // Mahalanobis distance (might give better results than Eucalidean distance)

        //          if (iTrain < 5) {

        //            LOGGER.info("    ** projected training face " + (iTrain + 1) + " distance from eigenface " + (i + 1) + " is " + projectedTrainFaceDistance);

        //            LOGGER.info("    distance between them " + d_i);

        //            LOGGER.info("    distance squared " + distSq);

        //          }

              }

       

              if (distSq < leastDistSq) {

                leastDistSq = distSq;

                iNearest = iTrain;

                LOGGER.info("  training face " + (iTrain + 1) + " is the new best match, least squared distance: " + leastDistSq);

              }

            }

       

            // Return the confidence level based on the Euclidean distance,

            // so that similar images should give a confidence between 0.5 to 1.0,

            // and very different images should give a confidence between 0.0 to 0.5.

            float pConfidence = (float) (1.0f - Math.sqrt(leastDistSq / (float) (nTrainFaces * nEigens)) / 255.0f);

            pConfidencePointer.put(pConfidence);

       

            LOGGER.info("training face " + (iNearest + 1) + " is the final best match, confidence " + pConfidence);

            return iNearest;

          }

       

         

          private String floatArrayToString(final float[] floatArray) {

            final StringBuilder stringBuilder = new StringBuilder();

            boolean isFirst = true;

            stringBuilder.append('[');

            for (int i = 0; i < floatArray.length; i++) {

              if (isFirst) {

                isFirst = false;

              }

              else {

                stringBuilder.append(", ");

              }

              stringBuilder.append(floatArray[i]);

            }

            stringBuilder.append(']');

       

            return stringBuilder.toString();

          }

       

 

          private String floatPointerToString(final FloatPointer floatPointer) {

            final StringBuilder stringBuilder = new StringBuilder();

            boolean isFirst = true;

            stringBuilder.append('[');

            for (int i = 0; i < floatPointer.capacity(); i++) {

              if (isFirst) {

                isFirst = false;

              } else {

                stringBuilder.append(", ");

              }

              stringBuilder.append(floatPointer.get(i));

            }

            stringBuilder.append(']');

       

            return stringBuilder.toString();

          }

       

 

         private String oneChannelCvMatToString(final CvMat cvMat) {

            //Preconditions

            if (cvMat.channels() != 1) {

              throw new RuntimeException("illegal argument - CvMat must have one channel");

            }

       

            final int type = cvMat.type();

            StringBuilder s = new StringBuilder("[ ");

            for (int i = 0; i < cvMat.rows(); i++) {

              for (int j = 0; j < cvMat.cols(); j++) {

                if (type == CV_32FC1 || type == CV_32SC1) {

                  s.append(cvMat.get(i, j));

                } else {

                  throw new RuntimeException("illegal argument - CvMat must have one channel and type of float or signed integer");

                }

                if (j < cvMat.cols() - 1) {

                  s.append(", ");

                }

              }

              if (i < cvMat.rows() - 1) {

                s.append("\n  ");

              }

            }

            s.append(" ]");

            return s.toString();

          }

        }