最近项目时间很紧，抓紧时间集中精力去研究android平台的opencv里的物体跟踪技术

 

其他几篇文章有时间再去完善吧

 

从网上找到了一些实例代码，我想采取的学习方法是研究实例代码和看教程相结合，教程是ndk编程方面的编程规则等、opencv人脸识别、物体跟踪这一块的教程

 

(1)人脸检测与跟踪库 asmlibrary   分析和研究

http://www.oschina.net/p/asmlibrary

http://yaohan.sinaapp.com/topic/3/asmlibrary#comments

 

 

我下载了6.0这个版本，往eclipse里导入的时候要注意一些问题，记得导入Opencv-Library，在C++的paths and symbols的include里把需要的库加进去，然后还可能遇到其他问

题，读者自行百度或者留言给我吧，一起讨论研究一下！

 

把这个项目导入eclipse之后，观察它的结构：

 

src文件夹下有两个java文件:  ASMFit.java， ASMLibraryActivity.java 

jni文件夹下有 so文件夹，Android.mk，Application.mk，asmfitting.h，asmlibrary.h，DemoFit.cpp，vjfacedetect.h

在res文件夹下发现了一个文件夹 raw，第一次见，然后百度了一下，

 

 

assets和res下面raw文件的使用不同点

assets下面的文件不会被编译，通过路径可以去访问其中的内容。raw中文件会自动编译，我们可以在R.java文件中找到对应的ID

 

 

 

其中比较重要的是获取到Assets和Raw文件夹中的资源方法:

      Assets:     AssetManager assetManager = getAssets();

      Raw:        InputStream inputStream = getResources().openRawResource(R.raw.demo); 

 

 

 

把代码贴进来研究

 

 

java部分：

 

（1）ASMFit.java

 

package org.asmlibrary.fit;

import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;

import android.util.Log;

public class ASMFit {
	
	public ASMFit(){}
	
	/**
	 * This function can only be used after nativeInitFastCascadeDetector()
	 * @param imageGray original gray image 
	 * @param faces all faces' feature points 
	 * @return true if found faces, false otherwise
	 */
	public boolean fastDetectAll(Mat imageGray, Mat faces){
		return nativeFastDetectAll(imageGray.getNativeObjAddr(), 
				faces.getNativeObjAddr());
	}
	
	/**
	 * This function can only be used after nativeInitCascadeDetector()
	 * @param imageGray original gray image 
	 * @param face all faces' feature points 
	 * @return true if found faces, false otherwise
	 */
	public boolean detectAll(Mat imageGray, Mat faces){
		return nativeDetectAll(imageGray.getNativeObjAddr(), 
				faces.getNativeObjAddr());
	}
	
	/**
	 * This function can only be used after nativeInitCascadeDetector()
	 * @param imageGray original gray image 
	 * @param faces only one face's feature points 
	 * @return true if found faces, false otherwise
	 */
	public boolean detectOne(Mat imageGray, Mat face){
		return nativeDetectOne(imageGray.getNativeObjAddr(), 
				face.getNativeObjAddr());
	}
	
	public void fitting(Mat imageGray, Mat shapes){
		nativeFitting(imageGray.getNativeObjAddr(), 
				shapes.getNativeObjAddr());
	}
	
	public boolean videoFitting(Mat imageGray, Mat shape, long frame){
		return nativeVideoFitting(imageGray.getNativeObjAddr(),
				shape.getNativeObjAddr(), frame);
	}
	
	public static native boolean nativeReadModel(String modelName);

	/**
	 * @param cascadeName could be haarcascade_frontalface_alt2.xml 
	 * @return
	 */
	public static native boolean nativeInitCascadeDetector(String cascadeName);
	public static native void nativeDestroyCascadeDetector();
	
	/**
	 * @param cascadeName could be lbpcascade_frontalface.xml 
	 * @return
	 */
	public static native boolean nativeInitFastCascadeDetector(String cascadeName);
	public static native void nativeDestroyFastCascadeDetector();
	
	public static native void nativeInitShape(long faces);
	
	private static native boolean nativeDetectAll(long inputImage, long faces);
	private static native boolean nativeDetectOne(long inputImage, long face);
	private static native boolean nativeFastDetectAll(long inputImage, long faces);
	
	private static native void nativeFitting(long inputImage, long shapes);
	private static native boolean nativeVideoFitting(long inputImage, long shape, long frame);

}

 

 

 

 

 

（2）ASMLibraryActivity.java

 

package org.asmlibrary.fit;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

import org.opencv.android.BaseLoaderCallback;
import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
import org.opencv.android.LoaderCallbackInterface;
import org.opencv.android.OpenCVLoader;
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.highgui.Highgui;
import org.opencv.core.Scalar;
import org.opencv.core.Point;
import org.opencv.android.CameraBridgeViewBase;
import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
import org.asmlibrary.fit.R;
import org.asmlibrary.fit.ASMFit;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.WindowManager;
import android.content.res.Configuration;

public class ASMLibraryActivity extends Activity implements CvCameraViewListener2{
    
	private static final String    TAG                 = "ASMLibraryDemo";
    
    private Mat                    	mRgba;
    private Mat                    	mGray;
    private Mat                    	mGray2;
    private File                   	mCascadeFile;
    private File                   	mFastCascadeFile;
    private File                   	mModelFile;
    private ASMFit      		   	mASMFit;
    private long				   	mFrame;
    private boolean					mFlag;
    private boolean					mPortrait = true;
    private boolean					mFastDetect = false;
    private Mat						mShape;
    private static final Scalar 	mColor = new Scalar(255, 0, 0);
    private MenuItem               	mHelpItem;
    private MenuItem               	mDetectItem;
    private MenuItem               	mOrieItem;
    private MenuItem				mCameraitem;
    private CameraBridgeViewBase   	mOpenCvCameraView;
    private int 					mCameraIndex = CameraBridgeViewBase.CAMERA_ID_ANY;
    
