opencv_imgproc.cc

/*
 +----------------------------------------------------------------------+
 | 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_imgproc.h"
#include <opencv2/imgproc.hpp>
#include "core/opencv_mat.h"
#include "core/opencv_type.h"
#include "../../opencv_exception.h"
#include <opencv2/highgui.hpp>

using namespace cv;

void opencv_imgproc_init(int module_number) {
    opencv_color_conversion_code_init(module_number);
    opencv_line_type_init(module_number);
    opencv_morph_shapes_init(module_number);
    opencv_morph_types_init(module_number);
    opencv_flood_fill_flags_init(module_number);
    opencv_threshold_types_init(module_number);
    opencv_adaptive_threshold_types_init(module_number);
    opencv_retrieval_modes_init(module_number);
    opencv_contour_approximation_modes_init(module_number);
}

/**
 * CV\cvtColor
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_cv_t_color) {
    long code, dstCn = 0;
    Mat dstImg;
    zval *mat_zval;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Ol|l", &mat_zval, opencv_mat_ce, &code, &dstCn) == FAILURE) {
        RETURN_NULL();
    }
    //get src mat object from mat_zval
    opencv_mat_object *src_obj = Z_PHP_MAT_OBJ_P(mat_zval);
    cvtColor(*(src_obj->mat), dstImg, (int) code, (int) dstCn);

    //new PHP Mat bing cv::cvtColor dstImg.
    zval instance;
    object_init_ex(&instance, opencv_mat_ce);
    opencv_mat_object *dst_obj = Z_PHP_MAT_OBJ_P(&instance);

    dst_obj->mat = new Mat(dstImg);

    opencv_mat_update_property_by_c_mat(&instance, dst_obj->mat);

    RETURN_ZVAL(&instance, 0, 0); //return php Mat object
}


/**
 * CV\ellipse
 * @param CV\Mat $img, Mat of original picture
 * @param CV\Point $center, Center Point of the ellipse
 * @param CV\Size $size, axes Half of the size of the ellipse main axes.
 * @param int $angle
 * @param int $startAngle
 * @param int $endAngle
 * @param Scalar $scalar
 * @param int thickness,
 * @param int lineType, line type:FILLED=-1,LINE_4=4,LINE_8=8,LINE_AA=16
 * @param int shift
 */
PHP_FUNCTION (opencv_ellipse) {

    long angle, startAngle, endAngle, thickness = 1, lineType = LINE_8, shift = 0;
    zval *mat_zval, *point_zval, *size_zval, *scalar_zval;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OOOlllO|lll",
                              &mat_zval, opencv_mat_ce,
                              &point_zval, opencv_point_ce,
                              &size_zval, opencv_size_ce,
                              &angle, &startAngle, &endAngle,
                              &scalar_zval, opencv_scalar_ce,
                              &thickness, &lineType, &shift) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *mat_obj = Z_PHP_MAT_OBJ_P(mat_zval);
    opencv_point_object *point_obj = Z_PHP_POINT_OBJ_P(point_zval);
    opencv_size_object *size_obj = Z_PHP_SIZE_OBJ_P(size_zval);
    opencv_scalar_object *scalar_obj = Z_PHP_SCALAR_OBJ_P(scalar_zval);
    ellipse(*(mat_obj->mat), *(point_obj->point), *(size_obj->size), angle, startAngle, endAngle, *(scalar_obj->scalar),
            (int) thickness, (int) lineType, (int) shift);

    RETURN_NULL();
}

/**
 * CV\circle
 */
