Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
The class implements the modified S. G. Kosov algorithm [KTS09] that differs
* from the original one as follows:
*
*
The automatic initialization of method's parameters is added.
*
The method of Smart Iteration Distribution (SID) is implemented.
*
The support of Multi-Level Adaptation Technique (MLAT) is not
* included.
*
The method of dynamic adaptation of method's parameters is not
* included.
*
*
* @see org.opencv.contrib.StereoVar
*/
public class StereoVar {
protected final long nativeObj;
protected StereoVar(long addr) { nativeObj = addr; }
public static final int
USE_INITIAL_DISPARITY = 1,
USE_EQUALIZE_HIST = 2,
USE_SMART_ID = 4,
USE_AUTO_PARAMS = 8,
USE_MEDIAN_FILTERING = 16,
CYCLE_O = 0,
CYCLE_V = 1,
PENALIZATION_TICHONOV = 0,
PENALIZATION_CHARBONNIER = 1,
PENALIZATION_PERONA_MALIK = 2;
//
// C++: StereoVar::StereoVar()
//
/**
*
The constructor
*
*
The first constructor initializes StereoVar with all the default
* parameters. So, you only have to set StereoVar.maxDisp and / or
* StereoVar.minDisp at minimum. The second constructor enables
* you to set each parameter to a custom value.
*
* @see org.opencv.contrib.StereoVar.StereoVar
*/
public StereoVar()
{
nativeObj = StereoVar_0();
return;
}
//
// C++: StereoVar::StereoVar(int levels, double pyrScale, int nIt, int minDisp, int maxDisp, int poly_n, double poly_sigma, float fi, float lambda, int penalization, int cycle, int flags)
//
/**
*
The constructor
*
*
The first constructor initializes StereoVar with all the default
* parameters. So, you only have to set StereoVar.maxDisp and / or
* StereoVar.minDisp at minimum. The second constructor enables
* you to set each parameter to a custom value.
*
* @param levels The number of pyramid layers, including the initial image.
* levels=1 means that no extra layers are created and only the original images
* are used. This parameter is ignored if flag USE_AUTO_PARAMS is set.
* @param pyrScale Specifies the image scale (<1) to build the pyramids for each
* image. pyrScale=0.5 means the classical pyramid, where each next layer is
* twice smaller than the previous. (This parameter is ignored if flag
* USE_AUTO_PARAMS is set).
* @param nIt The number of iterations the algorithm does at each pyramid level.
* (If the flag USE_SMART_ID is set, the number of iterations will be
* redistributed in such a way, that more iterations will be done on more
* coarser levels.)
* @param minDisp Minimum possible disparity value. Could be negative in case
* the left and right input images change places.
* @param maxDisp Maximum possible disparity value.
* @param poly_n Size of the pixel neighbourhood used to find polynomial
* expansion in each pixel. The larger values mean that the image will be
* approximated with smoother surfaces, yielding more robust algorithm and more
* blurred motion field. Typically, poly_n = 3, 5 or 7
* @param poly_sigma Standard deviation of the Gaussian that is used to smooth
* derivatives that are used as a basis for the polynomial expansion. For
* poly_n=5 you can set poly_sigma=1.1, for poly_n=7 a good value would be
* poly_sigma=1.5
* @param fi The smoothness parameter, ot the weight coefficient for the
* smoothness term.
* @param lambda The threshold parameter for edge-preserving smoothness. (This
* parameter is ignored if PENALIZATION_CHARBONNIER or PENALIZATION_PERONA_MALIK
* is used.)
* @param penalization Possible values: PENALIZATION_TICHONOV - linear
* smoothness; PENALIZATION_CHARBONNIER - non-linear edge preserving smoothness;
* PENALIZATION_PERONA_MALIK - non-linear edge-enhancing smoothness. (This
* parameter is ignored if flag USE_AUTO_PARAMS is set).
* @param cycle Type of the multigrid cycle. Possible values: CYCLE_O and
* CYCLE_V for null- and v-cycles respectively. (This parameter is ignored if
* flag USE_AUTO_PARAMS is set).
* @param flags The operation flags; can be a combination of the following:
*
*
USE_INITIAL_DISPARITY: Use the input flow as the initial flow
* approximation.
*
USE_EQUALIZE_HIST: Use the histogram equalization in the
* pre-processing phase.
*
USE_SMART_ID: Use the smart iteration distribution (SID).
*
USE_AUTO_PARAMS: Allow the method to initialize the main parameters.
*
USE_MEDIAN_FILTERING: Use the median filer of the solution in the post
* processing phase.
*
*
* @see org.opencv.contrib.StereoVar.StereoVar
*/
public StereoVar(int levels, double pyrScale, int nIt, int minDisp, int maxDisp, int poly_n, double poly_sigma, float fi, float lambda, int penalization, int cycle, int flags)
{
nativeObj = StereoVar_1(levels, pyrScale, nIt, minDisp, maxDisp, poly_n, poly_sigma, fi, lambda, penalization, cycle, flags);
return;
}
//
// C++: void StereoVar::operator ()(Mat left, Mat right, Mat& disp)
//
public void compute(Mat left, Mat right, Mat disp)
{
compute_0(nativeObj, left.nativeObj, right.nativeObj, disp.nativeObj);
return;
}
//
// C++: int StereoVar::levels
//
public int get_levels()
{
int retVal = get_levels_0(nativeObj);
return retVal;
}
//
// C++: void StereoVar::levels
//
public void set_levels(int levels)
{
set_levels_0(nativeObj, levels);
return;
}
//
// C++: double StereoVar::pyrScale
//
public double get_pyrScale()
{
double retVal = get_pyrScale_0(nativeObj);
return retVal;
}
//
// C++: void StereoVar::pyrScale
//
public void set_pyrScale(double pyrScale)
{
set_pyrScale_0(nativeObj, pyrScale);
return;
}
//
// C++: int StereoVar::nIt
//
public int get_nIt()
{
int retVal = get_nIt_0(nativeObj);
return retVal;
}
//
// C++: void StereoVar::nIt
//
public void set_nIt(int nIt)
{
set_nIt_0(nativeObj, nIt);
return;
}
//
// C++: int StereoVar::minDisp
//
public int get_minDisp()
{
int retVal = get_minDisp_0(nativeObj);
return retVal;
}
//
// C++: void StereoVar::minDisp
//
public void set_minDisp(int minDisp)
{
set_minDisp_0(nativeObj, minDisp);
return;
}
//
// C++: int StereoVar::maxDisp
//
public int get_maxDisp()
{
int retVal = get_maxDisp_0(nativeObj);
return retVal;
}
//
// C++: void StereoVar::maxDisp
//
public void set_maxDisp(int maxDisp)
{
set_maxDisp_0(nativeObj, maxDisp);
return;
}
//
// C++: int StereoVar::poly_n
//
public int get_poly_n()
{
int retVal = get_poly_n_0(nativeObj);
return retVal;
}
//
// C++: void StereoVar::poly_n
//
public void set_poly_n(int poly_n)
{
set_poly_n_0(nativeObj, poly_n);
return;
}
//
// C++: double StereoVar::poly_sigma
//
public double get_poly_sigma()
{
double retVal = get_poly_sigma_0(nativeObj);
return retVal;
}
//
// C++: void StereoVar::poly_sigma
//
public void set_poly_sigma(double poly_sigma)
{
set_poly_sigma_0(nativeObj, poly_sigma);
return;
}
//
// C++: float StereoVar::fi
//
public float get_fi()
{
float retVal = get_fi_0(nativeObj);
return retVal;
}
//
// C++: void StereoVar::fi
//
public void set_fi(float fi)
{
set_fi_0(nativeObj, fi);
return;
}
//
// C++: float StereoVar::lambda
//
public float get_lambda()
{
float retVal = get_lambda_0(nativeObj);
return retVal;
}
//
// C++: void StereoVar::lambda
//
public void set_lambda(float lambda)
{
set_lambda_0(nativeObj, lambda);
return;
}
//
// C++: int StereoVar::penalization
//
public int get_penalization()
{
int retVal = get_penalization_0(nativeObj);
return retVal;
}
//
// C++: void StereoVar::penalization
//
public void set_penalization(int penalization)
{
set_penalization_0(nativeObj, penalization);
return;
}
//
// C++: int StereoVar::cycle
//
public int get_cycle()
{
int retVal = get_cycle_0(nativeObj);
return retVal;
}
//
// C++: void StereoVar::cycle
//
public void set_cycle(int cycle)
{
set_cycle_0(nativeObj, cycle);
return;
}
//
// C++: int StereoVar::flags
//
public int get_flags()
{
int retVal = get_flags_0(nativeObj);
return retVal;
}
//
// C++: void StereoVar::flags
//
public void set_flags(int flags)
{
set_flags_0(nativeObj, flags);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: StereoVar::StereoVar()
private static native long StereoVar_0();
// C++: StereoVar::StereoVar(int levels, double pyrScale, int nIt, int minDisp, int maxDisp, int poly_n, double poly_sigma, float fi, float lambda, int penalization, int cycle, int flags)
private static native long StereoVar_1(int levels, double pyrScale, int nIt, int minDisp, int maxDisp, int poly_n, double poly_sigma, float fi, float lambda, int penalization, int cycle, int flags);
// C++: void StereoVar::operator ()(Mat left, Mat right, Mat& disp)
private static native void compute_0(long nativeObj, long left_nativeObj, long right_nativeObj, long disp_nativeObj);
// C++: int StereoVar::levels
private static native int get_levels_0(long nativeObj);
// C++: void StereoVar::levels
private static native void set_levels_0(long nativeObj, int levels);
// C++: double StereoVar::pyrScale
private static native double get_pyrScale_0(long nativeObj);
// C++: void StereoVar::pyrScale
private static native void set_pyrScale_0(long nativeObj, double pyrScale);
// C++: int StereoVar::nIt
private static native int get_nIt_0(long nativeObj);
// C++: void StereoVar::nIt
private static native void set_nIt_0(long nativeObj, int nIt);
// C++: int StereoVar::minDisp
private static native int get_minDisp_0(long nativeObj);
// C++: void StereoVar::minDisp
private static native void set_minDisp_0(long nativeObj, int minDisp);
// C++: int StereoVar::maxDisp
private static native int get_maxDisp_0(long nativeObj);
// C++: void StereoVar::maxDisp
private static native void set_maxDisp_0(long nativeObj, int maxDisp);
// C++: int StereoVar::poly_n
private static native int get_poly_n_0(long nativeObj);
// C++: void StereoVar::poly_n
private static native void set_poly_n_0(long nativeObj, int poly_n);
// C++: double StereoVar::poly_sigma
private static native double get_poly_sigma_0(long nativeObj);
// C++: void StereoVar::poly_sigma
private static native void set_poly_sigma_0(long nativeObj, double poly_sigma);
// C++: float StereoVar::fi
private static native float get_fi_0(long nativeObj);
// C++: void StereoVar::fi
private static native void set_fi_0(long nativeObj, float fi);
// C++: float StereoVar::lambda
private static native float get_lambda_0(long nativeObj);
// C++: void StereoVar::lambda
private static native void set_lambda_0(long nativeObj, float lambda);
// C++: int StereoVar::penalization
private static native int get_penalization_0(long nativeObj);
// C++: void StereoVar::penalization
private static native void set_penalization_0(long nativeObj, int penalization);
// C++: int StereoVar::cycle
private static native int get_cycle_0(long nativeObj);
// C++: void StereoVar::cycle
private static native void set_cycle_0(long nativeObj, int cycle);
// C++: int StereoVar::flags
private static native int get_flags_0(long nativeObj);
// C++: void StereoVar::flags
private static native void set_flags_0(long nativeObj, int flags);
// native support for java finalize()
private static native void delete(long nativeObj);
}