    public ASMLibraryActivity() {
        Log.i(TAG, "Instantiated new " + this.getClass());
    }
    
    private BaseLoaderCallback  mLoaderCallback = new BaseLoaderCallback(this) {
    	private File getSourceFile(int id, String name, String folder){
    		File file = null;
    		try {
	    		InputStream is = getResources().openRawResource(id);
	            File cascadeDir = getDir(folder, Context.MODE_PRIVATE);
	            file = new File(cascadeDir, name);
	            FileOutputStream os = new FileOutputStream(file);
	            
	            byte[] buffer = new byte[4096];
	            int bytesRead;
	            while ((bytesRead = is.read(buffer)) != -1) {
	                os.write(buffer, 0, bytesRead);
	            }
	            is.close();
	            os.close();
    		}catch (IOException e) {
                e.printStackTrace();
                Log.e(TAG, "Failed to load file " + name + ". Exception thrown: " + e);
            }
	            
            return file;
    		
    	}
    	
        @Override
        public void onManagerConnected(int status) {
            switch (status) {
                case LoaderCallbackInterface.SUCCESS:
                {
                    Log.i(TAG, "OpenCV loaded successfully");

                    // Load native library after(!) OpenCV initialization
                    System.loadLibrary("asmlibrary");
                    System.loadLibrary("jni-asmlibrary");
                    
                    mASMFit = new ASMFit();

                    mModelFile = getSourceFile(R.raw.my68_1d, "my68_1d.amf", "model");
                    if(mModelFile != null)
                    	mASMFit.nativeReadModel(mModelFile.getAbsolutePath());
                    
                    
                    mCascadeFile = getSourceFile(R.raw.haarcascade_frontalface_alt2, 
                    		"haarcascade_frontalface_alt2.xml", "cascade");
                    if(mCascadeFile != null)
                    	mASMFit.nativeInitCascadeDetector(mCascadeFile.getAbsolutePath());

                    mFastCascadeFile = getSourceFile(R.raw.lbpcascade_frontalface, 
                    		"lbpcascade_frontalface.xml", "cascade");
                    if(mFastCascadeFile != null)
                    	mASMFit.nativeInitFastCascadeDetector(mFastCascadeFile.getAbsolutePath());
                    
                    //test image alignment
                    // load image file from application resources
                	File JPGFile = getSourceFile(R.raw.gump, "gump.jpg", "image");
                	
                	Mat image = Highgui.imread(JPGFile.getAbsolutePath(), Highgui.IMREAD_GRAYSCALE);
                    Mat shapes = new Mat();
                    
                    if(mASMFit.detectAll(image, shapes) == true)
        			{
                    	/*
                    	for(int i = 0; i < shapes.row(0).cols()/2; i++)
        				{
                        	Log.d(TAG, "before points:" + 
                        			shapes.get(0, 2*i)[0] +"," +shapes.get(0, 2*i+1)[0]);
        				}
        				*/
                    	
        				mASMFit.fitting(image, shapes);
        				
        				/*
        				for(int i = 0; i < shapes.row(0).cols()/2; i++)
        				{
                        	Log.d(TAG, "after points:" + 
                        			shapes.get(0, 2*i)[0] +"," +shapes.get(0, 2*i+1)[0]);
        				}
        				*/
        			}

                    mOpenCvCameraView.enableView();
                } break;
                default:
                {
                    super.onManagerConnected(status);
                } break;
            }
        }
    };

	/** Called when the activity is first created. */
	@Override
    public void onCreate(Bundle savedInstanceState) {
        Log.i(TAG, "called onCreate");
        super.onCreate(savedInstanceState);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

        setContentView(R.layout.face_detect_surface_view);

        mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.fd_activity_surface_view);
        mOpenCvCameraView.setCvCameraViewListener(this);
        mFrame = 0;
        mFlag = false;
    }
	
	@Override
    public void onPause()
    {
        super.onPause();
        if (mOpenCvCameraView != null)
            mOpenCvCameraView.disableView();
    }

    @Override
    public void onResume()
    {
        super.onResume();
        OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_3, this, mLoaderCallback);
        mFrame = 0;
        mFlag = false;
    }
    
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        Log.i(TAG, "called onCreateOptionsMenu"+mFastDetect);
        mCameraitem = menu.add("Toggle Front/Back");
        mOrieItem = menu.add("Toggle Portrait");
        if(mFastDetect == true)
        	mDetectItem = menu.add("CascadeDetector");
        else
        	mDetectItem = menu.add("FastCascadeDetector");
        mHelpItem = menu.add("About ASMLibrary");
        return true;
    }
    
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);
        if (item == mHelpItem)
        	new AlertDialog.Builder(this).setTitle("About ASMLibrary")
        		.setMessage("ASMLibrary -- A compact SDK for face alignment/tracking\n" +
        				"Copyright (c) 2008-2011 by Yao Wei, all rights reserved.\n" +
        				"Contact: [email protected]\n")
        				.setPositiveButton("OK", null).show();
        else if(item == mDetectItem)
        {
        	mFastDetect = !mFastDetect;
        }
        else if(item == mOrieItem)
        {
        	mPortrait = !mPortrait;
        }
        else if(item == mCameraitem)
        {
        	if(mCameraIndex == CameraBridgeViewBase.CAMERA_ID_ANY ||
        			mCameraIndex == CameraBridgeViewBase.CAMERA_ID_BACK)
        		mCameraIndex = CameraBridgeViewBase.CAMERA_ID_FRONT;
        	else
        		mCameraIndex = CameraBridgeViewBase.CAMERA_ID_BACK;
        	mOpenCvCameraView.setCameraIndex(mCameraIndex);
        }
        return true;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        mOpenCvCameraView.disableView();
    }

    public void onCameraViewStarted(int width, int height) {
        mGray = new Mat();
        mGray2 = new Mat();
        mRgba = new Mat();
        mShape = new Mat();
        mFrame = 0;
        mFlag = false;
    }

    public void onCameraViewStopped() {
        mGray.release();
        mRgba.release();
    }

    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {

        mRgba = inputFrame.rgba();
        mGray = inputFrame.gray();
        
        if(mPortrait ==true) 
        	Core.transpose(mGray, mGray2);
        else
        	mGray2 = mGray;
        
        //WindowManager manager = getWindowManager();
        //int width = manager.getDefaultDisplay().getWidth();
        //int height = manager.getDefaultDisplay().getHeight();
        //Log.d(TAG, "屏幕大小" + width + "x" + height);

        if(mFrame == 0 || mFlag == false)
		{
        	Mat detShape = new Mat();
			if(mFastDetect)
				mFlag = mASMFit.fastDetectAll(mGray2, detShape);
			else
				mFlag = mASMFit.detectAll(mGray2, detShape);
			if(mFlag)	mShape = detShape.row(0);
		}
			
		if(mFlag) 
		{
			mFlag = mASMFit.videoFitting(mGray2, mShape, mFrame);
		}
		
		if(mFlag)
		{
			if(mPortrait == true)
			{
				int nPoints = mShape.row(0).cols()/2;
				for(int i = 0; i < nPoints; i++)
				{ 
					double x = mShape.get(0, 2*i)[0];
					double y = mShape.get(0, 2*i+1)[0];
					Point pt = new Point(y, x);
					
					Core.circle(mRgba, pt, 3, mColor);
				}
			}
			else
			{
				int nPoints = mShape.row(0).cols()/2;
				for(int i = 0; i < nPoints; i++)
				{ 
					Point pt = new Point(mShape.get(0, 2*i)[0], mShape.get(0, 2*i+1)[0]);
					Core.circle(mRgba, pt, 3, mColor);
				}
			}
		}
		
		mFrame ++;

        return mRgba;
    }
}

 

 

 

 

 

