using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace OpenCVCompact
{

    // C++: class StereoSGBM
    /**
     * The class implements the modified H. Hirschmuller algorithm CITE: HH08 that differs from the original
     * one as follows:
     *
     * <ul>
     *   <li>
     *    By default, the algorithm is single-pass, which means that you consider only 5 directions
     * instead of 8. Set mode=StereoSGBM::MODE_HH in createStereoSGBM to run the full variant of the
     * algorithm but beware that it may consume a lot of memory.
     *   </li>
     *   <li>
     *    The algorithm matches blocks, not individual pixels. Though, setting blockSize=1 reduces the
     * blocks to single pixels.
     *   </li>
     *   <li>
     *    Mutual information cost function is not implemented. Instead, a simpler Birchfield-Tomasi
     * sub-pixel metric from CITE: BT98 is used. Though, the color images are supported as well.
     *   </li>
     *   <li>
     *    Some pre- and post- processing steps from K. Konolige algorithm StereoBM are included, for
     * example: pre-filtering (StereoBM::PREFILTER_XSOBEL type) and post-filtering (uniqueness
     * check, quadratic interpolation and speckle filtering).
     *   </li>
     * </ul>
     *
     * <b>Note:</b>
     * <ul>
     *   <li>
     *       (Python) An example illustrating the use of the StereoSGBM matching algorithm can be found
     *         at opencv_source_code/samples/python/stereo_match.py
     *   </li>
     * </ul>
     */
    public class StereoSGBM : StereoMatcher
    {

        protected override void Dispose(bool disposing)
        {
            try
            {
                if (disposing)
                {
                }
                if (IsEnabledDispose)
                {
                    if (nativeObj != IntPtr.Zero)
                        StereoSGBM_delete(nativeObj);
                    nativeObj = IntPtr.Zero;
                }
            }
            finally
            {
                base.Dispose(disposing);
            }

        }

        protected internal StereoSGBM(IntPtr addr) : base(addr) { }

        // internal usage only
        public static new StereoSGBM __fromPtr__(IntPtr addr) { return new StereoSGBM(addr); }

        // C++: enum <unnamed>
        public const int MODE_SGBM = 0;
        public const int MODE_HH = 1;
        public const int MODE_SGBM_3WAY = 2;
        public const int MODE_HH4 = 3;

        //
        // C++: static Ptr_StereoSGBM cv::StereoSGBM::create(int minDisparity = 0, int numDisparities = 16, int blockSize = 3, int P1 = 0, int P2 = 0, int disp12MaxDiff = 0, int preFilterCap = 0, int uniquenessRatio = 0, int speckleWindowSize = 0, int speckleRange = 0, int mode = StereoSGBM::MODE_SGBM)
        //

        /**
         * Creates StereoSGBM object
         *
         *     @param minDisparity Minimum possible disparity value. Normally, it is zero but sometimes
         *     rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.
         *     @param numDisparities Maximum disparity minus minimum disparity. The value is always greater than
         *     zero. In the current implementation, this parameter must be divisible by 16.
         *     @param blockSize Matched block size. It must be an odd number &gt;=1 . Normally, it should be
         *     somewhere in the 3..11 range.
         *     @param P1 The first parameter controlling the disparity smoothness. See below.
         *     @param P2 The second parameter controlling the disparity smoothness. The larger the values are,
         *     the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1
         *     between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor
         *     pixels. The algorithm requires P2 &gt; P1 . See stereo_match.cpp sample where some reasonably good
         *     P1 and P2 values are shown (like 8\*number_of_image_channels\*blockSize\*blockSize and
         *     32\*number_of_image_channels\*blockSize\*blockSize , respectively).
         *     @param disp12MaxDiff Maximum allowed difference (in integer pixel units) in the left-right
         *     disparity check. Set it to a non-positive value to disable the check.
         *     @param preFilterCap Truncation value for the prefiltered image pixels. The algorithm first
         *     computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.
         *     The result values are passed to the Birchfield-Tomasi pixel cost function.
         *     @param uniquenessRatio Margin in percentage by which the best (minimum) computed cost function
         *     value should "win" the second best value to consider the found match correct. Normally, a value
         *     within the 5-15 range is good enough.
         *     @param speckleWindowSize Maximum size of smooth disparity regions to consider their noise speckles
         *     and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the
         *     50-200 range.
         *     @param speckleRange Maximum disparity variation within each connected component. If you do speckle
         *     filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.
         *     Normally, 1 or 2 is good enough.
         *     @param mode Set it to StereoSGBM::MODE_HH to run the full-scale two-pass dynamic programming
         *     algorithm. It will consume O(W\*H\*numDisparities) bytes, which is large for 640x480 stereo and
         *     huge for HD-size pictures. By default, it is set to false .
         *
         *     The first constructor initializes StereoSGBM with all the default parameters. So, you only have to
         *     set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter
         *     to a custom value.
         * @return automatically generated
         */
        public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange, int mode)
        {
            return StereoSGBM.__fromPtr__(StereoSGBM_create_10(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, mode));
        }

        /**
        * Creates StereoSGBM object
        *
        *     @param minDisparity Minimum possible disparity value. Normally, it is zero but sometimes
        *     rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.
        *     @param numDisparities Maximum disparity minus minimum disparity. The value is always greater than
        *     zero. In the current implementation, this parameter must be divisible by 16.
        *     @param blockSize Matched block size. It must be an odd number &gt;=1 . Normally, it should be
        *     somewhere in the 3..11 range.
        *     @param P1 The first parameter controlling the disparity smoothness. See below.
        *     @param P2 The second parameter controlling the disparity smoothness. The larger the values are,
        *     the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1
        *     between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor
        *     pixels. The algorithm requires P2 &gt; P1 . See stereo_match.cpp sample where some reasonably good
        *     P1 and P2 values are shown (like 8\*number_of_image_channels\*blockSize\*blockSize and
        *     32\*number_of_image_channels\*blockSize\*blockSize , respectively).
        *     @param disp12MaxDiff Maximum allowed difference (in integer pixel units) in the left-right
        *     disparity check. Set it to a non-positive value to disable the check.
        *     @param preFilterCap Truncation value for the prefiltered image pixels. The algorithm first
        *     computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.
        *     The result values are passed to the Birchfield-Tomasi pixel cost function.
        *     @param uniquenessRatio Margin in percentage by which the best (minimum) computed cost function
        *     value should "win" the second best value to consider the found match correct. Normally, a value
        *     within the 5-15 range is good enough.
        *     @param speckleWindowSize Maximum size of smooth disparity regions to consider their noise speckles
        *     and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the
        *     50-200 range.
        *     @param speckleRange Maximum disparity variation within each connected component. If you do speckle
        *     filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.
        *     Normally, 1 or 2 is good enough.
        *     algorithm. It will consume O(W\*H\*numDisparities) bytes, which is large for 640x480 stereo and
        *     huge for HD-size pictures. By default, it is set to false .
        *
        *     The first constructor initializes StereoSGBM with all the default parameters. So, you only have to
        *     set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter
        *     to a custom value.
        * @return automatically generated
        */
        public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange)
        {        
            return StereoSGBM.__fromPtr__(StereoSGBM_create_11(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange));
        }

        /**
       * Creates StereoSGBM object
       *
       *     @param minDisparity Minimum possible disparity value. Normally, it is zero but sometimes
       *     rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.
       *     @param numDisparities Maximum disparity minus minimum disparity. The value is always greater than
       *     zero. In the current implementation, this parameter must be divisible by 16.
       *     @param blockSize Matched block size. It must be an odd number &gt;=1 . Normally, it should be
       *     somewhere in the 3..11 range.
       *     @param P1 The first parameter controlling the disparity smoothness. See below.
       *     @param P2 The second parameter controlling the disparity smoothness. The larger the values are,
       *     the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1
       *     between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor
       *     pixels. The algorithm requires P2 &gt; P1 . See stereo_match.cpp sample where some reasonably good
       *     P1 and P2 values are shown (like 8\*number_of_image_channels\*blockSize\*blockSize and
       *     32\*number_of_image_channels\*blockSize\*blockSize , respectively).
       *     @param disp12MaxDiff Maximum allowed difference (in integer pixel units) in the left-right
       *     disparity check. Set it to a non-positive value to disable the check.
       *     @param preFilterCap Truncation value for the prefiltered image pixels. The algorithm first
       *     computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.
       *     The result values are passed to the Birchfield-Tomasi pixel cost function.
       *     @param uniquenessRatio Margin in percentage by which the best (minimum) computed cost function
       *     value should "win" the second best value to consider the found match correct. Normally, a value
       *     within the 5-15 range is good enough.
       *     @param speckleWindowSize Maximum size of smooth disparity regions to consider their noise speckles
       *     and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the
       *     50-200 range.
       *     filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.
       *     Normally, 1 or 2 is good enough.
       *     algorithm. It will consume O(W\*H\*numDisparities) bytes, which is large for 640x480 stereo and
       *     huge for HD-size pictures. By default, it is set to false .
       *
       *     The first constructor initializes StereoSGBM with all the default parameters. So, you only have to
       *     set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter
       *     to a custom value.
       * @return automatically generated
       */
        public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize)
        {
            return StereoSGBM.__fromPtr__(StereoSGBM_create_12(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize));     
        }

        /**
     * Creates StereoSGBM object
     *
     *     @param minDisparity Minimum possible disparity value. Normally, it is zero but sometimes
     *     rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.
     *     @param numDisparities Maximum disparity minus minimum disparity. The value is always greater than
     *     zero. In the current implementation, this parameter must be divisible by 16.
     *     @param blockSize Matched block size. It must be an odd number &gt;=1 . Normally, it should be
     *     somewhere in the 3..11 range.
     *     @param P1 The first parameter controlling the disparity smoothness. See below.
     *     @param P2 The second parameter controlling the disparity smoothness. The larger the values are,
     *     the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1
     *     between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor
     *     pixels. The algorithm requires P2 &gt; P1 . See stereo_match.cpp sample where some reasonably good
     *     P1 and P2 values are shown (like 8\*number_of_image_channels\*blockSize\*blockSize and
     *     32\*number_of_image_channels\*blockSize\*blockSize , respectively).
     *     @param disp12MaxDiff Maximum allowed difference (in integer pixel units) in the left-right
     *     disparity check. Set it to a non-positive value to disable the check.
     *     @param preFilterCap Truncation value for the prefiltered image pixels. The algorithm first
     *     computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.
     *     The result values are passed to the Birchfield-Tomasi pixel cost function.
     *     @param uniquenessRatio Margin in percentage by which the best (minimum) computed cost function
     *     value should "win" the second best value to consider the found match correct. Normally, a value
     *     within the 5-15 range is good enough.
     *     and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the
     *     50-200 range.
     *     filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.
     *     Normally, 1 or 2 is good enough.
     *     algorithm. It will consume O(W\*H\*numDisparities) bytes, which is large for 640x480 stereo and
     *     huge for HD-size pictures. By default, it is set to false .
     *
     *     The first constructor initializes StereoSGBM with all the default parameters. So, you only have to
     *     set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter
     *     to a custom value.
     * @return automatically generated
     */
        public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio)
        {
            return StereoSGBM.__fromPtr__(StereoSGBM_create_13(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio));
        }

        /**
           * Creates StereoSGBM object
           *
           *     @param minDisparity Minimum possible disparity value. Normally, it is zero but sometimes
           *     rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.
           *     @param numDisparities Maximum disparity minus minimum disparity. The value is always greater than
           *     zero. In the current implementation, this parameter must be divisible by 16.
           *     @param blockSize Matched block size. It must be an odd number &gt;=1 . Normally, it should be
           *     somewhere in the 3..11 range.
           *     @param P1 The first parameter controlling the disparity smoothness. See below.
           *     @param P2 The second parameter controlling the disparity smoothness. The larger the values are,
           *     the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1
           *     between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor
           *     pixels. The algorithm requires P2 &gt; P1 . See stereo_match.cpp sample where some reasonably good
           *     P1 and P2 values are shown (like 8\*number_of_image_channels\*blockSize\*blockSize and
           *     32\*number_of_image_channels\*blockSize\*blockSize , respectively).
           *     @param disp12MaxDiff Maximum allowed difference (in integer pixel units) in the left-right
           *     disparity check. Set it to a non-positive value to disable the check.
           *     @param preFilterCap Truncation value for the prefiltered image pixels. The algorithm first
           *     computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.
           *     The result values are passed to the Birchfield-Tomasi pixel cost function.
           *     value should "win" the second best value to consider the found match correct. Normally, a value
           *     within the 5-15 range is good enough.
           *     and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the
           *     50-200 range.
           *     filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.
           *     Normally, 1 or 2 is good enough.
           *     algorithm. It will consume O(W\*H\*numDisparities) bytes, which is large for 640x480 stereo and
           *     huge for HD-size pictures. By default, it is set to false .
           *
           *     The first constructor initializes StereoSGBM with all the default parameters. So, you only have to
           *     set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter
           *     to a custom value.
           * @return automatically generated
           */
        public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap)
        {  
            return StereoSGBM.__fromPtr__(StereoSGBM_create_14(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap));
        }

        /**
        * Creates StereoSGBM object
        *
        *     @param minDisparity Minimum possible disparity value. Normally, it is zero but sometimes
        *     rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.
        *     @param numDisparities Maximum disparity minus minimum disparity. The value is always greater than
        *     zero. In the current implementation, this parameter must be divisible by 16.
        *     @param blockSize Matched block size. It must be an odd number &gt;=1 . Normally, it should be
        *     somewhere in the 3..11 range.
        *     @param P1 The first parameter controlling the disparity smoothness. See below.
        *     @param P2 The second parameter controlling the disparity smoothness. The larger the values are,
        *     the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1
        *     between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor
        *     pixels. The algorithm requires P2 &gt; P1 . See stereo_match.cpp sample where some reasonably good
        *     P1 and P2 values are shown (like 8\*number_of_image_channels\*blockSize\*blockSize and
        *     32\*number_of_image_channels\*blockSize\*blockSize , respectively).
        *     @param disp12MaxDiff Maximum allowed difference (in integer pixel units) in the left-right
        *     disparity check. Set it to a non-positive value to disable the check.
        *     computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.
        *     The result values are passed to the Birchfield-Tomasi pixel cost function.
        *     value should "win" the second best value to consider the found match correct. Normally, a value
        *     within the 5-15 range is good enough.
        *     and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the
        *     50-200 range.
        *     filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.
        *     Normally, 1 or 2 is good enough.
        *     algorithm. It will consume O(W\*H\*numDisparities) bytes, which is large for 640x480 stereo and
        *     huge for HD-size pictures. By default, it is set to false .
        *
        *     The first constructor initializes StereoSGBM with all the default parameters. So, you only have to
        *     set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter
        *     to a custom value.
        * @return automatically generated
        */
        public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff)
        {
            return StereoSGBM.__fromPtr__(StereoSGBM_create_15(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff));
        }

        /**
           * Creates StereoSGBM object
           *
           *     @param minDisparity Minimum possible disparity value. Normally, it is zero but sometimes
           *     rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.
           *     @param numDisparities Maximum disparity minus minimum disparity. The value is always greater than
           *     zero. In the current implementation, this parameter must be divisible by 16.
           *     @param blockSize Matched block size. It must be an odd number &gt;=1 . Normally, it should be
           *     somewhere in the 3..11 range.
           *     @param P1 The first parameter controlling the disparity smoothness. See below.
           *     @param P2 The second parameter controlling the disparity smoothness. The larger the values are,
           *     the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1
           *     between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor
           *     pixels. The algorithm requires P2 &gt; P1 . See stereo_match.cpp sample where some reasonably good
           *     P1 and P2 values are shown (like 8\*number_of_image_channels\*blockSize\*blockSize and
           *     32\*number_of_image_channels\*blockSize\*blockSize , respectively).
           *     disparity check. Set it to a non-positive value to disable the check.
           *     computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.
           *     The result values are passed to the Birchfield-Tomasi pixel cost function.
           *     value should "win" the second best value to consider the found match correct. Normally, a value
           *     within the 5-15 range is good enough.
           *     and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the
           *     50-200 range.
           *     filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.
           *     Normally, 1 or 2 is good enough.
           *     algorithm. It will consume O(W\*H\*numDisparities) bytes, which is large for 640x480 stereo and
           *     huge for HD-size pictures. By default, it is set to false .
           *
           *     The first constructor initializes StereoSGBM with all the default parameters. So, you only have to
           *     set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter
           *     to a custom value.
           * @return automatically generated
           */
        public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2)
        {        
        return StereoSGBM.__fromPtr__(StereoSGBM_create_16(minDisparity, numDisparities, blockSize, P1, P2));
        }

        /**
          * Creates StereoSGBM object
          *
          *     @param minDisparity Minimum possible disparity value. Normally, it is zero but sometimes
          *     rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.
          *     @param numDisparities Maximum disparity minus minimum disparity. The value is always greater than
          *     zero. In the current implementation, this parameter must be divisible by 16.
          *     @param blockSize Matched block size. It must be an odd number &gt;=1 . Normally, it should be
          *     somewhere in the 3..11 range.
          *     @param P1 The first parameter controlling the disparity smoothness. See below.
          *     the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1
          *     between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor
          *     pixels. The algorithm requires P2 &gt; P1 . See stereo_match.cpp sample where some reasonably good
          *     P1 and P2 values are shown (like 8\*number_of_image_channels\*blockSize\*blockSize and
          *     32\*number_of_image_channels\*blockSize\*blockSize , respectively).
          *     disparity check. Set it to a non-positive value to disable the check.
          *     computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.
          *     The result values are passed to the Birchfield-Tomasi pixel cost function.
          *     value should "win" the second best value to consider the found match correct. Normally, a value
          *     within the 5-15 range is good enough.
          *     and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the
          *     50-200 range.
          *     filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.
          *     Normally, 1 or 2 is good enough.
          *     algorithm. It will consume O(W\*H\*numDisparities) bytes, which is large for 640x480 stereo and
          *     huge for HD-size pictures. By default, it is set to false .
          *
          *     The first constructor initializes StereoSGBM with all the default parameters. So, you only have to
          *     set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter
          *     to a custom value.
          * @return automatically generated
          */
        public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1)
        {
        return StereoSGBM.__fromPtr__(StereoSGBM_create_17(minDisparity, numDisparities, blockSize, P1));
        }

        /**
           * Creates StereoSGBM object
           *
           *     @param minDisparity Minimum possible disparity value. Normally, it is zero but sometimes
           *     rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.
           *     @param numDisparities Maximum disparity minus minimum disparity. The value is always greater than
           *     zero. In the current implementation, this parameter must be divisible by 16.
           *     @param blockSize Matched block size. It must be an odd number &gt;=1 . Normally, it should be
           *     somewhere in the 3..11 range.
           *     the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1
           *     between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor
           *     pixels. The algorithm requires P2 &gt; P1 . See stereo_match.cpp sample where some reasonably good
           *     P1 and P2 values are shown (like 8\*number_of_image_channels\*blockSize\*blockSize and
           *     32\*number_of_image_channels\*blockSize\*blockSize , respectively).
           *     disparity check. Set it to a non-positive value to disable the check.
           *     computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.
           *     The result values are passed to the Birchfield-Tomasi pixel cost function.
           *     value should "win" the second best value to consider the found match correct. Normally, a value
           *     within the 5-15 range is good enough.
           *     and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the
           *     50-200 range.
           *     filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.
           *     Normally, 1 or 2 is good enough.
           *     algorithm. It will consume O(W\*H\*numDisparities) bytes, which is large for 640x480 stereo and
           *     huge for HD-size pictures. By default, it is set to false .
           *
           *     The first constructor initializes StereoSGBM with all the default parameters. So, you only have to
           *     set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter
           *     to a custom value.
           * @return automatically generated
           */
        public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize)
        {
        return StereoSGBM.__fromPtr__(StereoSGBM_create_18(minDisparity, numDisparities, blockSize));
        }

        //javadoc: StereoSGBM::create(minDisparity, numDisparities)
        public static StereoSGBM create(int minDisparity, int numDisparities)
        {
#if UNITY_5_3_OR_NEWER
        
        StereoSGBM retVal = StereoSGBM.__fromPtr__(StereoSGBM_create_19(minDisparity, numDisparities));
        
        return retVal;
#else
            return null;
#endif
        }

        /**
    * Creates StereoSGBM object
    *
    *     @param minDisparity Minimum possible disparity value. Normally, it is zero but sometimes
    *     rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.
    *     zero. In the current implementation, this parameter must be divisible by 16.
    *     somewhere in the 3..11 range.
    *     the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1
    *     between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor
    *     pixels. The algorithm requires P2 &gt; P1 . See stereo_match.cpp sample where some reasonably good
    *     P1 and P2 values are shown (like 8\*number_of_image_channels\*blockSize\*blockSize and
    *     32\*number_of_image_channels\*blockSize\*blockSize , respectively).
    *     disparity check. Set it to a non-positive value to disable the check.
    *     computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.
    *     The result values are passed to the Birchfield-Tomasi pixel cost function.
    *     value should "win" the second best value to consider the found match correct. Normally, a value
    *     within the 5-15 range is good enough.
    *     and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the
    *     50-200 range.
    *     filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.
    *     Normally, 1 or 2 is good enough.
    *     algorithm. It will consume O(W\*H\*numDisparities) bytes, which is large for 640x480 stereo and
    *     huge for HD-size pictures. By default, it is set to false .
    *
    *     The first constructor initializes StereoSGBM with all the default parameters. So, you only have to
    *     set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter
    *     to a custom value.
    * @return automatically generated
    */
        public static StereoSGBM create(int minDisparity)
        {        
        return StereoSGBM.__fromPtr__(StereoSGBM_create_110(minDisparity));
        }

        /**
          * Creates StereoSGBM object
          *
          *     rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.
          *     zero. In the current implementation, this parameter must be divisible by 16.
          *     somewhere in the 3..11 range.
          *     the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1
          *     between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor
          *     pixels. The algorithm requires P2 &gt; P1 . See stereo_match.cpp sample where some reasonably good
          *     P1 and P2 values are shown (like 8\*number_of_image_channels\*blockSize\*blockSize and
          *     32\*number_of_image_channels\*blockSize\*blockSize , respectively).
          *     disparity check. Set it to a non-positive value to disable the check.
          *     computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.
          *     The result values are passed to the Birchfield-Tomasi pixel cost function.
          *     value should "win" the second best value to consider the found match correct. Normally, a value
          *     within the 5-15 range is good enough.
          *     and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the
          *     50-200 range.
          *     filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.
          *     Normally, 1 or 2 is good enough.
          *     algorithm. It will consume O(W\*H\*numDisparities) bytes, which is large for 640x480 stereo and
          *     huge for HD-size pictures. By default, it is set to false .
          *
          *     The first constructor initializes StereoSGBM with all the default parameters. So, you only have to
          *     set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter
          *     to a custom value.
          * @return automatically generated
          */
        public static StereoSGBM create()
        {
        return StereoSGBM.__fromPtr__(StereoSGBM_create_111());
        }


        //
        // C++:  int cv::StereoSGBM::getMode()
        //

        //javadoc: StereoSGBM::getMode()
        public int getMode()
        {
        return StereoSGBM_getMode_10(nativeObj);
        }


        //
        // C++:  int cv::StereoSGBM::getP1()
        //

        //javadoc: StereoSGBM::getP1()
        public int getP1()
        {          
        return StereoSGBM_getP1_10(nativeObj);
        }


        //
        // C++:  int cv::StereoSGBM::getP2()
        //

        //javadoc: StereoSGBM::getP2()
        public int getP2()
        {
        return StereoSGBM_getP2_10(nativeObj);
        }


        //
        // C++:  int cv::StereoSGBM::getPreFilterCap()
        //

        //javadoc: StereoSGBM::getPreFilterCap()
        public int getPreFilterCap()
        {
        return StereoSGBM_getPreFilterCap_10(nativeObj);
        }


        //
        // C++:  int cv::StereoSGBM::getUniquenessRatio()
        //

        //javadoc: StereoSGBM::getUniquenessRatio()
        public int getUniquenessRatio()
        {
        return StereoSGBM_getUniquenessRatio_10(nativeObj);
        }


        //
        // C++:  void cv::StereoSGBM::setMode(int mode)
        //

        //javadoc: StereoSGBM::setMode(mode)
        public void setMode(int mode)
        {
            StereoSGBM_setMode_10(nativeObj, mode);        
        }


        //
        // C++:  void cv::StereoSGBM::setP1(int P1)
        //

        //javadoc: StereoSGBM::setP1(P1)
        public void setP1(int P1)
        {
            StereoSGBM_setP1_10(nativeObj, P1);
        }


        //
        // C++:  void cv::StereoSGBM::setP2(int P2)
        //

        //javadoc: StereoSGBM::setP2(P2)
        public void setP2(int P2)
        {
            StereoSGBM_setP2_10(nativeObj, P2);       
        }


        //
        // C++:  void cv::StereoSGBM::setPreFilterCap(int preFilterCap)
        //

        //javadoc: StereoSGBM::setPreFilterCap(preFilterCap)
        public void setPreFilterCap(int preFilterCap)
        {
            StereoSGBM_setPreFilterCap_10(nativeObj, preFilterCap);      
        }


        //
        // C++:  void cv::StereoSGBM::setUniquenessRatio(int uniquenessRatio)
        //

        //javadoc: StereoSGBM::setUniquenessRatio(uniquenessRatio)
        public void setUniquenessRatio(int uniquenessRatio)
        {
            StereoSGBM_setUniquenessRatio_10(nativeObj, uniquenessRatio);        
        }



