FocusModes = params.getSupportedFocusModes();
if (FocusModes != null && FocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO))
{
params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
}
mCamera.setParameters(params);
params = mCamera.getParameters();
mFrameWidth = params.getPreviewSize().width;
mFrameHeight = params.getPreviewSize().height;
if ((getLayoutParams().width == LayoutParams.MATCH_PARENT) && (getLayoutParams().height == LayoutParams.MATCH_PARENT))
mScale = Math.min(((float)height)/mFrameHeight, ((float)width)/mFrameWidth);
else
mScale = 0;
if (mFpsMeter != null) {
mFpsMeter.setResolution(mFrameWidth, mFrameHeight);
}
int size = mFrameWidth * mFrameHeight;
size = size * ImageFormat.getBitsPerPixel(params.getPreviewFormat()) / 8;
mBuffer = new byte[size];
mCamera.addCallbackBuffer(mBuffer);
mCamera.setPreviewCallbackWithBuffer(this);
mFrameChain = new Mat[2];
mFrameChain[0] = new Mat(mFrameHeight + (mFrameHeight/2), mFrameWidth, CvType.CV_8UC1);
mFrameChain[1] = new Mat(mFrameHeight + (mFrameHeight/2), mFrameWidth, CvType.CV_8UC1);
AllocateCache();
mCameraFrame = new JavaCameraFrame[2];
mCameraFrame[0] = new JavaCameraFrame(mFrameChain[0], mFrameWidth, mFrameHeight);
mCameraFrame[1] = new JavaCameraFrame(mFrameChain[1], mFrameWidth, mFrameHeight);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
mSurfaceTexture = new SurfaceTexture(MAGIC_TEXTURE_ID);
mCamera.setPreviewTexture(mSurfaceTexture);
} else
mCamera.setPreviewDisplay(null);
/* Finally we are ready to start the preview */
Log.d(TAG, "startPreview");
mCamera.startPreview();
}
else
result = false;
} catch (Exception e) {
result = false;
e.printStackTrace();
}
}
return result;
}
protected void releaseCamera() {
synchronized (this) {
if (mCamera != null) {
mCamera.stopPreview();
mCamera.setPreviewCallback(null);
mCamera.release();
}
mCamera = null;
if (mFrameChain != null) {
mFrameChain[0].release();
mFrameChain[1].release();
}
if (mCameraFrame != null) {
mCameraFrame[0].release();
mCameraFrame[1].release();
}
}
}
private boolean mCameraFrameReady = false;
@Override
protected boolean connectCamera(int width, int height) {
/* 1. We need to instantiate camera
* 2. We need to start thread which will be getting frames
*/
/* First step - initialize camera connection */
Log.d(TAG, "Connecting to camera");
if (!initializeCamera(width, height))
return false;
mCameraFrameReady = false;
/* now we can start update thread */
Log.d(TAG, "Starting processing thread");
mStopThread = false;
mThread = new Thread(new CameraWorker());
mThread.start();
return true;
}
@Override
protected void disconnectCamera() {
/* 1. We need to stop thread which updating the frames
* 2. Stop camera and release it
*/
Log.d(TAG, "Disconnecting from camera");
try {
mStopThread = true;
Log.d(TAG, "Notify thread");
synchronized (this) {
this.notify();
}
Log.d(TAG, "Waiting for thread");
if (mThread != null)
mThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
mThread = null;
}
/* Now release camera */
releaseCamera();
mCameraFrameReady = false;
}
@Override
public void onPreviewFrame(byte[] frame, Camera arg1) {
if (BuildConfig.DEBUG)
Log.d(TAG, "Preview Frame received. Frame size: " + frame.length);
synchronized (this) {
mFrameChain[mChainIdx].put(0, 0, frame);
mCameraFrameReady = true;
this.notify();
}
if (mCamera != null)
mCamera.addCallbackBuffer(mBuffer);
}
private class JavaCameraFrame implements CvCameraViewFrame {
@Override
public Mat gray() {
return mYuvFrameData.submat(0, mHeight, 0, mWidth);
}
@Override
public Mat rgba() {
if (mPreviewFormat == ImageFormat.NV21)
Imgproc.cvtColor(mYuvFrameData, mRgba, Imgproc.COLOR_YUV2RGBA_NV21, 4);
else if (mPreviewFormat == ImageFormat.YV12)
Imgproc.cvtColor(mYuvFrameData, mRgba, Imgproc.COLOR_YUV2RGB_I420, 4); // COLOR_YUV2RGBA_YV12 produces inverted colors
else
throw new IllegalArgumentException("Preview Format can be NV21 or YV12");
return mRgba;
}
public JavaCameraFrame(Mat Yuv420sp, int width, int height) {
super();
mWidth = width;
mHeight = height;
mYuvFrameData = Yuv420sp;
mRgba = new Mat();
}
public void release() {
mRgba.release();
}
private Mat mYuvFrameData;
private Mat mRgba;
private int mWidth;
private int mHeight;
};
private class CameraWorker implements Runnable {
@Override
public void run() {
do {
boolean hasFrame = false;
synchronized (JavaCameraView.this) {
try {
while (!mCameraFrameReady && !mStopThread) {
JavaCameraView.this.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
if (mCameraFrameReady)
{
mChainIdx = 1 - mChainIdx;
mCameraFrameReady = false;
hasFrame = true;
}
}
if (!mStopThread && hasFrame) {
if (!mFrameChain[1 - mChainIdx].empty())
deliverAndDrawFrame(mCameraFrame[1 - mChainIdx]);
}
} while (!mStopThread);
Log.d(TAG, "Finish processing thread");
}
}
}
================================================
FILE: openCV/src/main/java/org/opencv/android/LoaderCallbackInterface.java
================================================
package org.opencv.android;
/**
* Interface for callback object in case of asynchronous initialization of OpenCV.
*/
public interface LoaderCallbackInterface
{
/**
* OpenCV initialization finished successfully.
*/
static final int SUCCESS = 0;
/**
* Google Play Market cannot be invoked.
*/
static final int MARKET_ERROR = 2;
/**
* OpenCV library installation has been canceled by the user.
*/
static final int INSTALL_CANCELED = 3;
/**
* This version of OpenCV Manager Service is incompatible with the app. Possibly, a service update is required.
*/
static final int INCOMPATIBLE_MANAGER_VERSION = 4;
/**
* OpenCV library initialization has failed.
*/
static final int INIT_FAILED = 0xff;
/**
* Callback method, called after OpenCV library initialization.
* @param status status of initialization (see initialization status constants).
*/
public void onManagerConnected(int status);
/**
* Callback method, called in case the package installation is needed.
* @param callback answer object with approve and cancel methods and the package description.
*/
public void onPackageInstall(final int operation, InstallCallbackInterface callback);
};
================================================
FILE: openCV/src/main/java/org/opencv/android/OpenCVLoader.java
================================================
package org.opencv.android;
import android.content.Context;
/**
* Helper class provides common initialization methods for OpenCV library.
*/
public class OpenCVLoader
{
/**
* OpenCV Library version 2.4.2.
*/
public static final String OPENCV_VERSION_2_4_2 = "2.4.2";
/**
* OpenCV Library version 2.4.3.
*/
public static final String OPENCV_VERSION_2_4_3 = "2.4.3";
/**
* OpenCV Library version 2.4.4.
*/
public static final String OPENCV_VERSION_2_4_4 = "2.4.4";
/**
* OpenCV Library version 2.4.5.
*/
public static final String OPENCV_VERSION_2_4_5 = "2.4.5";
/**
* OpenCV Library version 2.4.6.
*/
public static final String OPENCV_VERSION_2_4_6 = "2.4.6";
/**
* OpenCV Library version 2.4.7.
*/
public static final String OPENCV_VERSION_2_4_7 = "2.4.7";
/**
* OpenCV Library version 2.4.8.
*/
public static final String OPENCV_VERSION_2_4_8 = "2.4.8";
/**
* OpenCV Library version 2.4.9.
*/
public static final String OPENCV_VERSION_2_4_9 = "2.4.9";
/**
* OpenCV Library version 2.4.10.
*/
public static final String OPENCV_VERSION_2_4_10 = "2.4.10";
/**
* OpenCV Library version 2.4.11.
*/
public static final String OPENCV_VERSION_2_4_11 = "2.4.11";
/**
* OpenCV Library version 2.4.12.
*/
public static final String OPENCV_VERSION_2_4_12 = "2.4.12";
/**
* OpenCV Library version 2.4.13.
*/
public static final String OPENCV_VERSION_2_4_13 = "2.4.13";
/**
* OpenCV Library version 3.0.0.
*/
public static final String OPENCV_VERSION_3_0_0 = "3.0.0";
/**
* OpenCV Library version 3.1.0.
*/
public static final String OPENCV_VERSION_3_1_0 = "3.1.0";
/**
* OpenCV Library version 3.2.0.
*/
public static final String OPENCV_VERSION_3_2_0 = "3.2.0";
/**
* OpenCV Library version 3.3.0.
*/
public static final String OPENCV_VERSION_3_3_0 = "3.3.0";
/**
* OpenCV Library version 3.4.0.
*/
public static final String OPENCV_VERSION_3_4_0 = "3.4.0";
/**
* Current OpenCV Library version
*/
public static final String OPENCV_VERSION = "3.4.6";
/**
* Loads and initializes OpenCV library from current application package. Roughly, it's an analog of system.loadLibrary("opencv_java").
* @return Returns true is initialization of OpenCV was successful.
*/
public static boolean initDebug()
{
return StaticHelper.initOpenCV(false);
}
/**
* Loads and initializes OpenCV library from current application package. Roughly, it's an analog of system.loadLibrary("opencv_java").
* @param InitCuda load and initialize CUDA runtime libraries.
* @return Returns true is initialization of OpenCV was successful.
*/
public static boolean initDebug(boolean InitCuda)
{
return StaticHelper.initOpenCV(InitCuda);
}
/**
* Loads and initializes OpenCV library using OpenCV Engine service.
* @param Version OpenCV library version.
* @param AppContext application context for connecting to the service.
* @param Callback object, that implements LoaderCallbackInterface for handling the connection status.
* @return Returns true if initialization of OpenCV is successful.
*/
public static boolean initAsync(String Version, Context AppContext,
LoaderCallbackInterface Callback)
{
return AsyncServiceHelper.initOpenCV(Version, AppContext, Callback);
}
}
================================================
FILE: openCV/src/main/java/org/opencv/android/StaticHelper.java
================================================
package org.opencv.android;
import org.opencv.core.Core;
import java.util.StringTokenizer;
import android.util.Log;
class StaticHelper {
public static boolean initOpenCV(boolean InitCuda)
{
boolean result;
String libs = "";
if(InitCuda)
{
loadLibrary("cudart");
loadLibrary("nppc");
loadLibrary("nppi");
loadLibrary("npps");
loadLibrary("cufft");
loadLibrary("cublas");
}
Log.d(TAG, "Trying to get library list");
try
{
System.loadLibrary("opencv_info");
libs = getLibraryList();
}
catch(UnsatisfiedLinkError e)
{
Log.e(TAG, "OpenCV error: Cannot load info library for OpenCV");
}
Log.d(TAG, "Library list: \"" + libs + "\"");
Log.d(TAG, "First attempt to load libs");
if (initOpenCVLibs(libs))
{
Log.d(TAG, "First attempt to load libs is OK");
String eol = System.getProperty("line.separator");
for (String str : Core.getBuildInformation().split(eol))
Log.i(TAG, str);
result = true;
}
else
{
Log.d(TAG, "First attempt to load libs fails");
result = false;
}
return result;
}
private static boolean loadLibrary(String Name)
{
boolean result = true;
Log.d(TAG, "Trying to load library " + Name);
try
{
System.loadLibrary(Name);
Log.d(TAG, "Library " + Name + " loaded");
}
catch(UnsatisfiedLinkError e)
{
Log.d(TAG, "Cannot load library \"" + Name + "\"");
e.printStackTrace();
result = false;
}
return result;
}
private static boolean initOpenCVLibs(String Libs)
{
Log.d(TAG, "Trying to init OpenCV libs");
boolean result = true;
if ((null != Libs) && (Libs.length() != 0))
{
Log.d(TAG, "Trying to load libs by dependency list");
StringTokenizer splitter = new StringTokenizer(Libs, ";");
while(splitter.hasMoreTokens())
{
result &= loadLibrary(splitter.nextToken());
}
}
else
{
// If dependencies list is not defined or empty.
result = loadLibrary("opencv_java3");
}
return result;
}
private static final String TAG = "OpenCV/StaticHelper";
private static native String getLibraryList();
}
================================================
FILE: openCV/src/main/java/org/opencv/android/Utils.java
================================================
package org.opencv.android;
import android.content.Context;
import android.graphics.Bitmap;
import org.opencv.core.CvException;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
public class Utils {
public static String exportResource(Context context, int resourceId) {
return exportResource(context, resourceId, "OpenCV_data");
}
public static String exportResource(Context context, int resourceId, String dirname) {
String fullname = context.getResources().getString(resourceId);
String resName = fullname.substring(fullname.lastIndexOf("/") + 1);
try {
InputStream is = context.getResources().openRawResource(resourceId);
File resDir = context.getDir(dirname, Context.MODE_PRIVATE);
File resFile = new File(resDir, resName);
FileOutputStream os = new FileOutputStream(resFile);
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = is.read(buffer)) != -1) {
os.write(buffer, 0, bytesRead);
}
is.close();
os.close();
return resFile.getAbsolutePath();
} catch (IOException e) {
e.printStackTrace();
throw new CvException("Failed to export resource " + resName
+ ". Exception thrown: " + e);
}
}
public static Mat loadResource(Context context, int resourceId) throws IOException
{
return loadResource(context, resourceId, -1);
}
public static Mat loadResource(Context context, int resourceId, int flags) throws IOException
{
InputStream is = context.getResources().openRawResource(resourceId);
ByteArrayOutputStream os = new ByteArrayOutputStream(is.available());
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = is.read(buffer)) != -1) {
os.write(buffer, 0, bytesRead);
}
is.close();
Mat encoded = new Mat(1, os.size(), CvType.CV_8U);
encoded.put(0, 0, os.toByteArray());
os.close();
Mat decoded = Imgcodecs.imdecode(encoded, flags);
encoded.release();
return decoded;
}
/**
* Converts Android Bitmap to OpenCV Mat.
*
* This function converts an Android Bitmap image to the OpenCV Mat.
*
'ARGB_8888' and 'RGB_565' input Bitmap formats are supported.
*
The output Mat is always created of the same size as the input Bitmap and of the 'CV_8UC4' type,
* it keeps the image in RGBA format.
*
This function throws an exception if the conversion fails.
* @param bmp is a valid input Bitmap object of the type 'ARGB_8888' or 'RGB_565'.
* @param mat is a valid output Mat object, it will be reallocated if needed, so it may be empty.
* @param unPremultiplyAlpha is a flag, that determines, whether the bitmap needs to be converted from alpha premultiplied format (like Android keeps 'ARGB_8888' ones) to regular one; this flag is ignored for 'RGB_565' bitmaps.
*/
public static void bitmapToMat(Bitmap bmp, Mat mat, boolean unPremultiplyAlpha) {
if (bmp == null)
throw new java.lang.IllegalArgumentException("bmp == null");
if (mat == null)
throw new java.lang.IllegalArgumentException("mat == null");
nBitmapToMat2(bmp, mat.nativeObj, unPremultiplyAlpha);
}
/**
* Short form of the bitmapToMat(bmp, mat, unPremultiplyAlpha=false).
* @param bmp is a valid input Bitmap object of the type 'ARGB_8888' or 'RGB_565'.
* @param mat is a valid output Mat object, it will be reallocated if needed, so Mat may be empty.
*/
public static void bitmapToMat(Bitmap bmp, Mat mat) {
bitmapToMat(bmp, mat, false);
}
/**
* Converts OpenCV Mat to Android Bitmap.
*
*
This function converts an image in the OpenCV Mat representation to the Android Bitmap.
*
The input Mat object has to be of the types 'CV_8UC1' (gray-scale), 'CV_8UC3' (RGB) or 'CV_8UC4' (RGBA).
*
The output Bitmap object has to be of the same size as the input Mat and of the types 'ARGB_8888' or 'RGB_565'.
*
This function throws an exception if the conversion fails.
*
* @param mat is a valid input Mat object of types 'CV_8UC1', 'CV_8UC3' or 'CV_8UC4'.
* @param bmp is a valid Bitmap object of the same size as the Mat and of type 'ARGB_8888' or 'RGB_565'.
* @param premultiplyAlpha is a flag, that determines, whether the Mat needs to be converted to alpha premultiplied format (like Android keeps 'ARGB_8888' bitmaps); the flag is ignored for 'RGB_565' bitmaps.
*/
public static void matToBitmap(Mat mat, Bitmap bmp, boolean premultiplyAlpha) {
if (mat == null)
throw new java.lang.IllegalArgumentException("mat == null");
if (bmp == null)
throw new java.lang.IllegalArgumentException("bmp == null");
nMatToBitmap2(mat.nativeObj, bmp, premultiplyAlpha);
}
/**
* Short form of the matToBitmap(mat, bmp, premultiplyAlpha=false)
* @param mat is a valid input Mat object of the types 'CV_8UC1', 'CV_8UC3' or 'CV_8UC4'.
* @param bmp is a valid Bitmap object of the same size as the Mat and of type 'ARGB_8888' or 'RGB_565'.
*/
public static void matToBitmap(Mat mat, Bitmap bmp) {
matToBitmap(mat, bmp, false);
}
private static native void nBitmapToMat2(Bitmap b, long m_addr, boolean unPremultiplyAlpha);
private static native void nMatToBitmap2(long m_addr, Bitmap b, boolean premultiplyAlpha);
}
================================================
FILE: openCV/src/main/java/org/opencv/calib3d/Calib3d.java
================================================
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.calib3d;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.core.MatOfDouble;
import org.opencv.core.MatOfPoint2f;
import org.opencv.core.MatOfPoint3f;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Size;
import org.opencv.core.TermCriteria;
import org.opencv.utils.Converters;
// C++: class Calib3d
//javadoc: Calib3d
public class Calib3d {
// C++: enum HandEyeCalibrationMethod
public static final int
CALIB_HAND_EYE_TSAI = 0,
CALIB_HAND_EYE_PARK = 1,
CALIB_HAND_EYE_HORAUD = 2,
CALIB_HAND_EYE_ANDREFF = 3,
CALIB_HAND_EYE_DANIILIDIS = 4;
// C++: enum
public static final int
CALIB_USE_INTRINSIC_GUESS = 1,
CALIB_RECOMPUTE_EXTRINSIC = 2,
CALIB_CHECK_COND = 4,
CALIB_FIX_SKEW = 8,
CALIB_FIX_K1 = 16,
CALIB_FIX_K2 = 32,
CALIB_FIX_K3 = 64,
CALIB_FIX_K4 = 128,
CALIB_FIX_INTRINSIC = 256,
CV_ITERATIVE = 0,
CV_EPNP = 1,
CV_P3P = 2,
CV_DLS = 3,
CvLevMarq_DONE = 0,
CvLevMarq_STARTED = 1,
CvLevMarq_CALC_J = 2,
CvLevMarq_CHECK_ERR = 3,
LMEDS = 4,
RANSAC = 8,
RHO = 16,
SOLVEPNP_ITERATIVE = 0,
SOLVEPNP_EPNP = 1,
SOLVEPNP_P3P = 2,
SOLVEPNP_DLS = 3,
SOLVEPNP_UPNP = 4,
SOLVEPNP_AP3P = 5,
SOLVEPNP_MAX_COUNT = 5+1,
CALIB_CB_ADAPTIVE_THRESH = 1,
CALIB_CB_NORMALIZE_IMAGE = 2,
CALIB_CB_FILTER_QUADS = 4,
CALIB_CB_FAST_CHECK = 8,
CALIB_CB_SYMMETRIC_GRID = 1,
CALIB_CB_ASYMMETRIC_GRID = 2,
CALIB_CB_CLUSTERING = 4,
CALIB_FIX_ASPECT_RATIO = 0x00002,
CALIB_FIX_PRINCIPAL_POINT = 0x00004,
CALIB_ZERO_TANGENT_DIST = 0x00008,
CALIB_FIX_FOCAL_LENGTH = 0x00010,
CALIB_FIX_K5 = 0x01000,
CALIB_FIX_K6 = 0x02000,
CALIB_RATIONAL_MODEL = 0x04000,
CALIB_THIN_PRISM_MODEL = 0x08000,
CALIB_FIX_S1_S2_S3_S4 = 0x10000,
CALIB_TILTED_MODEL = 0x40000,
CALIB_FIX_TAUX_TAUY = 0x80000,
CALIB_USE_QR = 0x100000,
CALIB_FIX_TANGENT_DIST = 0x200000,
CALIB_SAME_FOCAL_LENGTH = 0x00200,
CALIB_ZERO_DISPARITY = 0x00400,
CALIB_USE_LU = (1 << 17),
CALIB_USE_EXTRINSIC_GUESS = (1 << 22),
FM_7POINT = 1,
FM_8POINT = 2,
FM_LMEDS = 4,
FM_RANSAC = 8,
fisheye_CALIB_USE_INTRINSIC_GUESS = 1 << 0,
fisheye_CALIB_RECOMPUTE_EXTRINSIC = 1 << 1,
fisheye_CALIB_CHECK_COND = 1 << 2,
fisheye_CALIB_FIX_SKEW = 1 << 3,
fisheye_CALIB_FIX_K1 = 1 << 4,
fisheye_CALIB_FIX_K2 = 1 << 5,
fisheye_CALIB_FIX_K3 = 1 << 6,
fisheye_CALIB_FIX_K4 = 1 << 7,
fisheye_CALIB_FIX_INTRINSIC = 1 << 8,
fisheye_CALIB_FIX_PRINCIPAL_POINT = 1 << 9;
// C++: enum GridType
public static final int
CirclesGridFinderParameters_SYMMETRIC_GRID = 0,
CirclesGridFinderParameters_ASYMMETRIC_GRID = 1;
//
// C++: Mat cv::estimateAffine2D(Mat from, Mat to, Mat& inliers = Mat(), int method = RANSAC, double ransacReprojThreshold = 3, size_t maxIters = 2000, double confidence = 0.99, size_t refineIters = 10)
//
//javadoc: estimateAffine2D(from, to, inliers, method, ransacReprojThreshold, maxIters, confidence, refineIters)
public static Mat estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters)
{
Mat retVal = new Mat(estimateAffine2D_0(from.nativeObj, to.nativeObj, inliers.nativeObj, method, ransacReprojThreshold, maxIters, confidence, refineIters));
return retVal;
}
//javadoc: estimateAffine2D(from, to, inliers, method, ransacReprojThreshold, maxIters, confidence)
public static Mat estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence)
{
Mat retVal = new Mat(estimateAffine2D_1(from.nativeObj, to.nativeObj, inliers.nativeObj, method, ransacReprojThreshold, maxIters, confidence));
return retVal;
}
//javadoc: estimateAffine2D(from, to, inliers, method, ransacReprojThreshold, maxIters)
public static Mat estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters)
{
Mat retVal = new Mat(estimateAffine2D_2(from.nativeObj, to.nativeObj, inliers.nativeObj, method, ransacReprojThreshold, maxIters));
return retVal;
}
//javadoc: estimateAffine2D(from, to, inliers, method, ransacReprojThreshold)
public static Mat estimateAffine2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold)
{
Mat retVal = new Mat(estimateAffine2D_3(from.nativeObj, to.nativeObj, inliers.nativeObj, method, ransacReprojThreshold));
return retVal;
}
//javadoc: estimateAffine2D(from, to, inliers, method)
public static Mat estimateAffine2D(Mat from, Mat to, Mat inliers, int method)
{
Mat retVal = new Mat(estimateAffine2D_4(from.nativeObj, to.nativeObj, inliers.nativeObj, method));
return retVal;
}
//javadoc: estimateAffine2D(from, to, inliers)
public static Mat estimateAffine2D(Mat from, Mat to, Mat inliers)
{
Mat retVal = new Mat(estimateAffine2D_5(from.nativeObj, to.nativeObj, inliers.nativeObj));
return retVal;
}
//javadoc: estimateAffine2D(from, to)
public static Mat estimateAffine2D(Mat from, Mat to)
{
Mat retVal = new Mat(estimateAffine2D_6(from.nativeObj, to.nativeObj));
return retVal;
}
//
// C++: Mat cv::estimateAffinePartial2D(Mat from, Mat to, Mat& inliers = Mat(), int method = RANSAC, double ransacReprojThreshold = 3, size_t maxIters = 2000, double confidence = 0.99, size_t refineIters = 10)
//
//javadoc: estimateAffinePartial2D(from, to, inliers, method, ransacReprojThreshold, maxIters, confidence, refineIters)
public static Mat estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters)
{
Mat retVal = new Mat(estimateAffinePartial2D_0(from.nativeObj, to.nativeObj, inliers.nativeObj, method, ransacReprojThreshold, maxIters, confidence, refineIters));
return retVal;
}
//javadoc: estimateAffinePartial2D(from, to, inliers, method, ransacReprojThreshold, maxIters, confidence)
public static Mat estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters, double confidence)
{
Mat retVal = new Mat(estimateAffinePartial2D_1(from.nativeObj, to.nativeObj, inliers.nativeObj, method, ransacReprojThreshold, maxIters, confidence));
return retVal;
}
//javadoc: estimateAffinePartial2D(from, to, inliers, method, ransacReprojThreshold, maxIters)
public static Mat estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold, long maxIters)
{
Mat retVal = new Mat(estimateAffinePartial2D_2(from.nativeObj, to.nativeObj, inliers.nativeObj, method, ransacReprojThreshold, maxIters));
return retVal;
}
//javadoc: estimateAffinePartial2D(from, to, inliers, method, ransacReprojThreshold)
public static Mat estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method, double ransacReprojThreshold)
{
Mat retVal = new Mat(estimateAffinePartial2D_3(from.nativeObj, to.nativeObj, inliers.nativeObj, method, ransacReprojThreshold));
return retVal;
}
//javadoc: estimateAffinePartial2D(from, to, inliers, method)
public static Mat estimateAffinePartial2D(Mat from, Mat to, Mat inliers, int method)
{
Mat retVal = new Mat(estimateAffinePartial2D_4(from.nativeObj, to.nativeObj, inliers.nativeObj, method));
return retVal;
}
//javadoc: estimateAffinePartial2D(from, to, inliers)
public static Mat estimateAffinePartial2D(Mat from, Mat to, Mat inliers)
{
Mat retVal = new Mat(estimateAffinePartial2D_5(from.nativeObj, to.nativeObj, inliers.nativeObj));
return retVal;
}
//javadoc: estimateAffinePartial2D(from, to)
public static Mat estimateAffinePartial2D(Mat from, Mat to)
{
Mat retVal = new Mat(estimateAffinePartial2D_6(from.nativeObj, to.nativeObj));
return retVal;
}
//
// C++: Mat cv::findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method = RANSAC, double prob = 0.999, double threshold = 1.0, Mat& mask = Mat())
//
//javadoc: findEssentialMat(points1, points2, cameraMatrix, method, prob, threshold, mask)
public static Mat findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold, Mat mask)
{
Mat retVal = new Mat(findEssentialMat_0(points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, method, prob, threshold, mask.nativeObj));
return retVal;
}
//javadoc: findEssentialMat(points1, points2, cameraMatrix, method, prob, threshold)
public static Mat findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob, double threshold)
{
Mat retVal = new Mat(findEssentialMat_1(points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, method, prob, threshold));
return retVal;
}
//javadoc: findEssentialMat(points1, points2, cameraMatrix, method, prob)
public static Mat findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method, double prob)
{
Mat retVal = new Mat(findEssentialMat_2(points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, method, prob));
return retVal;
}
//javadoc: findEssentialMat(points1, points2, cameraMatrix, method)
public static Mat findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method)
{
Mat retVal = new Mat(findEssentialMat_3(points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, method));
return retVal;
}
//javadoc: findEssentialMat(points1, points2, cameraMatrix)
public static Mat findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix)
{
Mat retVal = new Mat(findEssentialMat_4(points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj));
return retVal;
}
//
// C++: Mat cv::findEssentialMat(Mat points1, Mat points2, double focal = 1.0, Point2d pp = Point2d(0, 0), int method = RANSAC, double prob = 0.999, double threshold = 1.0, Mat& mask = Mat())
//
//javadoc: findEssentialMat(points1, points2, focal, pp, method, prob, threshold, mask)
public static Mat findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method, double prob, double threshold, Mat mask)
{
Mat retVal = new Mat(findEssentialMat_5(points1.nativeObj, points2.nativeObj, focal, pp.x, pp.y, method, prob, threshold, mask.nativeObj));
return retVal;
}
//javadoc: findEssentialMat(points1, points2, focal, pp, method, prob, threshold)
public static Mat findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method, double prob, double threshold)
{
Mat retVal = new Mat(findEssentialMat_6(points1.nativeObj, points2.nativeObj, focal, pp.x, pp.y, method, prob, threshold));
return retVal;
}
//javadoc: findEssentialMat(points1, points2, focal, pp, method, prob)
public static Mat findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method, double prob)
{
Mat retVal = new Mat(findEssentialMat_7(points1.nativeObj, points2.nativeObj, focal, pp.x, pp.y, method, prob));
return retVal;
}
//javadoc: findEssentialMat(points1, points2, focal, pp, method)
public static Mat findEssentialMat(Mat points1, Mat points2, double focal, Point pp, int method)
{
Mat retVal = new Mat(findEssentialMat_8(points1.nativeObj, points2.nativeObj, focal, pp.x, pp.y, method));
return retVal;
}
//javadoc: findEssentialMat(points1, points2, focal, pp)
public static Mat findEssentialMat(Mat points1, Mat points2, double focal, Point pp)
{
Mat retVal = new Mat(findEssentialMat_9(points1.nativeObj, points2.nativeObj, focal, pp.x, pp.y));
return retVal;
}
//javadoc: findEssentialMat(points1, points2, focal)
public static Mat findEssentialMat(Mat points1, Mat points2, double focal)
{
Mat retVal = new Mat(findEssentialMat_10(points1.nativeObj, points2.nativeObj, focal));
return retVal;
}
//javadoc: findEssentialMat(points1, points2)
public static Mat findEssentialMat(Mat points1, Mat points2)
{
Mat retVal = new Mat(findEssentialMat_11(points1.nativeObj, points2.nativeObj));
return retVal;
}
//
// C++: Mat cv::findFundamentalMat(vector_Point2f points1, vector_Point2f points2, int method = FM_RANSAC, double ransacReprojThreshold = 3., double confidence = 0.99, Mat& mask = Mat())
//
//javadoc: findFundamentalMat(points1, points2, method, ransacReprojThreshold, confidence, mask)
public static Mat findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double ransacReprojThreshold, double confidence, Mat mask)
{
Mat points1_mat = points1;
Mat points2_mat = points2;
Mat retVal = new Mat(findFundamentalMat_0(points1_mat.nativeObj, points2_mat.nativeObj, method, ransacReprojThreshold, confidence, mask.nativeObj));
return retVal;
}
//javadoc: findFundamentalMat(points1, points2, method, ransacReprojThreshold, confidence)
public static Mat findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double ransacReprojThreshold, double confidence)
{
Mat points1_mat = points1;
Mat points2_mat = points2;
Mat retVal = new Mat(findFundamentalMat_1(points1_mat.nativeObj, points2_mat.nativeObj, method, ransacReprojThreshold, confidence));
return retVal;
}
//javadoc: findFundamentalMat(points1, points2, method, ransacReprojThreshold)
public static Mat findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method, double ransacReprojThreshold)
{
Mat points1_mat = points1;
Mat points2_mat = points2;
Mat retVal = new Mat(findFundamentalMat_2(points1_mat.nativeObj, points2_mat.nativeObj, method, ransacReprojThreshold));
return retVal;
}
//javadoc: findFundamentalMat(points1, points2, method)
public static Mat findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2, int method)
{
Mat points1_mat = points1;
Mat points2_mat = points2;
Mat retVal = new Mat(findFundamentalMat_3(points1_mat.nativeObj, points2_mat.nativeObj, method));
return retVal;
}
//javadoc: findFundamentalMat(points1, points2)
public static Mat findFundamentalMat(MatOfPoint2f points1, MatOfPoint2f points2)
{
Mat points1_mat = points1;
Mat points2_mat = points2;
Mat retVal = new Mat(findFundamentalMat_4(points1_mat.nativeObj, points2_mat.nativeObj));
return retVal;
}
//
// C++: Mat cv::findHomography(vector_Point2f srcPoints, vector_Point2f dstPoints, int method = 0, double ransacReprojThreshold = 3, Mat& mask = Mat(), int maxIters = 2000, double confidence = 0.995)
//
//javadoc: findHomography(srcPoints, dstPoints, method, ransacReprojThreshold, mask, maxIters, confidence)
public static Mat findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold, Mat mask, int maxIters, double confidence)
{
Mat srcPoints_mat = srcPoints;
Mat dstPoints_mat = dstPoints;
Mat retVal = new Mat(findHomography_0(srcPoints_mat.nativeObj, dstPoints_mat.nativeObj, method, ransacReprojThreshold, mask.nativeObj, maxIters, confidence));
return retVal;
}
//javadoc: findHomography(srcPoints, dstPoints, method, ransacReprojThreshold, mask, maxIters)
public static Mat findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold, Mat mask, int maxIters)
{
Mat srcPoints_mat = srcPoints;
Mat dstPoints_mat = dstPoints;
Mat retVal = new Mat(findHomography_1(srcPoints_mat.nativeObj, dstPoints_mat.nativeObj, method, ransacReprojThreshold, mask.nativeObj, maxIters));
return retVal;
}
//javadoc: findHomography(srcPoints, dstPoints, method, ransacReprojThreshold, mask)
public static Mat findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold, Mat mask)
{
Mat srcPoints_mat = srcPoints;
Mat dstPoints_mat = dstPoints;
Mat retVal = new Mat(findHomography_2(srcPoints_mat.nativeObj, dstPoints_mat.nativeObj, method, ransacReprojThreshold, mask.nativeObj));
return retVal;
}
//javadoc: findHomography(srcPoints, dstPoints, method, ransacReprojThreshold)
public static Mat findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method, double ransacReprojThreshold)
{
Mat srcPoints_mat = srcPoints;
Mat dstPoints_mat = dstPoints;
Mat retVal = new Mat(findHomography_3(srcPoints_mat.nativeObj, dstPoints_mat.nativeObj, method, ransacReprojThreshold));
return retVal;
}
//javadoc: findHomography(srcPoints, dstPoints, method)
public static Mat findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints, int method)
{
Mat srcPoints_mat = srcPoints;
Mat dstPoints_mat = dstPoints;
Mat retVal = new Mat(findHomography_4(srcPoints_mat.nativeObj, dstPoints_mat.nativeObj, method));
return retVal;
}
//javadoc: findHomography(srcPoints, dstPoints)
public static Mat findHomography(MatOfPoint2f srcPoints, MatOfPoint2f dstPoints)
{
Mat srcPoints_mat = srcPoints;
Mat dstPoints_mat = dstPoints;
Mat retVal = new Mat(findHomography_5(srcPoints_mat.nativeObj, dstPoints_mat.nativeObj));
return retVal;
}
//
// C++: Mat cv::getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize = Size(), Rect* validPixROI = 0, bool centerPrincipalPoint = false)
//
//javadoc: getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha, newImgSize, validPixROI, centerPrincipalPoint)
public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect validPixROI, boolean centerPrincipalPoint)
{
double[] validPixROI_out = new double[4];
Mat retVal = new Mat(getOptimalNewCameraMatrix_0(cameraMatrix.nativeObj, distCoeffs.nativeObj, imageSize.width, imageSize.height, alpha, newImgSize.width, newImgSize.height, validPixROI_out, centerPrincipalPoint));
if(validPixROI!=null){ validPixROI.x = (int)validPixROI_out[0]; validPixROI.y = (int)validPixROI_out[1]; validPixROI.width = (int)validPixROI_out[2]; validPixROI.height = (int)validPixROI_out[3]; }
return retVal;
}
//javadoc: getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha, newImgSize, validPixROI)
public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize, Rect validPixROI)
{
double[] validPixROI_out = new double[4];
Mat retVal = new Mat(getOptimalNewCameraMatrix_1(cameraMatrix.nativeObj, distCoeffs.nativeObj, imageSize.width, imageSize.height, alpha, newImgSize.width, newImgSize.height, validPixROI_out));
if(validPixROI!=null){ validPixROI.x = (int)validPixROI_out[0]; validPixROI.y = (int)validPixROI_out[1]; validPixROI.width = (int)validPixROI_out[2]; validPixROI.height = (int)validPixROI_out[3]; }
return retVal;
}
//javadoc: getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha, newImgSize)
public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize)
{
Mat retVal = new Mat(getOptimalNewCameraMatrix_2(cameraMatrix.nativeObj, distCoeffs.nativeObj, imageSize.width, imageSize.height, alpha, newImgSize.width, newImgSize.height));
return retVal;
}
//javadoc: getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha)
public static Mat getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha)
{
Mat retVal = new Mat(getOptimalNewCameraMatrix_3(cameraMatrix.nativeObj, distCoeffs.nativeObj, imageSize.width, imageSize.height, alpha));
return retVal;
}
//
// C++: Mat cv::initCameraMatrix2D(vector_vector_Point3f objectPoints, vector_vector_Point2f imagePoints, Size imageSize, double aspectRatio = 1.0)
//
//javadoc: initCameraMatrix2D(objectPoints, imagePoints, imageSize, aspectRatio)
public static Mat initCameraMatrix2D(List objectPoints, List imagePoints, Size imageSize, double aspectRatio)
{
List objectPoints_tmplm = new ArrayList((objectPoints != null) ? objectPoints.size() : 0);
Mat objectPoints_mat = Converters.vector_vector_Point3f_to_Mat(objectPoints, objectPoints_tmplm);
List imagePoints_tmplm = new ArrayList((imagePoints != null) ? imagePoints.size() : 0);
Mat imagePoints_mat = Converters.vector_vector_Point2f_to_Mat(imagePoints, imagePoints_tmplm);
Mat retVal = new Mat(initCameraMatrix2D_0(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, aspectRatio));
return retVal;
}
//javadoc: initCameraMatrix2D(objectPoints, imagePoints, imageSize)
public static Mat initCameraMatrix2D(List objectPoints, List imagePoints, Size imageSize)
{
List objectPoints_tmplm = new ArrayList((objectPoints != null) ? objectPoints.size() : 0);
Mat objectPoints_mat = Converters.vector_vector_Point3f_to_Mat(objectPoints, objectPoints_tmplm);
List imagePoints_tmplm = new ArrayList((imagePoints != null) ? imagePoints.size() : 0);
Mat imagePoints_mat = Converters.vector_vector_Point2f_to_Mat(imagePoints, imagePoints_tmplm);
Mat retVal = new Mat(initCameraMatrix2D_1(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height));
return retVal;
}
//
// C++: Rect cv::getValidDisparityROI(Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize)
//
//javadoc: getValidDisparityROI(roi1, roi2, minDisparity, numberOfDisparities, SADWindowSize)
public static Rect getValidDisparityROI(Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize)
{
Rect retVal = new Rect(getValidDisparityROI_0(roi1.x, roi1.y, roi1.width, roi1.height, roi2.x, roi2.y, roi2.width, roi2.height, minDisparity, numberOfDisparities, SADWindowSize));
return retVal;
}
//
// C++: Vec3d cv::RQDecomp3x3(Mat src, Mat& mtxR, Mat& mtxQ, Mat& Qx = Mat(), Mat& Qy = Mat(), Mat& Qz = Mat())
//
//javadoc: RQDecomp3x3(src, mtxR, mtxQ, Qx, Qy, Qz)
public static double[] RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx, Mat Qy, Mat Qz)
{
double[] retVal = RQDecomp3x3_0(src.nativeObj, mtxR.nativeObj, mtxQ.nativeObj, Qx.nativeObj, Qy.nativeObj, Qz.nativeObj);
return retVal;
}
//javadoc: RQDecomp3x3(src, mtxR, mtxQ, Qx, Qy)
public static double[] RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx, Mat Qy)
{
double[] retVal = RQDecomp3x3_1(src.nativeObj, mtxR.nativeObj, mtxQ.nativeObj, Qx.nativeObj, Qy.nativeObj);
return retVal;
}
//javadoc: RQDecomp3x3(src, mtxR, mtxQ, Qx)
public static double[] RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ, Mat Qx)
{
double[] retVal = RQDecomp3x3_2(src.nativeObj, mtxR.nativeObj, mtxQ.nativeObj, Qx.nativeObj);
return retVal;
}
//javadoc: RQDecomp3x3(src, mtxR, mtxQ)
public static double[] RQDecomp3x3(Mat src, Mat mtxR, Mat mtxQ)
{
double[] retVal = RQDecomp3x3_3(src.nativeObj, mtxR.nativeObj, mtxQ.nativeObj);
return retVal;
}
//
// C++: bool cv::findChessboardCorners(Mat image, Size patternSize, vector_Point2f& corners, int flags = CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE)
//
//javadoc: findChessboardCorners(image, patternSize, corners, flags)
public static boolean findChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners, int flags)
{
Mat corners_mat = corners;
boolean retVal = findChessboardCorners_0(image.nativeObj, patternSize.width, patternSize.height, corners_mat.nativeObj, flags);
return retVal;
}
//javadoc: findChessboardCorners(image, patternSize, corners)
public static boolean findChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners)
{
Mat corners_mat = corners;
boolean retVal = findChessboardCorners_1(image.nativeObj, patternSize.width, patternSize.height, corners_mat.nativeObj);
return retVal;
}
//
// C++: bool cv::findCirclesGrid(Mat image, Size patternSize, Mat& centers, int flags, Ptr_FeatureDetector blobDetector, CirclesGridFinderParameters parameters)
//
// Unknown type 'Ptr_FeatureDetector' (I), skipping the function
//
// C++: bool cv::findCirclesGrid(Mat image, Size patternSize, Mat& centers, int flags = CALIB_CB_SYMMETRIC_GRID, Ptr_FeatureDetector blobDetector = SimpleBlobDetector::create())
//
//javadoc: findCirclesGrid(image, patternSize, centers, flags)
public static boolean findCirclesGrid(Mat image, Size patternSize, Mat centers, int flags)
{
boolean retVal = findCirclesGrid_0(image.nativeObj, patternSize.width, patternSize.height, centers.nativeObj, flags);
return retVal;
}
//javadoc: findCirclesGrid(image, patternSize, centers)
public static boolean findCirclesGrid(Mat image, Size patternSize, Mat centers)
{
boolean retVal = findCirclesGrid_2(image.nativeObj, patternSize.width, patternSize.height, centers.nativeObj);
return retVal;
}
//
// C++: bool cv::findCirclesGrid2(Mat image, Size patternSize, Mat& centers, int flags, Ptr_FeatureDetector blobDetector, CirclesGridFinderParameters2 parameters)
//
// Unknown type 'Ptr_FeatureDetector' (I), skipping the function
//
// C++: bool cv::solvePnP(vector_Point3f objectPoints, vector_Point2f imagePoints, Mat cameraMatrix, vector_double distCoeffs, Mat& rvec, Mat& tvec, bool useExtrinsicGuess = false, int flags = SOLVEPNP_ITERATIVE)
//
//javadoc: solvePnP(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess, flags)
public static boolean solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int flags)
{
Mat objectPoints_mat = objectPoints;
Mat imagePoints_mat = imagePoints;
Mat distCoeffs_mat = distCoeffs;
boolean retVal = solvePnP_0(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, useExtrinsicGuess, flags);
return retVal;
}
//javadoc: solvePnP(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess)
public static boolean solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)
{
Mat objectPoints_mat = objectPoints;
Mat imagePoints_mat = imagePoints;
Mat distCoeffs_mat = distCoeffs;
boolean retVal = solvePnP_1(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, useExtrinsicGuess);
return retVal;
}
//javadoc: solvePnP(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec)
public static boolean solvePnP(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec)
{
Mat objectPoints_mat = objectPoints;
Mat imagePoints_mat = imagePoints;
Mat distCoeffs_mat = distCoeffs;
boolean retVal = solvePnP_2(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj);
return retVal;
}
//
// C++: bool cv::solvePnPRansac(vector_Point3f objectPoints, vector_Point2f imagePoints, Mat cameraMatrix, vector_double distCoeffs, Mat& rvec, Mat& tvec, bool useExtrinsicGuess = false, int iterationsCount = 100, float reprojectionError = 8.0, double confidence = 0.99, Mat& inliers = Mat(), int flags = SOLVEPNP_ITERATIVE)
//
//javadoc: solvePnPRansac(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess, iterationsCount, reprojectionError, confidence, inliers, flags)
public static boolean solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, Mat inliers, int flags)
{
Mat objectPoints_mat = objectPoints;
Mat imagePoints_mat = imagePoints;
Mat distCoeffs_mat = distCoeffs;
boolean retVal = solvePnPRansac_0(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, useExtrinsicGuess, iterationsCount, reprojectionError, confidence, inliers.nativeObj, flags);
return retVal;
}
//javadoc: solvePnPRansac(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess, iterationsCount, reprojectionError, confidence, inliers)
public static boolean solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, Mat inliers)
{
Mat objectPoints_mat = objectPoints;
Mat imagePoints_mat = imagePoints;
Mat distCoeffs_mat = distCoeffs;
boolean retVal = solvePnPRansac_1(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, useExtrinsicGuess, iterationsCount, reprojectionError, confidence, inliers.nativeObj);
return retVal;
}
//javadoc: solvePnPRansac(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess, iterationsCount, reprojectionError, confidence)
public static boolean solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence)
{
Mat objectPoints_mat = objectPoints;
Mat imagePoints_mat = imagePoints;
Mat distCoeffs_mat = distCoeffs;
boolean retVal = solvePnPRansac_2(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, useExtrinsicGuess, iterationsCount, reprojectionError, confidence);
return retVal;
}
//javadoc: solvePnPRansac(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess, iterationsCount, reprojectionError)
public static boolean solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError)
{
Mat objectPoints_mat = objectPoints;
Mat imagePoints_mat = imagePoints;
Mat distCoeffs_mat = distCoeffs;
boolean retVal = solvePnPRansac_3(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, useExtrinsicGuess, iterationsCount, reprojectionError);
return retVal;
}
//javadoc: solvePnPRansac(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess, iterationsCount)
public static boolean solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess, int iterationsCount)
{
Mat objectPoints_mat = objectPoints;
Mat imagePoints_mat = imagePoints;
Mat distCoeffs_mat = distCoeffs;
boolean retVal = solvePnPRansac_4(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, useExtrinsicGuess, iterationsCount);
return retVal;
}
//javadoc: solvePnPRansac(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess)
public static boolean solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec, boolean useExtrinsicGuess)
{
Mat objectPoints_mat = objectPoints;
Mat imagePoints_mat = imagePoints;
Mat distCoeffs_mat = distCoeffs;
boolean retVal = solvePnPRansac_5(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, useExtrinsicGuess);
return retVal;
}
//javadoc: solvePnPRansac(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec)
public static boolean solvePnPRansac(MatOfPoint3f objectPoints, MatOfPoint2f imagePoints, Mat cameraMatrix, MatOfDouble distCoeffs, Mat rvec, Mat tvec)
{
Mat objectPoints_mat = objectPoints;
Mat imagePoints_mat = imagePoints;
Mat distCoeffs_mat = distCoeffs;
boolean retVal = solvePnPRansac_6(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, rvec.nativeObj, tvec.nativeObj);
return retVal;
}
//
// C++: bool cv::stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat& H1, Mat& H2, double threshold = 5)
//
//javadoc: stereoRectifyUncalibrated(points1, points2, F, imgSize, H1, H2, threshold)
public static boolean stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat H1, Mat H2, double threshold)
{
boolean retVal = stereoRectifyUncalibrated_0(points1.nativeObj, points2.nativeObj, F.nativeObj, imgSize.width, imgSize.height, H1.nativeObj, H2.nativeObj, threshold);
return retVal;
}
//javadoc: stereoRectifyUncalibrated(points1, points2, F, imgSize, H1, H2)
public static boolean stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat H1, Mat H2)
{
boolean retVal = stereoRectifyUncalibrated_1(points1.nativeObj, points2.nativeObj, F.nativeObj, imgSize.width, imgSize.height, H1.nativeObj, H2.nativeObj);
return retVal;
}
//
// C++: double cv::calibrateCamera(vector_Mat objectPoints, vector_Mat imagePoints, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, Mat& stdDeviationsIntrinsics, Mat& stdDeviationsExtrinsics, Mat& perViewErrors, int flags = 0, TermCriteria criteria = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON))
//
//javadoc: calibrateCameraExtended(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors, flags, criteria)
public static double calibrateCameraExtended(List objectPoints, List imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags, TermCriteria criteria)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints);
Mat rvecs_mat = new Mat();
Mat tvecs_mat = new Mat();
double retVal = calibrateCameraExtended_0(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, stdDeviationsIntrinsics.nativeObj, stdDeviationsExtrinsics.nativeObj, perViewErrors.nativeObj, flags, criteria.type, criteria.maxCount, criteria.epsilon);
Converters.Mat_to_vector_Mat(rvecs_mat, rvecs);
rvecs_mat.release();
Converters.Mat_to_vector_Mat(tvecs_mat, tvecs);
tvecs_mat.release();
return retVal;
}
//javadoc: calibrateCameraExtended(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors, flags)
public static double calibrateCameraExtended(List objectPoints, List imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors, int flags)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints);
Mat rvecs_mat = new Mat();
Mat tvecs_mat = new Mat();
double retVal = calibrateCameraExtended_1(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, stdDeviationsIntrinsics.nativeObj, stdDeviationsExtrinsics.nativeObj, perViewErrors.nativeObj, flags);
Converters.Mat_to_vector_Mat(rvecs_mat, rvecs);
rvecs_mat.release();
Converters.Mat_to_vector_Mat(tvecs_mat, tvecs);
tvecs_mat.release();
return retVal;
}
//javadoc: calibrateCameraExtended(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors)
public static double calibrateCameraExtended(List objectPoints, List imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs, Mat stdDeviationsIntrinsics, Mat stdDeviationsExtrinsics, Mat perViewErrors)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints);
Mat rvecs_mat = new Mat();
Mat tvecs_mat = new Mat();
double retVal = calibrateCameraExtended_2(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, stdDeviationsIntrinsics.nativeObj, stdDeviationsExtrinsics.nativeObj, perViewErrors.nativeObj);
Converters.Mat_to_vector_Mat(rvecs_mat, rvecs);
rvecs_mat.release();
Converters.Mat_to_vector_Mat(tvecs_mat, tvecs);
tvecs_mat.release();
return retVal;
}
//
// C++: double cv::calibrateCamera(vector_Mat objectPoints, vector_Mat imagePoints, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, int flags = 0, TermCriteria criteria = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON))
//
//javadoc: calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, flags, criteria)
public static double calibrateCamera(List objectPoints, List imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs, int flags, TermCriteria criteria)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints);
Mat rvecs_mat = new Mat();
Mat tvecs_mat = new Mat();
double retVal = calibrateCamera_0(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, flags, criteria.type, criteria.maxCount, criteria.epsilon);
Converters.Mat_to_vector_Mat(rvecs_mat, rvecs);
rvecs_mat.release();
Converters.Mat_to_vector_Mat(tvecs_mat, tvecs);
tvecs_mat.release();
return retVal;
}
//javadoc: calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, flags)
public static double calibrateCamera(List objectPoints, List imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs, int flags)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints);
Mat rvecs_mat = new Mat();
Mat tvecs_mat = new Mat();
double retVal = calibrateCamera_1(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, flags);
Converters.Mat_to_vector_Mat(rvecs_mat, rvecs);
rvecs_mat.release();
Converters.Mat_to_vector_Mat(tvecs_mat, tvecs);
tvecs_mat.release();
return retVal;
}
//javadoc: calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs)
public static double calibrateCamera(List objectPoints, List imagePoints, Size imageSize, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints);
Mat rvecs_mat = new Mat();
Mat tvecs_mat = new Mat();
double retVal = calibrateCamera_2(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, imageSize.width, imageSize.height, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj);
Converters.Mat_to_vector_Mat(rvecs_mat, rvecs);
rvecs_mat.release();
Converters.Mat_to_vector_Mat(tvecs_mat, tvecs);
tvecs_mat.release();
return retVal;
}
//
// C++: double cv::sampsonDistance(Mat pt1, Mat pt2, Mat F)
//
//javadoc: sampsonDistance(pt1, pt2, F)
public static double sampsonDistance(Mat pt1, Mat pt2, Mat F)
{
double retVal = sampsonDistance_0(pt1.nativeObj, pt2.nativeObj, F.nativeObj);
return retVal;
}
//
// C++: double cv::stereoCalibrate(vector_Mat objectPoints, vector_Mat imagePoints1, vector_Mat imagePoints2, Mat& cameraMatrix1, Mat& distCoeffs1, Mat& cameraMatrix2, Mat& distCoeffs2, Size imageSize, Mat& R, Mat& T, Mat& E, Mat& F, Mat& perViewErrors, int flags = CALIB_FIX_INTRINSIC, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
//
//javadoc: stereoCalibrateExtended(objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, E, F, perViewErrors, flags, criteria)
public static double stereoCalibrateExtended(List objectPoints, List imagePoints1, List imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, Mat perViewErrors, int flags, TermCriteria criteria)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1);
Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2);
double retVal = stereoCalibrateExtended_0(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, E.nativeObj, F.nativeObj, perViewErrors.nativeObj, flags, criteria.type, criteria.maxCount, criteria.epsilon);
return retVal;
}
//javadoc: stereoCalibrateExtended(objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, E, F, perViewErrors, flags)
public static double stereoCalibrateExtended(List objectPoints, List imagePoints1, List imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, Mat perViewErrors, int flags)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1);
Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2);
double retVal = stereoCalibrateExtended_1(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, E.nativeObj, F.nativeObj, perViewErrors.nativeObj, flags);
return retVal;
}
//javadoc: stereoCalibrateExtended(objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, E, F, perViewErrors)
public static double stereoCalibrateExtended(List objectPoints, List imagePoints1, List imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, Mat perViewErrors)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1);
Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2);
double retVal = stereoCalibrateExtended_2(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, E.nativeObj, F.nativeObj, perViewErrors.nativeObj);
return retVal;
}
//
// C++: double cv::stereoCalibrate(vector_Mat objectPoints, vector_Mat imagePoints1, vector_Mat imagePoints2, Mat& cameraMatrix1, Mat& distCoeffs1, Mat& cameraMatrix2, Mat& distCoeffs2, Size imageSize, Mat& R, Mat& T, Mat& E, Mat& F, int flags = CALIB_FIX_INTRINSIC, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
//
//javadoc: stereoCalibrate(objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, E, F, flags, criteria)
public static double stereoCalibrate(List objectPoints, List imagePoints1, List imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, int flags, TermCriteria criteria)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1);
Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2);
double retVal = stereoCalibrate_0(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, E.nativeObj, F.nativeObj, flags, criteria.type, criteria.maxCount, criteria.epsilon);
return retVal;
}
//javadoc: stereoCalibrate(objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, E, F, flags)
public static double stereoCalibrate(List objectPoints, List imagePoints1, List imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F, int flags)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1);
Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2);
double retVal = stereoCalibrate_1(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, E.nativeObj, F.nativeObj, flags);
return retVal;
}
//javadoc: stereoCalibrate(objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, E, F)
public static double stereoCalibrate(List objectPoints, List imagePoints1, List imagePoints2, Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat E, Mat F)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1);
Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2);
double retVal = stereoCalibrate_2(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, E.nativeObj, F.nativeObj);
return retVal;
}
//
// C++: double cv::fisheye::calibrate(vector_Mat objectPoints, vector_Mat imagePoints, Size image_size, Mat& K, Mat& D, vector_Mat& rvecs, vector_Mat& tvecs, int flags = 0, TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON))
//
//javadoc: fisheye_calibrate(objectPoints, imagePoints, image_size, K, D, rvecs, tvecs, flags, criteria)
public static double fisheye_calibrate(List objectPoints, List imagePoints, Size image_size, Mat K, Mat D, List rvecs, List tvecs, int flags, TermCriteria criteria)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints);
Mat rvecs_mat = new Mat();
Mat tvecs_mat = new Mat();
double retVal = fisheye_calibrate_0(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, image_size.width, image_size.height, K.nativeObj, D.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, flags, criteria.type, criteria.maxCount, criteria.epsilon);
Converters.Mat_to_vector_Mat(rvecs_mat, rvecs);
rvecs_mat.release();
Converters.Mat_to_vector_Mat(tvecs_mat, tvecs);
tvecs_mat.release();
return retVal;
}
//javadoc: fisheye_calibrate(objectPoints, imagePoints, image_size, K, D, rvecs, tvecs, flags)
public static double fisheye_calibrate(List objectPoints, List imagePoints, Size image_size, Mat K, Mat D, List rvecs, List tvecs, int flags)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints);
Mat rvecs_mat = new Mat();
Mat tvecs_mat = new Mat();
double retVal = fisheye_calibrate_1(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, image_size.width, image_size.height, K.nativeObj, D.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, flags);
Converters.Mat_to_vector_Mat(rvecs_mat, rvecs);
rvecs_mat.release();
Converters.Mat_to_vector_Mat(tvecs_mat, tvecs);
tvecs_mat.release();
return retVal;
}
//javadoc: fisheye_calibrate(objectPoints, imagePoints, image_size, K, D, rvecs, tvecs)
public static double fisheye_calibrate(List objectPoints, List imagePoints, Size image_size, Mat K, Mat D, List rvecs, List tvecs)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints_mat = Converters.vector_Mat_to_Mat(imagePoints);
Mat rvecs_mat = new Mat();
Mat tvecs_mat = new Mat();
double retVal = fisheye_calibrate_2(objectPoints_mat.nativeObj, imagePoints_mat.nativeObj, image_size.width, image_size.height, K.nativeObj, D.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj);
Converters.Mat_to_vector_Mat(rvecs_mat, rvecs);
rvecs_mat.release();
Converters.Mat_to_vector_Mat(tvecs_mat, tvecs);
tvecs_mat.release();
return retVal;
}
//
// C++: double cv::fisheye::stereoCalibrate(vector_Mat objectPoints, vector_Mat imagePoints1, vector_Mat imagePoints2, Mat& K1, Mat& D1, Mat& K2, Mat& D2, Size imageSize, Mat& R, Mat& T, int flags = fisheye::CALIB_FIX_INTRINSIC, TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON))
//
//javadoc: fisheye_stereoCalibrate(objectPoints, imagePoints1, imagePoints2, K1, D1, K2, D2, imageSize, R, T, flags, criteria)
public static double fisheye_stereoCalibrate(List objectPoints, List imagePoints1, List imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, int flags, TermCriteria criteria)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1);
Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2);
double retVal = fisheye_stereoCalibrate_0(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, K1.nativeObj, D1.nativeObj, K2.nativeObj, D2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, flags, criteria.type, criteria.maxCount, criteria.epsilon);
return retVal;
}
//javadoc: fisheye_stereoCalibrate(objectPoints, imagePoints1, imagePoints2, K1, D1, K2, D2, imageSize, R, T, flags)
public static double fisheye_stereoCalibrate(List objectPoints, List imagePoints1, List imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T, int flags)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1);
Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2);
double retVal = fisheye_stereoCalibrate_1(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, K1.nativeObj, D1.nativeObj, K2.nativeObj, D2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, flags);
return retVal;
}
//javadoc: fisheye_stereoCalibrate(objectPoints, imagePoints1, imagePoints2, K1, D1, K2, D2, imageSize, R, T)
public static double fisheye_stereoCalibrate(List objectPoints, List imagePoints1, List imagePoints2, Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat T)
{
Mat objectPoints_mat = Converters.vector_Mat_to_Mat(objectPoints);
Mat imagePoints1_mat = Converters.vector_Mat_to_Mat(imagePoints1);
Mat imagePoints2_mat = Converters.vector_Mat_to_Mat(imagePoints2);
double retVal = fisheye_stereoCalibrate_2(objectPoints_mat.nativeObj, imagePoints1_mat.nativeObj, imagePoints2_mat.nativeObj, K1.nativeObj, D1.nativeObj, K2.nativeObj, D2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj);
return retVal;
}
//
// C++: float cv::rectify3Collinear(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat cameraMatrix3, Mat distCoeffs3, vector_Mat imgpt1, vector_Mat imgpt3, Size imageSize, Mat R12, Mat T12, Mat R13, Mat T13, Mat& R1, Mat& R2, Mat& R3, Mat& P1, Mat& P2, Mat& P3, Mat& Q, double alpha, Size newImgSize, Rect* roi1, Rect* roi2, int flags)
//
//javadoc: rectify3Collinear(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, cameraMatrix3, distCoeffs3, imgpt1, imgpt3, imageSize, R12, T12, R13, T13, R1, R2, R3, P1, P2, P3, Q, alpha, newImgSize, roi1, roi2, flags)
public static float rectify3Collinear(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat cameraMatrix3, Mat distCoeffs3, List imgpt1, List imgpt3, Size imageSize, Mat R12, Mat T12, Mat R13, Mat T13, Mat R1, Mat R2, Mat R3, Mat P1, Mat P2, Mat P3, Mat Q, double alpha, Size newImgSize, Rect roi1, Rect roi2, int flags)
{
Mat imgpt1_mat = Converters.vector_Mat_to_Mat(imgpt1);
Mat imgpt3_mat = Converters.vector_Mat_to_Mat(imgpt3);
double[] roi1_out = new double[4];
double[] roi2_out = new double[4];
float retVal = rectify3Collinear_0(cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, cameraMatrix3.nativeObj, distCoeffs3.nativeObj, imgpt1_mat.nativeObj, imgpt3_mat.nativeObj, imageSize.width, imageSize.height, R12.nativeObj, T12.nativeObj, R13.nativeObj, T13.nativeObj, R1.nativeObj, R2.nativeObj, R3.nativeObj, P1.nativeObj, P2.nativeObj, P3.nativeObj, Q.nativeObj, alpha, newImgSize.width, newImgSize.height, roi1_out, roi2_out, flags);
if(roi1!=null){ roi1.x = (int)roi1_out[0]; roi1.y = (int)roi1_out[1]; roi1.width = (int)roi1_out[2]; roi1.height = (int)roi1_out[3]; }
if(roi2!=null){ roi2.x = (int)roi2_out[0]; roi2.y = (int)roi2_out[1]; roi2.width = (int)roi2_out[2]; roi2.height = (int)roi2_out[3]; }
return retVal;
}
//
// C++: int cv::decomposeHomographyMat(Mat H, Mat K, vector_Mat& rotations, vector_Mat& translations, vector_Mat& normals)
//
//javadoc: decomposeHomographyMat(H, K, rotations, translations, normals)
public static int decomposeHomographyMat(Mat H, Mat K, List rotations, List translations, List normals)
{
Mat rotations_mat = new Mat();
Mat translations_mat = new Mat();
Mat normals_mat = new Mat();
int retVal = decomposeHomographyMat_0(H.nativeObj, K.nativeObj, rotations_mat.nativeObj, translations_mat.nativeObj, normals_mat.nativeObj);
Converters.Mat_to_vector_Mat(rotations_mat, rotations);
rotations_mat.release();
Converters.Mat_to_vector_Mat(translations_mat, translations);
translations_mat.release();
Converters.Mat_to_vector_Mat(normals_mat, normals);
normals_mat.release();
return retVal;
}
//
// C++: int cv::estimateAffine3D(Mat src, Mat dst, Mat& out, Mat& inliers, double ransacThreshold = 3, double confidence = 0.99)
//
//javadoc: estimateAffine3D(src, dst, out, inliers, ransacThreshold, confidence)
public static int estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers, double ransacThreshold, double confidence)
{
int retVal = estimateAffine3D_0(src.nativeObj, dst.nativeObj, out.nativeObj, inliers.nativeObj, ransacThreshold, confidence);
return retVal;
}
//javadoc: estimateAffine3D(src, dst, out, inliers, ransacThreshold)
public static int estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers, double ransacThreshold)
{
int retVal = estimateAffine3D_1(src.nativeObj, dst.nativeObj, out.nativeObj, inliers.nativeObj, ransacThreshold);
return retVal;
}
//javadoc: estimateAffine3D(src, dst, out, inliers)
public static int estimateAffine3D(Mat src, Mat dst, Mat out, Mat inliers)
{
int retVal = estimateAffine3D_2(src.nativeObj, dst.nativeObj, out.nativeObj, inliers.nativeObj);
return retVal;
}
//
// C++: int cv::recoverPose(Mat E, Mat points1, Mat points2, Mat& R, Mat& t, double focal = 1.0, Point2d pp = Point2d(0, 0), Mat& mask = Mat())
//
//javadoc: recoverPose(E, points1, points2, R, t, focal, pp, mask)
public static int recoverPose(Mat E, Mat points1, Mat points2, Mat R, Mat t, double focal, Point pp, Mat mask)
{
int retVal = recoverPose_0(E.nativeObj, points1.nativeObj, points2.nativeObj, R.nativeObj, t.nativeObj, focal, pp.x, pp.y, mask.nativeObj);
return retVal;
}
//javadoc: recoverPose(E, points1, points2, R, t, focal, pp)
public static int recoverPose(Mat E, Mat points1, Mat points2, Mat R, Mat t, double focal, Point pp)
{
int retVal = recoverPose_1(E.nativeObj, points1.nativeObj, points2.nativeObj, R.nativeObj, t.nativeObj, focal, pp.x, pp.y);
return retVal;
}
//javadoc: recoverPose(E, points1, points2, R, t, focal)
public static int recoverPose(Mat E, Mat points1, Mat points2, Mat R, Mat t, double focal)
{
int retVal = recoverPose_2(E.nativeObj, points1.nativeObj, points2.nativeObj, R.nativeObj, t.nativeObj, focal);
return retVal;
}
//javadoc: recoverPose(E, points1, points2, R, t)
public static int recoverPose(Mat E, Mat points1, Mat points2, Mat R, Mat t)
{
int retVal = recoverPose_3(E.nativeObj, points1.nativeObj, points2.nativeObj, R.nativeObj, t.nativeObj);
return retVal;
}
//
// C++: int cv::recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat& R, Mat& t, Mat& mask = Mat())
//
//javadoc: recoverPose(E, points1, points2, cameraMatrix, R, t, mask)
public static int recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, Mat mask)
{
int retVal = recoverPose_4(E.nativeObj, points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, R.nativeObj, t.nativeObj, mask.nativeObj);
return retVal;
}
//javadoc: recoverPose(E, points1, points2, cameraMatrix, R, t)
public static int recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t)
{
int retVal = recoverPose_5(E.nativeObj, points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, R.nativeObj, t.nativeObj);
return retVal;
}
//
// C++: int cv::recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat& R, Mat& t, double distanceThresh, Mat& mask = Mat(), Mat& triangulatedPoints = Mat())
//
//javadoc: recoverPose(E, points1, points2, cameraMatrix, R, t, distanceThresh, mask, triangulatedPoints)
public static int recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, double distanceThresh, Mat mask, Mat triangulatedPoints)
{
int retVal = recoverPose_6(E.nativeObj, points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, R.nativeObj, t.nativeObj, distanceThresh, mask.nativeObj, triangulatedPoints.nativeObj);
return retVal;
}
//javadoc: recoverPose(E, points1, points2, cameraMatrix, R, t, distanceThresh, mask)
public static int recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, double distanceThresh, Mat mask)
{
int retVal = recoverPose_7(E.nativeObj, points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, R.nativeObj, t.nativeObj, distanceThresh, mask.nativeObj);
return retVal;
}
//javadoc: recoverPose(E, points1, points2, cameraMatrix, R, t, distanceThresh)
public static int recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat R, Mat t, double distanceThresh)
{
int retVal = recoverPose_8(E.nativeObj, points1.nativeObj, points2.nativeObj, cameraMatrix.nativeObj, R.nativeObj, t.nativeObj, distanceThresh);
return retVal;
}
//
// C++: int cv::solveP3P(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, int flags)
//
//javadoc: solveP3P(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvecs, tvecs, flags)
public static int solveP3P(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, List rvecs, List tvecs, int flags)
{
Mat rvecs_mat = new Mat();
Mat tvecs_mat = new Mat();
int retVal = solveP3P_0(objectPoints.nativeObj, imagePoints.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvecs_mat.nativeObj, tvecs_mat.nativeObj, flags);
Converters.Mat_to_vector_Mat(rvecs_mat, rvecs);
rvecs_mat.release();
Converters.Mat_to_vector_Mat(tvecs_mat, tvecs);
tvecs_mat.release();
return retVal;
}
//
// C++: void cv::Rodrigues(Mat src, Mat& dst, Mat& jacobian = Mat())
//
//javadoc: Rodrigues(src, dst, jacobian)
public static void Rodrigues(Mat src, Mat dst, Mat jacobian)
{
Rodrigues_0(src.nativeObj, dst.nativeObj, jacobian.nativeObj);
return;
}
//javadoc: Rodrigues(src, dst)
public static void Rodrigues(Mat src, Mat dst)
{
Rodrigues_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::calibrateHandEye(vector_Mat R_gripper2base, vector_Mat t_gripper2base, vector_Mat R_target2cam, vector_Mat t_target2cam, Mat& R_cam2gripper, Mat& t_cam2gripper, HandEyeCalibrationMethod method = CALIB_HAND_EYE_TSAI)
//
//javadoc: calibrateHandEye(R_gripper2base, t_gripper2base, R_target2cam, t_target2cam, R_cam2gripper, t_cam2gripper, method)
public static void calibrateHandEye(List R_gripper2base, List t_gripper2base, List R_target2cam, List t_target2cam, Mat R_cam2gripper, Mat t_cam2gripper, int method)
{
Mat R_gripper2base_mat = Converters.vector_Mat_to_Mat(R_gripper2base);
Mat t_gripper2base_mat = Converters.vector_Mat_to_Mat(t_gripper2base);
Mat R_target2cam_mat = Converters.vector_Mat_to_Mat(R_target2cam);
Mat t_target2cam_mat = Converters.vector_Mat_to_Mat(t_target2cam);
calibrateHandEye_0(R_gripper2base_mat.nativeObj, t_gripper2base_mat.nativeObj, R_target2cam_mat.nativeObj, t_target2cam_mat.nativeObj, R_cam2gripper.nativeObj, t_cam2gripper.nativeObj, method);
return;
}
//javadoc: calibrateHandEye(R_gripper2base, t_gripper2base, R_target2cam, t_target2cam, R_cam2gripper, t_cam2gripper)
public static void calibrateHandEye(List R_gripper2base, List t_gripper2base, List R_target2cam, List t_target2cam, Mat R_cam2gripper, Mat t_cam2gripper)
{
Mat R_gripper2base_mat = Converters.vector_Mat_to_Mat(R_gripper2base);
Mat t_gripper2base_mat = Converters.vector_Mat_to_Mat(t_gripper2base);
Mat R_target2cam_mat = Converters.vector_Mat_to_Mat(R_target2cam);
Mat t_target2cam_mat = Converters.vector_Mat_to_Mat(t_target2cam);
calibrateHandEye_1(R_gripper2base_mat.nativeObj, t_gripper2base_mat.nativeObj, R_target2cam_mat.nativeObj, t_target2cam_mat.nativeObj, R_cam2gripper.nativeObj, t_cam2gripper.nativeObj);
return;
}
//
// C++: void cv::calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double& fovx, double& fovy, double& focalLength, Point2d& principalPoint, double& aspectRatio)
//
//javadoc: calibrationMatrixValues(cameraMatrix, imageSize, apertureWidth, apertureHeight, fovx, fovy, focalLength, principalPoint, aspectRatio)
public static void calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double[] fovx, double[] fovy, double[] focalLength, Point principalPoint, double[] aspectRatio)
{
double[] fovx_out = new double[1];
double[] fovy_out = new double[1];
double[] focalLength_out = new double[1];
double[] principalPoint_out = new double[2];
double[] aspectRatio_out = new double[1];
calibrationMatrixValues_0(cameraMatrix.nativeObj, imageSize.width, imageSize.height, apertureWidth, apertureHeight, fovx_out, fovy_out, focalLength_out, principalPoint_out, aspectRatio_out);
if(fovx!=null) fovx[0] = (double)fovx_out[0];
if(fovy!=null) fovy[0] = (double)fovy_out[0];
if(focalLength!=null) focalLength[0] = (double)focalLength_out[0];
if(principalPoint!=null){ principalPoint.x = principalPoint_out[0]; principalPoint.y = principalPoint_out[1]; }
if(aspectRatio!=null) aspectRatio[0] = (double)aspectRatio_out[0];
return;
}
//
// C++: void cv::composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat& rvec3, Mat& tvec3, Mat& dr3dr1 = Mat(), Mat& dr3dt1 = Mat(), Mat& dr3dr2 = Mat(), Mat& dr3dt2 = Mat(), Mat& dt3dr1 = Mat(), Mat& dt3dt1 = Mat(), Mat& dt3dr2 = Mat(), Mat& dt3dt2 = Mat())
//
//javadoc: composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3, dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1, dt3dr2, dt3dt2)
public static void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1, Mat dr3dr2, Mat dr3dt2, Mat dt3dr1, Mat dt3dt1, Mat dt3dr2, Mat dt3dt2)
{
composeRT_0(rvec1.nativeObj, tvec1.nativeObj, rvec2.nativeObj, tvec2.nativeObj, rvec3.nativeObj, tvec3.nativeObj, dr3dr1.nativeObj, dr3dt1.nativeObj, dr3dr2.nativeObj, dr3dt2.nativeObj, dt3dr1.nativeObj, dt3dt1.nativeObj, dt3dr2.nativeObj, dt3dt2.nativeObj);
return;
}
//javadoc: composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3, dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1, dt3dr2)
public static void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1, Mat dr3dr2, Mat dr3dt2, Mat dt3dr1, Mat dt3dt1, Mat dt3dr2)
{
composeRT_1(rvec1.nativeObj, tvec1.nativeObj, rvec2.nativeObj, tvec2.nativeObj, rvec3.nativeObj, tvec3.nativeObj, dr3dr1.nativeObj, dr3dt1.nativeObj, dr3dr2.nativeObj, dr3dt2.nativeObj, dt3dr1.nativeObj, dt3dt1.nativeObj, dt3dr2.nativeObj);
return;
}
//javadoc: composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3, dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1)
public static void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1, Mat dr3dr2, Mat dr3dt2, Mat dt3dr1, Mat dt3dt1)
{
composeRT_2(rvec1.nativeObj, tvec1.nativeObj, rvec2.nativeObj, tvec2.nativeObj, rvec3.nativeObj, tvec3.nativeObj, dr3dr1.nativeObj, dr3dt1.nativeObj, dr3dr2.nativeObj, dr3dt2.nativeObj, dt3dr1.nativeObj, dt3dt1.nativeObj);
return;
}
//javadoc: composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3, dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1)
public static void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1, Mat dr3dr2, Mat dr3dt2, Mat dt3dr1)
{
composeRT_3(rvec1.nativeObj, tvec1.nativeObj, rvec2.nativeObj, tvec2.nativeObj, rvec3.nativeObj, tvec3.nativeObj, dr3dr1.nativeObj, dr3dt1.nativeObj, dr3dr2.nativeObj, dr3dt2.nativeObj, dt3dr1.nativeObj);
return;
}
//javadoc: composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3, dr3dr1, dr3dt1, dr3dr2, dr3dt2)
public static void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1, Mat dr3dr2, Mat dr3dt2)
{
composeRT_4(rvec1.nativeObj, tvec1.nativeObj, rvec2.nativeObj, tvec2.nativeObj, rvec3.nativeObj, tvec3.nativeObj, dr3dr1.nativeObj, dr3dt1.nativeObj, dr3dr2.nativeObj, dr3dt2.nativeObj);
return;
}
//javadoc: composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3, dr3dr1, dr3dt1, dr3dr2)
public static void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1, Mat dr3dr2)
{
composeRT_5(rvec1.nativeObj, tvec1.nativeObj, rvec2.nativeObj, tvec2.nativeObj, rvec3.nativeObj, tvec3.nativeObj, dr3dr1.nativeObj, dr3dt1.nativeObj, dr3dr2.nativeObj);
return;
}
//javadoc: composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3, dr3dr1, dr3dt1)
public static void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1, Mat dr3dt1)
{
composeRT_6(rvec1.nativeObj, tvec1.nativeObj, rvec2.nativeObj, tvec2.nativeObj, rvec3.nativeObj, tvec3.nativeObj, dr3dr1.nativeObj, dr3dt1.nativeObj);
return;
}
//javadoc: composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3, dr3dr1)
public static void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3, Mat dr3dr1)
{
composeRT_7(rvec1.nativeObj, tvec1.nativeObj, rvec2.nativeObj, tvec2.nativeObj, rvec3.nativeObj, tvec3.nativeObj, dr3dr1.nativeObj);
return;
}
//javadoc: composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3)
public static void composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat rvec3, Mat tvec3)
{
composeRT_8(rvec1.nativeObj, tvec1.nativeObj, rvec2.nativeObj, tvec2.nativeObj, rvec3.nativeObj, tvec3.nativeObj);
return;
}
//
// C++: void cv::computeCorrespondEpilines(Mat points, int whichImage, Mat F, Mat& lines)
//
//javadoc: computeCorrespondEpilines(points, whichImage, F, lines)
public static void computeCorrespondEpilines(Mat points, int whichImage, Mat F, Mat lines)
{
computeCorrespondEpilines_0(points.nativeObj, whichImage, F.nativeObj, lines.nativeObj);
return;
}
//
// C++: void cv::convertPointsFromHomogeneous(Mat src, Mat& dst)
//
//javadoc: convertPointsFromHomogeneous(src, dst)
public static void convertPointsFromHomogeneous(Mat src, Mat dst)
{
convertPointsFromHomogeneous_0(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::convertPointsToHomogeneous(Mat src, Mat& dst)
//
//javadoc: convertPointsToHomogeneous(src, dst)
public static void convertPointsToHomogeneous(Mat src, Mat dst)
{
convertPointsToHomogeneous_0(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::correctMatches(Mat F, Mat points1, Mat points2, Mat& newPoints1, Mat& newPoints2)
//
//javadoc: correctMatches(F, points1, points2, newPoints1, newPoints2)
public static void correctMatches(Mat F, Mat points1, Mat points2, Mat newPoints1, Mat newPoints2)
{
correctMatches_0(F.nativeObj, points1.nativeObj, points2.nativeObj, newPoints1.nativeObj, newPoints2.nativeObj);
return;
}
//
// C++: void cv::decomposeEssentialMat(Mat E, Mat& R1, Mat& R2, Mat& t)
//
//javadoc: decomposeEssentialMat(E, R1, R2, t)
public static void decomposeEssentialMat(Mat E, Mat R1, Mat R2, Mat t)
{
decomposeEssentialMat_0(E.nativeObj, R1.nativeObj, R2.nativeObj, t.nativeObj);
return;
}
//
// C++: void cv::decomposeProjectionMatrix(Mat projMatrix, Mat& cameraMatrix, Mat& rotMatrix, Mat& transVect, Mat& rotMatrixX = Mat(), Mat& rotMatrixY = Mat(), Mat& rotMatrixZ = Mat(), Mat& eulerAngles = Mat())
//
//javadoc: decomposeProjectionMatrix(projMatrix, cameraMatrix, rotMatrix, transVect, rotMatrixX, rotMatrixY, rotMatrixZ, eulerAngles)
public static void decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX, Mat rotMatrixY, Mat rotMatrixZ, Mat eulerAngles)
{
decomposeProjectionMatrix_0(projMatrix.nativeObj, cameraMatrix.nativeObj, rotMatrix.nativeObj, transVect.nativeObj, rotMatrixX.nativeObj, rotMatrixY.nativeObj, rotMatrixZ.nativeObj, eulerAngles.nativeObj);
return;
}
//javadoc: decomposeProjectionMatrix(projMatrix, cameraMatrix, rotMatrix, transVect, rotMatrixX, rotMatrixY, rotMatrixZ)
public static void decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX, Mat rotMatrixY, Mat rotMatrixZ)
{
decomposeProjectionMatrix_1(projMatrix.nativeObj, cameraMatrix.nativeObj, rotMatrix.nativeObj, transVect.nativeObj, rotMatrixX.nativeObj, rotMatrixY.nativeObj, rotMatrixZ.nativeObj);
return;
}
//javadoc: decomposeProjectionMatrix(projMatrix, cameraMatrix, rotMatrix, transVect, rotMatrixX, rotMatrixY)
public static void decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX, Mat rotMatrixY)
{
decomposeProjectionMatrix_2(projMatrix.nativeObj, cameraMatrix.nativeObj, rotMatrix.nativeObj, transVect.nativeObj, rotMatrixX.nativeObj, rotMatrixY.nativeObj);
return;
}
//javadoc: decomposeProjectionMatrix(projMatrix, cameraMatrix, rotMatrix, transVect, rotMatrixX)
public static void decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect, Mat rotMatrixX)
{
decomposeProjectionMatrix_3(projMatrix.nativeObj, cameraMatrix.nativeObj, rotMatrix.nativeObj, transVect.nativeObj, rotMatrixX.nativeObj);
return;
}
//javadoc: decomposeProjectionMatrix(projMatrix, cameraMatrix, rotMatrix, transVect)
public static void decomposeProjectionMatrix(Mat projMatrix, Mat cameraMatrix, Mat rotMatrix, Mat transVect)
{
decomposeProjectionMatrix_4(projMatrix.nativeObj, cameraMatrix.nativeObj, rotMatrix.nativeObj, transVect.nativeObj);
return;
}
//
// C++: void cv::drawChessboardCorners(Mat& image, Size patternSize, vector_Point2f corners, bool patternWasFound)
//
//javadoc: drawChessboardCorners(image, patternSize, corners, patternWasFound)
public static void drawChessboardCorners(Mat image, Size patternSize, MatOfPoint2f corners, boolean patternWasFound)
{
Mat corners_mat = corners;
drawChessboardCorners_0(image.nativeObj, patternSize.width, patternSize.height, corners_mat.nativeObj, patternWasFound);
return;
}
//
// C++: void cv::drawFrameAxes(Mat& image, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, float length, int thickness = 3)
//
//javadoc: drawFrameAxes(image, cameraMatrix, distCoeffs, rvec, tvec, length, thickness)
public static void drawFrameAxes(Mat image, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, float length, int thickness)
{
drawFrameAxes_0(image.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvec.nativeObj, tvec.nativeObj, length, thickness);
return;
}
//javadoc: drawFrameAxes(image, cameraMatrix, distCoeffs, rvec, tvec, length)
public static void drawFrameAxes(Mat image, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, float length)
{
drawFrameAxes_1(image.nativeObj, cameraMatrix.nativeObj, distCoeffs.nativeObj, rvec.nativeObj, tvec.nativeObj, length);
return;
}
//
// C++: void cv::filterHomographyDecompByVisibleRefpoints(vector_Mat rotations, vector_Mat normals, Mat beforePoints, Mat afterPoints, Mat& possibleSolutions, Mat pointsMask = Mat())
//
//javadoc: filterHomographyDecompByVisibleRefpoints(rotations, normals, beforePoints, afterPoints, possibleSolutions, pointsMask)
public static void filterHomographyDecompByVisibleRefpoints(List rotations, List normals, Mat beforePoints, Mat afterPoints, Mat possibleSolutions, Mat pointsMask)
{
Mat rotations_mat = Converters.vector_Mat_to_Mat(rotations);
Mat normals_mat = Converters.vector_Mat_to_Mat(normals);
filterHomographyDecompByVisibleRefpoints_0(rotations_mat.nativeObj, normals_mat.nativeObj, beforePoints.nativeObj, afterPoints.nativeObj, possibleSolutions.nativeObj, pointsMask.nativeObj);
return;
}
//javadoc: filterHomographyDecompByVisibleRefpoints(rotations, normals, beforePoints, afterPoints, possibleSolutions)
public static void filterHomographyDecompByVisibleRefpoints(List rotations, List normals, Mat beforePoints, Mat afterPoints, Mat possibleSolutions)
{
Mat rotations_mat = Converters.vector_Mat_to_Mat(rotations);
Mat normals_mat = Converters.vector_Mat_to_Mat(normals);
filterHomographyDecompByVisibleRefpoints_1(rotations_mat.nativeObj, normals_mat.nativeObj, beforePoints.nativeObj, afterPoints.nativeObj, possibleSolutions.nativeObj);
return;
}
//
// C++: void cv::filterSpeckles(Mat& img, double newVal, int maxSpeckleSize, double maxDiff, Mat& buf = Mat())
//
//javadoc: filterSpeckles(img, newVal, maxSpeckleSize, maxDiff, buf)
public static void filterSpeckles(Mat img, double newVal, int maxSpeckleSize, double maxDiff, Mat buf)
{
filterSpeckles_0(img.nativeObj, newVal, maxSpeckleSize, maxDiff, buf.nativeObj);
return;
}
//javadoc: filterSpeckles(img, newVal, maxSpeckleSize, maxDiff)
public static void filterSpeckles(Mat img, double newVal, int maxSpeckleSize, double maxDiff)
{
filterSpeckles_1(img.nativeObj, newVal, maxSpeckleSize, maxDiff);
return;
}
//
// C++: void cv::matMulDeriv(Mat A, Mat B, Mat& dABdA, Mat& dABdB)
//
//javadoc: matMulDeriv(A, B, dABdA, dABdB)
public static void matMulDeriv(Mat A, Mat B, Mat dABdA, Mat dABdB)
{
matMulDeriv_0(A.nativeObj, B.nativeObj, dABdA.nativeObj, dABdB.nativeObj);
return;
}
//
// C++: void cv::projectPoints(vector_Point3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, vector_double distCoeffs, vector_Point2f& imagePoints, Mat& jacobian = Mat(), double aspectRatio = 0)
//
//javadoc: projectPoints(objectPoints, rvec, tvec, cameraMatrix, distCoeffs, imagePoints, jacobian, aspectRatio)
public static void projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints, Mat jacobian, double aspectRatio)
{
Mat objectPoints_mat = objectPoints;
Mat distCoeffs_mat = distCoeffs;
Mat imagePoints_mat = imagePoints;
projectPoints_0(objectPoints_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, imagePoints_mat.nativeObj, jacobian.nativeObj, aspectRatio);
return;
}
//javadoc: projectPoints(objectPoints, rvec, tvec, cameraMatrix, distCoeffs, imagePoints, jacobian)
public static void projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints, Mat jacobian)
{
Mat objectPoints_mat = objectPoints;
Mat distCoeffs_mat = distCoeffs;
Mat imagePoints_mat = imagePoints;
projectPoints_1(objectPoints_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, imagePoints_mat.nativeObj, jacobian.nativeObj);
return;
}
//javadoc: projectPoints(objectPoints, rvec, tvec, cameraMatrix, distCoeffs, imagePoints)
public static void projectPoints(MatOfPoint3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, MatOfDouble distCoeffs, MatOfPoint2f imagePoints)
{
Mat objectPoints_mat = objectPoints;
Mat distCoeffs_mat = distCoeffs;
Mat imagePoints_mat = imagePoints;
projectPoints_2(objectPoints_mat.nativeObj, rvec.nativeObj, tvec.nativeObj, cameraMatrix.nativeObj, distCoeffs_mat.nativeObj, imagePoints_mat.nativeObj);
return;
}
//
// C++: void cv::reprojectImageTo3D(Mat disparity, Mat& _3dImage, Mat Q, bool handleMissingValues = false, int ddepth = -1)
//
//javadoc: reprojectImageTo3D(disparity, _3dImage, Q, handleMissingValues, ddepth)
public static void reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues, int ddepth)
{
reprojectImageTo3D_0(disparity.nativeObj, _3dImage.nativeObj, Q.nativeObj, handleMissingValues, ddepth);
return;
}
//javadoc: reprojectImageTo3D(disparity, _3dImage, Q, handleMissingValues)
public static void reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q, boolean handleMissingValues)
{
reprojectImageTo3D_1(disparity.nativeObj, _3dImage.nativeObj, Q.nativeObj, handleMissingValues);
return;
}
//javadoc: reprojectImageTo3D(disparity, _3dImage, Q)
public static void reprojectImageTo3D(Mat disparity, Mat _3dImage, Mat Q)
{
reprojectImageTo3D_2(disparity.nativeObj, _3dImage.nativeObj, Q.nativeObj);
return;
}
//
// C++: void cv::stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q, int flags = CALIB_ZERO_DISPARITY, double alpha = -1, Size newImageSize = Size(), Rect* validPixROI1 = 0, Rect* validPixROI2 = 0)
//
//javadoc: stereoRectify(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, R1, R2, P1, P2, Q, flags, alpha, newImageSize, validPixROI1, validPixROI2)
public static void stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, double alpha, Size newImageSize, Rect validPixROI1, Rect validPixROI2)
{
double[] validPixROI1_out = new double[4];
double[] validPixROI2_out = new double[4];
stereoRectify_0(cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj, flags, alpha, newImageSize.width, newImageSize.height, validPixROI1_out, validPixROI2_out);
if(validPixROI1!=null){ validPixROI1.x = (int)validPixROI1_out[0]; validPixROI1.y = (int)validPixROI1_out[1]; validPixROI1.width = (int)validPixROI1_out[2]; validPixROI1.height = (int)validPixROI1_out[3]; }
if(validPixROI2!=null){ validPixROI2.x = (int)validPixROI2_out[0]; validPixROI2.y = (int)validPixROI2_out[1]; validPixROI2.width = (int)validPixROI2_out[2]; validPixROI2.height = (int)validPixROI2_out[3]; }
return;
}
//javadoc: stereoRectify(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, R1, R2, P1, P2, Q, flags, alpha, newImageSize, validPixROI1)
public static void stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, double alpha, Size newImageSize, Rect validPixROI1)
{
double[] validPixROI1_out = new double[4];
stereoRectify_1(cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj, flags, alpha, newImageSize.width, newImageSize.height, validPixROI1_out);
if(validPixROI1!=null){ validPixROI1.x = (int)validPixROI1_out[0]; validPixROI1.y = (int)validPixROI1_out[1]; validPixROI1.width = (int)validPixROI1_out[2]; validPixROI1.height = (int)validPixROI1_out[3]; }
return;
}
//javadoc: stereoRectify(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, R1, R2, P1, P2, Q, flags, alpha, newImageSize)
public static void stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, double alpha, Size newImageSize)
{
stereoRectify_2(cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj, flags, alpha, newImageSize.width, newImageSize.height);
return;
}
//javadoc: stereoRectify(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, R1, R2, P1, P2, Q, flags, alpha)
public static void stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, double alpha)
{
stereoRectify_3(cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj, flags, alpha);
return;
}
//javadoc: stereoRectify(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, R1, R2, P1, P2, Q, flags)
public static void stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags)
{
stereoRectify_4(cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj, flags);
return;
}
//javadoc: stereoRectify(cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, R1, R2, P1, P2, Q)
public static void stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q)
{
stereoRectify_5(cameraMatrix1.nativeObj, distCoeffs1.nativeObj, cameraMatrix2.nativeObj, distCoeffs2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, T.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj);
return;
}
//
// C++: void cv::triangulatePoints(Mat projMatr1, Mat projMatr2, Mat projPoints1, Mat projPoints2, Mat& points4D)
//
//javadoc: triangulatePoints(projMatr1, projMatr2, projPoints1, projPoints2, points4D)
public static void triangulatePoints(Mat projMatr1, Mat projMatr2, Mat projPoints1, Mat projPoints2, Mat points4D)
{
triangulatePoints_0(projMatr1.nativeObj, projMatr2.nativeObj, projPoints1.nativeObj, projPoints2.nativeObj, points4D.nativeObj);
return;
}
//
// C++: void cv::validateDisparity(Mat& disparity, Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp = 1)
//
//javadoc: validateDisparity(disparity, cost, minDisparity, numberOfDisparities, disp12MaxDisp)
public static void validateDisparity(Mat disparity, Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp)
{
validateDisparity_0(disparity.nativeObj, cost.nativeObj, minDisparity, numberOfDisparities, disp12MaxDisp);
return;
}
//javadoc: validateDisparity(disparity, cost, minDisparity, numberOfDisparities)
public static void validateDisparity(Mat disparity, Mat cost, int minDisparity, int numberOfDisparities)
{
validateDisparity_1(disparity.nativeObj, cost.nativeObj, minDisparity, numberOfDisparities);
return;
}
//
// C++: void cv::fisheye::distortPoints(Mat undistorted, Mat& distorted, Mat K, Mat D, double alpha = 0)
//
//javadoc: fisheye_distortPoints(undistorted, distorted, K, D, alpha)
public static void fisheye_distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D, double alpha)
{
fisheye_distortPoints_0(undistorted.nativeObj, distorted.nativeObj, K.nativeObj, D.nativeObj, alpha);
return;
}
//javadoc: fisheye_distortPoints(undistorted, distorted, K, D)
public static void fisheye_distortPoints(Mat undistorted, Mat distorted, Mat K, Mat D)
{
fisheye_distortPoints_1(undistorted.nativeObj, distorted.nativeObj, K.nativeObj, D.nativeObj);
return;
}
//
// C++: void cv::fisheye::estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat& P, double balance = 0.0, Size new_size = Size(), double fov_scale = 1.0)
//
//javadoc: fisheye_estimateNewCameraMatrixForUndistortRectify(K, D, image_size, R, P, balance, new_size, fov_scale)
public static void fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P, double balance, Size new_size, double fov_scale)
{
fisheye_estimateNewCameraMatrixForUndistortRectify_0(K.nativeObj, D.nativeObj, image_size.width, image_size.height, R.nativeObj, P.nativeObj, balance, new_size.width, new_size.height, fov_scale);
return;
}
//javadoc: fisheye_estimateNewCameraMatrixForUndistortRectify(K, D, image_size, R, P, balance, new_size)
public static void fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P, double balance, Size new_size)
{
fisheye_estimateNewCameraMatrixForUndistortRectify_1(K.nativeObj, D.nativeObj, image_size.width, image_size.height, R.nativeObj, P.nativeObj, balance, new_size.width, new_size.height);
return;
}
//javadoc: fisheye_estimateNewCameraMatrixForUndistortRectify(K, D, image_size, R, P, balance)
public static void fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P, double balance)
{
fisheye_estimateNewCameraMatrixForUndistortRectify_2(K.nativeObj, D.nativeObj, image_size.width, image_size.height, R.nativeObj, P.nativeObj, balance);
return;
}
//javadoc: fisheye_estimateNewCameraMatrixForUndistortRectify(K, D, image_size, R, P)
public static void fisheye_estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat P)
{
fisheye_estimateNewCameraMatrixForUndistortRectify_3(K.nativeObj, D.nativeObj, image_size.width, image_size.height, R.nativeObj, P.nativeObj);
return;
}
//
// C++: void cv::fisheye::initUndistortRectifyMap(Mat K, Mat D, Mat R, Mat P, Size size, int m1type, Mat& map1, Mat& map2)
//
//javadoc: fisheye_initUndistortRectifyMap(K, D, R, P, size, m1type, map1, map2)
public static void fisheye_initUndistortRectifyMap(Mat K, Mat D, Mat R, Mat P, Size size, int m1type, Mat map1, Mat map2)
{
fisheye_initUndistortRectifyMap_0(K.nativeObj, D.nativeObj, R.nativeObj, P.nativeObj, size.width, size.height, m1type, map1.nativeObj, map2.nativeObj);
return;
}
//
// C++: void cv::fisheye::projectPoints(Mat objectPoints, Mat& imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha = 0, Mat& jacobian = Mat())
//
//javadoc: fisheye_projectPoints(objectPoints, imagePoints, rvec, tvec, K, D, alpha, jacobian)
public static void fisheye_projectPoints(Mat objectPoints, Mat imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha, Mat jacobian)
{
fisheye_projectPoints_0(objectPoints.nativeObj, imagePoints.nativeObj, rvec.nativeObj, tvec.nativeObj, K.nativeObj, D.nativeObj, alpha, jacobian.nativeObj);
return;
}
//javadoc: fisheye_projectPoints(objectPoints, imagePoints, rvec, tvec, K, D, alpha)
public static void fisheye_projectPoints(Mat objectPoints, Mat imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha)
{
fisheye_projectPoints_1(objectPoints.nativeObj, imagePoints.nativeObj, rvec.nativeObj, tvec.nativeObj, K.nativeObj, D.nativeObj, alpha);
return;
}
//javadoc: fisheye_projectPoints(objectPoints, imagePoints, rvec, tvec, K, D)
public static void fisheye_projectPoints(Mat objectPoints, Mat imagePoints, Mat rvec, Mat tvec, Mat K, Mat D)
{
fisheye_projectPoints_2(objectPoints.nativeObj, imagePoints.nativeObj, rvec.nativeObj, tvec.nativeObj, K.nativeObj, D.nativeObj);
return;
}
//
// C++: void cv::fisheye::stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q, int flags, Size newImageSize = Size(), double balance = 0.0, double fov_scale = 1.0)
//
//javadoc: fisheye_stereoRectify(K1, D1, K2, D2, imageSize, R, tvec, R1, R2, P1, P2, Q, flags, newImageSize, balance, fov_scale)
public static void fisheye_stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, Size newImageSize, double balance, double fov_scale)
{
fisheye_stereoRectify_0(K1.nativeObj, D1.nativeObj, K2.nativeObj, D2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, tvec.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj, flags, newImageSize.width, newImageSize.height, balance, fov_scale);
return;
}
//javadoc: fisheye_stereoRectify(K1, D1, K2, D2, imageSize, R, tvec, R1, R2, P1, P2, Q, flags, newImageSize, balance)
public static void fisheye_stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, Size newImageSize, double balance)
{
fisheye_stereoRectify_1(K1.nativeObj, D1.nativeObj, K2.nativeObj, D2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, tvec.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj, flags, newImageSize.width, newImageSize.height, balance);
return;
}
//javadoc: fisheye_stereoRectify(K1, D1, K2, D2, imageSize, R, tvec, R1, R2, P1, P2, Q, flags, newImageSize)
public static void fisheye_stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags, Size newImageSize)
{
fisheye_stereoRectify_2(K1.nativeObj, D1.nativeObj, K2.nativeObj, D2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, tvec.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj, flags, newImageSize.width, newImageSize.height);
return;
}
//javadoc: fisheye_stereoRectify(K1, D1, K2, D2, imageSize, R, tvec, R1, R2, P1, P2, Q, flags)
public static void fisheye_stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat R1, Mat R2, Mat P1, Mat P2, Mat Q, int flags)
{
fisheye_stereoRectify_3(K1.nativeObj, D1.nativeObj, K2.nativeObj, D2.nativeObj, imageSize.width, imageSize.height, R.nativeObj, tvec.nativeObj, R1.nativeObj, R2.nativeObj, P1.nativeObj, P2.nativeObj, Q.nativeObj, flags);
return;
}
//
// C++: void cv::fisheye::undistortImage(Mat distorted, Mat& undistorted, Mat K, Mat D, Mat Knew = cv::Mat(), Size new_size = Size())
//
//javadoc: fisheye_undistortImage(distorted, undistorted, K, D, Knew, new_size)
public static void fisheye_undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D, Mat Knew, Size new_size)
{
fisheye_undistortImage_0(distorted.nativeObj, undistorted.nativeObj, K.nativeObj, D.nativeObj, Knew.nativeObj, new_size.width, new_size.height);
return;
}
//javadoc: fisheye_undistortImage(distorted, undistorted, K, D, Knew)
public static void fisheye_undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D, Mat Knew)
{
fisheye_undistortImage_1(distorted.nativeObj, undistorted.nativeObj, K.nativeObj, D.nativeObj, Knew.nativeObj);
return;
}
//javadoc: fisheye_undistortImage(distorted, undistorted, K, D)
public static void fisheye_undistortImage(Mat distorted, Mat undistorted, Mat K, Mat D)
{
fisheye_undistortImage_2(distorted.nativeObj, undistorted.nativeObj, K.nativeObj, D.nativeObj);
return;
}
//
// C++: void cv::fisheye::undistortPoints(Mat distorted, Mat& undistorted, Mat K, Mat D, Mat R = Mat(), Mat P = Mat())
//
//javadoc: fisheye_undistortPoints(distorted, undistorted, K, D, R, P)
public static void fisheye_undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D, Mat R, Mat P)
{
fisheye_undistortPoints_0(distorted.nativeObj, undistorted.nativeObj, K.nativeObj, D.nativeObj, R.nativeObj, P.nativeObj);
return;
}
//javadoc: fisheye_undistortPoints(distorted, undistorted, K, D, R)
public static void fisheye_undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D, Mat R)
{
fisheye_undistortPoints_1(distorted.nativeObj, undistorted.nativeObj, K.nativeObj, D.nativeObj, R.nativeObj);
return;
}
//javadoc: fisheye_undistortPoints(distorted, undistorted, K, D)
public static void fisheye_undistortPoints(Mat distorted, Mat undistorted, Mat K, Mat D)
{
fisheye_undistortPoints_2(distorted.nativeObj, undistorted.nativeObj, K.nativeObj, D.nativeObj);
return;
}
// C++: Mat cv::estimateAffine2D(Mat from, Mat to, Mat& inliers = Mat(), int method = RANSAC, double ransacReprojThreshold = 3, size_t maxIters = 2000, double confidence = 0.99, size_t refineIters = 10)
private static native long estimateAffine2D_0(long from_nativeObj, long to_nativeObj, long inliers_nativeObj, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters);
private static native long estimateAffine2D_1(long from_nativeObj, long to_nativeObj, long inliers_nativeObj, int method, double ransacReprojThreshold, long maxIters, double confidence);
private static native long estimateAffine2D_2(long from_nativeObj, long to_nativeObj, long inliers_nativeObj, int method, double ransacReprojThreshold, long maxIters);
private static native long estimateAffine2D_3(long from_nativeObj, long to_nativeObj, long inliers_nativeObj, int method, double ransacReprojThreshold);
private static native long estimateAffine2D_4(long from_nativeObj, long to_nativeObj, long inliers_nativeObj, int method);
private static native long estimateAffine2D_5(long from_nativeObj, long to_nativeObj, long inliers_nativeObj);
private static native long estimateAffine2D_6(long from_nativeObj, long to_nativeObj);
// C++: Mat cv::estimateAffinePartial2D(Mat from, Mat to, Mat& inliers = Mat(), int method = RANSAC, double ransacReprojThreshold = 3, size_t maxIters = 2000, double confidence = 0.99, size_t refineIters = 10)
private static native long estimateAffinePartial2D_0(long from_nativeObj, long to_nativeObj, long inliers_nativeObj, int method, double ransacReprojThreshold, long maxIters, double confidence, long refineIters);
private static native long estimateAffinePartial2D_1(long from_nativeObj, long to_nativeObj, long inliers_nativeObj, int method, double ransacReprojThreshold, long maxIters, double confidence);
private static native long estimateAffinePartial2D_2(long from_nativeObj, long to_nativeObj, long inliers_nativeObj, int method, double ransacReprojThreshold, long maxIters);
private static native long estimateAffinePartial2D_3(long from_nativeObj, long to_nativeObj, long inliers_nativeObj, int method, double ransacReprojThreshold);
private static native long estimateAffinePartial2D_4(long from_nativeObj, long to_nativeObj, long inliers_nativeObj, int method);
private static native long estimateAffinePartial2D_5(long from_nativeObj, long to_nativeObj, long inliers_nativeObj);
private static native long estimateAffinePartial2D_6(long from_nativeObj, long to_nativeObj);
// C++: Mat cv::findEssentialMat(Mat points1, Mat points2, Mat cameraMatrix, int method = RANSAC, double prob = 0.999, double threshold = 1.0, Mat& mask = Mat())
private static native long findEssentialMat_0(long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, int method, double prob, double threshold, long mask_nativeObj);
private static native long findEssentialMat_1(long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, int method, double prob, double threshold);
private static native long findEssentialMat_2(long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, int method, double prob);
private static native long findEssentialMat_3(long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, int method);
private static native long findEssentialMat_4(long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj);
// C++: Mat cv::findEssentialMat(Mat points1, Mat points2, double focal = 1.0, Point2d pp = Point2d(0, 0), int method = RANSAC, double prob = 0.999, double threshold = 1.0, Mat& mask = Mat())
private static native long findEssentialMat_5(long points1_nativeObj, long points2_nativeObj, double focal, double pp_x, double pp_y, int method, double prob, double threshold, long mask_nativeObj);
private static native long findEssentialMat_6(long points1_nativeObj, long points2_nativeObj, double focal, double pp_x, double pp_y, int method, double prob, double threshold);
private static native long findEssentialMat_7(long points1_nativeObj, long points2_nativeObj, double focal, double pp_x, double pp_y, int method, double prob);
private static native long findEssentialMat_8(long points1_nativeObj, long points2_nativeObj, double focal, double pp_x, double pp_y, int method);
private static native long findEssentialMat_9(long points1_nativeObj, long points2_nativeObj, double focal, double pp_x, double pp_y);
private static native long findEssentialMat_10(long points1_nativeObj, long points2_nativeObj, double focal);
private static native long findEssentialMat_11(long points1_nativeObj, long points2_nativeObj);
// C++: Mat cv::findFundamentalMat(vector_Point2f points1, vector_Point2f points2, int method = FM_RANSAC, double ransacReprojThreshold = 3., double confidence = 0.99, Mat& mask = Mat())
private static native long findFundamentalMat_0(long points1_mat_nativeObj, long points2_mat_nativeObj, int method, double ransacReprojThreshold, double confidence, long mask_nativeObj);
private static native long findFundamentalMat_1(long points1_mat_nativeObj, long points2_mat_nativeObj, int method, double ransacReprojThreshold, double confidence);
private static native long findFundamentalMat_2(long points1_mat_nativeObj, long points2_mat_nativeObj, int method, double ransacReprojThreshold);
private static native long findFundamentalMat_3(long points1_mat_nativeObj, long points2_mat_nativeObj, int method);
private static native long findFundamentalMat_4(long points1_mat_nativeObj, long points2_mat_nativeObj);
// C++: Mat cv::findHomography(vector_Point2f srcPoints, vector_Point2f dstPoints, int method = 0, double ransacReprojThreshold = 3, Mat& mask = Mat(), int maxIters = 2000, double confidence = 0.995)
private static native long findHomography_0(long srcPoints_mat_nativeObj, long dstPoints_mat_nativeObj, int method, double ransacReprojThreshold, long mask_nativeObj, int maxIters, double confidence);
private static native long findHomography_1(long srcPoints_mat_nativeObj, long dstPoints_mat_nativeObj, int method, double ransacReprojThreshold, long mask_nativeObj, int maxIters);
private static native long findHomography_2(long srcPoints_mat_nativeObj, long dstPoints_mat_nativeObj, int method, double ransacReprojThreshold, long mask_nativeObj);
private static native long findHomography_3(long srcPoints_mat_nativeObj, long dstPoints_mat_nativeObj, int method, double ransacReprojThreshold);
private static native long findHomography_4(long srcPoints_mat_nativeObj, long dstPoints_mat_nativeObj, int method);
private static native long findHomography_5(long srcPoints_mat_nativeObj, long dstPoints_mat_nativeObj);
// C++: Mat cv::getOptimalNewCameraMatrix(Mat cameraMatrix, Mat distCoeffs, Size imageSize, double alpha, Size newImgSize = Size(), Rect* validPixROI = 0, bool centerPrincipalPoint = false)
private static native long getOptimalNewCameraMatrix_0(long cameraMatrix_nativeObj, long distCoeffs_nativeObj, double imageSize_width, double imageSize_height, double alpha, double newImgSize_width, double newImgSize_height, double[] validPixROI_out, boolean centerPrincipalPoint);
private static native long getOptimalNewCameraMatrix_1(long cameraMatrix_nativeObj, long distCoeffs_nativeObj, double imageSize_width, double imageSize_height, double alpha, double newImgSize_width, double newImgSize_height, double[] validPixROI_out);
private static native long getOptimalNewCameraMatrix_2(long cameraMatrix_nativeObj, long distCoeffs_nativeObj, double imageSize_width, double imageSize_height, double alpha, double newImgSize_width, double newImgSize_height);
private static native long getOptimalNewCameraMatrix_3(long cameraMatrix_nativeObj, long distCoeffs_nativeObj, double imageSize_width, double imageSize_height, double alpha);
// C++: Mat cv::initCameraMatrix2D(vector_vector_Point3f objectPoints, vector_vector_Point2f imagePoints, Size imageSize, double aspectRatio = 1.0)
private static native long initCameraMatrix2D_0(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, double aspectRatio);
private static native long initCameraMatrix2D_1(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height);
// C++: Rect cv::getValidDisparityROI(Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize)
private static native double[] getValidDisparityROI_0(int roi1_x, int roi1_y, int roi1_width, int roi1_height, int roi2_x, int roi2_y, int roi2_width, int roi2_height, int minDisparity, int numberOfDisparities, int SADWindowSize);
// C++: Vec3d cv::RQDecomp3x3(Mat src, Mat& mtxR, Mat& mtxQ, Mat& Qx = Mat(), Mat& Qy = Mat(), Mat& Qz = Mat())
private static native double[] RQDecomp3x3_0(long src_nativeObj, long mtxR_nativeObj, long mtxQ_nativeObj, long Qx_nativeObj, long Qy_nativeObj, long Qz_nativeObj);
private static native double[] RQDecomp3x3_1(long src_nativeObj, long mtxR_nativeObj, long mtxQ_nativeObj, long Qx_nativeObj, long Qy_nativeObj);
private static native double[] RQDecomp3x3_2(long src_nativeObj, long mtxR_nativeObj, long mtxQ_nativeObj, long Qx_nativeObj);
private static native double[] RQDecomp3x3_3(long src_nativeObj, long mtxR_nativeObj, long mtxQ_nativeObj);
// C++: bool cv::findChessboardCorners(Mat image, Size patternSize, vector_Point2f& corners, int flags = CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE)
private static native boolean findChessboardCorners_0(long image_nativeObj, double patternSize_width, double patternSize_height, long corners_mat_nativeObj, int flags);
private static native boolean findChessboardCorners_1(long image_nativeObj, double patternSize_width, double patternSize_height, long corners_mat_nativeObj);
// C++: bool cv::findCirclesGrid(Mat image, Size patternSize, Mat& centers, int flags = CALIB_CB_SYMMETRIC_GRID, Ptr_FeatureDetector blobDetector = SimpleBlobDetector::create())
private static native boolean findCirclesGrid_0(long image_nativeObj, double patternSize_width, double patternSize_height, long centers_nativeObj, int flags);
private static native boolean findCirclesGrid_2(long image_nativeObj, double patternSize_width, double patternSize_height, long centers_nativeObj);
// C++: bool cv::solvePnP(vector_Point3f objectPoints, vector_Point2f imagePoints, Mat cameraMatrix, vector_double distCoeffs, Mat& rvec, Mat& tvec, bool useExtrinsicGuess = false, int flags = SOLVEPNP_ITERATIVE)
private static native boolean solvePnP_0(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, boolean useExtrinsicGuess, int flags);
private static native boolean solvePnP_1(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, boolean useExtrinsicGuess);
private static native boolean solvePnP_2(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj);
// C++: bool cv::solvePnPRansac(vector_Point3f objectPoints, vector_Point2f imagePoints, Mat cameraMatrix, vector_double distCoeffs, Mat& rvec, Mat& tvec, bool useExtrinsicGuess = false, int iterationsCount = 100, float reprojectionError = 8.0, double confidence = 0.99, Mat& inliers = Mat(), int flags = SOLVEPNP_ITERATIVE)
private static native boolean solvePnPRansac_0(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, long inliers_nativeObj, int flags);
private static native boolean solvePnPRansac_1(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence, long inliers_nativeObj);
private static native boolean solvePnPRansac_2(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError, double confidence);
private static native boolean solvePnPRansac_3(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, boolean useExtrinsicGuess, int iterationsCount, float reprojectionError);
private static native boolean solvePnPRansac_4(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, boolean useExtrinsicGuess, int iterationsCount);
private static native boolean solvePnPRansac_5(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, boolean useExtrinsicGuess);
private static native boolean solvePnPRansac_6(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj);
// C++: bool cv::stereoRectifyUncalibrated(Mat points1, Mat points2, Mat F, Size imgSize, Mat& H1, Mat& H2, double threshold = 5)
private static native boolean stereoRectifyUncalibrated_0(long points1_nativeObj, long points2_nativeObj, long F_nativeObj, double imgSize_width, double imgSize_height, long H1_nativeObj, long H2_nativeObj, double threshold);
private static native boolean stereoRectifyUncalibrated_1(long points1_nativeObj, long points2_nativeObj, long F_nativeObj, double imgSize_width, double imgSize_height, long H1_nativeObj, long H2_nativeObj);
// C++: double cv::calibrateCamera(vector_Mat objectPoints, vector_Mat imagePoints, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, Mat& stdDeviationsIntrinsics, Mat& stdDeviationsExtrinsics, Mat& perViewErrors, int flags = 0, TermCriteria criteria = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON))
private static native double calibrateCameraExtended_0(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, long stdDeviationsIntrinsics_nativeObj, long stdDeviationsExtrinsics_nativeObj, long perViewErrors_nativeObj, int flags, int criteria_type, int criteria_maxCount, double criteria_epsilon);
private static native double calibrateCameraExtended_1(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, long stdDeviationsIntrinsics_nativeObj, long stdDeviationsExtrinsics_nativeObj, long perViewErrors_nativeObj, int flags);
private static native double calibrateCameraExtended_2(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, long stdDeviationsIntrinsics_nativeObj, long stdDeviationsExtrinsics_nativeObj, long perViewErrors_nativeObj);
// C++: double cv::calibrateCamera(vector_Mat objectPoints, vector_Mat imagePoints, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, int flags = 0, TermCriteria criteria = TermCriteria( TermCriteria::COUNT + TermCriteria::EPS, 30, DBL_EPSILON))
private static native double calibrateCamera_0(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, int flags, int criteria_type, int criteria_maxCount, double criteria_epsilon);
private static native double calibrateCamera_1(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, int flags);
private static native double calibrateCamera_2(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double imageSize_width, double imageSize_height, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj);
// C++: double cv::sampsonDistance(Mat pt1, Mat pt2, Mat F)
private static native double sampsonDistance_0(long pt1_nativeObj, long pt2_nativeObj, long F_nativeObj);
// C++: double cv::stereoCalibrate(vector_Mat objectPoints, vector_Mat imagePoints1, vector_Mat imagePoints2, Mat& cameraMatrix1, Mat& distCoeffs1, Mat& cameraMatrix2, Mat& distCoeffs2, Size imageSize, Mat& R, Mat& T, Mat& E, Mat& F, Mat& perViewErrors, int flags = CALIB_FIX_INTRINSIC, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
private static native double stereoCalibrateExtended_0(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long E_nativeObj, long F_nativeObj, long perViewErrors_nativeObj, int flags, int criteria_type, int criteria_maxCount, double criteria_epsilon);
private static native double stereoCalibrateExtended_1(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long E_nativeObj, long F_nativeObj, long perViewErrors_nativeObj, int flags);
private static native double stereoCalibrateExtended_2(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long E_nativeObj, long F_nativeObj, long perViewErrors_nativeObj);
// C++: double cv::stereoCalibrate(vector_Mat objectPoints, vector_Mat imagePoints1, vector_Mat imagePoints2, Mat& cameraMatrix1, Mat& distCoeffs1, Mat& cameraMatrix2, Mat& distCoeffs2, Size imageSize, Mat& R, Mat& T, Mat& E, Mat& F, int flags = CALIB_FIX_INTRINSIC, TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
private static native double stereoCalibrate_0(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long E_nativeObj, long F_nativeObj, int flags, int criteria_type, int criteria_maxCount, double criteria_epsilon);
private static native double stereoCalibrate_1(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long E_nativeObj, long F_nativeObj, int flags);
private static native double stereoCalibrate_2(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long E_nativeObj, long F_nativeObj);
// C++: double cv::fisheye::calibrate(vector_Mat objectPoints, vector_Mat imagePoints, Size image_size, Mat& K, Mat& D, vector_Mat& rvecs, vector_Mat& tvecs, int flags = 0, TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON))
private static native double fisheye_calibrate_0(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double image_size_width, double image_size_height, long K_nativeObj, long D_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, int flags, int criteria_type, int criteria_maxCount, double criteria_epsilon);
private static native double fisheye_calibrate_1(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double image_size_width, double image_size_height, long K_nativeObj, long D_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, int flags);
private static native double fisheye_calibrate_2(long objectPoints_mat_nativeObj, long imagePoints_mat_nativeObj, double image_size_width, double image_size_height, long K_nativeObj, long D_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj);
// C++: double cv::fisheye::stereoCalibrate(vector_Mat objectPoints, vector_Mat imagePoints1, vector_Mat imagePoints2, Mat& K1, Mat& D1, Mat& K2, Mat& D2, Size imageSize, Mat& R, Mat& T, int flags = fisheye::CALIB_FIX_INTRINSIC, TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON))
private static native double fisheye_stereoCalibrate_0(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long K1_nativeObj, long D1_nativeObj, long K2_nativeObj, long D2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, int flags, int criteria_type, int criteria_maxCount, double criteria_epsilon);
private static native double fisheye_stereoCalibrate_1(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long K1_nativeObj, long D1_nativeObj, long K2_nativeObj, long D2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, int flags);
private static native double fisheye_stereoCalibrate_2(long objectPoints_mat_nativeObj, long imagePoints1_mat_nativeObj, long imagePoints2_mat_nativeObj, long K1_nativeObj, long D1_nativeObj, long K2_nativeObj, long D2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj);
// C++: float cv::rectify3Collinear(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Mat cameraMatrix3, Mat distCoeffs3, vector_Mat imgpt1, vector_Mat imgpt3, Size imageSize, Mat R12, Mat T12, Mat R13, Mat T13, Mat& R1, Mat& R2, Mat& R3, Mat& P1, Mat& P2, Mat& P3, Mat& Q, double alpha, Size newImgSize, Rect* roi1, Rect* roi2, int flags)
private static native float rectify3Collinear_0(long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, long cameraMatrix3_nativeObj, long distCoeffs3_nativeObj, long imgpt1_mat_nativeObj, long imgpt3_mat_nativeObj, double imageSize_width, double imageSize_height, long R12_nativeObj, long T12_nativeObj, long R13_nativeObj, long T13_nativeObj, long R1_nativeObj, long R2_nativeObj, long R3_nativeObj, long P1_nativeObj, long P2_nativeObj, long P3_nativeObj, long Q_nativeObj, double alpha, double newImgSize_width, double newImgSize_height, double[] roi1_out, double[] roi2_out, int flags);
// C++: int cv::decomposeHomographyMat(Mat H, Mat K, vector_Mat& rotations, vector_Mat& translations, vector_Mat& normals)
private static native int decomposeHomographyMat_0(long H_nativeObj, long K_nativeObj, long rotations_mat_nativeObj, long translations_mat_nativeObj, long normals_mat_nativeObj);
// C++: int cv::estimateAffine3D(Mat src, Mat dst, Mat& out, Mat& inliers, double ransacThreshold = 3, double confidence = 0.99)
private static native int estimateAffine3D_0(long src_nativeObj, long dst_nativeObj, long out_nativeObj, long inliers_nativeObj, double ransacThreshold, double confidence);
private static native int estimateAffine3D_1(long src_nativeObj, long dst_nativeObj, long out_nativeObj, long inliers_nativeObj, double ransacThreshold);
private static native int estimateAffine3D_2(long src_nativeObj, long dst_nativeObj, long out_nativeObj, long inliers_nativeObj);
// C++: int cv::recoverPose(Mat E, Mat points1, Mat points2, Mat& R, Mat& t, double focal = 1.0, Point2d pp = Point2d(0, 0), Mat& mask = Mat())
private static native int recoverPose_0(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long R_nativeObj, long t_nativeObj, double focal, double pp_x, double pp_y, long mask_nativeObj);
private static native int recoverPose_1(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long R_nativeObj, long t_nativeObj, double focal, double pp_x, double pp_y);
private static native int recoverPose_2(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long R_nativeObj, long t_nativeObj, double focal);
private static native int recoverPose_3(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long R_nativeObj, long t_nativeObj);
// C++: int cv::recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat& R, Mat& t, Mat& mask = Mat())
private static native int recoverPose_4(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, long R_nativeObj, long t_nativeObj, long mask_nativeObj);
private static native int recoverPose_5(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, long R_nativeObj, long t_nativeObj);
// C++: int cv::recoverPose(Mat E, Mat points1, Mat points2, Mat cameraMatrix, Mat& R, Mat& t, double distanceThresh, Mat& mask = Mat(), Mat& triangulatedPoints = Mat())
private static native int recoverPose_6(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, long R_nativeObj, long t_nativeObj, double distanceThresh, long mask_nativeObj, long triangulatedPoints_nativeObj);
private static native int recoverPose_7(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, long R_nativeObj, long t_nativeObj, double distanceThresh, long mask_nativeObj);
private static native int recoverPose_8(long E_nativeObj, long points1_nativeObj, long points2_nativeObj, long cameraMatrix_nativeObj, long R_nativeObj, long t_nativeObj, double distanceThresh);
// C++: int cv::solveP3P(Mat objectPoints, Mat imagePoints, Mat cameraMatrix, Mat distCoeffs, vector_Mat& rvecs, vector_Mat& tvecs, int flags)
private static native int solveP3P_0(long objectPoints_nativeObj, long imagePoints_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvecs_mat_nativeObj, long tvecs_mat_nativeObj, int flags);
// C++: void cv::Rodrigues(Mat src, Mat& dst, Mat& jacobian = Mat())
private static native void Rodrigues_0(long src_nativeObj, long dst_nativeObj, long jacobian_nativeObj);
private static native void Rodrigues_1(long src_nativeObj, long dst_nativeObj);
// C++: void cv::calibrateHandEye(vector_Mat R_gripper2base, vector_Mat t_gripper2base, vector_Mat R_target2cam, vector_Mat t_target2cam, Mat& R_cam2gripper, Mat& t_cam2gripper, HandEyeCalibrationMethod method = CALIB_HAND_EYE_TSAI)
private static native void calibrateHandEye_0(long R_gripper2base_mat_nativeObj, long t_gripper2base_mat_nativeObj, long R_target2cam_mat_nativeObj, long t_target2cam_mat_nativeObj, long R_cam2gripper_nativeObj, long t_cam2gripper_nativeObj, int method);
private static native void calibrateHandEye_1(long R_gripper2base_mat_nativeObj, long t_gripper2base_mat_nativeObj, long R_target2cam_mat_nativeObj, long t_target2cam_mat_nativeObj, long R_cam2gripper_nativeObj, long t_cam2gripper_nativeObj);
// C++: void cv::calibrationMatrixValues(Mat cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double& fovx, double& fovy, double& focalLength, Point2d& principalPoint, double& aspectRatio)
private static native void calibrationMatrixValues_0(long cameraMatrix_nativeObj, double imageSize_width, double imageSize_height, double apertureWidth, double apertureHeight, double[] fovx_out, double[] fovy_out, double[] focalLength_out, double[] principalPoint_out, double[] aspectRatio_out);
// C++: void cv::composeRT(Mat rvec1, Mat tvec1, Mat rvec2, Mat tvec2, Mat& rvec3, Mat& tvec3, Mat& dr3dr1 = Mat(), Mat& dr3dt1 = Mat(), Mat& dr3dr2 = Mat(), Mat& dr3dt2 = Mat(), Mat& dt3dr1 = Mat(), Mat& dt3dt1 = Mat(), Mat& dt3dr2 = Mat(), Mat& dt3dt2 = Mat())
private static native void composeRT_0(long rvec1_nativeObj, long tvec1_nativeObj, long rvec2_nativeObj, long tvec2_nativeObj, long rvec3_nativeObj, long tvec3_nativeObj, long dr3dr1_nativeObj, long dr3dt1_nativeObj, long dr3dr2_nativeObj, long dr3dt2_nativeObj, long dt3dr1_nativeObj, long dt3dt1_nativeObj, long dt3dr2_nativeObj, long dt3dt2_nativeObj);
private static native void composeRT_1(long rvec1_nativeObj, long tvec1_nativeObj, long rvec2_nativeObj, long tvec2_nativeObj, long rvec3_nativeObj, long tvec3_nativeObj, long dr3dr1_nativeObj, long dr3dt1_nativeObj, long dr3dr2_nativeObj, long dr3dt2_nativeObj, long dt3dr1_nativeObj, long dt3dt1_nativeObj, long dt3dr2_nativeObj);
private static native void composeRT_2(long rvec1_nativeObj, long tvec1_nativeObj, long rvec2_nativeObj, long tvec2_nativeObj, long rvec3_nativeObj, long tvec3_nativeObj, long dr3dr1_nativeObj, long dr3dt1_nativeObj, long dr3dr2_nativeObj, long dr3dt2_nativeObj, long dt3dr1_nativeObj, long dt3dt1_nativeObj);
private static native void composeRT_3(long rvec1_nativeObj, long tvec1_nativeObj, long rvec2_nativeObj, long tvec2_nativeObj, long rvec3_nativeObj, long tvec3_nativeObj, long dr3dr1_nativeObj, long dr3dt1_nativeObj, long dr3dr2_nativeObj, long dr3dt2_nativeObj, long dt3dr1_nativeObj);
private static native void composeRT_4(long rvec1_nativeObj, long tvec1_nativeObj, long rvec2_nativeObj, long tvec2_nativeObj, long rvec3_nativeObj, long tvec3_nativeObj, long dr3dr1_nativeObj, long dr3dt1_nativeObj, long dr3dr2_nativeObj, long dr3dt2_nativeObj);
private static native void composeRT_5(long rvec1_nativeObj, long tvec1_nativeObj, long rvec2_nativeObj, long tvec2_nativeObj, long rvec3_nativeObj, long tvec3_nativeObj, long dr3dr1_nativeObj, long dr3dt1_nativeObj, long dr3dr2_nativeObj);
private static native void composeRT_6(long rvec1_nativeObj, long tvec1_nativeObj, long rvec2_nativeObj, long tvec2_nativeObj, long rvec3_nativeObj, long tvec3_nativeObj, long dr3dr1_nativeObj, long dr3dt1_nativeObj);
private static native void composeRT_7(long rvec1_nativeObj, long tvec1_nativeObj, long rvec2_nativeObj, long tvec2_nativeObj, long rvec3_nativeObj, long tvec3_nativeObj, long dr3dr1_nativeObj);
private static native void composeRT_8(long rvec1_nativeObj, long tvec1_nativeObj, long rvec2_nativeObj, long tvec2_nativeObj, long rvec3_nativeObj, long tvec3_nativeObj);
// C++: void cv::computeCorrespondEpilines(Mat points, int whichImage, Mat F, Mat& lines)
private static native void computeCorrespondEpilines_0(long points_nativeObj, int whichImage, long F_nativeObj, long lines_nativeObj);
// C++: void cv::convertPointsFromHomogeneous(Mat src, Mat& dst)
private static native void convertPointsFromHomogeneous_0(long src_nativeObj, long dst_nativeObj);
// C++: void cv::convertPointsToHomogeneous(Mat src, Mat& dst)
private static native void convertPointsToHomogeneous_0(long src_nativeObj, long dst_nativeObj);
// C++: void cv::correctMatches(Mat F, Mat points1, Mat points2, Mat& newPoints1, Mat& newPoints2)
private static native void correctMatches_0(long F_nativeObj, long points1_nativeObj, long points2_nativeObj, long newPoints1_nativeObj, long newPoints2_nativeObj);
// C++: void cv::decomposeEssentialMat(Mat E, Mat& R1, Mat& R2, Mat& t)
private static native void decomposeEssentialMat_0(long E_nativeObj, long R1_nativeObj, long R2_nativeObj, long t_nativeObj);
// C++: void cv::decomposeProjectionMatrix(Mat projMatrix, Mat& cameraMatrix, Mat& rotMatrix, Mat& transVect, Mat& rotMatrixX = Mat(), Mat& rotMatrixY = Mat(), Mat& rotMatrixZ = Mat(), Mat& eulerAngles = Mat())
private static native void decomposeProjectionMatrix_0(long projMatrix_nativeObj, long cameraMatrix_nativeObj, long rotMatrix_nativeObj, long transVect_nativeObj, long rotMatrixX_nativeObj, long rotMatrixY_nativeObj, long rotMatrixZ_nativeObj, long eulerAngles_nativeObj);
private static native void decomposeProjectionMatrix_1(long projMatrix_nativeObj, long cameraMatrix_nativeObj, long rotMatrix_nativeObj, long transVect_nativeObj, long rotMatrixX_nativeObj, long rotMatrixY_nativeObj, long rotMatrixZ_nativeObj);
private static native void decomposeProjectionMatrix_2(long projMatrix_nativeObj, long cameraMatrix_nativeObj, long rotMatrix_nativeObj, long transVect_nativeObj, long rotMatrixX_nativeObj, long rotMatrixY_nativeObj);
private static native void decomposeProjectionMatrix_3(long projMatrix_nativeObj, long cameraMatrix_nativeObj, long rotMatrix_nativeObj, long transVect_nativeObj, long rotMatrixX_nativeObj);
private static native void decomposeProjectionMatrix_4(long projMatrix_nativeObj, long cameraMatrix_nativeObj, long rotMatrix_nativeObj, long transVect_nativeObj);
// C++: void cv::drawChessboardCorners(Mat& image, Size patternSize, vector_Point2f corners, bool patternWasFound)
private static native void drawChessboardCorners_0(long image_nativeObj, double patternSize_width, double patternSize_height, long corners_mat_nativeObj, boolean patternWasFound);
// C++: void cv::drawFrameAxes(Mat& image, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec, float length, int thickness = 3)
private static native void drawFrameAxes_0(long image_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvec_nativeObj, long tvec_nativeObj, float length, int thickness);
private static native void drawFrameAxes_1(long image_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_nativeObj, long rvec_nativeObj, long tvec_nativeObj, float length);
// C++: void cv::filterHomographyDecompByVisibleRefpoints(vector_Mat rotations, vector_Mat normals, Mat beforePoints, Mat afterPoints, Mat& possibleSolutions, Mat pointsMask = Mat())
private static native void filterHomographyDecompByVisibleRefpoints_0(long rotations_mat_nativeObj, long normals_mat_nativeObj, long beforePoints_nativeObj, long afterPoints_nativeObj, long possibleSolutions_nativeObj, long pointsMask_nativeObj);
private static native void filterHomographyDecompByVisibleRefpoints_1(long rotations_mat_nativeObj, long normals_mat_nativeObj, long beforePoints_nativeObj, long afterPoints_nativeObj, long possibleSolutions_nativeObj);
// C++: void cv::filterSpeckles(Mat& img, double newVal, int maxSpeckleSize, double maxDiff, Mat& buf = Mat())
private static native void filterSpeckles_0(long img_nativeObj, double newVal, int maxSpeckleSize, double maxDiff, long buf_nativeObj);
private static native void filterSpeckles_1(long img_nativeObj, double newVal, int maxSpeckleSize, double maxDiff);
// C++: void cv::matMulDeriv(Mat A, Mat B, Mat& dABdA, Mat& dABdB)
private static native void matMulDeriv_0(long A_nativeObj, long B_nativeObj, long dABdA_nativeObj, long dABdB_nativeObj);
// C++: void cv::projectPoints(vector_Point3f objectPoints, Mat rvec, Mat tvec, Mat cameraMatrix, vector_double distCoeffs, vector_Point2f& imagePoints, Mat& jacobian = Mat(), double aspectRatio = 0)
private static native void projectPoints_0(long objectPoints_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long imagePoints_mat_nativeObj, long jacobian_nativeObj, double aspectRatio);
private static native void projectPoints_1(long objectPoints_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long imagePoints_mat_nativeObj, long jacobian_nativeObj);
private static native void projectPoints_2(long objectPoints_mat_nativeObj, long rvec_nativeObj, long tvec_nativeObj, long cameraMatrix_nativeObj, long distCoeffs_mat_nativeObj, long imagePoints_mat_nativeObj);
// C++: void cv::reprojectImageTo3D(Mat disparity, Mat& _3dImage, Mat Q, bool handleMissingValues = false, int ddepth = -1)
private static native void reprojectImageTo3D_0(long disparity_nativeObj, long _3dImage_nativeObj, long Q_nativeObj, boolean handleMissingValues, int ddepth);
private static native void reprojectImageTo3D_1(long disparity_nativeObj, long _3dImage_nativeObj, long Q_nativeObj, boolean handleMissingValues);
private static native void reprojectImageTo3D_2(long disparity_nativeObj, long _3dImage_nativeObj, long Q_nativeObj);
// C++: void cv::stereoRectify(Mat cameraMatrix1, Mat distCoeffs1, Mat cameraMatrix2, Mat distCoeffs2, Size imageSize, Mat R, Mat T, Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q, int flags = CALIB_ZERO_DISPARITY, double alpha = -1, Size newImageSize = Size(), Rect* validPixROI1 = 0, Rect* validPixROI2 = 0)
private static native void stereoRectify_0(long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj, int flags, double alpha, double newImageSize_width, double newImageSize_height, double[] validPixROI1_out, double[] validPixROI2_out);
private static native void stereoRectify_1(long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj, int flags, double alpha, double newImageSize_width, double newImageSize_height, double[] validPixROI1_out);
private static native void stereoRectify_2(long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj, int flags, double alpha, double newImageSize_width, double newImageSize_height);
private static native void stereoRectify_3(long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj, int flags, double alpha);
private static native void stereoRectify_4(long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj, int flags);
private static native void stereoRectify_5(long cameraMatrix1_nativeObj, long distCoeffs1_nativeObj, long cameraMatrix2_nativeObj, long distCoeffs2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long T_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj);
// C++: void cv::triangulatePoints(Mat projMatr1, Mat projMatr2, Mat projPoints1, Mat projPoints2, Mat& points4D)
private static native void triangulatePoints_0(long projMatr1_nativeObj, long projMatr2_nativeObj, long projPoints1_nativeObj, long projPoints2_nativeObj, long points4D_nativeObj);
// C++: void cv::validateDisparity(Mat& disparity, Mat cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp = 1)
private static native void validateDisparity_0(long disparity_nativeObj, long cost_nativeObj, int minDisparity, int numberOfDisparities, int disp12MaxDisp);
private static native void validateDisparity_1(long disparity_nativeObj, long cost_nativeObj, int minDisparity, int numberOfDisparities);
// C++: void cv::fisheye::distortPoints(Mat undistorted, Mat& distorted, Mat K, Mat D, double alpha = 0)
private static native void fisheye_distortPoints_0(long undistorted_nativeObj, long distorted_nativeObj, long K_nativeObj, long D_nativeObj, double alpha);
private static native void fisheye_distortPoints_1(long undistorted_nativeObj, long distorted_nativeObj, long K_nativeObj, long D_nativeObj);
// C++: void cv::fisheye::estimateNewCameraMatrixForUndistortRectify(Mat K, Mat D, Size image_size, Mat R, Mat& P, double balance = 0.0, Size new_size = Size(), double fov_scale = 1.0)
private static native void fisheye_estimateNewCameraMatrixForUndistortRectify_0(long K_nativeObj, long D_nativeObj, double image_size_width, double image_size_height, long R_nativeObj, long P_nativeObj, double balance, double new_size_width, double new_size_height, double fov_scale);
private static native void fisheye_estimateNewCameraMatrixForUndistortRectify_1(long K_nativeObj, long D_nativeObj, double image_size_width, double image_size_height, long R_nativeObj, long P_nativeObj, double balance, double new_size_width, double new_size_height);
private static native void fisheye_estimateNewCameraMatrixForUndistortRectify_2(long K_nativeObj, long D_nativeObj, double image_size_width, double image_size_height, long R_nativeObj, long P_nativeObj, double balance);
private static native void fisheye_estimateNewCameraMatrixForUndistortRectify_3(long K_nativeObj, long D_nativeObj, double image_size_width, double image_size_height, long R_nativeObj, long P_nativeObj);
// C++: void cv::fisheye::initUndistortRectifyMap(Mat K, Mat D, Mat R, Mat P, Size size, int m1type, Mat& map1, Mat& map2)
private static native void fisheye_initUndistortRectifyMap_0(long K_nativeObj, long D_nativeObj, long R_nativeObj, long P_nativeObj, double size_width, double size_height, int m1type, long map1_nativeObj, long map2_nativeObj);
// C++: void cv::fisheye::projectPoints(Mat objectPoints, Mat& imagePoints, Mat rvec, Mat tvec, Mat K, Mat D, double alpha = 0, Mat& jacobian = Mat())
private static native void fisheye_projectPoints_0(long objectPoints_nativeObj, long imagePoints_nativeObj, long rvec_nativeObj, long tvec_nativeObj, long K_nativeObj, long D_nativeObj, double alpha, long jacobian_nativeObj);
private static native void fisheye_projectPoints_1(long objectPoints_nativeObj, long imagePoints_nativeObj, long rvec_nativeObj, long tvec_nativeObj, long K_nativeObj, long D_nativeObj, double alpha);
private static native void fisheye_projectPoints_2(long objectPoints_nativeObj, long imagePoints_nativeObj, long rvec_nativeObj, long tvec_nativeObj, long K_nativeObj, long D_nativeObj);
// C++: void cv::fisheye::stereoRectify(Mat K1, Mat D1, Mat K2, Mat D2, Size imageSize, Mat R, Mat tvec, Mat& R1, Mat& R2, Mat& P1, Mat& P2, Mat& Q, int flags, Size newImageSize = Size(), double balance = 0.0, double fov_scale = 1.0)
private static native void fisheye_stereoRectify_0(long K1_nativeObj, long D1_nativeObj, long K2_nativeObj, long D2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long tvec_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj, int flags, double newImageSize_width, double newImageSize_height, double balance, double fov_scale);
private static native void fisheye_stereoRectify_1(long K1_nativeObj, long D1_nativeObj, long K2_nativeObj, long D2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long tvec_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj, int flags, double newImageSize_width, double newImageSize_height, double balance);
private static native void fisheye_stereoRectify_2(long K1_nativeObj, long D1_nativeObj, long K2_nativeObj, long D2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long tvec_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj, int flags, double newImageSize_width, double newImageSize_height);
private static native void fisheye_stereoRectify_3(long K1_nativeObj, long D1_nativeObj, long K2_nativeObj, long D2_nativeObj, double imageSize_width, double imageSize_height, long R_nativeObj, long tvec_nativeObj, long R1_nativeObj, long R2_nativeObj, long P1_nativeObj, long P2_nativeObj, long Q_nativeObj, int flags);
// C++: void cv::fisheye::undistortImage(Mat distorted, Mat& undistorted, Mat K, Mat D, Mat Knew = cv::Mat(), Size new_size = Size())
private static native void fisheye_undistortImage_0(long distorted_nativeObj, long undistorted_nativeObj, long K_nativeObj, long D_nativeObj, long Knew_nativeObj, double new_size_width, double new_size_height);
private static native void fisheye_undistortImage_1(long distorted_nativeObj, long undistorted_nativeObj, long K_nativeObj, long D_nativeObj, long Knew_nativeObj);
private static native void fisheye_undistortImage_2(long distorted_nativeObj, long undistorted_nativeObj, long K_nativeObj, long D_nativeObj);
// C++: void cv::fisheye::undistortPoints(Mat distorted, Mat& undistorted, Mat K, Mat D, Mat R = Mat(), Mat P = Mat())
private static native void fisheye_undistortPoints_0(long distorted_nativeObj, long undistorted_nativeObj, long K_nativeObj, long D_nativeObj, long R_nativeObj, long P_nativeObj);
private static native void fisheye_undistortPoints_1(long distorted_nativeObj, long undistorted_nativeObj, long K_nativeObj, long D_nativeObj, long R_nativeObj);
private static native void fisheye_undistortPoints_2(long distorted_nativeObj, long undistorted_nativeObj, long K_nativeObj, long D_nativeObj);
}
================================================
FILE: openCV/src/main/java/org/opencv/calib3d/StereoBM.java
================================================
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.calib3d;
import org.opencv.calib3d.StereoBM;
import org.opencv.calib3d.StereoMatcher;
import org.opencv.core.Rect;
// C++: class StereoBM
//javadoc: StereoBM
public class StereoBM extends StereoMatcher {
protected StereoBM(long addr) { super(addr); }
// internal usage only
public static StereoBM __fromPtr__(long addr) { return new StereoBM(addr); }
// C++: enum
public static final int
PREFILTER_NORMALIZED_RESPONSE = 0,
PREFILTER_XSOBEL = 1;
//
// C++: static Ptr_StereoBM cv::StereoBM::create(int numDisparities = 0, int blockSize = 21)
//
//javadoc: StereoBM::create(numDisparities, blockSize)
public static StereoBM create(int numDisparities, int blockSize)
{
StereoBM retVal = StereoBM.__fromPtr__(create_0(numDisparities, blockSize));
return retVal;
}
//javadoc: StereoBM::create(numDisparities)
public static StereoBM create(int numDisparities)
{
StereoBM retVal = StereoBM.__fromPtr__(create_1(numDisparities));
return retVal;
}
//javadoc: StereoBM::create()
public static StereoBM create()
{
StereoBM retVal = StereoBM.__fromPtr__(create_2());
return retVal;
}
//
// C++: Rect cv::StereoBM::getROI1()
//
//javadoc: StereoBM::getROI1()
public Rect getROI1()
{
Rect retVal = new Rect(getROI1_0(nativeObj));
return retVal;
}
//
// C++: Rect cv::StereoBM::getROI2()
//
//javadoc: StereoBM::getROI2()
public Rect getROI2()
{
Rect retVal = new Rect(getROI2_0(nativeObj));
return retVal;
}
//
// C++: int cv::StereoBM::getPreFilterCap()
//
//javadoc: StereoBM::getPreFilterCap()
public int getPreFilterCap()
{
int retVal = getPreFilterCap_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoBM::getPreFilterSize()
//
//javadoc: StereoBM::getPreFilterSize()
public int getPreFilterSize()
{
int retVal = getPreFilterSize_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoBM::getPreFilterType()
//
//javadoc: StereoBM::getPreFilterType()
public int getPreFilterType()
{
int retVal = getPreFilterType_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoBM::getSmallerBlockSize()
//
//javadoc: StereoBM::getSmallerBlockSize()
public int getSmallerBlockSize()
{
int retVal = getSmallerBlockSize_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoBM::getTextureThreshold()
//
//javadoc: StereoBM::getTextureThreshold()
public int getTextureThreshold()
{
int retVal = getTextureThreshold_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoBM::getUniquenessRatio()
//
//javadoc: StereoBM::getUniquenessRatio()
public int getUniquenessRatio()
{
int retVal = getUniquenessRatio_0(nativeObj);
return retVal;
}
//
// C++: void cv::StereoBM::setPreFilterCap(int preFilterCap)
//
//javadoc: StereoBM::setPreFilterCap(preFilterCap)
public void setPreFilterCap(int preFilterCap)
{
setPreFilterCap_0(nativeObj, preFilterCap);
return;
}
//
// C++: void cv::StereoBM::setPreFilterSize(int preFilterSize)
//
//javadoc: StereoBM::setPreFilterSize(preFilterSize)
public void setPreFilterSize(int preFilterSize)
{
setPreFilterSize_0(nativeObj, preFilterSize);
return;
}
//
// C++: void cv::StereoBM::setPreFilterType(int preFilterType)
//
//javadoc: StereoBM::setPreFilterType(preFilterType)
public void setPreFilterType(int preFilterType)
{
setPreFilterType_0(nativeObj, preFilterType);
return;
}
//
// C++: void cv::StereoBM::setROI1(Rect roi1)
//
//javadoc: StereoBM::setROI1(roi1)
public void setROI1(Rect roi1)
{
setROI1_0(nativeObj, roi1.x, roi1.y, roi1.width, roi1.height);
return;
}
//
// C++: void cv::StereoBM::setROI2(Rect roi2)
//
//javadoc: StereoBM::setROI2(roi2)
public void setROI2(Rect roi2)
{
setROI2_0(nativeObj, roi2.x, roi2.y, roi2.width, roi2.height);
return;
}
//
// C++: void cv::StereoBM::setSmallerBlockSize(int blockSize)
//
//javadoc: StereoBM::setSmallerBlockSize(blockSize)
public void setSmallerBlockSize(int blockSize)
{
setSmallerBlockSize_0(nativeObj, blockSize);
return;
}
//
// C++: void cv::StereoBM::setTextureThreshold(int textureThreshold)
//
//javadoc: StereoBM::setTextureThreshold(textureThreshold)
public void setTextureThreshold(int textureThreshold)
{
setTextureThreshold_0(nativeObj, textureThreshold);
return;
}
//
// C++: void cv::StereoBM::setUniquenessRatio(int uniquenessRatio)
//
//javadoc: StereoBM::setUniquenessRatio(uniquenessRatio)
public void setUniquenessRatio(int uniquenessRatio)
{
setUniquenessRatio_0(nativeObj, uniquenessRatio);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: static Ptr_StereoBM cv::StereoBM::create(int numDisparities = 0, int blockSize = 21)
private static native long create_0(int numDisparities, int blockSize);
private static native long create_1(int numDisparities);
private static native long create_2();
// C++: Rect cv::StereoBM::getROI1()
private static native double[] getROI1_0(long nativeObj);
// C++: Rect cv::StereoBM::getROI2()
private static native double[] getROI2_0(long nativeObj);
// C++: int cv::StereoBM::getPreFilterCap()
private static native int getPreFilterCap_0(long nativeObj);
// C++: int cv::StereoBM::getPreFilterSize()
private static native int getPreFilterSize_0(long nativeObj);
// C++: int cv::StereoBM::getPreFilterType()
private static native int getPreFilterType_0(long nativeObj);
// C++: int cv::StereoBM::getSmallerBlockSize()
private static native int getSmallerBlockSize_0(long nativeObj);
// C++: int cv::StereoBM::getTextureThreshold()
private static native int getTextureThreshold_0(long nativeObj);
// C++: int cv::StereoBM::getUniquenessRatio()
private static native int getUniquenessRatio_0(long nativeObj);
// C++: void cv::StereoBM::setPreFilterCap(int preFilterCap)
private static native void setPreFilterCap_0(long nativeObj, int preFilterCap);
// C++: void cv::StereoBM::setPreFilterSize(int preFilterSize)
private static native void setPreFilterSize_0(long nativeObj, int preFilterSize);
// C++: void cv::StereoBM::setPreFilterType(int preFilterType)
private static native void setPreFilterType_0(long nativeObj, int preFilterType);
// C++: void cv::StereoBM::setROI1(Rect roi1)
private static native void setROI1_0(long nativeObj, int roi1_x, int roi1_y, int roi1_width, int roi1_height);
// C++: void cv::StereoBM::setROI2(Rect roi2)
private static native void setROI2_0(long nativeObj, int roi2_x, int roi2_y, int roi2_width, int roi2_height);
// C++: void cv::StereoBM::setSmallerBlockSize(int blockSize)
private static native void setSmallerBlockSize_0(long nativeObj, int blockSize);
// C++: void cv::StereoBM::setTextureThreshold(int textureThreshold)
private static native void setTextureThreshold_0(long nativeObj, int textureThreshold);
// C++: void cv::StereoBM::setUniquenessRatio(int uniquenessRatio)
private static native void setUniquenessRatio_0(long nativeObj, int uniquenessRatio);
// native support for java finalize()
private static native void delete(long nativeObj);
}
================================================
FILE: openCV/src/main/java/org/opencv/calib3d/StereoMatcher.java
================================================
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.calib3d;
import org.opencv.core.Algorithm;
import org.opencv.core.Mat;
// C++: class StereoMatcher
//javadoc: StereoMatcher
public class StereoMatcher extends Algorithm {
protected StereoMatcher(long addr) { super(addr); }
// internal usage only
public static StereoMatcher __fromPtr__(long addr) { return new StereoMatcher(addr); }
// C++: enum
public static final int
DISP_SHIFT = 4,
DISP_SCALE = (1 << DISP_SHIFT);
//
// C++: int cv::StereoMatcher::getBlockSize()
//
//javadoc: StereoMatcher::getBlockSize()
public int getBlockSize()
{
int retVal = getBlockSize_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoMatcher::getDisp12MaxDiff()
//
//javadoc: StereoMatcher::getDisp12MaxDiff()
public int getDisp12MaxDiff()
{
int retVal = getDisp12MaxDiff_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoMatcher::getMinDisparity()
//
//javadoc: StereoMatcher::getMinDisparity()
public int getMinDisparity()
{
int retVal = getMinDisparity_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoMatcher::getNumDisparities()
//
//javadoc: StereoMatcher::getNumDisparities()
public int getNumDisparities()
{
int retVal = getNumDisparities_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoMatcher::getSpeckleRange()
//
//javadoc: StereoMatcher::getSpeckleRange()
public int getSpeckleRange()
{
int retVal = getSpeckleRange_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoMatcher::getSpeckleWindowSize()
//
//javadoc: StereoMatcher::getSpeckleWindowSize()
public int getSpeckleWindowSize()
{
int retVal = getSpeckleWindowSize_0(nativeObj);
return retVal;
}
//
// C++: void cv::StereoMatcher::compute(Mat left, Mat right, Mat& disparity)
//
//javadoc: StereoMatcher::compute(left, right, disparity)
public void compute(Mat left, Mat right, Mat disparity)
{
compute_0(nativeObj, left.nativeObj, right.nativeObj, disparity.nativeObj);
return;
}
//
// C++: void cv::StereoMatcher::setBlockSize(int blockSize)
//
//javadoc: StereoMatcher::setBlockSize(blockSize)
public void setBlockSize(int blockSize)
{
setBlockSize_0(nativeObj, blockSize);
return;
}
//
// C++: void cv::StereoMatcher::setDisp12MaxDiff(int disp12MaxDiff)
//
//javadoc: StereoMatcher::setDisp12MaxDiff(disp12MaxDiff)
public void setDisp12MaxDiff(int disp12MaxDiff)
{
setDisp12MaxDiff_0(nativeObj, disp12MaxDiff);
return;
}
//
// C++: void cv::StereoMatcher::setMinDisparity(int minDisparity)
//
//javadoc: StereoMatcher::setMinDisparity(minDisparity)
public void setMinDisparity(int minDisparity)
{
setMinDisparity_0(nativeObj, minDisparity);
return;
}
//
// C++: void cv::StereoMatcher::setNumDisparities(int numDisparities)
//
//javadoc: StereoMatcher::setNumDisparities(numDisparities)
public void setNumDisparities(int numDisparities)
{
setNumDisparities_0(nativeObj, numDisparities);
return;
}
//
// C++: void cv::StereoMatcher::setSpeckleRange(int speckleRange)
//
//javadoc: StereoMatcher::setSpeckleRange(speckleRange)
public void setSpeckleRange(int speckleRange)
{
setSpeckleRange_0(nativeObj, speckleRange);
return;
}
//
// C++: void cv::StereoMatcher::setSpeckleWindowSize(int speckleWindowSize)
//
//javadoc: StereoMatcher::setSpeckleWindowSize(speckleWindowSize)
public void setSpeckleWindowSize(int speckleWindowSize)
{
setSpeckleWindowSize_0(nativeObj, speckleWindowSize);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: int cv::StereoMatcher::getBlockSize()
private static native int getBlockSize_0(long nativeObj);
// C++: int cv::StereoMatcher::getDisp12MaxDiff()
private static native int getDisp12MaxDiff_0(long nativeObj);
// C++: int cv::StereoMatcher::getMinDisparity()
private static native int getMinDisparity_0(long nativeObj);
// C++: int cv::StereoMatcher::getNumDisparities()
private static native int getNumDisparities_0(long nativeObj);
// C++: int cv::StereoMatcher::getSpeckleRange()
private static native int getSpeckleRange_0(long nativeObj);
// C++: int cv::StereoMatcher::getSpeckleWindowSize()
private static native int getSpeckleWindowSize_0(long nativeObj);
// C++: void cv::StereoMatcher::compute(Mat left, Mat right, Mat& disparity)
private static native void compute_0(long nativeObj, long left_nativeObj, long right_nativeObj, long disparity_nativeObj);
// C++: void cv::StereoMatcher::setBlockSize(int blockSize)
private static native void setBlockSize_0(long nativeObj, int blockSize);
// C++: void cv::StereoMatcher::setDisp12MaxDiff(int disp12MaxDiff)
private static native void setDisp12MaxDiff_0(long nativeObj, int disp12MaxDiff);
// C++: void cv::StereoMatcher::setMinDisparity(int minDisparity)
private static native void setMinDisparity_0(long nativeObj, int minDisparity);
// C++: void cv::StereoMatcher::setNumDisparities(int numDisparities)
private static native void setNumDisparities_0(long nativeObj, int numDisparities);
// C++: void cv::StereoMatcher::setSpeckleRange(int speckleRange)
private static native void setSpeckleRange_0(long nativeObj, int speckleRange);
// C++: void cv::StereoMatcher::setSpeckleWindowSize(int speckleWindowSize)
private static native void setSpeckleWindowSize_0(long nativeObj, int speckleWindowSize);
// native support for java finalize()
private static native void delete(long nativeObj);
}
================================================
FILE: openCV/src/main/java/org/opencv/calib3d/StereoSGBM.java
================================================
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.calib3d;
import org.opencv.calib3d.StereoMatcher;
import org.opencv.calib3d.StereoSGBM;
// C++: class StereoSGBM
//javadoc: StereoSGBM
public class StereoSGBM extends StereoMatcher {
protected StereoSGBM(long addr) { super(addr); }
// internal usage only
public static StereoSGBM __fromPtr__(long addr) { return new StereoSGBM(addr); }
// C++: enum
public static final int
MODE_SGBM = 0,
MODE_HH = 1,
MODE_SGBM_3WAY = 2,
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)
//
//javadoc: StereoSGBM::create(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, mode)
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)
{
StereoSGBM retVal = StereoSGBM.__fromPtr__(create_0(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, mode));
return retVal;
}
//javadoc: StereoSGBM::create(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange)
public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange)
{
StereoSGBM retVal = StereoSGBM.__fromPtr__(create_1(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange));
return retVal;
}
//javadoc: StereoSGBM::create(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize)
public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize)
{
StereoSGBM retVal = StereoSGBM.__fromPtr__(create_2(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize));
return retVal;
}
//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)
{
StereoSGBM retVal = StereoSGBM.__fromPtr__(create_3(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio));
return retVal;
}
//javadoc: StereoSGBM::create(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap)
public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap)
{
StereoSGBM retVal = StereoSGBM.__fromPtr__(create_4(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap));
return retVal;
}
//javadoc: StereoSGBM::create(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff)
public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff)
{
StereoSGBM retVal = StereoSGBM.__fromPtr__(create_5(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff));
return retVal;
}
//javadoc: StereoSGBM::create(minDisparity, numDisparities, blockSize, P1, P2)
public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1, int P2)
{
StereoSGBM retVal = StereoSGBM.__fromPtr__(create_6(minDisparity, numDisparities, blockSize, P1, P2));
return retVal;
}
//javadoc: StereoSGBM::create(minDisparity, numDisparities, blockSize, P1)
public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize, int P1)
{
StereoSGBM retVal = StereoSGBM.__fromPtr__(create_7(minDisparity, numDisparities, blockSize, P1));
return retVal;
}
//javadoc: StereoSGBM::create(minDisparity, numDisparities, blockSize)
public static StereoSGBM create(int minDisparity, int numDisparities, int blockSize)
{
StereoSGBM retVal = StereoSGBM.__fromPtr__(create_8(minDisparity, numDisparities, blockSize));
return retVal;
}
//javadoc: StereoSGBM::create(minDisparity, numDisparities)
public static StereoSGBM create(int minDisparity, int numDisparities)
{
StereoSGBM retVal = StereoSGBM.__fromPtr__(create_9(minDisparity, numDisparities));
return retVal;
}
//javadoc: StereoSGBM::create(minDisparity)
public static StereoSGBM create(int minDisparity)
{
StereoSGBM retVal = StereoSGBM.__fromPtr__(create_10(minDisparity));
return retVal;
}
//javadoc: StereoSGBM::create()
public static StereoSGBM create()
{
StereoSGBM retVal = StereoSGBM.__fromPtr__(create_11());
return retVal;
}
//
// C++: int cv::StereoSGBM::getMode()
//
//javadoc: StereoSGBM::getMode()
public int getMode()
{
int retVal = getMode_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoSGBM::getP1()
//
//javadoc: StereoSGBM::getP1()
public int getP1()
{
int retVal = getP1_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoSGBM::getP2()
//
//javadoc: StereoSGBM::getP2()
public int getP2()
{
int retVal = getP2_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoSGBM::getPreFilterCap()
//
//javadoc: StereoSGBM::getPreFilterCap()
public int getPreFilterCap()
{
int retVal = getPreFilterCap_0(nativeObj);
return retVal;
}
//
// C++: int cv::StereoSGBM::getUniquenessRatio()
//
//javadoc: StereoSGBM::getUniquenessRatio()
public int getUniquenessRatio()
{
int retVal = getUniquenessRatio_0(nativeObj);
return retVal;
}
//
// C++: void cv::StereoSGBM::setMode(int mode)
//
//javadoc: StereoSGBM::setMode(mode)
public void setMode(int mode)
{
setMode_0(nativeObj, mode);
return;
}
//
// C++: void cv::StereoSGBM::setP1(int P1)
//
//javadoc: StereoSGBM::setP1(P1)
public void setP1(int P1)
{
setP1_0(nativeObj, P1);
return;
}
//
// C++: void cv::StereoSGBM::setP2(int P2)
//
//javadoc: StereoSGBM::setP2(P2)
public void setP2(int P2)
{
setP2_0(nativeObj, P2);
return;
}
//
// C++: void cv::StereoSGBM::setPreFilterCap(int preFilterCap)
//
//javadoc: StereoSGBM::setPreFilterCap(preFilterCap)
public void setPreFilterCap(int preFilterCap)
{
setPreFilterCap_0(nativeObj, preFilterCap);
return;
}
//
// C++: void cv::StereoSGBM::setUniquenessRatio(int uniquenessRatio)
//
//javadoc: StereoSGBM::setUniquenessRatio(uniquenessRatio)
public void setUniquenessRatio(int uniquenessRatio)
{
setUniquenessRatio_0(nativeObj, uniquenessRatio);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// 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)
private static native long create_0(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange, int mode);
private static native long create_1(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize, int speckleRange);
private static native long create_2(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio, int speckleWindowSize);
private static native long create_3(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap, int uniquenessRatio);
private static native long create_4(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff, int preFilterCap);
private static native long create_5(int minDisparity, int numDisparities, int blockSize, int P1, int P2, int disp12MaxDiff);
private static native long create_6(int minDisparity, int numDisparities, int blockSize, int P1, int P2);
private static native long create_7(int minDisparity, int numDisparities, int blockSize, int P1);
private static native long create_8(int minDisparity, int numDisparities, int blockSize);
private static native long create_9(int minDisparity, int numDisparities);
private static native long create_10(int minDisparity);
private static native long create_11();
// C++: int cv::StereoSGBM::getMode()
private static native int getMode_0(long nativeObj);
// C++: int cv::StereoSGBM::getP1()
private static native int getP1_0(long nativeObj);
// C++: int cv::StereoSGBM::getP2()
private static native int getP2_0(long nativeObj);
// C++: int cv::StereoSGBM::getPreFilterCap()
private static native int getPreFilterCap_0(long nativeObj);
// C++: int cv::StereoSGBM::getUniquenessRatio()
private static native int getUniquenessRatio_0(long nativeObj);
// C++: void cv::StereoSGBM::setMode(int mode)
private static native void setMode_0(long nativeObj, int mode);
// C++: void cv::StereoSGBM::setP1(int P1)
private static native void setP1_0(long nativeObj, int P1);
// C++: void cv::StereoSGBM::setP2(int P2)
private static native void setP2_0(long nativeObj, int P2);
// C++: void cv::StereoSGBM::setPreFilterCap(int preFilterCap)
private static native void setPreFilterCap_0(long nativeObj, int preFilterCap);
// C++: void cv::StereoSGBM::setUniquenessRatio(int uniquenessRatio)
private static native void setUniquenessRatio_0(long nativeObj, int uniquenessRatio);
// native support for java finalize()
private static native void delete(long nativeObj);
}
================================================
FILE: openCV/src/main/java/org/opencv/core/Algorithm.java
================================================
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.core;
import java.lang.String;
// C++: class Algorithm
//javadoc: Algorithm
public class Algorithm {
protected final long nativeObj;
protected Algorithm(long addr) { nativeObj = addr; }
public long getNativeObjAddr() { return nativeObj; }
// internal usage only
public static Algorithm __fromPtr__(long addr) { return new Algorithm(addr); }
//
// C++: String cv::Algorithm::getDefaultName()
//
//javadoc: Algorithm::getDefaultName()
public String getDefaultName()
{
String retVal = getDefaultName_0(nativeObj);
return retVal;
}
//
// C++: bool cv::Algorithm::empty()
//
//javadoc: Algorithm::empty()
public boolean empty()
{
boolean retVal = empty_0(nativeObj);
return retVal;
}
//
// C++: void cv::Algorithm::clear()
//
//javadoc: Algorithm::clear()
public void clear()
{
clear_0(nativeObj);
return;
}
//
// C++: void cv::Algorithm::read(FileNode fn)
//
// Unknown type 'FileNode' (I), skipping the function
//
// C++: void cv::Algorithm::save(String filename)
//
//javadoc: Algorithm::save(filename)
public void save(String filename)
{
save_0(nativeObj, filename);
return;
}
//
// C++: void cv::Algorithm::write(Ptr_FileStorage fs, String name = String())
//
// Unknown type 'Ptr_FileStorage' (I), skipping the function
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: String cv::Algorithm::getDefaultName()
private static native String getDefaultName_0(long nativeObj);
// C++: bool cv::Algorithm::empty()
private static native boolean empty_0(long nativeObj);
// C++: void cv::Algorithm::clear()
private static native void clear_0(long nativeObj);
// C++: void cv::Algorithm::save(String filename)
private static native void save_0(long nativeObj, String filename);
// native support for java finalize()
private static native void delete(long nativeObj);
}
================================================
FILE: openCV/src/main/java/org/opencv/core/Core.java
================================================
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.core;
import java.lang.String;
import java.util.ArrayList;
import java.util.List;
import org.opencv.core.Mat;
import org.opencv.core.MatOfDouble;
import org.opencv.core.MatOfInt;
import org.opencv.core.Scalar;
import org.opencv.core.TermCriteria;
import org.opencv.utils.Converters;
// C++: class Core
//javadoc: Core
public class Core {
// these constants are wrapped inside functions to prevent inlining
private static String getVersion() { return "3.4.6"; }
private static String getNativeLibraryName() { return "opencv_java346"; }
private static int getVersionMajorJ() { return 3; }
private static int getVersionMinorJ() { return 4; }
private static int getVersionRevisionJ() { return 6; }
private static String getVersionStatusJ() { return ""; }
public static final String VERSION = getVersion();
public static final String NATIVE_LIBRARY_NAME = getNativeLibraryName();
public static final int VERSION_MAJOR = getVersionMajorJ();
public static final int VERSION_MINOR = getVersionMinorJ();
public static final int VERSION_REVISION = getVersionRevisionJ();
public static final String VERSION_STATUS = getVersionStatusJ();
private static final int
CV_8U = 0,
CV_8S = 1,
CV_16U = 2,
CV_16S = 3,
CV_32S = 4,
CV_32F = 5,
CV_64F = 6,
CV_USRTYPE1 = 7;
// C++: enum DecompTypes
public static final int
DECOMP_LU = 0,
DECOMP_SVD = 1,
DECOMP_EIG = 2,
DECOMP_CHOLESKY = 3,
DECOMP_QR = 4,
DECOMP_NORMAL = 16;
// C++: enum HersheyFonts
public static final int
FONT_HERSHEY_SIMPLEX = 0,
FONT_HERSHEY_PLAIN = 1,
FONT_HERSHEY_DUPLEX = 2,
FONT_HERSHEY_COMPLEX = 3,
FONT_HERSHEY_TRIPLEX = 4,
FONT_HERSHEY_COMPLEX_SMALL = 5,
FONT_HERSHEY_SCRIPT_SIMPLEX = 6,
FONT_HERSHEY_SCRIPT_COMPLEX = 7,
FONT_ITALIC = 16;
// C++: enum LineTypes
public static final int
LINE_4 = 4,
LINE_8 = 8,
LINE_AA = 16;
// C++: enum BorderTypes
public static final int
BORDER_CONSTANT = 0,
BORDER_REPLICATE = 1,
BORDER_REFLECT = 2,
BORDER_WRAP = 3,
BORDER_REFLECT_101 = 4,
BORDER_TRANSPARENT = 5,
BORDER_REFLECT101 = 4,
BORDER_DEFAULT = 4,
BORDER_ISOLATED = 16;
// C++: enum GemmFlags
public static final int
GEMM_1_T = 1,
GEMM_2_T = 2,
GEMM_3_T = 4;
// C++: enum KmeansFlags
public static final int
KMEANS_RANDOM_CENTERS = 0,
KMEANS_PP_CENTERS = 2,
KMEANS_USE_INITIAL_LABELS = 1;
// C++: enum CmpTypes
public static final int
CMP_EQ = 0,
CMP_GT = 1,
CMP_GE = 2,
CMP_LT = 3,
CMP_LE = 4,
CMP_NE = 5;
// C++: enum
public static final int
SVD_MODIFY_A = 1,
SVD_NO_UV = 2,
SVD_FULL_UV = 4,
FILLED = -1,
REDUCE_SUM = 0,
REDUCE_AVG = 1,
REDUCE_MAX = 2,
REDUCE_MIN = 3,
Hamming_normType = 6,
RNG_UNIFORM = 0,
RNG_NORMAL = 1,
Formatter_FMT_DEFAULT = 0,
Formatter_FMT_MATLAB = 1,
Formatter_FMT_CSV = 2,
Formatter_FMT_PYTHON = 3,
Formatter_FMT_NUMPY = 4,
Formatter_FMT_C = 5,
Param_INT = 0,
Param_BOOLEAN = 1,
Param_REAL = 2,
Param_STRING = 3,
Param_MAT = 4,
Param_MAT_VECTOR = 5,
Param_ALGORITHM = 6,
Param_FLOAT = 7,
Param_UNSIGNED_INT = 8,
Param_UINT64 = 9,
Param_UCHAR = 11,
Param_SCALAR = 12;
// C++: enum Flags
public static final int
PCA_DATA_AS_ROW = 0,
PCA_DATA_AS_COL = 1,
PCA_USE_AVG = 2;
// C++: enum DftFlags
public static final int
DFT_INVERSE = 1,
DFT_SCALE = 2,
DFT_ROWS = 4,
DFT_COMPLEX_OUTPUT = 16,
DFT_REAL_OUTPUT = 32,
DFT_COMPLEX_INPUT = 64,
DCT_INVERSE = 1,
DCT_ROWS = 4;
// C++: enum CovarFlags
public static final int
COVAR_SCRAMBLED = 0,
COVAR_NORMAL = 1,
COVAR_USE_AVG = 2,
COVAR_SCALE = 4,
COVAR_ROWS = 8,
COVAR_COLS = 16;
// C++: enum FLAGS
public static final int
FLAGS_NONE = 0,
FLAGS_MAPPING = 0x01,
FLAGS_EXPAND_SAME_NAMES = 0x02;
// C++: enum TYPE
public static final int
TYPE_GENERAL = 0,
TYPE_MARKER = 0+1,
TYPE_WRAPPER = 0+2,
TYPE_FUN = 0+3;
// C++: enum SortFlags
public static final int
SORT_EVERY_ROW = 0,
SORT_EVERY_COLUMN = 1,
SORT_ASCENDING = 0,
SORT_DESCENDING = 16;
// C++: enum IMPL
public static final int
IMPL_PLAIN = 0,
IMPL_IPP = 0+1,
IMPL_OPENCL = 0+2;
// C++: enum NormTypes
public static final int
NORM_INF = 1,
NORM_L1 = 2,
NORM_L2 = 4,
NORM_L2SQR = 5,
NORM_HAMMING = 6,
NORM_HAMMING2 = 7,
NORM_TYPE_MASK = 7,
NORM_RELATIVE = 8,
NORM_MINMAX = 32;
// C++: enum RotateFlags
public static final int
ROTATE_90_CLOCKWISE = 0,
ROTATE_180 = 1,
ROTATE_90_COUNTERCLOCKWISE = 2;
// C++: enum Code
public static final int
StsOk = 0,
StsBackTrace = -1,
StsError = -2,
StsInternal = -3,
StsNoMem = -4,
StsBadArg = -5,
StsBadFunc = -6,
StsNoConv = -7,
StsAutoTrace = -8,
HeaderIsNull = -9,
BadImageSize = -10,
BadOffset = -11,
BadDataPtr = -12,
BadStep = -13,
BadModelOrChSeq = -14,
BadNumChannels = -15,
BadNumChannel1U = -16,
BadDepth = -17,
BadAlphaChannel = -18,
BadOrder = -19,
BadOrigin = -20,
BadAlign = -21,
BadCallBack = -22,
BadTileSize = -23,
BadCOI = -24,
BadROISize = -25,
MaskIsTiled = -26,
StsNullPtr = -27,
StsVecLengthErr = -28,
StsFilterStructContentErr = -29,
StsKernelStructContentErr = -30,
StsFilterOffsetErr = -31,
StsBadSize = -201,
StsDivByZero = -202,
StsInplaceNotSupported = -203,
StsObjectNotFound = -204,
StsUnmatchedFormats = -205,
StsBadFlag = -206,
StsBadPoint = -207,
StsBadMask = -208,
StsUnmatchedSizes = -209,
StsUnsupportedFormat = -210,
StsOutOfRange = -211,
StsParseError = -212,
StsNotImplemented = -213,
StsBadMemBlock = -214,
StsAssert = -215,
GpuNotSupported = -216,
GpuApiCallError = -217,
OpenGlNotSupported = -218,
OpenGlApiCallError = -219,
OpenCLApiCallError = -220,
OpenCLDoubleNotSupported = -221,
OpenCLInitError = -222,
OpenCLNoAMDBlasFft = -223;
//
// C++: Scalar cv::mean(Mat src, Mat mask = Mat())
//
//javadoc: mean(src, mask)
public static Scalar mean(Mat src, Mat mask)
{
Scalar retVal = new Scalar(mean_0(src.nativeObj, mask.nativeObj));
return retVal;
}
//javadoc: mean(src)
public static Scalar mean(Mat src)
{
Scalar retVal = new Scalar(mean_1(src.nativeObj));
return retVal;
}
//
// C++: Scalar cv::sum(Mat src)
//
//javadoc: sumElems(src)
public static Scalar sumElems(Mat src)
{
Scalar retVal = new Scalar(sumElems_0(src.nativeObj));
return retVal;
}
//
// C++: Scalar cv::trace(Mat mtx)
//
//javadoc: trace(mtx)
public static Scalar trace(Mat mtx)
{
Scalar retVal = new Scalar(trace_0(mtx.nativeObj));
return retVal;
}
//
// C++: String cv::getBuildInformation()
//
//javadoc: getBuildInformation()
public static String getBuildInformation()
{
String retVal = getBuildInformation_0();
return retVal;
}
//
// C++: String cv::getHardwareFeatureName(int feature)
//
//javadoc: getHardwareFeatureName(feature)
public static String getHardwareFeatureName(int feature)
{
String retVal = getHardwareFeatureName_0(feature);
return retVal;
}
//
// C++: String cv::getVersionString()
//
//javadoc: getVersionString()
public static String getVersionString()
{
String retVal = getVersionString_0();
return retVal;
}
//
// C++: String cv::ipp::getIppVersion()
//
//javadoc: getIppVersion()
public static String getIppVersion()
{
String retVal = getIppVersion_0();
return retVal;
}
//
// C++: String cv::samples::findFile(String relative_path, bool required = true, bool silentMode = false)
//
//javadoc: findFile(relative_path, required, silentMode)
public static String findFile(String relative_path, boolean required, boolean silentMode)
{
String retVal = findFile_0(relative_path, required, silentMode);
return retVal;
}
//javadoc: findFile(relative_path, required)
public static String findFile(String relative_path, boolean required)
{
String retVal = findFile_1(relative_path, required);
return retVal;
}
//javadoc: findFile(relative_path)
public static String findFile(String relative_path)
{
String retVal = findFile_2(relative_path);
return retVal;
}
//
// C++: String cv::samples::findFileOrKeep(String relative_path, bool silentMode = false)
//
//javadoc: findFileOrKeep(relative_path, silentMode)
public static String findFileOrKeep(String relative_path, boolean silentMode)
{
String retVal = findFileOrKeep_0(relative_path, silentMode);
return retVal;
}
//javadoc: findFileOrKeep(relative_path)
public static String findFileOrKeep(String relative_path)
{
String retVal = findFileOrKeep_1(relative_path);
return retVal;
}
//
// C++: bool cv::checkRange(Mat a, bool quiet = true, _hidden_ * pos = 0, double minVal = -DBL_MAX, double maxVal = DBL_MAX)
//
//javadoc: checkRange(a, quiet, minVal, maxVal)
public static boolean checkRange(Mat a, boolean quiet, double minVal, double maxVal)
{
boolean retVal = checkRange_0(a.nativeObj, quiet, minVal, maxVal);
return retVal;
}
//javadoc: checkRange(a, quiet, minVal)
public static boolean checkRange(Mat a, boolean quiet, double minVal)
{
boolean retVal = checkRange_1(a.nativeObj, quiet, minVal);
return retVal;
}
//javadoc: checkRange(a, quiet)
public static boolean checkRange(Mat a, boolean quiet)
{
boolean retVal = checkRange_2(a.nativeObj, quiet);
return retVal;
}
//javadoc: checkRange(a)
public static boolean checkRange(Mat a)
{
boolean retVal = checkRange_4(a.nativeObj);
return retVal;
}
//
// C++: bool cv::eigen(Mat src, Mat& eigenvalues, Mat& eigenvectors = Mat())
//
//javadoc: eigen(src, eigenvalues, eigenvectors)
public static boolean eigen(Mat src, Mat eigenvalues, Mat eigenvectors)
{
boolean retVal = eigen_0(src.nativeObj, eigenvalues.nativeObj, eigenvectors.nativeObj);
return retVal;
}
//javadoc: eigen(src, eigenvalues)
public static boolean eigen(Mat src, Mat eigenvalues)
{
boolean retVal = eigen_1(src.nativeObj, eigenvalues.nativeObj);
return retVal;
}
//
// C++: bool cv::solve(Mat src1, Mat src2, Mat& dst, int flags = DECOMP_LU)
//
//javadoc: solve(src1, src2, dst, flags)
public static boolean solve(Mat src1, Mat src2, Mat dst, int flags)
{
boolean retVal = solve_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, flags);
return retVal;
}
//javadoc: solve(src1, src2, dst)
public static boolean solve(Mat src1, Mat src2, Mat dst)
{
boolean retVal = solve_1(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return retVal;
}
//
// C++: bool cv::ipp::useIPP()
//
//javadoc: useIPP()
public static boolean useIPP()
{
boolean retVal = useIPP_0();
return retVal;
}
//
// C++: bool cv::ipp::useIPP_NE()
//
//javadoc: useIPP_NE()
public static boolean useIPP_NE()
{
boolean retVal = useIPP_NE_0();
return retVal;
}
//
// C++: bool cv::ipp::useIPP_NotExact()
//
//javadoc: useIPP_NotExact()
public static boolean useIPP_NotExact()
{
boolean retVal = useIPP_NotExact_0();
return retVal;
}
//
// C++: double cv::Mahalanobis(Mat v1, Mat v2, Mat icovar)
//
//javadoc: Mahalanobis(v1, v2, icovar)
public static double Mahalanobis(Mat v1, Mat v2, Mat icovar)
{
double retVal = Mahalanobis_0(v1.nativeObj, v2.nativeObj, icovar.nativeObj);
return retVal;
}
//
// C++: double cv::PSNR(Mat src1, Mat src2)
//
//javadoc: PSNR(src1, src2)
public static double PSNR(Mat src1, Mat src2)
{
double retVal = PSNR_0(src1.nativeObj, src2.nativeObj);
return retVal;
}
//
// C++: double cv::determinant(Mat mtx)
//
//javadoc: determinant(mtx)
public static double determinant(Mat mtx)
{
double retVal = determinant_0(mtx.nativeObj);
return retVal;
}
//
// C++: double cv::getTickFrequency()
//
//javadoc: getTickFrequency()
public static double getTickFrequency()
{
double retVal = getTickFrequency_0();
return retVal;
}
//
// C++: double cv::invert(Mat src, Mat& dst, int flags = DECOMP_LU)
//
//javadoc: invert(src, dst, flags)
public static double invert(Mat src, Mat dst, int flags)
{
double retVal = invert_0(src.nativeObj, dst.nativeObj, flags);
return retVal;
}
//javadoc: invert(src, dst)
public static double invert(Mat src, Mat dst)
{
double retVal = invert_1(src.nativeObj, dst.nativeObj);
return retVal;
}
//
// C++: double cv::kmeans(Mat data, int K, Mat& bestLabels, TermCriteria criteria, int attempts, int flags, Mat& centers = Mat())
//
//javadoc: kmeans(data, K, bestLabels, criteria, attempts, flags, centers)
public static double kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags, Mat centers)
{
double retVal = kmeans_0(data.nativeObj, K, bestLabels.nativeObj, criteria.type, criteria.maxCount, criteria.epsilon, attempts, flags, centers.nativeObj);
return retVal;
}
//javadoc: kmeans(data, K, bestLabels, criteria, attempts, flags)
public static double kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags)
{
double retVal = kmeans_1(data.nativeObj, K, bestLabels.nativeObj, criteria.type, criteria.maxCount, criteria.epsilon, attempts, flags);
return retVal;
}
//
// C++: double cv::norm(Mat src1, Mat src2, int normType = NORM_L2, Mat mask = Mat())
//
//javadoc: norm(src1, src2, normType, mask)
public static double norm(Mat src1, Mat src2, int normType, Mat mask)
{
double retVal = norm_0(src1.nativeObj, src2.nativeObj, normType, mask.nativeObj);
return retVal;
}
//javadoc: norm(src1, src2, normType)
public static double norm(Mat src1, Mat src2, int normType)
{
double retVal = norm_1(src1.nativeObj, src2.nativeObj, normType);
return retVal;
}
//javadoc: norm(src1, src2)
public static double norm(Mat src1, Mat src2)
{
double retVal = norm_2(src1.nativeObj, src2.nativeObj);
return retVal;
}
//
// C++: double cv::norm(Mat src1, int normType = NORM_L2, Mat mask = Mat())
//
//javadoc: norm(src1, normType, mask)
public static double norm(Mat src1, int normType, Mat mask)
{
double retVal = norm_3(src1.nativeObj, normType, mask.nativeObj);
return retVal;
}
//javadoc: norm(src1, normType)
public static double norm(Mat src1, int normType)
{
double retVal = norm_4(src1.nativeObj, normType);
return retVal;
}
//javadoc: norm(src1)
public static double norm(Mat src1)
{
double retVal = norm_5(src1.nativeObj);
return retVal;
}
//
// C++: double cv::solvePoly(Mat coeffs, Mat& roots, int maxIters = 300)
//
//javadoc: solvePoly(coeffs, roots, maxIters)
public static double solvePoly(Mat coeffs, Mat roots, int maxIters)
{
double retVal = solvePoly_0(coeffs.nativeObj, roots.nativeObj, maxIters);
return retVal;
}
//javadoc: solvePoly(coeffs, roots)
public static double solvePoly(Mat coeffs, Mat roots)
{
double retVal = solvePoly_1(coeffs.nativeObj, roots.nativeObj);
return retVal;
}
//
// C++: float cv::cubeRoot(float val)
//
//javadoc: cubeRoot(val)
public static float cubeRoot(float val)
{
float retVal = cubeRoot_0(val);
return retVal;
}
//
// C++: float cv::fastAtan2(float y, float x)
//
//javadoc: fastAtan2(y, x)
public static float fastAtan2(float y, float x)
{
float retVal = fastAtan2_0(y, x);
return retVal;
}
//
// C++: int cv::borderInterpolate(int p, int len, int borderType)
//
//javadoc: borderInterpolate(p, len, borderType)
public static int borderInterpolate(int p, int len, int borderType)
{
int retVal = borderInterpolate_0(p, len, borderType);
return retVal;
}
//
// C++: int cv::countNonZero(Mat src)
//
//javadoc: countNonZero(src)
public static int countNonZero(Mat src)
{
int retVal = countNonZero_0(src.nativeObj);
return retVal;
}
//
// C++: int cv::getNumThreads()
//
//javadoc: getNumThreads()
public static int getNumThreads()
{
int retVal = getNumThreads_0();
return retVal;
}
//
// C++: int cv::getNumberOfCPUs()
//
//javadoc: getNumberOfCPUs()
public static int getNumberOfCPUs()
{
int retVal = getNumberOfCPUs_0();
return retVal;
}
//
// C++: int cv::getOptimalDFTSize(int vecsize)
//
//javadoc: getOptimalDFTSize(vecsize)
public static int getOptimalDFTSize(int vecsize)
{
int retVal = getOptimalDFTSize_0(vecsize);
return retVal;
}
//
// C++: int cv::getThreadNum()
//
//javadoc: getThreadNum()
@Deprecated
public static int getThreadNum()
{
int retVal = getThreadNum_0();
return retVal;
}
//
// C++: int cv::getVersionMajor()
//
//javadoc: getVersionMajor()
public static int getVersionMajor()
{
int retVal = getVersionMajor_0();
return retVal;
}
//
// C++: int cv::getVersionMinor()
//
//javadoc: getVersionMinor()
public static int getVersionMinor()
{
int retVal = getVersionMinor_0();
return retVal;
}
//
// C++: int cv::getVersionRevision()
//
//javadoc: getVersionRevision()
public static int getVersionRevision()
{
int retVal = getVersionRevision_0();
return retVal;
}
//
// C++: int cv::solveCubic(Mat coeffs, Mat& roots)
//
//javadoc: solveCubic(coeffs, roots)
public static int solveCubic(Mat coeffs, Mat roots)
{
int retVal = solveCubic_0(coeffs.nativeObj, roots.nativeObj);
return retVal;
}
//
// C++: int64 cv::getCPUTickCount()
//
//javadoc: getCPUTickCount()
public static long getCPUTickCount()
{
long retVal = getCPUTickCount_0();
return retVal;
}
//
// C++: int64 cv::getTickCount()
//
//javadoc: getTickCount()
public static long getTickCount()
{
long retVal = getTickCount_0();
return retVal;
}
//
// C++: void cv::LUT(Mat src, Mat lut, Mat& dst)
//
//javadoc: LUT(src, lut, dst)
public static void LUT(Mat src, Mat lut, Mat dst)
{
LUT_0(src.nativeObj, lut.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::PCABackProject(Mat data, Mat mean, Mat eigenvectors, Mat& result)
//
//javadoc: PCABackProject(data, mean, eigenvectors, result)
public static void PCABackProject(Mat data, Mat mean, Mat eigenvectors, Mat result)
{
PCABackProject_0(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, result.nativeObj);
return;
}
//
// C++: void cv::PCACompute(Mat data, Mat& mean, Mat& eigenvectors, Mat& eigenvalues, double retainedVariance)
//
//javadoc: PCACompute2(data, mean, eigenvectors, eigenvalues, retainedVariance)
public static void PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, double retainedVariance)
{
PCACompute2_0(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, eigenvalues.nativeObj, retainedVariance);
return;
}
//
// C++: void cv::PCACompute(Mat data, Mat& mean, Mat& eigenvectors, Mat& eigenvalues, int maxComponents = 0)
//
//javadoc: PCACompute2(data, mean, eigenvectors, eigenvalues, maxComponents)
public static void PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, int maxComponents)
{
PCACompute2_1(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, eigenvalues.nativeObj, maxComponents);
return;
}
//javadoc: PCACompute2(data, mean, eigenvectors, eigenvalues)
public static void PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues)
{
PCACompute2_2(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, eigenvalues.nativeObj);
return;
}
//
// C++: void cv::PCACompute(Mat data, Mat& mean, Mat& eigenvectors, double retainedVariance)
//
//javadoc: PCACompute(data, mean, eigenvectors, retainedVariance)
public static void PCACompute(Mat data, Mat mean, Mat eigenvectors, double retainedVariance)
{
PCACompute_0(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, retainedVariance);
return;
}
//
// C++: void cv::PCACompute(Mat data, Mat& mean, Mat& eigenvectors, int maxComponents = 0)
//
//javadoc: PCACompute(data, mean, eigenvectors, maxComponents)
public static void PCACompute(Mat data, Mat mean, Mat eigenvectors, int maxComponents)
{
PCACompute_1(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, maxComponents);
return;
}
//javadoc: PCACompute(data, mean, eigenvectors)
public static void PCACompute(Mat data, Mat mean, Mat eigenvectors)
{
PCACompute_2(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj);
return;
}
//
// C++: void cv::PCAProject(Mat data, Mat mean, Mat eigenvectors, Mat& result)
//
//javadoc: PCAProject(data, mean, eigenvectors, result)
public static void PCAProject(Mat data, Mat mean, Mat eigenvectors, Mat result)
{
PCAProject_0(data.nativeObj, mean.nativeObj, eigenvectors.nativeObj, result.nativeObj);
return;
}
//
// C++: void cv::SVBackSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat& dst)
//
//javadoc: SVBackSubst(w, u, vt, rhs, dst)
public static void SVBackSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat dst)
{
SVBackSubst_0(w.nativeObj, u.nativeObj, vt.nativeObj, rhs.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::SVDecomp(Mat src, Mat& w, Mat& u, Mat& vt, int flags = 0)
//
//javadoc: SVDecomp(src, w, u, vt, flags)
public static void SVDecomp(Mat src, Mat w, Mat u, Mat vt, int flags)
{
SVDecomp_0(src.nativeObj, w.nativeObj, u.nativeObj, vt.nativeObj, flags);
return;
}
//javadoc: SVDecomp(src, w, u, vt)
public static void SVDecomp(Mat src, Mat w, Mat u, Mat vt)
{
SVDecomp_1(src.nativeObj, w.nativeObj, u.nativeObj, vt.nativeObj);
return;
}
//
// C++: void cv::absdiff(Mat src1, Mat src2, Mat& dst)
//
//javadoc: absdiff(src1, src2, dst)
public static void absdiff(Mat src1, Mat src2, Mat dst)
{
absdiff_0(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::absdiff(Mat src1, Scalar src2, Mat& dst)
//
//javadoc: absdiff(src1, src2, dst)
public static void absdiff(Mat src1, Scalar src2, Mat dst)
{
absdiff_1(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void cv::add(Mat src1, Mat src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
//
//javadoc: add(src1, src2, dst, mask, dtype)
public static void add(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)
{
add_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj, dtype);
return;
}
//javadoc: add(src1, src2, dst, mask)
public static void add(Mat src1, Mat src2, Mat dst, Mat mask)
{
add_1(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: add(src1, src2, dst)
public static void add(Mat src1, Mat src2, Mat dst)
{
add_2(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::add(Mat src1, Scalar src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
//
//javadoc: add(src1, src2, dst, mask, dtype)
public static void add(Mat src1, Scalar src2, Mat dst, Mat mask, int dtype)
{
add_3(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, mask.nativeObj, dtype);
return;
}
//javadoc: add(src1, src2, dst, mask)
public static void add(Mat src1, Scalar src2, Mat dst, Mat mask)
{
add_4(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: add(src1, src2, dst)
public static void add(Mat src1, Scalar src2, Mat dst)
{
add_5(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void cv::addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat& dst, int dtype = -1)
//
//javadoc: addWeighted(src1, alpha, src2, beta, gamma, dst, dtype)
public static void addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst, int dtype)
{
addWeighted_0(src1.nativeObj, alpha, src2.nativeObj, beta, gamma, dst.nativeObj, dtype);
return;
}
//javadoc: addWeighted(src1, alpha, src2, beta, gamma, dst)
public static void addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst)
{
addWeighted_1(src1.nativeObj, alpha, src2.nativeObj, beta, gamma, dst.nativeObj);
return;
}
//
// C++: void cv::batchDistance(Mat src1, Mat src2, Mat& dist, int dtype, Mat& nidx, int normType = NORM_L2, int K = 0, Mat mask = Mat(), int update = 0, bool crosscheck = false)
//
//javadoc: batchDistance(src1, src2, dist, dtype, nidx, normType, K, mask, update, crosscheck)
public static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update, boolean crosscheck)
{
batchDistance_0(src1.nativeObj, src2.nativeObj, dist.nativeObj, dtype, nidx.nativeObj, normType, K, mask.nativeObj, update, crosscheck);
return;
}
//javadoc: batchDistance(src1, src2, dist, dtype, nidx, normType, K, mask, update)
public static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update)
{
batchDistance_1(src1.nativeObj, src2.nativeObj, dist.nativeObj, dtype, nidx.nativeObj, normType, K, mask.nativeObj, update);
return;
}
//javadoc: batchDistance(src1, src2, dist, dtype, nidx, normType, K, mask)
public static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask)
{
batchDistance_2(src1.nativeObj, src2.nativeObj, dist.nativeObj, dtype, nidx.nativeObj, normType, K, mask.nativeObj);
return;
}
//javadoc: batchDistance(src1, src2, dist, dtype, nidx, normType, K)
public static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K)
{
batchDistance_3(src1.nativeObj, src2.nativeObj, dist.nativeObj, dtype, nidx.nativeObj, normType, K);
return;
}
//javadoc: batchDistance(src1, src2, dist, dtype, nidx, normType)
public static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType)
{
batchDistance_4(src1.nativeObj, src2.nativeObj, dist.nativeObj, dtype, nidx.nativeObj, normType);
return;
}
//javadoc: batchDistance(src1, src2, dist, dtype, nidx)
public static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx)
{
batchDistance_5(src1.nativeObj, src2.nativeObj, dist.nativeObj, dtype, nidx.nativeObj);
return;
}
//
// C++: void cv::bitwise_and(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
//
//javadoc: bitwise_and(src1, src2, dst, mask)
public static void bitwise_and(Mat src1, Mat src2, Mat dst, Mat mask)
{
bitwise_and_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: bitwise_and(src1, src2, dst)
public static void bitwise_and(Mat src1, Mat src2, Mat dst)
{
bitwise_and_1(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::bitwise_not(Mat src, Mat& dst, Mat mask = Mat())
//
//javadoc: bitwise_not(src, dst, mask)
public static void bitwise_not(Mat src, Mat dst, Mat mask)
{
bitwise_not_0(src.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: bitwise_not(src, dst)
public static void bitwise_not(Mat src, Mat dst)
{
bitwise_not_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::bitwise_or(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
//
//javadoc: bitwise_or(src1, src2, dst, mask)
public static void bitwise_or(Mat src1, Mat src2, Mat dst, Mat mask)
{
bitwise_or_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: bitwise_or(src1, src2, dst)
public static void bitwise_or(Mat src1, Mat src2, Mat dst)
{
bitwise_or_1(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::bitwise_xor(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
//
//javadoc: bitwise_xor(src1, src2, dst, mask)
public static void bitwise_xor(Mat src1, Mat src2, Mat dst, Mat mask)
{
bitwise_xor_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: bitwise_xor(src1, src2, dst)
public static void bitwise_xor(Mat src1, Mat src2, Mat dst)
{
bitwise_xor_1(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::calcCovarMatrix(Mat samples, Mat& covar, Mat& mean, int flags, int ctype = CV_64F)
//
//javadoc: calcCovarMatrix(samples, covar, mean, flags, ctype)
public static void calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags, int ctype)
{
calcCovarMatrix_0(samples.nativeObj, covar.nativeObj, mean.nativeObj, flags, ctype);
return;
}
//javadoc: calcCovarMatrix(samples, covar, mean, flags)
public static void calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags)
{
calcCovarMatrix_1(samples.nativeObj, covar.nativeObj, mean.nativeObj, flags);
return;
}
//
// C++: void cv::cartToPolar(Mat x, Mat y, Mat& magnitude, Mat& angle, bool angleInDegrees = false)
//
//javadoc: cartToPolar(x, y, magnitude, angle, angleInDegrees)
public static void cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle, boolean angleInDegrees)
{
cartToPolar_0(x.nativeObj, y.nativeObj, magnitude.nativeObj, angle.nativeObj, angleInDegrees);
return;
}
//javadoc: cartToPolar(x, y, magnitude, angle)
public static void cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle)
{
cartToPolar_1(x.nativeObj, y.nativeObj, magnitude.nativeObj, angle.nativeObj);
return;
}
//
// C++: void cv::compare(Mat src1, Mat src2, Mat& dst, int cmpop)
//
//javadoc: compare(src1, src2, dst, cmpop)
public static void compare(Mat src1, Mat src2, Mat dst, int cmpop)
{
compare_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, cmpop);
return;
}
//
// C++: void cv::compare(Mat src1, Scalar src2, Mat& dst, int cmpop)
//
//javadoc: compare(src1, src2, dst, cmpop)
public static void compare(Mat src1, Scalar src2, Mat dst, int cmpop)
{
compare_1(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, cmpop);
return;
}
//
// C++: void cv::completeSymm(Mat& m, bool lowerToUpper = false)
//
//javadoc: completeSymm(m, lowerToUpper)
public static void completeSymm(Mat m, boolean lowerToUpper)
{
completeSymm_0(m.nativeObj, lowerToUpper);
return;
}
//javadoc: completeSymm(m)
public static void completeSymm(Mat m)
{
completeSymm_1(m.nativeObj);
return;
}
//
// C++: void cv::convertFp16(Mat src, Mat& dst)
//
//javadoc: convertFp16(src, dst)
public static void convertFp16(Mat src, Mat dst)
{
convertFp16_0(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::convertScaleAbs(Mat src, Mat& dst, double alpha = 1, double beta = 0)
//
//javadoc: convertScaleAbs(src, dst, alpha, beta)
public static void convertScaleAbs(Mat src, Mat dst, double alpha, double beta)
{
convertScaleAbs_0(src.nativeObj, dst.nativeObj, alpha, beta);
return;
}
//javadoc: convertScaleAbs(src, dst, alpha)
public static void convertScaleAbs(Mat src, Mat dst, double alpha)
{
convertScaleAbs_1(src.nativeObj, dst.nativeObj, alpha);
return;
}
//javadoc: convertScaleAbs(src, dst)
public static void convertScaleAbs(Mat src, Mat dst)
{
convertScaleAbs_2(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::copyMakeBorder(Mat src, Mat& dst, int top, int bottom, int left, int right, int borderType, Scalar value = Scalar())
//
//javadoc: copyMakeBorder(src, dst, top, bottom, left, right, borderType, value)
public static void copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, Scalar value)
{
copyMakeBorder_0(src.nativeObj, dst.nativeObj, top, bottom, left, right, borderType, value.val[0], value.val[1], value.val[2], value.val[3]);
return;
}
//javadoc: copyMakeBorder(src, dst, top, bottom, left, right, borderType)
public static void copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType)
{
copyMakeBorder_1(src.nativeObj, dst.nativeObj, top, bottom, left, right, borderType);
return;
}
//
// C++: void cv::dct(Mat src, Mat& dst, int flags = 0)
//
//javadoc: dct(src, dst, flags)
public static void dct(Mat src, Mat dst, int flags)
{
dct_0(src.nativeObj, dst.nativeObj, flags);
return;
}
//javadoc: dct(src, dst)
public static void dct(Mat src, Mat dst)
{
dct_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::dft(Mat src, Mat& dst, int flags = 0, int nonzeroRows = 0)
//
//javadoc: dft(src, dst, flags, nonzeroRows)
public static void dft(Mat src, Mat dst, int flags, int nonzeroRows)
{
dft_0(src.nativeObj, dst.nativeObj, flags, nonzeroRows);
return;
}
//javadoc: dft(src, dst, flags)
public static void dft(Mat src, Mat dst, int flags)
{
dft_1(src.nativeObj, dst.nativeObj, flags);
return;
}
//javadoc: dft(src, dst)
public static void dft(Mat src, Mat dst)
{
dft_2(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::divide(Mat src1, Mat src2, Mat& dst, double scale = 1, int dtype = -1)
//
//javadoc: divide(src1, src2, dst, scale, dtype)
public static void divide(Mat src1, Mat src2, Mat dst, double scale, int dtype)
{
divide_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, scale, dtype);
return;
}
//javadoc: divide(src1, src2, dst, scale)
public static void divide(Mat src1, Mat src2, Mat dst, double scale)
{
divide_1(src1.nativeObj, src2.nativeObj, dst.nativeObj, scale);
return;
}
//javadoc: divide(src1, src2, dst)
public static void divide(Mat src1, Mat src2, Mat dst)
{
divide_2(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::divide(Mat src1, Scalar src2, Mat& dst, double scale = 1, int dtype = -1)
//
//javadoc: divide(src1, src2, dst, scale, dtype)
public static void divide(Mat src1, Scalar src2, Mat dst, double scale, int dtype)
{
divide_3(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, scale, dtype);
return;
}
//javadoc: divide(src1, src2, dst, scale)
public static void divide(Mat src1, Scalar src2, Mat dst, double scale)
{
divide_4(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, scale);
return;
}
//javadoc: divide(src1, src2, dst)
public static void divide(Mat src1, Scalar src2, Mat dst)
{
divide_5(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void cv::divide(double scale, Mat src2, Mat& dst, int dtype = -1)
//
//javadoc: divide(scale, src2, dst, dtype)
public static void divide(double scale, Mat src2, Mat dst, int dtype)
{
divide_6(scale, src2.nativeObj, dst.nativeObj, dtype);
return;
}
//javadoc: divide(scale, src2, dst)
public static void divide(double scale, Mat src2, Mat dst)
{
divide_7(scale, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::eigenNonSymmetric(Mat src, Mat& eigenvalues, Mat& eigenvectors)
//
//javadoc: eigenNonSymmetric(src, eigenvalues, eigenvectors)
public static void eigenNonSymmetric(Mat src, Mat eigenvalues, Mat eigenvectors)
{
eigenNonSymmetric_0(src.nativeObj, eigenvalues.nativeObj, eigenvectors.nativeObj);
return;
}
//
// C++: void cv::exp(Mat src, Mat& dst)
//
//javadoc: exp(src, dst)
public static void exp(Mat src, Mat dst)
{
exp_0(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::extractChannel(Mat src, Mat& dst, int coi)
//
//javadoc: extractChannel(src, dst, coi)
public static void extractChannel(Mat src, Mat dst, int coi)
{
extractChannel_0(src.nativeObj, dst.nativeObj, coi);
return;
}
//
// C++: void cv::findNonZero(Mat src, Mat& idx)
//
//javadoc: findNonZero(src, idx)
public static void findNonZero(Mat src, Mat idx)
{
findNonZero_0(src.nativeObj, idx.nativeObj);
return;
}
//
// C++: void cv::flip(Mat src, Mat& dst, int flipCode)
//
//javadoc: flip(src, dst, flipCode)
public static void flip(Mat src, Mat dst, int flipCode)
{
flip_0(src.nativeObj, dst.nativeObj, flipCode);
return;
}
//
// C++: void cv::gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat& dst, int flags = 0)
//
//javadoc: gemm(src1, src2, alpha, src3, beta, dst, flags)
public static void gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags)
{
gemm_0(src1.nativeObj, src2.nativeObj, alpha, src3.nativeObj, beta, dst.nativeObj, flags);
return;
}
//javadoc: gemm(src1, src2, alpha, src3, beta, dst)
public static void gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst)
{
gemm_1(src1.nativeObj, src2.nativeObj, alpha, src3.nativeObj, beta, dst.nativeObj);
return;
}
//
// C++: void cv::hconcat(vector_Mat src, Mat& dst)
//
//javadoc: hconcat(src, dst)
public static void hconcat(List src, Mat dst)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
hconcat_0(src_mat.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::idct(Mat src, Mat& dst, int flags = 0)
//
//javadoc: idct(src, dst, flags)
public static void idct(Mat src, Mat dst, int flags)
{
idct_0(src.nativeObj, dst.nativeObj, flags);
return;
}
//javadoc: idct(src, dst)
public static void idct(Mat src, Mat dst)
{
idct_1(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::idft(Mat src, Mat& dst, int flags = 0, int nonzeroRows = 0)
//
//javadoc: idft(src, dst, flags, nonzeroRows)
public static void idft(Mat src, Mat dst, int flags, int nonzeroRows)
{
idft_0(src.nativeObj, dst.nativeObj, flags, nonzeroRows);
return;
}
//javadoc: idft(src, dst, flags)
public static void idft(Mat src, Mat dst, int flags)
{
idft_1(src.nativeObj, dst.nativeObj, flags);
return;
}
//javadoc: idft(src, dst)
public static void idft(Mat src, Mat dst)
{
idft_2(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::inRange(Mat src, Scalar lowerb, Scalar upperb, Mat& dst)
//
//javadoc: inRange(src, lowerb, upperb, dst)
public static void inRange(Mat src, Scalar lowerb, Scalar upperb, Mat dst)
{
inRange_0(src.nativeObj, lowerb.val[0], lowerb.val[1], lowerb.val[2], lowerb.val[3], upperb.val[0], upperb.val[1], upperb.val[2], upperb.val[3], dst.nativeObj);
return;
}
//
// C++: void cv::insertChannel(Mat src, Mat& dst, int coi)
//
//javadoc: insertChannel(src, dst, coi)
public static void insertChannel(Mat src, Mat dst, int coi)
{
insertChannel_0(src.nativeObj, dst.nativeObj, coi);
return;
}
//
// C++: void cv::log(Mat src, Mat& dst)
//
//javadoc: log(src, dst)
public static void log(Mat src, Mat dst)
{
log_0(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::magnitude(Mat x, Mat y, Mat& magnitude)
//
//javadoc: magnitude(x, y, magnitude)
public static void magnitude(Mat x, Mat y, Mat magnitude)
{
magnitude_0(x.nativeObj, y.nativeObj, magnitude.nativeObj);
return;
}
//
// C++: void cv::max(Mat src1, Mat src2, Mat& dst)
//
//javadoc: max(src1, src2, dst)
public static void max(Mat src1, Mat src2, Mat dst)
{
max_0(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::max(Mat src1, Scalar src2, Mat& dst)
//
//javadoc: max(src1, src2, dst)
public static void max(Mat src1, Scalar src2, Mat dst)
{
max_1(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void cv::meanStdDev(Mat src, vector_double& mean, vector_double& stddev, Mat mask = Mat())
//
//javadoc: meanStdDev(src, mean, stddev, mask)
public static void meanStdDev(Mat src, MatOfDouble mean, MatOfDouble stddev, Mat mask)
{
Mat mean_mat = mean;
Mat stddev_mat = stddev;
meanStdDev_0(src.nativeObj, mean_mat.nativeObj, stddev_mat.nativeObj, mask.nativeObj);
return;
}
//javadoc: meanStdDev(src, mean, stddev)
public static void meanStdDev(Mat src, MatOfDouble mean, MatOfDouble stddev)
{
Mat mean_mat = mean;
Mat stddev_mat = stddev;
meanStdDev_1(src.nativeObj, mean_mat.nativeObj, stddev_mat.nativeObj);
return;
}
//
// C++: void cv::merge(vector_Mat mv, Mat& dst)
//
//javadoc: merge(mv, dst)
public static void merge(List mv, Mat dst)
{
Mat mv_mat = Converters.vector_Mat_to_Mat(mv);
merge_0(mv_mat.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::min(Mat src1, Mat src2, Mat& dst)
//
//javadoc: min(src1, src2, dst)
public static void min(Mat src1, Mat src2, Mat dst)
{
min_0(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::min(Mat src1, Scalar src2, Mat& dst)
//
//javadoc: min(src1, src2, dst)
public static void min(Mat src1, Scalar src2, Mat dst)
{
min_1(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void cv::mixChannels(vector_Mat src, vector_Mat dst, vector_int fromTo)
//
//javadoc: mixChannels(src, dst, fromTo)
public static void mixChannels(List src, List dst, MatOfInt fromTo)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
Mat dst_mat = Converters.vector_Mat_to_Mat(dst);
Mat fromTo_mat = fromTo;
mixChannels_0(src_mat.nativeObj, dst_mat.nativeObj, fromTo_mat.nativeObj);
return;
}
//
// C++: void cv::mulSpectrums(Mat a, Mat b, Mat& c, int flags, bool conjB = false)
//
//javadoc: mulSpectrums(a, b, c, flags, conjB)
public static void mulSpectrums(Mat a, Mat b, Mat c, int flags, boolean conjB)
{
mulSpectrums_0(a.nativeObj, b.nativeObj, c.nativeObj, flags, conjB);
return;
}
//javadoc: mulSpectrums(a, b, c, flags)
public static void mulSpectrums(Mat a, Mat b, Mat c, int flags)
{
mulSpectrums_1(a.nativeObj, b.nativeObj, c.nativeObj, flags);
return;
}
//
// C++: void cv::mulTransposed(Mat src, Mat& dst, bool aTa, Mat delta = Mat(), double scale = 1, int dtype = -1)
//
//javadoc: mulTransposed(src, dst, aTa, delta, scale, dtype)
public static void mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta, double scale, int dtype)
{
mulTransposed_0(src.nativeObj, dst.nativeObj, aTa, delta.nativeObj, scale, dtype);
return;
}
//javadoc: mulTransposed(src, dst, aTa, delta, scale)
public static void mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta, double scale)
{
mulTransposed_1(src.nativeObj, dst.nativeObj, aTa, delta.nativeObj, scale);
return;
}
//javadoc: mulTransposed(src, dst, aTa, delta)
public static void mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta)
{
mulTransposed_2(src.nativeObj, dst.nativeObj, aTa, delta.nativeObj);
return;
}
//javadoc: mulTransposed(src, dst, aTa)
public static void mulTransposed(Mat src, Mat dst, boolean aTa)
{
mulTransposed_3(src.nativeObj, dst.nativeObj, aTa);
return;
}
//
// C++: void cv::multiply(Mat src1, Mat src2, Mat& dst, double scale = 1, int dtype = -1)
//
//javadoc: multiply(src1, src2, dst, scale, dtype)
public static void multiply(Mat src1, Mat src2, Mat dst, double scale, int dtype)
{
multiply_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, scale, dtype);
return;
}
//javadoc: multiply(src1, src2, dst, scale)
public static void multiply(Mat src1, Mat src2, Mat dst, double scale)
{
multiply_1(src1.nativeObj, src2.nativeObj, dst.nativeObj, scale);
return;
}
//javadoc: multiply(src1, src2, dst)
public static void multiply(Mat src1, Mat src2, Mat dst)
{
multiply_2(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::multiply(Mat src1, Scalar src2, Mat& dst, double scale = 1, int dtype = -1)
//
//javadoc: multiply(src1, src2, dst, scale, dtype)
public static void multiply(Mat src1, Scalar src2, Mat dst, double scale, int dtype)
{
multiply_3(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, scale, dtype);
return;
}
//javadoc: multiply(src1, src2, dst, scale)
public static void multiply(Mat src1, Scalar src2, Mat dst, double scale)
{
multiply_4(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, scale);
return;
}
//javadoc: multiply(src1, src2, dst)
public static void multiply(Mat src1, Scalar src2, Mat dst)
{
multiply_5(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void cv::normalize(Mat src, Mat& dst, double alpha = 1, double beta = 0, int norm_type = NORM_L2, int dtype = -1, Mat mask = Mat())
//
//javadoc: normalize(src, dst, alpha, beta, norm_type, dtype, mask)
public static void normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype, Mat mask)
{
normalize_0(src.nativeObj, dst.nativeObj, alpha, beta, norm_type, dtype, mask.nativeObj);
return;
}
//javadoc: normalize(src, dst, alpha, beta, norm_type, dtype)
public static void normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype)
{
normalize_1(src.nativeObj, dst.nativeObj, alpha, beta, norm_type, dtype);
return;
}
//javadoc: normalize(src, dst, alpha, beta, norm_type)
public static void normalize(Mat src, Mat dst, double alpha, double beta, int norm_type)
{
normalize_2(src.nativeObj, dst.nativeObj, alpha, beta, norm_type);
return;
}
//javadoc: normalize(src, dst, alpha, beta)
public static void normalize(Mat src, Mat dst, double alpha, double beta)
{
normalize_3(src.nativeObj, dst.nativeObj, alpha, beta);
return;
}
//javadoc: normalize(src, dst, alpha)
public static void normalize(Mat src, Mat dst, double alpha)
{
normalize_4(src.nativeObj, dst.nativeObj, alpha);
return;
}
//javadoc: normalize(src, dst)
public static void normalize(Mat src, Mat dst)
{
normalize_5(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::patchNaNs(Mat& a, double val = 0)
//
//javadoc: patchNaNs(a, val)
public static void patchNaNs(Mat a, double val)
{
patchNaNs_0(a.nativeObj, val);
return;
}
//javadoc: patchNaNs(a)
public static void patchNaNs(Mat a)
{
patchNaNs_1(a.nativeObj);
return;
}
//
// C++: void cv::perspectiveTransform(Mat src, Mat& dst, Mat m)
//
//javadoc: perspectiveTransform(src, dst, m)
public static void perspectiveTransform(Mat src, Mat dst, Mat m)
{
perspectiveTransform_0(src.nativeObj, dst.nativeObj, m.nativeObj);
return;
}
//
// C++: void cv::phase(Mat x, Mat y, Mat& angle, bool angleInDegrees = false)
//
//javadoc: phase(x, y, angle, angleInDegrees)
public static void phase(Mat x, Mat y, Mat angle, boolean angleInDegrees)
{
phase_0(x.nativeObj, y.nativeObj, angle.nativeObj, angleInDegrees);
return;
}
//javadoc: phase(x, y, angle)
public static void phase(Mat x, Mat y, Mat angle)
{
phase_1(x.nativeObj, y.nativeObj, angle.nativeObj);
return;
}
//
// C++: void cv::polarToCart(Mat magnitude, Mat angle, Mat& x, Mat& y, bool angleInDegrees = false)
//
//javadoc: polarToCart(magnitude, angle, x, y, angleInDegrees)
public static void polarToCart(Mat magnitude, Mat angle, Mat x, Mat y, boolean angleInDegrees)
{
polarToCart_0(magnitude.nativeObj, angle.nativeObj, x.nativeObj, y.nativeObj, angleInDegrees);
return;
}
//javadoc: polarToCart(magnitude, angle, x, y)
public static void polarToCart(Mat magnitude, Mat angle, Mat x, Mat y)
{
polarToCart_1(magnitude.nativeObj, angle.nativeObj, x.nativeObj, y.nativeObj);
return;
}
//
// C++: void cv::pow(Mat src, double power, Mat& dst)
//
//javadoc: pow(src, power, dst)
public static void pow(Mat src, double power, Mat dst)
{
pow_0(src.nativeObj, power, dst.nativeObj);
return;
}
//
// C++: void cv::randShuffle(Mat& dst, double iterFactor = 1., RNG* rng = 0)
//
//javadoc: randShuffle(dst, iterFactor)
public static void randShuffle(Mat dst, double iterFactor)
{
randShuffle_0(dst.nativeObj, iterFactor);
return;
}
//javadoc: randShuffle(dst)
public static void randShuffle(Mat dst)
{
randShuffle_2(dst.nativeObj);
return;
}
//
// C++: void cv::randn(Mat& dst, double mean, double stddev)
//
//javadoc: randn(dst, mean, stddev)
public static void randn(Mat dst, double mean, double stddev)
{
randn_0(dst.nativeObj, mean, stddev);
return;
}
//
// C++: void cv::randu(Mat& dst, double low, double high)
//
//javadoc: randu(dst, low, high)
public static void randu(Mat dst, double low, double high)
{
randu_0(dst.nativeObj, low, high);
return;
}
//
// C++: void cv::reduce(Mat src, Mat& dst, int dim, int rtype, int dtype = -1)
//
//javadoc: reduce(src, dst, dim, rtype, dtype)
public static void reduce(Mat src, Mat dst, int dim, int rtype, int dtype)
{
reduce_0(src.nativeObj, dst.nativeObj, dim, rtype, dtype);
return;
}
//javadoc: reduce(src, dst, dim, rtype)
public static void reduce(Mat src, Mat dst, int dim, int rtype)
{
reduce_1(src.nativeObj, dst.nativeObj, dim, rtype);
return;
}
//
// C++: void cv::repeat(Mat src, int ny, int nx, Mat& dst)
//
//javadoc: repeat(src, ny, nx, dst)
public static void repeat(Mat src, int ny, int nx, Mat dst)
{
repeat_0(src.nativeObj, ny, nx, dst.nativeObj);
return;
}
//
// C++: void cv::rotate(Mat src, Mat& dst, int rotateCode)
//
//javadoc: rotate(src, dst, rotateCode)
public static void rotate(Mat src, Mat dst, int rotateCode)
{
rotate_0(src.nativeObj, dst.nativeObj, rotateCode);
return;
}
//
// C++: void cv::scaleAdd(Mat src1, double alpha, Mat src2, Mat& dst)
//
//javadoc: scaleAdd(src1, alpha, src2, dst)
public static void scaleAdd(Mat src1, double alpha, Mat src2, Mat dst)
{
scaleAdd_0(src1.nativeObj, alpha, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::setErrorVerbosity(bool verbose)
//
//javadoc: setErrorVerbosity(verbose)
public static void setErrorVerbosity(boolean verbose)
{
setErrorVerbosity_0(verbose);
return;
}
//
// C++: void cv::setIdentity(Mat& mtx, Scalar s = Scalar(1))
//
//javadoc: setIdentity(mtx, s)
public static void setIdentity(Mat mtx, Scalar s)
{
setIdentity_0(mtx.nativeObj, s.val[0], s.val[1], s.val[2], s.val[3]);
return;
}
//javadoc: setIdentity(mtx)
public static void setIdentity(Mat mtx)
{
setIdentity_1(mtx.nativeObj);
return;
}
//
// C++: void cv::setNumThreads(int nthreads)
//
//javadoc: setNumThreads(nthreads)
public static void setNumThreads(int nthreads)
{
setNumThreads_0(nthreads);
return;
}
//
// C++: void cv::setRNGSeed(int seed)
//
//javadoc: setRNGSeed(seed)
public static void setRNGSeed(int seed)
{
setRNGSeed_0(seed);
return;
}
//
// C++: void cv::sort(Mat src, Mat& dst, int flags)
//
//javadoc: sort(src, dst, flags)
public static void sort(Mat src, Mat dst, int flags)
{
sort_0(src.nativeObj, dst.nativeObj, flags);
return;
}
//
// C++: void cv::sortIdx(Mat src, Mat& dst, int flags)
//
//javadoc: sortIdx(src, dst, flags)
public static void sortIdx(Mat src, Mat dst, int flags)
{
sortIdx_0(src.nativeObj, dst.nativeObj, flags);
return;
}
//
// C++: void cv::split(Mat m, vector_Mat& mv)
//
//javadoc: split(m, mv)
public static void split(Mat m, List mv)
{
Mat mv_mat = new Mat();
split_0(m.nativeObj, mv_mat.nativeObj);
Converters.Mat_to_vector_Mat(mv_mat, mv);
mv_mat.release();
return;
}
//
// C++: void cv::sqrt(Mat src, Mat& dst)
//
//javadoc: sqrt(src, dst)
public static void sqrt(Mat src, Mat dst)
{
sqrt_0(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::subtract(Mat src1, Mat src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
//
//javadoc: subtract(src1, src2, dst, mask, dtype)
public static void subtract(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)
{
subtract_0(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj, dtype);
return;
}
//javadoc: subtract(src1, src2, dst, mask)
public static void subtract(Mat src1, Mat src2, Mat dst, Mat mask)
{
subtract_1(src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: subtract(src1, src2, dst)
public static void subtract(Mat src1, Mat src2, Mat dst)
{
subtract_2(src1.nativeObj, src2.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::subtract(Mat src1, Scalar src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
//
//javadoc: subtract(src1, src2, dst, mask, dtype)
public static void subtract(Mat src1, Scalar src2, Mat dst, Mat mask, int dtype)
{
subtract_3(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, mask.nativeObj, dtype);
return;
}
//javadoc: subtract(src1, src2, dst, mask)
public static void subtract(Mat src1, Scalar src2, Mat dst, Mat mask)
{
subtract_4(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj, mask.nativeObj);
return;
}
//javadoc: subtract(src1, src2, dst)
public static void subtract(Mat src1, Scalar src2, Mat dst)
{
subtract_5(src1.nativeObj, src2.val[0], src2.val[1], src2.val[2], src2.val[3], dst.nativeObj);
return;
}
//
// C++: void cv::transform(Mat src, Mat& dst, Mat m)
//
//javadoc: transform(src, dst, m)
public static void transform(Mat src, Mat dst, Mat m)
{
transform_0(src.nativeObj, dst.nativeObj, m.nativeObj);
return;
}
//
// C++: void cv::transpose(Mat src, Mat& dst)
//
//javadoc: transpose(src, dst)
public static void transpose(Mat src, Mat dst)
{
transpose_0(src.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::vconcat(vector_Mat src, Mat& dst)
//
//javadoc: vconcat(src, dst)
public static void vconcat(List src, Mat dst)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
vconcat_0(src_mat.nativeObj, dst.nativeObj);
return;
}
//
// C++: void cv::ipp::setUseIPP(bool flag)
//
//javadoc: setUseIPP(flag)
public static void setUseIPP(boolean flag)
{
setUseIPP_0(flag);
return;
}
//
// C++: void cv::ipp::setUseIPP_NE(bool flag)
//
//javadoc: setUseIPP_NE(flag)
public static void setUseIPP_NE(boolean flag)
{
setUseIPP_NE_0(flag);
return;
}
//
// C++: void cv::ipp::setUseIPP_NotExact(bool flag)
//
//javadoc: setUseIPP_NotExact(flag)
public static void setUseIPP_NotExact(boolean flag)
{
setUseIPP_NotExact_0(flag);
return;
}
//
// C++: void cv::samples::addSamplesDataSearchPath(String path)
//
//javadoc: addSamplesDataSearchPath(path)
public static void addSamplesDataSearchPath(String path)
{
addSamplesDataSearchPath_0(path);
return;
}
//
// C++: void cv::samples::addSamplesDataSearchSubDirectory(String subdir)
//
//javadoc: addSamplesDataSearchSubDirectory(subdir)
public static void addSamplesDataSearchSubDirectory(String subdir)
{
addSamplesDataSearchSubDirectory_0(subdir);
return;
}
// manual port
public static class MinMaxLocResult {
public double minVal;
public double maxVal;
public Point minLoc;
public Point maxLoc;
public MinMaxLocResult() {
minVal=0; maxVal=0;
minLoc=new Point();
maxLoc=new Point();
}
}
// C++: minMaxLoc(Mat src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, InputArray mask=noArray())
//javadoc: minMaxLoc(src, mask)
public static MinMaxLocResult minMaxLoc(Mat src, Mat mask) {
MinMaxLocResult res = new MinMaxLocResult();
long maskNativeObj=0;
if (mask != null) {
maskNativeObj=mask.nativeObj;
}
double resarr[] = n_minMaxLocManual(src.nativeObj, maskNativeObj);
res.minVal=resarr[0];
res.maxVal=resarr[1];
res.minLoc.x=resarr[2];
res.minLoc.y=resarr[3];
res.maxLoc.x=resarr[4];
res.maxLoc.y=resarr[5];
return res;
}
//javadoc: minMaxLoc(src)
public static MinMaxLocResult minMaxLoc(Mat src) {
return minMaxLoc(src, null);
}
// C++: Scalar cv::mean(Mat src, Mat mask = Mat())
private static native double[] mean_0(long src_nativeObj, long mask_nativeObj);
private static native double[] mean_1(long src_nativeObj);
// C++: Scalar cv::sum(Mat src)
private static native double[] sumElems_0(long src_nativeObj);
// C++: Scalar cv::trace(Mat mtx)
private static native double[] trace_0(long mtx_nativeObj);
// C++: String cv::getBuildInformation()
private static native String getBuildInformation_0();
// C++: String cv::getHardwareFeatureName(int feature)
private static native String getHardwareFeatureName_0(int feature);
// C++: String cv::getVersionString()
private static native String getVersionString_0();
// C++: String cv::ipp::getIppVersion()
private static native String getIppVersion_0();
// C++: String cv::samples::findFile(String relative_path, bool required = true, bool silentMode = false)
private static native String findFile_0(String relative_path, boolean required, boolean silentMode);
private static native String findFile_1(String relative_path, boolean required);
private static native String findFile_2(String relative_path);
// C++: String cv::samples::findFileOrKeep(String relative_path, bool silentMode = false)
private static native String findFileOrKeep_0(String relative_path, boolean silentMode);
private static native String findFileOrKeep_1(String relative_path);
// C++: bool cv::checkRange(Mat a, bool quiet = true, _hidden_ * pos = 0, double minVal = -DBL_MAX, double maxVal = DBL_MAX)
private static native boolean checkRange_0(long a_nativeObj, boolean quiet, double minVal, double maxVal);
private static native boolean checkRange_1(long a_nativeObj, boolean quiet, double minVal);
private static native boolean checkRange_2(long a_nativeObj, boolean quiet);
private static native boolean checkRange_4(long a_nativeObj);
// C++: bool cv::eigen(Mat src, Mat& eigenvalues, Mat& eigenvectors = Mat())
private static native boolean eigen_0(long src_nativeObj, long eigenvalues_nativeObj, long eigenvectors_nativeObj);
private static native boolean eigen_1(long src_nativeObj, long eigenvalues_nativeObj);
// C++: bool cv::solve(Mat src1, Mat src2, Mat& dst, int flags = DECOMP_LU)
private static native boolean solve_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, int flags);
private static native boolean solve_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: bool cv::ipp::useIPP()
private static native boolean useIPP_0();
// C++: bool cv::ipp::useIPP_NE()
private static native boolean useIPP_NE_0();
// C++: bool cv::ipp::useIPP_NotExact()
private static native boolean useIPP_NotExact_0();
// C++: double cv::Mahalanobis(Mat v1, Mat v2, Mat icovar)
private static native double Mahalanobis_0(long v1_nativeObj, long v2_nativeObj, long icovar_nativeObj);
// C++: double cv::PSNR(Mat src1, Mat src2)
private static native double PSNR_0(long src1_nativeObj, long src2_nativeObj);
// C++: double cv::determinant(Mat mtx)
private static native double determinant_0(long mtx_nativeObj);
// C++: double cv::getTickFrequency()
private static native double getTickFrequency_0();
// C++: double cv::invert(Mat src, Mat& dst, int flags = DECOMP_LU)
private static native double invert_0(long src_nativeObj, long dst_nativeObj, int flags);
private static native double invert_1(long src_nativeObj, long dst_nativeObj);
// C++: double cv::kmeans(Mat data, int K, Mat& bestLabels, TermCriteria criteria, int attempts, int flags, Mat& centers = Mat())
private static native double kmeans_0(long data_nativeObj, int K, long bestLabels_nativeObj, int criteria_type, int criteria_maxCount, double criteria_epsilon, int attempts, int flags, long centers_nativeObj);
private static native double kmeans_1(long data_nativeObj, int K, long bestLabels_nativeObj, int criteria_type, int criteria_maxCount, double criteria_epsilon, int attempts, int flags);
// C++: double cv::norm(Mat src1, Mat src2, int normType = NORM_L2, Mat mask = Mat())
private static native double norm_0(long src1_nativeObj, long src2_nativeObj, int normType, long mask_nativeObj);
private static native double norm_1(long src1_nativeObj, long src2_nativeObj, int normType);
private static native double norm_2(long src1_nativeObj, long src2_nativeObj);
// C++: double cv::norm(Mat src1, int normType = NORM_L2, Mat mask = Mat())
private static native double norm_3(long src1_nativeObj, int normType, long mask_nativeObj);
private static native double norm_4(long src1_nativeObj, int normType);
private static native double norm_5(long src1_nativeObj);
// C++: double cv::solvePoly(Mat coeffs, Mat& roots, int maxIters = 300)
private static native double solvePoly_0(long coeffs_nativeObj, long roots_nativeObj, int maxIters);
private static native double solvePoly_1(long coeffs_nativeObj, long roots_nativeObj);
// C++: float cv::cubeRoot(float val)
private static native float cubeRoot_0(float val);
// C++: float cv::fastAtan2(float y, float x)
private static native float fastAtan2_0(float y, float x);
// C++: int cv::borderInterpolate(int p, int len, int borderType)
private static native int borderInterpolate_0(int p, int len, int borderType);
// C++: int cv::countNonZero(Mat src)
private static native int countNonZero_0(long src_nativeObj);
// C++: int cv::getNumThreads()
private static native int getNumThreads_0();
// C++: int cv::getNumberOfCPUs()
private static native int getNumberOfCPUs_0();
// C++: int cv::getOptimalDFTSize(int vecsize)
private static native int getOptimalDFTSize_0(int vecsize);
// C++: int cv::getThreadNum()
private static native int getThreadNum_0();
// C++: int cv::getVersionMajor()
private static native int getVersionMajor_0();
// C++: int cv::getVersionMinor()
private static native int getVersionMinor_0();
// C++: int cv::getVersionRevision()
private static native int getVersionRevision_0();
// C++: int cv::solveCubic(Mat coeffs, Mat& roots)
private static native int solveCubic_0(long coeffs_nativeObj, long roots_nativeObj);
// C++: int64 cv::getCPUTickCount()
private static native long getCPUTickCount_0();
// C++: int64 cv::getTickCount()
private static native long getTickCount_0();
// C++: void cv::LUT(Mat src, Mat lut, Mat& dst)
private static native void LUT_0(long src_nativeObj, long lut_nativeObj, long dst_nativeObj);
// C++: void cv::PCABackProject(Mat data, Mat mean, Mat eigenvectors, Mat& result)
private static native void PCABackProject_0(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, long result_nativeObj);
// C++: void cv::PCACompute(Mat data, Mat& mean, Mat& eigenvectors, Mat& eigenvalues, double retainedVariance)
private static native void PCACompute2_0(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, long eigenvalues_nativeObj, double retainedVariance);
// C++: void cv::PCACompute(Mat data, Mat& mean, Mat& eigenvectors, Mat& eigenvalues, int maxComponents = 0)
private static native void PCACompute2_1(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, long eigenvalues_nativeObj, int maxComponents);
private static native void PCACompute2_2(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, long eigenvalues_nativeObj);
// C++: void cv::PCACompute(Mat data, Mat& mean, Mat& eigenvectors, double retainedVariance)
private static native void PCACompute_0(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, double retainedVariance);
// C++: void cv::PCACompute(Mat data, Mat& mean, Mat& eigenvectors, int maxComponents = 0)
private static native void PCACompute_1(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, int maxComponents);
private static native void PCACompute_2(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj);
// C++: void cv::PCAProject(Mat data, Mat mean, Mat eigenvectors, Mat& result)
private static native void PCAProject_0(long data_nativeObj, long mean_nativeObj, long eigenvectors_nativeObj, long result_nativeObj);
// C++: void cv::SVBackSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat& dst)
private static native void SVBackSubst_0(long w_nativeObj, long u_nativeObj, long vt_nativeObj, long rhs_nativeObj, long dst_nativeObj);
// C++: void cv::SVDecomp(Mat src, Mat& w, Mat& u, Mat& vt, int flags = 0)
private static native void SVDecomp_0(long src_nativeObj, long w_nativeObj, long u_nativeObj, long vt_nativeObj, int flags);
private static native void SVDecomp_1(long src_nativeObj, long w_nativeObj, long u_nativeObj, long vt_nativeObj);
// C++: void cv::absdiff(Mat src1, Mat src2, Mat& dst)
private static native void absdiff_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void cv::absdiff(Mat src1, Scalar src2, Mat& dst)
private static native void absdiff_1(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void cv::add(Mat src1, Mat src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
private static native void add_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj, int dtype);
private static native void add_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void add_2(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void cv::add(Mat src1, Scalar src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
private static native void add_3(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, long mask_nativeObj, int dtype);
private static native void add_4(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, long mask_nativeObj);
private static native void add_5(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void cv::addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat& dst, int dtype = -1)
private static native void addWeighted_0(long src1_nativeObj, double alpha, long src2_nativeObj, double beta, double gamma, long dst_nativeObj, int dtype);
private static native void addWeighted_1(long src1_nativeObj, double alpha, long src2_nativeObj, double beta, double gamma, long dst_nativeObj);
// C++: void cv::batchDistance(Mat src1, Mat src2, Mat& dist, int dtype, Mat& nidx, int normType = NORM_L2, int K = 0, Mat mask = Mat(), int update = 0, bool crosscheck = false)
private static native void batchDistance_0(long src1_nativeObj, long src2_nativeObj, long dist_nativeObj, int dtype, long nidx_nativeObj, int normType, int K, long mask_nativeObj, int update, boolean crosscheck);
private static native void batchDistance_1(long src1_nativeObj, long src2_nativeObj, long dist_nativeObj, int dtype, long nidx_nativeObj, int normType, int K, long mask_nativeObj, int update);
private static native void batchDistance_2(long src1_nativeObj, long src2_nativeObj, long dist_nativeObj, int dtype, long nidx_nativeObj, int normType, int K, long mask_nativeObj);
private static native void batchDistance_3(long src1_nativeObj, long src2_nativeObj, long dist_nativeObj, int dtype, long nidx_nativeObj, int normType, int K);
private static native void batchDistance_4(long src1_nativeObj, long src2_nativeObj, long dist_nativeObj, int dtype, long nidx_nativeObj, int normType);
private static native void batchDistance_5(long src1_nativeObj, long src2_nativeObj, long dist_nativeObj, int dtype, long nidx_nativeObj);
// C++: void cv::bitwise_and(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
private static native void bitwise_and_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void bitwise_and_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void cv::bitwise_not(Mat src, Mat& dst, Mat mask = Mat())
private static native void bitwise_not_0(long src_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void bitwise_not_1(long src_nativeObj, long dst_nativeObj);
// C++: void cv::bitwise_or(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
private static native void bitwise_or_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void bitwise_or_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void cv::bitwise_xor(Mat src1, Mat src2, Mat& dst, Mat mask = Mat())
private static native void bitwise_xor_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void bitwise_xor_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void cv::calcCovarMatrix(Mat samples, Mat& covar, Mat& mean, int flags, int ctype = CV_64F)
private static native void calcCovarMatrix_0(long samples_nativeObj, long covar_nativeObj, long mean_nativeObj, int flags, int ctype);
private static native void calcCovarMatrix_1(long samples_nativeObj, long covar_nativeObj, long mean_nativeObj, int flags);
// C++: void cv::cartToPolar(Mat x, Mat y, Mat& magnitude, Mat& angle, bool angleInDegrees = false)
private static native void cartToPolar_0(long x_nativeObj, long y_nativeObj, long magnitude_nativeObj, long angle_nativeObj, boolean angleInDegrees);
private static native void cartToPolar_1(long x_nativeObj, long y_nativeObj, long magnitude_nativeObj, long angle_nativeObj);
// C++: void cv::compare(Mat src1, Mat src2, Mat& dst, int cmpop)
private static native void compare_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, int cmpop);
// C++: void cv::compare(Mat src1, Scalar src2, Mat& dst, int cmpop)
private static native void compare_1(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, int cmpop);
// C++: void cv::completeSymm(Mat& m, bool lowerToUpper = false)
private static native void completeSymm_0(long m_nativeObj, boolean lowerToUpper);
private static native void completeSymm_1(long m_nativeObj);
// C++: void cv::convertFp16(Mat src, Mat& dst)
private static native void convertFp16_0(long src_nativeObj, long dst_nativeObj);
// C++: void cv::convertScaleAbs(Mat src, Mat& dst, double alpha = 1, double beta = 0)
private static native void convertScaleAbs_0(long src_nativeObj, long dst_nativeObj, double alpha, double beta);
private static native void convertScaleAbs_1(long src_nativeObj, long dst_nativeObj, double alpha);
private static native void convertScaleAbs_2(long src_nativeObj, long dst_nativeObj);
// C++: void cv::copyMakeBorder(Mat src, Mat& dst, int top, int bottom, int left, int right, int borderType, Scalar value = Scalar())
private static native void copyMakeBorder_0(long src_nativeObj, long dst_nativeObj, int top, int bottom, int left, int right, int borderType, double value_val0, double value_val1, double value_val2, double value_val3);
private static native void copyMakeBorder_1(long src_nativeObj, long dst_nativeObj, int top, int bottom, int left, int right, int borderType);
// C++: void cv::dct(Mat src, Mat& dst, int flags = 0)
private static native void dct_0(long src_nativeObj, long dst_nativeObj, int flags);
private static native void dct_1(long src_nativeObj, long dst_nativeObj);
// C++: void cv::dft(Mat src, Mat& dst, int flags = 0, int nonzeroRows = 0)
private static native void dft_0(long src_nativeObj, long dst_nativeObj, int flags, int nonzeroRows);
private static native void dft_1(long src_nativeObj, long dst_nativeObj, int flags);
private static native void dft_2(long src_nativeObj, long dst_nativeObj);
// C++: void cv::divide(Mat src1, Mat src2, Mat& dst, double scale = 1, int dtype = -1)
private static native void divide_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, double scale, int dtype);
private static native void divide_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, double scale);
private static native void divide_2(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void cv::divide(Mat src1, Scalar src2, Mat& dst, double scale = 1, int dtype = -1)
private static native void divide_3(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, double scale, int dtype);
private static native void divide_4(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, double scale);
private static native void divide_5(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void cv::divide(double scale, Mat src2, Mat& dst, int dtype = -1)
private static native void divide_6(double scale, long src2_nativeObj, long dst_nativeObj, int dtype);
private static native void divide_7(double scale, long src2_nativeObj, long dst_nativeObj);
// C++: void cv::eigenNonSymmetric(Mat src, Mat& eigenvalues, Mat& eigenvectors)
private static native void eigenNonSymmetric_0(long src_nativeObj, long eigenvalues_nativeObj, long eigenvectors_nativeObj);
// C++: void cv::exp(Mat src, Mat& dst)
private static native void exp_0(long src_nativeObj, long dst_nativeObj);
// C++: void cv::extractChannel(Mat src, Mat& dst, int coi)
private static native void extractChannel_0(long src_nativeObj, long dst_nativeObj, int coi);
// C++: void cv::findNonZero(Mat src, Mat& idx)
private static native void findNonZero_0(long src_nativeObj, long idx_nativeObj);
// C++: void cv::flip(Mat src, Mat& dst, int flipCode)
private static native void flip_0(long src_nativeObj, long dst_nativeObj, int flipCode);
// C++: void cv::gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat& dst, int flags = 0)
private static native void gemm_0(long src1_nativeObj, long src2_nativeObj, double alpha, long src3_nativeObj, double beta, long dst_nativeObj, int flags);
private static native void gemm_1(long src1_nativeObj, long src2_nativeObj, double alpha, long src3_nativeObj, double beta, long dst_nativeObj);
// C++: void cv::hconcat(vector_Mat src, Mat& dst)
private static native void hconcat_0(long src_mat_nativeObj, long dst_nativeObj);
// C++: void cv::idct(Mat src, Mat& dst, int flags = 0)
private static native void idct_0(long src_nativeObj, long dst_nativeObj, int flags);
private static native void idct_1(long src_nativeObj, long dst_nativeObj);
// C++: void cv::idft(Mat src, Mat& dst, int flags = 0, int nonzeroRows = 0)
private static native void idft_0(long src_nativeObj, long dst_nativeObj, int flags, int nonzeroRows);
private static native void idft_1(long src_nativeObj, long dst_nativeObj, int flags);
private static native void idft_2(long src_nativeObj, long dst_nativeObj);
// C++: void cv::inRange(Mat src, Scalar lowerb, Scalar upperb, Mat& dst)
private static native void inRange_0(long src_nativeObj, double lowerb_val0, double lowerb_val1, double lowerb_val2, double lowerb_val3, double upperb_val0, double upperb_val1, double upperb_val2, double upperb_val3, long dst_nativeObj);
// C++: void cv::insertChannel(Mat src, Mat& dst, int coi)
private static native void insertChannel_0(long src_nativeObj, long dst_nativeObj, int coi);
// C++: void cv::log(Mat src, Mat& dst)
private static native void log_0(long src_nativeObj, long dst_nativeObj);
// C++: void cv::magnitude(Mat x, Mat y, Mat& magnitude)
private static native void magnitude_0(long x_nativeObj, long y_nativeObj, long magnitude_nativeObj);
// C++: void cv::max(Mat src1, Mat src2, Mat& dst)
private static native void max_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void cv::max(Mat src1, Scalar src2, Mat& dst)
private static native void max_1(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void cv::meanStdDev(Mat src, vector_double& mean, vector_double& stddev, Mat mask = Mat())
private static native void meanStdDev_0(long src_nativeObj, long mean_mat_nativeObj, long stddev_mat_nativeObj, long mask_nativeObj);
private static native void meanStdDev_1(long src_nativeObj, long mean_mat_nativeObj, long stddev_mat_nativeObj);
// C++: void cv::merge(vector_Mat mv, Mat& dst)
private static native void merge_0(long mv_mat_nativeObj, long dst_nativeObj);
// C++: void cv::min(Mat src1, Mat src2, Mat& dst)
private static native void min_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void cv::min(Mat src1, Scalar src2, Mat& dst)
private static native void min_1(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void cv::mixChannels(vector_Mat src, vector_Mat dst, vector_int fromTo)
private static native void mixChannels_0(long src_mat_nativeObj, long dst_mat_nativeObj, long fromTo_mat_nativeObj);
// C++: void cv::mulSpectrums(Mat a, Mat b, Mat& c, int flags, bool conjB = false)
private static native void mulSpectrums_0(long a_nativeObj, long b_nativeObj, long c_nativeObj, int flags, boolean conjB);
private static native void mulSpectrums_1(long a_nativeObj, long b_nativeObj, long c_nativeObj, int flags);
// C++: void cv::mulTransposed(Mat src, Mat& dst, bool aTa, Mat delta = Mat(), double scale = 1, int dtype = -1)
private static native void mulTransposed_0(long src_nativeObj, long dst_nativeObj, boolean aTa, long delta_nativeObj, double scale, int dtype);
private static native void mulTransposed_1(long src_nativeObj, long dst_nativeObj, boolean aTa, long delta_nativeObj, double scale);
private static native void mulTransposed_2(long src_nativeObj, long dst_nativeObj, boolean aTa, long delta_nativeObj);
private static native void mulTransposed_3(long src_nativeObj, long dst_nativeObj, boolean aTa);
// C++: void cv::multiply(Mat src1, Mat src2, Mat& dst, double scale = 1, int dtype = -1)
private static native void multiply_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, double scale, int dtype);
private static native void multiply_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, double scale);
private static native void multiply_2(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void cv::multiply(Mat src1, Scalar src2, Mat& dst, double scale = 1, int dtype = -1)
private static native void multiply_3(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, double scale, int dtype);
private static native void multiply_4(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, double scale);
private static native void multiply_5(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void cv::normalize(Mat src, Mat& dst, double alpha = 1, double beta = 0, int norm_type = NORM_L2, int dtype = -1, Mat mask = Mat())
private static native void normalize_0(long src_nativeObj, long dst_nativeObj, double alpha, double beta, int norm_type, int dtype, long mask_nativeObj);
private static native void normalize_1(long src_nativeObj, long dst_nativeObj, double alpha, double beta, int norm_type, int dtype);
private static native void normalize_2(long src_nativeObj, long dst_nativeObj, double alpha, double beta, int norm_type);
private static native void normalize_3(long src_nativeObj, long dst_nativeObj, double alpha, double beta);
private static native void normalize_4(long src_nativeObj, long dst_nativeObj, double alpha);
private static native void normalize_5(long src_nativeObj, long dst_nativeObj);
// C++: void cv::patchNaNs(Mat& a, double val = 0)
private static native void patchNaNs_0(long a_nativeObj, double val);
private static native void patchNaNs_1(long a_nativeObj);
// C++: void cv::perspectiveTransform(Mat src, Mat& dst, Mat m)
private static native void perspectiveTransform_0(long src_nativeObj, long dst_nativeObj, long m_nativeObj);
// C++: void cv::phase(Mat x, Mat y, Mat& angle, bool angleInDegrees = false)
private static native void phase_0(long x_nativeObj, long y_nativeObj, long angle_nativeObj, boolean angleInDegrees);
private static native void phase_1(long x_nativeObj, long y_nativeObj, long angle_nativeObj);
// C++: void cv::polarToCart(Mat magnitude, Mat angle, Mat& x, Mat& y, bool angleInDegrees = false)
private static native void polarToCart_0(long magnitude_nativeObj, long angle_nativeObj, long x_nativeObj, long y_nativeObj, boolean angleInDegrees);
private static native void polarToCart_1(long magnitude_nativeObj, long angle_nativeObj, long x_nativeObj, long y_nativeObj);
// C++: void cv::pow(Mat src, double power, Mat& dst)
private static native void pow_0(long src_nativeObj, double power, long dst_nativeObj);
// C++: void cv::randShuffle(Mat& dst, double iterFactor = 1., RNG* rng = 0)
private static native void randShuffle_0(long dst_nativeObj, double iterFactor);
private static native void randShuffle_2(long dst_nativeObj);
// C++: void cv::randn(Mat& dst, double mean, double stddev)
private static native void randn_0(long dst_nativeObj, double mean, double stddev);
// C++: void cv::randu(Mat& dst, double low, double high)
private static native void randu_0(long dst_nativeObj, double low, double high);
// C++: void cv::reduce(Mat src, Mat& dst, int dim, int rtype, int dtype = -1)
private static native void reduce_0(long src_nativeObj, long dst_nativeObj, int dim, int rtype, int dtype);
private static native void reduce_1(long src_nativeObj, long dst_nativeObj, int dim, int rtype);
// C++: void cv::repeat(Mat src, int ny, int nx, Mat& dst)
private static native void repeat_0(long src_nativeObj, int ny, int nx, long dst_nativeObj);
// C++: void cv::rotate(Mat src, Mat& dst, int rotateCode)
private static native void rotate_0(long src_nativeObj, long dst_nativeObj, int rotateCode);
// C++: void cv::scaleAdd(Mat src1, double alpha, Mat src2, Mat& dst)
private static native void scaleAdd_0(long src1_nativeObj, double alpha, long src2_nativeObj, long dst_nativeObj);
// C++: void cv::setErrorVerbosity(bool verbose)
private static native void setErrorVerbosity_0(boolean verbose);
// C++: void cv::setIdentity(Mat& mtx, Scalar s = Scalar(1))
private static native void setIdentity_0(long mtx_nativeObj, double s_val0, double s_val1, double s_val2, double s_val3);
private static native void setIdentity_1(long mtx_nativeObj);
// C++: void cv::setNumThreads(int nthreads)
private static native void setNumThreads_0(int nthreads);
// C++: void cv::setRNGSeed(int seed)
private static native void setRNGSeed_0(int seed);
// C++: void cv::sort(Mat src, Mat& dst, int flags)
private static native void sort_0(long src_nativeObj, long dst_nativeObj, int flags);
// C++: void cv::sortIdx(Mat src, Mat& dst, int flags)
private static native void sortIdx_0(long src_nativeObj, long dst_nativeObj, int flags);
// C++: void cv::split(Mat m, vector_Mat& mv)
private static native void split_0(long m_nativeObj, long mv_mat_nativeObj);
// C++: void cv::sqrt(Mat src, Mat& dst)
private static native void sqrt_0(long src_nativeObj, long dst_nativeObj);
// C++: void cv::subtract(Mat src1, Mat src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
private static native void subtract_0(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj, int dtype);
private static native void subtract_1(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj, long mask_nativeObj);
private static native void subtract_2(long src1_nativeObj, long src2_nativeObj, long dst_nativeObj);
// C++: void cv::subtract(Mat src1, Scalar src2, Mat& dst, Mat mask = Mat(), int dtype = -1)
private static native void subtract_3(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, long mask_nativeObj, int dtype);
private static native void subtract_4(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj, long mask_nativeObj);
private static native void subtract_5(long src1_nativeObj, double src2_val0, double src2_val1, double src2_val2, double src2_val3, long dst_nativeObj);
// C++: void cv::transform(Mat src, Mat& dst, Mat m)
private static native void transform_0(long src_nativeObj, long dst_nativeObj, long m_nativeObj);
// C++: void cv::transpose(Mat src, Mat& dst)
private static native void transpose_0(long src_nativeObj, long dst_nativeObj);
// C++: void cv::vconcat(vector_Mat src, Mat& dst)
private static native void vconcat_0(long src_mat_nativeObj, long dst_nativeObj);
// C++: void cv::ipp::setUseIPP(bool flag)
private static native void setUseIPP_0(boolean flag);
// C++: void cv::ipp::setUseIPP_NE(bool flag)
private static native void setUseIPP_NE_0(boolean flag);
// C++: void cv::ipp::setUseIPP_NotExact(bool flag)
private static native void setUseIPP_NotExact_0(boolean flag);
// C++: void cv::samples::addSamplesDataSearchPath(String path)
private static native void addSamplesDataSearchPath_0(String path);
// C++: void cv::samples::addSamplesDataSearchSubDirectory(String subdir)
private static native void addSamplesDataSearchSubDirectory_0(String subdir);
private static native double[] n_minMaxLocManual(long src_nativeObj, long mask_nativeObj);
}
================================================
FILE: openCV/src/main/java/org/opencv/core/CvException.java
================================================
package org.opencv.core;
public class CvException extends RuntimeException {
private static final long serialVersionUID = 1L;
public CvException(String msg) {
super(msg);
}
@Override
public String toString() {
return "CvException [" + super.toString() + "]";
}
}
================================================
FILE: openCV/src/main/java/org/opencv/core/CvType.java
================================================
package org.opencv.core;
public final class CvType {
// type depth constants
public static final int
CV_8U = 0, CV_8S = 1,
CV_16U = 2, CV_16S = 3,
CV_32S = 4,
CV_32F = 5,
CV_64F = 6,
CV_USRTYPE1 = 7;
// predefined type constants
public static final int
CV_8UC1 = CV_8UC(1), CV_8UC2 = CV_8UC(2), CV_8UC3 = CV_8UC(3), CV_8UC4 = CV_8UC(4),
CV_8SC1 = CV_8SC(1), CV_8SC2 = CV_8SC(2), CV_8SC3 = CV_8SC(3), CV_8SC4 = CV_8SC(4),
CV_16UC1 = CV_16UC(1), CV_16UC2 = CV_16UC(2), CV_16UC3 = CV_16UC(3), CV_16UC4 = CV_16UC(4),
CV_16SC1 = CV_16SC(1), CV_16SC2 = CV_16SC(2), CV_16SC3 = CV_16SC(3), CV_16SC4 = CV_16SC(4),
CV_32SC1 = CV_32SC(1), CV_32SC2 = CV_32SC(2), CV_32SC3 = CV_32SC(3), CV_32SC4 = CV_32SC(4),
CV_32FC1 = CV_32FC(1), CV_32FC2 = CV_32FC(2), CV_32FC3 = CV_32FC(3), CV_32FC4 = CV_32FC(4),
CV_64FC1 = CV_64FC(1), CV_64FC2 = CV_64FC(2), CV_64FC3 = CV_64FC(3), CV_64FC4 = CV_64FC(4);
private static final int CV_CN_MAX = 512, CV_CN_SHIFT = 3, CV_DEPTH_MAX = (1 << CV_CN_SHIFT);
public static final int makeType(int depth, int channels) {
if (channels <= 0 || channels >= CV_CN_MAX) {
throw new java.lang.UnsupportedOperationException(
"Channels count should be 1.." + (CV_CN_MAX - 1));
}
if (depth < 0 || depth >= CV_DEPTH_MAX) {
throw new java.lang.UnsupportedOperationException(
"Data type depth should be 0.." + (CV_DEPTH_MAX - 1));
}
return (depth & (CV_DEPTH_MAX - 1)) + ((channels - 1) << CV_CN_SHIFT);
}
public static final int CV_8UC(int ch) {
return makeType(CV_8U, ch);
}
public static final int CV_8SC(int ch) {
return makeType(CV_8S, ch);
}
public static final int CV_16UC(int ch) {
return makeType(CV_16U, ch);
}
public static final int CV_16SC(int ch) {
return makeType(CV_16S, ch);
}
public static final int CV_32SC(int ch) {
return makeType(CV_32S, ch);
}
public static final int CV_32FC(int ch) {
return makeType(CV_32F, ch);
}
public static final int CV_64FC(int ch) {
return makeType(CV_64F, ch);
}
public static final int channels(int type) {
return (type >> CV_CN_SHIFT) + 1;
}
public static final int depth(int type) {
return type & (CV_DEPTH_MAX - 1);
}
public static final boolean isInteger(int type) {
return depth(type) < CV_32F;
}
public static final int ELEM_SIZE(int type) {
switch (depth(type)) {
case CV_8U:
case CV_8S:
return channels(type);
case CV_16U:
case CV_16S:
return 2 * channels(type);
case CV_32S:
case CV_32F:
return 4 * channels(type);
case CV_64F:
return 8 * channels(type);
default:
throw new java.lang.UnsupportedOperationException(
"Unsupported CvType value: " + type);
}
}
public static final String typeToString(int type) {
String s;
switch (depth(type)) {
case CV_8U:
s = "CV_8U";
break;
case CV_8S:
s = "CV_8S";
break;
case CV_16U:
s = "CV_16U";
break;
case CV_16S:
s = "CV_16S";
break;
case CV_32S:
s = "CV_32S";
break;
case CV_32F:
s = "CV_32F";
break;
case CV_64F:
s = "CV_64F";
break;
case CV_USRTYPE1:
s = "CV_USRTYPE1";
break;
default:
throw new java.lang.UnsupportedOperationException(
"Unsupported CvType value: " + type);
}
int ch = channels(type);
if (ch <= 4)
return s + "C" + ch;
else
return s + "C(" + ch + ")";
}
}
================================================
FILE: openCV/src/main/java/org/opencv/core/DMatch.java
================================================
package org.opencv.core;
//C++: class DMatch
/**
* Structure for matching: query descriptor index, train descriptor index, train
* image index and distance between descriptors.
*/
public class DMatch {
/**
* Query descriptor index.
*/
public int queryIdx;
/**
* Train descriptor index.
*/
public int trainIdx;
/**
* Train image index.
*/
public int imgIdx;
// javadoc: DMatch::distance
public float distance;
// javadoc: DMatch::DMatch()
public DMatch() {
this(-1, -1, Float.MAX_VALUE);
}
// javadoc: DMatch::DMatch(_queryIdx, _trainIdx, _distance)
public DMatch(int _queryIdx, int _trainIdx, float _distance) {
queryIdx = _queryIdx;
trainIdx = _trainIdx;
imgIdx = -1;
distance = _distance;
}
// javadoc: DMatch::DMatch(_queryIdx, _trainIdx, _imgIdx, _distance)
public DMatch(int _queryIdx, int _trainIdx, int _imgIdx, float _distance) {
queryIdx = _queryIdx;
trainIdx = _trainIdx;
imgIdx = _imgIdx;
distance = _distance;
}
public boolean lessThan(DMatch it) {
return distance < it.distance;
}
@Override
public String toString() {
return "DMatch [queryIdx=" + queryIdx + ", trainIdx=" + trainIdx
+ ", imgIdx=" + imgIdx + ", distance=" + distance + "]";
}
}
================================================
FILE: openCV/src/main/java/org/opencv/core/KeyPoint.java
================================================
package org.opencv.core;
import org.opencv.core.Point;
//javadoc: KeyPoint
public class KeyPoint {
/**
* Coordinates of the keypoint.
*/
public Point pt;
/**
* Diameter of the useful keypoint adjacent area.
*/
public float size;
/**
* Computed orientation of the keypoint (-1 if not applicable).
*/
public float angle;
/**
* The response, by which the strongest keypoints have been selected. Can
* be used for further sorting or subsampling.
*/
public float response;
/**
* Octave (pyramid layer), from which the keypoint has been extracted.
*/
public int octave;
/**
* Object ID, that can be used to cluster keypoints by an object they
* belong to.
*/
public int class_id;
// javadoc:KeyPoint::KeyPoint(x,y,_size,_angle,_response,_octave,_class_id)
public KeyPoint(float x, float y, float _size, float _angle, float _response, int _octave, int _class_id)
{
pt = new Point(x, y);
size = _size;
angle = _angle;
response = _response;
octave = _octave;
class_id = _class_id;
}
// javadoc: KeyPoint::KeyPoint()
public KeyPoint()
{
this(0, 0, 0, -1, 0, 0, -1);
}
// javadoc: KeyPoint::KeyPoint(x, y, _size, _angle, _response, _octave)
public KeyPoint(float x, float y, float _size, float _angle, float _response, int _octave)
{
this(x, y, _size, _angle, _response, _octave, -1);
}
// javadoc: KeyPoint::KeyPoint(x, y, _size, _angle, _response)
public KeyPoint(float x, float y, float _size, float _angle, float _response)
{
this(x, y, _size, _angle, _response, 0, -1);
}
// javadoc: KeyPoint::KeyPoint(x, y, _size, _angle)
public KeyPoint(float x, float y, float _size, float _angle)
{
this(x, y, _size, _angle, 0, 0, -1);
}
// javadoc: KeyPoint::KeyPoint(x, y, _size)
public KeyPoint(float x, float y, float _size)
{
this(x, y, _size, -1, 0, 0, -1);
}
@Override
public String toString() {
return "KeyPoint [pt=" + pt + ", size=" + size + ", angle=" + angle
+ ", response=" + response + ", octave=" + octave
+ ", class_id=" + class_id + "]";
}
}
================================================
FILE: openCV/src/main/java/org/opencv/core/Mat.java
================================================
package org.opencv.core;
import java.nio.ByteBuffer;
// C++: class Mat
//javadoc: Mat
public class Mat {
public final long nativeObj;
public Mat(long addr)
{
if (addr == 0)
throw new java.lang.UnsupportedOperationException("Native object address is NULL");
nativeObj = addr;
}
//
// C++: Mat::Mat()
//
// javadoc: Mat::Mat()
public Mat()
{
nativeObj = n_Mat();
return;
}
//
// C++: Mat::Mat(int rows, int cols, int type)
//
// javadoc: Mat::Mat(rows, cols, type)
public Mat(int rows, int cols, int type)
{
nativeObj = n_Mat(rows, cols, type);
return;
}
//
// C++: Mat::Mat(int rows, int cols, int type, void* data)
//
// javadoc: Mat::Mat(rows, cols, type, data)
public Mat(int rows, int cols, int type, ByteBuffer data)
{
nativeObj = n_Mat(rows, cols, type, data);
return;
}
//
// C++: Mat::Mat(Size size, int type)
//
// javadoc: Mat::Mat(size, type)
public Mat(Size size, int type)
{
nativeObj = n_Mat(size.width, size.height, type);
return;
}
//
// C++: Mat::Mat(int ndims, const int* sizes, int type)
//
// javadoc: Mat::Mat(sizes, type)
public Mat(int[] sizes, int type)
{
nativeObj = n_Mat(sizes.length, sizes, type);
return;
}
//
// C++: Mat::Mat(int rows, int cols, int type, Scalar s)
//
// javadoc: Mat::Mat(rows, cols, type, s)
public Mat(int rows, int cols, int type, Scalar s)
{
nativeObj = n_Mat(rows, cols, type, s.val[0], s.val[1], s.val[2], s.val[3]);
return;
}
//
// C++: Mat::Mat(Size size, int type, Scalar s)
//
// javadoc: Mat::Mat(size, type, s)
public Mat(Size size, int type, Scalar s)
{
nativeObj = n_Mat(size.width, size.height, type, s.val[0], s.val[1], s.val[2], s.val[3]);
return;
}
//
// C++: Mat::Mat(int ndims, const int* sizes, int type, Scalar s)
//
// javadoc: Mat::Mat(sizes, type, s)
public Mat(int[] sizes, int type, Scalar s)
{
nativeObj = n_Mat(sizes.length, sizes, type, s.val[0], s.val[1], s.val[2], s.val[3]);
return;
}
//
// C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())
//
// javadoc: Mat::Mat(m, rowRange, colRange)
public Mat(Mat m, Range rowRange, Range colRange)
{
nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end);
return;
}
// javadoc: Mat::Mat(m, rowRange)
public Mat(Mat m, Range rowRange)
{
nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end);
return;
}
//
// C++: Mat::Mat(const Mat& m, const std::vector& ranges)
//
// javadoc: Mat::Mat(m, ranges)
public Mat(Mat m, Range[] ranges)
{
nativeObj = n_Mat(m.nativeObj, ranges);
return;
}
//
// C++: Mat::Mat(Mat m, Rect roi)
//
// javadoc: Mat::Mat(m, roi)
public Mat(Mat m, Rect roi)
{
nativeObj = n_Mat(m.nativeObj, roi.y, roi.y + roi.height, roi.x, roi.x + roi.width);
return;
}
//
// C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)
//
// javadoc: Mat::adjustROI(dtop, dbottom, dleft, dright)
public Mat adjustROI(int dtop, int dbottom, int dleft, int dright)
{
Mat retVal = new Mat(n_adjustROI(nativeObj, dtop, dbottom, dleft, dright));
return retVal;
}
//
// C++: void Mat::assignTo(Mat m, int type = -1)
//
// javadoc: Mat::assignTo(m, type)
public void assignTo(Mat m, int type)
{
n_assignTo(nativeObj, m.nativeObj, type);
return;
}
// javadoc: Mat::assignTo(m)
public void assignTo(Mat m)
{
n_assignTo(nativeObj, m.nativeObj);
return;
}
//
// C++: int Mat::channels()
//
// javadoc: Mat::channels()
public int channels()
{
int retVal = n_channels(nativeObj);
return retVal;
}
//
// C++: int Mat::checkVector(int elemChannels, int depth = -1, bool
// requireContinuous = true)
//
// javadoc: Mat::checkVector(elemChannels, depth, requireContinuous)
public int checkVector(int elemChannels, int depth, boolean requireContinuous)
{
int retVal = n_checkVector(nativeObj, elemChannels, depth, requireContinuous);
return retVal;
}
// javadoc: Mat::checkVector(elemChannels, depth)
public int checkVector(int elemChannels, int depth)
{
int retVal = n_checkVector(nativeObj, elemChannels, depth);
return retVal;
}
// javadoc: Mat::checkVector(elemChannels)
public int checkVector(int elemChannels)
{
int retVal = n_checkVector(nativeObj, elemChannels);
return retVal;
}
//
// C++: Mat Mat::clone()
//
// javadoc: Mat::clone()
public Mat clone()
{
Mat retVal = new Mat(n_clone(nativeObj));
return retVal;
}
//
// C++: Mat Mat::col(int x)
//
// javadoc: Mat::col(x)
public Mat col(int x)
{
Mat retVal = new Mat(n_col(nativeObj, x));
return retVal;
}
//
// C++: Mat Mat::colRange(int startcol, int endcol)
//
// javadoc: Mat::colRange(startcol, endcol)
public Mat colRange(int startcol, int endcol)
{
Mat retVal = new Mat(n_colRange(nativeObj, startcol, endcol));
return retVal;
}
//
// C++: Mat Mat::colRange(Range r)
//
// javadoc: Mat::colRange(r)
public Mat colRange(Range r)
{
Mat retVal = new Mat(n_colRange(nativeObj, r.start, r.end));
return retVal;
}
//
// C++: int Mat::dims()
//
// javadoc: Mat::dims()
public int dims()
{
int retVal = n_dims(nativeObj);
return retVal;
}
//
// C++: int Mat::cols()
//
// javadoc: Mat::cols()
public int cols()
{
int retVal = n_cols(nativeObj);
return retVal;
}
//
// C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta
// = 0)
//
// javadoc: Mat::convertTo(m, rtype, alpha, beta)
public void convertTo(Mat m, int rtype, double alpha, double beta)
{
n_convertTo(nativeObj, m.nativeObj, rtype, alpha, beta);
return;
}
// javadoc: Mat::convertTo(m, rtype, alpha)
public void convertTo(Mat m, int rtype, double alpha)
{
n_convertTo(nativeObj, m.nativeObj, rtype, alpha);
return;
}
// javadoc: Mat::convertTo(m, rtype)
public void convertTo(Mat m, int rtype)
{
n_convertTo(nativeObj, m.nativeObj, rtype);
return;
}
//
// C++: void Mat::copyTo(Mat& m)
//
// javadoc: Mat::copyTo(m)
public void copyTo(Mat m)
{
n_copyTo(nativeObj, m.nativeObj);
return;
}
//
// C++: void Mat::copyTo(Mat& m, Mat mask)
//
// javadoc: Mat::copyTo(m, mask)
public void copyTo(Mat m, Mat mask)
{
n_copyTo(nativeObj, m.nativeObj, mask.nativeObj);
return;
}
//
// C++: void Mat::create(int rows, int cols, int type)
//
// javadoc: Mat::create(rows, cols, type)
public void create(int rows, int cols, int type)
{
n_create(nativeObj, rows, cols, type);
return;
}
//
// C++: void Mat::create(Size size, int type)
//
// javadoc: Mat::create(size, type)
public void create(Size size, int type)
{
n_create(nativeObj, size.width, size.height, type);
return;
}
//
// C++: void Mat::create(int ndims, const int* sizes, int type)
//
// javadoc: Mat::create(sizes, type)
public void create(int[] sizes, int type)
{
n_create(nativeObj, sizes.length, sizes, type);
return;
}
//
// C++: void Mat::copySize(const Mat& m);
//
// javadoc: Mat::copySize(m)
public void copySize(Mat m)
{
n_copySize(nativeObj, m.nativeObj);
return;
}
//
// C++: Mat Mat::cross(Mat m)
//
// javadoc: Mat::cross(m)
public Mat cross(Mat m)
{
Mat retVal = new Mat(n_cross(nativeObj, m.nativeObj));
return retVal;
}
//
// C++: long Mat::dataAddr()
//
// javadoc: Mat::dataAddr()
public long dataAddr()
{
long retVal = n_dataAddr(nativeObj);
return retVal;
}
//
// C++: int Mat::depth()
//
// javadoc: Mat::depth()
public int depth()
{
int retVal = n_depth(nativeObj);
return retVal;
}
//
// C++: Mat Mat::diag(int d = 0)
//
// javadoc: Mat::diag(d)
public Mat diag(int d)
{
Mat retVal = new Mat(n_diag(nativeObj, d));
return retVal;
}
// javadoc: Mat::diag()
public Mat diag()
{
Mat retVal = new Mat(n_diag(nativeObj, 0));
return retVal;
}
//
// C++: static Mat Mat::diag(Mat d)
//
// javadoc: Mat::diag(d)
public static Mat diag(Mat d)
{
Mat retVal = new Mat(n_diag(d.nativeObj));
return retVal;
}
//
// C++: double Mat::dot(Mat m)
//
// javadoc: Mat::dot(m)
public double dot(Mat m)
{
double retVal = n_dot(nativeObj, m.nativeObj);
return retVal;
}
//
// C++: size_t Mat::elemSize()
//
// javadoc: Mat::elemSize()
public long elemSize()
{
long retVal = n_elemSize(nativeObj);
return retVal;
}
//
// C++: size_t Mat::elemSize1()
//
// javadoc: Mat::elemSize1()
public long elemSize1()
{
long retVal = n_elemSize1(nativeObj);
return retVal;
}
//
// C++: bool Mat::empty()
//
// javadoc: Mat::empty()
public boolean empty()
{
boolean retVal = n_empty(nativeObj);
return retVal;
}
//
// C++: static Mat Mat::eye(int rows, int cols, int type)
//
// javadoc: Mat::eye(rows, cols, type)
public static Mat eye(int rows, int cols, int type)
{
Mat retVal = new Mat(n_eye(rows, cols, type));
return retVal;
}
//
// C++: static Mat Mat::eye(Size size, int type)
//
// javadoc: Mat::eye(size, type)
public static Mat eye(Size size, int type)
{
Mat retVal = new Mat(n_eye(size.width, size.height, type));
return retVal;
}
//
// C++: Mat Mat::inv(int method = DECOMP_LU)
//
// javadoc: Mat::inv(method)
public Mat inv(int method)
{
Mat retVal = new Mat(n_inv(nativeObj, method));
return retVal;
}
// javadoc: Mat::inv()
public Mat inv()
{
Mat retVal = new Mat(n_inv(nativeObj));
return retVal;
}
//
// C++: bool Mat::isContinuous()
//
// javadoc: Mat::isContinuous()
public boolean isContinuous()
{
boolean retVal = n_isContinuous(nativeObj);
return retVal;
}
//
// C++: bool Mat::isSubmatrix()
//
// javadoc: Mat::isSubmatrix()
public boolean isSubmatrix()
{
boolean retVal = n_isSubmatrix(nativeObj);
return retVal;
}
//
// C++: void Mat::locateROI(Size wholeSize, Point ofs)
//
// javadoc: Mat::locateROI(wholeSize, ofs)
public void locateROI(Size wholeSize, Point ofs)
{
double[] wholeSize_out = new double[2];
double[] ofs_out = new double[2];
locateROI_0(nativeObj, wholeSize_out, ofs_out);
if(wholeSize!=null){ wholeSize.width = wholeSize_out[0]; wholeSize.height = wholeSize_out[1]; }
if(ofs!=null){ ofs.x = ofs_out[0]; ofs.y = ofs_out[1]; }
return;
}
//
// C++: Mat Mat::mul(Mat m, double scale = 1)
//
// javadoc: Mat::mul(m, scale)
public Mat mul(Mat m, double scale)
{
Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj, scale));
return retVal;
}
// javadoc: Mat::mul(m)
public Mat mul(Mat m)
{
Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj));
return retVal;
}
//
// C++: static Mat Mat::ones(int rows, int cols, int type)
//
// javadoc: Mat::ones(rows, cols, type)
public static Mat ones(int rows, int cols, int type)
{
Mat retVal = new Mat(n_ones(rows, cols, type));
return retVal;
}
//
// C++: static Mat Mat::ones(Size size, int type)
//
// javadoc: Mat::ones(size, type)
public static Mat ones(Size size, int type)
{
Mat retVal = new Mat(n_ones(size.width, size.height, type));
return retVal;
}
//
// C++: static Mat Mat::ones(int ndims, const int* sizes, int type)
//
// javadoc: Mat::ones(sizes, type)
public static Mat ones(int[] sizes, int type)
{
Mat retVal = new Mat(n_ones(sizes.length, sizes, type));
return retVal;
}
//
// C++: void Mat::push_back(Mat m)
//
// javadoc: Mat::push_back(m)
public void push_back(Mat m)
{
n_push_back(nativeObj, m.nativeObj);
return;
}
//
// C++: void Mat::release()
//
// javadoc: Mat::release()
public void release()
{
n_release(nativeObj);
return;
}
//
// C++: Mat Mat::reshape(int cn, int rows = 0)
//
// javadoc: Mat::reshape(cn, rows)
public Mat reshape(int cn, int rows)
{
Mat retVal = new Mat(n_reshape(nativeObj, cn, rows));
return retVal;
}
// javadoc: Mat::reshape(cn)
public Mat reshape(int cn)
{
Mat retVal = new Mat(n_reshape(nativeObj, cn));
return retVal;
}
//
// C++: Mat Mat::reshape(int cn, int newndims, const int* newsz)
//
// javadoc: Mat::reshape(cn, newshape)
public Mat reshape(int cn, int[] newshape)
{
Mat retVal = new Mat(n_reshape_1(nativeObj, cn, newshape.length, newshape));
return retVal;
}
//
// C++: Mat Mat::row(int y)
//
// javadoc: Mat::row(y)
public Mat row(int y)
{
Mat retVal = new Mat(n_row(nativeObj, y));
return retVal;
}
//
// C++: Mat Mat::rowRange(int startrow, int endrow)
//
// javadoc: Mat::rowRange(startrow, endrow)
public Mat rowRange(int startrow, int endrow)
{
Mat retVal = new Mat(n_rowRange(nativeObj, startrow, endrow));
return retVal;
}
//
// C++: Mat Mat::rowRange(Range r)
//
// javadoc: Mat::rowRange(r)
public Mat rowRange(Range r)
{
Mat retVal = new Mat(n_rowRange(nativeObj, r.start, r.end));
return retVal;
}
//
// C++: int Mat::rows()
//
// javadoc: Mat::rows()
public int rows()
{
int retVal = n_rows(nativeObj);
return retVal;
}
//
// C++: Mat Mat::operator =(Scalar s)
//
// javadoc: Mat::operator =(s)
public Mat setTo(Scalar s)
{
Mat retVal = new Mat(n_setTo(nativeObj, s.val[0], s.val[1], s.val[2], s.val[3]));
return retVal;
}
//
// C++: Mat Mat::setTo(Scalar value, Mat mask = Mat())
//
// javadoc: Mat::setTo(value, mask)
public Mat setTo(Scalar value, Mat mask)
{
Mat retVal = new Mat(n_setTo(nativeObj, value.val[0], value.val[1], value.val[2], value.val[3], mask.nativeObj));
return retVal;
}
//
// C++: Mat Mat::setTo(Mat value, Mat mask = Mat())
//
// javadoc: Mat::setTo(value, mask)
public Mat setTo(Mat value, Mat mask)
{
Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj, mask.nativeObj));
return retVal;
}
// javadoc: Mat::setTo(value)
public Mat setTo(Mat value)
{
Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj));
return retVal;
}
//
// C++: Size Mat::size()
//
// javadoc: Mat::size()
public Size size()
{
Size retVal = new Size(n_size(nativeObj));
return retVal;
}
//
// C++: int Mat::size(int i)
//
// javadoc: Mat::size(int i)
public int size(int i)
{
int retVal = n_size_i(nativeObj, i);
return retVal;
}
//
// C++: size_t Mat::step1(int i = 0)
//
// javadoc: Mat::step1(i)
public long step1(int i)
{
long retVal = n_step1(nativeObj, i);
return retVal;
}
// javadoc: Mat::step1()
public long step1()
{
long retVal = n_step1(nativeObj);
return retVal;
}
//
// C++: Mat Mat::operator()(int rowStart, int rowEnd, int colStart, int
// colEnd)
//
// javadoc: Mat::operator()(rowStart, rowEnd, colStart, colEnd)
public Mat submat(int rowStart, int rowEnd, int colStart, int colEnd)
{
Mat retVal = new Mat(n_submat_rr(nativeObj, rowStart, rowEnd, colStart, colEnd));
return retVal;
}
//
// C++: Mat Mat::operator()(Range rowRange, Range colRange)
//
// javadoc: Mat::operator()(rowRange, colRange)
public Mat submat(Range rowRange, Range colRange)
{
Mat retVal = new Mat(n_submat_rr(nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end));
return retVal;
}
//
// C++: Mat Mat::operator()(const std::vector& ranges)
//
// javadoc: Mat::operator()(ranges[])
public Mat submat(Range[] ranges)
{
Mat retVal = new Mat(n_submat_ranges(nativeObj, ranges));
return retVal;
}
//
// C++: Mat Mat::operator()(Rect roi)
//
// javadoc: Mat::operator()(roi)
public Mat submat(Rect roi)
{
Mat retVal = new Mat(n_submat(nativeObj, roi.x, roi.y, roi.width, roi.height));
return retVal;
}
//
// C++: Mat Mat::t()
//
// javadoc: Mat::t()
public Mat t()
{
Mat retVal = new Mat(n_t(nativeObj));
return retVal;
}
//
// C++: size_t Mat::total()
//
// javadoc: Mat::total()
public long total()
{
long retVal = n_total(nativeObj);
return retVal;
}
//
// C++: int Mat::type()
//
// javadoc: Mat::type()
public int type()
{
int retVal = n_type(nativeObj);
return retVal;
}
//
// C++: static Mat Mat::zeros(int rows, int cols, int type)
//
// javadoc: Mat::zeros(rows, cols, type)
public static Mat zeros(int rows, int cols, int type)
{
Mat retVal = new Mat(n_zeros(rows, cols, type));
return retVal;
}
//
// C++: static Mat Mat::zeros(Size size, int type)
//
// javadoc: Mat::zeros(size, type)
public static Mat zeros(Size size, int type)
{
Mat retVal = new Mat(n_zeros(size.width, size.height, type));
return retVal;
}
//
// C++: static Mat Mat::zeros(int ndims, const int* sizes, int type)
//
// javadoc: Mat::zeros(sizes, type)
public static Mat zeros(int[] sizes, int type)
{
Mat retVal = new Mat(n_zeros(sizes.length, sizes, type));
return retVal;
}
@Override
protected void finalize() throws Throwable {
n_delete(nativeObj);
super.finalize();
}
// javadoc:Mat::toString()
@Override
public String toString() {
return "Mat [ " +
rows() + "*" + cols() + "*" + CvType.typeToString(type()) +
", isCont=" + isContinuous() + ", isSubmat=" + isSubmatrix() +
", nativeObj=0x" + Long.toHexString(nativeObj) +
", dataAddr=0x" + Long.toHexString(dataAddr()) +
" ]";
}
// javadoc:Mat::dump()
public String dump() {
return nDump(nativeObj);
}
// javadoc:Mat::put(row,col,data)
public int put(int row, int col, double... data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
return nPutD(nativeObj, row, col, data.length, data);
}
// javadoc:Mat::put(idx,data)
public int put(int[] idx, double... data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (idx.length != dims())
throw new IllegalArgumentException("Incorrect number of indices");
return nPutDIdx(nativeObj, idx, data.length, data);
}
// javadoc:Mat::put(row,col,data)
public int put(int row, int col, float[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_32F) {
return nPutF(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::put(idx,data)
public int put(int[] idx, float[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (idx.length != dims())
throw new IllegalArgumentException("Incorrect number of indices");
if (CvType.depth(t) == CvType.CV_32F) {
return nPutFIdx(nativeObj, idx, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::put(row,col,data)
public int put(int row, int col, int[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_32S) {
return nPutI(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::put(idx,data)
public int put(int[] idx, int[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (idx.length != dims())
throw new IllegalArgumentException("Incorrect number of indices");
if (CvType.depth(t) == CvType.CV_32S) {
return nPutIIdx(nativeObj, idx, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::put(row,col,data)
public int put(int row, int col, short[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
return nPutS(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::put(idx,data)
public int put(int[] idx, short[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (idx.length != dims())
throw new IllegalArgumentException("Incorrect number of indices");
if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
return nPutSIdx(nativeObj, idx, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::put(row,col,data)
public int put(int row, int col, byte[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
return nPutB(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::put(idx,data)
public int put(int[] idx, byte[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (idx.length != dims())
throw new IllegalArgumentException("Incorrect number of indices");
if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
return nPutBIdx(nativeObj, idx, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::put(row,col,data,offset,length)
public int put(int row, int col, byte[] data, int offset, int length) {
int t = type();
if (data == null || length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
return nPutBwOffset(nativeObj, row, col, length, offset, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::put(idx,data,offset,length)
public int put(int[] idx, byte[] data, int offset, int length) {
int t = type();
if (data == null || length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (idx.length != dims())
throw new IllegalArgumentException("Incorrect number of indices");
if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
return nPutBwIdxOffset(nativeObj, idx, length, offset, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(row,col,data)
public int get(int row, int col, byte[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
return nGetB(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(idx,data)
public int get(int[] idx, byte[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (idx.length != dims())
throw new IllegalArgumentException("Incorrect number of indices");
if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
return nGetBIdx(nativeObj, idx, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(row,col,data)
public int get(int row, int col, short[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
return nGetS(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(idx,data)
public int get(int[] idx, short[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (idx.length != dims())
throw new IllegalArgumentException("Incorrect number of indices");
if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
return nGetSIdx(nativeObj, idx, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(row,col,data)
public int get(int row, int col, int[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_32S) {
return nGetI(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(idx,data)
public int get(int[] idx, int[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (idx.length != dims())
throw new IllegalArgumentException("Incorrect number of indices");
if (CvType.depth(t) == CvType.CV_32S) {
return nGetIIdx(nativeObj, idx, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(row,col,data)
public int get(int row, int col, float[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_32F) {
return nGetF(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(idx,data)
public int get(int[] idx, float[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (idx.length != dims())
throw new IllegalArgumentException("Incorrect number of indices");
if (CvType.depth(t) == CvType.CV_32F) {
return nGetFIdx(nativeObj, idx, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(row,col,data)
public int get(int row, int col, double[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_64F) {
return nGetD(nativeObj, row, col, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(idx,data)
public int get(int[] idx, double[] data) {
int t = type();
if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException(
"Provided data element number (" +
(data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")");
if (idx.length != dims())
throw new IllegalArgumentException("Incorrect number of indices");
if (CvType.depth(t) == CvType.CV_64F) {
return nGetDIdx(nativeObj, idx, data.length, data);
}
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
}
// javadoc:Mat::get(row,col)
public double[] get(int row, int col) {
return nGet(nativeObj, row, col);
}
// javadoc:Mat::get(idx)
public double[] get(int[] idx) {
if (idx.length != dims())
throw new IllegalArgumentException("Incorrect number of indices");
return nGetIdx(nativeObj, idx);
}
// javadoc:Mat::height()
public int height() {
return rows();
}
// javadoc:Mat::width()
public int width() {
return cols();
}
// javadoc:Mat::getNativeObjAddr()
public long getNativeObjAddr() {
return nativeObj;
}
// C++: Mat::Mat()
private static native long n_Mat();
// C++: Mat::Mat(int rows, int cols, int type)
private static native long n_Mat(int rows, int cols, int type);
// C++: Mat::Mat(int ndims, const int* sizes, int type)
private static native long n_Mat(int ndims, int[] sizes, int type);
// C++: Mat::Mat(int rows, int cols, int type, void* data)
private static native long n_Mat(int rows, int cols, int type, ByteBuffer data);
// C++: Mat::Mat(Size size, int type)
private static native long n_Mat(double size_width, double size_height, int type);
// C++: Mat::Mat(int rows, int cols, int type, Scalar s)
private static native long n_Mat(int rows, int cols, int type, double s_val0, double s_val1, double s_val2, double s_val3);
// C++: Mat::Mat(Size size, int type, Scalar s)
private static native long n_Mat(double size_width, double size_height, int type, double s_val0, double s_val1, double s_val2, double s_val3);
// C++: Mat::Mat(int ndims, const int* sizes, int type, Scalar s)
private static native long n_Mat(int ndims, int[] sizes, int type, double s_val0, double s_val1, double s_val2, double s_val3);
// C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())
private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end);
private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end);
// C++: Mat::Mat(const Mat& m, const std::vector& ranges)
private static native long n_Mat(long m_nativeObj, Range[] ranges);
// C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)
private static native long n_adjustROI(long nativeObj, int dtop, int dbottom, int dleft, int dright);
// C++: void Mat::assignTo(Mat m, int type = -1)
private static native void n_assignTo(long nativeObj, long m_nativeObj, int type);
private static native void n_assignTo(long nativeObj, long m_nativeObj);
// C++: int Mat::channels()
private static native int n_channels(long nativeObj);
// C++: int Mat::checkVector(int elemChannels, int depth = -1, bool
// requireContinuous = true)
private static native int n_checkVector(long nativeObj, int elemChannels, int depth, boolean requireContinuous);
private static native int n_checkVector(long nativeObj, int elemChannels, int depth);
private static native int n_checkVector(long nativeObj, int elemChannels);
// C++: Mat Mat::clone()
private static native long n_clone(long nativeObj);
// C++: Mat Mat::col(int x)
private static native long n_col(long nativeObj, int x);
// C++: Mat Mat::colRange(int startcol, int endcol)
private static native long n_colRange(long nativeObj, int startcol, int endcol);
// C++: int Mat::dims()
private static native int n_dims(long nativeObj);
// C++: int Mat::cols()
private static native int n_cols(long nativeObj);
// C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta
// = 0)
private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha, double beta);
private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha);
private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype);
// C++: void Mat::copyTo(Mat& m)
private static native void n_copyTo(long nativeObj, long m_nativeObj);
// C++: void Mat::copyTo(Mat& m, Mat mask)
private static native void n_copyTo(long nativeObj, long m_nativeObj, long mask_nativeObj);
// C++: void Mat::create(int rows, int cols, int type)
private static native void n_create(long nativeObj, int rows, int cols, int type);
// C++: void Mat::create(Size size, int type)
private static native void n_create(long nativeObj, double size_width, double size_height, int type);
// C++: void Mat::create(int ndims, const int* sizes, int type)
private static native void n_create(long nativeObj, int ndims, int[] sizes, int type);
// C++: void Mat::copySize(const Mat& m)
private static native void n_copySize(long nativeObj, long m_nativeObj);
// C++: Mat Mat::cross(Mat m)
private static native long n_cross(long nativeObj, long m_nativeObj);
// C++: long Mat::dataAddr()
private static native long n_dataAddr(long nativeObj);
// C++: int Mat::depth()
private static native int n_depth(long nativeObj);
// C++: Mat Mat::diag(int d = 0)
private static native long n_diag(long nativeObj, int d);
// C++: static Mat Mat::diag(Mat d)
private static native long n_diag(long d_nativeObj);
// C++: double Mat::dot(Mat m)
private static native double n_dot(long nativeObj, long m_nativeObj);
// C++: size_t Mat::elemSize()
private static native long n_elemSize(long nativeObj);
// C++: size_t Mat::elemSize1()
private static native long n_elemSize1(long nativeObj);
// C++: bool Mat::empty()
private static native boolean n_empty(long nativeObj);
// C++: static Mat Mat::eye(int rows, int cols, int type)
private static native long n_eye(int rows, int cols, int type);
// C++: static Mat Mat::eye(Size size, int type)
private static native long n_eye(double size_width, double size_height, int type);
// C++: Mat Mat::inv(int method = DECOMP_LU)
private static native long n_inv(long nativeObj, int method);
private static native long n_inv(long nativeObj);
// C++: bool Mat::isContinuous()
private static native boolean n_isContinuous(long nativeObj);
// C++: bool Mat::isSubmatrix()
private static native boolean n_isSubmatrix(long nativeObj);
// C++: void Mat::locateROI(Size wholeSize, Point ofs)
private static native void locateROI_0(long nativeObj, double[] wholeSize_out, double[] ofs_out);
// C++: Mat Mat::mul(Mat m, double scale = 1)
private static native long n_mul(long nativeObj, long m_nativeObj, double scale);
private static native long n_mul(long nativeObj, long m_nativeObj);
// C++: static Mat Mat::ones(int rows, int cols, int type)
private static native long n_ones(int rows, int cols, int type);
// C++: static Mat Mat::ones(Size size, int type)
private static native long n_ones(double size_width, double size_height, int type);
// C++: static Mat Mat::ones(int ndims, const int* sizes, int type)
private static native long n_ones(int ndims, int[] sizes, int type);
// C++: void Mat::push_back(Mat m)
private static native void n_push_back(long nativeObj, long m_nativeObj);
// C++: void Mat::release()
private static native void n_release(long nativeObj);
// C++: Mat Mat::reshape(int cn, int rows = 0)
private static native long n_reshape(long nativeObj, int cn, int rows);
private static native long n_reshape(long nativeObj, int cn);
// C++: Mat Mat::reshape(int cn, int newndims, const int* newsz)
private static native long n_reshape_1(long nativeObj, int cn, int newndims, int[] newsz);
// C++: Mat Mat::row(int y)
private static native long n_row(long nativeObj, int y);
// C++: Mat Mat::rowRange(int startrow, int endrow)
private static native long n_rowRange(long nativeObj, int startrow, int endrow);
// C++: int Mat::rows()
private static native int n_rows(long nativeObj);
// C++: Mat Mat::operator =(Scalar s)
private static native long n_setTo(long nativeObj, double s_val0, double s_val1, double s_val2, double s_val3);
// C++: Mat Mat::setTo(Scalar value, Mat mask = Mat())
private static native long n_setTo(long nativeObj, double s_val0, double s_val1, double s_val2, double s_val3, long mask_nativeObj);
// C++: Mat Mat::setTo(Mat value, Mat mask = Mat())
private static native long n_setTo(long nativeObj, long value_nativeObj, long mask_nativeObj);
private static native long n_setTo(long nativeObj, long value_nativeObj);
// C++: Size Mat::size()
private static native double[] n_size(long nativeObj);
// C++: int Mat::size(int i)
private static native int n_size_i(long nativeObj, int i);
// C++: size_t Mat::step1(int i = 0)
private static native long n_step1(long nativeObj, int i);
private static native long n_step1(long nativeObj);
// C++: Mat Mat::operator()(Range rowRange, Range colRange)
private static native long n_submat_rr(long nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end);
// C++: Mat Mat::operator()(const std::vector& ranges)
private static native long n_submat_ranges(long nativeObj, Range[] ranges);
// C++: Mat Mat::operator()(Rect roi)
private static native long n_submat(long nativeObj, int roi_x, int roi_y, int roi_width, int roi_height);
// C++: Mat Mat::t()
private static native long n_t(long nativeObj);
// C++: size_t Mat::total()
private static native long n_total(long nativeObj);
// C++: int Mat::type()
private static native int n_type(long nativeObj);
// C++: static Mat Mat::zeros(int rows, int cols, int type)
private static native long n_zeros(int rows, int cols, int type);
// C++: static Mat Mat::zeros(Size size, int type)
private static native long n_zeros(double size_width, double size_height, int type);
// C++: static Mat Mat::zeros(int ndims, const int* sizes, int type)
private static native long n_zeros(int ndims, int[] sizes, int type);
// native support for java finalize()
private static native void n_delete(long nativeObj);
private static native int nPutD(long self, int row, int col, int count, double[] data);
private static native int nPutDIdx(long self, int[] idx, int count, double[] data);
private static native int nPutF(long self, int row, int col, int count, float[] data);
private static native int nPutFIdx(long self, int[] idx, int count, float[] data);
private static native int nPutI(long self, int row, int col, int count, int[] data);
private static native int nPutIIdx(long self, int[] idx, int count, int[] data);
private static native int nPutS(long self, int row, int col, int count, short[] data);
private static native int nPutSIdx(long self, int[] idx, int count, short[] data);
private static native int nPutB(long self, int row, int col, int count, byte[] data);
private static native int nPutBIdx(long self, int[] idx, int count, byte[] data);
private static native int nPutBwOffset(long self, int row, int col, int count, int offset, byte[] data);
private static native int nPutBwIdxOffset(long self, int[] idx, int count, int offset, byte[] data);
private static native int nGetB(long self, int row, int col, int count, byte[] vals);
private static native int nGetBIdx(long self, int[] idx, int count, byte[] vals);
private static native int nGetS(long self, int row, int col, int count, short[] vals);
private static native int nGetSIdx(long self, int[] idx, int count, short[] vals);
private static native int nGetI(long self, int row, int col, int count, int[] vals);
private static native int nGetIIdx(long self, int[] idx, int count, int[] vals);
private static native int nGetF(long self, int row, int col, int count, float[] vals);
private static native int nGetFIdx(long self, int[] idx, int count, float[] vals);
private static native int nGetD(long self, int row, int col, int count, double[] vals);
private static native int nGetDIdx(long self, int[] idx, int count, double[] vals);
private static native double[] nGet(long self, int row, int col);
private static native double[] nGetIdx(long self, int[] idx);
private static native String nDump(long self);
}
================================================
FILE: openCV/src/main/java/org/opencv/core/MatOfByte.java
================================================
package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfByte extends Mat {
// 8UC(x)
private static final int _depth = CvType.CV_8U;
private static final int _channels = 1;
public MatOfByte() {
super();
}
protected MatOfByte(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfByte fromNativeAddr(long addr) {
return new MatOfByte(addr);
}
public MatOfByte(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfByte(byte...a) {
super();
fromArray(a);
}
public MatOfByte(int offset, int length, byte...a) {
super();
fromArray(offset, length, a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(byte...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public void fromArray(int offset, int length, byte...a) {
if (offset < 0)
throw new IllegalArgumentException("offset < 0");
if (a == null)
throw new NullPointerException();
if (length < 0 || length + offset > a.length)
throw new IllegalArgumentException("invalid 'length' parameter: " + Integer.toString(length));
if (a.length == 0)
return;
int num = length / _channels;
alloc(num);
put(0, 0, a, offset, length); //TODO: check ret val!
}
public byte[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
byte[] a = new byte[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List lb) {
if(lb==null || lb.size()==0)
return;
Byte ab[] = lb.toArray(new Byte[0]);
byte a[] = new byte[ab.length];
for(int i=0; i toList() {
byte[] a = toArray();
Byte ab[] = new Byte[a.length];
for(int i=0; i0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(DMatch...a) {
if(a==null || a.length==0)
return;
int num = a.length;
alloc(num);
float buff[] = new float[num * _channels];
for(int i=0; i ldm) {
DMatch adm[] = ldm.toArray(new DMatch[0]);
fromArray(adm);
}
public List toList() {
DMatch[] adm = toArray();
return Arrays.asList(adm);
}
}
================================================
FILE: openCV/src/main/java/org/opencv/core/MatOfDouble.java
================================================
package org.opencv.core;
import java.util.Arrays;
import java.util.List;
public class MatOfDouble extends Mat {
// 64FC(x)
private static final int _depth = CvType.CV_64F;
private static final int _channels = 1;
public MatOfDouble() {
super();
}
protected MatOfDouble(long addr) {
super(addr);
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public static MatOfDouble fromNativeAddr(long addr) {
return new MatOfDouble(addr);
}
public MatOfDouble(Mat m) {
super(m, Range.all());
if( !empty() && checkVector(_channels, _depth) < 0 )
throw new IllegalArgumentException("Incompatible Mat");
//FIXME: do we need release() here?
}
public MatOfDouble(double...a) {
super();
fromArray(a);
}
public void alloc(int elemNumber) {
if(elemNumber>0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(double...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public double[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
double[] a = new double[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List lb) {
if(lb==null || lb.size()==0)
return;
Double ab[] = lb.toArray(new Double[0]);
double a[] = new double[ab.length];
for(int i=0; i toList() {
double[] a = toArray();
Double ab[] = new Double[a.length];
for(int i=0; i0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(float...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public float[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
float[] a = new float[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List lb) {
if(lb==null || lb.size()==0)
return;
Float ab[] = lb.toArray(new Float[0]);
float a[] = new float[ab.length];
for(int i=0; i toList() {
float[] a = toArray();
Float ab[] = new Float[a.length];
for(int i=0; i0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(float...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public float[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
float[] a = new float[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List lb) {
if(lb==null || lb.size()==0)
return;
Float ab[] = lb.toArray(new Float[0]);
float a[] = new float[ab.length];
for(int i=0; i toList() {
float[] a = toArray();
Float ab[] = new Float[a.length];
for(int i=0; i0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(float...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public float[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
float[] a = new float[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List lb) {
if(lb==null || lb.size()==0)
return;
Float ab[] = lb.toArray(new Float[0]);
float a[] = new float[ab.length];
for(int i=0; i toList() {
float[] a = toArray();
Float ab[] = new Float[a.length];
for(int i=0; i0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(int...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public int[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
int[] a = new int[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List lb) {
if(lb==null || lb.size()==0)
return;
Integer ab[] = lb.toArray(new Integer[0]);
int a[] = new int[ab.length];
for(int i=0; i toList() {
int[] a = toArray();
Integer ab[] = new Integer[a.length];
for(int i=0; i0)
super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
}
public void fromArray(int...a) {
if(a==null || a.length==0)
return;
int num = a.length / _channels;
alloc(num);
put(0, 0, a); //TODO: check ret val!
}
public int[] toArray() {
int num = checkVector(_channels, _depth);
if(num < 0)
throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
int[] a = new int[num * _channels];
if(num == 0)
return a;
get(0, 0, a); //TODO: check ret val!
return a;
}
public void fromList(List