C++部分（jni）

（1）Android.mk

 

LOCAL_PATH := $(call my-dir)


include $(CLEAR_VARS)
LOCAL_MODULE := asmlibrary
LOCAL_SRC_FILES := so/$(TARGET_ARCH_ABI)/libasmlibrary.so
include $(PREBUILT_SHARED_LIBRARY) 


include $(CLEAR_VARS)

#OPENCV_CAMERA_MODULES:=off
#OPENCV_INSTALL_MODULES:=off
#OPENCV_LIB_TYPE:=SHARED
include E:\android-eclipse\OpenCV-2.4.8-android-sdk/sdk/native/jni/OpenCV.mk

LOCAL_SRC_FILES  := DemoFit.cpp
LOCAL_C_INCLUDES += $(LOCAL_PATH)
LOCAL_CFLAGS    += -DOPENCV_OLDER_VISION
LOCAL_LDLIBS     += -llog -ldl  

LOCAL_MODULE     := jni-asmlibrary

LOCAL_SHARED_LIBRARIES := asmlibrary

include $(BUILD_SHARED_LIBRARY)

（2）Application.mk

 

 

APP_STL := gnustl_static
APP_CPPFLAGS := -frtti -fexceptions
APP_ABI := armeabi-v7a armeabi x86 mips
APP_PLATFORM := android-8

（3）asmfitting.h

 

 

#ifndef _ASM_FITTING_H_
#define _ASM_FITTING_H_

#include "asmlibrary.h"

/** Wrapped Class for face alignment/tracking using active shape model */
class ASMLIB asmfitting
{
public:
	/** Constructor */
	asmfitting();

	/** Destructor */
	~asmfitting();
	
	/**
     Process face alignment on image. (Only for one face box)
	 @param shape the point features that carries initial shape and also restores result after fitting
	 @param image the image resource
	 @param n_iteration the number of iteration during fitting
	*/
	void Fitting(asm_shape& shape, const IplImage* image, int n_iteration = 30);
	
	/**
     Process face alignment on image. (For multi-face boxes)
	 @param shapes all shape datas that carry the fitting result
	 @param n_shapes the number of human face
	 @param image the image resource
	 @param n_iteration the number of iteration during fitting
	*/
	void Fitting2(asm_shape* shapes, int n_shapes, const IplImage* image, int n_iteration = 30);
	
	/**
     Process face tracking on video/camera.
	 @param shape the point features that carries initial shape and also restores result after fitting
	 @param image the image resource
	 @param frame_no one certain frame number of video/camera
	 @param bopticalflow whether to use optical flow or not?
	 @param n_iteration the number of iteration during fitting
	 @return false on failure, true otherwise.
	 */
	bool ASMSeqSearch(asm_shape& shape, const IplImage* image, 
		int frame_no = 0, bool bopticalflow = false, int n_iteration = 30);
	
	/**<
     Get the Average Viola-Jone Box.
	*/
	const asm_shape GetMappingDetShape()const { return m__VJdetavshape;}
	
	/**<
     Get the width of mean face.
	*/
	const double	GetMeanFaceWidth()const{ return m_model.GetMeanShape().GetWidth();	}
	
	/**<
	 Get raw ptr of asm_model.
	*/
	const asm_model* GetModel()const { return &m_model; }
	
	/**
     Read model data from file.
	 @param filename the filename that stores the model
	 @return false on failure, true otherwise
    */
	bool Read(const char* filename);

private:

	/**
     Apply optical flow between two successive frames.
	 @param shape it carries initial shape and also restores result after fitting
	 @param grayimage the image resource.
	*/
	void OpticalFlowAlign(asm_shape& shape, const IplImage* grayimage);

private:
	asm_model	m_model;	/**<active shape model to be trained */
	int *m_edge_start; /**< Starting index of edges */
	int *m_edge_end;   /**< Ending index of edges */
	int m_nEdge;       /**< Number of edges */
	asm_shape m__VJdetavshape;    /**< average mapping shape relative to VJ detect box*/
	scale_param m_param;			/**< point index of left and right side in the face template*/
	bool m_flag;					/**< Does the image contain face? */
	double m_dReferenceFaceWidth;	/**< reference face width */

private:
	IplImage* __lastframe;  /**< Cached variables for optical flow */
	IplImage* __pyrimg1;	/**< Cached variables for optical flow */
	IplImage* __pyrimg2;	/**< Cached variables for optical flow */
	Point2D32f* __features1;	/**< Cached variables for optical flow */
	Point2D32f* __features2;	/**< Cached variables for optical flow */
	char* __found_feature;	/**< Cached variables for optical flow */
	float* __feature_error;	/**< Cached variables for optical flow */
};

