diff --git a/.travis.yml b/.travis.yml
index 473ffdb..226da6f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,84 +1,10 @@
-language: php
+sudo: required
 
-compiler:
-  - gcc
-  - clang
-
-os:
-  - linux
-#  - osx
-
-php:
-  - 7.0
-  - 7.1
-
-notifications:
-  email: hihozhou@gmail.com
+services:
+  - docker
 
 before_install:
-  - sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
-  - sudo apt-get -qq update
-  - sudo apt-get install gcc-4.8 -y -qq
-  - sudo apt-get install g++-4.8 -y -qq
-
-install:
-  # OpenCV dependencies - Details available at: http://docs.opencv.org/trunk/doc/tutorials/introduction/linux_install/linux_install.html
-  - sudo apt-get install -y build-essential
-  # Install Cmake
-  - wget https://cmake.org/files/v3.8/cmake-3.8.2.tar.gz
-  - tar -zxf cmake-3.8.2.tar.gz
-  - cd cmake-3.8.2
-  - ./configure
-  - make
-  - sudo make install
-  - cd ..
-
-  - sudo apt-get install -y git libgtk2.0-dev pkg-config libavcodec-dev libavformat-dev libswscale-dev -qq
-  - sudo apt-get install -y python-dev python-numpy libtbb2 libtbb-dev libjpeg-dev libpng-dev libtiff-dev libjasper-dev libdc1394-22-dev -qq
-
-  # Download OpenCV-contrib v3.3.0-rc
-  #- git clone https://github.com/opencv/opencv_contrib.git
-  #- cd opencv_contrib
-  #- git checkout 3.3.0-rc
-  #- cd ..
-
-  # Download OpenCV v3.3.0-rc
-  - git clone https://github.com/opencv/opencv.git
-  - cd opencv
-  - git checkout 3.3.0-rc
-
-  # Create a new 'build' folder.
-  - mkdir build
-  - cd build
-
-  # Set build instructions for Ubuntu distro.
-  #- cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D WITH_TBB=ON -D BUILD_NEW_PYTHON_SUPPORT=ON -D WITH_V4L=ON -D INSTALL_C_EXAMPLES=ON -D INSTALL_PYTHON_EXAMPLES=ON -D BUILD_EXAMPLES=ON -D WITH_QT=ON -D WITH_OPENGL=ON -D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib/modules ..
-  - cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D WITH_TBB=ON -D BUILD_NEW_PYTHON_SUPPORT=ON -D WITH_V4L=ON -D INSTALL_C_EXAMPLES=ON -D INSTALL_PYTHON_EXAMPLES=ON -D BUILD_EXAMPLES=ON -D WITH_QT=ON -D WITH_OPENGL=ON ..
-  # Run 'make' with four threads.
-  - make -j6
-
-  # Install to OS.
-  - sudo make install
-  # Add configuration to OpenCV to tell it where the library files are located on the file system (/usr/local/lib)
-  - sudo sh -c 'echo "/usr/local/lib" > /etc/ld.so.conf.d/opencv.conf'
-
-  - sudo ldconfig
-  - echo "OpenCV installed."
-
-  # We need to return to the repo "root" folder, so we can then 'cd' into the C++ project folder.
-  - cd ../../
-
-#addons:
-#  apt:
-#    sources:
-#      - george-edison55-precise-backports
-#    packages:
-#      - cmake-data
-#      - cmake
-
-#Compile
-before_script:
-  - ./travis/compile.sh
+  - docker pull ubuntu:18.04
 
 script:
-    - exit 0
\ No newline at end of file
+  - docker build .
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..da101c2
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,9 @@
+FROM ubuntu:18.04
+
+RUN apt update && export DEBIAN_FRONTEND=noninteractive && apt install -y wget pkg-config cmake git php-cli php-dev
+
+RUN wget https://raw.githubusercontent.com/php-opencv/php-opencv-packages/master/opencv_3.4_amd64.deb && dpkg -i opencv_3.4_amd64.deb && rm opencv_3.4_amd64.deb
+
+RUN git clone https://github.com/php-opencv/php-opencv.git
+
+RUN cd php-opencv && phpize && ./configure --with-php-config=/usr/bin/php-config && make && make install
\ No newline at end of file
diff --git a/README.md b/README.md
index a526920..d502745 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@
 
 ## Requirements
 
-- OpenCV 3.3.0+
+- OpenCV 3.4+
 - PHP7.0+
 
 
@@ -115,6 +115,8 @@ result:
 
 ![ellipse](tests/ellipse.png)
 
