php7.4 compatibility. now code can be compiled but tests pass only with export USE_ZEND_ALLOC=1

Changes from Junker

.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
+  - docker build .

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_4.0.1_amd64.deb && dpkg -i opencv_4.0.1_amd64.deb && rm opencv_4.0.1_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 && make test

README.md

@@ -1,152 +1,41 @@
-# PHP-OPENCV - PHP extension for Opencv
+## PHP-OPENCV - PHP extension for Opencv
 
-[![Build Status](https://travis-ci.org/hihozhou/php-opencv.svg?branch=master)](https://travis-ci.org/hihozhou/php-opencv) [![Minimum PHP Version](https://img.shields.io/badge/php-%3E%3D%207.0-8892BF.svg)](https://php.net/)
+[![Build Status](https://travis-ci.org/php-opencv/php-opencv.svg?branch=master)](https://travis-ci.org/php-opencv/php-opencv) [![Minimum PHP Version](https://img.shields.io/badge/php-%3E%3D%207.0-8892BF.svg)](https://php.net/)
 
-
-## Document
-- [PHP OpenCV Doc](http://phpopencv.org/zh-cn/docs/)
-- [PHP OpenCV Api](http://phpopencv.org/zh-cn/api/)
-
-
-## Requirements
-
-- OpenCV 3.3.0+
-- PHP7.0+
-
-
-
-## Installation
-
-```bash
-git clone https://github.com/hihozhou/php-opencv.git
-cd php-opencv
-phpize
-./configure --with-php-config=your php-config path
-make
-make install
+### Easy installation on ubuntu 18.04 LTS from packages (approximately 1 minute):
 ```
-
-## Configure
-
-php.ini
-
+apt update && apt install -y wget && \
+wget https://raw.githubusercontent.com/php-opencv/php-opencv-packages/master/opencv_4.0.1_amd64.deb && dpkg -i opencv_4.0.1_amd64.deb && rm opencv_4.0.1_amd64.deb && \
+wget https://raw.githubusercontent.com/php-opencv/php-opencv-packages/master/php-opencv_7.2-4.0.1_amd64.deb && dpkg -i php-opencv_7.2-4.0.1_amd64.deb && rm php-opencv_7.2-4.0.1_amd64.deb && \
+echo "extension=opencv.so" > /etc/php/7.2/cli/conf.d/opencv.ini
 ```
-extension="your opencv.so path"
-```
-## Example
+[All installation options](https://github.com/php-opencv/php-opencv/wiki/Installation)
 
-### LBPH face recognition
+### Examples
+- [dnn](https://github.com/php-opencv/php-opencv-examples)
+- [core](https://github.com/hihozhou/php-opencv)
 
-```php
-use CV\Face\LBPHFaceRecognizer;
-//use ...;
+### Documentation
+- [PHP OpenCV Doc](https://phpopencv.org/docs/index.html)
+- [PHP OpenCV Api](https://phpopencv.org/api/index.html)
 
-$src = imread('facePic.jpg');
-$gray = cvtColor($src, COLOR_BGR2GRAY);
-equalizeHist($gray, $gray);
-$faceRecognizer = LBPHFaceRecognizer::create();
-/* ... */ //get $images and $labels for train
-$faceRecognizer->train($images, $labels);//How to get $image and $labels, see the document
-/* ... */ //Face detection using CascadeClassifier
-$faceLabel = $faceRecognizer->predict($gray);
-/* ... */ //draw face and name
-```
+### Requirements
+- OpenCV 4.0.0+ (for OpenCV 3.4 use branch 3.4)
+- PHP 7.0 / 7.1 / 7.2
 
-result:
+### Features
+- [core](https://phpopencv.org/docs/mat.html)
+- [imgproc](https://phpopencv.org/docs/gausian_median_blur_bilateral_filter.html)
+- highgui
+- objdetect
+- video
+- ml
+- dnn
 
-![predict](tests/face_recognizer.jpg)
+### Helper for autocomplete and highlighting in your IDE
+- [phpdoc file](https://github.com/php-opencv/php-opencv-examples/blob/master/phpdoc.php)
 
-
-### Image Processing
-
-```php
-//Obama.php
-use function CV\{ imread, imshow, waitkey, namedWindow};
-
-$im = imread('Obama.png');//load image
-namedWindow('This is Obama id card',WINDOW_FULLSCREEN);//create window
-imshow('This is Obama id card',$im);//show image on window
-
-waitkey(0);
-
-```
-
-result:
-
-![Obama](tests/Obama.png)
-
-Load image by gray
-
-```php
-$gray = imread('Obama.png',IMREAD_GRAYSCALE);
-//or
-use  function CV\{ cvtColor};
-$gray = cvtColor($im, COLOR_BGR2GRAY);
-
-```
-
-![Obama_gray](tests/Obama_gray.png)
-
-
-You can draw something.  
-e.g:  
-
-```php
-use CV\{Mat,Scalar, Point, Size};
-use function CV\{ellipse, imwrite, waitKey};
-use const CV\{CV_8UC3};
-
-$windowWidth = 600;
-$thickness = 2;
-$lineType = 8;
-$matScalar = new Scalar(0,0,0);
-$mat = new Mat($windowWidth, $windowWidth, CV_8UC3, $matScalar);
-$point=new Point($windowWidth/2, $windowWidth/2);
-$size=new Size($windowWidth/4, $windowWidth/16);
-$scalar=new Scalar(255, 129, 0);
-for($i = 0; $i <= 360; $i += 45){
-    ellipse($mat,$point,$size,$i,0,360,$scalar,$thickness,$lineType);
-}
-imwrite('./tests/ellipse.png',$mat);
-
-```
-
-result:
-
-![ellipse](tests/ellipse.png)
-
-
-
-## Features
-- [x] 1.[core](http://phpopencv.org/zh-cn/docs/mat.html)
-- [x] 2.[imgproc](http://phpopencv.org/zh-cn/docs/gausian_median_blur_bilateral_filter.html)
-- [x] 3.highgui
-- [ ] 4.contrib
-- [ ] 5.features2d
-- [ ] 6.flann
-- [ ] 7.gpu
-- [ ] 8.calib3d
-- [ ] 9.legacy
-- [x] 10.ml
-- [ ] 11.nonfree
-- [x] 12.objdetect
-- [ ] 13.ocl
-- [ ] 14.photo
-- [ ] 15.stitching
-- [ ] 16.superres
-- [ ] 17.ts
-- [x] 18.video
-- [ ] 19.Videostab
-
-
-
-## Contributors
-
-[@hihozhou](https://github.com/hihozhou)  
-[@MaleicAcid](https://github.com/MaleicAcid)
-    
-## 感谢
-
-感谢[韩天峰](https://github.com/matyhtf)老大的指导，  
-感谢[盘古大叔](https://github.com/pangudashu)的[php7-internal](https://github.com/pangudashu/php7-internal)项目以及平常的指导，  
-感谢`木桶技术升级交流群`和`黑夜路人技术群`、以及`PHP内核交流`的群友对技术的帮助。
+### Contributors
+- [@morozovsk](https://github.com/morozovsk)
+- [@hihozhou](https://github.com/hihozhou)
+- [@MaleicAcid](https://github.com/MaleicAcid)

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"
 
 
@@ -64,19 +66,19 @@ if test "$PHP_OPENCV" != "no"; then
     if test -f "$PKG_CONFIG"; then
           AC_MSG_RESULT(found)
           AC_MSG_CHECKING(for opencv)
-          if $PKG_CONFIG --exists opencv; then
-              if $PKG_CONFIG --atleast-version=3.3.0 opencv; then
-                  opencv_version=`$PKG_CONFIG --modversion opencv`
+          if $PKG_CONFIG --exists opencv4; then
+              if $PKG_CONFIG --atleast-version=4.0.0 opencv4; then
+                  opencv_version=`$PKG_CONFIG --modversion opencv4`
                   AC_MSG_RESULT([found $opencv_version])
                   dnl Add c++ opencv libs and includes by pkg-config
-                  OPENCV_LIBS=`$PKG_CONFIG --libs opencv`
-                  OPENCV_INCS=`$PKG_CONFIG --cflags opencv`
+                  OPENCV_LIBS=`$PKG_CONFIG --libs opencv4`
+                  OPENCV_INCS=`$PKG_CONFIG --cflags opencv4`
                   PHP_EVAL_INCLINE($OPENCV_INCS)
                   PHP_EVAL_LIBLINE($OPENCV_LIBS, OPENCV_SHARED_LIBADD)
                   AC_DEFINE(HAVE_OPENCV, 1, [whether opencv exists in the system])
               else
                   AC_MSG_RESULT(too old)
-                  AC_MSG_ERROR(Ooops ! You need at least opencv 3.3.0)
+                  AC_MSG_ERROR(Ooops ! You need at least opencv 4.0.0)
               fi
           else
               AC_MSG_RESULT(not found)
@@ -88,4 +90,4 @@ if test "$PHP_OPENCV" != "no"; then
     fi
 
 
-fi
+fi

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[] */
 };
 /* }}} */

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
 

source/opencv2/core/hal/opencv_interface.cc

@@ -27,7 +27,8 @@ void opencv_interface_init(int module_number)
     REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_32S", CV_32S, CONST_CS | CONST_PERSISTENT);
     REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_32F", CV_32F, CONST_CS | CONST_PERSISTENT);
     REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_64F", CV_64F, CONST_CS | CONST_PERSISTENT);
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_USRTYPE1", CV_USRTYPE1, CONST_CS | CONST_PERSISTENT);
+    char *cv_usrtype1 = (char*)malloc(strlen("CV_USRTYPE1 support has been dropped in OpenCV 4.0") + 1);
+    REGISTER_NS_STRING_CONSTANT(OPENCV_NS, "CV_USRTYPE1", cv_usrtype1, CONST_CS | CONST_PERSISTENT);
 
     REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_8UC1", CV_8UC1, CONST_CS | CONST_PERSISTENT);
     REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_8UC2", CV_8UC2, CONST_CS | CONST_PERSISTENT);

source/opencv2/core/opencv_mat.cc

@@ -30,9 +30,9 @@ zend_class_entry *opencv_mat_ce;
  */
 zend_object* opencv_mat_create_handler(zend_class_entry *type)
 {
-    int size = sizeof(opencv_mat_object);
+    int size = sizeof(opencv_mat_object)+zend_object_properties_size(type);
     opencv_mat_object *obj = (opencv_mat_object *)ecalloc(1,size);
-    memset(obj, 0, sizeof(opencv_mat_object));
+    memset(obj, 0, size);
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -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;
+        }
+    }
 }
 
 /**
@@ -95,8 +196,12 @@ PHP_METHOD(opencv_mat, print)
     if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &type) == FAILURE) {
         RETURN_NULL();
     }
+
     opencv_mat_object *obj = Z_PHP_MAT_OBJ_P(getThis());
-    std::cout << format(*(obj->mat),int(type)) << std::endl;
+    //long转cv::Formatter::FormatType类型
+    cv::Formatter::FormatType formatType = static_cast<cv::Formatter::FormatType>((int)type);
+    std::cout << format(*(obj->mat), formatType) << std::endl;
+
     RETURN_NULL();
 }
 
@@ -119,6 +224,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 +474,6 @@ PHP_METHOD(opencv_mat, copy_to)
 }
 
 /**
- * //todo int,fload,double
  * CV\Mat->at
  * @param execute_data
  * @param return_value
@@ -376,77 +486,88 @@ 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;
 
-    }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;
-                }
-                break;
-        }
+    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();
 }
 
+/**
+ * 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());
+
+    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();
+                }
+    }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);
+    }
+}
 
 ZEND_BEGIN_ARG_INFO_EX(opencv_mat_convert_to_arginfo, 0, 0, 4)
                 ZEND_ARG_INFO(1, dst)
@@ -554,6 +675,33 @@ PHP_METHOD(opencv_mat, divide)
     RETURN_ZVAL(&instance,0,0); //return php Mat object
 }
 
+/**
+ * Mat->reshape()
+ * @param execute_data
+ * @param return_value
+ */
+PHP_METHOD(opencv_mat, reshape)
+{
+    zval instance;
+    long cn;
+    long rows = 0;
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|l", &cn, &rows) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    object_init_ex(&instance, opencv_mat_ce);
+
+    opencv_mat_object *new_obj = Z_PHP_MAT_OBJ_P(&instance);
+    opencv_mat_object *obj = Z_PHP_MAT_OBJ_P(getThis());
+
+    Mat im = obj->mat->reshape(cn, rows);
+    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
+}
+
 
 
 /**
@@ -656,11 +804,13 @@ 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)
         PHP_ME(opencv_mat, plus, NULL, ZEND_ACC_PUBLIC)
         PHP_ME(opencv_mat, divide, NULL, ZEND_ACC_PUBLIC)
+        PHP_ME(opencv_mat, reshape, NULL, ZEND_ACC_PUBLIC)
         PHP_MALIAS(opencv_mat, setTo ,set_to, NULL, ZEND_ACC_PUBLIC)
         PHP_ME(opencv_mat, add , NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
         PHP_ME(opencv_mat, subtract , NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
@@ -677,7 +827,7 @@ const zend_function_entry opencv_mat_methods[] = {
  * @param value
  * @param cache_slot
  */
-void opencv_mat_write_property(zval *object, zval *member, zval *value, void **cache_slot){
+zval *opencv_mat_write_property(zval *object, zval *member, zval *value, void **cache_slot){
 
     zend_string *str = zval_get_string(member);
     char *memberName=ZSTR_VAL(str);
@@ -690,7 +840,7 @@ void opencv_mat_write_property(zval *object, zval *member, zval *value, void **c
     }
     zend_string_release(str);//free zend_string not memberName(zend_string->val)
     std_object_handlers.write_property(object,member,value,cache_slot);
-
+    return value;
 }
 
 /**
@@ -709,6 +859,7 @@ void opencv_mat_init(void){
 
     zend_declare_property_null(opencv_mat_ce,"type",sizeof("type") - 1,ZEND_ACC_PRIVATE);//private Mat->type
     opencv_mat_object_handlers.free_obj = opencv_mat_free_obj;
+    opencv_mat_object_handlers.offset = XtOffsetOf(opencv_mat_object, std);
 }
 
 

source/opencv2/core/opencv_mat.h

@@ -28,8 +28,8 @@ extern zend_class_entry *opencv_mat_ce;
 #define Z_PHP_MAT_OBJ_P(zv)  get_mat_obj(Z_OBJ_P(zv))
 
 typedef struct _opencv_mat_object{
-    zend_object std;
     Mat *mat;
+    zend_object std;
 }opencv_mat_object;
 
 

source/opencv2/core/opencv_persistence.cc

@@ -24,9 +24,9 @@ zend_class_entry *opencv_file_storage_ce;
 zend_object_handlers opencv_file_storage_object_handlers;
 
 zend_object* opencv_file_storage_create_handler(zend_class_entry *type){
-    size_t size = sizeof(opencv_file_storage_object);
+    size_t size = sizeof(opencv_file_storage_object)+zend_object_properties_size(type);
     opencv_file_storage_object *obj = (opencv_file_storage_object *)ecalloc(1,size);
-    memset(obj, 0, sizeof(opencv_file_storage_object));
+    memset(obj, 0, size);
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -278,5 +278,6 @@ void opencv_file_storage_init(int module_number){
 
 //    zend_declare_property_null(opencv_mat_ce,"type",sizeof("type") - 1,ZEND_ACC_PRIVATE);//private Mat->type
 //    opencv_mat_object_handlers.free_obj = opencv_mat_free_obj;
+    opencv_file_storage_object_handlers.offset = XtOffsetOf(opencv_file_storage_object, std);
     opencv_file_storage_consts_init(module_number);
 }

source/opencv2/core/opencv_persistence.h

@@ -22,8 +22,8 @@
 extern zend_class_entry *opencv_file_storage_ce;
 
 typedef struct _opencv_file_storage_object{
-    zend_object std;
     FileStorage *fileStorage;
+    zend_object std;
 }opencv_file_storage_object;
 
 #define Z_PHP_FILE_STORAGE_OBJ_P(zv)  get_file_storage_obj(Z_OBJ_P(zv))

source/opencv2/core/opencv_type.cc

@@ -83,9 +83,9 @@ const zend_function_entry opencv_point_methods[] = {
 
 zend_object* opencv_point_create_handler(zend_class_entry *type)
 {
-    size_t size = sizeof(opencv_point_object);
+    size_t size = sizeof(opencv_point_object)+zend_object_properties_size(type);
     opencv_point_object *obj = (opencv_point_object *)ecalloc(1,size);
-    memset(obj, 0, sizeof(opencv_point_object));
+    memset(obj, 0, size);
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -108,7 +108,7 @@ void opencv_point_free_obj(zend_object *object)
  * @param value
  * @param cache_slot
  */
-void opencv_point_write_property(zval *object, zval *member, zval *value, void **cache_slot){
+zval *opencv_point_write_property(zval *object, zval *member, zval *value, void **cache_slot){
 
     zend_string *str = zval_get_string(member);
     char *memberName=ZSTR_VAL(str);
@@ -121,7 +121,7 @@ void opencv_point_write_property(zval *object, zval *member, zval *value, void *
     }
     zend_string_release(str);//free zend_string not memberName(zend_string->val)
     std_object_handlers.write_property(object,member,value,cache_slot);
-
+    return value;
 }
 
 /**
@@ -138,6 +138,7 @@ void opencv_point_init(int module_number){
     opencv_point_object_handlers.clone_obj = NULL;
     opencv_point_object_handlers.write_property = opencv_point_write_property;
     opencv_point_object_handlers.free_obj = opencv_point_free_obj;
+    opencv_point_object_handlers.offset = XtOffsetOf(opencv_point_object, std);
 }
 
 
@@ -154,9 +155,9 @@ zend_object_handlers opencv_scalar_object_handlers;
 
 zend_object* opencv_scalar_create_handler(zend_class_entry *type)
 {
-    size_t size = sizeof(opencv_scalar_object);
+    size_t size = sizeof(opencv_scalar_object)+zend_object_properties_size(type);
     opencv_scalar_object *obj = (opencv_scalar_object *)ecalloc(1,size);
-    memset(obj, 0, sizeof(opencv_scalar_object));
+    memset(obj, 0, size);
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -245,6 +246,7 @@ void opencv_scalar_init(int module_number){
            zend_get_std_object_handlers(), sizeof(zend_object_handlers));
     opencv_scalar_object_handlers.clone_obj = NULL;
     opencv_scalar_object_handlers.free_obj = opencv_scalar_free_obj;
+    opencv_scalar_object_handlers.offset = XtOffsetOf(opencv_scalar_object, std);
 }
 
 
@@ -258,9 +260,9 @@ zend_object_handlers opencv_size_object_handlers;
 
 zend_object* opencv_size_create_handler(zend_class_entry *type)
 {
-    size_t size = sizeof(opencv_size_object);
+    size_t size = sizeof(opencv_size_object)+zend_object_properties_size(type);
     opencv_size_object *obj = (opencv_size_object *)ecalloc(1,size);
-    memset(obj, 0, sizeof(opencv_size_object));
+    memset(obj, 0, size);
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -331,7 +333,7 @@ const zend_function_entry opencv_size_methods[] = {
  * @param value
  * @param cache_slot
  */
-void opencv_size_write_property(zval *object, zval *member, zval *value, void **cache_slot){
+zval *opencv_size_write_property(zval *object, zval *member, zval *value, void **cache_slot){
 
     zend_string *str = zval_get_string(member);
     char *memberName=ZSTR_VAL(str);
@@ -344,7 +346,7 @@ void opencv_size_write_property(zval *object, zval *member, zval *value, void **
     }
     zend_string_release(str);//free zend_string not memberName(zend_string->val)
     std_object_handlers.write_property(object,member,value,cache_slot);
-
+    return value;
 }
 
 
@@ -362,6 +364,7 @@ void opencv_size_init(int module_number){
     opencv_size_object_handlers.clone_obj = NULL;
     opencv_size_object_handlers.write_property = opencv_size_write_property;
     opencv_size_object_handlers.free_obj = opencv_size_free_obj;
+    opencv_size_object_handlers.offset = XtOffsetOf(opencv_size_object, std);
 }
 
 
@@ -375,9 +378,9 @@ zend_object_handlers opencv_rect_object_handlers;
 
 zend_object* opencv_rect_create_handler(zend_class_entry *type)
 {
-    size_t size = sizeof(opencv_rect_object);
+    size_t size = sizeof(opencv_rect_object)+zend_object_properties_size(type);
     opencv_rect_object *obj = (opencv_rect_object *)ecalloc(1,size);
-    memset(obj, 0, sizeof(opencv_rect_object));
+    memset(obj, 0, size);
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -522,7 +525,7 @@ const zend_function_entry opencv_rect_methods[] = {
  * @param value
  * @param cache_slot
  */
-void opencv_rect_write_property(zval *object, zval *member, zval *value, void **cache_slot){
+zval *opencv_rect_write_property(zval *object, zval *member, zval *value, void **cache_slot){
 
     zend_string *str = zval_get_string(member);
     char *memberName=ZSTR_VAL(str);
@@ -539,7 +542,7 @@ void opencv_rect_write_property(zval *object, zval *member, zval *value, void **
     }
     zend_string_release(str);//free zend_string not memberName(zend_string->val)
     std_object_handlers.write_property(object,member,value,cache_slot);
-
+    return value;
 }
 
 
@@ -557,6 +560,7 @@ void opencv_rect_init(int module_number){
     opencv_rect_object_handlers.clone_obj = NULL;
     opencv_rect_object_handlers.write_property = opencv_rect_write_property;
     opencv_rect_object_handlers.free_obj = opencv_rect_free_obj;
+    opencv_rect_object_handlers.offset = XtOffsetOf(opencv_rect_object, std);
 }
 
 //-----------------------------------【CV\RotatedRect】--------------------------------
@@ -567,9 +571,9 @@ zend_object_handlers opencv_rotated_rect_object_handlers;
 
 zend_object* opencv_rotated_rect_create_handler(zend_class_entry *type)
 {
-    size_t size = sizeof(opencv_rotated_rect_object);
+    size_t size = sizeof(opencv_rotated_rect_object)+zend_object_properties_size(type);
     opencv_rotated_rect_object *obj = (opencv_rotated_rect_object *)ecalloc(1,size);
-    memset(obj, 0, sizeof(opencv_rotated_rect_object));
+    memset(obj, 0, size);
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -586,7 +590,7 @@ zend_object* opencv_rotated_rect_create_handler(zend_class_entry *type)
  * @param value
  * @param cache_slot
  */
-void opencv_rotated_rect_write_property(zval *object, zval *member, zval *value, void **cache_slot){
+zval *opencv_rotated_rect_write_property(zval *object, zval *member, zval *value, void **cache_slot){
 
     zend_string *str = zval_get_string(member);
     char *memberName = ZSTR_VAL(str);
@@ -614,7 +618,7 @@ void opencv_rotated_rect_write_property(zval *object, zval *member, zval *value,
     }
     zend_string_release(str);//free zend_string not memberName(zend_string->val)
     std_object_handlers.write_property(object,member,value,cache_slot);
-
+    return value;
 }
 
 
@@ -686,11 +690,33 @@ PHP_METHOD(opencv_rotated_rect, __construct)
     opencv_rotated_rect_update_property_by_c_rotated_rect(getThis(), obj->rotatedRect);
 }
 
+
+PHP_METHOD(opencv_rotated_rect, points)
+{
+    opencv_rotated_rect_object *this_object = Z_PHP_ROTATED_RECT_OBJ_P(getThis());
+
+    cv::Point2f pts[4];
+    this_object->rotatedRect->points(pts);
+    zval instance;
+
+    array_init(&instance);
+    for (int i = 0; i < 4; i++) {
+        zval OPENCV_CONNECT(point_zval,i);
+        object_init_ex(&OPENCV_CONNECT(point_zval,i), opencv_point_ce);
+        Z_PHP_POINT_OBJ_P(&OPENCV_CONNECT(point_zval,i))->point = new Point(pts[i]);
+        opencv_point_update_property_by_c_point(&OPENCV_CONNECT(point_zval,i), Z_PHP_POINT_OBJ_P(&OPENCV_CONNECT(point_zval,i))->point);
+        add_next_index_zval(&instance,&OPENCV_CONNECT(point_zval,i));
+    }
+    RETURN_ZVAL(&instance,0,0);
+
+}
+
 /**
  * opencv_rect_methods[]
  */
 const zend_function_entry opencv_rotated_rect_methods[] = {
         PHP_ME(opencv_rotated_rect, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
+        PHP_ME(opencv_rotated_rect, points, NULL, ZEND_ACC_PUBLIC)
         PHP_FE_END
 };
 /* }}} */
@@ -706,6 +732,7 @@ void opencv_rotated_rect_init(int module_number){
     opencv_rotated_rect_object_handlers.clone_obj = NULL;
     opencv_rotated_rect_object_handlers.write_property = opencv_rotated_rect_write_property;
     opencv_rotated_rect_object_handlers.free_obj = opencv_rotated_rect_free_obj;
+    opencv_rotated_rect_object_handlers.offset = XtOffsetOf(opencv_rotated_rect_object, std);
 }
 
 

source/opencv2/core/opencv_type.h

@@ -34,29 +34,29 @@ extern zend_class_entry *opencv_rotated_rect_ce;
 
 
 typedef struct _opencv_point_object{
-    zend_object std;
     Point *point;
+    zend_object std;
 }opencv_point_object;
 
 typedef struct _opencv_scalar_object{
-    zend_object std;
     Scalar *scalar;
+    zend_object std;
 }opencv_scalar_object;
 
 typedef struct _opencv_size_object{
-    zend_object std;
     Size *size;
+    zend_object std;
 }opencv_size_object;
 
 typedef struct _opencv_rect_object{
-    zend_object std;
     Rect *rect;
+    zend_object std;
 }opencv_rect_object;
 
 
 typedef struct _opencv_rotated_rect_object{
-    zend_object std;
     RotatedRect *rotatedRect;
+    zend_object std;
 }opencv_rotated_rect_object;
 
 /**

source/opencv2/dnn/opencv_dnn.cc

@@ -0,0 +1,269 @@
+/*
+ +----------------------------------------------------------------------+
+ | 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{
+    Net DNNNet;
+    zend_object std;
+}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
+}
+
+PHP_METHOD(opencv_dnn_net, getLayerNames)
+{
+    std::vector<String> layers;
+    zval arr_zval;
+
+    opencv_dnn_net_object *obj = Z_PHP_DNN_NET_OBJ_P(getThis());
+    layers = obj->DNNNet.getLayerNames();
+
+    array_init_size(&arr_zval, layers.size());
+
+
+    for(std::vector<int>::size_type i = 0; i != layers.size(); i++) {
+        add_index_string(&arr_zval, i, layers[i].c_str());
+    }
+
+    RETURN_ZVAL(&arr_zval,0,0);
+}
+
+PHP_METHOD(opencv_dnn_net, getLayersCount)
+{
+    char *type;
+    size_t type_len;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &type, &type_len) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    opencv_dnn_net_object *obj = Z_PHP_DNN_NET_OBJ_P(getThis());
+    long count = obj->DNNNet.getLayersCount(type);
+    
+    RETURN_LONG(count);
+}
+
+
+/**
+ * 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_ME(opencv_dnn_net, getLayerNames, NULL, ZEND_ACC_PUBLIC)
+        PHP_ME(opencv_dnn_net, getLayersCount, 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)+zend_object_properties_size(type);
+    opencv_dnn_net_object *obj = (opencv_dnn_net_object *)ecalloc(1,size);
+    memset(obj, 0, size);
+    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));
+    opencv_dnn_net_object_handlers.offset = XtOffsetOf(opencv_dnn_net_object, std);
+}
+
+#else
+
+void opencv_dnn_init(int module_number){
+
+}
+
+#endif

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);

source/opencv2/face/opencv_facemarkLBF.cc

@@ -0,0 +1,248 @@
+/*
+ +----------------------------------------------------------------------+
+ | 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{
+    Ptr<FacemarkLBF> Facemark;
+    zend_object std;
+}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)+zend_object_properties_size(type);
+    opencv_facemark_lbf_object *obj = (opencv_facemark_lbf_object *)ecalloc(1,size);
+    memset(obj, 0, size);
+    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;
+    opencv_facemark_lbf_object_handlers.offset = XtOffsetOf(opencv_facemark_lbf_object, std);
+}
+
+
+
+
+
+/**
+ * -----------------------------------【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

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

source/opencv2/face/opencv_facerec.cc

@@ -27,8 +27,8 @@ using namespace cv::face;
 #define Z_PHP_LBPH_FACE_RECOGNIZER_OBJ_P(zv)  get_lbph_face_recognizer_obj(Z_OBJ_P(zv))
 
 typedef struct _opencv_lbph_face_recognizer_object{
-    zend_object std;
     Ptr<LBPHFaceRecognizer> faceRecognizer;
+    zend_object std;
 }opencv_lbph_face_recognizer_object;
 
 
@@ -102,36 +102,41 @@ PHP_METHOD(opencv_lbph_face_recognizer, train)
 
 }
 
+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, 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);
-}
-
-PHP_METHOD(opencv_lbph_face_recognizer, predictConfidence)
-{
-    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)
@@ -220,9 +224,9 @@ const zend_function_entry opencv_lbph_face_recognizer_methods[] = {
  */
 zend_object* opencv_lbph_face_recognizer_handler(zend_class_entry *type)
 {
-    size_t size = sizeof(opencv_lbph_face_recognizer_object);
+    size_t size = sizeof(opencv_lbph_face_recognizer_object)+zend_object_properties_size(type);
     opencv_lbph_face_recognizer_object *obj = (opencv_lbph_face_recognizer_object *)ecalloc(1,size);
-    memset(obj, 0, sizeof(opencv_lbph_face_recognizer_object));
+    memset(obj, 0, size);
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -235,7 +239,7 @@ void opencv_lbph_face_recognizer_free_obj(zend_object *object)
 {
     opencv_lbph_face_recognizer_object *obj;
     obj = get_lbph_face_recognizer_obj(object);
-    delete obj->faceRecognizer;
+    //delete obj->faceRecognizer; //todo: it's hotfix for: double free or corruption (out) Aborted (core dumped)
     zend_object_std_dtor(object);
 }
 
@@ -249,6 +253,7 @@ void opencv_lbph_face_recognizer_init(int module_number){
            zend_get_std_object_handlers(), sizeof(zend_object_handlers));
     opencv_lbph_face_recognizer_object_handlers.clone_obj = NULL;
     opencv_lbph_face_recognizer_object_handlers.free_obj = opencv_lbph_face_recognizer_free_obj;
+    opencv_lbph_face_recognizer_object_handlers.offset = XtOffsetOf(opencv_lbph_face_recognizer_object, std);
 }
 
 

source/opencv2/opencv_core.cc

@@ -60,19 +60,20 @@ void opencv_norm_types_const_init(int module_number){
     REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "NORM_MINMAX", NORM_MINMAX, CONST_CS | CONST_PERSISTENT);
 }
 
-void opencv_hershey_fonts_const_init(int module_number){
+//todo
+//void opencv_hershey_fonts_const_init(int module_number){
 
     //cv::HersheyFonts
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_SIMPLEX", FONT_HERSHEY_SIMPLEX, CONST_CS | CONST_PERSISTENT);
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_PLAIN", FONT_HERSHEY_PLAIN, CONST_CS | CONST_PERSISTENT);
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_DUPLEX", FONT_HERSHEY_DUPLEX, CONST_CS | CONST_PERSISTENT);
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_COMPLEX", FONT_HERSHEY_COMPLEX, CONST_CS | CONST_PERSISTENT);
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_TRIPLEX", FONT_HERSHEY_TRIPLEX, CONST_CS | CONST_PERSISTENT);
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_COMPLEX_SMALL", FONT_HERSHEY_COMPLEX_SMALL, CONST_CS | CONST_PERSISTENT);
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_SCRIPT_SIMPLEX", FONT_HERSHEY_SCRIPT_SIMPLEX, CONST_CS | CONST_PERSISTENT);
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_SCRIPT_COMPLEX", FONT_HERSHEY_SCRIPT_COMPLEX, CONST_CS | CONST_PERSISTENT);
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_ITALIC", FONT_ITALIC, CONST_CS | CONST_PERSISTENT);
-}
+//    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_SIMPLEX", FONT_HERSHEY_SIMPLEX, CONST_CS | CONST_PERSISTENT);
+//    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_PLAIN", FONT_HERSHEY_PLAIN, CONST_CS | CONST_PERSISTENT);
+//    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_DUPLEX", FONT_HERSHEY_DUPLEX, CONST_CS | CONST_PERSISTENT);
+//    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_COMPLEX", FONT_HERSHEY_COMPLEX, CONST_CS | CONST_PERSISTENT);
+//    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_TRIPLEX", FONT_HERSHEY_TRIPLEX, CONST_CS | CONST_PERSISTENT);
+//    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_COMPLEX_SMALL", FONT_HERSHEY_COMPLEX_SMALL, CONST_CS | CONST_PERSISTENT);
+//    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_SCRIPT_SIMPLEX", FONT_HERSHEY_SCRIPT_SIMPLEX, CONST_CS | CONST_PERSISTENT);
+//    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_HERSHEY_SCRIPT_COMPLEX", FONT_HERSHEY_SCRIPT_COMPLEX, CONST_CS | CONST_PERSISTENT);
+//    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "FONT_ITALIC", FONT_ITALIC, CONST_CS | CONST_PERSISTENT);
+//}
 
 
 void opencv_core_init(int module_number)
@@ -80,7 +81,7 @@ void opencv_core_init(int module_number)
     opencv_formatter_init();
     opencv_formatter_const_init(module_number);
     opencv_norm_types_const_init(module_number);
-    opencv_hershey_fonts_const_init(module_number);
+//    opencv_hershey_fonts_const_init(module_number);
 }
 
 

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

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)
 {

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

source/opencv2/opencv_imgproc.cc

@@ -1295,6 +1295,264 @@ PHP_FUNCTION(opencv_bounding_rect){
     RETURN_ZVAL(&instance,0,0); //return php Rect object
 }
 
+
+/**
+ * CV\getRotationMatrix2D
+ * @param execute_data
+ * @param return_value
+ */
+PHP_FUNCTION (opencv_get_rotation_matrix2D) {
+    zval *center_zval;
+    double angle, scale;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Odd", &center_zval, opencv_point_ce, &angle, &scale) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    opencv_point_object *center_object = Z_PHP_POINT_OBJ_P(center_zval);
+    Mat mat = getRotationMatrix2D(Point2f(*center_object->point), angle, scale);
+
+    zval instance;
+    object_init_ex(&instance, opencv_mat_ce);
+    opencv_mat_object *instance_object = Z_PHP_MAT_OBJ_P(&instance);
+
+    instance_object->mat = new Mat(mat);
+
+    opencv_mat_update_property_by_c_mat(&instance, instance_object->mat);
+
+    RETURN_ZVAL(&instance, 0, 0); //return php Mat object
+
+}
+
+
+/**
+ * CV\warpAffine
+ * @param execute_data
+ * @param return_value
+ */
+PHP_FUNCTION (opencv_warp_affine) {
+    zval *src_zval, *dst_zval, *M_zval, *dsize_zval, *border_value_zval = NULL;
+    long flags = INTER_LINEAR, borderMode = BORDER_CONSTANT;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OzOO|llO",
+                              &src_zval, opencv_mat_ce,
+                              &dst_zval,
+                              &M_zval, opencv_mat_ce,
+                              &dsize_zval, opencv_size_ce,
+                              &flags, &borderMode,
+                              &border_value_zval, opencv_scalar_ce) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    Scalar borderValue = Scalar();
+    if (border_value_zval != NULL) {
+        opencv_scalar_object *border_value_object = Z_PHP_SCALAR_OBJ_P(border_value_zval);
+        borderValue = *border_value_object->scalar;
+    }
+    opencv_mat_object *src_object = Z_PHP_MAT_OBJ_P(src_zval);
+    opencv_mat_object *M_object = Z_PHP_MAT_OBJ_P(M_zval);
+    opencv_size_object *dsize_object = Z_PHP_SIZE_OBJ_P(dsize_zval);
+
+    opencv_mat_object *dst_object;
+    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
+
+    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
+        // is Point object
+        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
+    } else {
+        // isn't Mat object
+        zval_ptr_dtor(dst_real_zval);
+        zval instance;
+        object_init_ex(&instance, opencv_mat_ce);
+        ZVAL_COPY_VALUE(dst_real_zval, &instance);// Cover dst_real_zval by Mat object
+        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
+    }
+    Mat dst;
+    warpAffine(*src_object->mat, dst, *M_object->mat, *dsize_object->size, (int) flags, (int) borderMode, borderValue);
+    dst_object->mat = new Mat(dst);
+    opencv_mat_update_property_by_c_mat(dst_real_zval, dst_object->mat);
+
+    RETURN_NULL();
+
+}
+
+
+PHP_FUNCTION (opencv_get_rect_sub_pix) {
+    zval *image_zval, *patch_size_zval, *center_zval, *patch_zval;
+    long patchType = -1;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OOOz|l",
+                              &image_zval, opencv_mat_ce,
+                              &patch_size_zval, opencv_size_ce,
+                              &center_zval, opencv_point_ce,
+                              &patch_zval,
+                              &patchType) == FAILURE) {
+        RETURN_NULL();
+    }
+
+
+    opencv_mat_object *image_object = Z_PHP_MAT_OBJ_P(image_zval);
+    opencv_size_object *patch_size_object = Z_PHP_SIZE_OBJ_P(patch_size_zval);
+    opencv_point_object *center_object = Z_PHP_POINT_OBJ_P(center_zval);
+
+    opencv_mat_object *patch_object;
+    zval *patch_real_zval = Z_REFVAL_P(patch_zval);
+
+    if (Z_TYPE_P(patch_real_zval) == IS_OBJECT && Z_OBJCE_P(patch_real_zval) == opencv_mat_ce) {
+        // is Point object
+        patch_object = Z_PHP_MAT_OBJ_P(patch_real_zval);
+    } else {
+        // isn't Mat object
+        zval_ptr_dtor(patch_real_zval);
+        zval instance;
+        object_init_ex(&instance, opencv_mat_ce);
+        ZVAL_COPY_VALUE(patch_real_zval, &instance);// Cover dst_real_zval by Mat object
+        patch_object = Z_PHP_MAT_OBJ_P(patch_real_zval);
+    }
+    Mat patch;
+    getRectSubPix(*image_object->mat, *patch_size_object->size, Point2f(*center_object->point), patch, (int) patchType);
+    patch_object->mat = new Mat(patch);
+    opencv_mat_update_property_by_c_mat(patch_real_zval, patch_object->mat);
+
+    RETURN_NULL();
+
+}
+
+/**
+ * @see cv::getPerspectiveTransform
+ * @param execute_data
+ * @param return_value
+ */
+PHP_FUNCTION(opencv_get_perspective_transform){
+
+    zval *src_zval,*dst_zval;
+    long solveMethod = DECOMP_LU;
+
+    if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_THROW, ZEND_NUM_ARGS(), "aa|l",
+                                 &src_zval ,
+                                 &dst_zval ,
+                                 &solveMethod
+    ) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    zend_ulong _h;
+    zval *array_val_zval;
+    std::vector<cv::Point2f> src_points, dst_points;
+    opencv_point_object *point_object;
+    //src point数组
+    unsigned long src_count = zend_hash_num_elements(Z_ARRVAL_P(src_zval));//获取数组长度
+    src_points.reserve(src_count);//指定长度
+    ZEND_HASH_FOREACH_NUM_KEY_VAL(Z_ARRVAL_P(src_zval), _h, array_val_zval)
+            {//get point arrays
+                again1:
+                if (Z_TYPE_P(array_val_zval) == IS_OBJECT && Z_OBJCE_P(array_val_zval) == opencv_point_ce) {
+                    point_object = Z_PHP_POINT_OBJ_P(array_val_zval);
+                    src_points.push_back(*point_object->point);
+                } else if (Z_TYPE_P(array_val_zval) == IS_REFERENCE) {
+                    array_val_zval = Z_REFVAL_P(array_val_zval);
+                    goto again1;
+                } else {
+                    opencv_throw_exception("The parameter src can only be a Point object two bit array.");
+                    RETURN_NULL();
+                }
+            }
+    ZEND_HASH_FOREACH_END();
+
+    //dst point数组
+    unsigned long dst_count = zend_hash_num_elements(Z_ARRVAL_P(dst_zval));//获取数组长度
+    dst_points.reserve(dst_count);//指定长度
+    ZEND_HASH_FOREACH_NUM_KEY_VAL(Z_ARRVAL_P(dst_zval), _h, array_val_zval)
+            {//get point arrays
+                again2:
+                if (Z_TYPE_P(array_val_zval) == IS_OBJECT && Z_OBJCE_P(array_val_zval) == opencv_point_ce) {
+                    point_object = Z_PHP_POINT_OBJ_P(array_val_zval);
+                    dst_points.push_back(*point_object->point);
+                } else if (Z_TYPE_P(array_val_zval) == IS_REFERENCE) {
+                    array_val_zval = Z_REFVAL_P(array_val_zval);
+                    goto again2;
+                } else {
+                    opencv_throw_exception("The parameter dst can only be a Point object two bit array.");
+                    RETURN_NULL();
+                }
+            }
+    ZEND_HASH_FOREACH_END();
+
+    try {
+        Mat mat = getPerspectiveTransform(src_points, dst_points, (int)solveMethod);
+        zval instance;
+        object_init_ex(&instance, opencv_mat_ce);
+        opencv_mat_object *instance_object = Z_PHP_MAT_OBJ_P(&instance);
+
+        instance_object->mat = new Mat(mat);
+
+        opencv_mat_update_property_by_c_mat(&instance, instance_object->mat);
+
+        RETURN_ZVAL(&instance, 0, 0); //return php Mat object
+    } catch (Exception e) {
+        opencv_throw_exception(e.what());
+    }
+
+}
+
+
+PHP_FUNCTION(opencv_warp_perspective){
+
+    zval *src_zval, *dst_zval, *M_zval, *dsize_zval, *border_value_zval = nullptr;
+    long flags = INTER_LINEAR ,borderMode = BORDER_CONSTANT;
+
+    if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_THROW, ZEND_NUM_ARGS(), "OzOO|llO",
+                                 &src_zval ,opencv_mat_ce,
+                                 &dst_zval ,
+                                 &M_zval ,opencv_mat_ce,
+                                 &dsize_zval ,opencv_size_ce,
+                                 &flags,
+                                 &borderMode,
+                                 &border_value_zval, opencv_scalar_ce
+    ) == FAILURE) {
+        RETURN_NULL();
+    }
+
+    Scalar borderValue = Scalar();
+    if (border_value_zval != nullptr) {
+        opencv_scalar_object *border_value_object = Z_PHP_SCALAR_OBJ_P(border_value_zval);
+        borderValue = *border_value_object->scalar;
+    }
+
+    opencv_mat_object *src_object = Z_PHP_MAT_OBJ_P(src_zval);
+    opencv_mat_object *M_object = Z_PHP_MAT_OBJ_P(M_zval);
+    opencv_size_object *dsize_object = Z_PHP_SIZE_OBJ_P(dsize_zval);
+
+    opencv_mat_object *dst_object;
+    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
+
+    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
+        // is Point object
+        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
+    } else {
+        // isn't Mat object
+        zval_ptr_dtor(dst_real_zval);
+        zval instance;
+        object_init_ex(&instance, opencv_mat_ce);
+        ZVAL_COPY_VALUE(dst_real_zval, &instance);// Cover dst_real_zval by Mat object
+        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
+    }
+    try{
+        Mat dst;
+        warpPerspective(*src_object->mat, dst, *M_object->mat, *dsize_object->size, (int) flags, (int) borderMode, borderValue);
+        dst_object->mat = new Mat(dst);
+        opencv_mat_update_property_by_c_mat(dst_real_zval, dst_object->mat);
+
+        RETURN_NULL();
+
+    } catch (Exception e) {
+        opencv_throw_exception(e.what());
+    }
+
+
+}
+
+
 /**
  * color conversion code in CV\cvtColor,opencv enum ColorConversionCodes
  * @param module_number

source/opencv2/opencv_imgproc.h

@@ -247,6 +247,44 @@ ZEND_BEGIN_ARG_INFO_EX(opencv_draw_contours_arginfo, 0, 0, 9)
 ZEND_END_ARG_INFO()
 PHP_FUNCTION(opencv_draw_contours);
 PHP_FUNCTION(opencv_bounding_rect);
+PHP_FUNCTION(opencv_get_rotation_matrix2D);
+ZEND_BEGIN_ARG_INFO_EX(opencv_warp_affine_arginfo, 0, 0, 7)
+                ZEND_ARG_INFO(0, src)
+                ZEND_ARG_INFO(1, dst)
+                ZEND_ARG_INFO(0, M)
+                ZEND_ARG_INFO(0, dsize)
+                ZEND_ARG_INFO(0, flags)
+                ZEND_ARG_INFO(0, borderMode)
+                ZEND_ARG_INFO(0, borderValue)
+ZEND_END_ARG_INFO()
+PHP_FUNCTION(opencv_warp_affine);
+ZEND_BEGIN_ARG_INFO_EX(opencv_get_rect_sub_pix_arginfo, 0, 0, 5)
+                ZEND_ARG_INFO(0, image)
+                ZEND_ARG_INFO(0, patchSize)
+                ZEND_ARG_INFO(0, center)
+                ZEND_ARG_INFO(1, patch)
+                ZEND_ARG_INFO(0, patchType)
+ZEND_END_ARG_INFO()
+PHP_FUNCTION(opencv_get_rect_sub_pix);
+
+
+ZEND_BEGIN_ARG_INFO_EX(opencv_get_perspective_transform_arginfo, 0, 0, 5)
+                ZEND_ARG_INFO(0, src)
+                ZEND_ARG_INFO(0, dst)
+                ZEND_ARG_INFO(0, solveMethod)
+ZEND_END_ARG_INFO()
+PHP_FUNCTION(opencv_get_perspective_transform);
+
+ZEND_BEGIN_ARG_INFO_EX(opencv_warp_perspective_arginfo, 0, 0, 7)
+                ZEND_ARG_INFO(0, src)
+                ZEND_ARG_INFO(1, dst)
+                ZEND_ARG_INFO(0, M)
+                ZEND_ARG_INFO(0, dsize)
+                ZEND_ARG_INFO(0, flags)
+                ZEND_ARG_INFO(0, borderMode)
+                ZEND_ARG_INFO(0, borderValue)
+ZEND_END_ARG_INFO()
+PHP_FUNCTION(opencv_warp_perspective);
 
 
 #endif //OPENCV_OPENCV_IMGPROC_H

source/opencv2/opencv_ml.cc

@@ -123,9 +123,9 @@ const zend_function_entry opencv_k_nearest_methods[] = {
  */
 zend_object* opencv_k_nearest_handler(zend_class_entry *type)
 {
-    size_t size = sizeof(opencv_k_nearest_object);
+    size_t size = sizeof(opencv_k_nearest_object)+zend_object_properties_size(type);
     opencv_k_nearest_object *obj = (opencv_k_nearest_object *)ecalloc(1,size);
-    memset(obj, 0, sizeof(opencv_k_nearest_object));
+    memset(obj, 0, size);
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -152,4 +152,5 @@ void opencv_k_nearest_init(int module_number){
            zend_get_std_object_handlers(), sizeof(zend_object_handlers));
     opencv_k_nearest_object_handlers.clone_obj = NULL;
     opencv_k_nearest_object_handlers.free_obj = opencv_k_nearest_free_obj;
+    opencv_k_nearest_object_handlers.offset = XtOffsetOf(opencv_k_nearest_object, std);
 }

source/opencv2/opencv_ml.h

@@ -32,8 +32,8 @@ extern void opencv_ml_sample_types_init(int module_number);
 extern zend_class_entry *opencv_k_nearest_ce;
 
 typedef struct _opencv_k_nearest_object{
-    zend_object std;
     Ptr<cv::ml::KNearest> KNearest;
+    zend_object std;
 }opencv_k_nearest_object;
 
 #define Z_PHP_K_NEAREST_OBJ_P(zv)  get_opencv_k_nearest_object(Z_OBJ_P(zv))

source/opencv2/opencv_objdetect.cc

@@ -30,9 +30,9 @@ zend_object_handlers opencv_cascade_classifier_object_handlers;
  */
 zend_object* opencv_cascade_classifier_create_handler(zend_class_entry *type)
 {
-    int size = sizeof(opencv_cascade_classifier_object);
+    int size = sizeof(opencv_cascade_classifier_object)+zend_object_properties_size(type);
     opencv_cascade_classifier_object *obj = (opencv_cascade_classifier_object *)ecalloc(1,size);
-    memset(obj, 0, sizeof(opencv_cascade_classifier_object));
+    memset(obj, 0, size);
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -167,6 +167,7 @@ void opencv_cascade_classifier_init(int module_number){
     opencv_cascade_classifier_object_handlers.clone_obj = NULL;
 //    opencv_cascade_classifier_object_handlers.write_property = opencv_mat_write_property;
     opencv_cascade_classifier_object_handlers.free_obj = opencv_cascade_classifier_free_obj;
+    opencv_cascade_classifier_object_handlers.offset = XtOffsetOf(opencv_cascade_classifier_object, std);
 }
 
 
@@ -174,10 +175,10 @@ void opencv_cascade_classifier_init(int module_number){
 void opencv_objdetect_constants_init(int module_number)
 {
 
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_HAAR_DO_CANNY_PRUNING", CV_HAAR_DO_CANNY_PRUNING, CONST_CS | CONST_PERSISTENT);
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_HAAR_SCALE_IMAGE", CV_HAAR_SCALE_IMAGE, CONST_CS | CONST_PERSISTENT);
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_HAAR_FIND_BIGGEST_OBJECT", CV_HAAR_FIND_BIGGEST_OBJECT, CONST_CS | CONST_PERSISTENT);
-    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_HAAR_DO_ROUGH_SEARCH", CV_HAAR_DO_ROUGH_SEARCH, CONST_CS | CONST_PERSISTENT);
+//    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_HAAR_DO_CANNY_PRUNING", CV_HAAR_DO_CANNY_PRUNING, CONST_CS | CONST_PERSISTENT);
+//    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_HAAR_SCALE_IMAGE", CV_HAAR_SCALE_IMAGE, CONST_CS | CONST_PERSISTENT);
+//    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_HAAR_FIND_BIGGEST_OBJECT", CV_HAAR_FIND_BIGGEST_OBJECT, CONST_CS | CONST_PERSISTENT);
+//    REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CV_HAAR_DO_ROUGH_SEARCH", CV_HAAR_DO_ROUGH_SEARCH, CONST_CS | CONST_PERSISTENT);
 
     REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CASCADE_DO_CANNY_PRUNING", CASCADE_DO_CANNY_PRUNING, CONST_CS | CONST_PERSISTENT);
     REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "CASCADE_SCALE_IMAGE", CASCADE_SCALE_IMAGE, CONST_CS | CONST_PERSISTENT);

source/opencv2/opencv_objdetect.h

@@ -25,8 +25,8 @@ extern zend_class_entry *opencv_cascade_classifier_ce;
 #define Z_PHP_CASCADE_CLASSIFIER_OBJ_P(zv)  get_cascade_classifier_obj(Z_OBJ_P(zv))
 
 typedef struct _opencv_cascade_classifier_object{
-    zend_object std;
     CascadeClassifier *cascadeClassifier;
+    zend_object std;
 }opencv_cascade_classifier_object;
 
 extern void opencv_objdetect_init(int module_number);

source/opencv2/opencv_videoio.cc

@@ -24,9 +24,9 @@ zend_object_handlers opencv_video_capture_object_handlers;
 
 zend_object* opencv_video_capture_create_handler(zend_class_entry *type)
 {
-    size_t size = sizeof(opencv_video_capture_object);
+    size_t size = sizeof(opencv_video_capture_object)+zend_object_properties_size(type);
     opencv_video_capture_object *obj = (opencv_video_capture_object *)ecalloc(1,size);
-    memset(obj, 0, sizeof(opencv_video_capture_object));
+    memset(obj, 0, size);
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -209,6 +209,7 @@ void opencv_video_capture_init(int module_number){
            zend_get_std_object_handlers(), sizeof(zend_object_handlers));
     opencv_video_capture_object_handlers.clone_obj = NULL;
     opencv_video_capture_object_handlers.free_obj = opencv_video_capture_free_obj;
+    opencv_video_capture_object_handlers.offset = XtOffsetOf(opencv_video_capture_object, std);
 }
 
 void opencv_videoio_init(int module_number){

source/opencv2/opencv_videoio.h

@@ -22,8 +22,8 @@ extern zend_class_entry *opencv_video_capture_ce;
 #define Z_PHP_VIDEO_CAPTURE_P(zv)  get_video_capture_obj(Z_OBJ_P(zv))
 
 typedef struct _opencv_video_capture_object{
-    zend_object std;
     VideoCapture *videoCapture;
+    zend_object std;
 }opencv_video_capture_object;
 
 extern void opencv_videoio_init(int module_number);

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,
+  ),
+))

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

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

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(
+))

tests/videoCapture.phpt

@@ -8,13 +8,11 @@ use CV\VideoCapture;
 
 $video=new VideoCapture();
 var_dump($video->isOpened());
-$video->open(0);
+//$video->open(0);
 var_dump($video);
-var_dump($video->isOpened());
 
 ?>
 --EXPECT--
 bool(false)
 object(CV\VideoCapture)#1 (0) {
-}
-bool(true)
+}