Merge branch 'master' into dev

.travis.yml

@@ -1,10 +1,86 @@
-sudo: required
+language: php
 
-services:
-  - docker
+compiler:
+  - gcc
+  - clang
+
+os:
+  - linux
+#  - osx
+
+php:
+  - 7.0
+  - 7.1
+  - 7.2
+
+notifications:
+  email: hihozhou@gmail.com
 
 before_install:
-  - docker pull ubuntu:18.04
+  - 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
+  - sudo apt-get install python3-numpy
+
+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
 
 script:
-  - docker build .
+    - exit 0

Dockerfile

@@ -1,9 +0,0 @@
-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,41 +1,152 @@
-## PHP-OPENCV - PHP extension for Opencv
+# PHP-OPENCV - PHP extension for Opencv
 
-[![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/)
+[![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/)
 
-### Easy installation on ubuntu 18.04 LTS from packages (approximately 1 minute):
+
+## 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
 ```
-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
+
+## Configure
+
+php.ini
+
 ```
-[All installation options](https://github.com/php-opencv/php-opencv/wiki/Installation)
+extension="your opencv.so path"
+```
+## Example
 
-### Examples
-- [dnn](https://github.com/php-opencv/php-opencv-examples)
-- [core](https://github.com/hihozhou/php-opencv)
+### LBPH face recognition
 
-### Documentation
-- [PHP OpenCV Doc](https://phpopencv.org/docs/index.html)
-- [PHP OpenCV Api](https://phpopencv.org/api/index.html)
+```php
+use CV\Face\LBPHFaceRecognizer;
+//use ...;
 
-### Requirements
-- OpenCV 4.0.0+ (for OpenCV 3.4 use branch 3.4)
-- PHP 7.0 / 7.1 / 7.2
+$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
+```
 
-### Features
-- [core](https://phpopencv.org/docs/mat.html)
-- [imgproc](https://phpopencv.org/docs/gausian_median_blur_bilateral_filter.html)
-- highgui
-- objdetect
-- video
-- ml
-- dnn
+result:
 
-### Helper for autocomplete and highlighting in your IDE
-- [phpdoc file](https://github.com/php-opencv/php-opencv-examples/blob/master/phpdoc.php)
+![predict](tests/face_recognizer.jpg)
 
-### Contributors
-- [@morozovsk](https://github.com/morozovsk)
-- [@hihozhou](https://github.com/hihozhou)
-- [@MaleicAcid](https://github.com/MaleicAcid)
+
+### 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内核交流`的群友对技术的帮助。

config.m4

@@ -49,9 +49,7 @@ 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"
 
 
@@ -66,19 +64,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 opencv4; then
-              if $PKG_CONFIG --atleast-version=4.0.0 opencv4; then
-                  opencv_version=`$PKG_CONFIG --modversion opencv4`
+          if $PKG_CONFIG --exists opencv; then
+              if $PKG_CONFIG --atleast-version=3.3.0 opencv; then
+                  opencv_version=`$PKG_CONFIG --modversion opencv`
                   AC_MSG_RESULT([found $opencv_version])
                   dnl Add c++ opencv libs and includes by pkg-config
-                  OPENCV_LIBS=`$PKG_CONFIG --libs opencv4`
-                  OPENCV_INCS=`$PKG_CONFIG --cflags opencv4`
+                  OPENCV_LIBS=`$PKG_CONFIG --libs opencv`
+                  OPENCV_INCS=`$PKG_CONFIG --cflags opencv`
                   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 4.0.0)
+                  AC_MSG_ERROR(Ooops ! You need at least opencv 3.3.0)
               fi
           else
               AC_MSG_RESULT(not found)
@@ -90,4 +88,4 @@ if test "$PHP_OPENCV" != "no"; then
     fi
 
 
-fi
+fi

opencv.cc

@@ -43,7 +43,6 @@ 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)
@@ -125,7 +124,6 @@ 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);
 
