/// <summary>
///
/// </summary>
/// <param name="size"></param>
/// <param name="type"></param>
/// <param name="data"></param>
/// <param name="step"></param>
public GpuMat(CvSize size, MatrixType type, IntPtr data, uint step)
{
ptr = GpuInvoke.GpuMat_new7(size, type, data, step);
if (ptr == IntPtr.Zero)
{
throw new OpenCvSharpException();
}
}
/// <summary>
/// locates matrix header within a parent matrix.
/// </summary>
/// <param name="wholeSize"></param>
/// <param name="ofs"></param>
public void LocateROI(out CvSize wholeSize, out CvPoint ofs)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
GpuInvoke.GpuMat_locateROI(ptr, out wholeSize, out ofs);
}
/// <summary>
///
/// </summary>
/// <param name="y"></param>
/// <returns></returns>
public unsafe byte *Ptr(int y = 0)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
return(GpuInvoke.GpuMat_ptr(ptr, y));
}
/// <summary>
/// デフォルトコンストラクタ
/// </summary>
#else
/// <summary>
/// Default constructor
/// </summary>
#endif
public GpuMat()
{
ptr = GpuInvoke.GpuMat_new1();
if (ptr == IntPtr.Zero)
{
throw new OpenCvSharpException();
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public bool IsContinuous()
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
return(GpuInvoke.GpuMat_isContinuous(ptr));
}
/// <summary>
/// converts matrix to another datatype with optional scalng. See cvConvertScale.
/// </summary>
/// <param name="dst"></param>
/// <param name="rtype"></param>
/// <param name="alpha"></param>
/// <param name="beta"></param>
/// <returns></returns>
public void ConvertTo(Mat dst, MatrixType rtype, double alpha = 1, double beta = 0)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
GpuInvoke.GpuMat_convertTo(ptr, dst.CvPtr, (int)rtype, alpha, beta);
}
/// <summary>
/// allocates new matrix data unless the matrix already has specified size and type.
/// previous data is unreferenced if needed.
/// </summary>
/// <param name="rows"></param>
/// <param name="cols"></param>
/// <param name="type"></param>
public void Create(int rows, int cols, MatrixType type)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
GpuInvoke.GpuMat_create1(ptr, rows, cols, type);
}
/// <summary>
///
/// </summary>
/// <param name="size"></param>
/// <param name="type"></param>
/// <param name="s"></param>
public GpuMat(CvSize size, MatrixType type, CvScalar s)
{
ptr = GpuInvoke.GpuMat_new11(size, type, s);
if (ptr == IntPtr.Zero)
{
throw new OpenCvSharpException();
}
}
/// <summary>
/// allocates new matrix data unless the matrix already has specified size and type.
/// previous data is unreferenced if needed.
/// </summary>
/// <param name="size"></param>
/// <param name="type"></param>
public void Create(CvSize size, MatrixType type)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
GpuInvoke.GpuMat_create2(ptr, size, type);
}
/// <summary>
///
/// </summary>
/// <param name="roi"></param>
/// <returns></returns>
public virtual Mat this[CvRect roi]
{
get
{
Mat result = new Mat();
GpuInvoke.GpuMat_opRange1(ptr, roi, result.CvPtr);
return(result);
}
}
/// <summary>
///
/// </summary>
/// <param name="rowRange"></param>
/// <param name="colRange"></param>
/// <returns></returns>
public virtual Mat this[CvSlice rowRange, CvSlice colRange]
{
get
{
Mat result = new Mat();
GpuInvoke.GpuMat_opRange2(ptr, rowRange, colRange, result.CvPtr);
return(result);
}
}
/// <summary>
/// returns deep copy of the matrix, i.e. the data is copied
/// </summary>
/// <returns></returns>
public GpuMat Clone()
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
GpuMat outValue = new GpuMat();
GpuInvoke.GpuMat_clone(ptr, outValue.CvPtr);
return(outValue);
}
/// <summary>
/// returns a new matrix header for the specified row span
/// </summary>
/// <param name="startrow"></param>
/// <param name="endrow"></param>
/// <returns></returns>
public GpuMat RowRange(int startrow, int endrow)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
GpuMat outValue = new GpuMat();
GpuInvoke.GpuMat_rowRange(ptr, startrow, endrow, outValue.CvPtr);
return(outValue);
}
/// <summary>
/// returns a new matrix header for the specified row
/// </summary>
/// <param name="y"></param>
/// <returns></returns>
public GpuMat Row(int y)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
GpuMat outValue = new GpuMat();
GpuInvoke.GpuMat_row(ptr, y, outValue.CvPtr);
return(outValue);
}
/// <summary>
/// matrix transposition by means of matrix expressions
/// </summary>
/// <returns></returns>
public GpuMat T()
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
GpuMat dst = new GpuMat();
GpuInvoke.GpuMat_t(ptr, dst.CvPtr);
return(dst);
}
/// <summary>
/// creates alternative matrix header for the same data, with different
/// number of channels and/or different number of rows. see cvReshape.
/// </summary>
/// <param name="cn"></param>
/// <param name="rows"></param>
/// <returns></returns>
public GpuMat Reshape(int cn, int rows)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
GpuMat outValue = new GpuMat();
GpuInvoke.GpuMat_reshape(ptr, cn, rows, outValue.CvPtr);
return(outValue);
}
/// <summary>
/// moves/resizes the current matrix ROI inside the parent matrix.
/// </summary>
/// <param name="dtop"></param>
/// <param name="dbottom"></param>
/// <param name="dleft"></param>
/// <param name="dright"></param>
/// <returns></returns>
public GpuMat AdjustROI(int dtop, int dbottom, int dleft, int dright)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
GpuMat dst = new GpuMat();
GpuInvoke.GpuMat_adjustROI(ptr, dtop, dbottom, dleft, dright, dst.CvPtr);
return(dst);
}
/// <summary>
/// returns a new matrix header for the specified column span
/// </summary>
/// <param name="startcol"></param>
/// <param name="endcol"></param>
/// <returns></returns>
public GpuMat ColRange(int startcol, int endcol)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
GpuMat outValue = new GpuMat();
GpuInvoke.GpuMat_colRange(ptr, startcol, endcol, outValue.CvPtr);
return(outValue);
}
/// <summary>
///
/// </summary>
/// <param name="m"></param>
/// <param name="rowRange"></param>
/// <param name="colRange"></param>
public GpuMat(GpuMat m, CvSlice rowRange, CvSlice colRange)
{
if (m == null)
{
throw new ArgumentNullException("m");
}
ptr = GpuInvoke.GpuMat_new9(m.CvPtr, rowRange, colRange);
if (ptr == IntPtr.Zero)
{
throw new OpenCvSharpException();
}
}
/// <summary>
///
/// </summary>
/// <param name="m"></param>
public GpuMat(GpuMat m)
{
if (m == null)
{
throw new ArgumentNullException("m");
}
ptr = GpuInvoke.GpuMat_new5(m.CvPtr);
if (ptr == IntPtr.Zero)
{
throw new OpenCvSharpException();
}
}
/// <summary>
/// ビット反転演算子
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
#else
/// <summary>
/// Unary bitwise complement operator
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
#endif
public static GpuMat operator~(GpuMat src)
{
if (src == null)
{
throw new ArgumentNullException("src");
}
GpuMat dst = new GpuMat();
GpuInvoke.GpuMat_opComplement(src.CvPtr, dst.CvPtr);
return(dst);
}
/// <summary>
/// copies those matrix elements to "m"
/// </summary>
/// <param name="m"></param>
public void CopyTo(GpuMat m)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
if (m == null)
{
throw new ArgumentNullException("m");
}
GpuInvoke.GpuMat_copyTo1(ptr, m.CvPtr);
}
/*
* /// <summary>
* /// decreases reference counter;
* /// deallocate the data when reference counter reaches 0.
* /// </summary>
* public void Release()
* {
* if (disposed)
* throw new ObjectDisposedException("GpuMat");
* CppInvoke.gpu_GpuMat_release(ptr);
* }
* //*/
/// <summary>
/// swaps with other smart pointer
/// </summary>
/// <param name="mat"></param>
public void Swap(GpuMat mat)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
if (mat == null)
{
throw new ArgumentNullException("mat");
}
GpuInvoke.GpuMat_swap(ptr, mat.CvPtr);
}
/// <summary>
/// sets some of the matrix elements to s, according to the mask
/// </summary>
/// <param name="s"></param>
/// <param name="mask"></param>
/// <returns></returns>
public GpuMat SetTo(CvScalar s, GpuMat mask = null)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
IntPtr maskPtr = (mask == null) ? IntPtr.Zero : mask.CvPtr;
GpuMat dst = new GpuMat();
GpuInvoke.GpuMat_setTo(ptr, s, maskPtr, dst.CvPtr);
return(dst);
}
/// <summary>
///
/// </summary>
/// <param name="m"></param>
/// <param name="roi"></param>
public GpuMat(GpuMat m, CvRect roi)
{
if (m == null)
{
throw new ArgumentNullException("m");
}
ptr = GpuInvoke.GpuMat_new10(m.CvPtr, (CvRect)roi);
if (ptr == IntPtr.Zero)
{
throw new OpenCvSharpException();
}
}
/// <summary>
///
/// </summary>
/// <param name="m"></param>
/// <param name="type"></param>
public void AssignTo(GpuMat m, MatrixType type)
{
if (disposed)
{
throw new ObjectDisposedException("GpuMat");
}
if (m == null)
{
throw new ArgumentNullException("m");
}
GpuInvoke.GpuMat_assignTo(ptr, m.CvPtr, (int)type);
}
/// <summary>
///
/// </summary>
/// <param name="rows"></param>
/// <param name="cols"></param>
/// <param name="type"></param>
/// <param name="data"></param>
/// <param name="step"></param>
public GpuMat(int rows, int cols, MatrixType type, IntPtr data, uint step)
{
if (rows <= 0)
{
throw new ArgumentOutOfRangeException("rows");
}
if (cols <= 0)
{
throw new ArgumentOutOfRangeException("cols");
}
ptr = GpuInvoke.GpuMat_new3(rows, cols, type, data, step);
if (ptr == IntPtr.Zero)
{
throw new OpenCvSharpException();
}
}
/// <summary>
/// XOR演算子
/// </summary>
/// <param name="src1"></param>
/// <param name="src2"></param>
/// <returns></returns>
#else
/// <summary>
/// Binary bitwise XOR operator
/// </summary>
/// <param name="src1"></param>
/// <param name="src2"></param>
/// <returns></returns>
#endif
public static GpuMat operator ^(GpuMat src1, GpuMat src2)
{
if (src1 == null)
{
throw new ArgumentNullException("src1");
}
if (src2 == null)
{
throw new ArgumentNullException("src2");
}
GpuMat dst = new GpuMat();
GpuInvoke.GpuMat_opXor(src1.CvPtr, src2.CvPtr, dst.CvPtr);
return(dst);
}
/// <summary>
///
/// </summary>
/// <param name="rows"></param>
/// <param name="cols"></param>
/// <param name="type"></param>
/// <param name="s"></param>
public GpuMat(int rows, int cols, MatrixType type, CvScalar s)
{
if (rows <= 0)
{
throw new ArgumentOutOfRangeException("rows");
}
if (cols <= 0)
{
throw new ArgumentOutOfRangeException("cols");
}
ptr = GpuInvoke.GpuMat_new8(rows, cols, type, (CvScalar)s);
if (ptr == IntPtr.Zero)
{
throw new OpenCvSharpException();
}
}
/// <summary>
/// リソースの解放
/// </summary>
/// <param name="disposing">
/// trueの場合は、このメソッドがユーザコードから直接が呼ばれたことを示す。マネージ・アンマネージ双方のリソースが解放される。
/// falseの場合は、このメソッドはランタイムからファイナライザによって呼ばれ、もうほかのオブジェクトから参照されていないことを示す。アンマネージリソースのみ解放される。
///</param>
#else
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">
/// If disposing equals true, the method has been called directly or indirectly by a user's code. Managed and unmanaged resources can be disposed.
/// If false, the method has been called by the runtime from inside the finalizer and you should not reference other objects. Only unmanaged resources can be disposed.
/// </param>
#endif
protected override void Dispose(bool disposing)
{
if (!disposed)
{
try
{
if (disposing)
{
}
if (IsEnabledDispose)
{
GpuInvoke.GpuMat_delete(ptr);
}
disposed = true;
}
finally
{
base.Dispose(disposing);
}
}
}
