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 void DrawRectangle(Array2DBase image, Rectangle rect, HsiPixel color, uint thickness = 1)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
if (rect == null)
{
throw new ArgumentNullException(nameof(rect));
}
image.ThrowIfDisposed();
rect.ThrowIfDisposed();
var ret = Native.draw_rectangle(
Native.Array2DType.HsiPixel,
image.NativePtr,
rect.NativePtr,
ref color,
thickness);
switch (ret)
{
case Native.ErrorType.ArrayTypeNotSupport:
throw new ArgumentException($"{color} is not supported.");
}
}
/// <summary>
/// This function saves image to disk as PNG (Portable Network Graphics) file.
/// </summary>
/// <param name="image">The image.</param>
/// <param name="path">A string that contains the name of the file to which to save image.</param>
/// <exception cref="ArgumentException">The specified type of image is not supported.</exception>
/// <exception cref="ArgumentException"><see cref="TwoDimensionObjectBase.Rows"/> or <see cref="TwoDimensionObjectBase.Columns"/> are less than or equal to zero.</exception>
/// <exception cref="ArgumentNullException"><paramref name="image"/> or <paramref name="path"/> is null.</exception>
/// <exception cref="ObjectDisposedException"><paramref name="image"/> is disposed.</exception>
public static void SavePng(Array2DBase image, string path)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
image.ThrowIfDisposed();
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (image.Rows <= 0 || image.Columns <= 0)
{
throw new ArgumentException($"{nameof(image.Columns)} and {nameof(image.Rows)} is less than or equal to zero.", nameof(image));
}
var str = Encoding.GetBytes(path);
var array2DType = image.ImageType.ToNativeArray2DType();
var ret = NativeMethods.save_png(array2DType, image.NativePtr, str);
if (ret == NativeMethods.ErrorType.Array2DTypeTypeNotSupport)
{
throw new ArgumentException($"{image.ImageType} is not supported.");
}
}
/// <summary>
/// This function saves image to disk as DNG (Digital Negative) file.
/// </summary>
/// <param name="image">The image.</param>
/// <param name="path">A string that contains the name of the file to which to save image.</param>
/// <exception cref="ArgumentException">The specified type of image is not supported.</exception>
/// <exception cref="ArgumentException"><see cref="TwoDimensionObjectBase.Rows"/> or <see cref="TwoDimensionObjectBase.Columns"/> are less than or equal to zero.</exception>
/// <exception cref="ArgumentNullException"><paramref name="image"/> or <paramref name="path"/> is null.</exception>
/// <exception cref="ObjectDisposedException"><paramref name="image"/> is disposed.</exception>
public static void SaveDng(Array2DBase image, string path)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
image.ThrowIfDisposed();
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
// NOTE: save_dng does not throw exception but it does NOT output any file.
// So it should throw exception in this timing!!
if (image.Rows <= 0 || image.Columns <= 0)
{
throw new ArgumentException($"{nameof(image.Columns)} and {nameof(image.Rows)} is less than or equal to zero.", nameof(image));
}
var str = Encoding.GetBytes(path);
var array2DType = image.ImageType.ToNativeArray2DType();
var ret = NativeMethods.save_dng(array2DType, image.NativePtr, str);
if (ret == NativeMethods.ErrorType.Array2DTypeTypeNotSupport)
{
throw new ArgumentException($"{image.ImageType} is not supported.");
}
}
public static void AssignImage(Array2DBase src, Array2DBase dest)
{
if (src == null)
{
throw new ArgumentNullException(nameof(src));
}
if (dest == null)
{
throw new ArgumentNullException(nameof(dest));
}
src.ThrowIfDisposed(nameof(src));
dest.ThrowIfDisposed(nameof(dest));
var inType = src.ImageType.ToNativeArray2DType();
var outType = dest.ImageType.ToNativeArray2DType();
var ret = Native.assign_image(outType, dest.NativePtr, inType, src.NativePtr);
switch (ret)
{
case Native.ErrorType.OutputArrayTypeNotSupport:
throw new ArgumentException($"Output {outType} is not supported.");
case Native.ErrorType.InputArrayTypeNotSupport:
throw new ArgumentException($"Input {inType} is not supported.");
}
}
public static void DrawLine(Array2DBase image, Point p1, Point p2, ushort color)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
if (p1 == null)
{
throw new ArgumentNullException(nameof(p1));
}
if (p2 == null)
{
throw new ArgumentNullException(nameof(p2));
}
image.ThrowIfDisposed();
using (var np1 = p1.ToNative())
using (var np2 = p2.ToNative())
{
var ret = NativeMethods.draw_line(NativeMethods.Array2DType.UInt16,
image.NativePtr,
np1.NativePtr,
np2.NativePtr,
ref color);
switch (ret)
{
case NativeMethods.ErrorType.Array2DTypeTypeNotSupport:
throw new ArgumentException($"{color} is not supported.");
}
}
}
public double Update(Array2DBase image, DRectangle guess)
{
this.ThrowIfDisposed();
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
image.ThrowIfDisposed();
if (guess.IsEmpty)
{
throw new ArgumentException($"{nameof(guess)} must not be empty");
}
var inType = image.ImageType.ToNativeArray2DType();
using (var native = guess.ToNative())
{
var ret = Native.correlation_tracker_update(this.NativePtr, inType, image.NativePtr, native.NativePtr, out var confident);
switch (ret)
{
case Dlib.Native.ErrorType.InputArrayTypeNotSupport:
throw new ArgumentException($"Input {inType} is not supported.");
}
return(confident);
}
}
public void StartTrack(Array2DBase image, DRectangle rect)
{
this.ThrowIfDisposed();
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
image.ThrowIfDisposed();
if (rect.IsEmpty)
{
throw new ArgumentException($"{nameof(rect)} must not be empty");
}
var inType = image.ImageType.ToNativeArray2DType();
using (var native = rect.ToNative())
{
var ret = Native.correlation_tracker_start_track(this.NativePtr, inType, image.NativePtr, native.NativePtr);
switch (ret)
{
case Dlib.Native.ErrorType.InputArrayTypeNotSupport:
throw new ArgumentException($"Input {inType} is not supported.");
}
}
}
public static void EqualizeHistogram <T>(Array2DBase image, out Array2D <T> outImage)
where T : struct
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
image.ThrowIfDisposed();
if (!Array2D <T> .TryParse <T>(out _))
{
throw new NotSupportedException();
}
outImage = new Array2D <T>();
var inType = image.ImageType.ToNativeArray2DType();
var outType = outImage.ImageType.ToNativeArray2DType();
var ret = NativeMethods.equalize_histogram_array2d_2(inType,
image.NativePtr,
outType,
outImage.NativePtr);
switch (ret)
{
case NativeMethods.ErrorType.Array2DTypeTypeNotSupport:
throw new ArgumentException($"Input {inType} or Output {outType} is not supported.");
}
}
public static void DrawLine(Array2DBase image, Point p1, Point p2, float color)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
if (p1 == null)
{
throw new ArgumentNullException(nameof(p1));
}
if (p2 == null)
{
throw new ArgumentNullException(nameof(p2));
}
image.ThrowIfDisposed();
p1.ThrowIfDisposed();
p2.ThrowIfDisposed();
var ret = Native.draw_line(
Native.Array2DType.Float,
image.NativePtr,
p1.NativePtr,
p2.NativePtr,
ref color);
switch (ret)
{
case Native.ErrorType.ArrayTypeNotSupport:
throw new ArgumentException($"{color} is not supported.");
}
}
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 static void RotateImage(Array2DBase inputImage, Array2DBase outputImage, double angle, InterpolationTypes interpolationTypes = InterpolationTypes.Quadratic)
{
if (inputImage == null)
{
throw new ArgumentNullException(nameof(inputImage));
}
if (outputImage == null)
{
throw new ArgumentNullException(nameof(outputImage));
}
if (inputImage == outputImage)
{
throw new ArgumentException();
}
inputImage.ThrowIfDisposed(nameof(inputImage));
outputImage.ThrowIfDisposed(nameof(outputImage));
var inType = inputImage.ImageType.ToNativeArray2DType();
var outType = outputImage.ImageType.ToNativeArray2DType();
var ret = NativeMethods.rotate_image2(inType, inputImage.NativePtr, outType, outputImage.NativePtr, angle, interpolationTypes.ToNativeInterpolationTypes());
switch (ret)
{
case NativeMethods.ErrorType.Array2DTypeTypeNotSupport:
throw new ArgumentException("Output or input type is not supported.");
}
}
public static void GaussianBlur(Array2DBase inImage, Array2DBase outImage, double sigma = 1, int maxSize = 1001)
{
if (inImage == null)
{
throw new ArgumentNullException(nameof(inImage));
}
if (outImage == null)
{
throw new ArgumentNullException(nameof(outImage));
}
if (!(sigma > 0))
{
throw new ArgumentOutOfRangeException(nameof(sigma));
}
if (!(0 < maxSize && maxSize % 2 != 0))
{
throw new ArgumentOutOfRangeException(nameof(maxSize));
}
inImage.ThrowIfDisposed(nameof(inImage));
outImage.ThrowIfDisposed(nameof(outImage));
var inType = inImage.ImageType.ToNativeArray2DType();
var outType = outImage.ImageType.ToNativeArray2DType();
var ret = Native.gaussian_blur(inType, inImage.NativePtr, outType, outImage.NativePtr, sigma, maxSize);
switch (ret)
{
case Native.ErrorType.OutputArrayTypeNotSupport:
throw new ArgumentException($"Output {outImage.ImageType} is not supported.");
case Native.ErrorType.InputArrayTypeNotSupport:
throw new ArgumentException($"Input {inImage.ImageType} is not supported.");
}
}
public void Operator(Array2DBase inImage, Rectangle rect, Array2DBase outImage)
{
this.ThrowIfDisposed();
if (inImage == null)
{
throw new ArgumentNullException(nameof(inImage));
}
if (outImage == null)
{
throw new ArgumentNullException(nameof(outImage));
}
inImage.ThrowIfDisposed();
outImage.ThrowIfDisposed();
var inType = inImage.ImageType.ToNativeArray2DType();
var outType = outImage.ImageType.ToNativeArray2DType();
using (var native = rect.ToNative())
{
var ret = Native.hough_transform_operator(
this.NativePtr,
inType,
inImage.NativePtr,
outType,
outImage.NativePtr,
native.NativePtr);
switch (ret)
{
case Dlib.Native.ErrorType.Array2DTypeTypeNotSupport:
throw new ArgumentException("Output or input type is not supported.");
}
}
}
public static void FlipImageUpDown(Array2DBase inputImage, Array2DBase outputImage)
{
if (inputImage == null)
{
throw new ArgumentNullException(nameof(inputImage));
}
if (outputImage == null)
{
throw new ArgumentNullException(nameof(outputImage));
}
if (inputImage == outputImage)
{
throw new ArgumentException();
}
inputImage.ThrowIfDisposed(nameof(inputImage));
outputImage.ThrowIfDisposed(nameof(outputImage));
var inType = inputImage.ImageType.ToNativeArray2DType();
var outType = outputImage.ImageType.ToNativeArray2DType();
var ret = NativeMethods.flip_image_up_down(inType, inputImage.NativePtr, outType, outputImage.NativePtr);
switch (ret)
{
case NativeMethods.ErrorType.Array2DTypeTypeNotSupport:
throw new ArgumentException("Output or input type is not supported.");
}
}
public static void TransformImage(Array2DBase inputImage, Array2DBase outputImage, PointTransformBase pointTransform, InterpolationTypes interpolationTypes = InterpolationTypes.Quadratic)
{
if (inputImage == null)
{
throw new ArgumentNullException(nameof(inputImage));
}
if (outputImage == null)
{
throw new ArgumentNullException(nameof(outputImage));
}
if (pointTransform == null)
{
throw new ArgumentNullException(nameof(pointTransform));
}
if (inputImage == outputImage)
{
throw new ArgumentException();
}
inputImage.ThrowIfDisposed(nameof(inputImage));
outputImage.ThrowIfDisposed(nameof(outputImage));
var inType = inputImage.ImageType.ToNativeArray2DType();
var outType = outputImage.ImageType.ToNativeArray2DType();
var ret = Native.transform_image(inType, inputImage.NativePtr, outType, outputImage.NativePtr, pointTransform.GetNativePointMappingTypes(), pointTransform.NativePtr, interpolationTypes.ToNativeInterpolationTypes());
switch (ret)
{
case Native.ErrorType.InputArrayTypeNotSupport:
throw new ArgumentException($"Input {inputImage.ImageType} is not supported.");
case Native.ErrorType.OutputArrayTypeNotSupport:
throw new ArgumentException($"Output {outputImage.ImageType} is not supported.");
}
}
public static void FlipImageLeftRight(Array2DBase inputImage, Array2DBase outputImage)
{
if (inputImage == null)
{
throw new ArgumentNullException(nameof(inputImage));
}
if (outputImage == null)
{
throw new ArgumentNullException(nameof(outputImage));
}
if (inputImage == outputImage)
{
throw new ArgumentException();
}
inputImage.ThrowIfDisposed(nameof(inputImage));
outputImage.ThrowIfDisposed(nameof(outputImage));
var inType = inputImage.ImageType.ToNativeArray2DType();
var outType = outputImage.ImageType.ToNativeArray2DType();
var ret = Native.flip_image_left_right2(inType, inputImage.NativePtr, outType, outputImage.NativePtr);
switch (ret)
{
case Native.ErrorType.InputArrayTypeNotSupport:
throw new ArgumentException($"Input {inputImage.ImageType} is not supported.");
case Native.ErrorType.OutputArrayTypeNotSupport:
throw new ArgumentException($"Output {outputImage.ImageType} is not supported.");
}
}
public static void ResizeImage(Array2DBase inputImage, Array2DBase outputImage, InterpolationTypes interpolationTypes = InterpolationTypes.Bilinear)
{
if (inputImage == null)
{
throw new ArgumentNullException(nameof(inputImage));
}
if (outputImage == null)
{
throw new ArgumentNullException(nameof(outputImage));
}
if (inputImage == outputImage)
{
throw new ArgumentException();
}
inputImage.ThrowIfDisposed(nameof(inputImage));
outputImage.ThrowIfDisposed(nameof(outputImage));
var inType = inputImage.ImageType.ToNativeArray2DType();
var outType = outputImage.ImageType.ToNativeArray2DType();
var ret = Native.resize_image2(inType, inputImage.NativePtr, outType, outputImage.NativePtr, interpolationTypes.ToNativeInterpolationTypes());
switch (ret)
{
case Native.ErrorType.InputArrayTypeNotSupport:
throw new ArgumentException($"Input {inputImage.ImageType} is not supported.");
case Native.ErrorType.OutputArrayTypeNotSupport:
throw new ArgumentException($"Output {outputImage.ImageType} is not supported.");
}
}
public Matrix(Array2DBase array)
{
if (array == null)
{
throw new ArgumentNullException(nameof(array));
}
array.ThrowIfDisposed();
if (!TryParse(typeof(TElement), out var type))
{
throw new NotSupportedException($"{typeof(TElement).Name} does not support");
}
this._MatrixElementTypes = type;
this._ElementType = type.ToNativeMatrixElementType();
var ret = NativeMethods.mat_matrix(array.ImageType.ToNativeArray2DType(),
array.NativePtr,
0,
0,
this._ElementType,
out var ptr);
switch (ret)
{
case ErrorType.MatrixElementTypeNotSupport:
throw new ArgumentException($"{array.ImageType} can not convert to {type}.");
}
this.NativePtr = ptr;
this._Indexer = this.CreateIndexer(type);
}
public static void SaveJpeg(Array2DBase image, string path, int quality = 75)
{
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (image.Rows <= 0 || image.Columns <= 0)
{
throw new ArgumentException($"{nameof(image.Columns)} and {nameof(image.Rows)} is less than or equal to zero.", nameof(image));
}
if (quality < 0)
{
throw new ArgumentOutOfRangeException(nameof(quality), $"{nameof(quality)} is less than zero.");
}
if (quality > 100)
{
throw new ArgumentOutOfRangeException(nameof(quality), $"{nameof(quality)} is greater than 100.");
}
var str = Encoding.UTF8.GetBytes(path);
var array2DType = image.ImageType.ToNativeArray2DType();
var ret = Native.save_jpeg(array2DType, image.NativePtr, str, quality);
if (ret == Native.ErrorType.ArrayTypeNotSupport)
{
throw new ArgumentException($"{image.ImageType} is not supported.");
}
}
public static void SumFilter(Array2DBase inImage, Array2DBase outImage, Rectangle rect)
{
if (inImage == null)
{
throw new ArgumentNullException(nameof(inImage));
}
if (outImage == null)
{
throw new ArgumentNullException(nameof(outImage));
}
inImage.ThrowIfDisposed(nameof(inImage));
outImage.ThrowIfDisposed(nameof(outImage));
if (inImage.Rows != outImage.Rows || inImage.Columns != outImage.Columns)
{
throw new ArgumentException();
}
var inType = inImage.ImageType.ToNativeArray2DType();
var outType = outImage.ImageType.ToNativeArray2DType();
using (var native = rect.ToNative())
{
var ret = NativeMethods.sum_filter(inType, inImage.NativePtr, outType, outImage.NativePtr, native.NativePtr);
switch (ret)
{
case ErrorType.Array2DTypeTypeNotSupport:
throw new ArgumentException("Output or input type is not supported.");
}
}
}
public FullObjectDetection Detect(Array2DBase image, Rectangle rect)
{
this.ThrowIfDisposed();
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
if (rect == null)
{
throw new ArgumentNullException(nameof(rect));
}
image.ThrowIfDisposed();
rect.ThrowIfDisposed();
var inType = image.ImageType.ToNativeArray2DType();
var ret = Native.shape_predictor_operator(this.NativePtr, inType, image.NativePtr, rect.NativePtr, out var fullObjDetect);
switch (ret)
{
case Dlib.Native.ErrorType.InputArrayTypeNotSupport:
throw new ArgumentException($"Input {inType} is not supported.");
}
return(new FullObjectDetection(fullObjDetect));
}
public Point GetBestHoughPoint(Array2DBase image, Point point)
{
this.ThrowIfDisposed();
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
if (point == null)
{
throw new ArgumentNullException(nameof(point));
}
image.ThrowIfDisposed();
var inType = image.ImageType.ToNativeArray2DType();
using (var native = point.ToNative())
{
var ret = Native.hough_transform_get_best_hough_point(
this.NativePtr,
native.NativePtr,
inType,
image.NativePtr,
out var resultPoint);
switch (ret)
{
case Dlib.Native.ErrorType.ArrayTypeNotSupport:
throw new ArgumentException($"Input {image.ImageType} is not supported.");
}
return(new Point(resultPoint));
}
}
internal Row(IntPtr ptr, ImageTypes type, Array2DBase parent)
{
if (ptr == IntPtr.Zero)
{
throw new ArgumentException("Can not pass IntPtr.Zero", nameof(ptr));
}
this._Parent = parent ?? throw new ArgumentNullException(nameof(parent));
this.NativePtr = ptr;
this._Type = type;
}
public ImageWindow(Array2DBase image)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
image.ThrowIfDisposed(nameof(image));
this.NativePtr = NativeMethods.image_window_new_array2d1(image.ImageType.ToNativeArray2DType(), image.NativePtr);
}
public ImageWindow(Array2DBase image, string title)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
if (title == null)
{
throw new ArgumentNullException(nameof(title));
}
image.ThrowIfDisposed(nameof(image));
var str = Dlib.Encoding.GetBytes(title);
this.NativePtr = NativeMethods.image_window_new_array2d2(image.ImageType.ToNativeArray2DType(), image.NativePtr, str, str.Length);
}
public static void PyramidUp(Array2DBase image)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
image.ThrowIfDisposed(nameof(image));
var array2DType = image.ImageType.ToNativeArray2DType();
var ret = NativeMethods.pyramid_up(array2DType, image.NativePtr);
if (ret == NativeMethods.ErrorType.Array2DTypeTypeNotSupport)
{
throw new ArgumentException($"{image.ImageType} is not supported.");
}
}
public static void FlipImageLeftRight(Array2DBase image)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
image.ThrowIfDisposed(nameof(image));
var array2DType = image.ImageType.ToNativeArray2DType();
var ret = NativeMethods.flip_image_left_right(array2DType, image.NativePtr);
switch (ret)
{
case NativeMethods.ErrorType.Array2DTypeTypeNotSupport:
throw new ArgumentException($"{image.ImageType} is not supported.");
}
}
public static MatrixOp Heatmap(Array2DBase image, double maxValue, double minValue = 0)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
var array2DType = image.ImageType.ToNativeArray2DType();
var ret = Native.heatmap2(array2DType, image.NativePtr, maxValue, minValue, out var matrix);
if (ret == Native.ErrorType.ArrayTypeNotSupport)
{
throw new ArgumentException($"{image.ImageType} is not supported.");
}
return(new MatrixOp(Native.ElementType.OpHeatmap, image.ImageType, matrix));
}
public static MatrixOp Jet(Array2DBase image)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
var array2DType = image.ImageType.ToNativeArray2DType();
var ret = Native.jet(array2DType, image.NativePtr, out var matrix);
if (ret == Native.ErrorType.ArrayTypeNotSupport)
{
throw new ArgumentException($"{image.ImageType} is not supported.");
}
return(new MatrixOp(Native.ElementType.OpJet, image.ImageType, matrix));
}