Skip to content

O
opencv
Commit c1c1a376 authored by Alexander Smorkalov's avatar Alexander Smorkalov
Browse files
Options

bad changes reverted.

parent a9d9eb1a
Hide whitespace changes
Inline Side-by-side
Showing with 2032 additions and 2219 deletions
modules/java/src/java/AsyncServiceHelper.java deleted 100644 → 0
View file @ a9d9eb1a
package org.opencv.android;
import java.io.File;
import java.util.StringTokenizer;
import org.opencv.engine.OpenCVEngineInterface;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
public class AsyncServiceHelper
{
public static int initOpenCV(String Version, Context AppContext,
LoaderCallbackInterface Callback)
{
AsyncServiceHelper helper = new AsyncServiceHelper(Version, AppContext, Callback);
if (AppContext.bindService(new Intent("org.opencv.engine.BIND"),
helper.mServiceConnection, Context.BIND_AUTO_CREATE))
{
return OpenCVLoader.Success;
}
else
{
return OpenCVLoader.NoService;
}
}
protected AsyncServiceHelper(String Version, Context AppContext,
LoaderCallbackInterface Callback)
{
mOpenCVersion = Version;
mUserAppCallback = Callback;
mAppContext = AppContext;
}
protected static final String TAG = "OpenCvEngine/Helper";
protected OpenCVEngineInterface mEngineService;
protected LoaderCallbackInterface mUserAppCallback;
protected String mOpenCVersion;
protected Context mAppContext;
protected int mStatus = OpenCVLoader.Success;
protected ServiceConnection mServiceConnection = new ServiceConnection()
{
public void onServiceConnected(ComponentName className, IBinder service)
{
Log.d(TAG, "Service connection created");
mEngineService = OpenCVEngineInterface.Stub.asInterface(service);
if (null == mEngineService)
{
Log.d(TAG, "Engine connection fails. May be service was not installed?");
mStatus = OpenCVLoader.NoService;
}
else
{
try
{
Log.d(TAG, "Trying to get library path");
String path = mEngineService.getLibPathByVersion(mOpenCVersion);
if ((null == path) || (path.length() == 0))
{
if (mEngineService.installVersion(mOpenCVersion))
{
mStatus = OpenCVLoader.RestartRequired;
}
else
{
Log.d(TAG, "OpenCV package was not installed!");
mStatus = OpenCVLoader.MarketError;
}
}
else
{
Log.d(TAG, "Trying to get library list");
String libs = mEngineService.getLibraryList(mOpenCVersion);
Log.d(TAG, "Library list: \"" + libs + "\"");
Log.d(TAG, "First attempt to load libs");
if (initOpenCVLibs(path, libs))
{
Log.d(TAG, "First attempt to load libs is OK");
mStatus = OpenCVLoader.Success;
}
else
{
Log.d(TAG, "First attempt to load libs fails");
mStatus = OpenCVLoader.InitFailed;
}
}
}
catch (RemoteException e)
{
e.printStackTrace();
mStatus = OpenCVLoader.InitFailed;
}
}
Log.d(TAG, "Init finished with status " + mStatus);
Log.d(TAG, "Unbind from service");
mAppContext.unbindService(mServiceConnection);
Log.d(TAG, "Calling using callback");
mUserAppCallback.onEngineConnected(mStatus);
}
private boolean loadLibrary(String AbsPath)
{
boolean result = true;
Log.d(TAG, "Trying to load library " + AbsPath);
try
{
System.load(AbsPath);
Log.d(TAG, "OpenCV libs init was ok!");
}
catch(Exception e)
{
Log.d(TAG, "Cannot load library \"" + AbsPath + "\"");
e.printStackTrace();
result &= false;
}
return result;
}
private boolean initOpenCVLibs(String Path, String Libs)
{
Log.d(TAG, "Trying to init OpenCV libs");
if ((null != Path) && (Path.length() != 0))
{
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())
{
String AbsLibraryPath = Path + File.separator + splitter.nextToken();
result &= loadLibrary(AbsLibraryPath);
}
}
else
{
// If dependencies list is not defined or empty
String AbsLibraryPath = Path + File.separator + "libopencv_java.so";
result &= loadLibrary(AbsLibraryPath);
}
return result;
}
else
{
Log.d(TAG, "Library path \"" + Path + "\" is empty");
return false;
}
}
public void onServiceDisconnected(ComponentName className)
{
mEngineService = null;
}
};
}
modules/java/src/java/LoaderCallbackInterface.java deleted 100644 → 0
View file @ a9d9eb1a
package org.opencv.android;
public interface LoaderCallbackInterface
{
public void onEngineConnected(int status);
};
modules/java/src/java/OpenCVLoader.java deleted 100644 → 0
View file @ a9d9eb1a
package org.opencv.android;
import android.content.Context;
import android.util.Log;
public class OpenCVLoader
{
public static final int Success = 0;
public static final int NoService = 1;
public static final int RestartRequired = 2;
public static final int MarketError = 3;
public static final int InitFailed = 0xff;
public static int initStatic()
{
int result;
try
{
System.loadLibrary("opencv_java");
result = Success;
}
catch(Exception e)
{
Log.e(TAG, "OpenCV error: Cannot load native library");
e.printStackTrace();
result = InitFailed;
}
return result;
}
public static int initAsync(String Version, Context AppContext,
LoaderCallbackInterface Callback)
{
return AsyncServiceHelper.initOpenCV(Version, AppContext, Callback);
}
private static final String TAG = "OpenCV/Helper";
}
modules/java/src/java/android+Utils.java
View file @ c1c1a376
...@@ -113,6 +113,11 @@ public class Utils { ...@@ -113,6 +113,11 @@ public class Utils {
nMatToBitmap(m.nativeObj, b); nMatToBitmap(m.nativeObj, b);
} }
// native stuff
static {
System.loadLibrary("opencv_java");
}
private static native void nBitmapToMat(Bitmap b, long m_addr); private static native void nBitmapToMat(Bitmap b, long m_addr);
private static native void nMatToBitmap(long m_addr, Bitmap b); private static native void nMatToBitmap(long m_addr, Bitmap b);
......
modules/java/src/java/core+Mat.java
View file @ c1c1a376
package org.opencv.core; package org.opencv.core;
// C++: class Mat // C++: class Mat
//javadoc: Mat //javadoc: Mat
public class Mat { public class Mat {
public final long nativeObj; public final long nativeObj;
public Mat(long addr) public Mat(long addr)
{ {
if (addr == 0) if (addr == 0)
throw new java.lang.UnsupportedOperationException("Native object address is NULL"); throw new java.lang.UnsupportedOperationException("Native object address is NULL");
nativeObj = addr; nativeObj = addr;
} }
// //
// C++: Mat::Mat() // C++: Mat::Mat()
// //
// javadoc: Mat::Mat() // javadoc: Mat::Mat()
public Mat() public Mat()
{ {
nativeObj = n_Mat(); nativeObj = n_Mat();
return; return;
} }
// //
// C++: Mat::Mat(int rows, int cols, int type) // C++: Mat::Mat(int rows, int cols, int type)
// //
// javadoc: Mat::Mat(rows, cols, type) // javadoc: Mat::Mat(rows, cols, type)
public Mat(int rows, int cols, int type) public Mat(int rows, int cols, int type)
{ {
nativeObj = n_Mat(rows, cols, type); nativeObj = n_Mat(rows, cols, type);
return; return;
} }
// //
// C++: Mat::Mat(Size size, int type) // C++: Mat::Mat(Size size, int type)
// //
// javadoc: Mat::Mat(size, type) // javadoc: Mat::Mat(size, type)
public Mat(Size size, int type) public Mat(Size size, int type)
{ {
nativeObj = n_Mat(size.width, size.height, type); nativeObj = n_Mat(size.width, size.height, type);
return; return;
} }
// //
// C++: Mat::Mat(int rows, int cols, int type, Scalar s) // C++: Mat::Mat(int rows, int cols, int type, Scalar s)
// //
// javadoc: Mat::Mat(rows, cols, type, s) // javadoc: Mat::Mat(rows, cols, type, s)
public Mat(int rows, int cols, int type, Scalar 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]); nativeObj = n_Mat(rows, cols, type, s.val[0], s.val[1], s.val[2], s.val[3]);
return; return;
} }
// //
// C++: Mat::Mat(Size size, int type, Scalar s) // C++: Mat::Mat(Size size, int type, Scalar s)
// //
// javadoc: Mat::Mat(size, type, s) // javadoc: Mat::Mat(size, type, s)
public Mat(Size size, int type, Scalar 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]); nativeObj = n_Mat(size.width, size.height, type, s.val[0], s.val[1], s.val[2], s.val[3]);
return; return;
} }
// //
// C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all()) // C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())
// //
// javadoc: Mat::Mat(m, rowRange, colRange) // javadoc: Mat::Mat(m, rowRange, colRange)
public Mat(Mat m, Range rowRange, Range colRange) public Mat(Mat m, Range rowRange, Range colRange)
{ {
nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end); nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end);
return; return;
} }
// javadoc: Mat::Mat(m, rowRange) // javadoc: Mat::Mat(m, rowRange)
public Mat(Mat m, Range rowRange) public Mat(Mat m, Range rowRange)
{ {
nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end); nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end);
return; return;
} }
// //
// C++: Mat::Mat(Mat m, Rect roi) // C++: Mat::Mat(Mat m, Rect roi)
// //
// javadoc: Mat::Mat(m, roi) // javadoc: Mat::Mat(m, roi)
public Mat(Mat m, Rect roi) public Mat(Mat m, Rect roi)
{ {
nativeObj = n_Mat(m.nativeObj, roi.x, roi.x + roi.width, roi.y, roi.y + roi.height); nativeObj = n_Mat(m.nativeObj, roi.x, roi.x + roi.width, roi.y, roi.y + roi.height);
return; return;
} }
// //
// C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright) // C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)
// //
// javadoc: Mat::adjustROI(dtop, dbottom, dleft, dright) // javadoc: Mat::adjustROI(dtop, dbottom, dleft, dright)
public Mat adjustROI(int dtop, int dbottom, int dleft, int dright) public Mat adjustROI(int dtop, int dbottom, int dleft, int dright)
{ {
Mat retVal = new Mat(n_adjustROI(nativeObj, dtop, dbottom, dleft, dright)); Mat retVal = new Mat(n_adjustROI(nativeObj, dtop, dbottom, dleft, dright));
return retVal; return retVal;
} }
// //
// C++: void Mat::assignTo(Mat m, int type = -1) // C++: void Mat::assignTo(Mat m, int type = -1)
// //
// javadoc: Mat::assignTo(m, type) // javadoc: Mat::assignTo(m, type)
public void assignTo(Mat m, int type) public void assignTo(Mat m, int type)
{ {
n_assignTo(nativeObj, m.nativeObj, type); n_assignTo(nativeObj, m.nativeObj, type);
return; return;
} }
// javadoc: Mat::assignTo(m) // javadoc: Mat::assignTo(m)
public void assignTo(Mat m) public void assignTo(Mat m)
{ {
n_assignTo(nativeObj, m.nativeObj); n_assignTo(nativeObj, m.nativeObj);
return; return;
} }
// //
// C++: int Mat::channels() // C++: int Mat::channels()
// //
// javadoc: Mat::channels() // javadoc: Mat::channels()
public int channels() public int channels()
{ {
int retVal = n_channels(nativeObj); int retVal = n_channels(nativeObj);
return retVal; return retVal;
} }
// //
// C++: int Mat::checkVector(int elemChannels, int depth = -1, bool // C++: int Mat::checkVector(int elemChannels, int depth = -1, bool
// requireContinuous = true) // requireContinuous = true)
// //
// javadoc: Mat::checkVector(elemChannels, depth, requireContinuous) // javadoc: Mat::checkVector(elemChannels, depth, requireContinuous)
public int checkVector(int elemChannels, int depth, boolean requireContinuous) public int checkVector(int elemChannels, int depth, boolean requireContinuous)
{ {
int retVal = n_checkVector(nativeObj, elemChannels, depth, requireContinuous); int retVal = n_checkVector(nativeObj, elemChannels, depth, requireContinuous);
return retVal; return retVal;
} }
// javadoc: Mat::checkVector(elemChannels, depth) // javadoc: Mat::checkVector(elemChannels, depth)
public int checkVector(int elemChannels, int depth) public int checkVector(int elemChannels, int depth)
{ {
int retVal = n_checkVector(nativeObj, elemChannels, depth); int retVal = n_checkVector(nativeObj, elemChannels, depth);
return retVal; return retVal;
} }
// javadoc: Mat::checkVector(elemChannels) // javadoc: Mat::checkVector(elemChannels)
public int checkVector(int elemChannels) public int checkVector(int elemChannels)
{ {
int retVal = n_checkVector(nativeObj, elemChannels); int retVal = n_checkVector(nativeObj, elemChannels);
return retVal; return retVal;
} }
// //
// C++: Mat Mat::clone() // C++: Mat Mat::clone()
// //
// javadoc: Mat::clone() // javadoc: Mat::clone()
public Mat clone() public Mat clone()
{ {
Mat retVal = new Mat(n_clone(nativeObj)); Mat retVal = new Mat(n_clone(nativeObj));
return retVal; return retVal;
} }
// //
// C++: Mat Mat::col(int x) // C++: Mat Mat::col(int x)
// //
// javadoc: Mat::col(x) // javadoc: Mat::col(x)
public Mat col(int x) public Mat col(int x)
{ {
Mat retVal = new Mat(n_col(nativeObj, x)); Mat retVal = new Mat(n_col(nativeObj, x));
return retVal; return retVal;
} }
// //
// C++: Mat Mat::colRange(int startcol, int endcol) // C++: Mat Mat::colRange(int startcol, int endcol)
// //
// javadoc: Mat::colRange(startcol, endcol) // javadoc: Mat::colRange(startcol, endcol)
public Mat colRange(int startcol, int endcol) public Mat colRange(int startcol, int endcol)
{ {
Mat retVal = new Mat(n_colRange(nativeObj, startcol, endcol)); Mat retVal = new Mat(n_colRange(nativeObj, startcol, endcol));
return retVal; return retVal;
} }
// //
// C++: Mat Mat::colRange(Range r) // C++: Mat Mat::colRange(Range r)
// //
// javadoc: Mat::colRange(r) // javadoc: Mat::colRange(r)
public Mat colRange(Range r) public Mat colRange(Range r)
{ {
Mat retVal = new Mat(n_colRange(nativeObj, r.start, r.end)); Mat retVal = new Mat(n_colRange(nativeObj, r.start, r.end));
return retVal; return retVal;
} }
// //
// C++: int Mat::cols() // C++: int Mat::cols()
// //
// javadoc: Mat::cols() // javadoc: Mat::cols()
public int cols() public int cols()
{ {
int retVal = n_cols(nativeObj); int retVal = n_cols(nativeObj);
return retVal; return retVal;
} }
// //
// C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta // C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta
// = 0) // = 0)
// //
// javadoc: Mat::convertTo(m, rtype, alpha, beta) // javadoc: Mat::convertTo(m, rtype, alpha, beta)
public void convertTo(Mat m, int rtype, double alpha, double beta) public void convertTo(Mat m, int rtype, double alpha, double beta)
{ {
n_convertTo(nativeObj, m.nativeObj, rtype, alpha, beta); n_convertTo(nativeObj, m.nativeObj, rtype, alpha, beta);
return; return;
} }
// javadoc: Mat::convertTo(m, rtype, alpha) // javadoc: Mat::convertTo(m, rtype, alpha)
public void convertTo(Mat m, int rtype, double alpha) public void convertTo(Mat m, int rtype, double alpha)
{ {
n_convertTo(nativeObj, m.nativeObj, rtype, alpha); n_convertTo(nativeObj, m.nativeObj, rtype, alpha);
return; return;
} }
// javadoc: Mat::convertTo(m, rtype) // javadoc: Mat::convertTo(m, rtype)
public void convertTo(Mat m, int rtype) public void convertTo(Mat m, int rtype)
{ {
n_convertTo(nativeObj, m.nativeObj, rtype); n_convertTo(nativeObj, m.nativeObj, rtype);
return; return;
} }
// //
// C++: void Mat::copyTo(Mat& m) // C++: void Mat::copyTo(Mat& m)
// //
// javadoc: Mat::copyTo(m) // javadoc: Mat::copyTo(m)
public void copyTo(Mat m) public void copyTo(Mat m)
{ {
n_copyTo(nativeObj, m.nativeObj); n_copyTo(nativeObj, m.nativeObj);
return; return;
} }
// //
// C++: void Mat::copyTo(Mat& m, Mat mask) // C++: void Mat::copyTo(Mat& m, Mat mask)
// //
// javadoc: Mat::copyTo(m, mask) // javadoc: Mat::copyTo(m, mask)
public void copyTo(Mat m, Mat mask) public void copyTo(Mat m, Mat mask)
{ {
n_copyTo(nativeObj, m.nativeObj, mask.nativeObj); n_copyTo(nativeObj, m.nativeObj, mask.nativeObj);
return; return;
} }
// //
// C++: void Mat::create(int rows, int cols, int type) // C++: void Mat::create(int rows, int cols, int type)
// //
// javadoc: Mat::create(rows, cols, type) // javadoc: Mat::create(rows, cols, type)
public void create(int rows, int cols, int type) public void create(int rows, int cols, int type)
{ {
n_create(nativeObj, rows, cols, type); n_create(nativeObj, rows, cols, type);
return; return;
} }
// //
// C++: void Mat::create(Size size, int type) // C++: void Mat::create(Size size, int type)
// //
// javadoc: Mat::create(size, type) // javadoc: Mat::create(size, type)
public void create(Size size, int type) public void create(Size size, int type)
{ {
n_create(nativeObj, size.width, size.height, type); n_create(nativeObj, size.width, size.height, type);
return; return;
} }
// //
// C++: Mat Mat::cross(Mat m) // C++: Mat Mat::cross(Mat m)
// //
// javadoc: Mat::cross(m) // javadoc: Mat::cross(m)
public Mat cross(Mat m) public Mat cross(Mat m)
{ {
Mat retVal = new Mat(n_cross(nativeObj, m.nativeObj)); Mat retVal = new Mat(n_cross(nativeObj, m.nativeObj));
return retVal; return retVal;
} }
// //
// C++: long Mat::dataAddr() // C++: long Mat::dataAddr()
// //
// javadoc: Mat::dataAddr() // javadoc: Mat::dataAddr()
public long dataAddr() public long dataAddr()
{ {
long retVal = n_dataAddr(nativeObj); long retVal = n_dataAddr(nativeObj);
return retVal; return retVal;
} }
// //
// C++: int Mat::depth() // C++: int Mat::depth()
// //
// javadoc: Mat::depth() // javadoc: Mat::depth()
public int depth() public int depth()
{ {
int retVal = n_depth(nativeObj); int retVal = n_depth(nativeObj);
return retVal; return retVal;
} }
// //
// C++: Mat Mat::diag(int d = 0) // C++: Mat Mat::diag(int d = 0)
// //
// javadoc: Mat::diag(d) // javadoc: Mat::diag(d)
public Mat diag(int d) public Mat diag(int d)
{ {
Mat retVal = new Mat(n_diag(nativeObj, d)); Mat retVal = new Mat(n_diag(nativeObj, d));
return retVal; return retVal;
} }
// javadoc: Mat::diag() // javadoc: Mat::diag()
public Mat diag() public Mat diag()
{ {
Mat retVal = new Mat(n_diag(nativeObj, 0)); Mat retVal = new Mat(n_diag(nativeObj, 0));
return retVal; return retVal;
} }
// //
// C++: static Mat Mat::diag(Mat d) // C++: static Mat Mat::diag(Mat d)
// //
// javadoc: Mat::diag(d) // javadoc: Mat::diag(d)
public static Mat diag(Mat d) public static Mat diag(Mat d)
{ {
Mat retVal = new Mat(n_diag(d.nativeObj)); Mat retVal = new Mat(n_diag(d.nativeObj));
return retVal; return retVal;
} }
// //
// C++: double Mat::dot(Mat m) // C++: double Mat::dot(Mat m)
// //
// javadoc: Mat::dot(m) // javadoc: Mat::dot(m)
public double dot(Mat m) public double dot(Mat m)
{ {
double retVal = n_dot(nativeObj, m.nativeObj); double retVal = n_dot(nativeObj, m.nativeObj);
return retVal; return retVal;
} }
// //
// C++: size_t Mat::elemSize() // C++: size_t Mat::elemSize()
// //
// javadoc: Mat::elemSize() // javadoc: Mat::elemSize()
public long elemSize() public long elemSize()
{ {
long retVal = n_elemSize(nativeObj); long retVal = n_elemSize(nativeObj);
return retVal; return retVal;
} }
// //
// C++: size_t Mat::elemSize1() // C++: size_t Mat::elemSize1()
// //
// javadoc: Mat::elemSize1() // javadoc: Mat::elemSize1()
public long elemSize1() public long elemSize1()
{ {
long retVal = n_elemSize1(nativeObj); long retVal = n_elemSize1(nativeObj);
return retVal; return retVal;
} }
// //
// C++: bool Mat::empty() // C++: bool Mat::empty()
// //
// javadoc: Mat::empty() // javadoc: Mat::empty()
public boolean empty() public boolean empty()
{ {
boolean retVal = n_empty(nativeObj); boolean retVal = n_empty(nativeObj);
return retVal; return retVal;
} }
// //
// C++: static Mat Mat::eye(int rows, int cols, int type) // C++: static Mat Mat::eye(int rows, int cols, int type)
// //
// javadoc: Mat::eye(rows, cols, type) // javadoc: Mat::eye(rows, cols, type)
public static Mat eye(int rows, int cols, int type) public static Mat eye(int rows, int cols, int type)
{ {
Mat retVal = new Mat(n_eye(rows, cols, type)); Mat retVal = new Mat(n_eye(rows, cols, type));
return retVal; return retVal;
} }
// //
// C++: static Mat Mat::eye(Size size, int type) // C++: static Mat Mat::eye(Size size, int type)
// //
// javadoc: Mat::eye(size, type) // javadoc: Mat::eye(size, type)
public static Mat eye(Size size, int type) public static Mat eye(Size size, int type)
{ {
Mat retVal = new Mat(n_eye(size.width, size.height, type)); Mat retVal = new Mat(n_eye(size.width, size.height, type));
return retVal; return retVal;
} }
// //
// C++: Mat Mat::inv(int method = DECOMP_LU) // C++: Mat Mat::inv(int method = DECOMP_LU)
// //
// javadoc: Mat::inv(method) // javadoc: Mat::inv(method)
public Mat inv(int method) public Mat inv(int method)
{ {
Mat retVal = new Mat(n_inv(nativeObj, method)); Mat retVal = new Mat(n_inv(nativeObj, method));
return retVal; return retVal;
} }
// javadoc: Mat::inv() // javadoc: Mat::inv()
public Mat inv() public Mat inv()
{ {
Mat retVal = new Mat(n_inv(nativeObj)); Mat retVal = new Mat(n_inv(nativeObj));
return retVal; return retVal;
} }
// //
// C++: bool Mat::isContinuous() // C++: bool Mat::isContinuous()
// //
// javadoc: Mat::isContinuous() // javadoc: Mat::isContinuous()
public boolean isContinuous() public boolean isContinuous()
{ {
boolean retVal = n_isContinuous(nativeObj); boolean retVal = n_isContinuous(nativeObj);
return retVal; return retVal;
} }
// //
// C++: bool Mat::isSubmatrix() // C++: bool Mat::isSubmatrix()
// //
// javadoc: Mat::isSubmatrix() // javadoc: Mat::isSubmatrix()
public boolean isSubmatrix() public boolean isSubmatrix()
{ {
boolean retVal = n_isSubmatrix(nativeObj); boolean retVal = n_isSubmatrix(nativeObj);
return retVal; return retVal;
} }
// //
// C++: void Mat::locateROI(Size wholeSize, Point ofs) // C++: void Mat::locateROI(Size wholeSize, Point ofs)
// //
// javadoc: Mat::locateROI(wholeSize, ofs) // javadoc: Mat::locateROI(wholeSize, ofs)
public void locateROI(Size wholeSize, Point ofs) public void locateROI(Size wholeSize, Point ofs)
{ {
double[] wholeSize_out = new double[2]; double[] wholeSize_out = new double[2];
double[] ofs_out = new double[2]; double[] ofs_out = new double[2];
locateROI_0(nativeObj, wholeSize_out, ofs_out); locateROI_0(nativeObj, wholeSize_out, ofs_out);
if(wholeSize!=null){ wholeSize.width = wholeSize_out[0]; wholeSize.height = wholeSize_out[1]; } 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]; } if(ofs!=null){ ofs.x = ofs_out[0]; ofs.y = ofs_out[1]; }
return; return;
} }
// //
// C++: Mat Mat::mul(Mat m, double scale = 1) // C++: Mat Mat::mul(Mat m, double scale = 1)
// //
// javadoc: Mat::mul(m, scale) // javadoc: Mat::mul(m, scale)
public Mat mul(Mat m, double scale) public Mat mul(Mat m, double scale)
{ {
Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj, scale)); Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj, scale));
return retVal; return retVal;
} }
// javadoc: Mat::mul(m) // javadoc: Mat::mul(m)
public Mat mul(Mat m) public Mat mul(Mat m)
{ {
Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj)); Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj));
return retVal; return retVal;
} }
// //
// C++: static Mat Mat::ones(int rows, int cols, int type) // C++: static Mat Mat::ones(int rows, int cols, int type)
// //
// javadoc: Mat::ones(rows, cols, type) // javadoc: Mat::ones(rows, cols, type)
public static Mat ones(int rows, int cols, int type) public static Mat ones(int rows, int cols, int type)
{ {
Mat retVal = new Mat(n_ones(rows, cols, type)); Mat retVal = new Mat(n_ones(rows, cols, type));
return retVal; return retVal;
} }
// //
// C++: static Mat Mat::ones(Size size, int type) // C++: static Mat Mat::ones(Size size, int type)
// //
// javadoc: Mat::ones(size, type) // javadoc: Mat::ones(size, type)
public static Mat ones(Size size, int type) public static Mat ones(Size size, int type)
{ {
Mat retVal = new Mat(n_ones(size.width, size.height, type)); Mat retVal = new Mat(n_ones(size.width, size.height, type));
return retVal; return retVal;
} }
// //
// C++: void Mat::push_back(Mat m) // C++: void Mat::push_back(Mat m)
// //
// javadoc: Mat::push_back(m) // javadoc: Mat::push_back(m)
public void push_back(Mat m) public void push_back(Mat m)
{ {
n_push_back(nativeObj, m.nativeObj); n_push_back(nativeObj, m.nativeObj);
return; return;
} }
// //
// C++: void Mat::release() // C++: void Mat::release()
// //
// javadoc: Mat::release() // javadoc: Mat::release()
public void release() public void release()
{ {
n_release(nativeObj); n_release(nativeObj);
return; return;
} }
// //
// C++: Mat Mat::reshape(int cn, int rows = 0) // C++: Mat Mat::reshape(int cn, int rows = 0)
// //
// javadoc: Mat::reshape(cn, rows) // javadoc: Mat::reshape(cn, rows)
public Mat reshape(int cn, int rows) public Mat reshape(int cn, int rows)
{ {
Mat retVal = new Mat(n_reshape(nativeObj, cn, rows)); Mat retVal = new Mat(n_reshape(nativeObj, cn, rows));
return retVal; return retVal;
} }
// javadoc: Mat::reshape(cn) // javadoc: Mat::reshape(cn)
public Mat reshape(int cn) public Mat reshape(int cn)
{ {
Mat retVal = new Mat(n_reshape(nativeObj, cn)); Mat retVal = new Mat(n_reshape(nativeObj, cn));
return retVal; return retVal;
} }
// //
// C++: Mat Mat::row(int y) // C++: Mat Mat::row(int y)
// //
// javadoc: Mat::row(y) // javadoc: Mat::row(y)
public Mat row(int y) public Mat row(int y)
{ {
Mat retVal = new Mat(n_row(nativeObj, y)); Mat retVal = new Mat(n_row(nativeObj, y));
return retVal; return retVal;
} }
// //
// C++: Mat Mat::rowRange(int startrow, int endrow) // C++: Mat Mat::rowRange(int startrow, int endrow)
// //
// javadoc: Mat::rowRange(startrow, endrow) // javadoc: Mat::rowRange(startrow, endrow)
public Mat rowRange(int startrow, int endrow) public Mat rowRange(int startrow, int endrow)
{ {
Mat retVal = new Mat(n_rowRange(nativeObj, startrow, endrow)); Mat retVal = new Mat(n_rowRange(nativeObj, startrow, endrow));
return retVal; return retVal;
} }
// //
// C++: Mat Mat::rowRange(Range r) // C++: Mat Mat::rowRange(Range r)
// //
// javadoc: Mat::rowRange(r) // javadoc: Mat::rowRange(r)
public Mat rowRange(Range r) public Mat rowRange(Range r)
{ {
Mat retVal = new Mat(n_rowRange(nativeObj, r.start, r.end)); Mat retVal = new Mat(n_rowRange(nativeObj, r.start, r.end));
return retVal; return retVal;
} }
// //
// C++: int Mat::rows() // C++: int Mat::rows()
// //
// javadoc: Mat::rows() // javadoc: Mat::rows()
public int rows() public int rows()
{ {
int retVal = n_rows(nativeObj); int retVal = n_rows(nativeObj);
return retVal; return retVal;
} }
// //
// C++: Mat Mat::operator =(Scalar s) // C++: Mat Mat::operator =(Scalar s)
// //
// javadoc: Mat::operator =(s) // javadoc: Mat::operator =(s)
public Mat setTo(Scalar 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])); Mat retVal = new Mat(n_setTo(nativeObj, s.val[0], s.val[1], s.val[2], s.val[3]));
return retVal; return retVal;
} }
// //
// C++: Mat Mat::setTo(Mat value, Mat mask = Mat()) // C++: Mat Mat::setTo(Mat value, Mat mask = Mat())
// //
// javadoc: Mat::setTo(value, mask) // javadoc: Mat::setTo(value, mask)
public Mat setTo(Mat value, Mat mask) public Mat setTo(Mat value, Mat mask)
{ {
Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj, mask.nativeObj)); Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj, mask.nativeObj));
return retVal; return retVal;
} }
// javadoc: Mat::setTo(value) // javadoc: Mat::setTo(value)
public Mat setTo(Mat value) public Mat setTo(Mat value)
{ {
Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj)); Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj));
return retVal; return retVal;
} }
// //
// C++: Size Mat::size() // C++: Size Mat::size()
// //
// javadoc: Mat::size() // javadoc: Mat::size()
public Size size() public Size size()
{ {
Size retVal = new Size(n_size(nativeObj)); Size retVal = new Size(n_size(nativeObj));
return retVal; return retVal;
} }
// //
// C++: size_t Mat::step1(int i = 0) // C++: size_t Mat::step1(int i = 0)
// //
// javadoc: Mat::step1(i) // javadoc: Mat::step1(i)
public long step1(int i) public long step1(int i)
{ {
long retVal = n_step1(nativeObj, i); long retVal = n_step1(nativeObj, i);
return retVal; return retVal;
} }
// javadoc: Mat::step1() // javadoc: Mat::step1()
public long step1() public long step1()
{ {
long retVal = n_step1(nativeObj); long retVal = n_step1(nativeObj);
return retVal; return retVal;
} }
// //
// C++: Mat Mat::operator()(int rowStart, int rowEnd, int colStart, int // C++: Mat Mat::operator()(int rowStart, int rowEnd, int colStart, int
// colEnd) // colEnd)
// //
// javadoc: Mat::operator()(rowStart, rowEnd, colStart, colEnd) // javadoc: Mat::operator()(rowStart, rowEnd, colStart, colEnd)
public Mat submat(int rowStart, int rowEnd, int colStart, int colEnd) public Mat submat(int rowStart, int rowEnd, int colStart, int colEnd)
{ {
Mat retVal = new Mat(n_submat_rr(nativeObj, rowStart, rowEnd, colStart, colEnd)); Mat retVal = new Mat(n_submat_rr(nativeObj, rowStart, rowEnd, colStart, colEnd));
return retVal; return retVal;
} }
// //
// C++: Mat Mat::operator()(Range rowRange, Range colRange) // C++: Mat Mat::operator()(Range rowRange, Range colRange)
// //
// javadoc: Mat::operator()(rowRange, colRange) // javadoc: Mat::operator()(rowRange, colRange)
public Mat submat(Range rowRange, Range colRange) public Mat submat(Range rowRange, Range colRange)
{ {
Mat retVal = new Mat(n_submat_rr(nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end)); Mat retVal = new Mat(n_submat_rr(nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end));
return retVal; return retVal;
} }
// //
// C++: Mat Mat::operator()(Rect roi) // C++: Mat Mat::operator()(Rect roi)
// //
// javadoc: Mat::operator()(roi) // javadoc: Mat::operator()(roi)
public Mat submat(Rect roi) public Mat submat(Rect roi)
{ {
Mat retVal = new Mat(n_submat(nativeObj, roi.x, roi.y, roi.width, roi.height)); Mat retVal = new Mat(n_submat(nativeObj, roi.x, roi.y, roi.width, roi.height));
return retVal; return retVal;
} }
// //
// C++: Mat Mat::t() // C++: Mat Mat::t()
// //
// javadoc: Mat::t() // javadoc: Mat::t()
public Mat t() public Mat t()
{ {
Mat retVal = new Mat(n_t(nativeObj)); Mat retVal = new Mat(n_t(nativeObj));
return retVal; return retVal;
} }
// //
// C++: size_t Mat::total() // C++: size_t Mat::total()
// //
// javadoc: Mat::total() // javadoc: Mat::total()
public long total() public long total()
{ {
long retVal = n_total(nativeObj); long retVal = n_total(nativeObj);
return retVal; return retVal;
} }
// //
// C++: int Mat::type() // C++: int Mat::type()
// //
// javadoc: Mat::type() // javadoc: Mat::type()
public int type() public int type()
{ {
int retVal = n_type(nativeObj); int retVal = n_type(nativeObj);
return retVal; return retVal;
} }
// //
// C++: static Mat Mat::zeros(int rows, int cols, int type) // C++: static Mat Mat::zeros(int rows, int cols, int type)
// //
// javadoc: Mat::zeros(rows, cols, type) // javadoc: Mat::zeros(rows, cols, type)
public static Mat zeros(int rows, int cols, int type) public static Mat zeros(int rows, int cols, int type)
{ {
Mat retVal = new Mat(n_zeros(rows, cols, type)); Mat retVal = new Mat(n_zeros(rows, cols, type));
return retVal; return retVal;
} }
// //
// C++: static Mat Mat::zeros(Size size, int type) // C++: static Mat Mat::zeros(Size size, int type)
// //
// javadoc: Mat::zeros(size, type) // javadoc: Mat::zeros(size, type)
public static Mat zeros(Size size, int type) public static Mat zeros(Size size, int type)
{ {
Mat retVal = new Mat(n_zeros(size.width, size.height, type)); Mat retVal = new Mat(n_zeros(size.width, size.height, type));
return retVal; return retVal;
} }
@Override @Override
protected void finalize() throws Throwable { protected void finalize() throws Throwable {
n_delete(nativeObj); n_delete(nativeObj);
super.finalize(); super.finalize();
} }
// javadoc:Mat::toString() // javadoc:Mat::toString()
@Override @Override
public String toString() { public String toString() {
return "Mat [ " + return "Mat [ " +
rows() + "*" + cols() + "*" + CvType.typeToString(type()) + rows() + "*" + cols() + "*" + CvType.typeToString(type()) +
", isCont=" + isContinuous() + ", isSubmat=" + isSubmatrix() + ", isCont=" + isContinuous() + ", isSubmat=" + isSubmatrix() +
", nativeObj=0x" + Long.toHexString(nativeObj) + ", nativeObj=0x" + Long.toHexString(nativeObj) +
", dataAddr=0x" + Long.toHexString(dataAddr()) + ", dataAddr=0x" + Long.toHexString(dataAddr()) +
" ]"; " ]";
} }
// javadoc:Mat::dump() // javadoc:Mat::dump()
public String dump() { public String dump() {
return nDump(nativeObj); return nDump(nativeObj);
} }
// javadoc:Mat::put(row,col,data) // javadoc:Mat::put(row,col,data)
public int put(int row, int col, double... data) { public int put(int row, int col, double... data) {
int t = type(); int t = type();
if (data == null || data.length % CvType.channels(t) != 0) if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException( throw new java.lang.UnsupportedOperationException(
"Provided data element number (" + "Provided data element number (" +
(data == null ? 0 : data.length) + (data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" + ") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")"); CvType.channels(t) + ")");
return nPutD(nativeObj, row, col, data.length, data); return nPutD(nativeObj, row, col, data.length, data);
} }
// javadoc:Mat::put(row,col,data) // javadoc:Mat::put(row,col,data)
public int put(int row, int col, float[] data) { public int put(int row, int col, float[] data) {
int t = type(); int t = type();
if (data == null || data.length % CvType.channels(t) != 0) if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException( throw new java.lang.UnsupportedOperationException(
"Provided data element number (" + "Provided data element number (" +
(data == null ? 0 : data.length) + (data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" + ") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")"); CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_32F) { if (CvType.depth(t) == CvType.CV_32F) {
return nPutF(nativeObj, row, col, data.length, data); return nPutF(nativeObj, row, col, data.length, data);
} }
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
} }
// javadoc:Mat::put(row,col,data) // javadoc:Mat::put(row,col,data)
public int put(int row, int col, int[] data) { public int put(int row, int col, int[] data) {
int t = type(); int t = type();
if (data == null || data.length % CvType.channels(t) != 0) if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException( throw new java.lang.UnsupportedOperationException(
"Provided data element number (" + "Provided data element number (" +
(data == null ? 0 : data.length) + (data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" + ") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")"); CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_32S) { if (CvType.depth(t) == CvType.CV_32S) {
return nPutI(nativeObj, row, col, data.length, data); return nPutI(nativeObj, row, col, data.length, data);
} }
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
} }
// javadoc:Mat::put(row,col,data) // javadoc:Mat::put(row,col,data)
public int put(int row, int col, short[] data) { public int put(int row, int col, short[] data) {
int t = type(); int t = type();
if (data == null || data.length % CvType.channels(t) != 0) if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException( throw new java.lang.UnsupportedOperationException(
"Provided data element number (" + "Provided data element number (" +
(data == null ? 0 : data.length) + (data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" + ") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")"); CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) { if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
return nPutS(nativeObj, row, col, data.length, data); return nPutS(nativeObj, row, col, data.length, data);
} }
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
} }
// javadoc:Mat::put(row,col,data) // javadoc:Mat::put(row,col,data)
public int put(int row, int col, byte[] data) { public int put(int row, int col, byte[] data) {
int t = type(); int t = type();
if (data == null || data.length % CvType.channels(t) != 0) if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException( throw new java.lang.UnsupportedOperationException(
"Provided data element number (" + "Provided data element number (" +
(data == null ? 0 : data.length) + (data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" + ") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")"); CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) { if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
return nPutB(nativeObj, row, col, data.length, data); return nPutB(nativeObj, row, col, data.length, data);
} }
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
} }
// javadoc:Mat::get(row,col,data) // javadoc:Mat::get(row,col,data)
public int get(int row, int col, byte[] data) { public int get(int row, int col, byte[] data) {
int t = type(); int t = type();
if (data == null || data.length % CvType.channels(t) != 0) if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException( throw new java.lang.UnsupportedOperationException(
"Provided data element number (" + "Provided data element number (" +
(data == null ? 0 : data.length) + (data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" + ") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")"); CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) { if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
return nGetB(nativeObj, row, col, data.length, data); return nGetB(nativeObj, row, col, data.length, data);
} }
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
} }
// javadoc:Mat::get(row,col,data) // javadoc:Mat::get(row,col,data)
public int get(int row, int col, short[] data) { public int get(int row, int col, short[] data) {
int t = type(); int t = type();
if (data == null || data.length % CvType.channels(t) != 0) if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException( throw new java.lang.UnsupportedOperationException(
"Provided data element number (" + "Provided data element number (" +
(data == null ? 0 : data.length) + (data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" + ") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")"); CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) { if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
return nGetS(nativeObj, row, col, data.length, data); return nGetS(nativeObj, row, col, data.length, data);
} }
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
} }
// javadoc:Mat::get(row,col,data) // javadoc:Mat::get(row,col,data)
public int get(int row, int col, int[] data) { public int get(int row, int col, int[] data) {
int t = type(); int t = type();
if (data == null || data.length % CvType.channels(t) != 0) if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException( throw new java.lang.UnsupportedOperationException(
"Provided data element number (" + "Provided data element number (" +
(data == null ? 0 : data.length) + (data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" + ") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")"); CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_32S) { if (CvType.depth(t) == CvType.CV_32S) {
return nGetI(nativeObj, row, col, data.length, data); return nGetI(nativeObj, row, col, data.length, data);
} }
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
} }
// javadoc:Mat::get(row,col,data) // javadoc:Mat::get(row,col,data)
public int get(int row, int col, float[] data) { public int get(int row, int col, float[] data) {
int t = type(); int t = type();
if (data == null || data.length % CvType.channels(t) != 0) if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException( throw new java.lang.UnsupportedOperationException(
"Provided data element number (" + "Provided data element number (" +
(data == null ? 0 : data.length) + (data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" + ") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")"); CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_32F) { if (CvType.depth(t) == CvType.CV_32F) {
return nGetF(nativeObj, row, col, data.length, data); return nGetF(nativeObj, row, col, data.length, data);
} }
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
} }
// javadoc:Mat::get(row,col,data) // javadoc:Mat::get(row,col,data)
public int get(int row, int col, double[] data) { public int get(int row, int col, double[] data) {
int t = type(); int t = type();
if (data == null || data.length % CvType.channels(t) != 0) if (data == null || data.length % CvType.channels(t) != 0)
throw new java.lang.UnsupportedOperationException( throw new java.lang.UnsupportedOperationException(
"Provided data element number (" + "Provided data element number (" +
(data == null ? 0 : data.length) + (data == null ? 0 : data.length) +
") should be multiple of the Mat channels count (" + ") should be multiple of the Mat channels count (" +
CvType.channels(t) + ")"); CvType.channels(t) + ")");
if (CvType.depth(t) == CvType.CV_64F) { if (CvType.depth(t) == CvType.CV_64F) {
return nGetD(nativeObj, row, col, data.length, data); return nGetD(nativeObj, row, col, data.length, data);
} }
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t); throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
} }
// javadoc:Mat::get(row,col) // javadoc:Mat::get(row,col)
public double[] get(int row, int col) { public double[] get(int row, int col) {
return nGet(nativeObj, row, col); return nGet(nativeObj, row, col);
} }
// javadoc:Mat::height() // javadoc:Mat::height()
public int height() { public int height() {
return rows(); return rows();
} }
// javadoc:Mat::width() // javadoc:Mat::width()
public int width() { public int width() {
return cols(); return cols();
} }
// javadoc:Mat::getNativeObjAddr() // javadoc:Mat::getNativeObjAddr()
public long getNativeObjAddr() { public long getNativeObjAddr() {
return nativeObj; return nativeObj;
} }
// C++: Mat::Mat() //
private static native long n_Mat(); // native stuff
//
// C++: Mat::Mat(int rows, int cols, int type) static {
private static native long n_Mat(int rows, int cols, int type); System.loadLibrary("opencv_java");
}
// C++: Mat::Mat(Size size, int type)
private static native long n_Mat(double size_width, double size_height, int type); // C++: Mat::Mat()
private static native long n_Mat();
// 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(int rows, int cols, int type)
private static native long n_Mat(int rows, int cols, int type);
// 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(Size size, int type)
private static native long n_Mat(double size_width, double size_height, int type);
// 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); // 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);
private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end);
// C++: Mat::Mat(Size size, int type, Scalar s)
// C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright) 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);
private static native long n_adjustROI(long nativeObj, int dtop, int dbottom, int dleft, int dright);
// C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())
// C++: void Mat::assignTo(Mat m, int type = -1) private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end);
private static native void n_assignTo(long nativeObj, long m_nativeObj, int type);
private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end);
private static native void n_assignTo(long nativeObj, long m_nativeObj);
// C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)
// C++: int Mat::channels() private static native long n_adjustROI(long nativeObj, int dtop, int dbottom, int dleft, int dright);
private static native int n_channels(long nativeObj);
// C++: void Mat::assignTo(Mat m, int type = -1)
// C++: int Mat::checkVector(int elemChannels, int depth = -1, bool private static native void n_assignTo(long nativeObj, long m_nativeObj, int type);
// requireContinuous = true)
private static native int n_checkVector(long nativeObj, int elemChannels, int depth, boolean requireContinuous); private static native void n_assignTo(long nativeObj, long m_nativeObj);
private static native int n_checkVector(long nativeObj, int elemChannels, int depth); // C++: int Mat::channels()
private static native int n_channels(long nativeObj);
private static native int n_checkVector(long nativeObj, int elemChannels);
// C++: int Mat::checkVector(int elemChannels, int depth = -1, bool
// C++: Mat Mat::clone() // requireContinuous = true)
private static native long n_clone(long nativeObj); private static native int n_checkVector(long nativeObj, int elemChannels, int depth, boolean requireContinuous);
// C++: Mat Mat::col(int x) private static native int n_checkVector(long nativeObj, int elemChannels, int depth);
private static native long n_col(long nativeObj, int x);
private static native int n_checkVector(long nativeObj, int elemChannels);
// C++: Mat Mat::colRange(int startcol, int endcol)
private static native long n_colRange(long nativeObj, int startcol, int endcol); // C++: Mat Mat::clone()
private static native long n_clone(long nativeObj);
// C++: int Mat::cols()
private static native int n_cols(long nativeObj); // C++: Mat Mat::col(int x)
private static native long n_col(long nativeObj, int x);
// C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta
// = 0) // C++: Mat Mat::colRange(int startcol, int endcol)
private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha, double beta); private static native long n_colRange(long nativeObj, int startcol, int endcol);
private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha); // C++: int Mat::cols()
private static native int n_cols(long nativeObj);
private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype);
// C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta
// C++: void Mat::copyTo(Mat& m) // = 0)
private static native void n_copyTo(long nativeObj, long m_nativeObj); private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha, double beta);
// C++: void Mat::copyTo(Mat& m, Mat mask) private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha);
private static native void n_copyTo(long nativeObj, long m_nativeObj, long mask_nativeObj);
private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype);
// 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::copyTo(Mat& m)
private static native void n_copyTo(long nativeObj, long m_nativeObj);
// 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::copyTo(Mat& m, Mat mask)
private static native void n_copyTo(long nativeObj, long m_nativeObj, long mask_nativeObj);
// C++: Mat Mat::cross(Mat m)
private static native long n_cross(long nativeObj, long m_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++: long Mat::dataAddr()
private static native long n_dataAddr(long nativeObj); // 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++: int Mat::depth()
private static native int n_depth(long nativeObj); // C++: Mat Mat::cross(Mat m)
private static native long n_cross(long nativeObj, long m_nativeObj);
// C++: Mat Mat::diag(int d = 0)
private static native long n_diag(long nativeObj, int d); // C++: long Mat::dataAddr()
private static native long n_dataAddr(long nativeObj);
// C++: static Mat Mat::diag(Mat d)
private static native long n_diag(long d_nativeObj); // C++: int Mat::depth()
private static native int n_depth(long nativeObj);
// C++: double Mat::dot(Mat m)
private static native double n_dot(long nativeObj, long m_nativeObj); // C++: Mat Mat::diag(int d = 0)
private static native long n_diag(long nativeObj, int d);
// C++: size_t Mat::elemSize()
private static native long n_elemSize(long nativeObj); // C++: static Mat Mat::diag(Mat d)
private static native long n_diag(long d_nativeObj);
// C++: size_t Mat::elemSize1()
private static native long n_elemSize1(long nativeObj); // C++: double Mat::dot(Mat m)
private static native double n_dot(long nativeObj, long m_nativeObj);
// C++: bool Mat::empty()
private static native boolean n_empty(long nativeObj); // C++: size_t Mat::elemSize()
private static native long n_elemSize(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++: size_t Mat::elemSize1()
private static native long n_elemSize1(long nativeObj);
// C++: static Mat Mat::eye(Size size, int type)
private static native long n_eye(double size_width, double size_height, int type); // C++: bool Mat::empty()
private static native boolean n_empty(long nativeObj);
// C++: Mat Mat::inv(int method = DECOMP_LU)
private static native long n_inv(long nativeObj, int method); // C++: static Mat Mat::eye(int rows, int cols, int type)
private static native long n_eye(int rows, int cols, int type);
private static native long n_inv(long nativeObj);
// C++: static Mat Mat::eye(Size size, int type)
// C++: bool Mat::isContinuous() private static native long n_eye(double size_width, double size_height, int type);
private static native boolean n_isContinuous(long nativeObj);
// C++: Mat Mat::inv(int method = DECOMP_LU)
// C++: bool Mat::isSubmatrix() private static native long n_inv(long nativeObj, int method);
private static native boolean n_isSubmatrix(long nativeObj);
private static native long n_inv(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++: bool Mat::isContinuous()
private static native boolean n_isContinuous(long nativeObj);
// C++: Mat Mat::mul(Mat m, double scale = 1)
private static native long n_mul(long nativeObj, long m_nativeObj, double scale); // C++: bool Mat::isSubmatrix()
private static native boolean n_isSubmatrix(long nativeObj);
private static native long n_mul(long nativeObj, long m_nativeObj);
// C++: void Mat::locateROI(Size wholeSize, Point ofs)
// C++: static Mat Mat::ones(int rows, int cols, int type) private static native void locateROI_0(long nativeObj, double[] wholeSize_out, double[] ofs_out);
private static native long n_ones(int rows, int cols, int type);
// C++: Mat Mat::mul(Mat m, double scale = 1)
// C++: static Mat Mat::ones(Size size, int type) private static native long n_mul(long nativeObj, long m_nativeObj, double scale);
private static native long n_ones(double size_width, double size_height, int type);
private static native long n_mul(long nativeObj, long m_nativeObj);
// C++: void Mat::push_back(Mat m)
private static native void n_push_back(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++: void Mat::release()
private static native void n_release(long nativeObj); // C++: static Mat Mat::ones(Size size, int type)
private static native long n_ones(double size_width, double size_height, int type);
// C++: Mat Mat::reshape(int cn, int rows = 0)
private static native long n_reshape(long nativeObj, int cn, int rows); // C++: void Mat::push_back(Mat m)
private static native void n_push_back(long nativeObj, long m_nativeObj);
private static native long n_reshape(long nativeObj, int cn);
// C++: void Mat::release()
// C++: Mat Mat::row(int y) private static native void n_release(long nativeObj);
private static native long n_row(long nativeObj, int y);
// C++: Mat Mat::reshape(int cn, int rows = 0)
// C++: Mat Mat::rowRange(int startrow, int endrow) private static native long n_reshape(long nativeObj, int cn, int rows);
private static native long n_rowRange(long nativeObj, int startrow, int endrow);
private static native long n_reshape(long nativeObj, int cn);
// C++: int Mat::rows()
private static native int n_rows(long nativeObj); // C++: Mat Mat::row(int y)
private static native long n_row(long nativeObj, int y);
// 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::rowRange(int startrow, int endrow)
private static native long n_rowRange(long nativeObj, int startrow, int endrow);
// C++: Mat Mat::setTo(Mat value, Mat mask = Mat())
private static native long n_setTo(long nativeObj, long value_nativeObj, long mask_nativeObj); // C++: int Mat::rows()
private static native int n_rows(long nativeObj);
private static native long n_setTo(long nativeObj, long value_nativeObj);
// C++: Mat Mat::operator =(Scalar s)
// C++: Size Mat::size() private static native long n_setTo(long nativeObj, double s_val0, double s_val1, double s_val2, double s_val3);
private static native double[] n_size(long nativeObj);
// C++: Mat Mat::setTo(Mat value, Mat mask = Mat())
// C++: size_t Mat::step1(int i = 0) private static native long n_setTo(long nativeObj, long value_nativeObj, long mask_nativeObj);
private static native long n_step1(long nativeObj, int i);
private static native long n_setTo(long nativeObj, long value_nativeObj);
private static native long n_step1(long nativeObj);
// C++: Size Mat::size()
// C++: Mat Mat::operator()(Range rowRange, Range colRange) private static native double[] n_size(long nativeObj);
private static native long n_submat_rr(long nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end);
// C++: size_t Mat::step1(int i = 0)
// C++: Mat Mat::operator()(Rect roi) private static native long n_step1(long nativeObj, int i);
private static native long n_submat(long nativeObj, int roi_x, int roi_y, int roi_width, int roi_height);
private static native long n_step1(long nativeObj);
// C++: Mat Mat::t()
private static native long n_t(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++: size_t Mat::total()
private static native long n_total(long nativeObj); // 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++: int Mat::type()
private static native int n_type(long nativeObj); // C++: Mat Mat::t()
private static native long n_t(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++: size_t Mat::total()
private static native long n_total(long nativeObj);
// C++: static Mat Mat::zeros(Size size, int type)
private static native long n_zeros(double size_width, double size_height, int type); // C++: int Mat::type()
private static native int n_type(long nativeObj);
// native support for java finalize()
private static native void n_delete(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);
private static native int nPutD(long self, int row, int col, int count, double[] data);
// C++: static Mat Mat::zeros(Size size, int type)
private static native int nPutF(long self, int row, int col, int count, float[] data); private static native long n_zeros(double size_width, double size_height, int type);
private static native int nPutI(long self, int row, int col, int count, int[] data); // native support for java finalize()
private static native void n_delete(long nativeObj);
private static native int nPutS(long self, int row, int col, int count, short[] data);
private static native int nPutD(long self, int row, int col, int count, double[] data);
private static native int nPutB(long self, int row, int col, int count, byte[] data);
private static native int nPutF(long self, int row, int col, int count, float[] data);
private static native int nGetB(long self, int row, int col, int count, byte[] vals);
private static native int nPutI(long self, int row, int col, int count, int[] data);
private static native int nGetS(long self, int row, int col, int count, short[] vals);
private static native int nPutS(long self, int row, int col, int count, short[] data);
private static native int nGetI(long self, int row, int col, int count, int[] vals);
private static native int nPutB(long self, int row, int col, int count, byte[] data);
private static native int nGetF(long self, int row, int col, int count, float[] vals);
private static native int nGetB(long self, int row, int col, int count, byte[] vals);
private static native int nGetD(long self, int row, int col, int count, double[] vals);
private static native int nGetS(long self, int row, int col, int count, short[] vals);
private static native double[] nGet(long self, int row, int col);
private static native int nGetI(long self, int row, int col, int count, int[] vals);
private static native String nDump(long self);
} private static native int nGetF(long self, int row, int col, int count, float[] vals);
private static native int nGetD(long self, int row, int col, int count, double[] vals);
private static native double[] nGet(long self, int row, int col);
private static native String nDump(long self);
}
modules/java/src/java/highgui+VideoCapture.java
View file @ c1c1a376
...@@ -194,6 +194,12 @@ public class VideoCapture { ...@@ -194,6 +194,12 @@ public class VideoCapture {
super.finalize(); super.finalize();
} }
// native stuff
static {
System.loadLibrary("opencv_java");
}
// C++: VideoCapture::VideoCapture() // C++: VideoCapture::VideoCapture()
private static native long n_VideoCapture(); private static native long n_VideoCapture();
......
modules/java/src/java/utils+Converters.java
View file @ c1c1a376
package org.opencv.utils; package org.opencv.utils;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import org.opencv.core.CvType; import org.opencv.core.CvType;
import org.opencv.core.Mat; import org.opencv.core.Mat;
import org.opencv.core.MatOfByte; import org.opencv.core.MatOfByte;
import org.opencv.core.MatOfDMatch; import org.opencv.core.MatOfDMatch;
import org.opencv.core.MatOfKeyPoint; import org.opencv.core.MatOfKeyPoint;
import org.opencv.core.MatOfPoint; import org.opencv.core.MatOfPoint;
import org.opencv.core.MatOfPoint2f; import org.opencv.core.MatOfPoint2f;
import org.opencv.core.MatOfPoint3f; import org.opencv.core.MatOfPoint3f;
import org.opencv.core.Point; import org.opencv.core.Point;
import org.opencv.core.Point3; import org.opencv.core.Point3;
import org.opencv.core.Rect; import org.opencv.core.Rect;
import org.opencv.features2d.DMatch; import org.opencv.features2d.DMatch;
import org.opencv.features2d.KeyPoint; import org.opencv.features2d.KeyPoint;
public class Converters { public class Converters {
public static Mat vector_Point_to_Mat(List<Point> pts) { public static Mat vector_Point_to_Mat(List<Point> pts) {
return vector_Point_to_Mat(pts, CvType.CV_32S); return vector_Point_to_Mat(pts, CvType.CV_32S);
} }
public static Mat vector_Point2f_to_Mat(List<Point> pts) { public static Mat vector_Point2f_to_Mat(List<Point> pts) {
return vector_Point_to_Mat(pts, CvType.CV_32F); return vector_Point_to_Mat(pts, CvType.CV_32F);
} }
public static Mat vector_Point2d_to_Mat(List<Point> pts) { public static Mat vector_Point2d_to_Mat(List<Point> pts) {
return vector_Point_to_Mat(pts, CvType.CV_64F); return vector_Point_to_Mat(pts, CvType.CV_64F);
} }
public static Mat vector_Point_to_Mat(List<Point> pts, int typeDepth) { public static Mat vector_Point_to_Mat(List<Point> pts, int typeDepth) {
Mat res; Mat res;
int count = (pts != null) ? pts.size() : 0; int count = (pts != null) ? pts.size() : 0;
if (count > 0) { if (count > 0) {
switch (typeDepth) { switch (typeDepth) {
case CvType.CV_32S: { case CvType.CV_32S: {
res = new Mat(count, 1, CvType.CV_32SC2); res = new Mat(count, 1, CvType.CV_32SC2);
int[] buff = new int[count * 2]; int[] buff = new int[count * 2];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
Point p = pts.get(i); Point p = pts.get(i);
buff[i * 2] = (int) p.x; buff[i * 2] = (int) p.x;
buff[i * 2 + 1] = (int) p.y; buff[i * 2 + 1] = (int) p.y;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} }
break; break;
case CvType.CV_32F: { case CvType.CV_32F: {
res = new Mat(count, 1, CvType.CV_32FC2); res = new Mat(count, 1, CvType.CV_32FC2);
float[] buff = new float[count * 2]; float[] buff = new float[count * 2];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
Point p = pts.get(i); Point p = pts.get(i);
buff[i * 2] = (float) p.x; buff[i * 2] = (float) p.x;
buff[i * 2 + 1] = (float) p.y; buff[i * 2 + 1] = (float) p.y;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} }
break; break;
case CvType.CV_64F: { case CvType.CV_64F: {
res = new Mat(count, 1, CvType.CV_64FC2); res = new Mat(count, 1, CvType.CV_64FC2);
double[] buff = new double[count * 2]; double[] buff = new double[count * 2];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
Point p = pts.get(i); Point p = pts.get(i);
buff[i * 2] = p.x; buff[i * 2] = p.x;
buff[i * 2 + 1] = p.y; buff[i * 2 + 1] = p.y;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} }
break; break;
default: default:
throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F"); throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F");
} }
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static Mat vector_Point3i_to_Mat(List<Point3> pts) { public static Mat vector_Point3i_to_Mat(List<Point3> pts) {
return vector_Point3_to_Mat(pts, CvType.CV_32S); return vector_Point3_to_Mat(pts, CvType.CV_32S);
} }
public static Mat vector_Point3f_to_Mat(List<Point3> pts) { public static Mat vector_Point3f_to_Mat(List<Point3> pts) {
return vector_Point3_to_Mat(pts, CvType.CV_32F); return vector_Point3_to_Mat(pts, CvType.CV_32F);
} }
public static Mat vector_Point3d_to_Mat(List<Point3> pts) { public static Mat vector_Point3d_to_Mat(List<Point3> pts) {
return vector_Point3_to_Mat(pts, CvType.CV_64F); return vector_Point3_to_Mat(pts, CvType.CV_64F);
} }
public static Mat vector_Point3_to_Mat(List<Point3> pts, int typeDepth) { public static Mat vector_Point3_to_Mat(List<Point3> pts, int typeDepth) {
Mat res; Mat res;
int count = (pts != null) ? pts.size() : 0; int count = (pts != null) ? pts.size() : 0;
if (count > 0) { if (count > 0) {
switch (typeDepth) { switch (typeDepth) {
case CvType.CV_32S: { case CvType.CV_32S: {
res = new Mat(count, 1, CvType.CV_32SC3); res = new Mat(count, 1, CvType.CV_32SC3);
int[] buff = new int[count * 3]; int[] buff = new int[count * 3];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
Point3 p = pts.get(i); Point3 p = pts.get(i);
buff[i * 3] = (int) p.x; buff[i * 3] = (int) p.x;
buff[i * 3 + 1] = (int) p.y; buff[i * 3 + 1] = (int) p.y;
buff[i * 3 + 2] = (int) p.z; buff[i * 3 + 2] = (int) p.z;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} }
break; break;
case CvType.CV_32F: { case CvType.CV_32F: {
res = new Mat(count, 1, CvType.CV_32FC3); res = new Mat(count, 1, CvType.CV_32FC3);
float[] buff = new float[count * 3]; float[] buff = new float[count * 3];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
Point3 p = pts.get(i); Point3 p = pts.get(i);
buff[i * 3] = (float) p.x; buff[i * 3] = (float) p.x;
buff[i * 3 + 1] = (float) p.y; buff[i * 3 + 1] = (float) p.y;
buff[i * 3 + 2] = (float) p.z; buff[i * 3 + 2] = (float) p.z;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} }
break; break;
case CvType.CV_64F: { case CvType.CV_64F: {
res = new Mat(count, 1, CvType.CV_64FC3); res = new Mat(count, 1, CvType.CV_64FC3);
double[] buff = new double[count * 3]; double[] buff = new double[count * 3];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
Point3 p = pts.get(i); Point3 p = pts.get(i);
buff[i * 3] = p.x; buff[i * 3] = p.x;
buff[i * 3 + 1] = p.y; buff[i * 3 + 1] = p.y;
buff[i * 3 + 2] = p.z; buff[i * 3 + 2] = p.z;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} }
break; break;
default: default:
throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F"); throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F");
} }
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static void Mat_to_vector_Point2f(Mat m, List<Point> pts) { public static void Mat_to_vector_Point2f(Mat m, List<Point> pts) {
Mat_to_vector_Point(m, pts); Mat_to_vector_Point(m, pts);
} }
public static void Mat_to_vector_Point2d(Mat m, List<Point> pts) { public static void Mat_to_vector_Point2d(Mat m, List<Point> pts) {
Mat_to_vector_Point(m, pts); Mat_to_vector_Point(m, pts);
} }
public static void Mat_to_vector_Point(Mat m, List<Point> pts) { public static void Mat_to_vector_Point(Mat m, List<Point> pts) {
if (pts == null) if (pts == null)
throw new java.lang.IllegalArgumentException("Output List can't be null"); throw new java.lang.IllegalArgumentException("Output List can't be null");
int count = m.rows(); int count = m.rows();
int type = m.type(); int type = m.type();
if (m.cols() != 1) if (m.cols() != 1)
throw new java.lang.IllegalArgumentException("Input Mat should have one column\n" + m); throw new java.lang.IllegalArgumentException("Input Mat should have one column\n" + m);
pts.clear(); pts.clear();
if (type == CvType.CV_32SC2) { if (type == CvType.CV_32SC2) {
int[] buff = new int[2 * count]; int[] buff = new int[2 * count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
pts.add(new Point(buff[i * 2], buff[i * 2 + 1])); pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));
} }
} else if (type == CvType.CV_32FC2) { } else if (type == CvType.CV_32FC2) {
float[] buff = new float[2 * count]; float[] buff = new float[2 * count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
pts.add(new Point(buff[i * 2], buff[i * 2 + 1])); pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));
} }
} else if (type == CvType.CV_64FC2) { } else if (type == CvType.CV_64FC2) {
double[] buff = new double[2 * count]; double[] buff = new double[2 * count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
pts.add(new Point(buff[i * 2], buff[i * 2 + 1])); pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));
} }
} else { } else {
throw new java.lang.IllegalArgumentException( throw new java.lang.IllegalArgumentException(
"Input Mat should be of CV_32SC2, CV_32FC2 or CV_64FC2 type\n" + m); "Input Mat should be of CV_32SC2, CV_32FC2 or CV_64FC2 type\n" + m);
} }
} }
public static void Mat_to_vector_Point3i(Mat m, List<Point3> pts) { public static void Mat_to_vector_Point3i(Mat m, List<Point3> pts) {
Mat_to_vector_Point3(m, pts); Mat_to_vector_Point3(m, pts);
} }
public static void Mat_to_vector_Point3f(Mat m, List<Point3> pts) { public static void Mat_to_vector_Point3f(Mat m, List<Point3> pts) {
Mat_to_vector_Point3(m, pts); Mat_to_vector_Point3(m, pts);
} }
public static void Mat_to_vector_Point3d(Mat m, List<Point3> pts) { public static void Mat_to_vector_Point3d(Mat m, List<Point3> pts) {
Mat_to_vector_Point3(m, pts); Mat_to_vector_Point3(m, pts);
} }
public static void Mat_to_vector_Point3(Mat m, List<Point3> pts) { public static void Mat_to_vector_Point3(Mat m, List<Point3> pts) {
if (pts == null) if (pts == null)
throw new java.lang.IllegalArgumentException("Output List can't be null"); throw new java.lang.IllegalArgumentException("Output List can't be null");
int count = m.rows(); int count = m.rows();
int type = m.type(); int type = m.type();
if (m.cols() != 1) if (m.cols() != 1)
throw new java.lang.IllegalArgumentException("Input Mat should have one column\n" + m); throw new java.lang.IllegalArgumentException("Input Mat should have one column\n" + m);
pts.clear(); pts.clear();
if (type == CvType.CV_32SC3) { if (type == CvType.CV_32SC3) {
int[] buff = new int[3 * count]; int[] buff = new int[3 * count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2])); pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2]));
} }
} else if (type == CvType.CV_32FC3) { } else if (type == CvType.CV_32FC3) {
float[] buff = new float[3 * count]; float[] buff = new float[3 * count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2])); pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2]));
} }
} else if (type == CvType.CV_64FC3) { } else if (type == CvType.CV_64FC3) {
double[] buff = new double[3 * count]; double[] buff = new double[3 * count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2])); pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2]));
} }
} else { } else {
throw new java.lang.IllegalArgumentException( throw new java.lang.IllegalArgumentException(
"Input Mat should be of CV_32SC3, CV_32FC3 or CV_64FC3 type\n" + m); "Input Mat should be of CV_32SC3, CV_32FC3 or CV_64FC3 type\n" + m);
} }
} }
public static Mat vector_Mat_to_Mat(List<Mat> mats) { public static Mat vector_Mat_to_Mat(List<Mat> mats) {
Mat res; Mat res;
int count = (mats != null) ? mats.size() : 0; int count = (mats != null) ? mats.size() : 0;
if (count > 0) { if (count > 0) {
res = new Mat(count, 1, CvType.CV_32SC2); res = new Mat(count, 1, CvType.CV_32SC2);
int[] buff = new int[count * 2]; int[] buff = new int[count * 2];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
long addr = mats.get(i).nativeObj; long addr = mats.get(i).nativeObj;
buff[i * 2] = (int) (addr >> 32); buff[i * 2] = (int) (addr >> 32);
buff[i * 2 + 1] = (int) (addr & 0xffffffff); buff[i * 2 + 1] = (int) (addr & 0xffffffff);
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static void Mat_to_vector_Mat(Mat m, List<Mat> mats) { public static void Mat_to_vector_Mat(Mat m, List<Mat> mats) {
if (mats == null) if (mats == null)
throw new java.lang.IllegalArgumentException("mats == null"); throw new java.lang.IllegalArgumentException("mats == null");
int count = m.rows(); int count = m.rows();
if (CvType.CV_32SC2 != m.type() || m.cols() != 1) if (CvType.CV_32SC2 != m.type() || m.cols() != 1)
throw new java.lang.IllegalArgumentException( throw new java.lang.IllegalArgumentException(
"CvType.CV_32SC2 != m.type() || m.cols()!=1\n" + m); "CvType.CV_32SC2 != m.type() || m.cols()!=1\n" + m);
mats.clear(); mats.clear();
int[] buff = new int[count * 2]; int[] buff = new int[count * 2];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
long addr = (((long) buff[i * 2]) << 32) | ((long) buff[i * 2 + 1]); long addr = (((long) buff[i * 2]) << 32) | ((long) buff[i * 2 + 1]);
mats.add(new Mat(addr)); mats.add(new Mat(addr));
} }
} }
public static Mat vector_float_to_Mat(List<Float> fs) { public static Mat vector_float_to_Mat(List<Float> fs) {
Mat res; Mat res;
int count = (fs != null) ? fs.size() : 0; int count = (fs != null) ? fs.size() : 0;
if (count > 0) { if (count > 0) {
res = new Mat(count, 1, CvType.CV_32FC1); res = new Mat(count, 1, CvType.CV_32FC1);
float[] buff = new float[count]; float[] buff = new float[count];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
float f = fs.get(i); float f = fs.get(i);
buff[i] = f; buff[i] = f;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static void Mat_to_vector_float(Mat m, List<Float> fs) { public static void Mat_to_vector_float(Mat m, List<Float> fs) {
if (fs == null) if (fs == null)
throw new java.lang.IllegalArgumentException("fs == null"); throw new java.lang.IllegalArgumentException("fs == null");
int count = m.rows(); int count = m.rows();
if (CvType.CV_32FC1 != m.type() || m.cols() != 1) if (CvType.CV_32FC1 != m.type() || m.cols() != 1)
throw new java.lang.IllegalArgumentException( throw new java.lang.IllegalArgumentException(
"CvType.CV_32FC1 != m.type() || m.cols()!=1\n" + m); "CvType.CV_32FC1 != m.type() || m.cols()!=1\n" + m);
fs.clear(); fs.clear();
float[] buff = new float[count]; float[] buff = new float[count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
fs.add(buff[i]); fs.add(buff[i]);
} }
} }
public static Mat vector_uchar_to_Mat(List<Byte> bs) { public static Mat vector_uchar_to_Mat(List<Byte> bs) {
Mat res; Mat res;
int count = (bs != null) ? bs.size() : 0; int count = (bs != null) ? bs.size() : 0;
if (count > 0) { if (count > 0) {
res = new Mat(count, 1, CvType.CV_8UC1); res = new Mat(count, 1, CvType.CV_8UC1);
byte[] buff = new byte[count]; byte[] buff = new byte[count];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
byte b = bs.get(i); byte b = bs.get(i);
buff[i] = b; buff[i] = b;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static void Mat_to_vector_uchar(Mat m, List<Byte> us) { public static void Mat_to_vector_uchar(Mat m, List<Byte> us) {
if (us == null) if (us == null)
throw new java.lang.IllegalArgumentException("Output List can't be null"); throw new java.lang.IllegalArgumentException("Output List can't be null");
int count = m.rows(); int count = m.rows();
if (CvType.CV_8UC1 != m.type() || m.cols() != 1) if (CvType.CV_8UC1 != m.type() || m.cols() != 1)
throw new java.lang.IllegalArgumentException( throw new java.lang.IllegalArgumentException(
"CvType.CV_8UC1 != m.type() || m.cols()!=1\n" + m); "CvType.CV_8UC1 != m.type() || m.cols()!=1\n" + m);
us.clear(); us.clear();
byte[] buff = new byte[count]; byte[] buff = new byte[count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
us.add(buff[i]); us.add(buff[i]);
} }
} }
public static Mat vector_char_to_Mat(List<Byte> bs) { public static Mat vector_char_to_Mat(List<Byte> bs) {
Mat res; Mat res;
int count = (bs != null) ? bs.size() : 0; int count = (bs != null) ? bs.size() : 0;
if (count > 0) { if (count > 0) {
res = new Mat(count, 1, CvType.CV_8SC1); res = new Mat(count, 1, CvType.CV_8SC1);
byte[] buff = new byte[count]; byte[] buff = new byte[count];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
byte b = bs.get(i); byte b = bs.get(i);
buff[i] = b; buff[i] = b;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static Mat vector_int_to_Mat(List<Integer> is) { public static Mat vector_int_to_Mat(List<Integer> is) {
Mat res; Mat res;
int count = (is != null) ? is.size() : 0; int count = (is != null) ? is.size() : 0;
if (count > 0) { if (count > 0) {
res = new Mat(count, 1, CvType.CV_32SC1); res = new Mat(count, 1, CvType.CV_32SC1);
int[] buff = new int[count]; int[] buff = new int[count];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
int v = is.get(i); int v = is.get(i);
buff[i] = v; buff[i] = v;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static void Mat_to_vector_int(Mat m, List<Integer> is) { public static void Mat_to_vector_int(Mat m, List<Integer> is) {
if (is == null) if (is == null)
throw new java.lang.IllegalArgumentException("is == null"); throw new java.lang.IllegalArgumentException("is == null");
int count = m.rows(); int count = m.rows();
if (CvType.CV_32SC1 != m.type() || m.cols() != 1) if (CvType.CV_32SC1 != m.type() || m.cols() != 1)
throw new java.lang.IllegalArgumentException( throw new java.lang.IllegalArgumentException(
"CvType.CV_32SC1 != m.type() || m.cols()!=1\n" + m); "CvType.CV_32SC1 != m.type() || m.cols()!=1\n" + m);
is.clear(); is.clear();
int[] buff = new int[count]; int[] buff = new int[count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
is.add(buff[i]); is.add(buff[i]);
} }
} }
public static void Mat_to_vector_char(Mat m, List<Byte> bs) { public static void Mat_to_vector_char(Mat m, List<Byte> bs) {
if (bs == null) if (bs == null)
throw new java.lang.IllegalArgumentException("Output List can't be null"); throw new java.lang.IllegalArgumentException("Output List can't be null");
int count = m.rows(); int count = m.rows();
if (CvType.CV_8SC1 != m.type() || m.cols() != 1) if (CvType.CV_8SC1 != m.type() || m.cols() != 1)
throw new java.lang.IllegalArgumentException( throw new java.lang.IllegalArgumentException(
"CvType.CV_8SC1 != m.type() || m.cols()!=1\n" + m); "CvType.CV_8SC1 != m.type() || m.cols()!=1\n" + m);
bs.clear(); bs.clear();
byte[] buff = new byte[count]; byte[] buff = new byte[count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
bs.add(buff[i]); bs.add(buff[i]);
} }
} }
public static Mat vector_Rect_to_Mat(List<Rect> rs) { public static Mat vector_Rect_to_Mat(List<Rect> rs) {
Mat res; Mat res;
int count = (rs != null) ? rs.size() : 0; int count = (rs != null) ? rs.size() : 0;
if (count > 0) { if (count > 0) {
res = new Mat(count, 1, CvType.CV_32SC4); res = new Mat(count, 1, CvType.CV_32SC4);
int[] buff = new int[4 * count]; int[] buff = new int[4 * count];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
Rect r = rs.get(i); Rect r = rs.get(i);
buff[4 * i] = r.x; buff[4 * i] = r.x;
buff[4 * i + 1] = r.y; buff[4 * i + 1] = r.y;
buff[4 * i + 2] = r.width; buff[4 * i + 2] = r.width;
buff[4 * i + 3] = r.height; buff[4 * i + 3] = r.height;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static void Mat_to_vector_Rect(Mat m, List<Rect> rs) { public static void Mat_to_vector_Rect(Mat m, List<Rect> rs) {
if (rs == null) if (rs == null)
throw new java.lang.IllegalArgumentException("rs == null"); throw new java.lang.IllegalArgumentException("rs == null");
int count = m.rows(); int count = m.rows();
if (CvType.CV_32SC4 != m.type() || m.cols() != 1) if (CvType.CV_32SC4 != m.type() || m.cols() != 1)
throw new java.lang.IllegalArgumentException( throw new java.lang.IllegalArgumentException(
"CvType.CV_32SC4 != m.type() || m.rows()!=1\n" + m); "CvType.CV_32SC4 != m.type() || m.rows()!=1\n" + m);
rs.clear(); rs.clear();
int[] buff = new int[4 * count]; int[] buff = new int[4 * count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
rs.add(new Rect(buff[4 * i], buff[4 * i + 1], buff[4 * i + 2], buff[4 * i + 3])); rs.add(new Rect(buff[4 * i], buff[4 * i + 1], buff[4 * i + 2], buff[4 * i + 3]));
} }
} }
public static Mat vector_KeyPoint_to_Mat(List<KeyPoint> kps) { public static Mat vector_KeyPoint_to_Mat(List<KeyPoint> kps) {
Mat res; Mat res;
int count = (kps != null) ? kps.size() : 0; int count = (kps != null) ? kps.size() : 0;
if (count > 0) { if (count > 0) {
res = new Mat(count, 1, CvType.CV_64FC(7)); res = new Mat(count, 1, CvType.CV_64FC(7));
double[] buff = new double[count * 7]; double[] buff = new double[count * 7];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
KeyPoint kp = kps.get(i); KeyPoint kp = kps.get(i);
buff[7 * i] = kp.pt.x; buff[7 * i] = kp.pt.x;
buff[7 * i + 1] = kp.pt.y; buff[7 * i + 1] = kp.pt.y;
buff[7 * i + 2] = kp.size; buff[7 * i + 2] = kp.size;
buff[7 * i + 3] = kp.angle; buff[7 * i + 3] = kp.angle;
buff[7 * i + 4] = kp.response; buff[7 * i + 4] = kp.response;
buff[7 * i + 5] = kp.octave; buff[7 * i + 5] = kp.octave;
buff[7 * i + 6] = kp.class_id; buff[7 * i + 6] = kp.class_id;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static void Mat_to_vector_KeyPoint(Mat m, List<KeyPoint> kps) { public static void Mat_to_vector_KeyPoint(Mat m, List<KeyPoint> kps) {
if (kps == null) if (kps == null)
throw new java.lang.IllegalArgumentException("Output List can't be null"); throw new java.lang.IllegalArgumentException("Output List can't be null");
int count = m.rows(); int count = m.rows();
if (CvType.CV_64FC(7) != m.type() || m.cols() != 1) if (CvType.CV_64FC(7) != m.type() || m.cols() != 1)
throw new java.lang.IllegalArgumentException( throw new java.lang.IllegalArgumentException(
"CvType.CV_64FC(7) != m.type() || m.cols()!=1\n" + m); "CvType.CV_64FC(7) != m.type() || m.cols()!=1\n" + m);
kps.clear(); kps.clear();
double[] buff = new double[7 * count]; double[] buff = new double[7 * count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
kps.add(new KeyPoint((float) buff[7 * i], (float) buff[7 * i + 1], (float) buff[7 * i + 2], (float) buff[7 * i + 3], kps.add(new KeyPoint((float) buff[7 * i], (float) buff[7 * i + 1], (float) buff[7 * i + 2], (float) buff[7 * i + 3],
(float) buff[7 * i + 4], (int) buff[7 * i + 5], (int) buff[7 * i + 6])); (float) buff[7 * i + 4], (int) buff[7 * i + 5], (int) buff[7 * i + 6]));
} }
} }
// vector_vector_Point // vector_vector_Point
public static Mat vector_vector_Point_to_Mat(List<MatOfPoint> pts, List<Mat> mats) { public static Mat vector_vector_Point_to_Mat(List<MatOfPoint> pts, List<Mat> mats) {
Mat res; Mat res;
int lCount = (pts != null) ? pts.size() : 0; int lCount = (pts != null) ? pts.size() : 0;
if (lCount > 0) { if (lCount > 0) {
for (MatOfPoint vpt : pts) for (MatOfPoint vpt : pts)
mats.add(vpt); mats.add(vpt);
res = vector_Mat_to_Mat(mats); res = vector_Mat_to_Mat(mats);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static void Mat_to_vector_vector_Point(Mat m, List<MatOfPoint> pts) { public static void Mat_to_vector_vector_Point(Mat m, List<MatOfPoint> pts) {
if (pts == null) if (pts == null)
throw new java.lang.IllegalArgumentException("Output List can't be null"); throw new java.lang.IllegalArgumentException("Output List can't be null");
if (m == null) if (m == null)
throw new java.lang.IllegalArgumentException("Input Mat can't be null"); throw new java.lang.IllegalArgumentException("Input Mat can't be null");
List<Mat> mats = new ArrayList<Mat>(m.rows()); List<Mat> mats = new ArrayList<Mat>(m.rows());
Mat_to_vector_Mat(m, mats); Mat_to_vector_Mat(m, mats);
for (Mat mi : mats) { for (Mat mi : mats) {
MatOfPoint pt = new MatOfPoint(mi); MatOfPoint pt = new MatOfPoint(mi);
pts.add(pt); pts.add(pt);
} }
} }
// vector_vector_Point2f // vector_vector_Point2f
public static void Mat_to_vector_vector_Point2f(Mat m, List<MatOfPoint2f> pts) { public static void Mat_to_vector_vector_Point2f(Mat m, List<MatOfPoint2f> pts) {
if (pts == null) if (pts == null)
throw new java.lang.IllegalArgumentException("Output List can't be null"); throw new java.lang.IllegalArgumentException("Output List can't be null");
if (m == null) if (m == null)
throw new java.lang.IllegalArgumentException("Input Mat can't be null"); throw new java.lang.IllegalArgumentException("Input Mat can't be null");
List<Mat> mats = new ArrayList<Mat>(m.rows()); List<Mat> mats = new ArrayList<Mat>(m.rows());
Mat_to_vector_Mat(m, mats); Mat_to_vector_Mat(m, mats);
for (Mat mi : mats) { for (Mat mi : mats) {
MatOfPoint2f pt = new MatOfPoint2f(mi); MatOfPoint2f pt = new MatOfPoint2f(mi);
pts.add(pt); pts.add(pt);
} }
} }
// vector_vector_Point2f // vector_vector_Point2f
public static Mat vector_vector_Point2f_to_Mat(List<MatOfPoint2f> pts, List<Mat> mats) { public static Mat vector_vector_Point2f_to_Mat(List<MatOfPoint2f> pts, List<Mat> mats) {
Mat res; Mat res;
int lCount = (pts != null) ? pts.size() : 0; int lCount = (pts != null) ? pts.size() : 0;
if (lCount > 0) { if (lCount > 0) {
for (MatOfPoint2f vpt : pts) for (MatOfPoint2f vpt : pts)
mats.add(vpt); mats.add(vpt);
res = vector_Mat_to_Mat(mats); res = vector_Mat_to_Mat(mats);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
// vector_vector_Point3f // vector_vector_Point3f
public static void Mat_to_vector_vector_Point3f(Mat m, List<MatOfPoint3f> pts) { public static void Mat_to_vector_vector_Point3f(Mat m, List<MatOfPoint3f> pts) {
if (pts == null) if (pts == null)
throw new java.lang.IllegalArgumentException("Output List can't be null"); throw new java.lang.IllegalArgumentException("Output List can't be null");
if (m == null) if (m == null)
throw new java.lang.IllegalArgumentException("Input Mat can't be null"); throw new java.lang.IllegalArgumentException("Input Mat can't be null");
List<Mat> mats = new ArrayList<Mat>(m.rows()); List<Mat> mats = new ArrayList<Mat>(m.rows());
Mat_to_vector_Mat(m, mats); Mat_to_vector_Mat(m, mats);
for (Mat mi : mats) { for (Mat mi : mats) {
MatOfPoint3f pt = new MatOfPoint3f(mi); MatOfPoint3f pt = new MatOfPoint3f(mi);
pts.add(pt); pts.add(pt);
} }
} }
// vector_vector_Point3f // vector_vector_Point3f
public static Mat vector_vector_Point3f_to_Mat(List<MatOfPoint3f> pts, List<Mat> mats) { public static Mat vector_vector_Point3f_to_Mat(List<MatOfPoint3f> pts, List<Mat> mats) {
Mat res; Mat res;
int lCount = (pts != null) ? pts.size() : 0; int lCount = (pts != null) ? pts.size() : 0;
if (lCount > 0) { if (lCount > 0) {
for (MatOfPoint3f vpt : pts) for (MatOfPoint3f vpt : pts)
mats.add(vpt); mats.add(vpt);
res = vector_Mat_to_Mat(mats); res = vector_Mat_to_Mat(mats);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
// vector_vector_KeyPoint // vector_vector_KeyPoint
public static Mat vector_vector_KeyPoint_to_Mat(List<MatOfKeyPoint> kps, List<Mat> mats) { public static Mat vector_vector_KeyPoint_to_Mat(List<MatOfKeyPoint> kps, List<Mat> mats) {
Mat res; Mat res;
int lCount = (kps != null) ? kps.size() : 0; int lCount = (kps != null) ? kps.size() : 0;
if (lCount > 0) { if (lCount > 0) {
for (MatOfKeyPoint vkp : kps) for (MatOfKeyPoint vkp : kps)
mats.add(vkp); mats.add(vkp);
res = vector_Mat_to_Mat(mats); res = vector_Mat_to_Mat(mats);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static void Mat_to_vector_vector_KeyPoint(Mat m, List<MatOfKeyPoint> kps) { public static void Mat_to_vector_vector_KeyPoint(Mat m, List<MatOfKeyPoint> kps) {
if (kps == null) if (kps == null)
throw new java.lang.IllegalArgumentException("Output List can't be null"); throw new java.lang.IllegalArgumentException("Output List can't be null");
if (m == null) if (m == null)
throw new java.lang.IllegalArgumentException("Input Mat can't be null"); throw new java.lang.IllegalArgumentException("Input Mat can't be null");
List<Mat> mats = new ArrayList<Mat>(m.rows()); List<Mat> mats = new ArrayList<Mat>(m.rows());
Mat_to_vector_Mat(m, mats); Mat_to_vector_Mat(m, mats);
for (Mat mi : mats) { for (Mat mi : mats) {
MatOfKeyPoint vkp = new MatOfKeyPoint(mi); MatOfKeyPoint vkp = new MatOfKeyPoint(mi);
kps.add(vkp); kps.add(vkp);
} }
} }
public static Mat vector_double_to_Mat(List<Double> ds) { public static Mat vector_double_to_Mat(List<Double> ds) {
Mat res; Mat res;
int count = (ds != null) ? ds.size() : 0; int count = (ds != null) ? ds.size() : 0;
if (count > 0) { if (count > 0) {
res = new Mat(count, 1, CvType.CV_64FC1); res = new Mat(count, 1, CvType.CV_64FC1);
double[] buff = new double[count]; double[] buff = new double[count];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
double v = ds.get(i); double v = ds.get(i);
buff[i] = v; buff[i] = v;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static void Mat_to_vector_double(Mat m, List<Double> ds) { public static void Mat_to_vector_double(Mat m, List<Double> ds) {
if (ds == null) if (ds == null)
throw new java.lang.IllegalArgumentException("ds == null"); throw new java.lang.IllegalArgumentException("ds == null");
int count = m.rows(); int count = m.rows();
if (CvType.CV_64FC1 != m.type() || m.cols() != 1) if (CvType.CV_64FC1 != m.type() || m.cols() != 1)
throw new java.lang.IllegalArgumentException( throw new java.lang.IllegalArgumentException(
"CvType.CV_64FC1 != m.type() || m.cols()!=1\n" + m); "CvType.CV_64FC1 != m.type() || m.cols()!=1\n" + m);
ds.clear(); ds.clear();
double[] buff = new double[count]; double[] buff = new double[count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
ds.add(buff[i]); ds.add(buff[i]);
} }
} }
public static Mat vector_DMatch_to_Mat(List<DMatch> matches) { public static Mat vector_DMatch_to_Mat(List<DMatch> matches) {
Mat res; Mat res;
int count = (matches != null) ? matches.size() : 0; int count = (matches != null) ? matches.size() : 0;
if (count > 0) { if (count > 0) {
res = new Mat(count, 1, CvType.CV_64FC4); res = new Mat(count, 1, CvType.CV_64FC4);
double[] buff = new double[count * 4]; double[] buff = new double[count * 4];
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
DMatch m = matches.get(i); DMatch m = matches.get(i);
buff[4 * i] = m.queryIdx; buff[4 * i] = m.queryIdx;
buff[4 * i + 1] = m.trainIdx; buff[4 * i + 1] = m.trainIdx;
buff[4 * i + 2] = m.imgIdx; buff[4 * i + 2] = m.imgIdx;
buff[4 * i + 3] = m.distance; buff[4 * i + 3] = m.distance;
} }
res.put(0, 0, buff); res.put(0, 0, buff);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static void Mat_to_vector_DMatch(Mat m, List<DMatch> matches) { public static void Mat_to_vector_DMatch(Mat m, List<DMatch> matches) {
if (matches == null) if (matches == null)
throw new java.lang.IllegalArgumentException("Output List can't be null"); throw new java.lang.IllegalArgumentException("Output List can't be null");
int count = m.rows(); int count = m.rows();
if (CvType.CV_64FC4 != m.type() || m.cols() != 1) if (CvType.CV_64FC4 != m.type() || m.cols() != 1)
throw new java.lang.IllegalArgumentException( throw new java.lang.IllegalArgumentException(
"CvType.CV_64FC4 != m.type() || m.cols()!=1\n" + m); "CvType.CV_64FC4 != m.type() || m.cols()!=1\n" + m);
matches.clear(); matches.clear();
double[] buff = new double[4 * count]; double[] buff = new double[4 * count];
m.get(0, 0, buff); m.get(0, 0, buff);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
matches.add(new DMatch((int) buff[4 * i], (int) buff[4 * i + 1], (int) buff[4 * i + 2], (float) buff[4 * i + 3])); matches.add(new DMatch((int) buff[4 * i], (int) buff[4 * i + 1], (int) buff[4 * i + 2], (float) buff[4 * i + 3]));
} }
} }
// vector_vector_DMatch // vector_vector_DMatch
public static Mat vector_vector_DMatch_to_Mat(List<MatOfDMatch> lvdm, List<Mat> mats) { public static Mat vector_vector_DMatch_to_Mat(List<MatOfDMatch> lvdm, List<Mat> mats) {
Mat res; Mat res;
int lCount = (lvdm != null) ? lvdm.size() : 0; int lCount = (lvdm != null) ? lvdm.size() : 0;
if (lCount > 0) { if (lCount > 0) {
for (MatOfDMatch vdm : lvdm) for (MatOfDMatch vdm : lvdm)
mats.add(vdm); mats.add(vdm);
res = vector_Mat_to_Mat(mats); res = vector_Mat_to_Mat(mats);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static void Mat_to_vector_vector_DMatch(Mat m, List<MatOfDMatch> lvdm) { public static void Mat_to_vector_vector_DMatch(Mat m, List<MatOfDMatch> lvdm) {
if (lvdm == null) if (lvdm == null)
throw new java.lang.IllegalArgumentException("Output List can't be null"); throw new java.lang.IllegalArgumentException("Output List can't be null");
if (m == null) if (m == null)
throw new java.lang.IllegalArgumentException("Input Mat can't be null"); throw new java.lang.IllegalArgumentException("Input Mat can't be null");
List<Mat> mats = new ArrayList<Mat>(m.rows()); List<Mat> mats = new ArrayList<Mat>(m.rows());
Mat_to_vector_Mat(m, mats); Mat_to_vector_Mat(m, mats);
lvdm.clear(); lvdm.clear();
for (Mat mi : mats) { for (Mat mi : mats) {
MatOfDMatch vdm = new MatOfDMatch(mi); MatOfDMatch vdm = new MatOfDMatch(mi);
lvdm.add(vdm); lvdm.add(vdm);
} }
} }
// vector_vector_char // vector_vector_char
public static Mat vector_vector_char_to_Mat(List<MatOfByte> lvb, List<Mat> mats) { public static Mat vector_vector_char_to_Mat(List<MatOfByte> lvb, List<Mat> mats) {
Mat res; Mat res;
int lCount = (lvb != null) ? lvb.size() : 0; int lCount = (lvb != null) ? lvb.size() : 0;
if (lCount > 0) { if (lCount > 0) {
for (MatOfByte vb : lvb) for (MatOfByte vb : lvb)
mats.add(vb); mats.add(vb);
res = vector_Mat_to_Mat(mats); res = vector_Mat_to_Mat(mats);
} else { } else {
res = new Mat(); res = new Mat();
} }
return res; return res;
} }
public static void Mat_to_vector_vector_char(Mat m, List<List<Byte>> llb) { public static void Mat_to_vector_vector_char(Mat m, List<List<Byte>> llb) {
if (llb == null) if (llb == null)
throw new java.lang.IllegalArgumentException("Output List can't be null"); throw new java.lang.IllegalArgumentException("Output List can't be null");
if (m == null) if (m == null)
throw new java.lang.IllegalArgumentException("Input Mat can't be null"); throw new java.lang.IllegalArgumentException("Input Mat can't be null");
List<Mat> mats = new ArrayList<Mat>(m.rows()); List<Mat> mats = new ArrayList<Mat>(m.rows());
Mat_to_vector_Mat(m, mats); Mat_to_vector_Mat(m, mats);
for (Mat mi : mats) { for (Mat mi : mats) {
List<Byte> lb = new ArrayList<Byte>(); List<Byte> lb = new ArrayList<Byte>();
Mat_to_vector_char(mi, lb); Mat_to_vector_char(mi, lb);
llb.add(lb); llb.add(lb);
} }
} }
}
static {
System.loadLibrary("opencv_java");
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment