/// <summary> /// Returns a training set of descriptors. /// </summary> /// <returns></returns> public Mat[] GetDescriptors() { using (var descriptors = new VectorOfMat()) { NativeMethods.features2d_BOWTrainer_getDescriptors(ptr, descriptors.CvPtr); return(descriptors.ToArray()); } }
/// <summary> /// Returns a training set of descriptors. /// </summary> /// <returns></returns> public Mat[] GetDescriptors() { using var descriptors = new VectorOfMat(); NativeMethods.HandleException( NativeMethods.features2d_BOWTrainer_getDescriptors(ptr, descriptors.CvPtr)); GC.KeepAlive(this); return(descriptors.ToArray()); }
/// <summary> /// /// </summary> /// <returns></returns> public Mat[] GetMatVector() { ThrowIfDisposed(); using var vec = new VectorOfMat(); NativeMethods.HandleException( NativeMethods.core_InputArray_getMatVector(ptr, vec.CvPtr)); GC.KeepAlive(this); return(vec.ToArray()); }
/// <summary> /// Get train descriptors collection. /// </summary> /// <returns></returns> public Mat[] GetTrainDescriptors() { ThrowIfDisposed(); using (var matVec = new VectorOfMat()) { NativeMethods.features2d_DescriptorMatcher_getTrainDescriptors(ptr, matVec.CvPtr); return(matVec.ToArray()); } }
//public Mat getMat_(int idx = -1) { } //public UMat getUMat(int idx = -1) const; /// <summary> /// /// </summary> /// <returns></returns> public Mat[] GetMatVector() { ThrowIfDisposed(); using (var vec = new VectorOfMat()) { NativeMethods.core_InputArray_getMatVector(ptr, vec.CvPtr); return(vec.ToArray()); } }
/// <summary> /// Get train descriptors collection. /// </summary> /// <returns></returns> public Mat[] GetTrainDescriptors() { ThrowIfDisposed(); using var matVec = new VectorOfMat(); NativeMethods.HandleException( NativeMethods.features2d_DescriptorMatcher_getTrainDescriptors(ptr, matVec.CvPtr)); GC.KeepAlive(this); return matVec.ToArray(); }
/// <summary> /// Returns covariation matrices. /// Returns vector of covariation matrices. Number of matrices is the number of /// gaussian mixtures, each matrix is a square floating-point matrix NxN, where N is the space dimensionality. /// </summary> public Mat[] GetCovs() { ThrowIfDisposed(); using (var vec = new VectorOfMat()) { NativeMethods.ml_EM_getCovs(ptr, vec.CvPtr); return(vec.ToArray()); } }
/// <summary> /// Loads a multi-page image from a file. /// </summary> /// <param name="filename">Name of file to be loaded.</param> /// <param name="mats">A vector of Mat objects holding each page, if more than one.</param> /// <param name="flags">Flag that can take values of @ref cv::ImreadModes, default with IMREAD_ANYCOLOR.</param> /// <returns></returns> public static bool ImReadMulti(string filename, out Mat[] mats, ImreadModes flags = ImreadModes.AnyColor) { if (filename == null) { throw new ArgumentNullException(nameof(filename)); } using var matsVec = new VectorOfMat(); NativeMethods.HandleException( NativeMethods.imgcodecs_imreadmulti(filename, matsVec.CvPtr, (int)flags, out var ret)); mats = matsVec.ToArray(); return(ret != 0); }
/// <summary> /// Returns covariation matrices. /// Returns vector of covariation matrices. Number of matrices is the number of /// gaussian mixtures, each matrix is a square floating-point matrix NxN, where N is the space dimensionality. /// </summary> public Mat[] GetCovs() { if (disposed) { throw new ObjectDisposedException(GetType().Name); } using (var vec = new VectorOfMat()) { NativeMethods.ml_EM_getCovs(ptr, vec.CvPtr); return(vec.ToArray()); } }
/// <summary> /// /// </summary> public override void AssignResult() { if (!IsReady()) { throw new NotSupportedException(); } using var vectorOfMat = new VectorOfMat(); NativeMethods.HandleException( NativeMethods.core_OutputArray_getVectorOfMat(ptr, vectorOfMat.CvPtr)); GC.KeepAlive(this); list.Clear(); list.AddRange(vectorOfMat.ToArray()); }
/// <summary> /// /// </summary> public override void AssignResult() { if (!IsReady()) { throw new NotSupportedException(); } // Matで結果取得 using (var vectorOfMat = new VectorOfMat()) { NativeMethods.core_OutputArray_getVectorOfMat(ptr, vectorOfMat.CvPtr); list.Clear(); list.AddRange(vectorOfMat.ToArray()); } }
/// <summary> /// Compute the different channels to be processed independently in the N&M algorithm [Neumann12] /// </summary> /// <param name="src">The source image</param> /// <returns>Channels</returns> public static Mat[] ComputeNMChannels(Mat src, ERFilter.Mode mode) { if (src == null) { throw new ArgumentNullException("nameof(src)"); } src.ThrowIfDisposed(); IntPtr mvPtr; NativeMethods.text_computeNMChannels(src.CvPtr, out mvPtr, (int)mode); using (var vec = new VectorOfMat(mvPtr)) { return(vec.ToArray()); } }
/// <summary> /// Decodes QR codes in image once it's found by the detect() method. /// Returns UTF8-encoded output string or empty string if the code cannot be decoded. /// </summary> /// <param name="img">grayscale or color (BGR) image containing QR code.</param> /// <param name="points">Quadrangle vertices found by detect() method (or some other algorithm).</param> /// <param name="decodedInfo">UTF8-encoded output vector of string or empty vector of string if the codes cannot be decoded. </param> /// <param name="straightQrCode">The optional output image containing rectified and binarized QR code</param> /// <param name="isOutputStraightQrCode"><see langword="true"/> to output <paramref name="straightQrCode"/></param> /// <returns></returns> protected bool DecodeMulti(InputArray img, IEnumerable <Point2f> points, out string?[] decodedInfo, out Mat[] straightQrCode, bool isOutputStraightQrCode) { if (img == null) { throw new ArgumentNullException(nameof(img)); } if (points == null) { throw new ArgumentNullException(nameof(points)); } img.ThrowIfDisposed(); using var decodedInfoVec = new VectorOfString(); using var pointsVec = new VectorOfPoint2f(points); int ret; if (isOutputStraightQrCode) { NativeMethods.HandleException( NativeMethods.objdetect_QRCodeDetector_decodeMulti( ptr, img.CvPtr, pointsVec.CvPtr, decodedInfoVec.CvPtr, out var straightQrCodePtr, out ret)); using var straightQrCodeVec = new VectorOfMat(straightQrCodePtr); straightQrCode = straightQrCodeVec.ToArray(); } else { NativeMethods.HandleException( NativeMethods.objdetect_QRCodeDetector_decodeMulti_NoStraightQrCode( ptr, img.CvPtr, pointsVec.CvPtr, decodedInfoVec.CvPtr, out ret)); straightQrCode = Array.Empty <Mat>(); } // decode utf-8 bytes. decodedInfo = decodedInfoVec.ToArray(); GC.KeepAlive(img); GC.KeepAlive(points); GC.KeepAlive(this); return(ret != 0); }
/// <summary> /// Both detects and decodes QR code. /// To simplify the usage, there is a only API: detectAndDecode /// </summary> /// <param name="inputImage">supports grayscale or color(BGR) image.</param> /// <param name="bbox">optional output array of vertices of the found QR code quadrangle.Will be empty if not found.</param> /// <param name="results">list of decoded string.</param> public void DetectAndDecode(InputArray inputImage, out Mat[] bbox, out string[] results) { if (inputImage == null) { throw new ArgumentNullException(nameof(inputImage)); } inputImage.ThrowIfDisposed(); using var bboxVec = new VectorOfMat(); using var texts = new VectorOfString(); NativeMethods.HandleException( NativeMethods.wechat_qrcode_WeChatQRCode_detectAndDecode( ptr, inputImage.CvPtr, bboxVec.CvPtr, texts.CvPtr)); bbox = bboxVec.ToArray(); results = texts.ToArray(); GC.KeepAlive(this); GC.KeepAlive(inputImage); }
/// <summary> /// Constructs a pyramid which can be used as input for calcOpticalFlowPyrLK /// </summary> /// <param name="img">8-bit input image.</param> /// <param name="pyramid">output pyramid.</param> /// <param name="winSize">window size of optical flow algorithm. /// Must be not less than winSize argument of calcOpticalFlowPyrLK(). /// It is needed to calculate required padding for pyramid levels.</param> /// <param name="maxLevel">0-based maximal pyramid level number.</param> /// <param name="withDerivatives">set to precompute gradients for the every pyramid level. /// If pyramid is constructed without the gradients then calcOpticalFlowPyrLK() will /// calculate them internally.</param> /// <param name="pyrBorder">the border mode for pyramid layers.</param> /// <param name="derivBorder">the border mode for gradients.</param> /// <param name="tryReuseInputImage">put ROI of input image into the pyramid if possible. /// You can pass false to force data copying.</param> /// <returns>number of levels in constructed pyramid. Can be less than maxLevel.</returns> public static int BuildOpticalFlowPyramid( InputArray img, out Mat[] pyramid, Size winSize, int maxLevel, bool withDerivatives = true, BorderTypes pyrBorder = BorderTypes.Reflect101, BorderTypes derivBorder = BorderTypes.Constant, bool tryReuseInputImage = true) { if (img == null) { throw new ArgumentNullException(nameof(img)); } img.ThrowIfDisposed(); using var pyramidVec = new VectorOfMat(); NativeMethods.HandleException( NativeMethods.video_buildOpticalFlowPyramid2( img.CvPtr, pyramidVec.CvPtr, winSize, maxLevel, withDerivatives ? 1 : 0, (int)pyrBorder, (int)derivBorder, tryReuseInputImage ? 1 : 0, out var ret)); GC.KeepAlive(img); pyramid = pyramidVec.ToArray(); return(ret); }