public static IEnumerable <uint> SpectralCluster <TScalar, TKernel>(TKernel kernel, IEnumerable <Matrix <TScalar> > samples, uint clusters) where TScalar : struct where TKernel : KernelBase { if (kernel == null) { throw new ArgumentNullException(nameof(kernel)); } if (samples == null) { throw new ArgumentNullException(nameof(samples)); } if (!(clusters > 0)) { throw new ArgumentOutOfRangeException(); } kernel.ThrowIfDisposed(); var samplesArray = samples.ToArray(); samplesArray.ThrowIfDisposed(); var templateRow = kernel.TemplateRows; var templateColumn = kernel.TemplateColumns; foreach (var sample in samplesArray) { if (sample == null) { throw new ArgumentException($"{nameof(samples)} contains null object", nameof(samples)); } if (sample.IsDisposed) { throw new ArgumentException($"{nameof(samples)} contains disposed object", nameof(samples)); } if (sample.TemplateRows != templateRow) { throw new ArgumentException($"{nameof(samples)} contains different {nameof(sample.TemplateRows)} of {typeof(Matrix<TScalar>).Name}", nameof(samples)); } if (sample.TemplateColumns != templateColumn) { throw new ArgumentException($"{nameof(samples)} contains different {nameof(sample.TemplateColumns)} of {typeof(Matrix<TScalar>).Name}", nameof(samples)); } } using (var samplesVector = new StdVector <Matrix <TScalar> >(samplesArray)) { var err = NativeMethods.spectral_cluster(kernel.KernelType.ToNativeKernelType(), kernel.SampleType.ToNativeMatrixElementType(), kernel.TemplateRows, kernel.TemplateColumns, kernel.NativePtr, samplesVector.NativePtr, clusters, out var ret); using (var vector = new StdVector <uint>(ret)) return(vector.ToArray()); } }
public static void LoadImageDataset <T>(string path, out IList <Matrix <T> > images, out IList <IList <Rectangle> > boxes) where T : struct { if (path == null) { throw new ArgumentNullException(nameof(path)); } if (!File.Exists(path)) { throw new FileNotFoundException("", path); } var str = Encoding.GetBytes(path); using (var matrix = new Matrix <T>()) using (var retImages = new StdVector <Matrix <T> >()) using (var retBoxes = new StdVector <StdVector <Rectangle> >()) using (new EnumerableDisposer <StdVector <Rectangle> >(retBoxes)) { var type = matrix.MatrixElementType.ToNativeMatrixElementType(); var ret = NativeMethods.load_image_dataset_rectangle(type, retImages.NativePtr, retBoxes.NativePtr, str, str.Length); if (ret == NativeMethods.ErrorType.MatrixElementTypeNotSupport) { throw new ArgumentException($"{type} is not supported."); } images = retImages.ToArray(); boxes = retBoxes.ToArray().Select(box => box.ToArray()).ToArray(); } }
public static IEnumerable <SurfPoint> GetSurfPoints(Array2DBase image, long maxPoints = 10000, double detectionThreshold = 30.0) { if (image == null) { throw new ArgumentNullException(nameof(image)); } image.ThrowIfDisposed(); if (maxPoints <= 0) { throw new ArgumentOutOfRangeException(); } if (detectionThreshold < 0) { throw new ArgumentOutOfRangeException(); } using (var points = new StdVector <SurfPoint>()) { var array2DType = image.ImageType.ToNativeArray2DType(); var ret = Native.get_surf_points(array2DType, image.NativePtr, maxPoints, detectionThreshold, points.NativePtr); if (ret == Native.ErrorType.ArrayTypeNotSupport) { throw new ArgumentException($"{image.ImageType} is not supported."); } return(points.ToArray()); } }
public static ChipDetails[] GetFaceChipDetails(IEnumerable <FullObjectDetection> dets, uint size = 200, double padding = 0.2d) { if (dets == null) { throw new ArgumentNullException(nameof(dets)); } if (size <= 0) { throw new ArgumentException(); } if (padding < 0) { throw new ArgumentException(); } if (dets.Any(detection => detection == null || detection.IsDisposed || detection.Parts != 68)) { throw new ArgumentException($"{nameof(dets)} includes invalid item."); } using (var vector = new StdVector <FullObjectDetection>(dets)) using (var vectorOfChips = new StdVector <ChipDetails>()) { NativeMethods.get_face_chip_details(vector.NativePtr, size, padding, vectorOfChips.NativePtr); return(vectorOfChips.ToArray()); } }
public static void LoadImageDataset <T>(string path, out Array <Array2D <T> > images, out IList <IList <FullObjectDetection> > boxes) where T : struct { if (path == null) { throw new ArgumentNullException(nameof(path)); } if (!File.Exists(path)) { throw new FileNotFoundException("", path); } if (!Array2D <T> .TryParse <T>(out var type)) { throw new NotSupportedException(); } var str = Encoding.GetBytes(path); images = new Array <Array2D <T> >(); using (var retBoxes = new StdVector <StdVector <FullObjectDetection> >()) using (new EnumerableDisposer <StdVector <FullObjectDetection> >(retBoxes)) { var ret = NativeMethods.load_image_dataset_array_full_object_detection(type.ToNativeArray2DType(), images.NativePtr, retBoxes.NativePtr, str); if (ret == NativeMethods.ErrorType.Array2DTypeTypeNotSupport) { throw new ArgumentException($"{type} is not supported."); } boxes = retBoxes.ToArray().Select(box => box.ToArray()).ToArray(); } }
public override IEnumerable <Rectangle> Operator <U>(Matrix <U> image) { if (image == null) { throw new ArgumentNullException(nameof(image)); } image.ThrowIfDisposed(); var type = image.MatrixElementType.ToNativeMatrixElementType(); var ret = NativeMethods.object_detector_scan_fhog_pyramid_operator(this._PyramidType, this._PyramidRate, this._FeatureExtractorType, this.NativePtr, type, image.NativePtr, out var rects); switch (ret) { case NativeMethods.ErrorType.MatrixElementTypeNotSupport: throw new ArgumentException($"{type} is not supported."); } using (var tmp = new StdVector <Rectangle>(rects)) return(tmp.ToArray()); }
public static void RandomizeSamples <T1, T2>(IList <T1> samples1, IList <T2> samples2) { if (samples1 == null) { throw new ArgumentNullException(nameof(samples1)); } if (samples2 == null) { throw new ArgumentNullException(nameof(samples2)); } if (samples1.Count != samples2.Count) { throw new ArgumentException(); } var indexList = Enumerable.Range(0, samples1.Count).ToArray(); using (var vector = new StdVector <int>(indexList)) { NativeMethods.randomize_samples_value(vector.NativePtr); var result = vector.ToArray(); for (var index = 0; index < indexList.Length; index++) { var newIndex = result[index]; var old1 = samples1[index]; samples1[index] = samples1[newIndex]; samples1[newIndex] = old1; var old2 = samples2[index]; samples2[index] = samples2[newIndex]; samples2[newIndex] = old2; } } }
public static IEnumerable <long> MaxCostAssignment <T>(Matrix <T> cost) where T : struct { if (cost == null) { throw new ArgumentNullException(nameof(cost)); } if (cost.Rows != cost.Columns) { throw new ArgumentException($"{cost.Rows} must equal to {cost.Columns}"); } using (var vector = new StdVector <long>()) { var type = cost.MatrixElementType.ToNativeMatrixElementType(); var ret = Native.max_cost_assignment( type, cost.NativePtr, vector.NativePtr); if (ret == Native.ErrorType.MatrixElementTypeNotSupport) { throw new ArgumentException($"{cost.MatrixElementType} is not supported."); } return(vector.ToArray()); } }
public static IEnumerable <Rectangle> FindCandidateObjectLocations( Array2DBase image, MatrixRangeExp <double> kvals, uint minSize = 20, uint maxMergingIterations = 50) { if (image == null) { throw new ArgumentNullException(nameof(image)); } if (kvals == null) { throw new ArgumentNullException(nameof(kvals)); } var array2DType = image.ImageType.ToNativeArray2DType(); using (var dets = new StdVector <Rectangle>()) { var ret = Native.find_candidate_object_locations(array2DType, image.NativePtr, dets.NativePtr, IntPtr.Zero, minSize, maxMergingIterations); if (ret == Native.ErrorType.ArrayTypeNotSupport) { throw new ArgumentException($"{image.ImageType} is not supported."); } return(dets.ToArray()); } }
public void CreateWithCollection() { const int size = 10; var source = Enumerable.Range(0, size).Select(j => new StdVector <Rectangle>(Enumerable.Range(0, size).Select(i => new Rectangle(i, i, i, i)))); var vector = new StdVector <StdVector <Rectangle> >(source); Assert.AreEqual(vector.Size, size); var ret = vector.ToArray(); for (var j = 0; j < size; j++) { var tmp = ret[j].ToArray(); for (var i = 0; i < size; i++) { Assert.AreEqual(tmp[i].Left, i); Assert.AreEqual(tmp[i].Top, i); Assert.AreEqual(tmp[i].Right, i); Assert.AreEqual(tmp[i].Bottom, i); } } this.DisposeAndCheckDisposedState(vector); foreach (var s in source) { s.Dispose(); } }
public void Operator(MatrixBase image, out IEnumerable <RectDetection> detections, double threshold = 0d) { this.ThrowIfDisposed(); if (image == null) { throw new ArgumentNullException(nameof(image)); } image.ThrowIfDisposed(); using (var dets = new StdVector <RectDetection>()) { var inType = image.MatrixElementType.ToNativeMatrixElementType(); var ret = NativeMethods.frontal_face_detector_matrix_operator2(this.NativePtr, inType, image.NativePtr, threshold, dets.NativePtr); switch (ret) { case NativeMethods.ErrorType.MatrixElementTypeNotSupport: throw new ArgumentException($"Input {inType} is not supported."); } detections = dets.ToArray(); } }
public void CreateWithCollection() { const int size = 10; var source = Enumerable.Range(0, size).Select(j => new StdVector <MModRect>(Enumerable.Range(0, size).Select(i => new MModRect { Ignore = true, DetectionConfidence = i }))); var vector = new StdVector <StdVector <MModRect> >(source); Assert.AreEqual(vector.Size, size); var ret = vector.ToArray(); for (var j = 0; j < size; j++) { var tmp = ret[j].ToArray(); for (var i = 0; i < size; i++) { Assert.AreEqual(tmp[i].DetectionConfidence, i); Assert.AreEqual(tmp[i].Ignore, true); } } this.DisposeAndCheckDisposedState(vector); foreach (var s in source) { s.Dispose(); } }
public IEnumerable <OverlayRect> GetOverlayRects() { this.ThrowIfDisposed(); var rects = NativeMethods.image_display_get_overlay_rects(this.NativePtr); using (var vector = new StdVector <OverlayRect>(rects)) return(vector.ToArray()); }
public static void UpsampleImageDataset <T>(uint pyramidRate, IList <Matrix <T> > images, IList <IList <MModRect> > objects, uint maxImageSize = uint.MaxValue) where T : struct { if (images == null) { throw new ArgumentNullException(nameof(images)); } if (objects == null) { throw new ArgumentNullException(nameof(objects)); } images.ThrowIfDisposed(); var imageCount = images.Count(); var objectCount = objects.Count(); if (imageCount != objectCount) { throw new ArgumentException(); } using (var vecImage = new StdVector <Matrix <T> >(images)) using (var disposer = new EnumerableDisposer <StdVector <MModRect> >(objects.Select(r => new StdVector <MModRect>(r)))) using (var vecObject = new StdVector <StdVector <MModRect> >(disposer.Collection)) using (new EnumerableDisposer <StdVector <MModRect> >(vecObject)) { Matrix <T> .TryParse <T>(out var matrixElementType); var ret = NativeMethods.upsample_image_dataset_pyramid_down_mmod_rect(pyramidRate, matrixElementType.ToNativeMatrixElementType(), vecImage.NativePtr, vecObject.NativePtr, maxImageSize); switch (ret) { case NativeMethods.ErrorType.PyramidNotSupportRate: throw new ArgumentException($"{pyramidRate} is not supported."); case NativeMethods.ErrorType.MatrixElementTypeNotSupport: throw new ArgumentException($"{matrixElementType} is not supported."); } images.Clear(); foreach (var matrix in vecImage.ToArray()) { images.Add(matrix); } objects.Clear(); foreach (var list in vecObject.ToArray()) { objects.Add(list.ToArray()); } } }
public static IEnumerable <Rectangle> EvaluateDetectors <T, U>(IEnumerable <ObjectDetector <ScanFHogPyramid <T, U> > > detectors, MatrixBase matrix, double adjustThreshold = 0) where T : class where U : class { if (detectors == null) { throw new ArgumentNullException(nameof(detectors)); } if (matrix == null) { throw new ArgumentNullException(nameof(matrix)); } var count = detectors.Count(); if (count == 0) { throw new ArgumentException(); } detectors.ThrowIfDisposed(); var @params = detectors.Select(detector => detector.GetFHogPyramidParameter()); var param = @params.First(); var not = @params.Any(p => p.PyramidRate != param.PyramidRate || p.PyramidType != param.PyramidType || p.FeatureExtractorType != param.FeatureExtractorType); if (not) { throw new ArgumentException(); } var detectorArray = detectors.Select(det => det.NativePtr).ToArray(); var elementType = matrix.MatrixElementType.ToNativeMatrixElementType(); var ret = NativeMethods.scan_fhog_pyramid_evaluate_detectors(param.PyramidType, param.PyramidRate, param.FeatureExtractorType, detectorArray, count, elementType, matrix.NativePtr, adjustThreshold, out var vector); switch (ret) { case NativeMethods.ErrorType.FHogNotSupportExtractor: case NativeMethods.ErrorType.PyramidNotSupportRate: case NativeMethods.ErrorType.PyramidNotSupportType: throw new NotSupportedException(); } using (var tmp = new StdVector <Rectangle>(vector)) return(tmp.ToArray()); }
public static void UpsampleImageDataset <T>(uint pyramidRate, IList <Matrix <T> > images, IList <IEnumerable <Rectangle> > objects) where T : struct { if (images == null) { throw new ArgumentNullException(nameof(images)); } if (objects == null) { throw new ArgumentNullException(nameof(objects)); } images.ThrowIfDisposed(); var imageCount = images.Count(); var objectCount = objects.Count(); if (imageCount != objectCount) { throw new ArgumentException(); } using (var vecImage = new StdVector <Matrix <T> >(images)) { var tmp = objects.Select(rectangles => new StdVector <Rectangle>(rectangles)); using (var vecObject = new StdVector <StdVector <Rectangle> >(tmp)) { Matrix <T> .TryParse <T>(out var matrixElementType); var ret = Native.upsample_image_dataset_pyramid_down(pyramidRate, matrixElementType.ToNativeMatrixElementType(), vecImage.NativePtr, vecObject.NativePtr); switch (ret) { case Native.ErrorType.PyramidNotSupportRate: throw new ArgumentException($"{pyramidRate} is not supported."); case Native.ErrorType.MatrixElementTypeNotSupport: throw new ArgumentException($"{matrixElementType} is not supported."); } images.Clear(); foreach (var matrix in vecImage.ToArray()) { images.Add(matrix); } objects.Clear(); foreach (var list in vecObject.ToArray()) { objects.Add(list); } } } }
public static IEnumerable <Rectangle> CreateGridDetectionTemplate(Rectangle objectBox, uint cellsX, uint cellsY) { if (!(cellsX > 0 && cellsY > 0)) { throw new ArgumentOutOfRangeException(); } using (var native = objectBox.ToNative()) { var ret = NativeMethods.create_grid_detection_template(native.NativePtr, cellsX, cellsY); using (var vector = new StdVector <Rectangle>(ret)) return(vector.ToArray()); } }
public static ImageWindow.OverlayLine[] RenderFaceDetections(IEnumerable <FullObjectDetection> detection, RgbPixel color) { if (detection == null) { throw new ArgumentNullException(nameof(detection)); } using (var vectorIn = new StdVector <FullObjectDetection>(detection)) using (var vectorOut = new StdVector <ImageWindow.OverlayLine>()) { Native.render_face_detections(vectorIn.NativePtr, ref color, vectorOut.NativePtr); return(vectorOut.ToArray()); } }
public void CreateWithCollection() { const int size = 10; var source = Enumerable.Range(0, size).Select(s => (long)s).ToArray(); var vector = new StdVector <long>(source); Assert.AreEqual(vector.Size, size); var ret = vector.ToArray(); for (var i = 0; i < size; i++) { Assert.AreEqual(ret[i], i); } this.DisposeAndCheckDisposedState(vector); }
public static ImageWindow.OverlayLine[] RenderFaceDetections(FullObjectDetection detection, RgbPixel color) { if (detection == null) { throw new ArgumentNullException(nameof(detection)); } detection.ThrowIfDisposed(nameof(detection)); using (var vector = new StdVector <ImageWindow.OverlayLine>()) { Native.render_face_detections(detection.NativePtr, ref color, vector.NativePtr); return(vector.ToArray()); } }
public void CreateWithCollection() { const int size = 10; var source = Enumerable.Range(0, size).Select(i => new Matrix <int>(i, i)); var vector = new StdVector <Matrix <int> >(source); Assert.AreEqual(vector.Size, size); var ret = vector.ToArray(); for (var i = 0; i < size; i++) { Assert.AreEqual(ret[i].Rows, i); Assert.AreEqual(ret[i].Columns, i); } this.DisposeAndCheckDisposedState(vector); }
public static void ChineseWhispers(IEnumerable <SamplePair> edges, uint iterations, out uint clusters, out uint[] labels) { if (edges == null) { throw new ArgumentNullException(nameof(edges)); } edges.ThrowIfDisposed(); using (var e = new StdVector <SamplePair>(edges)) using (var l = new StdVector <uint>()) { clusters = Native.clustering_chinese_whispers(e.NativePtr, l.NativePtr, iterations); labels = l.ToArray(); } }
public static void RandomizeSamples <T>(IList <T> samples) where T : DlibObject { if (samples == null) { throw new ArgumentNullException(nameof(samples)); } using (var vector = new StdVector <T>(samples)) { NativeMethods.randomize_samples_pointer(vector.NativePtr); var result = vector.ToArray(); for (var index = 0; index < samples.Count; index++) { samples[index] = result[index]; } } }
public static void AddImageLeftRightFlips <T>(IList <Matrix <T> > images, IList <IEnumerable <Rectangle> > objects) where T : struct { if (images == null) { throw new ArgumentNullException(nameof(images)); } if (objects == null) { throw new ArgumentNullException(nameof(objects)); } images.ThrowIfDisposed(); using (var vecImage = new StdVector <Matrix <T> >(images)) { var tmp = objects.Select(rectangles => new StdVector <Rectangle>(rectangles)); using (var vecObject = new StdVector <StdVector <Rectangle> >(tmp)) { Matrix <T> .TryParse <T>(out var matrixElementType); var ret = NativeMethods.add_image_left_right_flips_rectangle(matrixElementType.ToNativeMatrixElementType(), vecImage.NativePtr, vecObject.NativePtr); switch (ret) { case NativeMethods.ErrorType.MatrixElementTypeNotSupport: throw new ArgumentException($"{matrixElementType} is not supported."); } images.Clear(); foreach (var matrix in vecImage.ToArray()) { images.Add(matrix); } objects.Clear(); foreach (var list in vecObject.ToArray()) { objects.Add(list); } } } }
public static void CreateTiledPyramid <T, U>(Matrix <T> image, uint padding, uint outerPadding, uint pyramidRate, out Matrix <T> outImage, out IEnumerable <Rectangle> rects) where T : struct where U : Pyramid { // 10, 0 if (image == null) { throw new ArgumentNullException(nameof(image)); } outImage = default(Matrix <T>); rects = default(IEnumerable <Rectangle>); image.ThrowIfDisposed(); if (!Pyramid.TryGetSupportPyramidType <U>(out var pyramidType)) { throw new NotSupportedException(); } var inType = image.MatrixElementType.ToNativeMatrixElementType(); var ret = Native.create_tiled_pyramid(inType, image.NativePtr, pyramidType, pyramidRate, padding, outerPadding, out var outImg, out var vecRects); switch (ret) { case Native.ErrorType.MatrixElementTypeNotSupport: throw new ArgumentException($"Input {inType} is not supported."); case Native.ErrorType.PyramidNotSupportRate: throw new NotSupportedException(); } outImage = new Matrix <T>(outImg); using (var vec = new StdVector <Rectangle>(vecRects)) rects = vec.ToArray(); }
public static void LoadMNISTDataset(string folderPath, out IList <Matrix <byte> > trainingImages, out IList <uint> trainingLabels, out IList <Matrix <byte> > testingImages, out IList <uint> testingLabels) { if (folderPath == null) { throw new ArgumentNullException(nameof(folderPath)); } if (!Directory.Exists(folderPath)) { throw new DirectoryNotFoundException(); } trainingImages = null; trainingLabels = null; testingImages = null; testingLabels = null; var str = Encoding.GetBytes(folderPath); var strLength = str.Length; Array.Resize(ref str, strLength + 1); str[strLength] = (byte)'\0'; NativeMethods.load_mnist_dataset(str, out var retTrainingImages, out var retTrainingLabels, out var retTestingImages, out var retTestingLabels); using (var tmp = new StdVector <Matrix <byte> >(retTrainingImages)) trainingImages = tmp.ToArray(); using (var tmp = new StdVector <uint>(retTrainingLabels)) trainingLabels = tmp.ToArray(); using (var tmp = new StdVector <Matrix <byte> >(retTestingImages)) testingImages = tmp.ToArray(); using (var tmp = new StdVector <uint>(retTestingLabels)) testingLabels = tmp.ToArray(); }
public static IEnumerable <Rectangle> FindCandidateObjectLocations <T>(Array2DBase image, Matrix <T> kvals, uint minSize = 20, uint maxMergingIterations = 50) where T : struct { if (image == null) { throw new ArgumentNullException(nameof(image)); } if (kvals == null) { throw new ArgumentNullException(nameof(kvals)); } var array2DType = image.ImageType.ToNativeArray2DType(); using (var dets = new StdVector <Rectangle>()) { var matrixType = kvals.MatrixElementType.ToNativeMatrixElementType(); var ret = Native.find_candidate_object_locations(array2DType, image.NativePtr, dets.NativePtr, matrixType, kvals.NativePtr, minSize, maxMergingIterations); switch (ret) { case Native.ErrorType.Array2DTypeTypeNotSupport: throw new ArgumentException($"{image.ImageType} is not supported."); case Native.ErrorType.MatrixElementTypeNotSupport: throw new ArgumentException($"{matrixType} is not supported."); } return(dets.ToArray()); } }
public override IEnumerable <Tuple <double, Rectangle> > OperatorWithConfidence <U>(Matrix <U> image) { if (image == null) { throw new ArgumentNullException(nameof(image)); } image.ThrowIfDisposed(); var type = image.MatrixElementType.ToNativeMatrixElementType(); var ret = NativeMethods.object_detector_scan_fhog_pyramid_operator_with_confidence(this._PyramidType, this._PyramidRate, this._FeatureExtractorType, this.NativePtr, type, image.NativePtr, out var rects, out var confidences); switch (ret) { case NativeMethods.ErrorType.MatrixElementTypeNotSupport: throw new ArgumentException($"{type} is not supported."); } using (var rectsVector = new StdVector <Rectangle>(rects)) using (var tconfidencesVector = new StdVector <double>(confidences)) { var rectsArray = rectsVector.ToArray(); var confidencesArray = tconfidencesVector.ToArray(); var count = rectsArray.Length; for (var index = 0; index < count; index++) { yield return(new Tuple <double, Rectangle>(confidencesArray[index], rectsArray[index])); } }; }
public static void LoadMNISTDataset(string folderPath, out Matrix <byte>[] trainingImages, out uint[] trainingLabels, out Matrix <byte>[] testingImages, out uint[] testingLabels) { if (folderPath == null) { throw new ArgumentNullException(nameof(folderPath)); } if (!Directory.Exists(folderPath)) { throw new DirectoryNotFoundException(); } trainingImages = null; trainingLabels = null; testingImages = null; testingLabels = null; var str = Dlib.Encoding.GetBytes(folderPath); NativeMethods.load_mnist_dataset(str, out var retTrainingImages, out var retTrainingLabels, out var retTestingImages, out var retTestingLabels); using (var tmp = new StdVector <Matrix <byte> >(retTrainingImages)) trainingImages = tmp.ToArray(); using (var tmp = new StdVector <uint>(retTrainingLabels)) trainingLabels = tmp.ToArray(); using (var tmp = new StdVector <Matrix <byte> >(retTestingImages)) testingImages = tmp.ToArray(); using (var tmp = new StdVector <uint>(retTestingLabels)) testingLabels = tmp.ToArray(); }
public Rectangle[] Operator(MatrixBase image, double threshold = 0d) { this.ThrowIfDisposed(); if (image == null) { throw new ArgumentNullException(nameof(image)); } image.ThrowIfDisposed(); using (var dets = new StdVector <Rectangle>()) { var inType = image.MatrixElementType.ToNativeMatrixElementType(); var ret = Native.frontal_face_detector_matrix_operator(this.NativePtr, inType, image.NativePtr, threshold, dets.NativePtr); switch (ret) { case Dlib.Native.ErrorType.InputElementTypeNotSupport: throw new ArgumentException($"Input {inType} is not supported."); } return(dets.ToArray()); } }