@@ -246,11 +244,9 @@ 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)
+    ZEND_NS_NAMED_FE(OPENCV_NS, getRotationMatrix2D, ZEND_FN(opencv_get_rotation_matrix2D), NULL)
+    ZEND_NS_NAMED_FE(OPENCV_NS, warpAffine, ZEND_FN(opencv_warp_affine), opencv_warp_affine_arginfo)
+    ZEND_NS_NAMED_FE(OPENCV_NS, getRectSubPix, ZEND_FN(opencv_get_rect_sub_pix), opencv_get_rect_sub_pix_arginfo)
 	PHP_FE_END	/* Must be the last line in opencv_functions[] */
 };
 /* }}} */

php_opencv.h

@@ -49,7 +49,6 @@ 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,8 +27,7 @@ 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);
-    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_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)+zend_object_properties_size(type);
+    int size = sizeof(opencv_mat_object);
     opencv_mat_object *obj = (opencv_mat_object *)ecalloc(1,size);
-    memset(obj, 0, size);
+    memset(obj, 0, sizeof(opencv_mat_object));
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -54,107 +54,6 @@ 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;
-        }
-    }
 }
 
 /**
@@ -196,12 +95,8 @@ 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());
-    //long转cv::Formatter::FormatType类型
-    cv::Formatter::FormatType formatType = static_cast<cv::Formatter::FormatType>((int)type);
-    std::cout << format(*(obj->mat), formatType) << std::endl;
-
+    std::cout << format(*(obj->mat),int(type)) << std::endl;
     RETURN_NULL();
 }
 
@@ -224,12 +119,6 @@ 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());
@@ -474,6 +363,7 @@ PHP_METHOD(opencv_mat, copy_to)
 }
 
 /**
+ * //todo int,fload,double
  * CV\Mat->at
  * @param execute_data
  * @param return_value
@@ -486,89 +376,78 @@ 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());
-    zval *idx_zval;
-    int *idx;
-    long return_long_val;
-    double return_double_val;
+    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;
+        }
 
-    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());
-
-    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();
+    }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;
                 }
-    }ZEND_HASH_FOREACH_END();
+                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;
+        }
 
-    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)
@@ -675,33 +554,6 @@ 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
-}
-
 
 
 /**
@@ -804,13 +656,11 @@ 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)
@@ -827,7 +677,7 @@ const zend_function_entry opencv_mat_methods[] = {
  * @param value
  * @param cache_slot
  */
-zval *opencv_mat_write_property(zval *object, zval *member, zval *value, void **cache_slot){
+void 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);
@@ -840,7 +690,7 @@ zval *opencv_mat_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;
+
 }
 
 /**
@@ -859,7 +709,6 @@ 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{
-    Mat *mat;
     zend_object std;
+    Mat *mat;
 }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)+zend_object_properties_size(type);
+    size_t size = sizeof(opencv_file_storage_object);
     opencv_file_storage_object *obj = (opencv_file_storage_object *)ecalloc(1,size);
-    memset(obj, 0, size);
+    memset(obj, 0, sizeof(opencv_file_storage_object));
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -278,6 +278,5 @@ 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{
-    FileStorage *fileStorage;
     zend_object std;
+    FileStorage *fileStorage;
 }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

@@ -18,6 +18,8 @@
 #include "../../../php_opencv.h"
 #include "../../../opencv_exception.h"
 #include "opencv_type.h"
+#include <algorithm>
+#include <iostream>
 
 zend_class_entry *opencv_point_ce;
 zend_class_entry *opencv_scalar_ce;
@@ -83,9 +85,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)+zend_object_properties_size(type);
+    size_t size = sizeof(opencv_point_object);
     opencv_point_object *obj = (opencv_point_object *)ecalloc(1,size);
-    memset(obj, 0, size);
+    memset(obj, 0, sizeof(opencv_point_object));
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -108,7 +110,7 @@ void opencv_point_free_obj(zend_object *object)
  * @param value
  * @param cache_slot
  */
-zval *opencv_point_write_property(zval *object, zval *member, zval *value, void **cache_slot){
+void 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 +123,7 @@ zval *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,7 +140,6 @@ 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);
 }
 
 
@@ -155,9 +156,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)+zend_object_properties_size(type);
+    size_t size = sizeof(opencv_scalar_object);
     opencv_scalar_object *obj = (opencv_scalar_object *)ecalloc(1,size);