#endif //_ASM_FITTING_H_

（4）asmlibrary.h

#ifndef _ASM_LIBRARY_H_
#define _ASM_LIBRARY_H_

#include <stdio.h>

class asm_shape;
class asm_profile;
class asm_model;
struct profile_Nd_model;
struct profile_lbp_model;
struct CvMat;
struct _IplImage;

typedef unsigned char uchar;
typedef struct _IplImage IplImage;

#ifdef WIN32
#ifdef ASMLIBRARY_EXPORTS
#define ASMLIB __declspec(dllexport)
#else
#define ASMLIB __declspec(dllimport)
#endif
#else
#define ASMLIB
#endif

/**
 * Predefined local texture (profile) types.
 * <ul>
 * <li>PROFILE_1D: use only the pixels along the normal vector in the contour.</li>
 * <li>PROFILE_2D: use the pixels located at the recentage.</li>
 * <li>PROFILE_LBP: use the pixels processed with LBP-operator.</li>
 * </ul>
 **/
enum ASM_PROFILE_TYPE {PROFILE_1D, PROFILE_2D, PROFILE_LBP};

#ifdef __cplusplus
extern "C"{
#endif

/**
 Initialize shape from the detected box.
 @param shape the returned initial shape
 @param det_shape the detected box calling by \a asm_vjfacedetect::\a Detect()
 @param ref_shape the average mean shape
 @param refwidth the width of average mean shape
*/
ASMLIB void InitShapeFromDetBox(asm_shape &shape, const asm_shape& det_shape, 
								const asm_shape &ref_shape, double refwidth);

#ifdef __cplusplus
}
#endif

/** Class for 2d point. */
typedef struct Point2D32f
{
    float x;
    float y;
}
Point2D32f;

/** Class for 2d shape data. */
class ASMLIB asm_shape
{
public:
    /** Constructor */
	asm_shape();
    
	/** Copy Constructor */
	asm_shape(const asm_shape &v);
    
	/** Destructor */
    ~asm_shape();

	/**
     Access elements by \a CvPoint2D32f \a pt = \a shape[\a i] to get \a i-th point in the shape.
     @param i Index of points
     @return   Point at the certain index
	*/
	const Point2D32f operator [](int i)const{ return m_vPoints[i];	}
	
	/**
     Access elements by \a CvPoint2D32f \a pt = \a shape[\a i] to get \a i-th point in the shape.
     @param i Index of points
     @return   Point at the certain index
	*/
	Point2D32f& operator [](int i){ return m_vPoints[i];	}
	
	/**
     Get the number of points.
     @return   Number of points
	*/
	inline const int NPoints()const{ return	m_nPoints; }

    /**
     Override of operator =
    */
    asm_shape&			operator =(const asm_shape &s);
    
	/**
     Override of operator =.
    */
	asm_shape&			operator =(double value);
    
	/**
     Override of operator +
    */
    const asm_shape		operator +(const asm_shape &s)const;
    
	/**
     Override of operator +=
    */
    asm_shape&			operator +=(const asm_shape &s);
    
	/**
     Override of operator -
    */
    const asm_shape     operator -(const asm_shape &s)const;
    
	/**
     Override of operator -=
    */
    asm_shape&			operator -=(const asm_shape &s);
    
	/**
     Override of operator *
    */
    const asm_shape     operator *(double value)const;
    
	/**
     Override of operator *=
    */
    asm_shape&			operator *=(double value);
    
	/**
     Override of operator *
    */
    double				operator *(const asm_shape &s)const;
    
	/**
     Override of operator /
    */
    const asm_shape     operator /(double value)const;
    
	/**
     Override of operator /=
    */
    asm_shape&			operator /=(double value);

	/**
     Release memory.
    */
    void    Clear();
    
	/**
     Allocate memory.
	 @param length Number of of shape points
    */
    void    Resize(int length);
    
	/**
     Read points from file.
	 @param filename the filename the stored shape data
     @return   true on pts format, false on asf format, exit otherwise
    */
    bool	ReadAnnotations(const char* filename);
	
	/**
     Read points from asf format file.
	 @param filename the filename the stored shape data
    */
    void    ReadFromASF(const char*filename);
	
	/**
     Read points from pts format file.
	 @param filename the filename the stored shape data
    */
    void	ReadFromPTS(const char*filename);
	
	/**
     Write shape data into file stream.
	 @param f  stream to write to
    */
	void	Write(FILE* f);
	
	/**
     Read shape data from file stream.
	 @param f  stream to read from
    */
	void	Read(FILE* f);
	
	/**
     Calculate minimum \f$x\f$-direction value of shape.
    */
	const double  MinX()const;
    
	/**
     Calculate minimum \f$y\f$-direction value of shape.
    */
	const double  MinY()const;
    
	/**
     Calculate maximum \f$x\f$-direction value of shape.
    */
	const double  MaxX()const;
    
	/**
     Calculate maximum \f$y\f$-direction value of shape.
    */
	const double  MaxY()const;
	
	/**
     Calculate the left and right index for \f$x\f$-direction in the shape.
	 @param ileft the index of points in \f$x\f$-direction which has the minimum x
	 @param iright the index of points in \f$x\f$-direction which has the maximum x
    */
	void		  GetLeftRight(int& ileft, int& iright)const;
    
	/**
     Calculate width of shape.
	 @param ileft Index of points in \f$x\f$-direction which has the minimum x
	 @param iright Index of points in \f$x\f$-direction which has the maximum x
    */
	const double  GetWidth(int ileft = -1, int iright = -1)const;
	
