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