-    memset(obj, 0, size);
+    memset(obj, 0, sizeof(opencv_scalar_object));
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -246,7 +247,6 @@ 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);
 }
 
 
@@ -260,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)+zend_object_properties_size(type);
+    size_t size = sizeof(opencv_size_object);
     opencv_size_object *obj = (opencv_size_object *)ecalloc(1,size);
-    memset(obj, 0, size);
+    memset(obj, 0, sizeof(opencv_size_object));
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -333,7 +333,7 @@ const zend_function_entry opencv_size_methods[] = {
  * @param value
  * @param cache_slot
  */
-zval *opencv_size_write_property(zval *object, zval *member, zval *value, void **cache_slot){
+void 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);
@@ -346,7 +346,7 @@ zval *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;
+
 }
 
 
@@ -364,7 +364,6 @@ 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);
 }
 
 
@@ -378,9 +377,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)+zend_object_properties_size(type);
+    size_t size = sizeof(opencv_rect_object);
     opencv_rect_object *obj = (opencv_rect_object *)ecalloc(1,size);
-    memset(obj, 0, size);
+    memset(obj, 0, sizeof(opencv_rect_object));
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -525,7 +524,7 @@ const zend_function_entry opencv_rect_methods[] = {
  * @param value
  * @param cache_slot
  */
-zval *opencv_rect_write_property(zval *object, zval *member, zval *value, void **cache_slot){
+void 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);
@@ -542,7 +541,7 @@ zval *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;
+
 }
 
 
@@ -560,7 +559,6 @@ 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】--------------------------------
@@ -571,9 +569,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)+zend_object_properties_size(type);
+    size_t size = sizeof(opencv_rotated_rect_object);
     opencv_rotated_rect_object *obj = (opencv_rotated_rect_object *)ecalloc(1,size);
-    memset(obj, 0, size);
+    memset(obj, 0, sizeof(opencv_rotated_rect_object));
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -590,7 +588,7 @@ zend_object* opencv_rotated_rect_create_handler(zend_class_entry *type)
  * @param value
  * @param cache_slot
  */
-zval *opencv_rotated_rect_write_property(zval *object, zval *member, zval *value, void **cache_slot){
+void 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);
@@ -618,7 +616,7 @@ zval *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;
+
 }
 
 