	/**
     Calculate height of shape.
    */
	const double  GetHeight()const { return MaxY()-MinY();	}
	
    /**
     Calculate center of gravity for shape.
	 @param x Value of center in \f$x\f$-direction
	 @param y Value of center in \f$y\f$-direction
    */
	void    COG(double &x, double &y)const;
    
	/**
     Translate the shape to make its center locate at (0, 0).
	*/
	void    Centralize();
    
	/**
	 Translate the shape.
	 @param x Value of translation factor in \f$x\f$-direction
	 @param y Value of translation factor in \f$y\f$-direction
    */
	void    Translate(double x, double y);
    
	/**
     Scale shape by an uniform factor.
	 @param s Scaling factor
	*/
	void    Scale(double s);
    
	/**
     Rotate shape by anti clock-wise.
	 @param theta Angle to be rotated
	*/
	void    Rotate(double theta);
	
	/**
     Scale shape in x and y direction respectively.
	 @param sx Scaling factor in \f$x\f$-direction
	 @param sy Scaling factor in \f$y\f$-direction
	*/
	void    ScaleXY(double sx, double sy);
	
	/**
     Normalize shape (zero_mean_unit_length) so that its center locates at (0, 0) and its \f$L2\f$-norm is 1.
	 @return the \f$L2\f$-norm of original shape
	*/
	double	Normalize();
	
	
	enum{ LU, SVD, Direct };

	/**
	 Calculate the similarity transform between one shape and another reference shape. 
	 Where the similarity transform is: 
	 <BR>
	 \f$T(a,b,tx,ty) = [a \ -b \ Tx; b \ a \ Ty ; 0 \ 0 \ 1]\f$.
	 @param ref_shape the reference shape
	 @param a  will return \f$ s \times cos(theta) \f$ in form of similarity transform
	 @param b  will return \f$ s \times sin(theta) \f$ in form of similarity transform
	 @param tx will return \f$ Tx \f$ in form of similarity transform
	 @param ty will return \f$ Ty \f$ in form of similarity transform
	 @param method  Method of similarity transform
	*/
	void    AlignTransformation(const asm_shape &ref_shape, double &a, double &b, 
								double &tx, double &ty, int method = SVD)const;
    
	/**
	 Align the shape to the reference shape. 
	 @param ref_shape the reference shape
	 @param method  method of similarity transform
	*/
	void    AlignTo(const asm_shape &ref_shape, int method = SVD);
    
	/**
	 Transform Shape using the similarity transform \f$T(a,b,tx,ty)\f$. 
	*/
	void    TransformPose(double a, double b, double tx, double ty);

	/**
	 Calculate the angular bisector between two lines \f$Pi-Pj\f$ and \f$Pj-Pk\f$. 
	 @param i the index of point vertex
	 @param j the index of point vertex
	 @param k the index of point vertex
	 @return Angular bisector vector in form of \f$(cos(x), sin(x))^T\f$
	*/
	Point2D32f CalcBisector(int i, int j, int k)const;

	/**
	 Calculate the Euclidean norm (\f$L2\f$-norm). 
	 @return Euclidean norm
	*/
	double  GetNorm2()const;

	/**
	 Calculate the normal vector at certain vertex around the shape contour. 
	 @param cos_alpha the normal vector in \f$x\f$-direction
	 @param sin_alpha the normal vector in \f$y\f$-direction
	 @param i the index of point vertex
	*/
	void	CalcNormalVector(double &cos_alpha, double &sin_alpha, int i)const;

	/**
	 Convert from OpenCV's \a CvMat to class asm_shape
	 @param mat \a CvMat that converted from
	*/
	void    CopyFrom(const CvMat* mat);
	
	/**
	 Convert from class asm_shape to OpenCV's CvMat.
	 @param mat CvMat that converted to
	*/
	void    CopyTo(CvMat* mat)const;

private:
	void    Transform(double c00, double c01, double c10, double c11);

private:
	Point2D32f* m_vPoints;	/**< point data */
	int m_nPoints;				/**< number of points */
};

/** Left and Right index in \f$x\f$-direction of shape */
typedef struct scale_param
{
	int left;	/**< Index of points in \f$x\f$-direction which has the minimum x */
	int right;	/**< Index of points in \f$x\f$-direction which has the maximum x */
}scale_param;


/** Class for active shape model. */
class ASMLIB asm_model
{
public:
	/**
	 Constructor
	*/
	asm_model();
	
	/**
	 Destructor
	*/
	~asm_model();

	/**
	 Image alignment/fitting with an initial shape.
	 @param shape the point features that carries initial shape and also restores result after fitting
	 @param grayimage the gray image resource
	 @param max_iter the number of iteration
	 @param param the left and right index for \f$x\f$-direction in the shape (Always set \a NULL )
	 @return false on failure, true otherwise
	*/
	bool Fit(asm_shape& shape, const IplImage *grayimage, 
		int max_iter = 30, const scale_param* param = NULL);	
	
	/**
     Write model data to file stream.
	 @param f  stream to write to
    */
	void WriteModel(FILE* f);
	
	/**
     Read model data from file stream.
	 @param f  stream to read from
    */
	void ReadModel(FILE* f);

	/**
	 Get mean shape of model.
	*/
	const asm_shape& GetMeanShape()const { return m_asm_meanshape;	}
	
	/**
	 Get modes of shape distribution model (Will be calculated in shape's PCA)
	*/
	const int GetModesOfModel()const { return m_nModes;}
	
	/**
	 Get the width of mean shape [Identical to \a m_asm_meanshape.\a GetWidth()].
	*/
	const double GetReferenceWidthOfFace()const { return m_dReferenceFaceWidth; }

private:

	/**
     Get the optimal offset at one certain point vertex during the process of 
	 best profile matching (work for 1d/2d profile model).
	 @param image the image resource
	 @param ilev one certain pyramid level
	 @param shape the shape data
	 @param ipoint the index of point vertex
	 @param cos_alpha the normal vector in \f$x\f$-direction
	 @param sin_alpha the normal vector in \f$y\f$-direction
	 @return offset bias from \a Shape[\a iPoint]
	*/
	int FindBestOffsetForNd(const IplImage* image, int ilev,
							const asm_shape& shape, int ipoint,
							double& cos_alpha, double& sin_alpha);

	/**
     Get the optimal offset at one certain point vertex during the process of 
	 best profile matching (work for lbp profile model).
  	 @param lbp_img the target image processed with LBP
	 @param nrows the height of \a lbp_img
	 @param ncols the width of \a lbp_img
	 @param ilev one certain pyramid level
	 @param shape the shape data
	 @param ipoint the index of point vertex
	 @param xoffset the returned offset in \f$x\f$-direction away from \a Shape[\a iPoint]
	 @param yoffset the returned offset in \f$y\f$-direction away from \a Shape[\a iPoint]
	*/
	void FindBestOffsetForLBP(const int* lbp_img, int nrows, int ncols, int ilev,
				const asm_shape& shape, int ipoint, int& xoffset, int& yoffset);

	/**
     Update shape by matching the image profile to the model profile.
	 @param update_shape the updated shape
	 @param shape  the point feature that will be matched
	 @param ilev one certain pyramid level
	 @param image the image resource
	 @param lbp_img the LBP-operator image
	 @param norm the \f$L2\f$-norm of the difference between \a shape and \a update_shape
	 @return how many point vertex will be updated?
	*/
	int MatchToModel(asm_shape& update_shape, const asm_shape& shape, 
		int ilev, const IplImage* image, const int *lbp_img, double* norm = NULL);

	/**
     Calculate shape parameters (\a a, \a b, \a Tx, \a Ty) and pose parameters \a p.
	 @param p  Shape parameters
	 @param a  \f$ s \times cos(theta) \f$ in form of similarity transform
	 @param b  \f$ s \times sin(theta) \f$ in form of similarity transform
	 @param tx \f$ Tx \f$ in form of similarity transform
	 @param ty \f$ Ty \f$ in form of similarity transform
	 @param shape  the point features data
	 @param iter_no Number of iteration
	*/
	void CalcParams(CvMat* p, double& a, double& b,	double& tx, double& ty, 
		const asm_shape& shape, int iter_no = 2);
	
	/**
     Constrain the shape parameters.
	 @param p  Shape parameters
	*/
	void Clamp(CvMat* p);

	/**
     Generate shape instance according to shape parameters p and pose parameters.
	 @param shape the point feature data
	 @param p  the shape parameters
	 @param a  Return \f$ s \times cos(theta) \f$ in form of similarity transform
	 @param b  Return \f$ s \times sin(theta) \f$ in form of similarity transform
	 @param tx  Return \f$ Tx \f$ in form of similarity transform
	 @param ty  Return \f$ Ty \f$ in form of similarity transform
	*/
	void CalcGlobalShape(asm_shape& shape, const CvMat* p, 
							double a, double b, double tx, double ty);

	/**
     Pyramid fitting at one certain level.
	 @param shape the point feature data
	 @param image the image resource
	 @param ilev one certain pyramid level
	 @param iter_no the number of iteration
	*/
	void PyramidFit(asm_shape& shape, const IplImage* image, int ilev, int iter_no);

private:

	CvMat*  m_M;   /**< mean vector of shape data */
    CvMat*  m_B;   /**< eigenvetors of shape data */
    CvMat*  m_V;   /**< eigenvalues of shape data */

	CvMat* m_SM;   /**< mean of shapes projected space */	
	CvMat* m_SSD;  /**< standard deviation of shapes projected space	*/	


	ASM_PROFILE_TYPE m_type;	/**< the type of sampling profile */
	
	/**< the profile distribution model */
	union
	{
		struct profile_lbp_model* lbp_tdm;			/**< lbp profile model */
		struct profile_Nd_model* classical_tdm;	/**< 1d/2d profile model */
	}; 
	
	
	asm_shape m_asm_meanshape;			/**< mean shape of aligned shapes */
	
	int m_nPoints;					/**< number of shape points */
	int m_nWidth;					/**< width of each landmark's profile */
	int m_nLevels;					/**< pyramid level of multi-resolution */
	int m_nModes;					/**< number of truncated eigenvalues */
	double m_dReferenceFaceWidth;	/**< width of reference face  */
	bool m_bInterpolate;			/**< whether to using image interpolate or not*/
	double m_dMeanCost;		/**< the mean of fitting cost to determine whether fitting succeed or not*/
	double m_dVarCost;		/**< the variance of fitting cost determine whether fitting succeed or not*/

private:
	CvMat*		m_CBackproject; /**< Cached variables for speed up */
	CvMat*		m_CBs;			/**< Cached variables for speed up */
	double*		m_dist;			/**< Cached variables for speed up */
	asm_profile* m_profile;		/**< Cached variables for speed up */
	asm_shape	m_search_shape;	/**< Cached variables for speed up */
	asm_shape	m_temp_shape;	/**< Cached variables for speed up */
};

/** You can define your own face detector function here
 @param shapes Returned face detected box which stores the Top-Left and Bottom-Right points, so its \a NPoints() = 2 here.
 @param image Image resource.
 @return false on no face exists in image, true otherwise.
*/
typedef	bool (*detect_func)(asm_shape& shape, const IplImage* image);

#endif  // _ASM_LIBRARY_H_

 

 

 

（5）DemoFit.cpp

 

#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/contrib/detection_based_tracker.hpp>

#include "asmfitting.h"
#include "vjfacedetect.h"

#include <string>
#include <vector>

#include <android/log.h>
#include <jni.h>

using namespace std;
using namespace cv;

#define LOG_TAG "ASMLIBRARY"
#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__))

