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