├── CREDITS ├── EXPERIMENTAL ├── examples ├── test_convert.php ├── test_smooth.php ├── test_split.php ├── test_edge_detect.php ├── test_file_capture.php ├── test_haar.php ├── test_template.php ├── test_capture.php └── test_hist.php ├── README.md ├── config.w32 ├── opencv.php ├── tests └── 001.phpt ├── .gitignore ├── opencv_error.cpp ├── config.m4 ├── php_opencv.h ├── opencv.cpp ├── opencv_histogram.cpp ├── opencv_mat.cpp ├── opencv_capture.cpp └── opencv_image.cpp /CREDITS: -------------------------------------------------------------------------------- 1 | opencv -------------------------------------------------------------------------------- /EXPERIMENTAL: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /examples/test_convert.php: -------------------------------------------------------------------------------- 1 | convertColor(OpenCV\Image::RGB2HSV); 4 | $hsv->save("hsv.jpg"); 5 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # OpenCV for PHP 2 | 3 | This is a PHP extension wrapping the OpenCV library for image processing. It 4 | lets you use the OpenCV library for image recognition and modification tasks. 5 | 6 | It requires PHP 5.3, and OpenCV 2.0 or above. 7 | -------------------------------------------------------------------------------- /examples/test_smooth.php: -------------------------------------------------------------------------------- 1 | smooth(Image::GAUSSIAN, 31, 0, 0, 0); 7 | $dst->save("test_smoothed.jpg"); 8 | -------------------------------------------------------------------------------- /examples/test_split.php: -------------------------------------------------------------------------------- 1 | split(); 5 | $i = 0; 6 | foreach ($split as $plane) { 7 | $i++; 8 | $plane->save("split_$i.jpg"); 9 | } 10 | -------------------------------------------------------------------------------- /examples/test_edge_detect.php: -------------------------------------------------------------------------------- 1 | sobel(1, 0, 1); 7 | $dst->save("test_sobel.jpg"); 8 | 9 | $dst2 = $i->canny(10, 50, 3); 10 | $dst2->save("test_canny.jpg"); 11 | -------------------------------------------------------------------------------- /config.w32: -------------------------------------------------------------------------------- 1 | // $Id$ 2 | // vim:ft=javascript 3 | 4 | // If your extension references something external, use ARG_WITH 5 | // ARG_WITH("opencv", "for opencv support", "no"); 6 | 7 | // Otherwise, use ARG_ENABLE 8 | // ARG_ENABLE("opencv", "enable opencv support", "no"); 9 | 10 | if (PHP_OPENCV != "no") { 11 | EXTENSION("opencv", "opencv.c"); 12 | } 13 | 14 | -------------------------------------------------------------------------------- /examples/test_file_capture.php: -------------------------------------------------------------------------------- 1 | queryFrame(); 4 | $result = $image->haarDetectObjects("data/haarcascades/haarcascade_frontalface_default.xml"); 5 | foreach ($result as $r) { 6 | $image->rectangle($r['x'], $r['y'], $r['width'], $r['height']); 7 | } 8 | $image->save('/tmp/video.jpg'); 9 | -------------------------------------------------------------------------------- /examples/test_haar.php: -------------------------------------------------------------------------------- 1 | haarDetectObjects("/usr/share/opencv/haarcascades/haarcascade_frontalface_default.xml"); 7 | 8 | foreach ($result as $r) { 9 | $i->rectangle($r['x'], $r['y'], $r['width'], $r['height']); 10 | } 11 | 12 | $i->save("haar_output.jpg"); 13 | -------------------------------------------------------------------------------- /examples/test_template.php: -------------------------------------------------------------------------------- 1 | matchTemplate($im, $i); 11 | $result->save("mt_output_$i.jpg"); 12 | } 13 | -------------------------------------------------------------------------------- /examples/test_capture.php: -------------------------------------------------------------------------------- 1 | queryFrame(); 6 | $result = $image->haarDetectObjects("/usr/share/opencv/haarcascades/haarcascade_frontalface_default.xml"); 7 | foreach ($result as $r) { 8 | $image->rectangle($r['x'], $r['y'], $r['width'], $r['height']); 9 | } 10 | //$image = $image->convertColor(7); 11 | $image->save('/tmp/camera.jpg'); 12 | -------------------------------------------------------------------------------- /opencv.php: -------------------------------------------------------------------------------- 1 | "; 3 | 4 | if(!extension_loaded('opencv')) { 5 | dl('opencv.' . PHP_SHLIB_SUFFIX); 6 | } 7 | $module = 'opencv'; 8 | $functions = get_extension_funcs($module); 9 | echo "Functions available in the test extension:$br\n"; 10 | foreach($functions as $func) { 11 | echo $func."$br\n"; 12 | } 13 | echo "$br\n"; 14 | $function = 'confirm_' . $module . '_compiled'; 15 | if (extension_loaded($module)) { 16 | $str = $function($module); 17 | } else { 18 | $str = "Module $module is not compiled into PHP"; 19 | } 20 | echo "$str\n"; 21 | ?> 22 | -------------------------------------------------------------------------------- /tests/001.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for opencv presence 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | 20 | --EXPECT-- 21 | opencv extension is available 22 | -------------------------------------------------------------------------------- /examples/test_hist.php: -------------------------------------------------------------------------------- 1 | convertColor(Image::RGB2HSV); 8 | $planes = $hsv->split(); 9 | $hist = new Histogram(1, 32, CV_HIST_ARRAY); 10 | $hist->calc($planes[0]); 11 | 12 | /* Load the target image */ 13 | $i2 = Image::load("target.jpg", Image::LOAD_IMAGE_COLOR); 14 | $hsv2 = $i2->convertColor(Image::RGB2HSV); 15 | $planes2 = $hsv2->split(); 16 | $result = $planes2[0]->backProject($hist); 17 | 18 | /* Dilate the image to make the objects more obvious */ 19 | $result = $result->dilate(2); 20 | $result->save("back_project_output.jpg"); 21 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /.deps 2 | /Makefile 3 | /*.lo 4 | /*.loT 5 | /*.slo 6 | /*.mk 7 | /*.la 8 | /.libs 9 | /libs.mk 10 | /ac*.m4 11 | /build 12 | /config.h 13 | /config.h.in 14 | /config.h.in~ 15 | /config.nice 16 | /config.sub 17 | /configure 18 | /configure.in 19 | /config.status 20 | /config.cache 21 | /conftest 22 | /conftest.c 23 | /core 24 | /dynlib.m4 25 | /install-sh 26 | /ltmain.sh 27 | /include 28 | /Makefile.fragments 29 | /Makefile.global 30 | /Makefile.objects 31 | /missing 32 | /mkinstalldirs 33 | /modules 34 | /scan_makefile_in.awk 35 | /config.guess 36 | /*swp 37 | /config.log 38 | /libtool 39 | /Debug 40 | /Release 41 | /Debug_TS 42 | /Release_TS 43 | /*.plg 44 | /*.patch 45 | /*.tgz 46 | /*.ncb 47 | /*.opt 48 | /*.dsw 49 | /autom4te.cache 50 | /run-tests-config.php 51 | /run-tests.php 52 | /tmp-php.ini 53 | .svn 54 | -------------------------------------------------------------------------------- /opencv_error.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | +----------------------------------------------------------------------+ 3 | | PHP Version 5 | 4 | +----------------------------------------------------------------------+ 5 | | Copyright (c) 1997-2010 The PHP Group | 6 | +----------------------------------------------------------------------+ 7 | | This source file is subject to version 3.01 of the PHP license, | 8 | | that is bundled with this package in the file LICENSE, and is | 9 | | available through the world-wide-web at the following url: | 10 | | http://www.php.net/license/3_01.txt | 11 | | If you did not receive a copy of the PHP license and are unable to | 12 | | obtain it through the world-wide-web, please send a note to | 13 | | license@php.net so we can mail you a copy immediately. | 14 | +----------------------------------------------------------------------+ 15 | | Author: Michael Maclean | 16 | +----------------------------------------------------------------------+ 17 | */ 18 | 19 | /* $Id$ */ 20 | 21 | #ifdef HAVE_CONFIG_H 22 | #include "config.h" 23 | #endif 24 | 25 | #include "php_opencv.h" 26 | 27 | zend_class_entry *opencv_ce_cvexception; 28 | 29 | /* {{{ PHP_MINIT_FUNCTION */ 30 | PHP_MINIT_FUNCTION(opencv_error) 31 | { 32 | zend_class_entry ce, status_ce; 33 | 34 | INIT_NS_CLASS_ENTRY(ce, "OpenCV", "Exception", NULL); 35 | opencv_ce_cvexception = zend_register_internal_class_ex(&ce, zend_exception_get_default(TSRMLS_C), "Exception" TSRMLS_CC); 36 | 37 | return SUCCESS; 38 | } 39 | /* }}} */ 40 | 41 | PHP_OPENCV_API void php_opencv_throw_exception(TSRMLS_D) 42 | { 43 | char * error_message; 44 | int status = cvGetErrStatus(); 45 | 46 | if (status >= 0) { 47 | return; 48 | } 49 | 50 | error_message = estrdup(cvErrorStr(status)); 51 | zend_throw_exception(opencv_ce_cvexception, error_message, status TSRMLS_CC); 52 | efree(error_message); 53 | return; 54 | } 55 | 56 | /* 57 | * Local variables: 58 | * tab-width: 4 59 | * c-basic-offset: 4 60 | * End: 61 | * vim600: noet sw=4 ts=4 fdm=marker 62 | * vim<600: noet sw=4 ts=4 63 | */ 64 | -------------------------------------------------------------------------------- /config.m4: -------------------------------------------------------------------------------- 1 | dnl 2 | dnl $ Id: opencv 1.0.1$ 3 | dnl 4 | 5 | PHP_ARG_WITH(opencv, for OpenCV support, 6 | [ --with-opencv Enable OpenCV support], yes) 7 | 8 | if test "$PHP_OPENCV" != "no"; then 9 | export OLD_CPPFLAGS="$CPPFLAGS" 10 | export CPPFLAGS="$CPPFLAGS $INCLUDES -DHAVE_OPENCV" 11 | 12 | AC_MSG_CHECKING(PHP version) 13 | AC_TRY_COMPILE([#include ], [ 14 | #if PHP_VERSION_ID < 50200 15 | #error this extension requires at least PHP version 5.2.0 16 | #endif 17 | ], 18 | [AC_MSG_RESULT(ok)], 19 | [AC_MSG_ERROR([need at least PHP 5.2.0])]) 20 | 21 | export CPPFLAGS="$OLD_CPPFLAGS" 22 | 23 | PHP_REQUIRE_CXX() 24 | PHP_SUBST(OPENCV_SHARED_LIBADD) 25 | PHP_ADD_LIBRARY(stdc++, 1, OPENCV_SHARED_LIBADD) 26 | AC_DEFINE(HAVE_OPENCV, 1, [ ]) 27 | 28 | PHP_NEW_EXTENSION( 29 | opencv, 30 | opencv.cpp opencv_error.cpp opencv_mat.cpp opencv_image.cpp opencv_histogram.cpp opencv_capture.cpp, 31 | $ext_shared, 32 | , 33 | , 34 | "yes") 35 | 36 | EXT_OPENCV_HEADERS="php_opencv_api.h" 37 | 38 | ifdef([PHP_INSTALL_HEADERS], [ 39 | PHP_INSTALL_HEADERS(ext/opencv, $EXT_OPENCV_HEADERS) 40 | ]) 41 | 42 | if test "$PHP_OPENCV" != "no"; then 43 | OPENCV_CHECK_DIR=$PHP_OPENCV 44 | OPENCV_TEST_FILE=opencv/include/cv.h 45 | OPENCV_LIBNAME=opencv 46 | fi 47 | condition="$OPENCV_CHECK_DIR$OPENCV_TEST_FILE" 48 | 49 | if test -r $condition; then 50 | OPENCV_DIR=$OPENCV_CHECK_DIR 51 | CFLAGS="$CFLAGS -I$OPENCV_DIR/include" 52 | LDFLAGS=`$OPENCV_DIR/bin/opencv-config --libs` 53 | else 54 | AC_MSG_CHECKING(for pkg-config) 55 | 56 | if test ! -f "$PKG_CONFIG"; then 57 | PKG_CONFIG=`which pkg-config` 58 | fi 59 | 60 | if test -f "$PKG_CONFIG"; then 61 | AC_MSG_RESULT(found) 62 | AC_MSG_CHECKING(for opencv) 63 | 64 | if $PKG_CONFIG --exists opencv; then 65 | if $PKG_CONFIG --atleast-version=2.1.0 opencv; then 66 | opencv_version_full=`$PKG_CONFIG --modversion opencv` 67 | AC_MSG_RESULT([found $opencv_version_full]) 68 | OPENCV_LIBS="$LDFLAGS `$PKG_CONFIG --libs opencv`" 69 | OPENCV_INCS="$CFLAGS `$PKG_CONFIG --cflags-only-I opencv`" 70 | PHP_EVAL_INCLINE($OPENCV_INCS) 71 | PHP_EVAL_LIBLINE($OPENCV_LIBS, OPENCV_SHARED_LIBADD) 72 | AC_DEFINE(HAVE_OPENCV, 1, [whether opencv exists in the system]) 73 | else 74 | AC_MSG_RESULT(too old) 75 | AC_MSG_ERROR(Ooops ! You need at least opencv 2.1.0) 76 | fi 77 | else 78 | AC_MSG_RESULT(not found) 79 | AC_MSG_ERROR(Ooops ! no opencv detected in the system) 80 | fi 81 | else 82 | AC_MSG_RESULT(not found) 83 | AC_MSG_ERROR(Ooops ! no pkg-config found .... ) 84 | fi 85 | fi 86 | fi 87 | -------------------------------------------------------------------------------- /php_opencv.h: -------------------------------------------------------------------------------- 1 | /* 2 | +----------------------------------------------------------------------+ 3 | | PHP Version 5 | 4 | +----------------------------------------------------------------------+ 5 | | Copyright (c) 1997-2010 The PHP Group | 6 | +----------------------------------------------------------------------+ 7 | | This source file is subject to version 3.01 of the PHP license, | 8 | | that is bundled with this package in the file LICENSE, and is | 9 | | available through the world-wide-web at the following url: | 10 | | http://www.php.net/license/3_01.txt | 11 | | If you did not receive a copy of the PHP license and are unable to | 12 | | obtain it through the world-wide-web, please send a note to | 13 | | license@php.net so we can mail you a copy immediately. | 14 | +----------------------------------------------------------------------+ 15 | | Author: Michael Maclean | 16 | +----------------------------------------------------------------------+ 17 | */ 18 | 19 | /* $Id: header 297205 2010-03-30 21:09:07Z johannes $ */ 20 | 21 | #ifndef PHP_OPENCV_H 22 | #define PHP_OPENCV_H 23 | 24 | extern "C" { 25 | #include "php.h" 26 | #include "zend_exceptions.h" 27 | 28 | #ifdef ZTS 29 | #include "TSRM.h" 30 | #endif 31 | 32 | } 33 | 34 | extern zend_error_handling opencv_original_error_handling; 35 | extern zend_module_entry opencv_module_entry; 36 | #define phpext_opencv_ptr &opencv_module_entry 37 | 38 | 39 | #ifdef PHP_WIN32 40 | # define PHP_OPENCV_API __declspec(dllexport) 41 | #elif defined(__GNUC__) && __GNUC__ >= 4 42 | # define PHP_OPENCV_API __attribute__ ((visibility("default"))) 43 | #else 44 | # define PHP_OPENCV_API 45 | #endif 46 | 47 | /* Constants for open_basedir checks */ 48 | #define OPENCV_READ_WRITE_NO_ERROR 0 49 | #define OPENCV_READ_WRITE_SAFE_MODE_ERROR 1 50 | #define OPENCV_READ_WRITE_OPEN_BASEDIR_ERROR 2 51 | 52 | /* turn error handling to exception mode and restore */ 53 | #define PHP_OPENCV_ERROR_HANDLING() do { \ 54 | zend_replace_error_handling(EH_THROW, opencv_ce_cvexception, &opencv_original_error_handling TSRMLS_CC); \ 55 | } while(0) 56 | 57 | #define PHP_OPENCV_RESTORE_ERRORS() do { \ 58 | zend_restore_error_handling(&opencv_original_error_handling TSRMLS_CC); \ 59 | } while(0) 60 | 61 | #include 62 | #include 63 | 64 | using namespace cv; 65 | 66 | PHP_MINIT_FUNCTION(opencv); 67 | PHP_MINIT_FUNCTION(opencv_error); 68 | PHP_MINIT_FUNCTION(opencv_mat); 69 | PHP_MINIT_FUNCTION(opencv_image); 70 | PHP_MINIT_FUNCTION(opencv_histogram); 71 | PHP_MINIT_FUNCTION(opencv_capture); 72 | PHP_MSHUTDOWN_FUNCTION(opencv); 73 | PHP_MINFO_FUNCTION(opencv); 74 | PHP_RINIT_FUNCTION(opencv); 75 | 76 | extern zend_object_handlers opencv_std_object_handlers; 77 | extern zend_class_entry *opencv_ce_cvexception; 78 | extern zend_class_entry *opencv_ce_cvmat; 79 | extern zend_class_entry *opencv_ce_image; 80 | extern zend_class_entry *opencv_ce_histogram; 81 | 82 | 83 | typedef struct _opencv_mat_object { 84 | zend_object std; 85 | zend_bool constructed; 86 | Mat *cvptr; 87 | } opencv_mat_object; 88 | 89 | typedef struct _opencv_image_object { 90 | zend_object std; 91 | zend_bool constructed; 92 | IplImage *cvptr; 93 | } opencv_image_object; 94 | 95 | typedef struct _opencv_histogram_object { 96 | zend_object std; 97 | zend_bool constructed; 98 | CvHistogram *cvptr; 99 | } opencv_histogram_object; 100 | 101 | typedef struct _opencv_capture_object { 102 | zend_object std; 103 | zend_bool constructed; 104 | CvCapture* cvptr; 105 | } opencv_capture_object; 106 | 107 | 108 | PHP_OPENCV_API extern void php_opencv_throw_exception(TSRMLS_D); 109 | PHP_OPENCV_API void php_opencv_basedir_check(const char *filename TSRMLS_DC); 110 | PHP_OPENCV_API extern opencv_image_object* opencv_image_object_get(zval *zobj TSRMLS_DC); 111 | PHP_OPENCV_API extern opencv_histogram_object* opencv_histogram_object_get(zval *zobj TSRMLS_DC); 112 | PHP_OPENCV_API zval *php_opencv_make_image_zval(IplImage *image, zval *image_zval TSRMLS_DC); 113 | 114 | 115 | #ifdef ZTS 116 | #define OPENCV_G(v) TSRMG(opencv_globals_id, zend_opencv_globals *, v) 117 | #else 118 | #define OPENCV_G(v) (opencv_globals.v) 119 | #endif 120 | 121 | #endif /* PHP_OPENCV_H */ 122 | 123 | 124 | /* 125 | * Local variables: 126 | * tab-width: 4 127 | * c-basic-offset: 4 128 | * End: 129 | * vim600: noet sw=4 ts=4 fdm=marker 130 | * vim<600: noet sw=4 ts=4 131 | */ 132 | -------------------------------------------------------------------------------- /opencv.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | +----------------------------------------------------------------------+ 3 | | PHP Version 5 | 4 | +----------------------------------------------------------------------+ 5 | | Copyright (c) 1997-2010 The PHP Group | 6 | +----------------------------------------------------------------------+ 7 | | This source file is subject to version 3.01 of the PHP license, | 8 | | that is bundled with this package in the file LICENSE, and is | 9 | | available through the world-wide-web at the following url: | 10 | | http://www.php.net/license/3_01.txt | 11 | | If you did not receive a copy of the PHP license and are unable to | 12 | | obtain it through the world-wide-web, please send a note to | 13 | | license@php.net so we can mail you a copy immediately. | 14 | +----------------------------------------------------------------------+ 15 | | Author: Michael Maclean | 16 | +----------------------------------------------------------------------+ 17 | */ 18 | 19 | /* $Id$ */ 20 | 21 | #ifdef HAVE_CONFIG_H 22 | #include "config.h" 23 | #endif 24 | 25 | #include "php_opencv.h" 26 | 27 | extern "C" { 28 | #include "php_ini.h" 29 | #include "ext/standard/info.h" 30 | } 31 | 32 | /* If you declare any globals in php_opencv.h uncomment this: 33 | ZEND_DECLARE_MODULE_GLOBALS(opencv) 34 | */ 35 | 36 | /* True global resources - no need for thread safety here */ 37 | static int le_opencv; 38 | zend_error_handling opencv_original_error_handling; 39 | 40 | PHP_OPENCV_API void php_opencv_basedir_check(const char *filename TSRMLS_DC) { 41 | char *error_message; 42 | int status; 43 | 44 | #if PHP_VERSION_ID < 50400 45 | if (PG(safe_mode) && (!php_checkuid_ex(filename, NULL, CHECKUID_CHECK_FILE_AND_DIR, CHECKUID_NO_ERRORS))) { 46 | error_message = estrdup("Could not access file due to safe_mode restrictions"); 47 | zend_throw_exception(opencv_ce_cvexception, (char *) error_message, status TSRMLS_CC); 48 | efree(error_message); 49 | return; 50 | } 51 | #endif 52 | 53 | if (PG(open_basedir) && php_check_open_basedir_ex(filename, 0 TSRMLS_CC)) { 54 | error_message = estrdup("Could not access file due to open_basedir restrictions"); 55 | zend_throw_exception(opencv_ce_cvexception, error_message, status TSRMLS_CC); 56 | efree(error_message); 57 | return; 58 | } 59 | } 60 | 61 | zend_class_entry *opencv_ce_cv; 62 | /* {{{ proto void contruct() 63 | OpenCV CANNOT be extended in userspace, this will throw an exception on use */ 64 | PHP_METHOD(OpenCV, __construct) 65 | { 66 | zend_throw_exception(opencv_ce_cvexception, "OpenCV cannot be constructed", 0 TSRMLS_CC); 67 | } 68 | /* }}} */ 69 | 70 | /* {{{ opencv_functions[] 71 | * 72 | * Every user visible function must have an entry in opencv_functions[]. 73 | */ 74 | const zend_function_entry opencv_functions[] = { 75 | {NULL, NULL, NULL} /* Must be the last line in opencv_functions[] */ 76 | }; 77 | /* }}} */ 78 | 79 | /* {{{ opencv_module_entry 80 | */ 81 | zend_module_entry opencv_module_entry = { 82 | #if ZEND_MODULE_API_NO >= 20010901 83 | STANDARD_MODULE_HEADER, 84 | #endif 85 | "opencv", 86 | opencv_functions, 87 | PHP_MINIT(opencv), 88 | PHP_MSHUTDOWN(opencv), 89 | PHP_RINIT(opencv), 90 | NULL, 91 | PHP_MINFO(opencv), 92 | #if ZEND_MODULE_API_NO >= 20010901 93 | "0.1", /* Replace with version number for your extension */ 94 | #endif 95 | STANDARD_MODULE_PROPERTIES 96 | }; 97 | /* }}} */ 98 | 99 | #ifdef COMPILE_DL_OPENCV 100 | ZEND_GET_MODULE(opencv) 101 | #endif 102 | 103 | /* {{{ PHP_MINIT_FUNCTION 104 | */ 105 | PHP_MINIT_FUNCTION(opencv) 106 | { 107 | /* If you have INI entries, uncomment these lines 108 | REGISTER_INI_ENTRIES(); 109 | */ 110 | 111 | PHP_MINIT(opencv_error)(INIT_FUNC_ARGS_PASSTHRU); 112 | PHP_MINIT(opencv_mat)(INIT_FUNC_ARGS_PASSTHRU); 113 | PHP_MINIT(opencv_image)(INIT_FUNC_ARGS_PASSTHRU); 114 | PHP_MINIT(opencv_histogram)(INIT_FUNC_ARGS_PASSTHRU); 115 | PHP_MINIT(opencv_capture)(INIT_FUNC_ARGS_PASSTHRU); 116 | cvSetErrMode(CV_ErrModeSilent); 117 | return SUCCESS; 118 | } 119 | /* }}} */ 120 | 121 | /* {{{ PHP_MSHUTDOWN_FUNCTION 122 | */ 123 | PHP_MSHUTDOWN_FUNCTION(opencv) 124 | { 125 | /* uncomment this line if you have INI entries 126 | UNREGISTER_INI_ENTRIES(); 127 | */ 128 | return SUCCESS; 129 | } 130 | /* }}} */ 131 | 132 | /* {{{ PHP_RINIT_FUNCTION */ 133 | PHP_RINIT_FUNCTION(opencv) 134 | { 135 | cvSetErrMode(CV_ErrModeSilent); 136 | return SUCCESS; 137 | } 138 | 139 | /* {{{ PHP_MINFO_FUNCTION 140 | */ 141 | PHP_MINFO_FUNCTION(opencv) 142 | { 143 | php_info_print_table_start(); 144 | php_info_print_table_header(2, "OpenCV support", "Enabled"); 145 | php_info_print_table_row(2, "OpenCV library version", CV_VERSION); 146 | php_info_print_table_end(); 147 | 148 | /* Remove comments if you have entries in php.ini 149 | DISPLAY_INI_ENTRIES(); 150 | */ 151 | } 152 | /* }}} */ 153 | 154 | 155 | /* 156 | * Local variables: 157 | * tab-width: 4 158 | * c-basic-offset: 4 159 | * End: 160 | * vim600: noet sw=4 ts=4 fdm=marker 161 | * vim<600: noet sw=4 ts=4 162 | */ 163 | -------------------------------------------------------------------------------- /opencv_histogram.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | +----------------------------------------------------------------------+ 3 | | PHP Version 5 | 4 | +----------------------------------------------------------------------+ 5 | | Copyright (c) 1997-2010 The PHP Group | 6 | +----------------------------------------------------------------------+ 7 | | This source file is subject to version 3.01 of the PHP license, | 8 | | that is bundled with this package in the file LICENSE, and is | 9 | | available through the world-wide-web at the following url: | 10 | | http://www.php.net/license/3_01.txt | 11 | | If you did not receive a copy of the PHP license and are unable to | 12 | | obtain it through the world-wide-web, please send a note to | 13 | | license@php.net so we can mail you a copy immediately. | 14 | +----------------------------------------------------------------------+ 15 | | Author: Michael Maclean | 16 | +----------------------------------------------------------------------+ 17 | */ 18 | 19 | /* $Id$ */ 20 | 21 | #ifdef HAVE_CONFIG_H 22 | #include "config.h" 23 | #endif 24 | 25 | #include "php_opencv.h" 26 | 27 | zend_class_entry *opencv_ce_histogram; 28 | 29 | PHP_OPENCV_API opencv_histogram_object* opencv_histogram_object_get(zval *zobj TSRMLS_DC) { 30 | opencv_histogram_object *pobj = (opencv_histogram_object *) zend_object_store_get_object(zobj TSRMLS_CC); 31 | if (pobj->cvptr == NULL) { 32 | php_error(E_ERROR, "Internal surface object missing in %s wrapper, you must call parent::__construct in extended classes", Z_OBJCE_P(zobj)->name); 33 | } 34 | return pobj; 35 | } 36 | 37 | void opencv_histogram_object_destroy(void *object TSRMLS_DC) 38 | { 39 | opencv_histogram_object *histogram = (opencv_histogram_object *)object; 40 | 41 | zend_hash_destroy(histogram->std.properties); 42 | FREE_HASHTABLE(histogram->std.properties); 43 | 44 | if(histogram->cvptr != NULL){ 45 | cvReleaseHist(&histogram->cvptr); 46 | } 47 | efree(histogram); 48 | } 49 | 50 | PHP_OPENCV_API zend_object_value opencv_histogram_object_new(zend_class_entry *ce TSRMLS_DC) 51 | { 52 | zend_object_value retval; 53 | opencv_histogram_object *histogram; 54 | zval *temp; 55 | 56 | histogram = (opencv_histogram_object *) ecalloc(1, sizeof(opencv_histogram_object)); 57 | 58 | histogram->std.ce = ce; 59 | histogram->cvptr = NULL; 60 | 61 | ALLOC_HASHTABLE(histogram->std.properties); 62 | zend_hash_init(histogram->std.properties, 0, NULL, ZVAL_PTR_DTOR, 0); 63 | #if PHP_VERSION_ID < 50399 64 | zend_hash_copy(histogram->std.properties, &ce->default_properties, (copy_ctor_func_t) zval_add_ref,(void *) &temp, sizeof(zval *)); 65 | #else 66 | object_properties_init(&histogram->std, ce); 67 | #endif 68 | retval.handle = zend_objects_store_put(histogram, NULL, (zend_objects_free_object_storage_t)opencv_histogram_object_destroy, NULL TSRMLS_CC); 69 | retval.handlers = zend_get_std_object_handlers(); 70 | return retval; 71 | } 72 | 73 | PHP_METHOD(OpenCV_Histogram, __construct) 74 | { 75 | long bins, sizes, type, uniform; 76 | zval *ranges; 77 | opencv_histogram_object *histogram_object; 78 | CvHistogram *temp; 79 | int cast_sizes; 80 | 81 | PHP_OPENCV_ERROR_HANDLING(); 82 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll|al", &bins, &sizes, &type, &ranges, &uniform) == FAILURE) 83 | { 84 | PHP_OPENCV_RESTORE_ERRORS(); 85 | return; 86 | } 87 | PHP_OPENCV_RESTORE_ERRORS(); 88 | 89 | cast_sizes = sizes; 90 | 91 | temp = cvCreateHist(bins, &cast_sizes, type, NULL, 1); 92 | histogram_object = (opencv_histogram_object *) zend_object_store_get_object(getThis() TSRMLS_CC); 93 | histogram_object->cvptr = temp; 94 | 95 | php_opencv_throw_exception(TSRMLS_C); 96 | } 97 | /* }}} */ 98 | 99 | PHP_METHOD(OpenCV_Histogram, calc) 100 | { 101 | zval *hist_zval, *image_zval; 102 | opencv_histogram_object *hist_object; 103 | opencv_image_object *image_object; 104 | long accumulate = 0; 105 | 106 | PHP_OPENCV_ERROR_HANDLING(); 107 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO|l", &hist_zval, opencv_ce_histogram, &image_zval, opencv_ce_image) == FAILURE) 108 | { 109 | PHP_OPENCV_RESTORE_ERRORS(); 110 | return; 111 | } 112 | PHP_OPENCV_ERROR_HANDLING(); 113 | 114 | hist_object = opencv_histogram_object_get(getThis() TSRMLS_CC); 115 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 116 | cvCalcHist(&image_object->cvptr, hist_object->cvptr, accumulate, NULL); 117 | 118 | php_opencv_throw_exception(TSRMLS_C); 119 | } 120 | 121 | /* {{{ opencv_histogram_methods[] */ 122 | const zend_function_entry opencv_histogram_methods[] = { 123 | PHP_ME(OpenCV_Histogram, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) 124 | PHP_ME(OpenCV_Histogram, calc, NULL, ZEND_ACC_PUBLIC) 125 | {NULL, NULL, NULL} 126 | }; 127 | /* }}} */ 128 | 129 | /* {{{ PHP_MINIT_FUNCTION */ 130 | PHP_MINIT_FUNCTION(opencv_histogram) 131 | { 132 | zend_class_entry ce; 133 | 134 | INIT_NS_CLASS_ENTRY(ce, "OpenCV", "Histogram", opencv_histogram_methods); 135 | opencv_ce_histogram = zend_register_internal_class(&ce TSRMLS_CC); 136 | 137 | #define REGISTER_HIST_LONG_CONST(const_name, value) \ 138 | zend_declare_class_constant_long(opencv_ce_histogram, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC); \ 139 | REGISTER_LONG_CONSTANT(#value, value, CONST_CS | CONST_PERSISTENT); 140 | 141 | REGISTER_HIST_LONG_CONST("TYPE_SPARSE", CV_HIST_SPARSE); 142 | REGISTER_HIST_LONG_CONST("TYPE_ARRAY", CV_HIST_ARRAY); 143 | 144 | return SUCCESS; 145 | } 146 | /* }}} */ 147 | -------------------------------------------------------------------------------- /opencv_mat.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | +----------------------------------------------------------------------+ 3 | | PHP Version 5 | 4 | +----------------------------------------------------------------------+ 5 | | Copyright (c) 1997-2010 The PHP Group | 6 | +----------------------------------------------------------------------+ 7 | | This source file is subject to version 3.01 of the PHP license, | 8 | | that is bundled with this package in the file LICENSE, and is | 9 | | available through the world-wide-web at the following url: | 10 | | http://www.php.net/license/3_01.txt | 11 | | If you did not receive a copy of the PHP license and are unable to | 12 | | obtain it through the world-wide-web, please send a note to | 13 | | license@php.net so we can mail you a copy immediately. | 14 | +----------------------------------------------------------------------+ 15 | | Author: Michael Maclean | 16 | +----------------------------------------------------------------------+ 17 | */ 18 | 19 | /* $Id$ */ 20 | 21 | #ifdef HAVE_CONFIG_H 22 | #include "config.h" 23 | #endif 24 | 25 | #include "php_opencv.h" 26 | 27 | zend_class_entry *opencv_ce_cvmat; 28 | 29 | static inline opencv_mat_object* opencv_mat_object_get(zval *zobj TSRMLS_DC) { 30 | opencv_mat_object *pobj = (opencv_mat_object *) zend_object_store_get_object(zobj TSRMLS_CC); 31 | if (pobj->cvptr->empty()) { 32 | php_error(E_ERROR, "Internal surface object missing in %s wrapper, you must call parent::__construct in extended classes", Z_OBJCE_P(zobj)->name); 33 | } 34 | return pobj; 35 | } 36 | 37 | #define PHP_OPENCV_ADD_MAT_LONG_PROPERTY(PROPERTY, MEMBER) \ 38 | do { \ 39 | zval *temp_prop; \ 40 | MAKE_STD_ZVAL(temp_prop); \ 41 | ZVAL_LONG(temp_prop, MEMBER); \ 42 | zend_hash_update(Z_OBJPROP_P(mat_zval), PROPERTY, sizeof(PROPERTY), (void **) &temp_prop, sizeof(zval *), NULL); \ 43 | } while(0) 44 | 45 | /* 46 | PHP_OPENCV_API zval *php_opencv_make_mat_zval(Mat mat, zval *mat_zval TSRMLS_DC) { 47 | zval *return_value, *width, *height; 48 | opencv_mat_object *mat_obj; 49 | 50 | if (mat_zval == NULL) { 51 | MAKE_STD_ZVAL(mat_zval); 52 | } 53 | 54 | object_init_ex(mat_zval, opencv_ce_cvmat); 55 | mat_obj = (opencv_mat_object *) zend_object_store_get_object(mat_zval TSRMLS_CC); 56 | mat_obj->cvptr = &mat; 57 | 58 | PHP_OPENCV_ADD_MAT_LONG_PROPERTY("cols", mat.cols); 59 | PHP_OPENCV_ADD_MAT_LONG_PROPERTY("rows", mat.rows); 60 | PHP_OPENCV_ADD_MAT_LONG_PROPERTY("channels", mat.channels()); 61 | // PHP_OPENCV_ADD_MAT_LONG_PROPERTY("alphaChannel", mat.alphaChannel); 62 | PHP_OPENCV_ADD_MAT_LONG_PROPERTY("depth", mat.depth()); 63 | 64 | return mat_zval; 65 | } 66 | */ 67 | 68 | static void opencv_mat_object_assign_properties(zval *mat_zval TSRMLS_DC) { 69 | opencv_mat_object *mat_obj; 70 | mat_obj = (opencv_mat_object *) zend_object_store_get_object(mat_zval TSRMLS_CC); 71 | 72 | PHP_OPENCV_ADD_MAT_LONG_PROPERTY("cols", mat_obj->cvptr->cols); 73 | PHP_OPENCV_ADD_MAT_LONG_PROPERTY("rows", mat_obj->cvptr->rows); 74 | PHP_OPENCV_ADD_MAT_LONG_PROPERTY("channels", mat_obj->cvptr->channels()); 75 | // PHP_OPENCV_ADD_MAT_LONG_PROPERTY("alphaChannel", mat_obj->cvptr.alphaChannel); 76 | PHP_OPENCV_ADD_MAT_LONG_PROPERTY("depth", mat_obj->cvptr->depth()); 77 | } 78 | 79 | void opencv_mat_object_destroy(void *object TSRMLS_DC) 80 | { 81 | opencv_mat_object *mat = (opencv_mat_object *)object; 82 | //delete mat->cvptr; 83 | zend_hash_destroy(mat->std.properties); 84 | FREE_HASHTABLE(mat->std.properties); 85 | 86 | /* 87 | if(mat->cvptr != NULL){ 88 | cvRelease((void **) &mat->cvptr); 89 | } 90 | */ 91 | efree(mat); 92 | } 93 | 94 | static zend_object_value opencv_mat_object_new(zend_class_entry *ce TSRMLS_DC) 95 | { 96 | zend_object_value retval; 97 | opencv_mat_object *mat; 98 | zval *temp; 99 | 100 | mat = (opencv_mat_object *) ecalloc(1, sizeof(opencv_mat_object)); 101 | 102 | mat->std.ce = ce; 103 | //mat->cvptr = NULL; 104 | 105 | ALLOC_HASHTABLE(mat->std.properties); 106 | zend_hash_init(mat->std.properties, 0, NULL, ZVAL_PTR_DTOR, 0); 107 | #if PHP_VERSION_ID < 50399 108 | zend_hash_copy(mat->std.properties, &ce->default_properties, (copy_ctor_func_t) zval_add_ref,(void *) &temp, sizeof(zval *)); 109 | #else 110 | object_properties_init(&mat->std, ce); 111 | #endif 112 | retval.handle = zend_objects_store_put(mat, NULL, (zend_objects_free_object_storage_t)opencv_mat_object_destroy, NULL TSRMLS_CC); 113 | retval.handlers = zend_get_std_object_handlers(); 114 | return retval; 115 | } 116 | 117 | /* {{{ proto void contruct() 118 | OpenCV_Mat CANNOT be extended in userspace, this will throw an exception on use */ 119 | PHP_METHOD(OpenCV_Mat, __construct) 120 | { 121 | long rows, cols, type; 122 | opencv_mat_object *object; 123 | 124 | PHP_OPENCV_ERROR_HANDLING(); 125 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &rows, &cols, &type) == FAILURE) { 126 | PHP_OPENCV_RESTORE_ERRORS(); 127 | return; 128 | } 129 | PHP_OPENCV_RESTORE_ERRORS(); 130 | 131 | object = (opencv_mat_object *) zend_object_store_get_object(getThis() TSRMLS_CC); 132 | object->cvptr = new Mat(rows, cols, type); 133 | opencv_mat_object_assign_properties(getThis() TSRMLS_CC); 134 | php_opencv_throw_exception(TSRMLS_C); 135 | } 136 | /* }}} */ 137 | 138 | PHP_METHOD(OpenCV_Mat, load) { 139 | Mat temp; 140 | char *filename; 141 | int filename_len; 142 | long mode = 0; 143 | opencv_mat_object *mat_obj; 144 | 145 | PHP_OPENCV_ERROR_HANDLING(); 146 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &filename, &filename_len, &mode) == FAILURE) { 147 | PHP_OPENCV_RESTORE_ERRORS(); 148 | return; 149 | } 150 | PHP_OPENCV_RESTORE_ERRORS(); 151 | 152 | php_opencv_basedir_check(filename TSRMLS_CC); 153 | 154 | object_init_ex(return_value, opencv_ce_cvmat); 155 | mat_obj = (opencv_mat_object *) zend_object_store_get_object(return_value TSRMLS_CC); 156 | 157 | temp = imread(filename, mode); 158 | if (temp.empty()) { 159 | char *error_message = estrdup("Could not open the video file - check it exists and the codec is available"); 160 | zend_throw_exception(opencv_ce_cvexception, error_message, 0 TSRMLS_CC); 161 | efree(error_message); 162 | return; 163 | } 164 | 165 | // I'm sure there's a neater way to do this 166 | mat_obj->cvptr = new Mat(temp); 167 | opencv_mat_object_assign_properties(return_value TSRMLS_CC); 168 | 169 | php_opencv_throw_exception(TSRMLS_C); 170 | } 171 | 172 | PHP_METHOD(OpenCV_Mat, save) { 173 | opencv_mat_object *mat_object; 174 | zval *mat_zval = NULL; 175 | char *filename; 176 | int filename_len, cast_mode; 177 | bool status; 178 | long mode = 0; 179 | 180 | PHP_OPENCV_ERROR_HANDLING(); 181 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|l", &mat_zval, opencv_ce_cvmat, &filename, &filename_len, &mode) == FAILURE) { 182 | PHP_OPENCV_RESTORE_ERRORS(); 183 | return; 184 | } 185 | PHP_OPENCV_RESTORE_ERRORS(); 186 | 187 | mat_object = opencv_mat_object_get(getThis() TSRMLS_CC); 188 | cast_mode = mode; 189 | status = imwrite(filename, *mat_object->cvptr); 190 | php_opencv_throw_exception(TSRMLS_C); 191 | 192 | if (!status) { 193 | zend_throw_exception(opencv_ce_cvexception, "Failed to save image", 0 TSRMLS_CC); 194 | } 195 | } 196 | 197 | /* {{{ opencv_mat_methods[] */ 198 | const zend_function_entry opencv_mat_methods[] = { 199 | PHP_ME(OpenCV_Mat, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) 200 | PHP_ME(OpenCV_Mat, load, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) 201 | PHP_ME(OpenCV_Mat, save, NULL, ZEND_ACC_PUBLIC) 202 | {NULL, NULL, NULL} 203 | }; 204 | /* }}} */ 205 | 206 | /* {{{ PHP_MINIT_FUNCTION */ 207 | PHP_MINIT_FUNCTION(opencv_mat) 208 | { 209 | zend_class_entry ce; 210 | 211 | INIT_NS_CLASS_ENTRY(ce, "OpenCV", "Mat", opencv_mat_methods); 212 | opencv_ce_cvmat = zend_register_internal_class(&ce TSRMLS_CC); 213 | 214 | return SUCCESS; 215 | } 216 | /* }}} */ 217 | 218 | 219 | -------------------------------------------------------------------------------- /opencv_capture.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | +----------------------------------------------------------------------+ 3 | | PHP Version 5 | 4 | +----------------------------------------------------------------------+ 5 | | Copyright (c) 1997-2010 The PHP Group | 6 | +----------------------------------------------------------------------+ 7 | | This source file is subject to version 3.01 of the PHP license, | 8 | | that is bundled with this package in the file LICENSE, and is | 9 | | available through the world-wide-web at the following url: | 10 | | http://www.php.net/license/3_01.txt | 11 | | If you did not receive a copy of the PHP license and are unable to | 12 | | obtain it through the world-wide-web, please send a note to | 13 | | license@php.net so we can mail you a copy immediately. | 14 | +----------------------------------------------------------------------+ 15 | | Author: Michael Maclean | 16 | +----------------------------------------------------------------------+ 17 | */ 18 | 19 | /* $Id$ */ 20 | 21 | #ifdef HAVE_CONFIG_H 22 | #include "config.h" 23 | #endif 24 | 25 | #include "php_opencv.h" 26 | 27 | zend_class_entry *opencv_ce_capture; 28 | 29 | PHP_OPENCV_API opencv_capture_object* opencv_capture_object_get(zval *zobj TSRMLS_DC) { 30 | opencv_capture_object *pobj = (opencv_capture_object *) zend_object_store_get_object(zobj TSRMLS_CC); 31 | if (pobj->cvptr == NULL) { 32 | php_error(E_ERROR, "Internal surface object missing in %s wrapper, you must call parent::__construct in extended classes", Z_OBJCE_P(zobj)->name); 33 | } 34 | return pobj; 35 | } 36 | 37 | void opencv_capture_object_destroy(void *object TSRMLS_DC) 38 | { 39 | opencv_capture_object *capture = (opencv_capture_object *)object; 40 | 41 | zend_hash_destroy(capture->std.properties); 42 | FREE_HASHTABLE(capture->std.properties); 43 | 44 | if(capture->cvptr != NULL){ 45 | cvReleaseCapture(&capture->cvptr); 46 | } 47 | efree(capture); 48 | } 49 | 50 | PHP_OPENCV_API zend_object_value opencv_capture_object_new(zend_class_entry *ce TSRMLS_DC) 51 | { 52 | zend_object_value retval; 53 | opencv_capture_object *capture; 54 | zval *temp; 55 | 56 | capture = (opencv_capture_object *) ecalloc(1, sizeof(opencv_capture_object)); 57 | 58 | capture->std.ce = ce; 59 | capture->cvptr = NULL; 60 | 61 | ALLOC_HASHTABLE(capture->std.properties); 62 | zend_hash_init(capture->std.properties, 0, NULL, ZVAL_PTR_DTOR, 0); 63 | #if PHP_VERSION_ID < 50399 64 | zend_hash_copy(capture->std.properties, &ce->default_properties, (copy_ctor_func_t) zval_add_ref,(void *) &temp, sizeof(zval *)); 65 | #else 66 | object_properties_init(&capture->std, ce); 67 | #endif 68 | retval.handle = zend_objects_store_put(capture, NULL, (zend_objects_free_object_storage_t)opencv_capture_object_destroy, NULL TSRMLS_CC); 69 | retval.handlers = zend_get_std_object_handlers(); 70 | return retval; 71 | } 72 | 73 | PHP_METHOD(OpenCV_Capture, createCameraCapture) 74 | { 75 | long camera; 76 | opencv_capture_object *capture_object; 77 | CvCapture *temp; 78 | 79 | PHP_OPENCV_ERROR_HANDLING(); 80 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &camera) == FAILURE) 81 | { 82 | PHP_OPENCV_RESTORE_ERRORS(); 83 | return; 84 | } 85 | PHP_OPENCV_RESTORE_ERRORS(); 86 | 87 | object_init_ex(return_value, opencv_ce_capture); 88 | temp = (CvCapture *) cvCaptureFromCAM(camera); 89 | capture_object = (opencv_capture_object *) zend_object_store_get_object(return_value TSRMLS_CC); 90 | capture_object->cvptr = temp; 91 | 92 | php_opencv_throw_exception(TSRMLS_C); 93 | } 94 | /* }}} */ 95 | 96 | PHP_METHOD(OpenCV_Capture, createFileCapture) 97 | { 98 | const char *filename; 99 | int filename_len; 100 | opencv_capture_object *capture_object; 101 | CvCapture *temp; 102 | 103 | PHP_OPENCV_ERROR_HANDLING(); 104 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) 105 | { 106 | PHP_OPENCV_RESTORE_ERRORS(); 107 | return; 108 | } 109 | PHP_OPENCV_RESTORE_ERRORS(); 110 | 111 | php_opencv_basedir_check(filename TSRMLS_CC); 112 | 113 | object_init_ex(return_value, opencv_ce_capture); 114 | capture_object = (opencv_capture_object *) zend_object_store_get_object(return_value TSRMLS_CC); 115 | temp = (CvCapture *) cvCreateFileCapture(filename); 116 | 117 | if (temp == NULL) { 118 | char *error_message = estrdup("Could not open the video file - check it exists and the codec is available"); 119 | zend_throw_exception(opencv_ce_cvexception, error_message, 0 TSRMLS_CC); 120 | efree(error_message); 121 | return; 122 | } 123 | 124 | capture_object->cvptr = temp; 125 | php_opencv_throw_exception(TSRMLS_C); 126 | } 127 | /* }}} */ 128 | 129 | PHP_METHOD(OpenCV_Capture, grabFrame) 130 | { 131 | zval *capture_zval; 132 | opencv_capture_object *capture_object; 133 | 134 | PHP_OPENCV_ERROR_HANDLING(); 135 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &capture_zval, opencv_ce_capture) == FAILURE) 136 | { 137 | PHP_OPENCV_RESTORE_ERRORS(); 138 | return; 139 | } 140 | PHP_OPENCV_ERROR_HANDLING(); 141 | 142 | capture_object = opencv_capture_object_get(getThis() TSRMLS_CC); 143 | long result = cvGrabFrame(capture_object->cvptr); 144 | 145 | php_opencv_throw_exception(TSRMLS_C); 146 | RETURN_LONG(result); 147 | } 148 | 149 | PHP_METHOD(OpenCV_Capture, retrieveFrame) 150 | { 151 | zval *capture_zval; 152 | opencv_capture_object *capture_object; 153 | IplImage *temp; 154 | 155 | PHP_OPENCV_ERROR_HANDLING(); 156 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &capture_zval, opencv_ce_capture) == FAILURE) 157 | { 158 | PHP_OPENCV_RESTORE_ERRORS(); 159 | return; 160 | } 161 | PHP_OPENCV_ERROR_HANDLING(); 162 | 163 | capture_object = opencv_capture_object_get(getThis() TSRMLS_CC); 164 | temp = cvCloneImage(cvRetrieveFrame(capture_object->cvptr, 0)); 165 | php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 166 | 167 | php_opencv_throw_exception(TSRMLS_C); 168 | } 169 | 170 | PHP_METHOD(OpenCV_Capture, queryFrame) 171 | { 172 | zval *capture_zval; 173 | opencv_capture_object *capture_object; 174 | IplImage *temp; 175 | 176 | PHP_OPENCV_ERROR_HANDLING(); 177 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &capture_zval, opencv_ce_capture) == FAILURE) 178 | { 179 | PHP_OPENCV_RESTORE_ERRORS(); 180 | return; 181 | } 182 | PHP_OPENCV_ERROR_HANDLING(); 183 | 184 | capture_object = opencv_capture_object_get(getThis() TSRMLS_CC); 185 | temp = cvCloneImage(cvQueryFrame(capture_object->cvptr)); 186 | php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 187 | 188 | php_opencv_throw_exception(TSRMLS_C); 189 | } 190 | 191 | PHP_METHOD(OpenCV_Capture, getProperty) 192 | { 193 | zval *capture_zval; 194 | opencv_capture_object *capture_object; 195 | IplImage *temp; 196 | double val; 197 | long property; 198 | 199 | PHP_OPENCV_ERROR_HANDLING(); 200 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &capture_zval, opencv_ce_capture, &property) == FAILURE) 201 | { 202 | PHP_OPENCV_RESTORE_ERRORS(); 203 | return; 204 | } 205 | PHP_OPENCV_ERROR_HANDLING(); 206 | 207 | capture_object = opencv_capture_object_get(getThis() TSRMLS_CC); 208 | val = cvGetCaptureProperty(capture_object->cvptr, property); 209 | php_opencv_throw_exception(TSRMLS_C); 210 | 211 | /* FourCC is special */ 212 | if (property == CV_CAP_PROP_FOURCC) { 213 | char *unpacked_val = (char *) &val; 214 | RETURN_STRING(unpacked_val, 1); 215 | } 216 | RETURN_LONG(val); 217 | } 218 | 219 | PHP_METHOD(OpenCV_Capture, setProperty) 220 | { 221 | zval *capture_zval; 222 | opencv_capture_object *capture_object; 223 | IplImage *temp; 224 | double val; 225 | long property; 226 | 227 | PHP_OPENCV_ERROR_HANDLING(); 228 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Old", &capture_zval, opencv_ce_capture, &property, &val) == FAILURE) 229 | { 230 | PHP_OPENCV_RESTORE_ERRORS(); 231 | return; 232 | } 233 | PHP_OPENCV_ERROR_HANDLING(); 234 | 235 | capture_object = opencv_capture_object_get(getThis() TSRMLS_CC); 236 | val = cvSetCaptureProperty(capture_object->cvptr, property, val); 237 | php_opencv_throw_exception(TSRMLS_C); 238 | } 239 | 240 | /* {{{ opencv_capture_methods[] */ 241 | const zend_function_entry opencv_capture_methods[] = { 242 | PHP_ME(OpenCV_Capture, createCameraCapture, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) 243 | PHP_ME(OpenCV_Capture, createFileCapture, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) 244 | PHP_ME(OpenCV_Capture, grabFrame, NULL, ZEND_ACC_PUBLIC) 245 | PHP_ME(OpenCV_Capture, retrieveFrame, NULL, ZEND_ACC_PUBLIC) 246 | PHP_ME(OpenCV_Capture, queryFrame, NULL, ZEND_ACC_PUBLIC) 247 | PHP_ME(OpenCV_Capture, getProperty, NULL, ZEND_ACC_PUBLIC) 248 | PHP_ME(OpenCV_Capture, setProperty, NULL, ZEND_ACC_PUBLIC) 249 | {NULL, NULL, NULL} 250 | }; 251 | /* }}} */ 252 | 253 | /* {{{ PHP_MINIT_FUNCTION */ 254 | PHP_MINIT_FUNCTION(opencv_capture) 255 | { 256 | zend_class_entry ce; 257 | 258 | INIT_NS_CLASS_ENTRY(ce, "OpenCV", "Capture", opencv_capture_methods); 259 | opencv_ce_capture = zend_register_internal_class(&ce TSRMLS_CC); 260 | 261 | #define REGISTER_CAPTURE_LONG_CONST(const_name, value) \ 262 | zend_declare_class_constant_long(opencv_ce_capture, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC); \ 263 | REGISTER_LONG_CONSTANT(#value, value, CONST_CS | CONST_PERSISTENT); 264 | 265 | REGISTER_CAPTURE_LONG_CONST("PROP_POS_MSEC", CV_CAP_PROP_POS_MSEC); 266 | REGISTER_CAPTURE_LONG_CONST("PROP_POS_FRAMES", CV_CAP_PROP_POS_FRAMES); 267 | REGISTER_CAPTURE_LONG_CONST("PROP_POS_AVI_RATIO", CV_CAP_PROP_POS_AVI_RATIO); 268 | REGISTER_CAPTURE_LONG_CONST("PROP_FRAME_WIDTH", CV_CAP_PROP_FRAME_WIDTH); 269 | REGISTER_CAPTURE_LONG_CONST("PROP_FRAME_HEIGHT", CV_CAP_PROP_FRAME_HEIGHT); 270 | REGISTER_CAPTURE_LONG_CONST("PROP_FPS", CV_CAP_PROP_FPS); 271 | REGISTER_CAPTURE_LONG_CONST("PROP_FOURCC", CV_CAP_PROP_FOURCC); 272 | REGISTER_CAPTURE_LONG_CONST("PROP_FRAME_COUNT", CV_CAP_PROP_FRAME_COUNT); 273 | REGISTER_CAPTURE_LONG_CONST("PROP_FORMAT", CV_CAP_PROP_FORMAT); 274 | REGISTER_CAPTURE_LONG_CONST("PROP_MODE", CV_CAP_PROP_MODE); 275 | REGISTER_CAPTURE_LONG_CONST("PROP_BRIGHTNESS", CV_CAP_PROP_BRIGHTNESS); 276 | REGISTER_CAPTURE_LONG_CONST("PROP_CONTRAST", CV_CAP_PROP_CONTRAST); 277 | REGISTER_CAPTURE_LONG_CONST("PROP_SATURATION", CV_CAP_PROP_SATURATION); 278 | REGISTER_CAPTURE_LONG_CONST("PROP_HUE", CV_CAP_PROP_HUE); 279 | REGISTER_CAPTURE_LONG_CONST("PROP_GAIN", CV_CAP_PROP_GAIN); 280 | REGISTER_CAPTURE_LONG_CONST("PROP_EXPOSURE", CV_CAP_PROP_EXPOSURE); 281 | REGISTER_CAPTURE_LONG_CONST("PROP_CONVERT_RGB", CV_CAP_PROP_CONVERT_RGB); 282 | 283 | #ifdef CV_CAP_PROP_WHITE_BALANCE 284 | REGISTER_CAPTURE_LONG_CONST("PROP_WHITE_BALANCE", CV_CAP_PROP_WHITE_BALANCE); 285 | #endif 286 | 287 | #ifdef CV_CAP_PROP_WHITE_BALANCE_BLUE_U 288 | REGISTER_CAPTURE_LONG_CONST("PROP_WHITE_BALANCE_BLUE_U", CV_CAP_PROP_WHITE_BALANCE_BLUE_U); 289 | #endif 290 | 291 | REGISTER_CAPTURE_LONG_CONST("PROP_RECTIFICATION", CV_CAP_PROP_RECTIFICATION); 292 | 293 | #ifdef CV_CAP_PROP_MONOCROME 294 | REGISTER_CAPTURE_LONG_CONST("PROP_MONOCHROME", CV_CAP_PROP_MONOCROME); 295 | #endif 296 | 297 | #ifdef CV_CAP_PROP_SHARPNESS 298 | REGISTER_CAPTURE_LONG_CONST("PROP_SHARPNESS", CV_CAP_PROP_SHARPNESS); 299 | #endif 300 | 301 | #ifdef CV_CAP_PROP_AUTO_EXPOSURE 302 | REGISTER_CAPTURE_LONG_CONST("PROP_AUTO_EXPOSURE", CV_CAP_PROP_AUTO_EXPOSURE); 303 | #endif 304 | 305 | #ifdef CV_CAP_PROP_GAMMA 306 | REGISTER_CAPTURE_LONG_CONST("PROP_GAMMA", CV_CAP_PROP_GAMMA); 307 | #endif 308 | 309 | #ifdef CV_CAP_PROP_TEMPERATURE 310 | REGISTER_CAPTURE_LONG_CONST("PROP_TEMPERATURE", CV_CAP_PROP_TEMPERATURE); 311 | #endif 312 | 313 | #ifdef CV_CAP_PROP_GAMMA 314 | REGISTER_CAPTURE_LONG_CONST("PROP_GAMMA", CV_CAP_PROP_GAMMA); 315 | #endif 316 | 317 | #ifdef CV_CAP_PROP_TRIGGER 318 | REGISTER_CAPTURE_LONG_CONST("PROP_TRIGGER", CV_CAP_PROP_TRIGGER); 319 | #endif 320 | 321 | #ifdef CV_CAP_PROP_TRIGGER_DELAY 322 | REGISTER_CAPTURE_LONG_CONST("PROP_TRIGGER_DELAY", CV_CAP_PROP_TRIGGER_DELAY); 323 | #endif 324 | 325 | #ifdef CV_CAP_PROP_WHITE_BALANCE_RED_V 326 | REGISTER_CAPTURE_LONG_CONST("PROP_WHITE_BALANCE_RED_V", CV_CAP_PROP_WHITE_BALANCE_RED_V); 327 | #endif 328 | 329 | #ifdef CV_CAP_PROP_MAX_DC1394 330 | REGISTER_CAPTURE_LONG_CONST("PROP_MAX_DC1394", CV_CAP_PROP_MAX_DC1394); 331 | #endif 332 | 333 | return SUCCESS; 334 | } 335 | /* }}} */ 336 | -------------------------------------------------------------------------------- /opencv_image.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | +----------------------------------------------------------------------+ 3 | | PHP Version 5 | 4 | +----------------------------------------------------------------------+ 5 | | Copyright (c) 1997-2010 The PHP Group | 6 | +----------------------------------------------------------------------+ 7 | | This source file is subject to version 3.01 of the PHP license, | 8 | | that is bundled with this package in the file LICENSE, and is | 9 | | available through the world-wide-web at the following url: | 10 | | http://www.php.net/license/3_01.txt | 11 | | If you did not receive a copy of the PHP license and are unable to | 12 | | obtain it through the world-wide-web, please send a note to | 13 | | license@php.net so we can mail you a copy immediately. | 14 | +----------------------------------------------------------------------+ 15 | | Author: Michael Maclean | 16 | +----------------------------------------------------------------------+ 17 | */ 18 | 19 | /* $Id$ */ 20 | 21 | #ifdef HAVE_CONFIG_H 22 | #include "config.h" 23 | #endif 24 | 25 | #include "php_opencv.h" 26 | 27 | zend_class_entry *opencv_ce_image; 28 | 29 | PHP_OPENCV_API opencv_image_object* opencv_image_object_get(zval *zobj TSRMLS_DC) { 30 | opencv_image_object *pobj = (opencv_image_object *) zend_object_store_get_object(zobj TSRMLS_CC); 31 | if (pobj->cvptr == NULL) { 32 | php_error(E_ERROR, "Internal surface object missing in %s wrapper, you must call parent::__construct in extended classes", Z_OBJCE_P(zobj)->name); 33 | } 34 | return pobj; 35 | } 36 | 37 | #define PHP_OPENCV_ADD_IMAGE_LONG_PROPERTY(PROPERTY, MEMBER) \ 38 | do { \ 39 | zval *temp_prop; \ 40 | MAKE_STD_ZVAL(temp_prop); \ 41 | ZVAL_LONG(temp_prop, MEMBER); \ 42 | zend_hash_update(Z_OBJPROP_P(image_zval), PROPERTY, sizeof(PROPERTY), (void **) &temp_prop, sizeof(zval *), NULL); \ 43 | } while(0) 44 | 45 | 46 | PHP_OPENCV_API zval *php_opencv_make_image_zval(IplImage *image, zval *image_zval TSRMLS_DC) { 47 | zval *return_value, *width, *height; 48 | opencv_image_object *image_obj; 49 | 50 | if (image_zval == NULL) { 51 | MAKE_STD_ZVAL(image_zval); 52 | } 53 | 54 | object_init_ex(image_zval, opencv_ce_image); 55 | image_obj = (opencv_image_object *) zend_object_store_get_object(image_zval TSRMLS_CC); 56 | image_obj->cvptr = image; 57 | 58 | PHP_OPENCV_ADD_IMAGE_LONG_PROPERTY("width", image->width); 59 | PHP_OPENCV_ADD_IMAGE_LONG_PROPERTY("height", image->height); 60 | PHP_OPENCV_ADD_IMAGE_LONG_PROPERTY("nChannels", image->nChannels); 61 | PHP_OPENCV_ADD_IMAGE_LONG_PROPERTY("alphaChannel", image->alphaChannel); 62 | PHP_OPENCV_ADD_IMAGE_LONG_PROPERTY("depth", image->depth); 63 | 64 | return image_zval; 65 | } 66 | 67 | void opencv_image_object_destroy(void *object TSRMLS_DC) 68 | { 69 | opencv_image_object *image = (opencv_image_object *)object; 70 | 71 | zend_hash_destroy(image->std.properties); 72 | FREE_HASHTABLE(image->std.properties); 73 | 74 | if(image->cvptr != NULL){ 75 | cvReleaseImage(&image->cvptr); 76 | } 77 | efree(image); 78 | } 79 | 80 | static zend_object_value opencv_image_object_new(zend_class_entry *ce TSRMLS_DC) 81 | { 82 | zend_object_value retval; 83 | opencv_image_object *image; 84 | zval *temp; 85 | 86 | image = (opencv_image_object *) ecalloc(1, sizeof(opencv_image_object)); 87 | 88 | image->std.ce = ce; 89 | image->cvptr = NULL; 90 | 91 | ALLOC_HASHTABLE(image->std.properties); 92 | zend_hash_init(image->std.properties, 0, NULL, ZVAL_PTR_DTOR, 0); 93 | #if PHP_VERSION_ID < 50399 94 | zend_hash_copy(image->std.properties, &ce->default_properties, (copy_ctor_func_t) zval_add_ref,(void *) &temp, sizeof(zval *)); 95 | #else 96 | object_properties_init(&image->std, ce); 97 | #endif 98 | retval.handle = zend_objects_store_put(image, NULL, (zend_objects_free_object_storage_t)opencv_image_object_destroy, NULL TSRMLS_CC); 99 | retval.handlers = zend_get_std_object_handlers(); 100 | return retval; 101 | } 102 | 103 | /* {{{ proto void __construct(int width, int height, int format, int channels) 104 | Returns new CairoSurfaceImage object created on an image surface */ 105 | PHP_METHOD(OpenCV_Image, __construct) 106 | { 107 | long format, width, height, channels; 108 | opencv_image_object *image_object; 109 | IplImage *temp; 110 | 111 | PHP_OPENCV_ERROR_HANDLING(); 112 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llll", &width, &height, &format, &channels) == FAILURE) 113 | { 114 | PHP_OPENCV_RESTORE_ERRORS(); 115 | return; 116 | } 117 | PHP_OPENCV_RESTORE_ERRORS(); 118 | 119 | temp = cvCreateImage(cvSize(width, height), format, channels); 120 | php_opencv_make_image_zval(temp, getThis() TSRMLS_CC); 121 | php_opencv_throw_exception(TSRMLS_C); 122 | } 123 | /* }}} */ 124 | 125 | PHP_METHOD(OpenCV_Image, load) { 126 | IplImage *temp; 127 | char *filename; 128 | int filename_len; 129 | long mode = 0; 130 | 131 | PHP_OPENCV_ERROR_HANDLING(); 132 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &filename, &filename_len, &mode) == FAILURE) { 133 | PHP_OPENCV_RESTORE_ERRORS(); 134 | return; 135 | } 136 | PHP_OPENCV_RESTORE_ERRORS(); 137 | 138 | php_opencv_basedir_check(filename TSRMLS_CC); 139 | 140 | temp = (IplImage *) cvLoadImage(filename, mode); 141 | if (temp == NULL) { 142 | char *error_message = estrdup("Could not open the video file - check it exists and the codec is available"); 143 | zend_throw_exception(opencv_ce_cvexception, error_message, 0 TSRMLS_CC); 144 | efree(error_message); 145 | return; 146 | } 147 | 148 | php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 149 | php_opencv_throw_exception(TSRMLS_C); 150 | } 151 | 152 | PHP_METHOD(OpenCV_Image, save) { 153 | opencv_image_object *image_object; 154 | zval *image_zval = NULL; 155 | char *filename; 156 | int filename_len, status, cast_mode; 157 | long mode = 0; 158 | 159 | PHP_OPENCV_ERROR_HANDLING(); 160 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|l", &image_zval, opencv_ce_image, &filename, &filename_len, &mode) == FAILURE) { 161 | PHP_OPENCV_RESTORE_ERRORS(); 162 | return; 163 | } 164 | PHP_OPENCV_RESTORE_ERRORS(); 165 | 166 | image_object = opencv_image_object_get(getThis() TSRMLS_CC); 167 | cast_mode = mode; 168 | cvSetErrMode(CV_ErrModeSilent); 169 | status = cvSaveImage(filename, image_object->cvptr, 0); 170 | php_opencv_throw_exception(TSRMLS_C); 171 | 172 | if (status == 0) { 173 | zend_throw_exception(opencv_ce_cvexception, "Failed to save image", 0 TSRMLS_CC); 174 | } 175 | } 176 | 177 | /* {{{ */ 178 | PHP_METHOD(OpenCV_Image, setImageROI) { 179 | opencv_image_object *image_object; 180 | zval *image_zval, *rect_zval, **ppzval; 181 | HashTable *rect_ht; 182 | long rect_vals[4] = {0, 0, 0, 0}; 183 | int i = 0; 184 | 185 | PHP_OPENCV_ERROR_HANDLING(); 186 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ollll", &image_zval, opencv_ce_image, &rect_vals[0], &rect_vals[1], &rect_vals[2], &rect_vals[3]) == FAILURE) { 187 | PHP_OPENCV_RESTORE_ERRORS(); 188 | return; 189 | } 190 | PHP_OPENCV_RESTORE_ERRORS(); 191 | 192 | image_object = opencv_image_object_get(getThis() TSRMLS_CC); 193 | cvSetImageROI(image_object->cvptr, cvRect(rect_vals[0], rect_vals[1], rect_vals[2], rect_vals[3])); 194 | php_opencv_throw_exception(TSRMLS_C); 195 | } 196 | /* }}} */ 197 | 198 | /* {{{ */ 199 | PHP_METHOD(OpenCV_Image, getImageROI) { 200 | opencv_image_object *image_object; 201 | zval *image_zval; 202 | CvRect rect; 203 | 204 | PHP_OPENCV_ERROR_HANDLING(); 205 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &image_zval, opencv_ce_image) == FAILURE) { 206 | PHP_OPENCV_RESTORE_ERRORS(); 207 | return; 208 | } 209 | PHP_OPENCV_RESTORE_ERRORS(); 210 | 211 | image_object = opencv_image_object_get(getThis() TSRMLS_CC); 212 | rect = cvGetImageROI(image_object->cvptr); 213 | array_init(return_value); 214 | add_assoc_long(return_value, "x", rect.x); 215 | add_assoc_long(return_value, "y", rect.y); 216 | add_assoc_long(return_value, "width", rect.width); 217 | add_assoc_long(return_value, "height", rect.height); 218 | 219 | php_opencv_throw_exception(TSRMLS_C); 220 | } 221 | /* }}} */ 222 | 223 | /* {{{ */ 224 | PHP_METHOD(OpenCV_Image, resetImageROI) { 225 | opencv_image_object *image_object; 226 | zval *image_zval; 227 | 228 | PHP_OPENCV_ERROR_HANDLING(); 229 | if (zend_parse_parameters_none() == FAILURE) { 230 | PHP_OPENCV_RESTORE_ERRORS(); 231 | return; 232 | } 233 | PHP_OPENCV_RESTORE_ERRORS(); 234 | 235 | image_object = opencv_image_object_get(getThis() TSRMLS_CC); 236 | cvResetImageROI(image_object->cvptr); 237 | php_opencv_throw_exception(TSRMLS_C); 238 | } 239 | /* }}} */ 240 | 241 | /* {{{ */ 242 | PHP_METHOD(OpenCV_Image, smooth) { 243 | opencv_image_object *image_object, *dst_object; 244 | zval *image_zval; 245 | IplImage *temp; 246 | long params[4] = { 3, 0, 0, 0 }; 247 | long smoothType = 0; 248 | 249 | PHP_OPENCV_ERROR_HANDLING(); 250 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Olllll", &image_zval, opencv_ce_image, &smoothType, ¶ms[0], ¶ms[1], ¶ms[2], ¶ms[3]) == FAILURE) { 251 | PHP_OPENCV_RESTORE_ERRORS(); 252 | return; 253 | } 254 | PHP_OPENCV_RESTORE_ERRORS(); 255 | 256 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 257 | 258 | temp = cvCloneImage(image_object->cvptr); 259 | *return_value = *php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 260 | dst_object = (opencv_image_object *) zend_object_store_get_object(return_value TSRMLS_CC); 261 | 262 | cvSmooth(image_object->cvptr, dst_object->cvptr, smoothType, params[0], params[1], params[2], params[3]); 263 | php_opencv_throw_exception(TSRMLS_C); 264 | } 265 | /* }}} */ 266 | 267 | /* {{{ */ 268 | PHP_METHOD(OpenCV_Image, laplace) { 269 | opencv_image_object *image_object, *dst_object; 270 | zval *image_zval; 271 | IplImage *temp; 272 | long apertureSize = 0; 273 | 274 | PHP_OPENCV_ERROR_HANDLING(); 275 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &image_zval, opencv_ce_image, &apertureSize) == FAILURE) { 276 | PHP_OPENCV_RESTORE_ERRORS(); 277 | return; 278 | } 279 | PHP_OPENCV_RESTORE_ERRORS(); 280 | 281 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 282 | temp = cvCreateImage(cvGetSize(image_object->cvptr), IPL_DEPTH_16S, image_object->cvptr->nChannels); 283 | *return_value = *php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 284 | dst_object = (opencv_image_object *) zend_object_store_get_object(return_value TSRMLS_CC); 285 | 286 | cvLaplace(image_object->cvptr, dst_object->cvptr, apertureSize); 287 | php_opencv_throw_exception(TSRMLS_C); 288 | } 289 | /* }}} */ 290 | 291 | /* {{{ */ 292 | PHP_METHOD(OpenCV_Image, sobel) { 293 | opencv_image_object *image_object, *dst_object; 294 | zval *image_zval; 295 | IplImage *temp; 296 | long xorder = 0, yorder = 0, apertureSize = 0; 297 | 298 | PHP_OPENCV_ERROR_HANDLING(); 299 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Olll", &image_zval, opencv_ce_image, &xorder, &yorder, &apertureSize) == FAILURE) { 300 | PHP_OPENCV_RESTORE_ERRORS(); 301 | return; 302 | } 303 | PHP_OPENCV_RESTORE_ERRORS(); 304 | 305 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 306 | temp = cvCreateImage(cvGetSize(image_object->cvptr), IPL_DEPTH_16S, image_object->cvptr->nChannels); 307 | *return_value = *php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 308 | dst_object = (opencv_image_object *) zend_object_store_get_object(return_value TSRMLS_CC); 309 | 310 | cvSobel(image_object->cvptr, dst_object->cvptr, xorder, yorder, apertureSize); 311 | php_opencv_throw_exception(TSRMLS_C); 312 | } 313 | /* }}} */ 314 | 315 | /* {{{ */ 316 | PHP_METHOD(OpenCV_Image, erode) { 317 | opencv_image_object *image_object, *dst_object; 318 | zval *image_zval; 319 | IplImage *temp; 320 | long iterations = 1; 321 | 322 | PHP_OPENCV_ERROR_HANDLING(); 323 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &image_zval, opencv_ce_image, &iterations) == FAILURE) { 324 | PHP_OPENCV_RESTORE_ERRORS(); 325 | return; 326 | } 327 | PHP_OPENCV_RESTORE_ERRORS(); 328 | 329 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 330 | temp = cvCloneImage(image_object->cvptr); 331 | *return_value = *php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 332 | dst_object = (opencv_image_object *) zend_object_store_get_object(return_value TSRMLS_CC); 333 | 334 | cvErode(image_object->cvptr, dst_object->cvptr, NULL, iterations); 335 | php_opencv_throw_exception(TSRMLS_C); 336 | } 337 | /* }}} */ 338 | 339 | /* {{{ */ 340 | PHP_METHOD(OpenCV_Image, dilate) { 341 | opencv_image_object *image_object, *dst_object; 342 | zval *image_zval; 343 | IplImage *temp; 344 | long iterations = 1; 345 | 346 | PHP_OPENCV_ERROR_HANDLING(); 347 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &image_zval, opencv_ce_image, &iterations) == FAILURE) { 348 | PHP_OPENCV_RESTORE_ERRORS(); 349 | return; 350 | } 351 | PHP_OPENCV_RESTORE_ERRORS(); 352 | 353 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 354 | temp = cvCloneImage(image_object->cvptr); 355 | *return_value = *php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 356 | dst_object = (opencv_image_object *) zend_object_store_get_object(return_value TSRMLS_CC); 357 | 358 | cvDilate(image_object->cvptr, dst_object->cvptr, NULL, iterations); 359 | php_opencv_throw_exception(TSRMLS_C); 360 | } 361 | /* }}} */ 362 | 363 | /* {{{ */ 364 | PHP_METHOD(OpenCV_Image, open) { 365 | opencv_image_object *image_object, *dst_object; 366 | zval *image_zval; 367 | IplImage *temp; 368 | long iterations = 1; 369 | 370 | PHP_OPENCV_ERROR_HANDLING(); 371 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &image_zval, opencv_ce_image, &iterations) == FAILURE) { 372 | PHP_OPENCV_RESTORE_ERRORS(); 373 | return; 374 | } 375 | PHP_OPENCV_RESTORE_ERRORS(); 376 | 377 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 378 | temp = cvCloneImage(image_object->cvptr); 379 | *return_value = *php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 380 | dst_object = (opencv_image_object *) zend_object_store_get_object(return_value TSRMLS_CC); 381 | 382 | cvMorphologyEx(image_object->cvptr, dst_object->cvptr, NULL, NULL, CV_MOP_OPEN, iterations); 383 | php_opencv_throw_exception(TSRMLS_C); 384 | } 385 | /* }}} */ 386 | 387 | /* {{{ */ 388 | PHP_METHOD(OpenCV_Image, close) { 389 | opencv_image_object *image_object, *dst_object; 390 | zval *image_zval; 391 | IplImage *temp; 392 | long iterations = 1; 393 | 394 | PHP_OPENCV_ERROR_HANDLING(); 395 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &image_zval, opencv_ce_image, &iterations) == FAILURE) { 396 | PHP_OPENCV_RESTORE_ERRORS(); 397 | return; 398 | } 399 | PHP_OPENCV_RESTORE_ERRORS(); 400 | 401 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 402 | temp = cvCloneImage(image_object->cvptr); 403 | *return_value = *php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 404 | dst_object = (opencv_image_object *) zend_object_store_get_object(return_value TSRMLS_CC); 405 | 406 | cvMorphologyEx(image_object->cvptr, dst_object->cvptr, NULL, NULL, CV_MOP_CLOSE, iterations); 407 | php_opencv_throw_exception(TSRMLS_C); 408 | } 409 | /* }}} */ 410 | 411 | /* {{{ */ 412 | PHP_METHOD(OpenCV_Image, gradient) { 413 | opencv_image_object *image_object, *dst_object; 414 | zval *image_zval; 415 | IplImage *temp, *temp2; 416 | long iterations = 1; 417 | 418 | PHP_OPENCV_ERROR_HANDLING(); 419 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &image_zval, opencv_ce_image, &iterations) == FAILURE) { 420 | PHP_OPENCV_RESTORE_ERRORS(); 421 | return; 422 | } 423 | PHP_OPENCV_RESTORE_ERRORS(); 424 | 425 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 426 | temp = cvCloneImage(image_object->cvptr); 427 | temp2 = cvCloneImage(image_object->cvptr); 428 | *return_value = *php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 429 | dst_object = (opencv_image_object *) zend_object_store_get_object(return_value TSRMLS_CC); 430 | 431 | cvMorphologyEx(image_object->cvptr, dst_object->cvptr, temp2, NULL, CV_MOP_GRADIENT, iterations); 432 | php_opencv_throw_exception(TSRMLS_C); 433 | } 434 | /* }}} */ 435 | 436 | /* {{{ */ 437 | PHP_METHOD(OpenCV_Image, topHat) { 438 | opencv_image_object *image_object, *dst_object; 439 | zval *image_zval; 440 | IplImage *temp; 441 | long iterations = 1; 442 | 443 | PHP_OPENCV_ERROR_HANDLING(); 444 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &image_zval, opencv_ce_image, &iterations) == FAILURE) { 445 | PHP_OPENCV_RESTORE_ERRORS(); 446 | return; 447 | } 448 | PHP_OPENCV_RESTORE_ERRORS(); 449 | 450 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 451 | temp = cvCloneImage(image_object->cvptr); 452 | *return_value = *php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 453 | dst_object = (opencv_image_object *) zend_object_store_get_object(return_value TSRMLS_CC); 454 | 455 | cvMorphologyEx(image_object->cvptr, dst_object->cvptr, NULL, NULL, CV_MOP_TOPHAT, iterations); 456 | php_opencv_throw_exception(TSRMLS_C); 457 | } 458 | /* }}} */ 459 | 460 | /* {{{ */ 461 | PHP_METHOD(OpenCV_Image, blackHat) { 462 | opencv_image_object *image_object, *dst_object; 463 | zval *image_zval; 464 | IplImage *temp; 465 | long iterations = 1; 466 | 467 | PHP_OPENCV_ERROR_HANDLING(); 468 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &image_zval, opencv_ce_image, &iterations) == FAILURE) { 469 | PHP_OPENCV_RESTORE_ERRORS(); 470 | return; 471 | } 472 | PHP_OPENCV_RESTORE_ERRORS(); 473 | 474 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 475 | temp = cvCloneImage(image_object->cvptr); 476 | *return_value = *php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 477 | dst_object = (opencv_image_object *) zend_object_store_get_object(return_value TSRMLS_CC); 478 | 479 | cvMorphologyEx(image_object->cvptr, dst_object->cvptr, NULL, NULL, CV_MOP_BLACKHAT, iterations); 480 | php_opencv_throw_exception(TSRMLS_C); 481 | } 482 | /* }}} */ 483 | 484 | /* {{{ */ 485 | PHP_METHOD(OpenCV_Image, resize) { 486 | opencv_image_object *image_object, *dst_object; 487 | zval *image_zval, *dst_zval; 488 | long interpolation = CV_INTER_LINEAR; 489 | 490 | PHP_OPENCV_ERROR_HANDLING(); 491 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO|l", &image_zval, opencv_ce_image, &dst_zval, opencv_ce_image, &interpolation) == FAILURE) { 492 | PHP_OPENCV_RESTORE_ERRORS(); 493 | return; 494 | } 495 | PHP_OPENCV_RESTORE_ERRORS(); 496 | 497 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 498 | dst_object = opencv_image_object_get(dst_zval TSRMLS_CC); 499 | 500 | cvResize(image_object->cvptr, dst_object->cvptr, interpolation); 501 | php_opencv_throw_exception(TSRMLS_C); 502 | } 503 | /* }}} */ 504 | 505 | /* {{{ */ 506 | PHP_METHOD(OpenCV_Image, pyrDown) { 507 | opencv_image_object *image_object, *dst_object; 508 | zval *image_zval; 509 | IplImage *temp; 510 | long filter = CV_GAUSSIAN_5x5; 511 | 512 | PHP_OPENCV_ERROR_HANDLING(); 513 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &image_zval, opencv_ce_image, &filter) == FAILURE) { 514 | PHP_OPENCV_RESTORE_ERRORS(); 515 | return; 516 | } 517 | PHP_OPENCV_RESTORE_ERRORS(); 518 | 519 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 520 | temp = cvCreateImage( 521 | cvSize(image_object->cvptr->width / 2, image_object->cvptr->height / 2), 522 | image_object->cvptr->depth, image_object->cvptr->nChannels); 523 | php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 524 | dst_object = opencv_image_object_get(return_value TSRMLS_CC); 525 | 526 | cvPyrDown(image_object->cvptr, dst_object->cvptr, filter); 527 | php_opencv_throw_exception(TSRMLS_C); 528 | } 529 | /* }}} */ 530 | 531 | /* {{{ */ 532 | PHP_METHOD(OpenCV_Image, pyrUp) { 533 | opencv_image_object *image_object, *dst_object; 534 | zval *image_zval; 535 | IplImage *temp; 536 | long filter = CV_GAUSSIAN_5x5; 537 | 538 | PHP_OPENCV_ERROR_HANDLING(); 539 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &image_zval, opencv_ce_image, &filter) == FAILURE) { 540 | PHP_OPENCV_RESTORE_ERRORS(); 541 | return; 542 | } 543 | PHP_OPENCV_RESTORE_ERRORS(); 544 | 545 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 546 | temp = cvCreateImage( 547 | cvSize(image_object->cvptr->width * 2, image_object->cvptr->height * 2), 548 | image_object->cvptr->depth, image_object->cvptr->nChannels); 549 | php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 550 | dst_object = opencv_image_object_get(return_value TSRMLS_CC); 551 | 552 | cvPyrUp(image_object->cvptr, dst_object->cvptr, filter); 553 | php_opencv_throw_exception(TSRMLS_C); 554 | } 555 | /* }}} */ 556 | 557 | /* {{{ */ 558 | PHP_METHOD(OpenCV_Image, canny) { 559 | opencv_image_object *image_object, *dst_object; 560 | zval *image_zval; 561 | IplImage *temp, *grey_image; 562 | long lowThresh, highThresh, apertureSize; 563 | 564 | PHP_OPENCV_ERROR_HANDLING(); 565 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Olll", &image_zval, opencv_ce_image, &lowThresh, &highThresh, &apertureSize) == FAILURE) { 566 | PHP_OPENCV_RESTORE_ERRORS(); 567 | return; 568 | } 569 | PHP_OPENCV_RESTORE_ERRORS(); 570 | 571 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 572 | if (image_object->cvptr->nChannels > 1) { 573 | grey_image = cvCreateImage(cvGetSize(image_object->cvptr), IPL_DEPTH_8U, 1); 574 | cvCvtColor(image_object->cvptr, grey_image, CV_BGR2GRAY); 575 | } else { 576 | grey_image = image_object->cvptr; 577 | } 578 | 579 | temp = cvCreateImage(cvGetSize(image_object->cvptr), IPL_DEPTH_8U, 1); 580 | php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 581 | dst_object = opencv_image_object_get(return_value TSRMLS_CC); 582 | 583 | cvCanny(grey_image, dst_object->cvptr, lowThresh, highThresh, apertureSize); 584 | php_opencv_throw_exception(TSRMLS_C); 585 | } 586 | /* }}} */ 587 | 588 | /* {{{ */ 589 | PHP_METHOD(OpenCV_Image, split) { 590 | opencv_image_object *image_object, *dst_object; 591 | zval *image_zval; 592 | IplImage *temp, *grey_image; 593 | long lowThresh, highThresh, apertureSize, i; 594 | 595 | PHP_OPENCV_ERROR_HANDLING(); 596 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &image_zval, opencv_ce_image) == FAILURE) { 597 | PHP_OPENCV_RESTORE_ERRORS(); 598 | return; 599 | } 600 | PHP_OPENCV_RESTORE_ERRORS(); 601 | 602 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 603 | 604 | IplImage **planes = (IplImage **) ecalloc(image_object->cvptr->nChannels, sizeof(IplImage *)); 605 | zval **return_zvals = (zval **) ecalloc(image_object->cvptr->nChannels, sizeof(zval *)); 606 | 607 | for (i = 0; i < image_object->cvptr->nChannels; i++) { 608 | opencv_image_object *current_plane; 609 | MAKE_STD_ZVAL(return_zvals[i]); 610 | object_init_ex(return_zvals[i], opencv_ce_image); 611 | temp = cvCreateImage(cvGetSize(image_object->cvptr), IPL_DEPTH_8U, 1); 612 | php_opencv_make_image_zval(temp, return_zvals[i] TSRMLS_CC); 613 | planes[i] = temp; 614 | } 615 | 616 | for (i = image_object->cvptr->nChannels; i < 4; i++) { 617 | planes[i] = NULL; 618 | } 619 | 620 | array_init(return_value); 621 | cvSplit(image_object->cvptr, planes[0], planes[1], planes[2], planes[3]); 622 | for (i = 0; i < image_object->cvptr->nChannels; i++) { 623 | add_next_index_zval(return_value, return_zvals[i]); 624 | } 625 | 626 | php_opencv_throw_exception(TSRMLS_C); 627 | } 628 | 629 | /* {{{ */ 630 | PHP_METHOD(OpenCV_Image, convertColor) { 631 | opencv_image_object *image_object, *dst_object; 632 | zval *image_zval; 633 | IplImage *temp; 634 | long code; 635 | long channels = -1; 636 | 637 | PHP_OPENCV_ERROR_HANDLING(); 638 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol|l", &image_zval, opencv_ce_image, &code, &channels) == FAILURE) { 639 | PHP_OPENCV_RESTORE_ERRORS(); 640 | return; 641 | } 642 | PHP_OPENCV_RESTORE_ERRORS(); 643 | 644 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 645 | 646 | if (channels <= 0) { 647 | channels = image_object->cvptr->nChannels; 648 | } 649 | 650 | temp = cvCreateImage(cvGetSize(image_object->cvptr), image_object->cvptr->depth, channels); 651 | cvCvtColor(image_object->cvptr, temp, code); 652 | php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 653 | 654 | php_opencv_throw_exception(TSRMLS_C); 655 | } 656 | /* }}} */ 657 | 658 | /* {{{ */ 659 | PHP_METHOD(OpenCV_Image, backProject) 660 | { 661 | opencv_image_object *image_object, *dst_object; 662 | opencv_histogram_object *hist_object; 663 | zval *image_zval, *hist_zval; 664 | IplImage *temp; 665 | 666 | PHP_OPENCV_ERROR_HANDLING(); 667 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO", &image_zval, opencv_ce_image, &hist_zval, opencv_ce_histogram) == FAILURE) { 668 | PHP_OPENCV_RESTORE_ERRORS(); 669 | return; 670 | } 671 | PHP_OPENCV_RESTORE_ERRORS(); 672 | 673 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 674 | hist_object = opencv_histogram_object_get(hist_zval TSRMLS_CC); 675 | 676 | temp = cvCloneImage(image_object->cvptr); 677 | cvCalcBackProject(&image_object->cvptr, temp, hist_object->cvptr); 678 | php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 679 | 680 | php_opencv_throw_exception(TSRMLS_C); 681 | } 682 | /* }}} */ 683 | 684 | PHP_METHOD(OpenCV_Image, matchTemplate) 685 | { 686 | opencv_image_object *image_object, *template_object, *dst_object; 687 | zval *image_zval, *template_zval; 688 | IplImage *temp; 689 | long mode; 690 | 691 | PHP_OPENCV_ERROR_HANDLING(); 692 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OOl", &image_zval, opencv_ce_image, &template_zval, opencv_ce_image, &mode) == FAILURE) { 693 | PHP_OPENCV_RESTORE_ERRORS(); 694 | return; 695 | } 696 | PHP_OPENCV_RESTORE_ERRORS(); 697 | 698 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 699 | template_object = opencv_image_object_get(template_zval TSRMLS_CC); 700 | 701 | temp = cvCreateImage(cvSize( 702 | image_object->cvptr->width - template_object->cvptr->width + 1, 703 | image_object->cvptr->height - template_object->cvptr->height + 1), 704 | IPL_DEPTH_32F, 1); 705 | 706 | cvMatchTemplate(image_object->cvptr, template_object->cvptr, temp, mode); 707 | php_opencv_make_image_zval(temp, return_value TSRMLS_CC); 708 | php_opencv_throw_exception(TSRMLS_C); 709 | } 710 | /* }}} */ 711 | 712 | PHP_METHOD(OpenCV_Image, rectangle) 713 | { 714 | opencv_image_object *image_object; 715 | zval *image_zval, *template_zval; 716 | IplImage *temp; 717 | long x, y, width, height; 718 | CvScalar colour = { 255, 0, 0 }; 719 | 720 | PHP_OPENCV_ERROR_HANDLING(); 721 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ollll", &image_zval, opencv_ce_image, &x, &y, &width, &height) == FAILURE) { 722 | PHP_OPENCV_RESTORE_ERRORS(); 723 | return; 724 | } 725 | PHP_OPENCV_RESTORE_ERRORS(); 726 | 727 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 728 | cvRectangle(image_object->cvptr, cvPoint(x, y), cvPoint(x + width, y + height), colour, 1, 8, 0); 729 | 730 | php_opencv_throw_exception(TSRMLS_C); 731 | } 732 | /* }}} */ 733 | 734 | /* {{{ */ 735 | PHP_METHOD(OpenCV_Image, haarDetectObjects) 736 | { 737 | opencv_image_object *image_object, *dst_object; 738 | zval *image_zval; 739 | IplImage *grey_image; 740 | const char *cascade_name; 741 | int cascade_name_len, i; 742 | CvHaarClassifierCascade *cascade; 743 | CvMemStorage *storage = cvCreateMemStorage(0); 744 | 745 | PHP_OPENCV_ERROR_HANDLING(); 746 | if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &image_zval, opencv_ce_image, &cascade_name, &cascade_name_len) == FAILURE) { 747 | PHP_OPENCV_RESTORE_ERRORS(); 748 | return; 749 | } 750 | PHP_OPENCV_RESTORE_ERRORS(); 751 | 752 | cascade = (CvHaarClassifierCascade *) cvLoad(cascade_name, 0, 0, 0); 753 | 754 | image_object = opencv_image_object_get(image_zval TSRMLS_CC); 755 | if (image_object->cvptr->nChannels > 1) { 756 | grey_image = cvCreateImage(cvGetSize(image_object->cvptr), IPL_DEPTH_8U, 1); 757 | cvCvtColor(image_object->cvptr, grey_image, CV_BGR2GRAY); 758 | } else { 759 | grey_image = image_object->cvptr; 760 | } 761 | cvEqualizeHist(grey_image, grey_image); 762 | cvClearMemStorage(storage); 763 | #if ( (CV_MAJOR_VERSION >= 2) && (CV_MINOR_VERSION >= 3) ) 764 | CvSeq *objects = cvHaarDetectObjects(grey_image, cascade, storage, 1.1, 3, 0, cvSize(20, 20), cvSize(0, 0)); 765 | #else 766 | CvSeq *objects = cvHaarDetectObjects(grey_image, cascade, storage, 1.1, 3, 0, cvSize(20, 20)); 767 | #endif 768 | array_init(return_value); 769 | for (i = 0; i < (objects ? objects->total : 0); i++) { 770 | zval *temp; 771 | CvRect *r = (CvRect *) cvGetSeqElem(objects, i); 772 | 773 | MAKE_STD_ZVAL(temp); 774 | array_init(temp); 775 | add_assoc_long(temp, "x", r->x); 776 | add_assoc_long(temp, "y", r->y); 777 | add_assoc_long(temp, "width", r->width); 778 | add_assoc_long(temp, "height", r->height); 779 | 780 | add_next_index_zval(return_value, temp); 781 | } 782 | 783 | //cvReleaseImage(grey_image); 784 | php_opencv_throw_exception(TSRMLS_C); 785 | } 786 | /* }}} */ 787 | 788 | /* {{{ opencv_image_methods[] */ 789 | const zend_function_entry opencv_image_methods[] = { 790 | PHP_ME(OpenCV_Image, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR) 791 | PHP_ME(OpenCV_Image, load, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) 792 | PHP_ME(OpenCV_Image, save, NULL, ZEND_ACC_PUBLIC) 793 | PHP_ME(OpenCV_Image, setImageROI, NULL, ZEND_ACC_PUBLIC) 794 | PHP_ME(OpenCV_Image, getImageROI, NULL, ZEND_ACC_PUBLIC) 795 | PHP_ME(OpenCV_Image, resetImageROI, NULL, ZEND_ACC_PUBLIC) 796 | PHP_ME(OpenCV_Image, smooth, NULL, ZEND_ACC_PUBLIC) 797 | PHP_ME(OpenCV_Image, laplace, NULL, ZEND_ACC_PUBLIC) 798 | PHP_ME(OpenCV_Image, sobel, NULL, ZEND_ACC_PUBLIC) 799 | PHP_ME(OpenCV_Image, erode, NULL, ZEND_ACC_PUBLIC) 800 | PHP_ME(OpenCV_Image, dilate, NULL, ZEND_ACC_PUBLIC) 801 | PHP_ME(OpenCV_Image, open, NULL, ZEND_ACC_PUBLIC) 802 | PHP_ME(OpenCV_Image, close, NULL, ZEND_ACC_PUBLIC) 803 | PHP_ME(OpenCV_Image, gradient, NULL, ZEND_ACC_PUBLIC) 804 | PHP_ME(OpenCV_Image, topHat, NULL, ZEND_ACC_PUBLIC) 805 | PHP_ME(OpenCV_Image, blackHat, NULL, ZEND_ACC_PUBLIC) 806 | PHP_ME(OpenCV_Image, resize, NULL, ZEND_ACC_PUBLIC) 807 | PHP_ME(OpenCV_Image, pyrDown, NULL, ZEND_ACC_PUBLIC) 808 | PHP_ME(OpenCV_Image, pyrUp, NULL, ZEND_ACC_PUBLIC) 809 | PHP_ME(OpenCV_Image, canny, NULL, ZEND_ACC_PUBLIC) 810 | PHP_ME(OpenCV_Image, split, NULL, ZEND_ACC_PUBLIC) 811 | PHP_ME(OpenCV_Image, convertColor, NULL, ZEND_ACC_PUBLIC) 812 | PHP_ME(OpenCV_Image, backProject, NULL, ZEND_ACC_PUBLIC) 813 | PHP_ME(OpenCV_Image, matchTemplate, NULL, ZEND_ACC_PUBLIC) 814 | PHP_ME(OpenCV_Image, haarDetectObjects, NULL, ZEND_ACC_PUBLIC) 815 | PHP_ME(OpenCV_Image, rectangle, NULL, ZEND_ACC_PUBLIC) 816 | {NULL, NULL, NULL} 817 | }; 818 | /* }}} */ 819 | 820 | /* {{{ PHP_MINIT_FUNCTION */ 821 | PHP_MINIT_FUNCTION(opencv_image) 822 | { 823 | zend_class_entry ce; 824 | 825 | INIT_NS_CLASS_ENTRY(ce, "OpenCV", "Image", opencv_image_methods); 826 | opencv_ce_image = zend_register_internal_class_ex(&ce, opencv_ce_cvmat, NULL TSRMLS_CC); 827 | opencv_ce_image->create_object = opencv_image_object_new; 828 | 829 | #define REGISTER_IMAGE_LONG_CONST(const_name, value) \ 830 | zend_declare_class_constant_long(opencv_ce_image, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC); \ 831 | REGISTER_LONG_CONSTANT(#value, value, CONST_CS | CONST_PERSISTENT); 832 | 833 | REGISTER_IMAGE_LONG_CONST("DEPTH_8U", IPL_DEPTH_8U); 834 | REGISTER_IMAGE_LONG_CONST("DEPTH_8S", IPL_DEPTH_8S); 835 | REGISTER_IMAGE_LONG_CONST("DEPTH_16U", IPL_DEPTH_16U); 836 | REGISTER_IMAGE_LONG_CONST("DEPTH_16S", IPL_DEPTH_16S); 837 | REGISTER_IMAGE_LONG_CONST("DEPTH_32S", IPL_DEPTH_32S); 838 | REGISTER_IMAGE_LONG_CONST("DEPTH_32F", IPL_DEPTH_32F); 839 | REGISTER_IMAGE_LONG_CONST("DEPTH_64F", IPL_DEPTH_64F); 840 | 841 | REGISTER_IMAGE_LONG_CONST("LOAD_IMAGE_COLOR", CV_LOAD_IMAGE_COLOR); 842 | REGISTER_IMAGE_LONG_CONST("LOAD_IMAGE_GRAYSCALE", CV_LOAD_IMAGE_GRAYSCALE); 843 | REGISTER_IMAGE_LONG_CONST("LOAD_IMAGE_UNCHANGED", CV_LOAD_IMAGE_UNCHANGED); 844 | 845 | REGISTER_IMAGE_LONG_CONST("BLUR_NO_SCALE", CV_BLUR_NO_SCALE); 846 | REGISTER_IMAGE_LONG_CONST("BLUR", CV_BLUR); 847 | REGISTER_IMAGE_LONG_CONST("GAUSSIAN", CV_GAUSSIAN); 848 | REGISTER_IMAGE_LONG_CONST("MEDIAN", CV_MEDIAN); 849 | REGISTER_IMAGE_LONG_CONST("BILATERAL", CV_BILATERAL); 850 | 851 | REGISTER_IMAGE_LONG_CONST("INTER_NN", CV_INTER_NN); 852 | REGISTER_IMAGE_LONG_CONST("INTER_LINEAR", CV_INTER_LINEAR); 853 | REGISTER_IMAGE_LONG_CONST("INTER_AREA", CV_INTER_AREA); 854 | REGISTER_IMAGE_LONG_CONST("INTER_CUBIC", CV_INTER_CUBIC); 855 | 856 | REGISTER_IMAGE_LONG_CONST("GAUSSIAN_5x5", CV_GAUSSIAN_5x5); 857 | 858 | /* Constants for conversion - these should be moved into a separate class, probably */ 859 | REGISTER_IMAGE_LONG_CONST("BGR2BGRA", CV_BGR2BGRA); 860 | REGISTER_IMAGE_LONG_CONST("RGB2RGBA", CV_RGB2RGBA); 861 | REGISTER_IMAGE_LONG_CONST("BGRA2BGR", CV_BGRA2BGR); 862 | REGISTER_IMAGE_LONG_CONST("RGBA2RGB", CV_RGBA2RGB); 863 | REGISTER_IMAGE_LONG_CONST("BGR2RGBA", CV_BGR2RGBA); 864 | REGISTER_IMAGE_LONG_CONST("RGB2BGRA", CV_RGB2BGRA); 865 | REGISTER_IMAGE_LONG_CONST("RGBA2BGR", CV_RGBA2BGR); 866 | REGISTER_IMAGE_LONG_CONST("BGRA2RGB", CV_BGRA2RGB); 867 | REGISTER_IMAGE_LONG_CONST("BGR2RGB", CV_BGR2RGB); 868 | REGISTER_IMAGE_LONG_CONST("RGB2BGR", CV_RGB2BGR); 869 | REGISTER_IMAGE_LONG_CONST("BGRA2RGBA", CV_BGRA2RGBA); 870 | REGISTER_IMAGE_LONG_CONST("RGBA2BGRA", CV_RGBA2BGRA); 871 | REGISTER_IMAGE_LONG_CONST("BGR2GRAY", CV_BGR2GRAY); 872 | REGISTER_IMAGE_LONG_CONST("RGB2GRAY", CV_RGB2GRAY); 873 | REGISTER_IMAGE_LONG_CONST("GRAY2BGR", CV_GRAY2BGR); 874 | REGISTER_IMAGE_LONG_CONST("GRAY2RGB", CV_GRAY2RGB); 875 | REGISTER_IMAGE_LONG_CONST("GRAY2BGRA", CV_GRAY2BGRA); 876 | REGISTER_IMAGE_LONG_CONST("GRAY2RGBA", CV_GRAY2RGBA); 877 | REGISTER_IMAGE_LONG_CONST("BGRA2GRAY", CV_BGRA2GRAY); 878 | REGISTER_IMAGE_LONG_CONST("RGBA2GRAY", CV_RGBA2GRAY); 879 | REGISTER_IMAGE_LONG_CONST("BGR2BGR565", CV_BGR2BGR565); 880 | REGISTER_IMAGE_LONG_CONST("RGB2BGR565", CV_RGB2BGR565); 881 | REGISTER_IMAGE_LONG_CONST("BGR5652BGR", CV_BGR5652BGR); 882 | REGISTER_IMAGE_LONG_CONST("BGR5652RGB", CV_BGR5652RGB); 883 | REGISTER_IMAGE_LONG_CONST("BGRA2BGR565", CV_BGRA2BGR565); 884 | REGISTER_IMAGE_LONG_CONST("RGBA2BGR565", CV_RGBA2BGR565); 885 | REGISTER_IMAGE_LONG_CONST("BGR5652BGRA", CV_BGR5652BGRA); 886 | REGISTER_IMAGE_LONG_CONST("BGR5652RGBA", CV_BGR5652RGBA); 887 | REGISTER_IMAGE_LONG_CONST("GRAY2BGR565", CV_GRAY2BGR565); 888 | REGISTER_IMAGE_LONG_CONST("BGR5652GRAY", CV_BGR5652GRAY); 889 | REGISTER_IMAGE_LONG_CONST("BGR2BGR555", CV_BGR2BGR555); 890 | REGISTER_IMAGE_LONG_CONST("RGB2BGR555", CV_RGB2BGR555); 891 | REGISTER_IMAGE_LONG_CONST("BGR5552BGR", CV_BGR5552BGR); 892 | REGISTER_IMAGE_LONG_CONST("BGR5552RGB", CV_BGR5552RGB); 893 | REGISTER_IMAGE_LONG_CONST("BGRA2BGR555", CV_BGRA2BGR555); 894 | REGISTER_IMAGE_LONG_CONST("RGBA2BGR555", CV_RGBA2BGR555); 895 | REGISTER_IMAGE_LONG_CONST("BGR5552BGRA", CV_BGR5552BGRA); 896 | REGISTER_IMAGE_LONG_CONST("BGR5552RGBA", CV_BGR5552RGBA); 897 | REGISTER_IMAGE_LONG_CONST("GRAY2BGR555", CV_GRAY2BGR555); 898 | REGISTER_IMAGE_LONG_CONST("BGR5552GRAY", CV_BGR5552GRAY); 899 | REGISTER_IMAGE_LONG_CONST("BGR2XYZ", CV_BGR2XYZ); 900 | REGISTER_IMAGE_LONG_CONST("RGB2XYZ", CV_RGB2XYZ); 901 | REGISTER_IMAGE_LONG_CONST("XYZ2BGR", CV_XYZ2BGR); 902 | REGISTER_IMAGE_LONG_CONST("XYZ2RGB", CV_XYZ2RGB); 903 | REGISTER_IMAGE_LONG_CONST("BGR2YCrCb", CV_BGR2YCrCb); 904 | REGISTER_IMAGE_LONG_CONST("RGB2YCrCb", CV_RGB2YCrCb); 905 | REGISTER_IMAGE_LONG_CONST("YCrCb2BGR", CV_YCrCb2BGR); 906 | REGISTER_IMAGE_LONG_CONST("YCrCb2RGB", CV_YCrCb2RGB); 907 | REGISTER_IMAGE_LONG_CONST("BGR2HSV", CV_BGR2HSV); 908 | REGISTER_IMAGE_LONG_CONST("RGB2HSV", CV_RGB2HSV); 909 | REGISTER_IMAGE_LONG_CONST("BGR2Lab", CV_BGR2Lab); 910 | REGISTER_IMAGE_LONG_CONST("RGB2Lab", CV_RGB2Lab); 911 | REGISTER_IMAGE_LONG_CONST("BayerBG2BGR", CV_BayerBG2BGR); 912 | REGISTER_IMAGE_LONG_CONST("BayerGB2BGR", CV_BayerGB2BGR); 913 | REGISTER_IMAGE_LONG_CONST("BayerRG2BGR", CV_BayerRG2BGR); 914 | REGISTER_IMAGE_LONG_CONST("BayerGR2BGR", CV_BayerGR2BGR); 915 | REGISTER_IMAGE_LONG_CONST("BayerBG2RGB", CV_BayerBG2RGB); 916 | REGISTER_IMAGE_LONG_CONST("BayerGB2RGB", CV_BayerGB2RGB); 917 | REGISTER_IMAGE_LONG_CONST("BayerRG2RGB", CV_BayerRG2RGB); 918 | REGISTER_IMAGE_LONG_CONST("BayerGR2RGB", CV_BayerGR2RGB); 919 | REGISTER_IMAGE_LONG_CONST("BGR2Luv", CV_BGR2Luv); 920 | REGISTER_IMAGE_LONG_CONST("RGB2Luv", CV_RGB2Luv); 921 | REGISTER_IMAGE_LONG_CONST("BGR2HLS", CV_BGR2HLS); 922 | REGISTER_IMAGE_LONG_CONST("RGB2HLS", CV_RGB2HLS); 923 | REGISTER_IMAGE_LONG_CONST("HSV2BGR", CV_HSV2BGR); 924 | REGISTER_IMAGE_LONG_CONST("HSV2RGB", CV_HSV2RGB); 925 | REGISTER_IMAGE_LONG_CONST("Lab2BGR", CV_Lab2BGR); 926 | REGISTER_IMAGE_LONG_CONST("Lab2RGB", CV_Lab2RGB); 927 | REGISTER_IMAGE_LONG_CONST("Luv2BGR", CV_Luv2BGR); 928 | REGISTER_IMAGE_LONG_CONST("Luv2RGB", CV_Luv2RGB); 929 | REGISTER_IMAGE_LONG_CONST("HLS2BGR", CV_HLS2BGR); 930 | REGISTER_IMAGE_LONG_CONST("HLS2RGB", CV_HLS2RGB); 931 | 932 | REGISTER_IMAGE_LONG_CONST("TM_SQDIFF", CV_TM_SQDIFF); 933 | REGISTER_IMAGE_LONG_CONST("TM_SQDIFF_NORMED", CV_TM_SQDIFF_NORMED); 934 | REGISTER_IMAGE_LONG_CONST("TM_CCORR", CV_TM_CCORR); 935 | REGISTER_IMAGE_LONG_CONST("TM_CCORR_NORMED", CV_TM_CCORR_NORMED); 936 | REGISTER_IMAGE_LONG_CONST("TM_CCOEFF", CV_TM_CCOEFF); 937 | REGISTER_IMAGE_LONG_CONST("TM_CCOEFF_NORMED", CV_TM_CCOEFF_NORMED); 938 | 939 | return SUCCESS; 940 | } 941 | /* }}} */ 942 | 943 | 944 | --------------------------------------------------------------------------------