#define BEGINT()	double t = (double)cvGetTickCount();
#define ENDT(exp)	t = ((double)cvGetTickCount() -  t )/  (cvGetTickFrequency()*1000.);	\
					LOGD(exp " time cost: %.2f millisec\n", t);

asmfitting fit_asm;
DetectionBasedTracker *track = NULL;

#ifdef __cplusplus
extern "C" {
#endif

JNIEXPORT jboolean JNICALL Java_org_asmlibrary_fit_ASMFit_nativeReadModel
(JNIEnv * jenv, jclass, jstring jFileName)
{
    LOGD("nativeReadModel enter");
    const char* filename = jenv->GetStringUTFChars(jFileName, NULL);
    jboolean result = false;

    try
    {
	if(fit_asm.Read(filename) == true)
		result = true;

    }
    catch (...)
    {
        LOGD("nativeReadModel caught unknown exception");
        jclass je = jenv->FindClass("java/lang/Exception");
        jenv->ThrowNew(je, "Unknown exception in JNI code");
    }

    LOGD("nativeReadModel %s exit %d", filename, result);
    return result;
}

JNIEXPORT jboolean JNICALL Java_org_asmlibrary_fit_ASMFit_nativeInitCascadeDetector
(JNIEnv * jenv, jclass, jstring jFileName)
{
    const char* cascade_name = jenv->GetStringUTFChars(jFileName, NULL);
    LOGD("nativeInitCascadeDetector %s enter", cascade_name);

    if(init_detect_cascade(cascade_name) == false)
		return false;

    LOGD("nativeInitCascadeDetector exit");
    return true;
}

JNIEXPORT jboolean JNICALL Java_org_asmlibrary_fit_ASMFit_nativeInitFastCascadeDetector
(JNIEnv * jenv, jclass, jstring jFileName)
{
    const char* cascade_name = jenv->GetStringUTFChars(jFileName, NULL);
    LOGD("nativeInitFastCascadeDetector %s enter", cascade_name);

    DetectionBasedTracker::Parameters DetectorParams;
    DetectorParams.minObjectSize = 45;
    track = new DetectionBasedTracker(cascade_name, DetectorParams);

    if(track == NULL)	return false;

    DetectorParams = track->getParameters();
    DetectorParams.minObjectSize = 64;
    track->setParameters(DetectorParams);

    track->run();

    LOGD("nativeInitFastCascadeDetector exit");
    return true;
}

JNIEXPORT void JNICALL Java_org_asmlibrary_fit_ASMFit_nativeDestroyCascadeDetector
(JNIEnv * jenv, jclass)
{
    LOGD("nativeDestroyCascadeDetector enter");

    destory_detect_cascade();

    LOGD("nativeDestroyCascadeDetector exit");
}

JNIEXPORT void JNICALL Java_org_asmlibrary_fit_ASMFit_nativeDestroyFastCascadeDetector
(JNIEnv * jenv, jclass)
{
    LOGD("nativeDestroyFastCascadeDetector enter");

    if(track){
    	track->stop();
    	delete track;
    }

    LOGD("nativeDestroyFastCascadeDetector exit");
}

inline void shape_to_Mat(asm_shape shapes[], int nShape, Mat& mat)
{
	mat = Mat(nShape, shapes[0].NPoints()*2, CV_64FC1); 

	for(int i = 0; i < nShape; i++)
	{
		double *pt = mat.ptr<double>(i);  
		for(int j = 0; j < mat.cols/2; j++)
		{
			pt[2*j] = shapes[i][j].x;
			pt[2*j+1] = shapes[i][j].y;		
		}
	}
}

inline void Mat_to_shape(asm_shape shapes[], int nShape, Mat& mat)
{
	for(int i = 0; i < nShape; i++)
	{
		double *pt = mat.ptr<double>(i);  
		shapes[i].Resize(mat.cols/2);
		for(int j = 0; j < mat.cols/2; j++)
		{
			shapes[i][j].x = pt[2*j];
			shapes[i][j].y = pt[2*j+1];
		}
	}
}

JNIEXPORT jboolean JNICALL Java_org_asmlibrary_fit_ASMFit_nativeFastDetectAll
(JNIEnv * jenv, jclass, jlong imageGray, jlong faces)
{
	if(!track)	return false;

	BEGINT();

	vector<Rect> RectFaces;
	try{
		Mat image = *(Mat*)imageGray;
		LOGD("image: (%d, %d)", image.cols, image.rows);
		track->process(image);
		track->getObjects(RectFaces);
	}
	catch(cv::Exception& e)
	{
		LOGD("nativeFastDetectAll caught cv::Exception: %s", e.what());
		jclass je = jenv->FindClass("org/opencv/core/CvException");
		if(!je)
			je = jenv->FindClass("java/lang/Exception");
		jenv->ThrowNew(je, e.what());
	}
	catch (...)
	{
		LOGD("nativeFastDetectAll caught unknown exception");
		jclass je = jenv->FindClass("java/lang/Exception");
		jenv->ThrowNew(je, "Unknown exception in JNI code");
	}

	int nFaces = RectFaces.size();
	if(nFaces <= 0){
		ENDT("FastCascadeDetector CANNOT detect any face");
		return false;
	}

	LOGD("FastCascadeDetector found %d faces", nFaces);

	asm_shape* detshapes = new asm_shape[nFaces];
	for(int i = 0; i < nFaces; i++){
		Rect r = RectFaces[i];
		detshapes[i].Resize(2);
		detshapes[i][0].x = r.x;
		detshapes[i][0].y = r.y;
		detshapes[i][1].x = r.x+r.width;
		detshapes[i][1].y = r.y+r.height;
	}

	asm_shape* shapes = new asm_shape[nFaces];
	for(int i = 0; i < nFaces; i++)
	{
		InitShapeFromDetBox(shapes[i], detshapes[i], fit_asm.GetMappingDetShape(), fit_asm.GetMeanFaceWidth());
	}

	shape_to_Mat(shapes, nFaces, *((Mat*)faces));

	delete []detshapes;
	delete []shapes;

	ENDT("FastCascadeDetector detect");

	return true;
}

JNIEXPORT jboolean JNICALL Java_org_asmlibrary_fit_ASMFit_nativeDetectAll
(JNIEnv * jenv, jclass, jlong imageGray, jlong faces)
{
	IplImage image = *(Mat*)imageGray;
	int nFaces;
	asm_shape *detshapes = NULL;

	LOGD("image: (%d, %d)", image.width, image.height);

	BEGINT();

	bool flag =detect_all_faces(&detshapes, nFaces, &image);
	if(flag == false)	{
		ENDT("CascadeDetector CANNOT detect any face");
		return false;
	}

	LOGD("CascadeDetector found %d faces", nFaces);
	asm_shape* shapes = new asm_shape[nFaces];
	for(int i = 0; i < nFaces; i++)
	{
		InitShapeFromDetBox(shapes[i], detshapes[i], fit_asm.GetMappingDetShape(), fit_asm.GetMeanFaceWidth());
	}

	shape_to_Mat(shapes, nFaces, *((Mat*)faces));
	free_shape_memeory(&detshapes);	
	delete []shapes;
	
	ENDT("CascadeDetector detect");

	return true;
}

JNIEXPORT void JNICALL Java_org_asmlibrary_fit_ASMFit_nativeInitShape(JNIEnv * jenv, jclass, jlong faces)
{
	Mat faces1 = *((Mat*)faces);
	int nFaces = faces1.rows;
	asm_shape* detshapes = new asm_shape[nFaces];
	asm_shape* shapes = new asm_shape[nFaces];

	Mat_to_shape(detshapes, nFaces, faces1);

	for(int i = 0; i < nFaces; i++)
	{
		InitShapeFromDetBox(shapes[i], detshapes[i], fit_asm.GetMappingDetShape(), fit_asm.GetMeanFaceWidth());
	}

	shape_to_Mat(shapes, nFaces, *((Mat*)faces));

	delete []detshapes;
	delete []shapes;
}


JNIEXPORT jboolean JNICALL Java_org_asmlibrary_fit_ASMFit_nativeDetectOne
(JNIEnv * jenv, jclass, jlong imageGray, jlong faces)
{
	IplImage image = *(Mat*)imageGray;
	asm_shape shape, detshape;
	
	BEGINT();

	bool flag = detect_one_face(detshape, &image);

	if(flag == false)	{
		ENDT("CascadeDetector CANNOT detect any face");
		return false;
	}

	InitShapeFromDetBox(shape, detshape, fit_asm.GetMappingDetShape(), fit_asm.GetMeanFaceWidth());

	shape_to_Mat(&shape, 1, *((Mat*)faces));
	
	ENDT("CascadeDetector detects central face");

	return true;
}


JNIEXPORT void JNICALL Java_org_asmlibrary_fit_ASMFit_nativeFitting
(JNIEnv * jenv, jclass, jlong imageGray, jlong shapes0)
{
	IplImage image = *(Mat*)imageGray;
	Mat shapes1 = *(Mat*)shapes0;	
	int nFaces = shapes1.rows;	
	asm_shape* shapes = new asm_shape[nFaces];
	
	BEGINT();

	Mat_to_shape(shapes, nFaces, shapes1);

	fit_asm.Fitting2(shapes, nFaces, &image);

	shape_to_Mat(shapes, nFaces, *((Mat*)shapes0));

	ENDT("nativeFitting");

	//for(int i = 0; i < shapes[0].NPoints(); i++)
	//	LOGD("points: (%f, %f)", shapes[0][i].x, shapes[0][i].y);

	delete []shapes;
}

JNIEXPORT jboolean JNICALL Java_org_asmlibrary_fit_ASMFit_nativeVideoFitting
(JNIEnv * jenv, jclass, jlong imageGray, jlong shapes0, jlong frame)
{
	IplImage image = *(Mat*)imageGray;
	Mat shapes1 = *(Mat*)shapes0;	
	bool flag = false;
	if(shapes1.rows == 1)
	{
		asm_shape shape;
	
		LOGD("nativeVideoFitting %d x %d", image.width, image.height);
		BEGINT();

		Mat_to_shape(&shape, 1, shapes1);

		flag = fit_asm.ASMSeqSearch(shape, &image, frame, true);

		shape_to_Mat(&shape, 1, *((Mat*)shapes0));

		ENDT("nativeVideoFitting");
	}

	return flag;
}

#ifdef __cplusplus
}
#endif