@@ -732,7 +730,6 @@ 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{
-    Point *point;
     zend_object std;
+    Point *point;
 }opencv_point_object;
 
 typedef struct _opencv_scalar_object{
-    Scalar *scalar;
     zend_object std;
+    Scalar *scalar;
 }opencv_scalar_object;
 
 typedef struct _opencv_size_object{
-    Size *size;
     zend_object std;
+    Size *size;
 }opencv_size_object;
 
 typedef struct _opencv_rect_object{
-    Rect *rect;
     zend_object std;
+    Rect *rect;
 }opencv_rect_object;
 
 
 typedef struct _opencv_rotated_rect_object{
-    RotatedRect *rotatedRect;
     zend_object std;
+    RotatedRect *rotatedRect;
 }opencv_rotated_rect_object;
 
 /**

source/opencv2/dnn/opencv_dnn.cc

@@ -1,269 +0,0 @@
-/*
- +----------------------------------------------------------------------+
- | 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

@@ -1,33 +0,0 @@
-/*
- +----------------------------------------------------------------------+
- | 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

@@ -1,248 +0,0 @@
-/*
- +----------------------------------------------------------------------+
- | 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

@@ -1,39 +0,0 @@
-/*
- +----------------------------------------------------------------------+
- | 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{
-    Ptr<LBPHFaceRecognizer> faceRecognizer;
     zend_object std;
+    Ptr<LBPHFaceRecognizer> faceRecognizer;
 }opencv_lbph_face_recognizer_object;
 
 
@@ -102,41 +102,36 @@ 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, *confidence_zval = NULL;
-    int label;
-    double confidence = 0;
-
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "O|z", &src_zval, opencv_mat_ce, &confidence_zval) == FAILURE) {
+    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;
+    double confidence = 0;
+    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);
     obj->faceRecognizer->predict(*src_object->mat, label, 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);
+    RETURN_DOUBLE(confidence);
 }
 
 PHP_METHOD(opencv_lbph_face_recognizer, read)
 {
     char *filename;
-    size_t filename_len;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &filename, &filename_len) == FAILURE) {
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &filename) == FAILURE) {
         RETURN_NULL();
     }
 
@@ -148,8 +143,7 @@ PHP_METHOD(opencv_lbph_face_recognizer, read)
 PHP_METHOD(opencv_lbph_face_recognizer, write)
 {
     char *filename;
-    size_t filename_len;
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &filename, &filename_len) == FAILURE) {
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &filename) == FAILURE) {
         RETURN_NULL();
     }
 
@@ -210,7 +204,9 @@ 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, opencv_lbph_face_recognizer_predict_arginfo, 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, 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)
@@ -224,9 +220,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)+zend_object_properties_size(type);
+    size_t size = sizeof(opencv_lbph_face_recognizer_object);
     opencv_lbph_face_recognizer_object *obj = (opencv_lbph_face_recognizer_object *)ecalloc(1,size);
-    memset(obj, 0, size);
+    memset(obj, 0, sizeof(opencv_lbph_face_recognizer_object));
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -239,7 +235,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; //todo: it's hotfix for: double free or corruption (out) Aborted (core dumped)
+    delete obj->faceRecognizer;
     zend_object_std_dtor(object);
 }
 
@@ -253,7 +249,6 @@ 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,20 +60,19 @@ void opencv_norm_types_const_init(int module_number){
     REGISTER_NS_LONG_CONSTANT(OPENCV_NS, "NORM_MINMAX", NORM_MINMAX, CONST_CS | CONST_PERSISTENT);
 }
 
-//todo
-//void opencv_hershey_fonts_const_init(int module_number){
+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)
@@ -81,7 +80,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,7 +24,6 @@ zend_class_entry *opencv_face_recognizer_ce;
 using namespace face;
 
 #include "face/opencv_facerec.h"
-#include "face/opencv_facemarkLBF.h"
 
 
 /**
@@ -46,8 +45,6 @@ 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,40 +80,6 @@ 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,6 +20,5 @@
 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.h

@@ -268,23 +268,4 @@ 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)+zend_object_properties_size(type);
+    size_t size = sizeof(opencv_k_nearest_object);
     opencv_k_nearest_object *obj = (opencv_k_nearest_object *)ecalloc(1,size);
-    memset(obj, 0, size);
+    memset(obj, 0, sizeof(opencv_k_nearest_object));
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -152,5 +152,4 @@ 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{
-    Ptr<cv::ml::KNearest> KNearest;
     zend_object std;
+    Ptr<cv::ml::KNearest> KNearest;
 }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)+zend_object_properties_size(type);
+    int size = sizeof(opencv_cascade_classifier_object);
     opencv_cascade_classifier_object *obj = (opencv_cascade_classifier_object *)ecalloc(1,size);
-    memset(obj, 0, size);
+    memset(obj, 0, sizeof(opencv_cascade_classifier_object));
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -167,7 +167,6 @@ 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);
 }
 
 
@@ -175,10 +174,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{
-    CascadeClassifier *cascadeClassifier;
     zend_object std;
+    CascadeClassifier *cascadeClassifier;
 }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)+zend_object_properties_size(type);
+    size_t size = sizeof(opencv_video_capture_object);
     opencv_video_capture_object *obj = (opencv_video_capture_object *)ecalloc(1,size);
-    memset(obj, 0, size);
+    memset(obj, 0, sizeof(opencv_video_capture_object));
     zend_object_std_init(&obj->std, type);
     object_properties_init(&obj->std, type);
     obj->std.ce = type;
@@ -209,7 +209,6 @@ 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{
-    VideoCapture *videoCapture;
     zend_object std;
+    VideoCapture *videoCapture;
 }opencv_video_capture_object;
 
 extern void opencv_videoio_init(int module_number);

tests/dnn.phpt

@@ -1,28 +0,0 @@
---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

@@ -1,39 +0,0 @@
---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

@@ -1,42 +0,0 @@
---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

@@ -1,14 +0,0 @@
---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,11 +8,13 @@ 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)