//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 }
//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 }
//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 }
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 > 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 > 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 > 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))); }
/** * 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 >=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 > 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))); }
/** * 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 >=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 > 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))); }
/** * 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 >=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 > 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))); }
// // 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 >=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 > 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))); }