+### Other examples
+- [phpopencv/tutorial-demo](https://github.com/phpopencv/tutorial-demo)
 
 
 ## Features
@@ -137,8 +139,10 @@ result:
 - [ ] 17.ts
 - [x] 18.video
 - [ ] 19.Videostab
+- [X] 20.dnn
 
-
+## Auto complete
+- [hihozhou/php-opencv-ide-helper](https://github.com/hihozhou/php-opencv-ide-helper)
 
 ## Contributors
 
diff --git a/config.m4 b/config.m4
index bd390b6..436419d 100644
--- a/config.m4
+++ b/config.m4
@@ -49,7 +49,9 @@ if test "$PHP_OPENCV" != "no"; then
     source/opencv2/opencv_videoio.cc \
     source/opencv2/opencv_face.cc \
     source/opencv2/face/opencv_facerec.cc \
+    source/opencv2/face/opencv_facemarkLBF.cc \
     source/opencv2/core/opencv_cvdef.cc \
+    source/opencv2/dnn/opencv_dnn.cc \
     source/opencv2/opencv_ml.cc"
 
 
@@ -88,4 +90,4 @@ if test "$PHP_OPENCV" != "no"; then
     fi
 
 
-fi
\ No newline at end of file
+fi
diff --git a/opencv.cc b/opencv.cc
index 7f22eb9..990d392 100644
--- a/opencv.cc
+++ b/opencv.cc
@@ -43,6 +43,7 @@ extern "C" {
 #include "source/opencv2/core/opencv_utility.h"
 #include "source/opencv2/opencv_ml.h"
 #include "source/opencv2/core/opencv_cvdef.h"
+#include "source/opencv2/dnn/opencv_dnn.h"
 
 /* If you declare any globals in php_opencv.h uncomment this:
 ZEND_DECLARE_MODULE_GLOBALS(opencv)
@@ -124,6 +125,7 @@ PHP_MINIT_FUNCTION(opencv)
 	opencv_objdetect_init(module_number);
 	opencv_videoio_init(module_number);
     opencv_face_init(module_number);
+    opencv_dnn_init(module_number);
 	opencv_ml_init(module_number);
     opencv_cvdef_init(module_number);
 
@@ -244,6 +246,11 @@ const zend_function_entry opencv_functions[] = {
     ZEND_NS_NAMED_FE(OPENCV_NS, findContoursWithoutHierarchy, ZEND_FN(opencv_find_contours_without_hierarchy), opencv_find_contours_without_hierarchy_arginfo)
     ZEND_NS_NAMED_FE(OPENCV_NS, drawContours, ZEND_FN(opencv_draw_contours), opencv_draw_contours_arginfo)
     ZEND_NS_NAMED_FE(OPENCV_NS, boundingRect, ZEND_FN(opencv_bounding_rect), NULL)
+    ZEND_NS_NAMED_FE(OPENCV_DNN_NS, blobFromImage, ZEND_FN(opencv_dnn_blob_from_image), NULL)
+    ZEND_NS_NAMED_FE(OPENCV_DNN_NS, readNetFromCaffe, ZEND_FN(opencv_dnn_read_net_from_caffe), NULL)
+    ZEND_NS_NAMED_FE(OPENCV_DNN_NS, readNetFromTorch, ZEND_FN(opencv_dnn_read_net_from_torch), NULL)
+    ZEND_NS_NAMED_FE(OPENCV_DNN_NS, readNetFromTensorflow, ZEND_FN(opencv_dnn_read_net_from_tensorflow), NULL)
+    ZEND_NS_NAMED_FE(OPENCV_NS, imdecode, ZEND_FN(opencv_imdecode), NULL)
 	PHP_FE_END	/* Must be the last line in opencv_functions[] */
 };
 /* }}} */
diff --git a/php_opencv.h b/php_opencv.h
index 86c37aa..5bbb068 100644
--- a/php_opencv.h
+++ b/php_opencv.h
@@ -49,6 +49,7 @@ using namespace cv;
 #define OPENCV_NS "CV"
 #define OPENCV_FACE_NS ZEND_NS_NAME(OPENCV_NS,"Face")
 #define OPENCV_ML_NS ZEND_NS_NAME(OPENCV_NS,"ML")
+#define OPENCV_DNN_NS ZEND_NS_NAME(OPENCV_NS,"DNN")
 
 #define OPENCV_CONNECT(text1,text2) text1##text2
 
diff --git a/source/opencv2/core/opencv_mat.cc b/source/opencv2/core/opencv_mat.cc
index 44d4de6..3d8ff8d 100644
--- a/source/opencv2/core/opencv_mat.cc
+++ b/source/opencv2/core/opencv_mat.cc
@@ -54,6 +54,107 @@ void opencv_mat_update_property_by_c_mat(zval *z,Mat *mat){
     zend_update_property_long(opencv_mat_ce, z, "cols", sizeof("cols")-1, mat->cols);
     zend_update_property_long(opencv_mat_ce, z, "dims", sizeof("dims")-1, mat->dims);
     zend_update_property_long(opencv_mat_ce, z, "type", sizeof("type")-1, mat->type());
+    //zend_update_property_long(opencv_mat_ce, z, "depth", sizeof("depth")-1, mat->depth());
+
+    if (mat->dims > 2) {
+        zval shape_zval;
+        array_init(&shape_zval);
+        for(int i = 0; i < mat->dims; i++)
+        {
+            add_next_index_long(&shape_zval, mat->size.p[i]);
+        }
+        zend_update_property(opencv_mat_ce, z, "shape", sizeof("shape")-1, &shape_zval);
+    }
+}
+
+void opencv_mat_at(Mat *mat, int *idx, long channel, zval *value_zval, long *return_long_val, double *return_double_val) {
+    uchar *return_uchar_val;
+    schar *return_schar_val;
+    ushort *return_ushort_val;
+    short *return_short_val;
+    int *return_int_val;
+    float *return_float_val;
+
+    switch(mat->type()) {
+        //CV_8U
+        case CV_8UC1: return_uchar_val = &mat->at<uchar>(idx); break;
+        case CV_8UC2: return_uchar_val = &mat->at<Vec2b>(idx)[channel]; break;
+        case CV_8UC3: return_uchar_val = &mat->at<Vec3b>(idx)[channel]; break;
+        case CV_8UC4: return_uchar_val = &mat->at<Vec4b>(idx)[channel]; break;
+
+        //CV_8S
+        case CV_8SC1: return_schar_val = &mat->at<schar>(idx); break;
+        case CV_8SC2: return_schar_val = &mat->at<Vec<schar, 2>>(idx)[channel]; break;
+        case CV_8SC3: return_schar_val = &mat->at<Vec<schar, 3>>(idx)[channel]; break;
+        case CV_8SC4: return_schar_val = &mat->at<Vec<schar, 4>>(idx)[channel]; break;
+
+        //CV_16U
+        case CV_16UC1: return_ushort_val = &mat->at<ushort>(idx); break;
+        case CV_16UC2: return_ushort_val = &mat->at<Vec2w>(idx)[channel]; break;
+        case CV_16UC3: return_ushort_val = &mat->at<Vec3w>(idx)[channel]; break;
+        case CV_16UC4: return_ushort_val = &mat->at<Vec4w>(idx)[channel]; break;
+
+        //CV_16S
+        case CV_16SC1: return_short_val = &mat->at<short>(idx); break;
+        case CV_16SC2: return_short_val = &mat->at<Vec2s>(idx)[channel]; break;
+        case CV_16SC3: return_short_val = &mat->at<Vec3s>(idx)[channel]; break;
+        case CV_16SC4: return_short_val = &mat->at<Vec4s>(idx)[channel]; break;
+
+        //CV_32S
+        case CV_32SC1: return_int_val = &mat->at<int>(idx); break;
+        case CV_32SC2: return_int_val = &mat->at<Vec2i>(idx)[channel]; break;
+        case CV_32SC3: return_int_val = &mat->at<Vec3i>(idx)[channel]; break;
+        case CV_32SC4: return_int_val = &mat->at<Vec4i>(idx)[channel]; break;
+
+        //CV_32F
+        case CV_32FC1: return_float_val = &mat->at<float>(idx); break;
+        case CV_32FC2: return_float_val = &mat->at<Vec2f>(idx)[channel]; break;
+        case CV_32FC3: return_float_val = &mat->at<Vec3f>(idx)[channel]; break;
+        case CV_32FC4: return_float_val = &mat->at<Vec4f>(idx)[channel]; break;
+
+        //CV_64F
+        case CV_64FC1: return_double_val = &mat->at<double>(idx); break;
+        case CV_64FC2: return_double_val = &mat->at<Vec2d>(idx)[channel]; break;
+        case CV_64FC3: return_double_val = &mat->at<Vec3d>(idx)[channel]; break;
+        case CV_64FC4: return_double_val = &mat->at<Vec4d>(idx)[channel]; break;
+
+        default: opencv_throw_exception("Wrong Mat type"); break;
+    }
+
+    //get px value
+    switch(mat->depth()){
+        case CV_8U: *return_long_val = *return_uchar_val; break;
+        case CV_8S: *return_long_val = *return_schar_val; break;
+        case CV_16U: *return_long_val = *return_ushort_val; break;
+        case CV_16S: *return_long_val = *return_short_val; break;
+        case CV_32S: *return_long_val = *return_int_val; break;
+        case CV_32F: *return_double_val = *return_float_val; break;
+        case CV_64F: break;
+
+        default: opencv_throw_exception("Wrong Mat type"); break;
+    }
+
+    //set px value
+    if (value_zval != NULL) {
+        switch(mat->depth()){
+            case CV_32F:
+            case CV_64F: convert_to_double(value_zval); break;
+            default: convert_to_long(value_zval); break;
+        }
+
+        zend_long value = Z_LVAL_P(value_zval);
+        switch(mat->depth()){
+            case CV_8U: *return_uchar_val = saturate_cast<uchar>(Z_LVAL_P(value_zval)); break;
+            case CV_8S: *return_schar_val = saturate_cast<schar>(Z_LVAL_P(value_zval)); break;
+            case CV_16U: *return_ushort_val = saturate_cast<ushort>(Z_LVAL_P(value_zval)); break;
+            case CV_16S: *return_short_val = saturate_cast<short>(Z_LVAL_P(value_zval)); break;
+            case CV_32S: *return_int_val = saturate_cast<int>(Z_LVAL_P(value_zval)); break;
+            case CV_32F: *return_float_val = saturate_cast<float>(Z_DVAL_P(value_zval)); break;
+            case CV_64F: *return_double_val = saturate_cast<double>(Z_DVAL_P(value_zval)); break;
+
+            default: opencv_throw_exception("Wrong Mat type"); break;
+        }
+    }
 }
 
 /**
@@ -119,6 +220,12 @@ PHP_METHOD(opencv_mat, channels)
     RETURN_LONG(obj->mat->channels());
 }
 
+PHP_METHOD(opencv_mat, total)
+{
+    opencv_mat_object *obj = Z_PHP_MAT_OBJ_P(getThis());
+    RETURN_LONG(obj->mat->total());
+}
+
 PHP_METHOD(opencv_mat, empty)
 {
     opencv_mat_object *obj = Z_PHP_MAT_OBJ_P(getThis());
@@ -363,7 +470,6 @@ PHP_METHOD(opencv_mat, copy_to)
 }
 
 /**
- * //todo int,fload,double
  * CV\Mat->at
  * @param execute_data
  * @param return_value
@@ -376,78 +482,89 @@ PHP_METHOD(opencv_mat, at)
     if (zend_parse_parameters(ZEND_NUM_ARGS(), "lll|z", &row, &col, &channel, &value_zval) == FAILURE) {
         RETURN_NULL();
     }
+
     opencv_mat_object *this_object = Z_PHP_MAT_OBJ_P(getThis());
-    if(value_zval == NULL){
-        //get px value
-        switch (this_object->mat->channels()){
-            case 1:
-                this_object->mat->at<uchar>((int)row,(int)col);
-                break;
-            case 2:
-            RETURN_LONG(this_object->mat->at<Vec2b>((int)row,(int)col)[channel]);
-                break;
-            case 3:
-            RETURN_LONG(this_object->mat->at<Vec3b>((int)row,(int)col)[channel]);
-                break;
-            case 4:
-            RETURN_LONG(this_object->mat->at<Vec4b>((int)row,(int)col)[channel]);
-                break;
-            default:
-                opencv_throw_exception("Get Mat px only channel in 1,2,3,4.");
-                break;
-        }
+    zval *idx_zval;
+    int *idx;
+    long return_long_val;
+    double return_double_val;
+
+    idx = new int(2);
+    idx[0] = row;
+    idx[1] = col;
+
+    opencv_mat_at(this_object->mat, idx, channel, value_zval, &return_long_val, &return_double_val);
+
+    switch (this_object->mat->depth()){
+        case CV_32F:
+        case CV_64F:
+            RETURN_DOUBLE(return_double_val);
+        default:
+            RETURN_LONG(return_long_val);
+    }
+}
+
+/**
+ * CV\Mat->atIdx
+ * @param execute_data
+ * @param return_value
+ */
+PHP_METHOD(opencv_mat, atIdx) // multi dimensions support
+{
+    long channel = 1;
+    zval *value_zval = NULL;
+    zval *idx_zval;
+    int *idx = nullptr;
+
+    if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "a|lz", &idx_zval, &channel, &value_zval) == FAILURE) {
+        RETURN_NULL();
+    }
 
+    opencv_mat_object *this_object = Z_PHP_MAT_OBJ_P(getThis());
 
-    }else{
-        //set px value
-        convert_to_long(value_zval);
-        zend_long value = Z_LVAL_P(value_zval);
-        switch(this_object->mat->depth()){
-            case CV_8U:
-                switch (this_object->mat->channels()){
-                    case 1:
-                        this_object->mat->at<uchar>((int)row,(int)col) = saturate_cast<uchar>(value);
-                        break;
-                    case 2:
-                        this_object->mat->at<Vec2b>((int)row,(int)col)[channel]=saturate_cast<uchar>(value);
-                        break;
-                    case 3:
-                        this_object->mat->at<Vec3b>((int)row,(int)col)[channel]=saturate_cast<uchar>(value);
-                        break;
-                    case 4:
-                        this_object->mat->at<Vec4b>((int)row,(int)col)[channel]=saturate_cast<uchar>(value);
-                        break;
-                    default:
-                        opencv_throw_exception("Get Mat px only channel in 1,2,3,4.");
-                        break;
-                }
-                break;
-            default:
-                switch (this_object->mat->channels()){
-                    case 1:
-                        this_object->mat->at<uchar>((int)row,(int)col) = saturate_cast<char>(value);
-                        break;
-                    case 2:
-                        this_object->mat->at<Vec2b>((int)row,(int)col)[channel]=saturate_cast<char>(value);
-                        break;
-                    case 3:
-                        this_object->mat->at<Vec3b>((int)row,(int)col)[channel]=saturate_cast<char>(value);
-                        break;
-                    case 4:
-                        this_object->mat->at<Vec4b>((int)row,(int)col)[channel]=saturate_cast<char>(value);
-                        break;
-                    default:
-                        opencv_throw_exception("Get Mat px only channel in 1,2,3,4.");
-                        break;
+    unsigned long idx_count = zend_hash_num_elements(Z_ARRVAL_P(idx_zval));
+
+    if (idx_count == 0) {
+        opencv_throw_exception("array lenght must be >=1");
+        RETURN_NULL();
+    } else if (idx_count != this_object->mat->dims) {
+        opencv_throw_exception("array lenght must be = dims");
+        RETURN_NULL();
+    }
+
+    idx = new int(idx_count);
+    zval *array_val_zval;
+    zend_ulong _h;
+
+    ZEND_HASH_FOREACH_NUM_KEY_VAL(Z_ARRVAL_P(idx_zval),_h,array_val_zval){
+                again:
+                if(Z_TYPE_P(array_val_zval) == IS_LONG){
+                    //idx.push_back((int)zval_get_long(array_val_zval));
+                    idx[_h] = (int)zval_get_long(array_val_zval);
+                }else if(Z_TYPE_P(array_val_zval) == IS_REFERENCE){
+                    array_val_zval = Z_REFVAL_P(array_val_zval);
+                    goto again;
+                } else {
+                    opencv_throw_exception("array value just number.");
+                    RETURN_NULL();
                 }
-                break;
-        }
+    }ZEND_HASH_FOREACH_END();
 
+    long return_long_val;
+    double return_double_val;
+
+    opencv_mat_at(this_object->mat, idx, channel, value_zval, &return_long_val, &return_double_val);
+
+
+    switch (this_object->mat->depth()){
+        case CV_32F:
+        case CV_64F:
+            RETURN_DOUBLE(return_double_val);
+        default:
+            RETURN_LONG(return_long_val);
     }
-    RETURN_NULL();
 }
 
-
 ZEND_BEGIN_ARG_INFO_EX(opencv_mat_convert_to_arginfo, 0, 0, 4)
                 ZEND_ARG_INFO(1, dst)
                 ZEND_ARG_INFO(0, rtype)
@@ -656,6 +773,7 @@ const zend_function_entry opencv_mat_methods[] = {
         PHP_ME(opencv_mat, row, NULL, ZEND_ACC_PUBLIC)
         PHP_ME(opencv_mat, col, NULL, ZEND_ACC_PUBLIC)
         PHP_ME(opencv_mat, at, NULL, ZEND_ACC_PUBLIC)
+        PHP_ME(opencv_mat, atIdx, NULL, ZEND_ACC_PUBLIC)
         PHP_MALIAS(opencv_mat, getImageROI ,get_image_roi, NULL, ZEND_ACC_PUBLIC)
         PHP_MALIAS(opencv_mat, copyTo ,copy_to, opencv_mat_copy_to_arginfo, ZEND_ACC_PUBLIC)
         PHP_MALIAS(opencv_mat, convertTo ,convert_to, opencv_mat_convert_to_arginfo, ZEND_ACC_PUBLIC)
diff --git a/source/opencv2/dnn/opencv_dnn.cc b/source/opencv2/dnn/opencv_dnn.cc
new file mode 100644
index 0000000..da77007
--- /dev/null
+++ b/source/opencv2/dnn/opencv_dnn.cc
@@ -0,0 +1,233 @@
+/*
+ +----------------------------------------------------------------------+
+ | PHP-OpenCV                                                           |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 2.0 of the Apache license,    |
+ | that is bundled with this package in the file LICENSE, and is        |
+ | available through the world-wide-web at the following url:           |
+ | http://www.apache.org/licenses/LICENSE-2.0.html                      |
+ | If you did not receive a copy of the Apache2.0 license and are unable|
+ | to obtain it through the world-wide-web, please send a note to       |
+ | hihozhou@gmail.com so we can mail you a copy immediately.            |
+ +----------------------------------------------------------------------+
+ | Author: HaiHao Zhou  <hihozhou@gmail.com>                            |
+ +----------------------------------------------------------------------+
+ */
+#include "../../../php_opencv.h"
+#include "opencv_dnn.h"
+
+#ifdef HAVE_OPENCV_DNN
+
+#include "../core/opencv_type.h"
+#include "../core/opencv_mat.h"
+#include "../../../opencv_exception.h"
+
+using namespace dnn;
+using namespace std;
+
+#define Z_PHP_DNN_NET_OBJ_P(zv)  get_dnn_net_obj(Z_OBJ_P(zv))
+
+typedef struct _opencv_dnn_net_object{
+    zend_object std;
+    Net DNNNet;
+}opencv_dnn_net_object;
+
+
+/**
+ * @param obj
+ * @return
+ */
+static inline opencv_dnn_net_object* get_dnn_net_obj(zend_object *obj) {
+    return (opencv_dnn_net_object*)((char*)(obj) - XtOffsetOf(opencv_dnn_net_object, std));
+}
+
+zend_object_handlers opencv_dnn_net_object_handlers;
+
+zend_class_entry *opencv_dnn_net_ce;
+
+zend_class_entry *opencv_base_dnn_net_ce;
+
+PHP_FUNCTION(opencv_dnn_blob_from_image)
+{
+    zval *image_zval, *size_zval, *mean_zval;
+    double scalefactor = 1.;
+    bool swapRB = true, crop = true;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OdOO|bb",
+        &image_zval, opencv_mat_ce,
+        &scalefactor,
+        &size_zval, opencv_size_ce,
+        &mean_zval, opencv_scalar_ce,
+        &swapRB,
+        &crop
+    ) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    opencv_mat_object *image_object = Z_PHP_MAT_OBJ_P(image_zval);
+    opencv_size_object *size_object = Z_PHP_SIZE_OBJ_P(size_zval);
+    opencv_scalar_object *mean_object = Z_PHP_SCALAR_OBJ_P(mean_zval);
+
+    Mat im = blobFromImage(*image_object->mat, scalefactor, *size_object->size, *mean_object->scalar, swapRB, crop);
+
+    zval instance;
+    object_init_ex(&instance, opencv_mat_ce);
+    opencv_mat_object *new_obj = Z_PHP_MAT_OBJ_P(&instance);
+    new_obj->mat=new Mat(im);
+    opencv_mat_update_property_by_c_mat(&instance, new_obj->mat);
+    RETURN_ZVAL(&instance,0,0); //return php Mat object
+}
+
+PHP_FUNCTION(opencv_dnn_read_net_from_torch)
+{
+    char *filename;
+    size_t filename_len;
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &filename, &filename_len) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    zval instance;
+    object_init_ex(&instance, opencv_dnn_net_ce);
+    opencv_dnn_net_object *obj = Z_PHP_DNN_NET_OBJ_P(&instance);
+    obj->DNNNet = readNetFromTorch(filename, true);
+
+    RETURN_ZVAL(&instance,0,0);
+}
+
+PHP_FUNCTION(opencv_dnn_read_net_from_caffe)
+{
+    char *prototxt, *caffeModel;
+    size_t prototxt_len, caffeModel_len;
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &prototxt, &prototxt_len, &caffeModel, &caffeModel_len) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    ifstream protoFile;
+    protoFile.open(prototxt);//open the input file
+    stringstream protoStream;
+    protoStream << protoFile.rdbuf();//read the file
+    string protoData = protoStream.str();
+
+    ifstream modelFile;
+    modelFile.open(caffeModel, ios::binary);//open the input file
+    stringstream modelStream;
+    modelStream << modelFile.rdbuf();//read the file
+    string modelData = modelStream.str();
+
+    zval instance;
+    object_init_ex(&instance, opencv_dnn_net_ce);
+    opencv_dnn_net_object *obj = Z_PHP_DNN_NET_OBJ_P(&instance);
+
+    //obj->DNNNet = readNetFromCaffe(protoData.c_str(), protoData.size());
+    obj->DNNNet = readNetFromCaffe(protoData.c_str(), protoData.size(), modelData.c_str(), modelData.size());
+
+    RETURN_ZVAL(&instance,0,0);
+}
+
+PHP_FUNCTION(opencv_dnn_read_net_from_tensorflow)
+{
+    char *model, *config;
+    size_t model_len, config_len;
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &model, &model_len, &config, &config_len) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    ifstream modelFile;
+    modelFile.open(model);//open the input file
+    stringstream modelStream;
+    modelStream << modelFile.rdbuf();//read the file
+    string modelData = modelStream.str();
+
+    ifstream configFile;
+    configFile.open(config, ios::binary);//open the input file
+    stringstream configStream;
+    configStream << configFile.rdbuf();//read the file
+    string configData = configStream.str();
+
+    zval instance;
+    object_init_ex(&instance, opencv_dnn_net_ce);
+    opencv_dnn_net_object *obj = Z_PHP_DNN_NET_OBJ_P(&instance);
+
+    //obj->DNNNet = readNetFromTensorflow(modelData.c_str(), modelData.size());
+    obj->DNNNet = readNetFromTensorflow(modelData.c_str(), modelData.size(), configData.c_str(), configData.size());
+
+    RETURN_ZVAL(&instance,0,0);
+}
+
+PHP_METHOD(opencv_dnn_net, setInput)
+{
+    zval *image_zval;
+    char *name;
+    size_t name_len;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Os", &image_zval, opencv_mat_ce, &name, &name_len) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    opencv_mat_object *image_object = Z_PHP_MAT_OBJ_P(image_zval);
+
+    opencv_dnn_net_object *obj = Z_PHP_DNN_NET_OBJ_P(getThis());
+    obj->DNNNet.setInput(*(image_object->mat), name);
+
+    RETURN_NULL();
+}
+
+PHP_METHOD(opencv_dnn_net, forward)
+{
+    zval *image_zval;
+    char *name;
+
+    opencv_dnn_net_object *obj = Z_PHP_DNN_NET_OBJ_P(getThis());
+    Mat image = obj->DNNNet.forward();
+
+    zval instance;
+    object_init_ex(&instance, opencv_mat_ce);
+    opencv_mat_object *new_obj = Z_PHP_MAT_OBJ_P(&instance);
+    new_obj->mat=new Mat(image);
+    opencv_mat_update_property_by_c_mat(&instance, new_obj->mat);
+    RETURN_ZVAL(&instance,0,0); //return php Mat object
+}
+
+
+/**
+ * opencv_dnn_net_methods[]
+ */
+const zend_function_entry opencv_dnn_net_methods[] = {
+        PHP_ME(opencv_dnn_net, setInput, NULL, ZEND_ACC_PUBLIC)
+        PHP_ME(opencv_dnn_net, forward, NULL, ZEND_ACC_PUBLIC)
+        PHP_FE_END
+};
+/* }}} */
+
+/**
+ * @param type
+ * @return
+ */
+zend_object* opencv_dnn_net_handler(zend_class_entry *type)
+{
+    size_t size = sizeof(opencv_dnn_net_object);
+    opencv_dnn_net_object *obj = (opencv_dnn_net_object *)ecalloc(1,size);
+    memset(obj, 0, sizeof(opencv_dnn_net_object));
+    zend_object_std_init(&obj->std, type);
+    object_properties_init(&obj->std, type);
+    obj->std.ce = type;
+    obj->std.handlers = &opencv_dnn_net_object_handlers;
+    return &obj->std;
+}
+
+void opencv_dnn_init(int module_number){
+    zend_class_entry ce;
+    INIT_NS_CLASS_ENTRY(ce,OPENCV_DNN_NS, "Net", opencv_dnn_net_methods);
+    opencv_dnn_net_ce = zend_register_internal_class_ex(&ce, opencv_dnn_net_ce);
+
+    opencv_dnn_net_ce->create_object = opencv_dnn_net_handler;
+    memcpy(&opencv_dnn_net_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+}
+
+#else
+
+void opencv_dnn_init(int module_number){
+
+}
+
+#endif
diff --git a/source/opencv2/dnn/opencv_dnn.h b/source/opencv2/dnn/opencv_dnn.h
new file mode 100644
index 0000000..15f60ac
--- /dev/null
+++ b/source/opencv2/dnn/opencv_dnn.h
@@ -0,0 +1,33 @@
+/*
+ +----------------------------------------------------------------------+
+ | PHP-OpenCV                                                           |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 2.0 of the Apache license,    |
+ | that is bundled with this package in the file LICENSE, and is        |
+ | available through the world-wide-web at the following url:           |
+ | http://www.apache.org/licenses/LICENSE-2.0.html                      |
+ | If you did not receive a copy of the Apache2.0 license and are unable|
+ | to obtain it through the world-wide-web, please send a note to       |
+ | hihozhou@gmail.com so we can mail you a copy immediately.            |
+ +----------------------------------------------------------------------+
+ | Author: HaiHao Zhou  <hihozhou@gmail.com>                            |
+ +----------------------------------------------------------------------+
+ */
+
+
+#ifndef PHP_OPENCV_DNN_NET_H
+#define PHP_OPENCV_DNN_NET_H
+
+#include <opencv2/dnn.hpp>
+#include <string>
+#include <fstream>
+#include <streambuf>
+
+
+extern void opencv_dnn_init(int module_number);
+
+#endif
+PHP_FUNCTION(opencv_dnn_blob_from_image);
+PHP_FUNCTION(opencv_dnn_read_net_from_torch);
+PHP_FUNCTION(opencv_dnn_read_net_from_caffe);
+PHP_FUNCTION(opencv_dnn_read_net_from_tensorflow);
\ No newline at end of file
diff --git a/source/opencv2/face/opencv_facemarkLBF.cc b/source/opencv2/face/opencv_facemarkLBF.cc
new file mode 100644
index 0000000..3fc4802
--- /dev/null
+++ b/source/opencv2/face/opencv_facemarkLBF.cc
@@ -0,0 +1,247 @@
+/*
+ +----------------------------------------------------------------------+
+ | PHP-OpenCV                                                           |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 2.0 of the Apache license,    |
+ | that is bundled with this package in the file LICENSE, and is        |
+ | available through the world-wide-web at the following url:           |
+ | http://www.apache.org/licenses/LICENSE-2.0.html                      |
+ | If you did not receive a copy of the Apache2.0 license and are unable|
+ | to obtain it through the world-wide-web, please send a note to       |
+ | hihozhou@gmail.com so we can mail you a copy immediately.            |
+ +----------------------------------------------------------------------+
+ | Author: HaiHao Zhou  <hihozhou@gmail.com>                            |
+ +----------------------------------------------------------------------+
+ */
+#include "../../../php_opencv.h"
+#include "opencv_facemarkLBF.h"
+
+#ifdef HAVE_OPENCV_FACE
+
+#include "../opencv_face.h"
+#include "../core/opencv_type.h"
+#include "../core/opencv_mat.h"
+#include "../../../opencv_exception.h"
+#include <opencv2/face.hpp>
+using namespace cv::face;
+
+#define Z_PHP_FACEMARK_LBF_OBJ_P(zv)  get_facemark_lbf_obj(Z_OBJ_P(zv))
+
+typedef struct _opencv_facemark_lbf_object{
+    zend_object std;
+    Ptr<FacemarkLBF> Facemark;
+}opencv_facemark_lbf_object;
+
+
+/**
+ * @param obj
+ * @return
+ */
+static inline opencv_facemark_lbf_object* get_facemark_lbf_obj(zend_object *obj) {
+    return (opencv_facemark_lbf_object*)((char*)(obj) - XtOffsetOf(opencv_facemark_lbf_object, std));
+}
+
+zend_object_handlers opencv_facemark_lbf_object_handlers;
+
+zend_class_entry *opencv_facemark_lbf_ce;
+
+zend_class_entry *opencv_base_facemark_ce;
+
+PHP_METHOD(opencv_facemark_lbf, create)
+{
+    zval instance;
+    object_init_ex(&instance, opencv_facemark_lbf_ce);
+    opencv_facemark_lbf_object *obj = Z_PHP_FACEMARK_LBF_OBJ_P(&instance);
+    obj->Facemark = FacemarkLBF::create();
+    RETURN_ZVAL(&instance,0,0);
+}
+
+PHP_METHOD(opencv_facemark_lbf, loadModel)
+{
+    char *filename;
+    size_t filename_len;
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &filename, &filename_len) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    opencv_facemark_lbf_object *obj = Z_PHP_FACEMARK_LBF_OBJ_P(getThis());
+    obj->Facemark->loadModel(filename);
+    RETURN_NULL();
+}
+
+PHP_METHOD(opencv_facemark_lbf, getFaces)
+{
+    zval *image_zval, *objects_zval;
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Oz", &image_zval, opencv_mat_ce, &objects_zval) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    std::vector<Rect> objects;
+    opencv_mat_object *image_object = Z_PHP_MAT_OBJ_P(image_zval);
+    opencv_facemark_lbf_object *obj = Z_PHP_FACEMARK_LBF_OBJ_P(getThis());
+    obj->Facemark->getFaces(*(image_object->mat), objects);
+
+    zval *objects_real_zval = Z_REFVAL_P(objects_zval);
+
+    zval_dtor(objects_real_zval);//if real_zval value not eq null ,free real_zval to avoid memory leaks detected
+
+    array_init(objects_real_zval);
+    for(unsigned long i=0; i < objects.size(); i++){
+        zval OPENCV_CONNECT(zval,i);
+        Rect OPENCV_CONNECT(rect,i);
+        opencv_rect_object *OPENCV_CONNECT(rect_object,i);
+        object_init_ex(&OPENCV_CONNECT(zval,i), opencv_rect_ce);
+        OPENCV_CONNECT(rect_object,i) = Z_PHP_RECT_OBJ_P(&OPENCV_CONNECT(zval,i));
+        OPENCV_CONNECT(rect,i) = objects.at(i);
+        OPENCV_CONNECT(rect_object,i)->rect = new Rect(OPENCV_CONNECT(rect,i));
+        opencv_rect_update_property_by_c_rect(&OPENCV_CONNECT(zval,i), OPENCV_CONNECT(rect_object,i)->rect);
+
+        add_next_index_zval(objects_real_zval,&OPENCV_CONNECT(zval,i));
+    }
+
+    RETURN_NULL();
+}
+
+ZEND_BEGIN_ARG_INFO_EX(opencv_facemark_lbf_fit_arginfo, 0, 0, 3)
+                ZEND_ARG_INFO(0, image)
+                ZEND_ARG_INFO(0, faces)
+                ZEND_ARG_INFO(1, landmarks)
+ZEND_END_ARG_INFO()
+
+PHP_METHOD(opencv_facemark_lbf, fit)
+{
+    zval *image_zval, *faces_array, *landmarks_zval, *array_val_zval;
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Oaz", &image_zval, opencv_mat_ce, &faces_array, &landmarks_zval) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    std::vector<Rect> faces;
+
+    zend_ulong _h;
+    ZEND_HASH_FOREACH_NUM_KEY_VAL(Z_ARRVAL_P(faces_array),_h,array_val_zval){
+        //check array_val_zval is Mat object
+        if(Z_TYPE_P(array_val_zval) == IS_OBJECT && Z_OBJCE_P(array_val_zval)==opencv_rect_ce){
+            opencv_rect_object *rect_object = Z_PHP_RECT_OBJ_P(array_val_zval);
+            faces.push_back(*rect_object->rect);
+        }else {
+            opencv_throw_exception("array value just Rect object.");
+            RETURN_NULL();
+        }
+    }ZEND_HASH_FOREACH_END();
+
+    std::vector<std::vector<Point2f> > landmarks;
+
+    opencv_mat_object *image_object = Z_PHP_MAT_OBJ_P(image_zval);
+    opencv_facemark_lbf_object *obj = Z_PHP_FACEMARK_LBF_OBJ_P(getThis());
+    obj->Facemark->fit(*(image_object->mat), faces, landmarks);
+
+    zval *landmarks_real_zval = Z_REFVAL_P(landmarks_zval);
+
+    zval_dtor(landmarks_real_zval);//if real_zval value not eq null ,free real_zval to avoid memory leaks detected
+
+    array_init(landmarks_real_zval);
+
+    int point_count = 0;
+    for(unsigned long i=0; i < landmarks.size(); i++){
+        zval OPENCV_CONNECT(zval_arr,i);
+        array_init(&OPENCV_CONNECT(zval_arr,i));
+        for(unsigned long j=0; j < landmarks.at(i).size(); j++){
+            zval OPENCV_CONNECT(zval_point,point_count);
+            object_init_ex(&OPENCV_CONNECT(zval_point,point_count), opencv_point_ce);
+            //printf("* Debug %i %i\n", i, j, landmarks.at(i).at(j));
+            Z_PHP_POINT_OBJ_P(&OPENCV_CONNECT(zval_point,point_count))->point=new Point(landmarks.at(i).at(j));
+            opencv_point_update_property_by_c_point(&OPENCV_CONNECT(zval_point,point_count), Z_PHP_POINT_OBJ_P(&OPENCV_CONNECT(zval_point,point_count))->point);
+            add_next_index_zval(&OPENCV_CONNECT(zval_arr,i),&OPENCV_CONNECT(zval_point,point_count));
+            point_count++;
+        }
+        add_next_index_zval(landmarks_real_zval,&OPENCV_CONNECT(zval_arr,i));
+    }
+
+    RETURN_NULL();//RETURN_ZVAL(landmarks_real_zval,0,0);
+}
+
+/**
+ * opencv_facemark_lbf_methods[]
+ */
+const zend_function_entry opencv_facemark_lbf_methods[] = {
+        PHP_ME(opencv_facemark_lbf, create, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
+        PHP_ME(opencv_facemark_lbf, loadModel, NULL, ZEND_ACC_PUBLIC)
+        PHP_ME(opencv_facemark_lbf, getFaces, NULL, ZEND_ACC_PUBLIC)
+        PHP_ME(opencv_facemark_lbf, fit, opencv_facemark_lbf_fit_arginfo, ZEND_ACC_PUBLIC)
+        PHP_FE_END
+};
+/* }}} */
+
+/**
+ * @param type
+ * @return
+ */
+zend_object* opencv_facemark_lbf_handler(zend_class_entry *type)
+{
+    size_t size = sizeof(opencv_facemark_lbf_object);
+    opencv_facemark_lbf_object *obj = (opencv_facemark_lbf_object *)ecalloc(1,size);
+    memset(obj, 0, sizeof(opencv_facemark_lbf_object));
+    zend_object_std_init(&obj->std, type);
+    object_properties_init(&obj->std, type);
+    obj->std.ce = type;
+    obj->std.handlers = &opencv_facemark_lbf_object_handlers;
+    return &obj->std;
+}
+
+
+void opencv_facemark_lbf_free_obj(zend_object *object)
+{
+    opencv_facemark_lbf_object *obj;
+    obj = get_facemark_lbf_obj(object);
+    delete obj->Facemark;
+    zend_object_std_dtor(object);
+}
+
+void opencv_facemark_lbf_init(int module_number){
+    zend_class_entry ce;
+    INIT_NS_CLASS_ENTRY(ce,OPENCV_FACE_NS, "FacemarkLBF", opencv_facemark_lbf_methods);
+    opencv_facemark_lbf_ce = zend_register_internal_class_ex(&ce, opencv_facemark_lbf_ce);
+
+    opencv_facemark_lbf_ce->create_object = opencv_facemark_lbf_handler;
+    memcpy(&opencv_facemark_lbf_object_handlers,
+           zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+    opencv_facemark_lbf_object_handlers.clone_obj = NULL;
+    opencv_facemark_lbf_object_handlers.free_obj = opencv_facemark_lbf_free_obj;
+}
+
+
+
+
+
+/**
+ * -----------------------------------【CV\BaseFaceRecognizer】--------------------------------------
+ *
+ * -------------------------------------------------------------------------------------
+ */
+
+/**
+ * opencv_facemark_lbf_methods[]
+ */
+const zend_function_entry opencv_base_facemark_methods[] = {
+        PHP_FE_END
+};
+/* }}} */
+
+void opencv_base_facemark_init(int module_number){
+    zend_class_entry ce;
+    INIT_NS_CLASS_ENTRY(ce,OPENCV_FACE_NS, "BaseFacemarkLBF", opencv_base_facemark_methods);
+    opencv_base_facemark_ce = zend_register_internal_class_ex(&ce, opencv_facemark_lbf_ce);
+}
+
+
+#else
+
+void opencv_facemark_lbf_init(int module_number){
+
+}
+
+void opencv_base_facemark_init(int module_number){
+
+}
+
+#endif
diff --git a/source/opencv2/face/opencv_facemarkLBF.h b/source/opencv2/face/opencv_facemarkLBF.h
new file mode 100644
index 0000000..6ef7b36
--- /dev/null
+++ b/source/opencv2/face/opencv_facemarkLBF.h
@@ -0,0 +1,39 @@
+/*
+ +----------------------------------------------------------------------+
+ | PHP-OpenCV                                                           |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 2.0 of the Apache license,    |
+ | that is bundled with this package in the file LICENSE, and is        |
+ | available through the world-wide-web at the following url:           |
+ | http://www.apache.org/licenses/LICENSE-2.0.html                      |
+ | If you did not receive a copy of the Apache2.0 license and are unable|
+ | to obtain it through the world-wide-web, please send a note to       |
+ | hihozhou@gmail.com so we can mail you a copy immediately.            |
+ +----------------------------------------------------------------------+
+ | Author: HaiHao Zhou  <hihozhou@gmail.com>                            |
+ +----------------------------------------------------------------------+
+ */
+
+
+#ifndef PHP_OPENCV_FACEMARK_LBF_H
+#define PHP_OPENCV_FACEMARK_LBF_H
+
+
+/**
+ * -----------------------------------【CV\LBPHFaceRecognizer】-------------------------
+ *
+ * -------------------------------------------------------------------------------------
+ */
+extern void opencv_facemark_lbf_init(int module_number);
+
+
+
+/**
+ * -----------------------------------【CV\BaseFaceRecognizer】-------------------------
+ *
+ * -------------------------------------------------------------------------------------
+ */
+extern void opencv_base_facemark_init(int module_number);
+
+
+#endif //PHP_OPENCV_FACEMARK_LBF_H
diff --git a/source/opencv2/face/opencv_facerec.cc b/source/opencv2/face/opencv_facerec.cc
index 93f25a4..f766ef6 100644
--- a/source/opencv2/face/opencv_facerec.cc
+++ b/source/opencv2/face/opencv_facerec.cc
@@ -102,36 +102,41 @@ PHP_METHOD(opencv_lbph_face_recognizer, train)
 
 }
 
-PHP_METHOD(opencv_lbph_face_recognizer, predict)
-{
-    zval *src_zval;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &src_zval, opencv_mat_ce) == FAILURE) {
-        RETURN_NULL();
-    }
-    opencv_lbph_face_recognizer_object *obj = Z_PHP_LBPH_FACE_RECOGNIZER_OBJ_P(getThis());
-    opencv_mat_object *src_object = Z_PHP_MAT_OBJ_P(src_zval);
-    int predict_label = obj->faceRecognizer->predict(*src_object->mat);
-    RETURN_LONG(predict_label);
-}
+ZEND_BEGIN_ARG_INFO_EX(opencv_lbph_face_recognizer_predict_arginfo, 0, 0, 2)
+                ZEND_ARG_INFO(0, src)
+                ZEND_ARG_INFO(1, confidence)
+ZEND_END_ARG_INFO()
 