（6）vjfacedetect.h

 

 

#ifndef _VJFACE_DETECT_H_
#define _VJFACE_DETECT_H_

#include "asmlibrary.h"


/**
 Load adaboost cascade file for detect face.
 @param cascade_name Filename the cascade detector located in
 @return false on failure, true otherwise
*/
bool init_detect_cascade(const char* cascade_name = "haarcascade_frontalface_alt2.xml");


/**
 Release the memory of adaboost cascade face detector
*/
void destory_detect_cascade();

/**
 Detect only one face from image, and this human face is located as close as to the center of image
 @param shape return face detected box which stores the Top-Left and Bottom-Right points, so its \a NPoints() = 2 here
 @param image the image resource
 @return false on no face exists in image, true otherwise
*/
bool detect_one_face(asm_shape& shape, const IplImage* image);


/**
 Detect all human face from image.
 @param shapes return face detected box which stores the Top-Left and Bottom-Right points, so its \a NPoints() = 2 here
 @param n_shapes the numbers of faces to return
 @param image the image resource
 @return false on no face exists in image, true otherwise
*/
bool detect_all_faces(asm_shape** shapes, int& n_shapes, const IplImage* image);

/**
 Release the shape resource allocated by detect_all_faces().
 @param shapes the ptr of asm_shape [] 
*/
void free_shape_memeory(asm_shape** shapes);



#endif  // _VJFACE_DETECT_H_

 

 

未完待续，我发现这样去看代码，有点看不懂