PHP_FUNCTION (opencv_circle) {

    long radius, thickness = 1, lineType = LINE_8, shift = 0;
    zval *mat_zval, *point_zval, *scalar_zval;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OOlO|lll",
                              &mat_zval, opencv_mat_ce,
                              &point_zval, opencv_point_ce,
                              &radius,
                              &scalar_zval, opencv_scalar_ce,
                              &thickness, &lineType, &shift) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *mat_obj = Z_PHP_MAT_OBJ_P(mat_zval);
    opencv_point_object *point_obj = Z_PHP_POINT_OBJ_P(point_zval);
    opencv_scalar_object *scalar_obj = Z_PHP_SCALAR_OBJ_P(scalar_zval);

    circle(*(mat_obj->mat), *(point_obj->point), (int) radius, *(scalar_obj->scalar), (int) thickness, (int) lineType,
           (int) shift);

    RETURN_NULL();
}

/**
 * todo 传入二维数组
 * CV\fillPoly
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_fill_poly) {

    long lineType = LINE_8, shift = 0;
    zval *img_zval, *color_zval, *offset_point_zval = NULL;
    zval *points_zval;
    opencv_point_object *offset_object;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OaO|llz",
                              &img_zval, opencv_mat_ce,
                              &points_zval,
                              &color_zval, opencv_scalar_ce,
                              &lineType, &shift,
                              &offset_point_zval) == FAILURE) {
        RETURN_NULL();
    }

#ifdef PHP_WIN32
    //todo windwo报错问题
    opencv_throw_exception("fillPoly function not support Window system.");
    RETURN_NULL();
#else

    long ncontours = 1;
    unsigned long point_count = zend_hash_num_elements(Z_ARRVAL_P(points_zval));
    Point root_points[ncontours][point_count];
    opencv_point_object *point_object;
    zend_ulong _h;
    zval *array_val_zval;
    ZEND_HASH_FOREACH_NUM_KEY_VAL(Z_ARRVAL_P(points_zval), _h, array_val_zval)
                        {
                            again1:
                        if (Z_TYPE_P(array_val_zval) == IS_OBJECT && Z_OBJCE_P(array_val_zval) == opencv_point_ce) {
                                point_object = Z_PHP_POINT_OBJ_P(array_val_zval);
                                root_points[0][_h] = *point_object->point;
                            } else if (Z_TYPE_P(array_val_zval) == IS_REFERENCE) {
                                array_val_zval = Z_REFVAL_P(array_val_zval);
                                goto again1;
                            } else {
                                    opencv_throw_exception("points array value just Point object.");
                                    RETURN_NULL();
                            }
                        }
    ZEND_HASH_FOREACH_END();

    const Point *pts[ncontours];
    pts[0] = root_points[0];
    int npts[] = {(int) point_count};
    Point offset;
    zval *offset_point_real_zval;

    if (offset_point_zval != NULL) {
        offset_point_real_zval = Z_REFVAL_P(offset_point_zval);
        if (Z_TYPE_P(offset_point_real_zval) == IS_OBJECT && Z_OBJCE_P(offset_point_real_zval) == opencv_point_ce) {
            // is Point object
            offset_object = Z_PHP_POINT_OBJ_P(offset_point_real_zval);
        } else {
                // isn't Point object
                zval_ptr_dtor(offset_point_real_zval);
                zval instance;
                object_init_ex(&instance, opencv_point_ce);
                ZVAL_COPY_VALUE(offset_point_real_zval, &instance);// Cover dst_real_zval by Point object
                offset_object = Z_PHP_POINT_OBJ_P(offset_point_real_zval);
        }
    } else {
            offset = Point();
    }

    opencv_mat_object *mat_obj = Z_PHP_MAT_OBJ_P(img_zval);
    opencv_scalar_object *scalar_obj = Z_PHP_SCALAR_OBJ_P(color_zval);

    fillPoly(*(mat_obj->mat), pts, npts, (int) ncontours, *(scalar_obj->scalar), (int) lineType, (int) shift, offset);
    if (offset_point_zval != NULL) {
        offset_object->point = new Point(offset);
        opencv_point_update_property_by_c_point(offset_point_real_zval, offset_object->point);
    }

    RETURN_NULL();
#endif


}


/**
 * CV\line
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_line) {

    long thickness = 1, lineType = LINE_8, shift = 0;
    zval *mat_zval, *start_point_zval, *end_point_zval, *scalar_zval;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OOOO|lll",
                              &mat_zval, opencv_mat_ce,
                              &start_point_zval, opencv_point_ce,
                              &end_point_zval, opencv_point_ce,
                              &scalar_zval, opencv_scalar_ce,
                              &thickness, &lineType, &shift) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *mat_obj = Z_PHP_MAT_OBJ_P(mat_zval);
    opencv_point_object *start_point_obj = Z_PHP_POINT_OBJ_P(start_point_zval);
    opencv_point_object *end_point_obj = Z_PHP_POINT_OBJ_P(end_point_zval);
    opencv_scalar_object *scalar_obj = Z_PHP_SCALAR_OBJ_P(scalar_zval);

    line(*(mat_obj->mat), *(start_point_obj->point), *(end_point_obj->point),
         *(scalar_obj->scalar), (int) thickness, (int) lineType, (int) shift);

    RETURN_NULL();
}

/**
 * CV\rectangle
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_rectangle) {

    long startX, startY, endX, endY;
    long thickness = 1, lineType = LINE_8, shift = 0;
    zval *mat_zval, *color_zval;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OllllO|lll",
                              &mat_zval, opencv_mat_ce,
                              &startX, &startY, &endX, &endY,
                              &color_zval, opencv_scalar_ce,
                              &thickness, &lineType, &shift) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *mat_obj = Z_PHP_MAT_OBJ_P(mat_zval);
    opencv_scalar_object *scalar_obj = Z_PHP_SCALAR_OBJ_P(color_zval);

    rectangle(*(mat_obj->mat), Point((int) startX, (int) startY), Point((int) endX, (int) endY), *(scalar_obj->scalar),
              (int) thickness, (int) lineType, (int) shift);

    RETURN_NULL();
}

/**
 * CV\rectangleByPoint
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_rectangle_by_point) {

    long thickness = 1, lineType = LINE_8, shift = 0;
    zval *mat_zval, *start_point_zval, *end_point_zval, *color_zval;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OOOO|lll",
                              &mat_zval, opencv_mat_ce,
                              &start_point_zval, opencv_point_ce,
                              &end_point_zval, opencv_point_ce,
                              &color_zval, opencv_scalar_ce,
                              &thickness, &lineType, &shift) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *mat_obj = Z_PHP_MAT_OBJ_P(mat_zval);
    opencv_point_object *start_point_obj = Z_PHP_POINT_OBJ_P(start_point_zval);
    opencv_point_object *end_point_obj = Z_PHP_POINT_OBJ_P(end_point_zval);
    opencv_scalar_object *scalar_obj = Z_PHP_SCALAR_OBJ_P(color_zval);

    rectangle(*(mat_obj->mat), *(start_point_obj->point), *(end_point_obj->point), *(scalar_obj->scalar),
              (int) thickness, (int) lineType, (int) shift);

    RETURN_NULL();
}

/**
 * CV\rectangleByRect
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_rectangle_by_rect) {

    long thickness = 1, lineType = LINE_8, shift = 0;
    zval *mat_zval, *rect_zval, *color_zval;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OOO|lll",
                              &mat_zval, opencv_mat_ce,
                              &rect_zval, opencv_rect_ce,
                              &color_zval, opencv_scalar_ce,
                              &thickness, &lineType, &shift) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *mat_obj = Z_PHP_MAT_OBJ_P(mat_zval);
    opencv_rect_object *rect_object = Z_PHP_RECT_OBJ_P(rect_zval);
    opencv_scalar_object *scalar_obj = Z_PHP_SCALAR_OBJ_P(color_zval);

    rectangle(*(mat_obj->mat), *(rect_object->rect), *(scalar_obj->scalar), (int) thickness, (int) lineType,
              (int) shift);

    RETURN_NULL();
}


/**
 * CV\equalizeHist
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_equalize_hist) {

    zval *src_zval, *dst_zval;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Oz",
                              &src_zval, opencv_mat_ce,
                              &dst_zval) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *src_obj, *dst_object;
    src_obj = Z_PHP_MAT_OBJ_P(src_zval);
    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }
    try {
        equalizeHist(*src_obj->mat, *dst_object->mat);
    } catch (Exception e) {
        opencv_throw_exception(e.what());
    }
    RETURN_NULL();
}


PHP_FUNCTION (opencv_resize) {

    zval *src_zval, *dst_zval, *dsize_zval;
    double fx = 0, fy = 0;
    long interpolation = INTER_LINEAR;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OzO|ddl",
                              &src_zval, opencv_mat_ce,
                              &dst_zval,
                              &dsize_zval, opencv_size_ce,
                              &fx, &fy, &interpolation
    ) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *src_obj, *dst_object;
    src_obj = Z_PHP_MAT_OBJ_P(src_zval);
    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }
    opencv_size_object *dsize_obj = Z_PHP_SIZE_OBJ_P(dsize_zval);
    try {
        resize(*src_obj->mat, *dst_object->mat, *dsize_obj->size, fx, fy, (int) interpolation);
    } catch (Exception e) {
        opencv_throw_exception(e.what());
    }
    RETURN_NULL();
}

/**
 * CV\putText
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_put_text) {

    zval *img_zval, *org_zval, *color_zval;
    char *text;
    long text_len = 0;
    long font_face, thickness = 1, line_type = LINE_8;
    double font_scale;
    zend_bool bottom_left_origin = 0;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OsOldO|llb",
                              &img_zval, opencv_mat_ce,
                              &text, &text_len,
                              &org_zval, opencv_point_ce,
                              &font_face, &font_scale,
                              &color_zval, opencv_scalar_ce,
                              &thickness, &line_type,
                              &bottom_left_origin
    ) == FAILURE) {
        RETURN_NULL();
    }
    opencv_mat_object *img_object = Z_PHP_MAT_OBJ_P(img_zval);
    opencv_point_object *org_object = Z_PHP_POINT_OBJ_P(org_zval);
    opencv_scalar_object *color_object = Z_PHP_SCALAR_OBJ_P(color_zval);
    putText(*img_object->mat, text, *org_object->point, (int) font_face, (int) font_scale, *color_object->scalar,
            (int) thickness, (int) line_type, (bool) bottom_left_origin);
}

/**
 * CV\blur
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_blur) {

    zval *src_zval, *dst_zval, *ksize_zval, *anchor_zval = NULL;
    long border_type = BORDER_DEFAULT;
    Point anchor = Point(-1, -1);
    opencv_mat_object *dst_object;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OzO|Ol",
                              &src_zval, opencv_mat_ce,
                              &dst_zval,
                              &ksize_zval, opencv_size_ce,
                              &anchor_zval, opencv_point_ce,
                              &border_type) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *src_object = Z_PHP_MAT_OBJ_P(src_zval);
    opencv_size_object *ksize_object = Z_PHP_SIZE_OBJ_P(ksize_zval);
    if (anchor_zval != NULL) {
        opencv_point_object *anchor_object = Z_PHP_POINT_OBJ_P(anchor_zval);
        anchor = *anchor_object->point;
    }

    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }
    blur(*src_object->mat, *dst_object->mat, *ksize_object->size, anchor, (int) border_type);
    RETURN_NULL();
}

PHP_FUNCTION (opencv_gaussian_blur) {

    zval *src_zval, *dst_zval, *ksize_zval;
    double sigma_x, sigma_y = 0;
    long border_type = BORDER_DEFAULT;
    opencv_mat_object *dst_object;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OzOd|dl",
                              &src_zval, opencv_mat_ce,
                              &dst_zval,
                              &ksize_zval, opencv_size_ce,
                              &sigma_x, &sigma_y,
                              &border_type) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *src_object = Z_PHP_MAT_OBJ_P(src_zval);
    opencv_size_object *ksize_object = Z_PHP_SIZE_OBJ_P(ksize_zval);

    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }
    GaussianBlur(*src_object->mat, *dst_object->mat, *ksize_object->size, sigma_x, sigma_y, (int) border_type);
    RETURN_NULL();
}

PHP_FUNCTION (opencv_median_blur) {

    zval *src_zval, *dst_zval;
    long ksize;
    opencv_mat_object *dst_object;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Ozl",
                              &src_zval, opencv_mat_ce,
                              &dst_zval, &ksize) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *src_object = Z_PHP_MAT_OBJ_P(src_zval);

    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }
    medianBlur(*src_object->mat, *dst_object->mat, (int) ksize);
    RETURN_NULL();
}

PHP_FUNCTION (opencv_bilateral_filter) {

    zval *src_zval, *dst_zval;
    long d, border_type = BORDER_DEFAULT;
    double sigma_color, sigma_space;
    opencv_mat_object *dst_object;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Ozldd|l",
                              &src_zval, opencv_mat_ce,
                              &dst_zval, &d, &sigma_color,
                              &sigma_space, &border_type) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *src_object = Z_PHP_MAT_OBJ_P(src_zval);

    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }
    bilateralFilter(*src_object->mat, *dst_object->mat, (int) d, sigma_color, sigma_space, (int) border_type);
    RETURN_NULL();
}


PHP_FUNCTION (opencv_dilate) {
    zval *src_zval, *dst_zval, *kernel_zval, *anchor_zval = NULL, *border_value_zval = NULL;
    long iterations = 1, border_type = BORDER_CONSTANT;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OzO|OllO",
                              &src_zval, opencv_mat_ce,
                              &dst_zval,
                              &kernel_zval, opencv_mat_ce,
                              &anchor_zval, opencv_point_ce,
                              &iterations, &border_type,
                              &border_value_zval, opencv_scalar_ce) == FAILURE) {
        RETURN_NULL();
    }
    opencv_mat_object *src_object, *dst_object, *kernel_object;
    Point anchor = Point(-1, -1);
    Scalar border_value = morphologyDefaultBorderValue();

    src_object = Z_PHP_MAT_OBJ_P(src_zval);
    kernel_object = Z_PHP_MAT_OBJ_P(kernel_zval);
    zval *dst_real_zval = Z_REFVAL_P(dst_zval);

    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }

    if (anchor_zval != NULL) {
        opencv_point_object *anchor_object = Z_PHP_POINT_OBJ_P(anchor_zval);
        anchor = *anchor_object->point;
    }

    if (border_value_zval != NULL) {
        opencv_scalar_object *border_value_object = Z_PHP_SCALAR_OBJ_P(border_value_zval);
        border_value = *border_value_object->scalar;
    }

    dilate(*src_object->mat, *dst_object->mat, *kernel_object->mat, anchor, (int) iterations, (int) border_type,
           border_value);
    RETURN_NULL();

}

PHP_FUNCTION (opencv_erode) {

    zval *src_zval, *dst_zval, *kernel_zval, *anchor_zval = NULL, *border_value_zval = NULL;
    long iterations = 1, border_type = BORDER_CONSTANT;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OzO|OllO",
                              &src_zval, opencv_mat_ce,
                              &dst_zval,
                              &kernel_zval, opencv_mat_ce,
                              &anchor_zval, opencv_point_ce,
                              &iterations, &border_type,
                              &border_value_zval, opencv_scalar_ce) == FAILURE) {
        RETURN_NULL();
    }
    opencv_mat_object *src_object, *dst_object, *kernel_object;
    Point anchor = Point(-1, -1);
    Scalar border_value = morphologyDefaultBorderValue();

    src_object = Z_PHP_MAT_OBJ_P(src_zval);
    kernel_object = Z_PHP_MAT_OBJ_P(kernel_zval);
    zval *dst_real_zval = Z_REFVAL_P(dst_zval);

    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }

    if (anchor_zval != NULL) {
        opencv_point_object *anchor_object = Z_PHP_POINT_OBJ_P(anchor_zval);
        anchor = *anchor_object->point;
    }

    if (border_value_zval != NULL) {
        opencv_scalar_object *border_value_object = Z_PHP_SCALAR_OBJ_P(border_value_zval);
        border_value = *border_value_object->scalar;
    }
    erode(*src_object->mat, *dst_object->mat, *kernel_object->mat, anchor, (int) iterations, (int) border_type,
          border_value);
    RETURN_NULL();
}


PHP_FUNCTION (opencv_threshold) {

    zval *src_zval, *dst_zval;
    double thresh, maxval;
    long type;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Ozddl",
                              &src_zval, opencv_mat_ce,
                              &dst_zval,
                              &thresh, &maxval,
                              &type) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *src_object, *dst_object;

    src_object = Z_PHP_MAT_OBJ_P(src_zval);
    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }
    RETURN_DOUBLE(threshold(*src_object->mat, *dst_object->mat, thresh, maxval, (int) type));
}


PHP_FUNCTION (opencv_adaptive_threshold) {

    zval *src_zval, *dst_zval;
    double maxValue, C;
    long adaptiveMethod, thresholdType, blockSize;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Ozdllld",
                              &src_zval, opencv_mat_ce,
                              &dst_zval,
                              &maxValue, &adaptiveMethod,
                              &thresholdType, &blockSize, &C) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *src_object, *dst_object;

    src_object = Z_PHP_MAT_OBJ_P(src_zval);
    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }

    adaptiveThreshold(*src_object->mat, *dst_object->mat, maxValue, (int) adaptiveMethod, (int) thresholdType,
                      (int) blockSize, C);
    RETURN_NULL();
}


/**
 * CV\sobel
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_sobel) {

    zval *src_zval, *dst_zval;
    long ddepth, dx, dy;
    long ksize = 3;

    double delta = 0.0, scale = 1.0;
    long border_type = BORDER_DEFAULT;
    opencv_mat_object *dst_object;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Ozlll|lddl",
                              &src_zval, opencv_mat_ce,
                              &dst_zval,
                              &ddepth,
                              &dx,
                              &dy,
                              &ksize,
                              &scale,
                              &delta,
                              &border_type) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *src_object = Z_PHP_MAT_OBJ_P(src_zval);

    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }
    Sobel(*src_object->mat, *dst_object->mat, (int) ddepth, (int) dx, (int) dy, (int) ksize, scale, delta,
          (int) border_type);
    RETURN_NULL();
}

/**
 * CV\Scharr
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_scharr) {

    zval *src_zval, *dst_zval;
    long ddepth, dx, dy;

    double delta = 0.0, scale = 1.0;
    long border_type = BORDER_DEFAULT;
    opencv_mat_object *dst_object;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Ozlll|ddl",
                              &src_zval, opencv_mat_ce,
                              &dst_zval,
                              &ddepth,
                              &dx,
                              &dy,
                              &scale,
                              &delta,
                              &border_type) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *src_object = Z_PHP_MAT_OBJ_P(src_zval);

    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }
    Scharr(*src_object->mat, *dst_object->mat, (int) ddepth, (int) dx, (int) dy, scale, delta, (int) border_type);
    RETURN_NULL();
}

/**
 * CV\laplacian
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_laplacian) {

    zval *src_zval, *dst_zval;
    long ddepth;
    long ksize = 3;

    double delta = 0.0, scale = 1.0;
    long border_type = BORDER_DEFAULT;
    opencv_mat_object *dst_object;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Ozl|lddl",
                              &src_zval, opencv_mat_ce,
                              &dst_zval,
                              &ddepth,
                              &ksize,
                              &scale,
                              &delta,
                              &border_type) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *src_object = Z_PHP_MAT_OBJ_P(src_zval);

    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }
    Laplacian(*src_object->mat, *dst_object->mat, (int) ddepth, (int) ksize, scale, delta, (int) border_type);
    RETURN_NULL();
}

/**
 * CV\filter2D
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_filter2D) {

    zval *src_zval, *dst_zval, *kernel_zval, *anchor_zval = NULL;
    long ddepth;
    Point anchor = Point(-1, -1);
    double delta = 0.0;
    long border_type = BORDER_DEFAULT;
    opencv_mat_object *dst_object;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "OzlO|Odl",
                              &src_zval, opencv_mat_ce,
                              &dst_zval,
                              &ddepth,
                              &kernel_zval, opencv_mat_ce,
                              &anchor_zval, opencv_point_ce,
                              &delta,
                              &border_type) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *src_object = Z_PHP_MAT_OBJ_P(src_zval);
    opencv_mat_object *kernel_object = Z_PHP_MAT_OBJ_P(kernel_zval);
    if (anchor_zval != NULL) {
        opencv_point_object *anchor_object = Z_PHP_POINT_OBJ_P(anchor_zval);
        anchor = *anchor_object->point;
    }

    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }
    filter2D(*src_object->mat, *dst_object->mat, (int) ddepth, *kernel_object->mat, anchor, delta, (int) border_type);
    RETURN_NULL();
}

/**
 * CV\convertScaleAbs
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_convert_scale_abs) {

    zval *src_zval, *dst_zval;
    double alpha = 1.0;
    double beta = 0.0;

    opencv_mat_object *dst_object;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "Oz|dd",
                              &src_zval, opencv_mat_ce,
                              &dst_zval,
                              &alpha,
                              &beta) == FAILURE) {
        RETURN_NULL();
    }

    opencv_mat_object *src_object = Z_PHP_MAT_OBJ_P(src_zval);

    zval *dst_real_zval = Z_REFVAL_P(dst_zval);
    if (Z_TYPE_P(dst_real_zval) == IS_OBJECT && Z_OBJCE_P(dst_real_zval) == opencv_mat_ce) {
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
    } else {
        zval_ptr_dtor(dst_real_zval);
        zval instance;
        Mat dst;
        object_init_ex(&instance, opencv_mat_ce);
        ZVAL_COPY_VALUE(dst_real_zval, &instance);
        dst_object = Z_PHP_MAT_OBJ_P(dst_real_zval);
        dst_object->mat = new Mat(dst);
    }
    convertScaleAbs(*src_object->mat, *dst_object->mat, alpha, beta);
    RETURN_NULL();
}

/**
 * CV\getStructuringElement
 * @param execute_data
 * @param return_value
 */
PHP_FUNCTION (opencv_get_structuring_element) {
    long shape;
    zval *ksize_zval, *anchor_zval = NULL;
    Point anchor = Point(-1, -1);
    Mat dst;
    if (zend_parse_parameters(ZEND_NUM_ARGS(), "lO|O",
                              &shape,
                              &ksize_zval, opencv_size_ce,
                              &anchor_zval, opencv_point_ce) == FAILURE) {
        RETURN_NULL();
    }

    opencv_size_object *ksize_object = Z_PHP_SIZE_OBJ_P(ksize_zval);
    if (anchor_zval != NULL) {
        opencv_point_object *anchor_object = Z_PHP_POINT_OBJ_P(anchor_zval);
        anchor = *anchor_object->point;
    }

    dst = getStructuringElement((int) shape, *ksize_object->size, anchor);

    zval instance;
    object_init_ex(&instance, opencv_mat_ce);
    opencv_mat_object *dst_obj = Z_PHP_MAT_OBJ_P(&instance);

    dst_obj->mat = new Mat(dst);
    opencv_mat_update_property_by_c_mat(&instance, dst_obj->mat);

    RETURN_ZVAL(&instance, 0, 0); //return php Mat object
}