-PHP_METHOD(opencv_lbph_face_recognizer, predictConfidence)
+PHP_METHOD(opencv_lbph_face_recognizer, predict)
 {
-    zval *src_zval;
-    int label = 0;
+    zval *src_zval, *confidence_zval = NULL;
+    int label;
     double confidence = 0;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &src_zval, opencv_mat_ce) == FAILURE) {
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "O|z", &src_zval, opencv_mat_ce, &confidence_zval) == FAILURE) {
         RETURN_NULL();
     }
+
     opencv_lbph_face_recognizer_object *obj = Z_PHP_LBPH_FACE_RECOGNIZER_OBJ_P(getThis());
     opencv_mat_object *src_object = Z_PHP_MAT_OBJ_P(src_zval);
     obj->faceRecognizer->predict(*src_object->mat, label, confidence);
-    RETURN_DOUBLE(confidence);
+
+    zval *confidence_real_zval;
+
+    if (confidence_zval != NULL) {
+        confidence_real_zval = Z_REFVAL_P(confidence_zval);
+        zval_ptr_dtor(confidence_real_zval);
+        ZVAL_DOUBLE(confidence_real_zval, confidence);
+    }
+
+    RETURN_LONG(label);
 }
 
 PHP_METHOD(opencv_lbph_face_recognizer, read)
 {
     char *filename;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &filename) == FAILURE) {
+    size_t filename_len;
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &filename, &filename_len) == FAILURE) {
         RETURN_NULL();
     }
 
