Exemple #1
0
        //javadoc: StereoSGBM::create(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio)
        public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio)
        {
#if ((UNITY_ANDROID || UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR) || UNITY_5 || UNITY_5_3_OR_NEWER
            StereoSGBM retVal = StereoSGBM.__fromPtr__(calib3d_StereoSGBM_create_13(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio));

            return(retVal);
#else
            return(null);
#endif
        }
Exemple #2
0
        //javadoc: StereoSGBM::create(minDisparity, numDisparities)
        public static StereoSGBM create(int minDisparity, int numDisparities)
        {
#if ((UNITY_ANDROID || UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR) || UNITY_5 || UNITY_5_3_OR_NEWER
            StereoSGBM retVal = StereoSGBM.__fromPtr__(calib3d_StereoSGBM_create_19(minDisparity, numDisparities));

            return(retVal);
#else
            return(null);
#endif
        }
Exemple #3
0
        //javadoc: StereoSGBM::create()
        public static StereoSGBM create()
        {
#if ((UNITY_ANDROID || UNITY_IOS || UNITY_WEBGL) && !UNITY_EDITOR) || UNITY_5 || UNITY_5_3_OR_NEWER
            StereoSGBM retVal = StereoSGBM.__fromPtr__(calib3d_StereoSGBM_create_111());

            return(retVal);
#else
            return(null);
#endif
        }
Exemple #4
0
        void DoProcess()
        {
            if (!(owner.Value is OpenCVForUnityPlayMakerActions.StereoSGBM))
            {
                LogError("owner is not initialized. Add Action \"newStereoSGBM\".");
                return;
            }
            OpenCVForUnity.Calib3dModule.StereoSGBM wrapped_owner = OpenCVForUnityPlayMakerActionsUtils.GetWrappedObject <OpenCVForUnityPlayMakerActions.StereoSGBM, OpenCVForUnity.Calib3dModule.StereoSGBM>(owner);

            wrapped_owner.setUniquenessRatio(uniquenessRatio.Value);
        }
        void DoProcess()
        {
            if (!(owner.Value is OpenCVForUnityPlayMakerActions.StereoSGBM))
            {
                LogError("owner is not initialized. Add Action \"newStereoSGBM\".");
                return;
            }
            OpenCVForUnity.Calib3dModule.StereoSGBM wrapped_owner = OpenCVForUnityPlayMakerActionsUtils.GetWrappedObject <OpenCVForUnityPlayMakerActions.StereoSGBM, OpenCVForUnity.Calib3dModule.StereoSGBM>(owner);

            storeResult.Value = wrapped_owner.getP2();
        }
 public StereoSGBM(OpenCVForUnity.Calib3dModule.StereoSGBM nativeObj) : base(nativeObj)
 {
 }
 /**
  * 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__(calib3d_StereoSGBM_create_111()));
 }
 /**
  * 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__(calib3d_StereoSGBM_create_110(minDisparity)));
 }
 /**
  * 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.
  *     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)
 {
     return(StereoSGBM.__fromPtr__(calib3d_StereoSGBM_create_19(minDisparity, numDisparities)));
 }
Exemple #10
0
 /**
  * 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__(calib3d_StereoSGBM_create_18(minDisparity, numDisparities, blockSize)));
 }
Exemple #11
0
 /**
  * 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__(calib3d_StereoSGBM_create_15(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff)));
 }
Exemple #12
0
 /**
  * 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__(calib3d_StereoSGBM_create_13(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio)));
 }
Exemple #13
0
        //
        // 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__(calib3d_StereoSGBM_create_10(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, mode)));
        }