#if (UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR
        const string LIBNAME = "__Internal";
#else
        const string LIBNAME = "face_analyzer";
#endif


        // C++: static Ptr_StereoSGBM cv::StereoSGBM::create(int minDisparity = 0, int numDisparities = 16, int blockSize = 3, int P1 = 0, int P2 = 0, int disp12MaxDiff = 0, int preFilterCap = 0, int uniquenessRatio = 0, int speckleWindowSize = 0, int speckleRange = 0, int mode = StereoSGBM::MODE_SGBM)
        [DllImport(LIBNAME)]
        private static extern IntPtr StereoSGBM_create_10(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange, int mode);
        [DllImport(LIBNAME)]
        private static extern IntPtr StereoSGBM_create_11(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange);
        [DllImport(LIBNAME)]
        private static extern IntPtr StereoSGBM_create_12(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize);
        [DllImport(LIBNAME)]
        private static extern IntPtr StereoSGBM_create_13(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio);
        [DllImport(LIBNAME)]
        private static extern IntPtr StereoSGBM_create_14(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap);
        [DllImport(LIBNAME)]
        private static extern IntPtr StereoSGBM_create_15(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff);
        [DllImport(LIBNAME)]
        private static extern IntPtr StereoSGBM_create_16(int minDisparity, int numDisparities, int blockSize, int P1, int P2);
        [DllImport(LIBNAME)]
        private static extern IntPtr StereoSGBM_create_17(int minDisparity, int numDisparities, int blockSize, int P1);
        [DllImport(LIBNAME)]
        private static extern IntPtr StereoSGBM_create_18(int minDisparity, int numDisparities, int blockSize);
        [DllImport(LIBNAME)]
        private static extern IntPtr StereoSGBM_create_19(int minDisparity, int numDisparities);
        [DllImport(LIBNAME)]
        private static extern IntPtr StereoSGBM_create_110(int minDisparity);
        [DllImport(LIBNAME)]
        private static extern IntPtr StereoSGBM_create_111();

        // C++:  int cv::StereoSGBM::getMode()
        [DllImport(LIBNAME)]
        private static extern int StereoSGBM_getMode_10(IntPtr nativeObj);

        // C++:  int cv::StereoSGBM::getP1()
        [DllImport(LIBNAME)]
        private static extern int StereoSGBM_getP1_10(IntPtr nativeObj);

        // C++:  int cv::StereoSGBM::getP2()
        [DllImport(LIBNAME)]
        private static extern int StereoSGBM_getP2_10(IntPtr nativeObj);

        // C++:  int cv::StereoSGBM::getPreFilterCap()
        [DllImport(LIBNAME)]
        private static extern int StereoSGBM_getPreFilterCap_10(IntPtr nativeObj);

        // C++:  int cv::StereoSGBM::getUniquenessRatio()
        [DllImport(LIBNAME)]
        private static extern int StereoSGBM_getUniquenessRatio_10(IntPtr nativeObj);

        // C++:  void cv::StereoSGBM::setMode(int mode)
        [DllImport(LIBNAME)]
        private static extern void StereoSGBM_setMode_10(IntPtr nativeObj, int mode);

        // C++:  void cv::StereoSGBM::setP1(int P1)
        [DllImport(LIBNAME)]
        private static extern void StereoSGBM_setP1_10(IntPtr nativeObj, int P1);

        // C++:  void cv::StereoSGBM::setP2(int P2)
        [DllImport(LIBNAME)]
        private static extern void StereoSGBM_setP2_10(IntPtr nativeObj, int P2);

        // C++:  void cv::StereoSGBM::setPreFilterCap(int preFilterCap)
        [DllImport(LIBNAME)]
        private static extern void StereoSGBM_setPreFilterCap_10(IntPtr nativeObj, int preFilterCap);

        // C++:  void cv::StereoSGBM::setUniquenessRatio(int uniquenessRatio)
        [DllImport(LIBNAME)]
        private static extern void StereoSGBM_setUniquenessRatio_10(IntPtr nativeObj, int uniquenessRatio);

        // native support for java finalize()
        [DllImport(LIBNAME)]
        private static extern void StereoSGBM_delete(IntPtr nativeObj);

    }
}