@@ -143,7 +148,8 @@ PHP_METHOD(opencv_lbph_face_recognizer, read)
 PHP_METHOD(opencv_lbph_face_recognizer, write)
 {
     char *filename;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &filename) == FAILURE) {
+    size_t filename_len;
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &filename, &filename_len) == FAILURE) {
         RETURN_NULL();
     }
 
@@ -204,9 +210,7 @@ PHP_METHOD(opencv_lbph_face_recognizer, update)
 const zend_function_entry opencv_lbph_face_recognizer_methods[] = {
         PHP_ME(opencv_lbph_face_recognizer, create, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
         PHP_ME(opencv_lbph_face_recognizer, train, NULL, ZEND_ACC_PUBLIC)
-        PHP_ME(opencv_lbph_face_recognizer, predict, NULL, ZEND_ACC_PUBLIC)
-        // todo
-        PHP_ME(opencv_lbph_face_recognizer, predictConfidence, NULL, ZEND_ACC_PUBLIC)
+        PHP_ME(opencv_lbph_face_recognizer, predict, opencv_lbph_face_recognizer_predict_arginfo, ZEND_ACC_PUBLIC)
         PHP_ME(opencv_lbph_face_recognizer, read, NULL, ZEND_ACC_PUBLIC)
         PHP_ME(opencv_lbph_face_recognizer, write, NULL, ZEND_ACC_PUBLIC)
         PHP_ME(opencv_lbph_face_recognizer, update, NULL, ZEND_ACC_PUBLIC)
diff --git a/source/opencv2/opencv_face.cc b/source/opencv2/opencv_face.cc
index 4dc284d..b163ee0 100644
--- a/source/opencv2/opencv_face.cc
+++ b/source/opencv2/opencv_face.cc
@@ -24,6 +24,7 @@ zend_class_entry *opencv_face_recognizer_ce;
 using namespace face;
 
 #include "face/opencv_facerec.h"
+#include "face/opencv_facemarkLBF.h"
 
 
 /**
@@ -45,6 +46,8 @@ void opencv_face_init(int module_number){
     opencv_face_recognizer_init(module_number);
     opencv_lbph_face_recognizer_init(module_number);
     opencv_base_face_recognizer_init(module_number);
+    opencv_facemark_lbf_init(module_number);
+    opencv_base_facemark_init(module_number);
 }
 
 #else
diff --git a/source/opencv2/opencv_imgcodecs.cc b/source/opencv2/opencv_imgcodecs.cc
index 56bb6cd..718361d 100644
--- a/source/opencv2/opencv_imgcodecs.cc
+++ b/source/opencv2/opencv_imgcodecs.cc
@@ -80,6 +80,40 @@ PHP_FUNCTION(opencv_imwrite){
     RETURN_TRUE;
 }
 
+/**
+ * CV\imdecode
+ * @param execute_data
+ * @param return_value
+ */
+PHP_FUNCTION(opencv_imdecode)
+{
+    long flags;
+    char *buf;
+    long buf_len;
+    flags = IMREAD_COLOR;//flags default value
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &buf,&buf_len, &flags) == FAILURE) {
+        RETURN_NULL();
+    }
+    zval instance;
+    object_init_ex(&instance,opencv_mat_ce);
+    opencv_mat_object *obj = Z_PHP_MAT_OBJ_P(&instance);
+
+    Mat im = imdecode(Mat(1, buf_len, CV_8UC1, buf), (int)flags);
+    if(im.empty() || !im.data){
+        char *error_message = (char*)malloc(strlen("Can not load image") + 1);
+        strcpy(error_message,"Can not load image");
+        opencv_throw_exception(error_message);//throw exception
+        free(error_message);
+    }
+
+    obj->mat = new Mat(im);
+
+    //update php Mat object property
+    opencv_mat_update_property_by_c_mat(&instance, obj->mat);
+
+    RETURN_ZVAL(&instance,0,0); //return php Mat object
+}
 
 void opencv_imgcodecs_init(int module_number)
 {
diff --git a/source/opencv2/opencv_imgcodecs.h b/source/opencv2/opencv_imgcodecs.h
index 50a92f6..60f11f7 100644
--- a/source/opencv2/opencv_imgcodecs.h
+++ b/source/opencv2/opencv_imgcodecs.h
@@ -20,5 +20,6 @@
 extern void opencv_imgcodecs_init(int module_number);
 PHP_FUNCTION(opencv_imread);
 PHP_FUNCTION(opencv_imwrite);
+PHP_FUNCTION(opencv_imdecode);
 
 #endif //OPENCV_OPENCV_IMCODECS_H
diff --git a/tests/dnn.phpt b/tests/dnn.phpt
new file mode 100644
index 0000000..78d5c39
--- /dev/null
+++ b/tests/dnn.phpt
@@ -0,0 +1,28 @@
+--TEST--
+DNN::blobFromImage
+--SKIPIF--
+<?php if (!extension_loaded("opencv")) print "skip"; ?>
+--FILE--
+<?php
+use CV\Scalar;
+use function CV\{imread};
+
+$src = imread("./tests/Obama_gray.png");
+
+$blob = \CV\DNN\blobFromImage($src, 1, new \CV\Size(48, 48), new Scalar(104, 177, 123));
+var_export($blob);
+?>
+--EXPECT--
+CV\Mat::__set_state(array(
+   'type' => 5,
+   'rows' => -1,
+   'cols' => -1,
+   'dims' => 4,
+   'shape' => 
+  array (
+    0 => 1,
+    1 => 3,
+    2 => 48,
+    3 => 48,
+  ),
+))
\ No newline at end of file
diff --git a/tests/faceRecognizer.phpt b/tests/faceRecognizer.phpt
new file mode 100644
index 0000000..a31c248
--- /dev/null
+++ b/tests/faceRecognizer.phpt
@@ -0,0 +1,39 @@
+--TEST--
+LBPHFaceRecognizer
+--SKIPIF--
+<?php if (!extension_loaded("opencv")) print "skip"; ?>
+--FILE--
+<?php
+use CV\Face\LBPHFaceRecognizer;
+use function CV\{imread, cvtColor, equalizeHist};
+use const CV\{COLOR_BGR2GRAY};
+
+$faceRecognizer = LBPHFaceRecognizer::create();
+
+//hihozhou
+$src = imread("./tests/face_recognizer.jpg");
+$gray = cvtColor($src, COLOR_BGR2GRAY);
+equalizeHist($gray, $gray);
+
+$faceRecognizer->train([$gray], [1]);
+
+//Obama
+$src = imread("./tests/Obama.png");
+$gray = cvtColor($src, COLOR_BGR2GRAY);
+equalizeHist($gray, $gray);
+
+//Obama grey
+$faceRecognizer->train([$gray], [41]);
+
+$src = imread("./tests/Obama_gray.png");
+$gray = cvtColor($src, COLOR_BGR2GRAY);
+equalizeHist($gray, $gray);
+
+$faceLabel = $faceRecognizer->predict($gray, $faceConfidence);
+
+$faceLabel = $faceRecognizer->predict($gray);
+
+echo "{$faceLabel}";
+?>
+--EXPECT--
+41
diff --git a/tests/faceRecognizerDecode.phpt b/tests/faceRecognizerDecode.phpt
new file mode 100644
index 0000000..349b4c0
--- /dev/null
+++ b/tests/faceRecognizerDecode.phpt
@@ -0,0 +1,42 @@
+--TEST--
+LBPHFaceRecognizer with Decode
+--SKIPIF--
+<?php if (!extension_loaded("opencv")) print "skip"; ?>
+--FILE--
+<?php
+use CV\Face\LBPHFaceRecognizer;
+use function CV\{imdecode, cvtColor, equalizeHist};
+use const CV\{COLOR_BGR2GRAY};
+
+$faceRecognizer = LBPHFaceRecognizer::create();
+
+//hihozhou
+$str = file_get_contents('./tests/face_recognizer.jpg');
+$src = imdecode($str);
+$gray = cvtColor($src, COLOR_BGR2GRAY);
+equalizeHist($gray, $gray);
+
+$faceRecognizer->train([$gray], [1]);
+
+//Obama
+$str = file_get_contents('./tests/Obama.png');
+$src = imdecode($str);
+$gray = cvtColor($src, COLOR_BGR2GRAY);
+equalizeHist($gray, $gray);
+
+//Obama grey
+$faceRecognizer->train([$gray], [41]);
+
+$str = file_get_contents('./tests/Obama_gray.png');
+$src = imdecode($str);
+$gray = cvtColor($src, COLOR_BGR2GRAY);
+equalizeHist($gray, $gray);
+
+$faceLabel = $faceRecognizer->predict($gray, $faceConfidence);
+
+$faceLabel = $faceRecognizer->predict($gray);
+
+echo "{$faceLabel}";
+?>
+--EXPECT--
+41
diff --git a/tests/facemark.phpt b/tests/facemark.phpt
new file mode 100644
index 0000000..4d17139
--- /dev/null
+++ b/tests/facemark.phpt
@@ -0,0 +1,14 @@
+--TEST--
+FacemarkLBF::create
+--SKIPIF--
+<?php if (!extension_loaded("opencv")) print "skip"; ?>
+--FILE--
+<?php
+use CV\Face\FacemarkLBF;
+
+$facemark = FacemarkLBF::create();
+var_export($facemark);
+?>
+--EXPECT--
+CV\Face\FacemarkLBF::__set_state(array(
+))